Lines Matching +full:mm +full:- +full:0
1 // SPDX-License-Identifier: MIT
31 struct drm_buddy mm;
37 mm_size = (SZ_8M-1) & ~(ps-1); /* Multiple roots */
41 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),
55 for (i = 0; i < count; i++) {
65 drm_buddy_alloc_blocks(&mm, bias_start,
69 "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",
74 drm_buddy_alloc_blocks(&mm, bias_start,
78 "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",
83 drm_buddy_alloc_blocks(&mm, bias_start + ps,
87 "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",
92 drm_buddy_alloc_blocks(&mm, bias_start + ps,
93 bias_end - ps,
97 "buddy_alloc h didn't fail with bias(%x-%x), size=%u, ps=%u\n",
98 bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1);
102 drm_buddy_alloc_blocks(&mm, bias_start,
106 "buddy_alloc i failed with bias(%x-%x), size=%u, ps=%u\n",
108 drm_buddy_free_list(&mm, &tmp, 0);
112 drm_buddy_alloc_blocks(&mm, bias_start,
116 "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",
118 drm_buddy_free_list(&mm, &tmp, 0);
124 drm_buddy_alloc_blocks(&mm, bias_start,
128 "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",
131 bias_rem -= size;
134 drm_buddy_alloc_blocks(&mm, bias_start,
138 "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",
147 drm_buddy_alloc_blocks(&mm, bias_start,
151 "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",
158 drm_buddy_free_list(&mm, &tmp, 0);
165 drm_buddy_free_list(&mm, &allocated, 0);
166 drm_buddy_fini(&mm);
169 * Something more free-form. Idea is to pick a random starting bias
177 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),
180 bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps);
181 bias_end = round_up(bias_start + prandom_u32_state(&prng) % (mm_size - bias_start), ps);
183 bias_rem = bias_end - bias_start;
189 drm_buddy_alloc_blocks(&mm, bias_start,
193 "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",
195 bias_rem -= size;
206 bias_start -= round_up(prandom_u32_state(&prng) % bias_start, ps);
208 bias_end += round_up(prandom_u32_state(&prng) % (mm_size - bias_end), ps);
210 bias_rem += old_bias_start - bias_start;
211 bias_rem += bias_end - old_bias_end;
215 KUNIT_ASSERT_EQ(test, bias_start, 0);
218 drm_buddy_alloc_blocks(&mm, bias_start, bias_end,
222 "buddy_alloc passed with bias(%x-%x), size=%u\n",
225 drm_buddy_free_list(&mm, &allocated, 0);
226 drm_buddy_fini(&mm);
235 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),
238 bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps);
239 bias_end = round_up(bias_start + prandom_u32_state(&prng) % (mm_size - bias_start), ps);
241 bias_rem = bias_end - bias_start;
247 drm_buddy_alloc_blocks(&mm, bias_start,
251 "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",
257 drm_buddy_free_list(&mm, &allocated, 0);
258 drm_buddy_fini(&mm);
263 unsigned long n_pages, total, i = 0;
268 struct drm_buddy mm;
275 KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps));
277 KUNIT_EXPECT_EQ(test, mm.max_order, max_order);
281 * returning those pages as non-dirty and randomly alternate between
282 * requesting dirty and non-dirty pages (not going over the limit
283 * we freed as non-dirty), putting that into two separate lists.
288 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
292 drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED);
300 if (slot == 0) {
302 flags = 0;
308 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
320 drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED);
324 * The allocation should never fail with reasonable page-size.
326 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
331 drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED);
332 drm_buddy_free_list(&mm, &dirty, 0);
333 drm_buddy_fini(&mm);
335 KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps));
338 * Create a new mm. Intentionally fragment the address space by creating
346 i = 0;
352 if (slot == 0)
357 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
358 ps, ps, list, 0),
362 drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED);
363 drm_buddy_free_list(&mm, &dirty, 0);
369 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
373 total = 0;
377 total += drm_buddy_block_size(&mm, block);
381 drm_buddy_free_list(&mm, &allocated, 0);
384 drm_buddy_fini(&mm);
387 * Create a new mm with a non power-of-two size. Allocate a random size from each
388 * root, free as cleared and then call fini. This will ensure the multi-root
391 mm_size = (SZ_4K << max_order) + (SZ_4K << (max_order - 2));
393 KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps));
394 KUNIT_EXPECT_EQ(test, mm.max_order, max_order);
395 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order,
399 drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED);
400 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order,
404 drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED);
405 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, SZ_4K << max_order, mm_size,
409 drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED);
410 drm_buddy_fini(&mm);
418 struct drm_buddy mm;
424 KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps));
434 i = 0;
440 if (slot == 0)
447 drm_buddy_alloc_blocks(&mm, 0, mm_size,
448 ps, ps, list, 0),
453 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
458 drm_buddy_free_list(&mm, &middle, 0);
459 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
463 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
468 drm_buddy_free_list(&mm, &right, 0);
469 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
478 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
483 drm_buddy_free_list(&mm, &left, 0);
484 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
489 total = 0;
491 total += drm_buddy_block_size(&mm, block);
495 drm_buddy_free_list(&mm, &allocated, 0);
496 drm_buddy_fini(&mm);
501 u64 mm_size, size, start = 0;
504 unsigned long flags = 0;
506 struct drm_buddy mm;
512 * Create a pot-sized mm, then allocate one of each possible
513 * order within. This should leave the mm with exactly one
515 * Eventually we will have a fully 50% fragmented mm.
519 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K),
522 KUNIT_EXPECT_EQ(test, mm.max_order, max_order);
524 for (top = max_order; top; top--) {
528 list_del(&block->link);
529 drm_buddy_free_block(&mm, block);
532 for (order = top; order--;) {
533 size = get_size(order, mm.chunk_size);
534 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start,
537 "buddy_alloc hit -ENOMEM with order=%d, top=%d\n",
543 list_move_tail(&block->link, &blocks);
546 /* There should be one final page for this sub-allocation */
547 size = get_size(0, mm.chunk_size);
548 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
550 "buddy_alloc hit -ENOMEM for hole\n");
555 list_move_tail(&block->link, &holes);
557 size = get_size(top, mm.chunk_size);
558 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
560 "buddy_alloc unexpectedly succeeded at top-order %d/%d, it should be full!",
564 drm_buddy_free_list(&mm, &holes, 0);
568 size = get_size(order, mm.chunk_size);
569 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
576 drm_buddy_free_list(&mm, &blocks, 0);
577 drm_buddy_fini(&mm);
582 u64 mm_size, size, start = 0;
585 unsigned long flags = 0;
586 struct drm_buddy mm;
592 * Create a pot-sized mm, then allocate one of each possible
593 * order within. This should leave the mm with exactly one
598 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K),
601 KUNIT_EXPECT_EQ(test, mm.max_order, max_order);
603 for (order = 0; order < max_order; order++) {
604 size = get_size(order, mm.chunk_size);
605 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
607 "buddy_alloc hit -ENOMEM with order=%d\n",
613 list_move_tail(&block->link, &blocks);
617 size = get_size(0, mm.chunk_size);
618 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
620 "buddy_alloc hit -ENOMEM on final alloc\n");
625 list_move_tail(&block->link, &blocks);
628 for (order = max_order; order--;) {
629 size = get_size(order, mm.chunk_size);
630 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
636 list_del(&block->link);
637 drm_buddy_free_block(&mm, block);
642 list_del(&block->link);
643 drm_buddy_free_block(&mm, block);
645 size = get_size(order, mm.chunk_size);
646 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
648 "buddy_alloc hit -ENOMEM with order=%d\n",
654 list_del(&block->link);
655 drm_buddy_free_block(&mm, block);
659 /* To confirm, now the whole mm should be available */
660 size = get_size(max_order, mm.chunk_size);
661 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
663 "buddy_alloc (realloc) hit -ENOMEM with order=%d\n",
669 list_del(&block->link);
670 drm_buddy_free_block(&mm, block);
671 drm_buddy_free_list(&mm, &blocks, 0);
672 drm_buddy_fini(&mm);
677 u64 mm_size, size, start = 0;
679 unsigned long flags = 0;
681 struct drm_buddy mm;
687 * Create a mm with one block of each order available, and
691 mm_size = SZ_4K * ((1 << (max_order + 1)) - 1);
693 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K),
696 KUNIT_EXPECT_EQ(test, mm.max_order, max_order);
698 for (order = 0; order <= max_order; order++) {
699 size = get_size(order, mm.chunk_size);
700 KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
702 "buddy_alloc hit -ENOMEM with order=%d\n",
708 list_move_tail(&block->link, &blocks);
712 size = get_size(0, mm.chunk_size);
713 KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size,
717 drm_buddy_free_list(&mm, &blocks, 0);
718 drm_buddy_fini(&mm);
723 u64 size = U64_MAX, start = 0;
725 unsigned long flags = 0;
727 struct drm_buddy mm;
729 KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, size, SZ_4K));
731 KUNIT_EXPECT_EQ_MSG(test, mm.max_order, DRM_BUDDY_MAX_ORDER,
732 "mm.max_order(%d) != %d\n", mm.max_order,
735 size = mm.chunk_size << mm.max_order;
736 KUNIT_EXPECT_FALSE(test, drm_buddy_alloc_blocks(&mm, start, size, size,
737 mm.chunk_size, &allocated, flags));
742 KUNIT_EXPECT_EQ_MSG(test, drm_buddy_block_order(block), mm.max_order,
744 drm_buddy_block_order(block), mm.max_order);
746 KUNIT_EXPECT_EQ_MSG(test, drm_buddy_block_size(&mm, block),
747 BIT_ULL(mm.max_order) * mm.chunk_size,
749 drm_buddy_block_size(&mm, block),
750 BIT_ULL(mm.max_order) * mm.chunk_size);
752 drm_buddy_free_list(&mm, &allocated, 0);
753 drm_buddy_fini(&mm);
761 kunit_info(suite, "Testing DRM buddy manager, with random_seed=0x%x\n",
764 return 0;