test/lib/lmb.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2018 Simon Goldschmidt
   4  */
   5
   6 #include <common.h>
   7 #include <lmb.h>
   8 #include <dm/test.h>
   9 #include <test/ut.h>
  10
  11 static int check_lmb(struct unit_test_state *uts, struct lmb *lmb,
  12                      phys_addr_t ram_base, phys_size_t ram_size,
  13                      unsigned long num_reserved,
  14                      phys_addr_t base1, phys_size_t size1,
  15                      phys_addr_t base2, phys_size_t size2,
  16                      phys_addr_t base3, phys_size_t size3)
  17 {
  18         ut_asserteq(lmb->memory.cnt, 1);
  19         ut_asserteq(lmb->memory.region[0].base, ram_base);
  20         ut_asserteq(lmb->memory.region[0].size, ram_size);
  21
  22         ut_asserteq(lmb->reserved.cnt, num_reserved);
  23         if (num_reserved > 0) {
  24                 ut_asserteq(lmb->reserved.region[0].base, base1);
  25                 ut_asserteq(lmb->reserved.region[0].size, size1);
  26         }
  27         if (num_reserved > 1) {
  28                 ut_asserteq(lmb->reserved.region[1].base, base2);
  29                 ut_asserteq(lmb->reserved.region[1].size, size2);
  30         }
  31         if (num_reserved > 2) {
  32                 ut_asserteq(lmb->reserved.region[2].base, base3);
  33                 ut_asserteq(lmb->reserved.region[2].size, size3);
  34         }
  35         return 0;
  36 }
  37
  38 #define ASSERT_LMB(lmb, ram_base, ram_size, num_reserved, base1, size1, \
  39                    base2, size2, base3, size3) \
  40                    ut_assert(!check_lmb(uts, lmb, ram_base, ram_size, \
  41                              num_reserved, base1, size1, base2, size2, base3, \
  42                              size3))
  43
  44 /*
  45  * Test helper function that reserves 64 KiB somewhere in the simulated RAM and
  46  * then does some alloc + free tests.
  47  */
  48 static int test_multi_alloc(struct unit_test_state *uts,
  49                             const phys_addr_t ram, const phys_size_t ram_size,
  50                             const phys_addr_t alloc_64k_addr)
  51 {
  52         const phys_addr_t ram_end = ram + ram_size;
  53         const phys_addr_t alloc_64k_end = alloc_64k_addr + 0x10000;
  54
  55         struct lmb lmb;
  56         long ret;
  57         phys_addr_t a, a2, b, b2, c, d;
  58
  59         /* check for overflow */
  60         ut_assert(ram_end == 0 || ram_end > ram);
  61         ut_assert(alloc_64k_end > alloc_64k_addr);
  62         /* check input addresses + size */
  63         ut_assert(alloc_64k_addr >= ram + 8);
  64         ut_assert(alloc_64k_end <= ram_end - 8);
  65
  66         lmb_init(&lmb);
  67
  68         ret = lmb_add(&lmb, ram, ram_size);
  69         ut_asserteq(ret, 0);
  70
  71         /* reserve 64KiB somewhere */
  72         ret = lmb_reserve(&lmb, alloc_64k_addr, 0x10000);
  73         ut_asserteq(ret, 0);
  74         ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
  75                    0, 0, 0, 0);
  76
  77         /* allocate somewhere, should be at the end of RAM */
  78         a = lmb_alloc(&lmb, 4, 1);
  79         ut_asserteq(a, ram_end - 4);
  80         ASSERT_LMB(&lmb, ram, ram_size, 2, alloc_64k_addr, 0x10000,
  81                    ram_end - 4, 4, 0, 0);
  82         /* alloc below end of reserved region -> below reserved region */
  83         b = lmb_alloc_base(&lmb, 4, 1, alloc_64k_end);
  84         ut_asserteq(b, alloc_64k_addr - 4);
  85         ASSERT_LMB(&lmb, ram, ram_size, 2,
  86                    alloc_64k_addr - 4, 0x10000 + 4, ram_end - 4, 4, 0, 0);
  87
  88         /* 2nd time */
  89         c = lmb_alloc(&lmb, 4, 1);
  90         ut_asserteq(c, ram_end - 8);
  91         ASSERT_LMB(&lmb, ram, ram_size, 2,
  92                    alloc_64k_addr - 4, 0x10000 + 4, ram_end - 8, 8, 0, 0);
  93         d = lmb_alloc_base(&lmb, 4, 1, alloc_64k_end);
  94         ut_asserteq(d, alloc_64k_addr - 8);
  95         ASSERT_LMB(&lmb, ram, ram_size, 2,
  96                    alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 8, 0, 0);
  97
  98         ret = lmb_free(&lmb, a, 4);
  99         ut_asserteq(ret, 0);
 100         ASSERT_LMB(&lmb, ram, ram_size, 2,
 101                    alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
 102         /* allocate again to ensure we get the same address */
 103         a2 = lmb_alloc(&lmb, 4, 1);
 104         ut_asserteq(a, a2);
 105         ASSERT_LMB(&lmb, ram, ram_size, 2,
 106                    alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 8, 0, 0);
 107         ret = lmb_free(&lmb, a2, 4);
 108         ut_asserteq(ret, 0);
 109         ASSERT_LMB(&lmb, ram, ram_size, 2,
 110                    alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
 111
 112         ret = lmb_free(&lmb, b, 4);
 113         ut_asserteq(ret, 0);
 114         ASSERT_LMB(&lmb, ram, ram_size, 3,
 115                    alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000,
 116                    ram_end - 8, 4);
 117         /* allocate again to ensure we get the same address */
 118         b2 = lmb_alloc_base(&lmb, 4, 1, alloc_64k_end);
 119         ut_asserteq(b, b2);
 120         ASSERT_LMB(&lmb, ram, ram_size, 2,
 121                    alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
 122         ret = lmb_free(&lmb, b2, 4);
 123         ut_asserteq(ret, 0);
 124         ASSERT_LMB(&lmb, ram, ram_size, 3,
 125                    alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000,
 126                    ram_end - 8, 4);
 127
 128         ret = lmb_free(&lmb, c, 4);
 129         ut_asserteq(ret, 0);
 130         ASSERT_LMB(&lmb, ram, ram_size, 2,
 131                    alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000, 0, 0);
 132         ret = lmb_free(&lmb, d, 4);
 133         ut_asserteq(ret, 0);
 134         ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
 135                    0, 0, 0, 0);
 136
 137         return 0;
 138 }
 139
 140 static int test_multi_alloc_512mb(struct unit_test_state *uts,
 141                                   const phys_addr_t ram)
 142 {
 143         return test_multi_alloc(uts, ram, 0x20000000, ram + 0x10000000);
 144 }
 145
 146 /* Create a memory region with one reserved region and allocate */
 147 static int lib_test_lmb_simple(struct unit_test_state *uts)
 148 {
 149         int ret;
 150
 151         /* simulate 512 MiB RAM beginning at 1GiB */
 152         ret = test_multi_alloc_512mb(uts, 0x40000000);
 153         if (ret)
 154                 return ret;
 155
 156         /* simulate 512 MiB RAM beginning at 1.5GiB */
 157         return test_multi_alloc_512mb(uts, 0xE0000000);
 158 }
 159
 160 DM_TEST(lib_test_lmb_simple, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 161
 162 /* Simulate 512 MiB RAM, allocate some blocks that fit/don't fit */
 163 static int test_bigblock(struct unit_test_state *uts, const phys_addr_t ram)
 164 {
 165         const phys_size_t ram_size = 0x20000000;
 166         const phys_size_t big_block_size = 0x10000000;
 167         const phys_addr_t ram_end = ram + ram_size;
 168         const phys_addr_t alloc_64k_addr = ram + 0x10000000;
 169         struct lmb lmb;
 170         long ret;
 171         phys_addr_t a, b;
 172
 173         /* check for overflow */
 174         ut_assert(ram_end == 0 || ram_end > ram);
 175
 176         lmb_init(&lmb);
 177
 178         ret = lmb_add(&lmb, ram, ram_size);
 179         ut_asserteq(ret, 0);
 180
 181         /* reserve 64KiB in the middle of RAM */
 182         ret = lmb_reserve(&lmb, alloc_64k_addr, 0x10000);
 183         ut_asserteq(ret, 0);
 184         ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
 185                    0, 0, 0, 0);
 186
 187         /* allocate a big block, should be below reserved */
 188         a = lmb_alloc(&lmb, big_block_size, 1);
 189         ut_asserteq(a, ram);
 190         ASSERT_LMB(&lmb, ram, ram_size, 1, a,
 191                    big_block_size + 0x10000, 0, 0, 0, 0);
 192         /* allocate 2nd big block */
 193         /* This should fail, printing an error */
 194         b = lmb_alloc(&lmb, big_block_size, 1);
 195         ut_asserteq(b, 0);
 196         ASSERT_LMB(&lmb, ram, ram_size, 1, a,
 197                    big_block_size + 0x10000, 0, 0, 0, 0);
 198
 199         ret = lmb_free(&lmb, a, big_block_size);
 200         ut_asserteq(ret, 0);
 201         ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
 202                    0, 0, 0, 0);
 203
 204         /* allocate too big block */
 205         /* This should fail, printing an error */
 206         a = lmb_alloc(&lmb, ram_size, 1);
 207         ut_asserteq(a, 0);
 208         ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
 209                    0, 0, 0, 0);
 210
 211         return 0;
 212 }
 213
 214 static int lib_test_lmb_big(struct unit_test_state *uts)
 215 {
 216         int ret;
 217
 218         /* simulate 512 MiB RAM beginning at 1GiB */
 219         ret = test_bigblock(uts, 0x40000000);
 220         if (ret)
 221                 return ret;
 222
 223         /* simulate 512 MiB RAM beginning at 1.5GiB */
 224         return test_bigblock(uts, 0xE0000000);
 225 }
 226
 227 DM_TEST(lib_test_lmb_big, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 228
 229 /* Simulate 512 MiB RAM, allocate a block without previous reservation */
 230 static int test_noreserved(struct unit_test_state *uts, const phys_addr_t ram)
 231 {
 232         const phys_size_t ram_size = 0x20000000;
 233         const phys_addr_t ram_end = ram + ram_size;
 234         struct lmb lmb;
 235         long ret;
 236         phys_addr_t a, b;
 237
 238         /* check for overflow */
 239         ut_assert(ram_end == 0 || ram_end > ram);
 240
 241         lmb_init(&lmb);
 242
 243         ret = lmb_add(&lmb, ram, ram_size);
 244         ut_asserteq(ret, 0);
 245
 246         /* allocate a block */
 247         a = lmb_alloc(&lmb, 4, 1);
 248         ut_assert(a != 0);
 249         /* and free it */
 250         ret = lmb_free(&lmb, a, 4);
 251         ut_asserteq(ret, 0);
 252
 253         /* allocate a block with base*/
 254         b = lmb_alloc_base(&lmb, 4, 1, ram_end);
 255         ut_assert(a == b);
 256         /* and free it */
 257         ret = lmb_free(&lmb, b, 4);
 258         ut_asserteq(ret, 0);
 259
 260         return 0;
 261 }
 262
 263 static int lib_test_lmb_noreserved(struct unit_test_state *uts)
 264 {
 265         int ret;
 266
 267         /* simulate 512 MiB RAM beginning at 1GiB */
 268         ret = test_noreserved(uts, 0x40000000);
 269         if (ret)
 270                 return ret;
 271
 272         /* simulate 512 MiB RAM beginning at 1.5GiB */
 273         return test_noreserved(uts, 0xE0000000);
 274 }
 275
 276 DM_TEST(lib_test_lmb_noreserved, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 277
 278 /*
 279  * Simulate a RAM that starts at 0 and allocate down to address 0, which must
 280  * fail as '0' means failure for the lmb_alloc functions.
 281  */
 282 static int lib_test_lmb_at_0(struct unit_test_state *uts)
 283 {
 284         const phys_addr_t ram = 0;
 285         const phys_size_t ram_size = 0x20000000;
 286         struct lmb lmb;
 287         long ret;
 288         phys_addr_t a, b;
 289
 290         lmb_init(&lmb);
 291
 292         ret = lmb_add(&lmb, ram, ram_size);
 293         ut_asserteq(ret, 0);
 294
 295         /* allocate nearly everything */
 296         a = lmb_alloc(&lmb, ram_size - 4, 1);
 297         ut_asserteq(a, ram + 4);
 298         ASSERT_LMB(&lmb, ram, ram_size, 1, a, ram_size - 4,
 299                    0, 0, 0, 0);
 300         /* allocate the rest */
 301         /* This should fail as the allocated address would be 0 */
 302         b = lmb_alloc(&lmb, 4, 1);
 303         ut_asserteq(b, 0);
 304         /* check that this was an error by checking lmb */
 305         ASSERT_LMB(&lmb, ram, ram_size, 1, a, ram_size - 4,
 306                    0, 0, 0, 0);
 307         /* check that this was an error by freeing b */
 308         ret = lmb_free(&lmb, b, 4);
 309         ut_asserteq(ret, -1);
 310         ASSERT_LMB(&lmb, ram, ram_size, 1, a, ram_size - 4,
 311                    0, 0, 0, 0);
 312
 313         ret = lmb_free(&lmb, a, ram_size - 4);
 314         ut_asserteq(ret, 0);
 315         ASSERT_LMB(&lmb, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
 316
 317         return 0;
 318 }
 319
 320 DM_TEST(lib_test_lmb_at_0, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);