1 /* SPDX-License-Identifier: GPL-2.0-only */
2
3 #include <stdlib.h>
4 #include <types.h>
5 #include <string.h>
6 #include <tests/test.h>
7 #include <imd.h>
8 #include <imd_private.h>
9 #include <cbmem.h>
10 #include <commonlib/bsd/helpers.h>
11 #include <lib.h>
12
13 /* Auxiliary functions and definitions. */
14
15 #define LG_ROOT_SIZE \
16 align_up_pow2(sizeof(struct imd_root_pointer) + sizeof(struct imd_root) \
17 + 3 * sizeof(struct imd_entry))
18 #define LG_ENTRY_ALIGN (2 * sizeof(int32_t))
19 #define LG_ENTRY_SIZE (2 * sizeof(int32_t))
20 #define LG_ENTRY_ID 0xA001
21
22 #define SM_ROOT_SIZE LG_ROOT_SIZE
23 #define SM_ENTRY_ALIGN sizeof(uint32_t)
24 #define SM_ENTRY_SIZE sizeof(uint32_t)
25 #define SM_ENTRY_ID 0xB001
26
27 #define INVALID_REGION_ID 0xC001
28
align_up_pow2(uint32_t x)29 static uint32_t align_up_pow2(uint32_t x)
30 {
31 return (1 << log2_ceil(x));
32 }
33
max_entries(size_t root_size)34 static size_t max_entries(size_t root_size)
35 {
36 return (root_size - sizeof(struct imd_root_pointer) - sizeof(struct imd_root))
37 / sizeof(struct imd_entry);
38 }
39
40 /*
41 * Mainly, we should check that imd_handle_init() aligns upper_limit properly
42 * for various inputs. Upper limit is the _exclusive_ address, so we expect
43 * ALIGN_DOWN.
44 */
test_imd_handle_init(void ** state)45 static void test_imd_handle_init(void **state)
46 {
47 int i;
48 void *base;
49 struct imd imd;
50 uintptr_t test_inputs[] = {
51 0, /* Lowest possible address */
52 0xA000, /* Fits in 16 bits, should not get rounded down */
53 0xDEAA, /* Fits in 16 bits */
54 0xB0B0B000, /* Fits in 32 bits, should not get rounded down */
55 0xF0F0F0F0, /* Fits in 32 bits */
56 ((1ULL << 32) + 4), /* Just above 32-bit limit */
57 0x6666777788889000, /* Fits in 64 bits, should not get rounded down */
58 ((1ULL << 60) - 100) /* Very large address, fitting in 64 bits */
59 };
60
61 for (i = 0; i < ARRAY_SIZE(test_inputs); i++) {
62 base = (void *)test_inputs[i];
63
64 imd_handle_init(&imd, (void *)base);
65
66 assert_int_equal(imd.lg.limit % LIMIT_ALIGN, 0);
67 assert_int_equal(imd.lg.limit, ALIGN_DOWN(test_inputs[i], LIMIT_ALIGN));
68 assert_ptr_equal(imd.lg.r, NULL);
69
70 /* Small allocations not initialized */
71 assert_ptr_equal(imd.sm.limit, NULL);
72 assert_ptr_equal(imd.sm.r, NULL);
73 }
74 }
75
test_imd_handle_init_partial_recovery(void ** state)76 static void test_imd_handle_init_partial_recovery(void **state)
77 {
78 void *base;
79 struct imd imd = {0};
80 const struct imd_entry *entry;
81
82 imd_handle_init_partial_recovery(&imd);
83 assert_null(imd.lg.limit);
84 assert_null(imd.sm.limit);
85
86 base = malloc(LIMIT_ALIGN);
87 if (base == NULL)
88 fail_msg("Cannot allocate enough memory - fail test");
89
90 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
91 imd_handle_init_partial_recovery(&imd);
92
93 assert_non_null(imd.lg.r);
94 assert_null(imd.sm.limit);
95
96 assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
97 entry = imd_entry_add(&imd, SMALL_REGION_ID, LG_ENTRY_SIZE);
98 assert_non_null(entry);
99
100 imd_handle_init_partial_recovery(&imd);
101
102 assert_non_null(imd.lg.r);
103 assert_non_null(imd.sm.limit);
104 assert_ptr_equal(imd.lg.r + entry->start_offset + LG_ENTRY_SIZE, imd.sm.limit);
105 assert_non_null(imd.sm.r);
106
107 free(base);
108 }
109
test_imd_create_empty(void ** state)110 static void test_imd_create_empty(void **state)
111 {
112 struct imd imd = {0};
113 void *base;
114 struct imd_root *r;
115 struct imd_entry *e;
116
117 /* Expect imd_create_empty to fail, since imd handle is not initialized */
118 assert_int_equal(-1, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
119 base = malloc(sizeof(struct imd_root_pointer) + sizeof(struct imd_root));
120 if (base == NULL)
121 fail_msg("Cannot allocate enough memory - fail test");
122
123 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
124
125 /* Try incorrect sizes */
126 assert_int_equal(
127 -1, imd_create_empty(&imd, sizeof(struct imd_root_pointer), LG_ENTRY_ALIGN));
128 assert_int_equal(-1, imd_create_empty(&imd, LG_ROOT_SIZE, 2 * LG_ROOT_SIZE));
129
130 /* Working case */
131 assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
132
133 /* Only large allocation initialized with one entry for the root region */
134 r = (struct imd_root *)(imd.lg.r);
135 assert_non_null(r);
136
137 e = &r->entries[r->num_entries - 1];
138
139 assert_int_equal(max_entries(LG_ROOT_SIZE), r->max_entries);
140 assert_int_equal(1, r->num_entries);
141 assert_int_equal(0, r->flags);
142 assert_int_equal(LG_ENTRY_ALIGN, r->entry_align);
143 assert_int_equal(0, r->max_offset);
144 assert_ptr_equal(e, &r->entries);
145
146 assert_int_equal(IMD_ENTRY_MAGIC, e->magic);
147 assert_int_equal(0, e->start_offset);
148 assert_int_equal(LG_ROOT_SIZE, e->size);
149 assert_int_equal(CBMEM_ID_IMD_ROOT, e->id);
150
151 free(base);
152 }
153
test_imd_create_tiered_empty(void ** state)154 static void test_imd_create_tiered_empty(void **state)
155 {
156 void *base;
157 size_t sm_region_size, lg_region_wrong_size;
158 struct imd imd = {0};
159 struct imd_root *r;
160 struct imd_entry *fst_lg_entry, *snd_lg_entry, *sm_entry;
161
162 /* Uninitialized imd handle */
163 assert_int_equal(-1, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
164 LG_ROOT_SIZE, SM_ENTRY_ALIGN));
165
166 base = malloc(LIMIT_ALIGN);
167 if (base == NULL)
168 fail_msg("Cannot allocate enough memory - fail test");
169
170 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
171
172 /* Too small root_size for small region */
173 assert_int_equal(-1, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
174 sizeof(int32_t), 2 * sizeof(int32_t)));
175
176 /* Fail when large region doesn't have capacity for more than 1 entry */
177 lg_region_wrong_size = sizeof(struct imd_root_pointer) + sizeof(struct imd_root)
178 + sizeof(struct imd_entry);
179 expect_assert_failure(imd_create_tiered_empty(
180 &imd, lg_region_wrong_size, LG_ENTRY_ALIGN, SM_ROOT_SIZE, SM_ENTRY_ALIGN));
181
182 assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
183 SM_ROOT_SIZE, SM_ENTRY_ALIGN));
184
185 r = imd.lg.r;
186
187 /* One entry for root_region and one for small allocations */
188 assert_int_equal(2, r->num_entries);
189
190 fst_lg_entry = &r->entries[0];
191 assert_int_equal(IMD_ENTRY_MAGIC, fst_lg_entry->magic);
192 assert_int_equal(0, fst_lg_entry->start_offset);
193 assert_int_equal(LG_ROOT_SIZE, fst_lg_entry->size);
194 assert_int_equal(CBMEM_ID_IMD_ROOT, fst_lg_entry->id);
195
196 /* Calculated like in imd_create_tiered_empty */
197 sm_region_size = max_entries(SM_ROOT_SIZE) * SM_ENTRY_ALIGN;
198 sm_region_size += SM_ROOT_SIZE;
199 sm_region_size = ALIGN_UP(sm_region_size, LG_ENTRY_ALIGN);
200
201 snd_lg_entry = &r->entries[1];
202 assert_int_equal(IMD_ENTRY_MAGIC, snd_lg_entry->magic);
203 assert_int_equal(-sm_region_size, snd_lg_entry->start_offset);
204 assert_int_equal(CBMEM_ID_IMD_SMALL, snd_lg_entry->id);
205
206 assert_int_equal(sm_region_size, snd_lg_entry->size);
207
208 r = imd.sm.r;
209 assert_int_equal(1, r->num_entries);
210
211 sm_entry = &r->entries[0];
212 assert_int_equal(IMD_ENTRY_MAGIC, sm_entry->magic);
213 assert_int_equal(0, sm_entry->start_offset);
214 assert_int_equal(SM_ROOT_SIZE, sm_entry->size);
215 assert_int_equal(CBMEM_ID_IMD_ROOT, sm_entry->id);
216
217 free(base);
218 }
219
220 /* Tests for imdr_recover. */
test_imd_recover(void ** state)221 static void test_imd_recover(void **state)
222 {
223 int32_t offset_copy, max_offset_copy;
224 uint32_t rp_magic_copy, num_entries_copy;
225 uint32_t e_align_copy, e_magic_copy, e_id_copy;
226 uint32_t size_copy, diff;
227 void *base;
228 struct imd imd = {0};
229 struct imd_root_pointer *rp;
230 struct imd_root *r;
231 struct imd_entry *lg_root_entry, *sm_root_entry, *ptr;
232 const struct imd_entry *lg_entry;
233
234 /* Fail when the limit for lg was not set. */
235 imd.lg.limit = (uintptr_t)NULL;
236 assert_int_equal(-1, imd_recover(&imd));
237
238 /* Set the limit for lg. */
239 base = malloc(LIMIT_ALIGN);
240 if (base == NULL)
241 fail_msg("Cannot allocate enough memory - fail test");
242
243 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
244
245 /* Fail when the root pointer is not valid. */
246 rp = (void *)imd.lg.limit - sizeof(struct imd_root_pointer);
247 assert_non_null(rp);
248 assert_int_equal(IMD_ROOT_PTR_MAGIC, rp->magic);
249
250 rp_magic_copy = rp->magic;
251 rp->magic = 0;
252 assert_int_equal(-1, imd_recover(&imd));
253 rp->magic = rp_magic_copy;
254
255 /* Set the root pointer. */
256 assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
257 SM_ROOT_SIZE, SM_ENTRY_ALIGN));
258 assert_int_equal(2, ((struct imd_root *)imd.lg.r)->num_entries);
259 assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
260
261 /* Fail if the number of entries exceeds the maximum number of entries. */
262 r = imd.lg.r;
263 num_entries_copy = r->num_entries;
264 r->num_entries = r->max_entries + 1;
265 assert_int_equal(-1, imd_recover(&imd));
266 r->num_entries = num_entries_copy;
267
268 /* Fail if entry align is not a power of 2. */
269 e_align_copy = r->entry_align;
270 r->entry_align++;
271 assert_int_equal(-1, imd_recover(&imd));
272 r->entry_align = e_align_copy;
273
274 /* Fail when an entry is not valid. */
275 lg_root_entry = &r->entries[0];
276 e_magic_copy = lg_root_entry->magic;
277 lg_root_entry->magic = 0;
278 assert_int_equal(-1, imd_recover(&imd));
279 lg_root_entry->magic = e_magic_copy;
280
281 /* Add new entries: large and small. */
282 lg_entry = imd_entry_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE);
283 assert_non_null(lg_entry);
284 assert_int_equal(3, r->num_entries);
285
286 assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, SM_ENTRY_SIZE));
287 assert_int_equal(2, ((struct imd_root *)imd.sm.r)->num_entries);
288
289 /* Fail when start_addr is lower than low_limit. */
290 r = imd.lg.r;
291 max_offset_copy = r->max_offset;
292 r->max_offset = lg_entry->start_offset + sizeof(int32_t);
293 assert_int_equal(-1, imd_recover(&imd));
294 r->max_offset = max_offset_copy;
295
296 /* Fail when start_addr is at least imdr->limit. */
297 offset_copy = lg_entry->start_offset;
298 ptr = (struct imd_entry *)lg_entry;
299 ptr->start_offset = (void *)imd.lg.limit - (void *)r;
300 assert_int_equal(-1, imd_recover(&imd));
301 ptr->start_offset = offset_copy;
302
303 /* Fail when (start_addr + e->size) is higher than imdr->limit. */
304 size_copy = lg_entry->size;
305 diff = (void *)imd.lg.limit - ((void *)r + lg_entry->start_offset);
306 ptr->size = diff + 1;
307 assert_int_equal(-1, imd_recover(&imd));
308 ptr->size = size_copy;
309
310 /* Succeed if small region is not present. */
311 sm_root_entry = &r->entries[1];
312 e_id_copy = sm_root_entry->id;
313 sm_root_entry->id = 0;
314 assert_int_equal(0, imd_recover(&imd));
315 sm_root_entry->id = e_id_copy;
316
317 assert_int_equal(0, imd_recover(&imd));
318
319 free(base);
320 }
321
test_imd_limit_size(void ** state)322 static void test_imd_limit_size(void **state)
323 {
324 void *base;
325 struct imd imd = {0};
326 size_t root_size, max_size;
327
328 max_size = align_up_pow2(sizeof(struct imd_root_pointer) + sizeof(struct imd_root)
329 + 3 * sizeof(struct imd_entry));
330
331 assert_int_equal(-1, imd_limit_size(&imd, max_size));
332
333 base = malloc(LIMIT_ALIGN);
334 if (base == NULL)
335 fail_msg("Cannot allocate enough memory - fail test");
336 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
337
338 root_size = align_up_pow2(sizeof(struct imd_root_pointer) + sizeof(struct imd_root)
339 + 2 * sizeof(struct imd_entry));
340 imd.lg.r = (void *)imd.lg.limit - root_size;
341
342 imd_create_empty(&imd, root_size, LG_ENTRY_ALIGN);
343 assert_int_equal(-1, imd_limit_size(&imd, root_size - 1));
344 assert_int_equal(0, imd_limit_size(&imd, max_size));
345
346 /* Cannot create such a big entry */
347 assert_null(imd_entry_add(&imd, LG_ENTRY_ID, max_size - root_size + 1));
348
349 free(base);
350 }
351
test_imd_lockdown(void ** state)352 static void test_imd_lockdown(void **state)
353 {
354 struct imd imd = {0};
355 struct imd_root *r_lg, *r_sm;
356
357 assert_int_equal(-1, imd_lockdown(&imd));
358
359 imd.lg.r = malloc(sizeof(struct imd_root));
360 if (imd.lg.r == NULL)
361 fail_msg("Cannot allocate enough memory - fail test");
362
363 r_lg = (struct imd_root *)(imd.lg.r);
364
365 assert_int_equal(0, imd_lockdown(&imd));
366 assert_true(r_lg->flags & IMD_FLAG_LOCKED);
367
368 imd.sm.r = malloc(sizeof(struct imd_root));
369 if (imd.sm.r == NULL)
370 fail_msg("Cannot allocate enough memory - fail test");
371 r_sm = (struct imd_root *)(imd.sm.r);
372
373 assert_int_equal(0, imd_lockdown(&imd));
374 assert_true(r_sm->flags & IMD_FLAG_LOCKED);
375
376 free(imd.lg.r);
377 free(imd.sm.r);
378 }
379
test_imd_region_used(void ** state)380 static void test_imd_region_used(void **state)
381 {
382 struct imd imd = {0};
383 struct imd_entry *first_entry, *new_entry;
384 struct imd_root *r;
385 size_t size;
386 void *imd_base;
387 void *base;
388
389 assert_int_equal(-1, imd_region_used(&imd, &base, &size));
390
391 imd_base = malloc(LIMIT_ALIGN);
392 if (imd_base == NULL)
393 fail_msg("Cannot allocate enough memory - fail test");
394 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)imd_base));
395
396 assert_int_equal(-1, imd_region_used(&imd, &base, &size));
397 assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
398 assert_int_equal(0, imd_region_used(&imd, &base, &size));
399
400 r = (struct imd_root *)imd.lg.r;
401 first_entry = &r->entries[r->num_entries - 1];
402
403 assert_int_equal(r + first_entry->start_offset, (uintptr_t)base);
404 assert_int_equal(first_entry->size, size);
405
406 assert_non_null(imd_entry_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE));
407 assert_int_equal(2, r->num_entries);
408
409 assert_int_equal(0, imd_region_used(&imd, &base, &size));
410
411 new_entry = &r->entries[r->num_entries - 1];
412
413 assert_true((void *)r + new_entry->start_offset == base);
414 assert_int_equal(first_entry->size + new_entry->size, size);
415
416 free(imd_base);
417 }
418
test_imd_entry_add(void ** state)419 static void test_imd_entry_add(void **state)
420 {
421 int i;
422 struct imd imd = {0};
423 size_t entry_size = 0;
424 size_t used_size;
425 ssize_t entry_offset;
426 void *base;
427 struct imd_root *r, *sm_r, *lg_r;
428 struct imd_entry *first_entry, *new_entry;
429 uint32_t num_entries_copy;
430 int32_t max_offset_copy;
431
432 /* No small region case. */
433 assert_null(imd_entry_add(&imd, LG_ENTRY_ID, entry_size));
434
435 base = malloc(LIMIT_ALIGN);
436 if (base == NULL)
437 fail_msg("Cannot allocate enough memory - fail test");
438
439 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
440
441 assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
442
443 r = (struct imd_root *)imd.lg.r;
444 first_entry = &r->entries[r->num_entries - 1];
445
446 /* Cannot add an entry when root is locked. */
447 r->flags = IMD_FLAG_LOCKED;
448 assert_null(imd_entry_add(&imd, LG_ENTRY_ID, entry_size));
449 r->flags = 0;
450
451 /* Fail when the maximum number of entries has been reached. */
452 num_entries_copy = r->num_entries;
453 r->num_entries = r->max_entries;
454 assert_null(imd_entry_add(&imd, LG_ENTRY_ID, entry_size));
455 r->num_entries = num_entries_copy;
456
457 /* Fail when entry size is 0 */
458 assert_null(imd_entry_add(&imd, LG_ENTRY_ID, 0));
459
460 /* Fail when entry size (after alignment) overflows imd total size. */
461 entry_size = 2049;
462 max_offset_copy = r->max_offset;
463 r->max_offset = -entry_size;
464 assert_null(imd_entry_add(&imd, LG_ENTRY_ID, entry_size));
465 r->max_offset = max_offset_copy;
466
467 /* Finally succeed. */
468 entry_size = 2 * sizeof(int32_t);
469 assert_non_null(imd_entry_add(&imd, LG_ENTRY_ID, entry_size));
470 assert_int_equal(2, r->num_entries);
471
472 new_entry = &r->entries[r->num_entries - 1];
473 assert_int_equal(sizeof(struct imd_entry), (void *)new_entry - (void *)first_entry);
474
475 assert_int_equal(IMD_ENTRY_MAGIC, new_entry->magic);
476 assert_int_equal(LG_ENTRY_ID, new_entry->id);
477 assert_int_equal(entry_size, new_entry->size);
478
479 used_size = ALIGN_UP(entry_size, r->entry_align);
480 entry_offset = first_entry->start_offset - used_size;
481 assert_int_equal(entry_offset, new_entry->start_offset);
482
483 /* Use small region case. */
484 imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN, SM_ROOT_SIZE,
485 SM_ENTRY_ALIGN);
486
487 lg_r = imd.lg.r;
488 sm_r = imd.sm.r;
489
490 /* All five new entries should be added to small allocations */
491 for (i = 0; i < 5; i++) {
492 assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, SM_ENTRY_SIZE));
493 assert_int_equal(i + 2, sm_r->num_entries);
494 assert_int_equal(2, lg_r->num_entries);
495 }
496
497 /* But next should fall back on large region */
498 assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, SM_ENTRY_SIZE));
499 assert_int_equal(6, sm_r->num_entries);
500 assert_int_equal(3, lg_r->num_entries);
501
502 /*
503 * Small allocation is created when occupies less than 1/4 of available
504 * small region. Verify this.
505 */
506 imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN, SM_ROOT_SIZE,
507 SM_ENTRY_ALIGN);
508
509 assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, -sm_r->max_offset / 4 + 1));
510 assert_int_equal(1, sm_r->num_entries);
511 assert_int_equal(3, lg_r->num_entries);
512
513 /* Next two should go into small region */
514 assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, -sm_r->max_offset / 4));
515 assert_int_equal(2, sm_r->num_entries);
516 assert_int_equal(3, lg_r->num_entries);
517
518 /* (1/4 * 3/4) */
519 assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, -sm_r->max_offset / 16 * 3));
520 assert_int_equal(3, sm_r->num_entries);
521 assert_int_equal(3, lg_r->num_entries);
522
523 free(base);
524 }
525
test_imd_entry_find(void ** state)526 static void test_imd_entry_find(void **state)
527 {
528 struct imd imd = {0};
529 void *base;
530
531 base = malloc(LIMIT_ALIGN);
532 if (base == NULL)
533 fail_msg("Cannot allocate enough memory - fail test");
534 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
535
536 assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
537 SM_ROOT_SIZE, SM_ENTRY_ALIGN));
538
539 assert_non_null(imd_entry_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE));
540
541 assert_non_null(imd_entry_find(&imd, LG_ENTRY_ID));
542 assert_non_null(imd_entry_find(&imd, SMALL_REGION_ID));
543
544 /* Try invalid id, should fail */
545 assert_null(imd_entry_find(&imd, INVALID_REGION_ID));
546
547 free(base);
548 }
549
test_imd_entry_find_or_add(void ** state)550 static void test_imd_entry_find_or_add(void **state)
551 {
552 struct imd imd = {0};
553 const struct imd_entry *entry;
554 struct imd_root *r;
555 void *base;
556
557 base = malloc(LIMIT_ALIGN);
558 if (base == NULL)
559 fail_msg("Cannot allocate enough memory - fail test");
560 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
561
562 assert_null(imd_entry_find_or_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE));
563
564 assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
565 entry = imd_entry_find_or_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE);
566 assert_non_null(entry);
567
568 r = (struct imd_root *)imd.lg.r;
569
570 assert_int_equal(entry->id, LG_ENTRY_ID);
571 assert_int_equal(2, r->num_entries);
572 assert_non_null(imd_entry_find_or_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE));
573 assert_int_equal(2, r->num_entries);
574
575 free(base);
576 }
577
test_imd_entry_size(void ** state)578 static void test_imd_entry_size(void **state)
579 {
580 struct imd_entry entry = {.size = LG_ENTRY_SIZE};
581
582 assert_int_equal(LG_ENTRY_SIZE, imd_entry_size(&entry));
583
584 entry.size = 0;
585 assert_int_equal(0, imd_entry_size(&entry));
586 }
587
test_imd_entry_at(void ** state)588 static void test_imd_entry_at(void **state)
589 {
590 struct imd imd = {0};
591 struct imd_root *r;
592 struct imd_entry *e = NULL;
593 const struct imd_entry *entry;
594 void *base;
595
596 base = malloc(LIMIT_ALIGN);
597 if (base == NULL)
598 fail_msg("Cannot allocate enough memory - fail test");
599 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
600
601 assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
602
603 /* Fail when entry is NULL */
604 assert_null(imd_entry_at(&imd, e));
605
606 entry = imd_entry_add(&imd, LG_ENTRY_ID, LG_ENTRY_SIZE);
607 assert_non_null(entry);
608
609 r = (struct imd_root *)imd.lg.r;
610 assert_ptr_equal((void *)r + entry->start_offset, imd_entry_at(&imd, entry));
611
612 free(base);
613 }
614
test_imd_entry_id(void ** state)615 static void test_imd_entry_id(void **state)
616 {
617 struct imd_entry entry = {.id = LG_ENTRY_ID};
618
619 assert_int_equal(LG_ENTRY_ID, imd_entry_id(&entry));
620 }
621
test_imd_entry_remove(void ** state)622 static void test_imd_entry_remove(void **state)
623 {
624 void *base;
625 struct imd imd = {0};
626 struct imd_root *r;
627 const struct imd_entry *fst_lg_entry, *snd_lg_entry, *fst_sm_entry;
628 const struct imd_entry *e = NULL;
629
630 /* Uninitialized handle */
631 assert_int_equal(-1, imd_entry_remove(&imd, e));
632
633 base = malloc(LIMIT_ALIGN);
634 if (base == NULL)
635 fail_msg("Cannot allocate enough memory - fail test");
636
637 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
638
639 assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
640 SM_ROOT_SIZE, SM_ENTRY_ALIGN));
641
642 r = imd.lg.r;
643 assert_int_equal(2, r->num_entries);
644 fst_lg_entry = &r->entries[0];
645 snd_lg_entry = &r->entries[1];
646
647 /* Only last entry can be removed */
648 assert_int_equal(-1, imd_entry_remove(&imd, fst_lg_entry));
649 r->flags = IMD_FLAG_LOCKED;
650 assert_int_equal(-1, imd_entry_remove(&imd, snd_lg_entry));
651 r->flags = 0;
652
653 r = imd.sm.r;
654 assert_int_equal(1, r->num_entries);
655 fst_sm_entry = &r->entries[0];
656
657 /* Fail trying to remove root entry */
658 assert_int_equal(-1, imd_entry_remove(&imd, fst_sm_entry));
659 assert_int_equal(1, r->num_entries);
660
661 r = imd.lg.r;
662 assert_int_equal(0, imd_entry_remove(&imd, snd_lg_entry));
663 assert_int_equal(1, r->num_entries);
664
665 /* Fail trying to remove root entry */
666 assert_int_equal(-1, imd_entry_remove(&imd, fst_lg_entry));
667 assert_int_equal(1, r->num_entries);
668
669 free(base);
670 }
671
test_imd_cursor_init(void ** state)672 static void test_imd_cursor_init(void **state)
673 {
674 struct imd imd = {0};
675 struct imd_cursor cursor;
676
677 assert_int_equal(-1, imd_cursor_init(NULL, NULL));
678 assert_int_equal(-1, imd_cursor_init(NULL, &cursor));
679 assert_int_equal(-1, imd_cursor_init(&imd, NULL));
680 assert_int_equal(0, imd_cursor_init(&imd, &cursor));
681
682 assert_ptr_equal(cursor.imdr[0], &imd.lg);
683 assert_ptr_equal(cursor.imdr[1], &imd.sm);
684 }
685
test_imd_cursor_next(void ** state)686 static void test_imd_cursor_next(void **state)
687 {
688 void *base;
689 struct imd imd = {0};
690 struct imd_cursor cursor;
691 struct imd_root *r;
692 const struct imd_entry *entry;
693 struct imd_entry *fst_lg_entry, *snd_lg_entry, *fst_sm_entry;
694 assert_int_equal(0, imd_cursor_init(&imd, &cursor));
695
696 cursor.current_imdr = 3;
697 cursor.current_entry = 0;
698 assert_null(imd_cursor_next(&cursor));
699
700 cursor.current_imdr = 0;
701 assert_null(imd_cursor_next(&cursor));
702
703 base = malloc(LIMIT_ALIGN);
704 if (base == NULL)
705 fail_msg("Cannot allocate enough memory - fail test");
706 imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
707
708 assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
709 SM_ROOT_SIZE, SM_ENTRY_ALIGN));
710
711 r = imd.lg.r;
712 entry = imd_cursor_next(&cursor);
713 assert_non_null(entry);
714
715 fst_lg_entry = &r->entries[0];
716 assert_int_equal(fst_lg_entry->id, entry->id);
717 assert_ptr_equal(fst_lg_entry, entry);
718
719 entry = imd_cursor_next(&cursor);
720 assert_non_null(entry);
721
722 snd_lg_entry = &r->entries[1];
723 assert_int_equal(snd_lg_entry->id, entry->id);
724 assert_ptr_equal(snd_lg_entry, entry);
725
726 entry = imd_cursor_next(&cursor);
727 assert_non_null(entry);
728
729 r = imd.sm.r;
730 fst_sm_entry = &r->entries[0];
731 assert_int_equal(fst_sm_entry->id, entry->id);
732 assert_ptr_equal(fst_sm_entry, entry);
733
734 entry = imd_cursor_next(&cursor);
735 assert_null(entry);
736 }
737
main(void)738 int main(void)
739 {
740 const struct CMUnitTest tests[] = {
741 cmocka_unit_test(test_imd_handle_init),
742 cmocka_unit_test(test_imd_handle_init_partial_recovery),
743 cmocka_unit_test(test_imd_create_empty),
744 cmocka_unit_test(test_imd_create_tiered_empty),
745 cmocka_unit_test(test_imd_recover),
746 cmocka_unit_test(test_imd_limit_size),
747 cmocka_unit_test(test_imd_lockdown),
748 cmocka_unit_test(test_imd_region_used),
749 cmocka_unit_test(test_imd_entry_add),
750 cmocka_unit_test(test_imd_entry_find),
751 cmocka_unit_test(test_imd_entry_find_or_add),
752 cmocka_unit_test(test_imd_entry_size),
753 cmocka_unit_test(test_imd_entry_at),
754 cmocka_unit_test(test_imd_entry_id),
755 cmocka_unit_test(test_imd_entry_remove),
756 cmocka_unit_test(test_imd_cursor_init),
757 cmocka_unit_test(test_imd_cursor_next),
758 };
759
760 return cb_run_group_tests(tests, NULL, NULL);
761 }
762