1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Test cases for the drm_mm range manager
4  *
5  * Copyright (c) 2022 Arthur Grillo <arthur.grillo@usp.br>
6  */
7 
8 #include <kunit/test.h>
9 
10 #include <linux/prime_numbers.h>
11 #include <linux/slab.h>
12 #include <linux/random.h>
13 #include <linux/vmalloc.h>
14 #include <linux/ktime.h>
15 
16 #include <drm/drm_mm.h>
17 
18 #include "../lib/drm_random.h"
19 
20 static unsigned int random_seed;
21 static unsigned int max_iterations = 8192;
22 static unsigned int max_prime = 128;
23 
24 enum {
25 	BEST,
26 	BOTTOMUP,
27 	TOPDOWN,
28 	EVICT,
29 };
30 
31 static const struct insert_mode {
32 	const char *name;
33 	enum drm_mm_insert_mode mode;
34 } insert_modes[] = {
35 	[BEST] = { "best", DRM_MM_INSERT_BEST },
36 	[BOTTOMUP] = { "bottom-up", DRM_MM_INSERT_LOW },
37 	[TOPDOWN] = { "top-down", DRM_MM_INSERT_HIGH },
38 	[EVICT] = { "evict", DRM_MM_INSERT_EVICT },
39 	{}
40 }, evict_modes[] = {
41 	{ "bottom-up", DRM_MM_INSERT_LOW },
42 	{ "top-down", DRM_MM_INSERT_HIGH },
43 	{}
44 };
45 
46 static bool assert_no_holes(struct kunit *test, const struct drm_mm *mm)
47 {
48 	struct drm_mm_node *hole;
49 	u64 hole_start, __always_unused hole_end;
50 	unsigned long count;
51 
52 	count = 0;
53 	drm_mm_for_each_hole(hole, mm, hole_start, hole_end)
54 		count++;
55 	if (count) {
56 		KUNIT_FAIL(test,
57 			   "Expected to find no holes (after reserve), found %lu instead\n", count);
58 		return false;
59 	}
60 
61 	drm_mm_for_each_node(hole, mm) {
62 		if (drm_mm_hole_follows(hole)) {
63 			KUNIT_FAIL(test, "Hole follows node, expected none!\n");
64 			return false;
65 		}
66 	}
67 
68 	return true;
69 }
70 
71 static bool assert_one_hole(struct kunit *test, const struct drm_mm *mm, u64 start, u64 end)
72 {
73 	struct drm_mm_node *hole;
74 	u64 hole_start, hole_end;
75 	unsigned long count;
76 	bool ok = true;
77 
78 	if (end <= start)
79 		return true;
80 
81 	count = 0;
82 	drm_mm_for_each_hole(hole, mm, hole_start, hole_end) {
83 		if (start != hole_start || end != hole_end) {
84 			if (ok)
85 				KUNIT_FAIL(test,
86 					   "empty mm has incorrect hole, found (%llx, %llx), expect (%llx, %llx)\n",
87 					   hole_start, hole_end, start, end);
88 			ok = false;
89 		}
90 		count++;
91 	}
92 	if (count != 1) {
93 		KUNIT_FAIL(test, "Expected to find one hole, found %lu instead\n", count);
94 		ok = false;
95 	}
96 
97 	return ok;
98 }
99 
100 static bool assert_continuous(struct kunit *test, const struct drm_mm *mm, u64 size)
101 {
102 	struct drm_mm_node *node, *check, *found;
103 	unsigned long n;
104 	u64 addr;
105 
106 	if (!assert_no_holes(test, mm))
107 		return false;
108 
109 	n = 0;
110 	addr = 0;
111 	drm_mm_for_each_node(node, mm) {
112 		if (node->start != addr) {
113 			KUNIT_FAIL(test, "node[%ld] list out of order, expected %llx found %llx\n",
114 				   n, addr, node->start);
115 			return false;
116 		}
117 
118 		if (node->size != size) {
119 			KUNIT_FAIL(test, "node[%ld].size incorrect, expected %llx, found %llx\n",
120 				   n, size, node->size);
121 			return false;
122 		}
123 
124 		if (drm_mm_hole_follows(node)) {
125 			KUNIT_FAIL(test, "node[%ld] is followed by a hole!\n", n);
126 			return false;
127 		}
128 
129 		found = NULL;
130 		drm_mm_for_each_node_in_range(check, mm, addr, addr + size) {
131 			if (node != check) {
132 				KUNIT_FAIL(test,
133 					   "lookup return wrong node, expected start %llx, found %llx\n",
134 					   node->start, check->start);
135 				return false;
136 			}
137 			found = check;
138 		}
139 		if (!found) {
140 			KUNIT_FAIL(test, "lookup failed for node %llx + %llx\n", addr, size);
141 			return false;
142 		}
143 
144 		addr += size;
145 		n++;
146 	}
147 
148 	return true;
149 }
150 
151 static u64 misalignment(struct drm_mm_node *node, u64 alignment)
152 {
153 	u64 rem;
154 
155 	if (!alignment)
156 		return 0;
157 
158 	div64_u64_rem(node->start, alignment, &rem);
159 	return rem;
160 }
161 
162 static bool assert_node(struct kunit *test, struct drm_mm_node *node, struct drm_mm *mm,
163 			u64 size, u64 alignment, unsigned long color)
164 {
165 	bool ok = true;
166 
167 	if (!drm_mm_node_allocated(node) || node->mm != mm) {
168 		KUNIT_FAIL(test, "node not allocated\n");
169 		ok = false;
170 	}
171 
172 	if (node->size != size) {
173 		KUNIT_FAIL(test, "node has wrong size, found %llu, expected %llu\n",
174 			   node->size, size);
175 		ok = false;
176 	}
177 
178 	if (misalignment(node, alignment)) {
179 		KUNIT_FAIL(test,
180 			   "node is misaligned, start %llx rem %llu, expected alignment %llu\n",
181 			   node->start, misalignment(node, alignment), alignment);
182 		ok = false;
183 	}
184 
185 	if (node->color != color) {
186 		KUNIT_FAIL(test, "node has wrong color, found %lu, expected %lu\n",
187 			   node->color, color);
188 		ok = false;
189 	}
190 
191 	return ok;
192 }
193 
194 static void drm_test_mm_init(struct kunit *test)
195 {
196 	const unsigned int size = 4096;
197 	struct drm_mm mm;
198 	struct drm_mm_node tmp;
199 
200 	/* Start with some simple checks on initialising the struct drm_mm */
201 	memset(&mm, 0, sizeof(mm));
202 	KUNIT_ASSERT_FALSE_MSG(test, drm_mm_initialized(&mm),
203 			       "zeroed mm claims to be initialized\n");
204 
205 	memset(&mm, 0xff, sizeof(mm));
206 	drm_mm_init(&mm, 0, size);
207 	if (!drm_mm_initialized(&mm)) {
208 		KUNIT_FAIL(test, "mm claims not to be initialized\n");
209 		goto out;
210 	}
211 
212 	if (!drm_mm_clean(&mm)) {
213 		KUNIT_FAIL(test, "mm not empty on creation\n");
214 		goto out;
215 	}
216 
217 	/* After creation, it should all be one massive hole */
218 	if (!assert_one_hole(test, &mm, 0, size)) {
219 		KUNIT_FAIL(test, "");
220 		goto out;
221 	}
222 
223 	memset(&tmp, 0, sizeof(tmp));
224 	tmp.start = 0;
225 	tmp.size = size;
226 	if (drm_mm_reserve_node(&mm, &tmp)) {
227 		KUNIT_FAIL(test, "failed to reserve whole drm_mm\n");
228 		goto out;
229 	}
230 
231 	/* After filling the range entirely, there should be no holes */
232 	if (!assert_no_holes(test, &mm)) {
233 		KUNIT_FAIL(test, "");
234 		goto out;
235 	}
236 
237 	/* And then after emptying it again, the massive hole should be back */
238 	drm_mm_remove_node(&tmp);
239 	if (!assert_one_hole(test, &mm, 0, size)) {
240 		KUNIT_FAIL(test, "");
241 		goto out;
242 	}
243 
244 out:
245 	drm_mm_takedown(&mm);
246 }
247 
248 static void drm_test_mm_debug(struct kunit *test)
249 {
250 	struct drm_mm mm;
251 	struct drm_mm_node nodes[2];
252 
253 	/* Create a small drm_mm with a couple of nodes and a few holes, and
254 	 * check that the debug iterator doesn't explode over a trivial drm_mm.
255 	 */
256 
257 	drm_mm_init(&mm, 0, 4096);
258 
259 	memset(nodes, 0, sizeof(nodes));
260 	nodes[0].start = 512;
261 	nodes[0].size = 1024;
262 	KUNIT_ASSERT_FALSE_MSG(test, drm_mm_reserve_node(&mm, &nodes[0]),
263 			       "failed to reserve node[0] {start=%lld, size=%lld)\n",
264 			       nodes[0].start, nodes[0].size);
265 
266 	nodes[1].size = 1024;
267 	nodes[1].start = 4096 - 512 - nodes[1].size;
268 	KUNIT_ASSERT_FALSE_MSG(test, drm_mm_reserve_node(&mm, &nodes[1]),
269 			       "failed to reserve node[0] {start=%lld, size=%lld)\n",
270 			       nodes[0].start, nodes[0].size);
271 }
272 
273 static struct drm_mm_node *set_node(struct drm_mm_node *node,
274 				    u64 start, u64 size)
275 {
276 	node->start = start;
277 	node->size = size;
278 	return node;
279 }
280 
281 static bool expect_reserve_fail(struct kunit *test, struct drm_mm *mm, struct drm_mm_node *node)
282 {
283 	int err;
284 
285 	err = drm_mm_reserve_node(mm, node);
286 	if (likely(err == -ENOSPC))
287 		return true;
288 
289 	if (!err) {
290 		KUNIT_FAIL(test, "impossible reserve succeeded, node %llu + %llu\n",
291 			   node->start, node->size);
292 		drm_mm_remove_node(node);
293 	} else {
294 		KUNIT_FAIL(test,
295 			   "impossible reserve failed with wrong error %d [expected %d], node %llu + %llu\n",
296 		       err, -ENOSPC, node->start, node->size);
297 	}
298 	return false;
299 }
300 
301 static bool check_reserve_boundaries(struct kunit *test, struct drm_mm *mm,
302 				     unsigned int count,
303 				     u64 size)
304 {
305 	const struct boundary {
306 		u64 start, size;
307 		const char *name;
308 	} boundaries[] = {
309 #define B(st, sz) { (st), (sz), "{ " #st ", " #sz "}" }
310 		B(0, 0),
311 		B(-size, 0),
312 		B(size, 0),
313 		B(size * count, 0),
314 		B(-size, size),
315 		B(-size, -size),
316 		B(-size, 2 * size),
317 		B(0, -size),
318 		B(size, -size),
319 		B(count * size, size),
320 		B(count * size, -size),
321 		B(count * size, count * size),
322 		B(count * size, -count * size),
323 		B(count * size, -(count + 1) * size),
324 		B((count + 1) * size, size),
325 		B((count + 1) * size, -size),
326 		B((count + 1) * size, -2 * size),
327 #undef B
328 	};
329 	struct drm_mm_node tmp = {};
330 	int n;
331 
332 	for (n = 0; n < ARRAY_SIZE(boundaries); n++) {
333 		if (!expect_reserve_fail(test, mm, set_node(&tmp, boundaries[n].start,
334 							    boundaries[n].size))) {
335 			KUNIT_FAIL(test, "boundary[%d:%s] failed, count=%u, size=%lld\n",
336 				   n, boundaries[n].name, count, size);
337 			return false;
338 		}
339 	}
340 
341 	return true;
342 }
343 
344 static int __drm_test_mm_reserve(struct kunit *test, unsigned int count, u64 size)
345 {
346 	DRM_RND_STATE(prng, random_seed);
347 	struct drm_mm mm;
348 	struct drm_mm_node tmp, *nodes, *node, *next;
349 	unsigned int *order, n, m, o = 0;
350 	int ret, err;
351 
352 	/* For exercising drm_mm_reserve_node(), we want to check that
353 	 * reservations outside of the drm_mm range are rejected, and to
354 	 * overlapping and otherwise already occupied ranges. Afterwards,
355 	 * the tree and nodes should be intact.
356 	 */
357 
358 	DRM_MM_BUG_ON(!count);
359 	DRM_MM_BUG_ON(!size);
360 
361 	ret = -ENOMEM;
362 	order = drm_random_order(count, &prng);
363 	if (!order)
364 		goto err;
365 
366 	nodes = vzalloc(array_size(count, sizeof(*nodes)));
367 	KUNIT_ASSERT_TRUE(test, nodes);
368 
369 	ret = -EINVAL;
370 	drm_mm_init(&mm, 0, count * size);
371 
372 	if (!check_reserve_boundaries(test, &mm, count, size))
373 		goto out;
374 
375 	for (n = 0; n < count; n++) {
376 		nodes[n].start = order[n] * size;
377 		nodes[n].size = size;
378 
379 		err = drm_mm_reserve_node(&mm, &nodes[n]);
380 		if (err) {
381 			KUNIT_FAIL(test, "reserve failed, step %d, start %llu\n",
382 				   n, nodes[n].start);
383 			ret = err;
384 			goto out;
385 		}
386 
387 		if (!drm_mm_node_allocated(&nodes[n])) {
388 			KUNIT_FAIL(test, "reserved node not allocated! step %d, start %llu\n",
389 				   n, nodes[n].start);
390 			goto out;
391 		}
392 
393 		if (!expect_reserve_fail(test, &mm, &nodes[n]))
394 			goto out;
395 	}
396 
397 	/* After random insertion the nodes should be in order */
398 	if (!assert_continuous(test, &mm, size))
399 		goto out;
400 
401 	/* Repeated use should then fail */
402 	drm_random_reorder(order, count, &prng);
403 	for (n = 0; n < count; n++) {
404 		if (!expect_reserve_fail(test, &mm, set_node(&tmp, order[n] * size, 1)))
405 			goto out;
406 
407 		/* Remove and reinsert should work */
408 		drm_mm_remove_node(&nodes[order[n]]);
409 		err = drm_mm_reserve_node(&mm, &nodes[order[n]]);
410 		if (err) {
411 			KUNIT_FAIL(test, "reserve failed, step %d, start %llu\n",
412 				   n, nodes[n].start);
413 			ret = err;
414 			goto out;
415 		}
416 	}
417 
418 	if (!assert_continuous(test, &mm, size))
419 		goto out;
420 
421 	/* Overlapping use should then fail */
422 	for (n = 0; n < count; n++) {
423 		if (!expect_reserve_fail(test, &mm, set_node(&tmp, 0, size * count)))
424 			goto out;
425 	}
426 	for (n = 0; n < count; n++) {
427 		if (!expect_reserve_fail(test, &mm, set_node(&tmp, size * n, size * (count - n))))
428 			goto out;
429 	}
430 
431 	/* Remove several, reinsert, check full */
432 	for_each_prime_number(n, min(max_prime, count)) {
433 		for (m = 0; m < n; m++) {
434 			node = &nodes[order[(o + m) % count]];
435 			drm_mm_remove_node(node);
436 		}
437 
438 		for (m = 0; m < n; m++) {
439 			node = &nodes[order[(o + m) % count]];
440 			err = drm_mm_reserve_node(&mm, node);
441 			if (err) {
442 				KUNIT_FAIL(test, "reserve failed, step %d/%d, start %llu\n",
443 					   m, n, node->start);
444 				ret = err;
445 				goto out;
446 			}
447 		}
448 
449 		o += n;
450 
451 		if (!assert_continuous(test, &mm, size))
452 			goto out;
453 	}
454 
455 	ret = 0;
456 out:
457 	drm_mm_for_each_node_safe(node, next, &mm)
458 		drm_mm_remove_node(node);
459 	drm_mm_takedown(&mm);
460 	vfree(nodes);
461 	kfree(order);
462 err:
463 	return ret;
464 }
465 
466 static void drm_test_mm_reserve(struct kunit *test)
467 {
468 	const unsigned int count = min_t(unsigned int, BIT(10), max_iterations);
469 	int n;
470 
471 	for_each_prime_number_from(n, 1, 54) {
472 		u64 size = BIT_ULL(n);
473 
474 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_reserve(test, count, size - 1));
475 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_reserve(test, count, size));
476 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_reserve(test, count, size + 1));
477 
478 		cond_resched();
479 	}
480 }
481 
482 static bool expect_insert(struct kunit *test, struct drm_mm *mm,
483 			  struct drm_mm_node *node, u64 size, u64 alignment, unsigned long color,
484 			const struct insert_mode *mode)
485 {
486 	int err;
487 
488 	err = drm_mm_insert_node_generic(mm, node,
489 					 size, alignment, color,
490 					 mode->mode);
491 	if (err) {
492 		KUNIT_FAIL(test,
493 			   "insert (size=%llu, alignment=%llu, color=%lu, mode=%s) failed with err=%d\n",
494 			   size, alignment, color, mode->name, err);
495 		return false;
496 	}
497 
498 	if (!assert_node(test, node, mm, size, alignment, color)) {
499 		drm_mm_remove_node(node);
500 		return false;
501 	}
502 
503 	return true;
504 }
505 
506 static bool expect_insert_fail(struct kunit *test, struct drm_mm *mm, u64 size)
507 {
508 	struct drm_mm_node tmp = {};
509 	int err;
510 
511 	err = drm_mm_insert_node(mm, &tmp, size);
512 	if (likely(err == -ENOSPC))
513 		return true;
514 
515 	if (!err) {
516 		KUNIT_FAIL(test, "impossible insert succeeded, node %llu + %llu\n",
517 			   tmp.start, tmp.size);
518 		drm_mm_remove_node(&tmp);
519 	} else {
520 		KUNIT_FAIL(test,
521 			   "impossible insert failed with wrong error %d [expected %d], size %llu\n",
522 			   err, -ENOSPC, size);
523 	}
524 	return false;
525 }
526 
527 static int __drm_test_mm_insert(struct kunit *test, unsigned int count, u64 size, bool replace)
528 {
529 	DRM_RND_STATE(prng, random_seed);
530 	const struct insert_mode *mode;
531 	struct drm_mm mm;
532 	struct drm_mm_node *nodes, *node, *next;
533 	unsigned int *order, n, m, o = 0;
534 	int ret;
535 
536 	/* Fill a range with lots of nodes, check it doesn't fail too early */
537 
538 	DRM_MM_BUG_ON(!count);
539 	DRM_MM_BUG_ON(!size);
540 
541 	ret = -ENOMEM;
542 	nodes = vmalloc(array_size(count, sizeof(*nodes)));
543 	KUNIT_ASSERT_TRUE(test, nodes);
544 
545 	order = drm_random_order(count, &prng);
546 	if (!order)
547 		goto err_nodes;
548 
549 	ret = -EINVAL;
550 	drm_mm_init(&mm, 0, count * size);
551 
552 	for (mode = insert_modes; mode->name; mode++) {
553 		for (n = 0; n < count; n++) {
554 			struct drm_mm_node tmp;
555 
556 			node = replace ? &tmp : &nodes[n];
557 			memset(node, 0, sizeof(*node));
558 			if (!expect_insert(test, &mm, node, size, 0, n, mode)) {
559 				KUNIT_FAIL(test, "%s insert failed, size %llu step %d\n",
560 					   mode->name, size, n);
561 				goto out;
562 			}
563 
564 			if (replace) {
565 				drm_mm_replace_node(&tmp, &nodes[n]);
566 				if (drm_mm_node_allocated(&tmp)) {
567 					KUNIT_FAIL(test,
568 						   "replaced old-node still allocated! step %d\n",
569 						   n);
570 					goto out;
571 				}
572 
573 				if (!assert_node(test, &nodes[n], &mm, size, 0, n)) {
574 					KUNIT_FAIL(test,
575 						   "replaced node did not inherit parameters, size %llu step %d\n",
576 						   size, n);
577 					goto out;
578 				}
579 
580 				if (tmp.start != nodes[n].start) {
581 					KUNIT_FAIL(test,
582 						   "replaced node mismatch location expected [%llx + %llx], found [%llx + %llx]\n",
583 						   tmp.start, size, nodes[n].start, nodes[n].size);
584 					goto out;
585 				}
586 			}
587 		}
588 
589 		/* After random insertion the nodes should be in order */
590 		if (!assert_continuous(test, &mm, size))
591 			goto out;
592 
593 		/* Repeated use should then fail */
594 		if (!expect_insert_fail(test, &mm, size))
595 			goto out;
596 
597 		/* Remove one and reinsert, as the only hole it should refill itself */
598 		for (n = 0; n < count; n++) {
599 			u64 addr = nodes[n].start;
600 
601 			drm_mm_remove_node(&nodes[n]);
602 			if (!expect_insert(test, &mm, &nodes[n], size, 0, n, mode)) {
603 				KUNIT_FAIL(test, "%s reinsert failed, size %llu step %d\n",
604 					   mode->name, size, n);
605 				goto out;
606 			}
607 
608 			if (nodes[n].start != addr) {
609 				KUNIT_FAIL(test,
610 					   "%s reinsert node moved, step %d, expected %llx, found %llx\n",
611 					   mode->name, n, addr, nodes[n].start);
612 				goto out;
613 			}
614 
615 			if (!assert_continuous(test, &mm, size))
616 				goto out;
617 		}
618 
619 		/* Remove several, reinsert, check full */
620 		for_each_prime_number(n, min(max_prime, count)) {
621 			for (m = 0; m < n; m++) {
622 				node = &nodes[order[(o + m) % count]];
623 				drm_mm_remove_node(node);
624 			}
625 
626 			for (m = 0; m < n; m++) {
627 				node = &nodes[order[(o + m) % count]];
628 				if (!expect_insert(test, &mm, node, size, 0, n, mode)) {
629 					KUNIT_FAIL(test,
630 						   "%s multiple reinsert failed, size %llu step %d\n",
631 							   mode->name, size, n);
632 					goto out;
633 				}
634 			}
635 
636 			o += n;
637 
638 			if (!assert_continuous(test, &mm, size))
639 				goto out;
640 
641 			if (!expect_insert_fail(test, &mm, size))
642 				goto out;
643 		}
644 
645 		drm_mm_for_each_node_safe(node, next, &mm)
646 			drm_mm_remove_node(node);
647 		DRM_MM_BUG_ON(!drm_mm_clean(&mm));
648 
649 		cond_resched();
650 	}
651 
652 	ret = 0;
653 out:
654 	drm_mm_for_each_node_safe(node, next, &mm)
655 		drm_mm_remove_node(node);
656 	drm_mm_takedown(&mm);
657 	kfree(order);
658 err_nodes:
659 	vfree(nodes);
660 	return ret;
661 }
662 
663 static void drm_test_mm_insert(struct kunit *test)
664 {
665 	const unsigned int count = min_t(unsigned int, BIT(10), max_iterations);
666 	unsigned int n;
667 
668 	for_each_prime_number_from(n, 1, 54) {
669 		u64 size = BIT_ULL(n);
670 
671 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size - 1, false));
672 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size, false));
673 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size + 1, false));
674 
675 		cond_resched();
676 	}
677 }
678 
679 static void drm_test_mm_replace(struct kunit *test)
680 {
681 	const unsigned int count = min_t(unsigned int, BIT(10), max_iterations);
682 	unsigned int n;
683 
684 	/* Reuse __drm_test_mm_insert to exercise replacement by inserting a dummy node,
685 	 * then replacing it with the intended node. We want to check that
686 	 * the tree is intact and all the information we need is carried
687 	 * across to the target node.
688 	 */
689 
690 	for_each_prime_number_from(n, 1, 54) {
691 		u64 size = BIT_ULL(n);
692 
693 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size - 1, true));
694 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size, true));
695 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size + 1, true));
696 
697 		cond_resched();
698 	}
699 }
700 
701 static bool expect_insert_in_range(struct kunit *test, struct drm_mm *mm, struct drm_mm_node *node,
702 				   u64 size, u64 alignment, unsigned long color,
703 				   u64 range_start, u64 range_end, const struct insert_mode *mode)
704 {
705 	int err;
706 
707 	err = drm_mm_insert_node_in_range(mm, node,
708 					  size, alignment, color,
709 					  range_start, range_end,
710 					  mode->mode);
711 	if (err) {
712 		KUNIT_FAIL(test,
713 			   "insert (size=%llu, alignment=%llu, color=%lu, mode=%s) nto range [%llx, %llx] failed with err=%d\n",
714 				   size, alignment, color, mode->name,
715 				   range_start, range_end, err);
716 		return false;
717 	}
718 
719 	if (!assert_node(test, node, mm, size, alignment, color)) {
720 		drm_mm_remove_node(node);
721 		return false;
722 	}
723 
724 	return true;
725 }
726 
727 static bool expect_insert_in_range_fail(struct kunit *test, struct drm_mm *mm,
728 					u64 size, u64 range_start, u64 range_end)
729 {
730 	struct drm_mm_node tmp = {};
731 	int err;
732 
733 	err = drm_mm_insert_node_in_range(mm, &tmp, size, 0, 0, range_start, range_end,
734 					  0);
735 	if (likely(err == -ENOSPC))
736 		return true;
737 
738 	if (!err) {
739 		KUNIT_FAIL(test,
740 			   "impossible insert succeeded, node %llx + %llu, range [%llx, %llx]\n",
741 				   tmp.start, tmp.size, range_start, range_end);
742 		drm_mm_remove_node(&tmp);
743 	} else {
744 		KUNIT_FAIL(test,
745 			   "impossible insert failed with wrong error %d [expected %d], size %llu, range [%llx, %llx]\n",
746 				   err, -ENOSPC, size, range_start, range_end);
747 	}
748 
749 	return false;
750 }
751 
752 static bool assert_contiguous_in_range(struct kunit *test, struct drm_mm *mm,
753 				       u64 size, u64 start, u64 end)
754 {
755 	struct drm_mm_node *node;
756 	unsigned int n;
757 
758 	if (!expect_insert_in_range_fail(test, mm, size, start, end))
759 		return false;
760 
761 	n = div64_u64(start + size - 1, size);
762 	drm_mm_for_each_node(node, mm) {
763 		if (node->start < start || node->start + node->size > end) {
764 			KUNIT_FAIL(test,
765 				   "node %d out of range, address [%llx + %llu], range [%llx, %llx]\n",
766 					   n, node->start, node->start + node->size, start, end);
767 			return false;
768 		}
769 
770 		if (node->start != n * size) {
771 			KUNIT_FAIL(test, "node %d out of order, expected start %llx, found %llx\n",
772 				   n, n * size, node->start);
773 			return false;
774 		}
775 
776 		if (node->size != size) {
777 			KUNIT_FAIL(test, "node %d has wrong size, expected size %llx, found %llx\n",
778 				   n, size, node->size);
779 			return false;
780 		}
781 
782 		if (drm_mm_hole_follows(node) && drm_mm_hole_node_end(node) < end) {
783 			KUNIT_FAIL(test, "node %d is followed by a hole!\n", n);
784 			return false;
785 		}
786 
787 		n++;
788 	}
789 
790 	if (start > 0) {
791 		node = __drm_mm_interval_first(mm, 0, start - 1);
792 		if (drm_mm_node_allocated(node)) {
793 			KUNIT_FAIL(test, "node before start: node=%llx+%llu, start=%llx\n",
794 				   node->start, node->size, start);
795 			return false;
796 		}
797 	}
798 
799 	if (end < U64_MAX) {
800 		node = __drm_mm_interval_first(mm, end, U64_MAX);
801 		if (drm_mm_node_allocated(node)) {
802 			KUNIT_FAIL(test, "node after end: node=%llx+%llu, end=%llx\n",
803 				   node->start, node->size, end);
804 			return false;
805 		}
806 	}
807 
808 	return true;
809 }
810 
811 static int __drm_test_mm_insert_range(struct kunit *test, unsigned int count, u64 size,
812 				      u64 start, u64 end)
813 {
814 	const struct insert_mode *mode;
815 	struct drm_mm mm;
816 	struct drm_mm_node *nodes, *node, *next;
817 	unsigned int n, start_n, end_n;
818 	int ret;
819 
820 	DRM_MM_BUG_ON(!count);
821 	DRM_MM_BUG_ON(!size);
822 	DRM_MM_BUG_ON(end <= start);
823 
824 	/* Very similar to __drm_test_mm_insert(), but now instead of populating the
825 	 * full range of the drm_mm, we try to fill a small portion of it.
826 	 */
827 
828 	ret = -ENOMEM;
829 	nodes = vzalloc(array_size(count, sizeof(*nodes)));
830 	KUNIT_ASSERT_TRUE(test, nodes);
831 
832 	ret = -EINVAL;
833 	drm_mm_init(&mm, 0, count * size);
834 
835 	start_n = div64_u64(start + size - 1, size);
836 	end_n = div64_u64(end - size, size);
837 
838 	for (mode = insert_modes; mode->name; mode++) {
839 		for (n = start_n; n <= end_n; n++) {
840 			if (!expect_insert_in_range(test, &mm, &nodes[n], size, size, n,
841 						    start, end, mode)) {
842 				KUNIT_FAIL(test,
843 					   "%s insert failed, size %llu, step %d [%d, %d], range [%llx, %llx]\n",
844 						   mode->name, size, n, start_n, end_n, start, end);
845 				goto out;
846 			}
847 		}
848 
849 		if (!assert_contiguous_in_range(test, &mm, size, start, end)) {
850 			KUNIT_FAIL(test,
851 				   "%s: range [%llx, %llx] not full after initialisation, size=%llu\n",
852 				   mode->name, start, end, size);
853 			goto out;
854 		}
855 
856 		/* Remove one and reinsert, it should refill itself */
857 		for (n = start_n; n <= end_n; n++) {
858 			u64 addr = nodes[n].start;
859 
860 			drm_mm_remove_node(&nodes[n]);
861 			if (!expect_insert_in_range(test, &mm, &nodes[n], size, size, n,
862 						    start, end, mode)) {
863 				KUNIT_FAIL(test, "%s reinsert failed, step %d\n", mode->name, n);
864 				goto out;
865 			}
866 
867 			if (nodes[n].start != addr) {
868 				KUNIT_FAIL(test,
869 					   "%s reinsert node moved, step %d, expected %llx, found %llx\n",
870 					   mode->name, n, addr, nodes[n].start);
871 				goto out;
872 			}
873 		}
874 
875 		if (!assert_contiguous_in_range(test, &mm, size, start, end)) {
876 			KUNIT_FAIL(test,
877 				   "%s: range [%llx, %llx] not full after reinsertion, size=%llu\n",
878 				   mode->name, start, end, size);
879 			goto out;
880 		}
881 
882 		drm_mm_for_each_node_safe(node, next, &mm)
883 			drm_mm_remove_node(node);
884 		DRM_MM_BUG_ON(!drm_mm_clean(&mm));
885 
886 		cond_resched();
887 	}
888 
889 	ret = 0;
890 out:
891 	drm_mm_for_each_node_safe(node, next, &mm)
892 		drm_mm_remove_node(node);
893 	drm_mm_takedown(&mm);
894 	vfree(nodes);
895 	return ret;
896 }
897 
898 static int insert_outside_range(struct kunit *test)
899 {
900 	struct drm_mm mm;
901 	const unsigned int start = 1024;
902 	const unsigned int end = 2048;
903 	const unsigned int size = end - start;
904 
905 	drm_mm_init(&mm, start, size);
906 
907 	if (!expect_insert_in_range_fail(test, &mm, 1, 0, start))
908 		return -EINVAL;
909 
910 	if (!expect_insert_in_range_fail(test, &mm, size,
911 					 start - size / 2, start + (size + 1) / 2))
912 		return -EINVAL;
913 
914 	if (!expect_insert_in_range_fail(test, &mm, size,
915 					 end - (size + 1) / 2, end + size / 2))
916 		return -EINVAL;
917 
918 	if (!expect_insert_in_range_fail(test, &mm, 1, end, end + size))
919 		return -EINVAL;
920 
921 	drm_mm_takedown(&mm);
922 	return 0;
923 }
924 
925 static void drm_test_mm_insert_range(struct kunit *test)
926 {
927 	const unsigned int count = min_t(unsigned int, BIT(13), max_iterations);
928 	unsigned int n;
929 
930 	/* Check that requests outside the bounds of drm_mm are rejected. */
931 	KUNIT_ASSERT_FALSE(test, insert_outside_range(test));
932 
933 	for_each_prime_number_from(n, 1, 50) {
934 		const u64 size = BIT_ULL(n);
935 		const u64 max = count * size;
936 
937 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max));
938 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 1, max));
939 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max - 1));
940 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max / 2));
941 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,
942 								    max / 2, max / 2));
943 		KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,
944 								    max / 4 + 1, 3 * max / 4 - 1));
945 
946 		cond_resched();
947 	}
948 }
949 
950 static int prepare_frag(struct kunit *test, struct drm_mm *mm, struct drm_mm_node *nodes,
951 			unsigned int num_insert, const struct insert_mode *mode)
952 {
953 	unsigned int size = 4096;
954 	unsigned int i;
955 
956 	for (i = 0; i < num_insert; i++) {
957 		if (!expect_insert(test, mm, &nodes[i], size, 0, i, mode) != 0) {
958 			KUNIT_FAIL(test, "%s insert failed\n", mode->name);
959 			return -EINVAL;
960 		}
961 	}
962 
963 	/* introduce fragmentation by freeing every other node */
964 	for (i = 0; i < num_insert; i++) {
965 		if (i % 2 == 0)
966 			drm_mm_remove_node(&nodes[i]);
967 	}
968 
969 	return 0;
970 }
971 
972 static u64 get_insert_time(struct kunit *test, struct drm_mm *mm,
973 			   unsigned int num_insert, struct drm_mm_node *nodes,
974 			   const struct insert_mode *mode)
975 {
976 	unsigned int size = 8192;
977 	ktime_t start;
978 	unsigned int i;
979 
980 	start = ktime_get();
981 	for (i = 0; i < num_insert; i++) {
982 		if (!expect_insert(test, mm, &nodes[i], size, 0, i, mode) != 0) {
983 			KUNIT_FAIL(test, "%s insert failed\n", mode->name);
984 			return 0;
985 		}
986 	}
987 
988 	return ktime_to_ns(ktime_sub(ktime_get(), start));
989 }
990 
991 static void drm_test_mm_frag(struct kunit *test)
992 {
993 	struct drm_mm mm;
994 	const struct insert_mode *mode;
995 	struct drm_mm_node *nodes, *node, *next;
996 	unsigned int insert_size = 10000;
997 	unsigned int scale_factor = 4;
998 
999 	/* We need 4 * insert_size nodes to hold intermediate allocated
1000 	 * drm_mm nodes.
1001 	 * 1 times for prepare_frag()
1002 	 * 1 times for get_insert_time()
1003 	 * 2 times for get_insert_time()
1004 	 */
1005 	nodes = vzalloc(array_size(insert_size * 4, sizeof(*nodes)));
1006 	KUNIT_ASSERT_TRUE(test, nodes);
1007 
1008 	/* For BOTTOMUP and TOPDOWN, we first fragment the
1009 	 * address space using prepare_frag() and then try to verify
1010 	 * that insertions scale quadratically from 10k to 20k insertions
1011 	 */
1012 	drm_mm_init(&mm, 1, U64_MAX - 2);
1013 	for (mode = insert_modes; mode->name; mode++) {
1014 		u64 insert_time1, insert_time2;
1015 
1016 		if (mode->mode != DRM_MM_INSERT_LOW &&
1017 		    mode->mode != DRM_MM_INSERT_HIGH)
1018 			continue;
1019 
1020 		if (prepare_frag(test, &mm, nodes, insert_size, mode))
1021 			goto err;
1022 
1023 		insert_time1 = get_insert_time(test, &mm, insert_size,
1024 					       nodes + insert_size, mode);
1025 		if (insert_time1 == 0)
1026 			goto err;
1027 
1028 		insert_time2 = get_insert_time(test, &mm, (insert_size * 2),
1029 					       nodes + insert_size * 2, mode);
1030 		if (insert_time2 == 0)
1031 			goto err;
1032 
1033 		kunit_info(test, "%s fragmented insert of %u and %u insertions took %llu and %llu nsecs\n",
1034 			   mode->name, insert_size, insert_size * 2, insert_time1, insert_time2);
1035 
1036 		if (insert_time2 > (scale_factor * insert_time1)) {
1037 			KUNIT_FAIL(test, "%s fragmented insert took %llu nsecs more\n",
1038 				   mode->name, insert_time2 - (scale_factor * insert_time1));
1039 			goto err;
1040 		}
1041 
1042 		drm_mm_for_each_node_safe(node, next, &mm)
1043 			drm_mm_remove_node(node);
1044 	}
1045 
1046 err:
1047 	drm_mm_for_each_node_safe(node, next, &mm)
1048 		drm_mm_remove_node(node);
1049 	drm_mm_takedown(&mm);
1050 	vfree(nodes);
1051 }
1052 
1053 static void drm_test_mm_align(struct kunit *test)
1054 {
1055 	const struct insert_mode *mode;
1056 	const unsigned int max_count = min(8192u, max_prime);
1057 	struct drm_mm mm;
1058 	struct drm_mm_node *nodes, *node, *next;
1059 	unsigned int prime;
1060 
1061 	/* For each of the possible insertion modes, we pick a few
1062 	 * arbitrary alignments and check that the inserted node
1063 	 * meets our requirements.
1064 	 */
1065 
1066 	nodes = vzalloc(array_size(max_count, sizeof(*nodes)));
1067 	KUNIT_ASSERT_TRUE(test, nodes);
1068 
1069 	drm_mm_init(&mm, 1, U64_MAX - 2);
1070 
1071 	for (mode = insert_modes; mode->name; mode++) {
1072 		unsigned int i = 0;
1073 
1074 		for_each_prime_number_from(prime, 1, max_count) {
1075 			u64 size = next_prime_number(prime);
1076 
1077 			if (!expect_insert(test, &mm, &nodes[i], size, prime, i, mode)) {
1078 				KUNIT_FAIL(test, "%s insert failed with alignment=%d",
1079 					   mode->name, prime);
1080 				goto out;
1081 			}
1082 
1083 			i++;
1084 		}
1085 
1086 		drm_mm_for_each_node_safe(node, next, &mm)
1087 			drm_mm_remove_node(node);
1088 		DRM_MM_BUG_ON(!drm_mm_clean(&mm));
1089 
1090 		cond_resched();
1091 	}
1092 
1093 out:
1094 	drm_mm_for_each_node_safe(node, next, &mm)
1095 		drm_mm_remove_node(node);
1096 	drm_mm_takedown(&mm);
1097 	vfree(nodes);
1098 }
1099 
1100 static void drm_test_mm_align_pot(struct kunit *test, int max)
1101 {
1102 	struct drm_mm mm;
1103 	struct drm_mm_node *node, *next;
1104 	int bit;
1105 
1106 	/* Check that we can align to the full u64 address space */
1107 
1108 	drm_mm_init(&mm, 1, U64_MAX - 2);
1109 
1110 	for (bit = max - 1; bit; bit--) {
1111 		u64 align, size;
1112 
1113 		node = kzalloc(sizeof(*node), GFP_KERNEL);
1114 		if (!node) {
1115 			KUNIT_FAIL(test, "failed to allocate node");
1116 			goto out;
1117 		}
1118 
1119 		align = BIT_ULL(bit);
1120 		size = BIT_ULL(bit - 1) + 1;
1121 		if (!expect_insert(test, &mm, node, size, align, bit, &insert_modes[0])) {
1122 			KUNIT_FAIL(test, "insert failed with alignment=%llx [%d]", align, bit);
1123 			goto out;
1124 		}
1125 
1126 		cond_resched();
1127 	}
1128 
1129 out:
1130 	drm_mm_for_each_node_safe(node, next, &mm) {
1131 		drm_mm_remove_node(node);
1132 		kfree(node);
1133 	}
1134 	drm_mm_takedown(&mm);
1135 }
1136 
1137 static void drm_test_mm_align32(struct kunit *test)
1138 {
1139 	drm_test_mm_align_pot(test, 32);
1140 }
1141 
1142 static void drm_test_mm_align64(struct kunit *test)
1143 {
1144 	drm_test_mm_align_pot(test, 64);
1145 }
1146 
1147 static void show_scan(struct kunit *test, const struct drm_mm_scan *scan)
1148 {
1149 	kunit_info(test, "scan: hit [%llx, %llx], size=%lld, align=%lld, color=%ld\n",
1150 		   scan->hit_start, scan->hit_end, scan->size, scan->alignment, scan->color);
1151 }
1152 
1153 static void show_holes(struct kunit *test, const struct drm_mm *mm, int count)
1154 {
1155 	u64 hole_start, hole_end;
1156 	struct drm_mm_node *hole;
1157 
1158 	drm_mm_for_each_hole(hole, mm, hole_start, hole_end) {
1159 		struct drm_mm_node *next = list_next_entry(hole, node_list);
1160 		const char *node1 = NULL, *node2 = NULL;
1161 
1162 		if (drm_mm_node_allocated(hole))
1163 			node1 = kasprintf(GFP_KERNEL, "[%llx + %lld, color=%ld], ",
1164 					  hole->start, hole->size, hole->color);
1165 
1166 		if (drm_mm_node_allocated(next))
1167 			node2 = kasprintf(GFP_KERNEL, ", [%llx + %lld, color=%ld]",
1168 					  next->start, next->size, next->color);
1169 
1170 		kunit_info(test, "%sHole [%llx - %llx, size %lld]%s\n", node1,
1171 			   hole_start, hole_end, hole_end - hole_start, node2);
1172 
1173 		kfree(node2);
1174 		kfree(node1);
1175 
1176 		if (!--count)
1177 			break;
1178 	}
1179 }
1180 
1181 struct evict_node {
1182 	struct drm_mm_node node;
1183 	struct list_head link;
1184 };
1185 
1186 static bool evict_nodes(struct kunit *test, struct drm_mm_scan *scan,
1187 			struct evict_node *nodes, unsigned int *order, unsigned int count,
1188 			bool use_color, struct list_head *evict_list)
1189 {
1190 	struct evict_node *e, *en;
1191 	unsigned int i;
1192 
1193 	for (i = 0; i < count; i++) {
1194 		e = &nodes[order ? order[i] : i];
1195 		list_add(&e->link, evict_list);
1196 		if (drm_mm_scan_add_block(scan, &e->node))
1197 			break;
1198 	}
1199 	list_for_each_entry_safe(e, en, evict_list, link) {
1200 		if (!drm_mm_scan_remove_block(scan, &e->node))
1201 			list_del(&e->link);
1202 	}
1203 	if (list_empty(evict_list)) {
1204 		KUNIT_FAIL(test,
1205 			   "Failed to find eviction: size=%lld [avail=%d], align=%lld (color=%lu)\n",
1206 			   scan->size, count, scan->alignment, scan->color);
1207 		return false;
1208 	}
1209 
1210 	list_for_each_entry(e, evict_list, link)
1211 		drm_mm_remove_node(&e->node);
1212 
1213 	if (use_color) {
1214 		struct drm_mm_node *node;
1215 
1216 		while ((node = drm_mm_scan_color_evict(scan))) {
1217 			e = container_of(node, typeof(*e), node);
1218 			drm_mm_remove_node(&e->node);
1219 			list_add(&e->link, evict_list);
1220 		}
1221 	} else {
1222 		if (drm_mm_scan_color_evict(scan)) {
1223 			KUNIT_FAIL(test,
1224 				   "drm_mm_scan_color_evict unexpectedly reported overlapping nodes!\n");
1225 			return false;
1226 		}
1227 	}
1228 
1229 	return true;
1230 }
1231 
1232 static bool evict_nothing(struct kunit *test, struct drm_mm *mm,
1233 			  unsigned int total_size, struct evict_node *nodes)
1234 {
1235 	struct drm_mm_scan scan;
1236 	LIST_HEAD(evict_list);
1237 	struct evict_node *e;
1238 	struct drm_mm_node *node;
1239 	unsigned int n;
1240 
1241 	drm_mm_scan_init(&scan, mm, 1, 0, 0, 0);
1242 	for (n = 0; n < total_size; n++) {
1243 		e = &nodes[n];
1244 		list_add(&e->link, &evict_list);
1245 		drm_mm_scan_add_block(&scan, &e->node);
1246 	}
1247 	list_for_each_entry(e, &evict_list, link)
1248 		drm_mm_scan_remove_block(&scan, &e->node);
1249 
1250 	for (n = 0; n < total_size; n++) {
1251 		e = &nodes[n];
1252 
1253 		if (!drm_mm_node_allocated(&e->node)) {
1254 			KUNIT_FAIL(test, "node[%d] no longer allocated!\n", n);
1255 			return false;
1256 		}
1257 
1258 		e->link.next = NULL;
1259 	}
1260 
1261 	drm_mm_for_each_node(node, mm) {
1262 		e = container_of(node, typeof(*e), node);
1263 		e->link.next = &e->link;
1264 	}
1265 
1266 	for (n = 0; n < total_size; n++) {
1267 		e = &nodes[n];
1268 
1269 		if (!e->link.next) {
1270 			KUNIT_FAIL(test, "node[%d] no longer connected!\n", n);
1271 			return false;
1272 		}
1273 	}
1274 
1275 	return assert_continuous(test, mm, nodes[0].node.size);
1276 }
1277 
1278 static bool evict_everything(struct kunit *test, struct drm_mm *mm,
1279 			     unsigned int total_size, struct evict_node *nodes)
1280 {
1281 	struct drm_mm_scan scan;
1282 	LIST_HEAD(evict_list);
1283 	struct evict_node *e;
1284 	unsigned int n;
1285 	int err;
1286 
1287 	drm_mm_scan_init(&scan, mm, total_size, 0, 0, 0);
1288 	for (n = 0; n < total_size; n++) {
1289 		e = &nodes[n];
1290 		list_add(&e->link, &evict_list);
1291 		if (drm_mm_scan_add_block(&scan, &e->node))
1292 			break;
1293 	}
1294 
1295 	err = 0;
1296 	list_for_each_entry(e, &evict_list, link) {
1297 		if (!drm_mm_scan_remove_block(&scan, &e->node)) {
1298 			if (!err) {
1299 				KUNIT_FAIL(test, "Node %lld not marked for eviction!\n",
1300 					   e->node.start);
1301 				err = -EINVAL;
1302 			}
1303 		}
1304 	}
1305 	if (err)
1306 		return false;
1307 
1308 	list_for_each_entry(e, &evict_list, link)
1309 		drm_mm_remove_node(&e->node);
1310 
1311 	if (!assert_one_hole(test, mm, 0, total_size))
1312 		return false;
1313 
1314 	list_for_each_entry(e, &evict_list, link) {
1315 		err = drm_mm_reserve_node(mm, &e->node);
1316 		if (err) {
1317 			KUNIT_FAIL(test, "Failed to reinsert node after eviction: start=%llx\n",
1318 				   e->node.start);
1319 			return false;
1320 		}
1321 	}
1322 
1323 	return assert_continuous(test, mm, nodes[0].node.size);
1324 }
1325 
1326 static int evict_something(struct kunit *test, struct drm_mm *mm,
1327 			   u64 range_start, u64 range_end, struct evict_node *nodes,
1328 			   unsigned int *order, unsigned int count, unsigned int size,
1329 			   unsigned int alignment, const struct insert_mode *mode)
1330 {
1331 	struct drm_mm_scan scan;
1332 	LIST_HEAD(evict_list);
1333 	struct evict_node *e;
1334 	struct drm_mm_node tmp;
1335 	int err;
1336 
1337 	drm_mm_scan_init_with_range(&scan, mm, size, alignment, 0, range_start,
1338 				    range_end, mode->mode);
1339 	if (!evict_nodes(test, &scan, nodes, order, count, false, &evict_list))
1340 		return -EINVAL;
1341 
1342 	memset(&tmp, 0, sizeof(tmp));
1343 	err = drm_mm_insert_node_generic(mm, &tmp, size, alignment, 0,
1344 					 DRM_MM_INSERT_EVICT);
1345 	if (err) {
1346 		KUNIT_FAIL(test, "Failed to insert into eviction hole: size=%d, align=%d\n",
1347 			   size, alignment);
1348 		show_scan(test, &scan);
1349 		show_holes(test, mm, 3);
1350 		return err;
1351 	}
1352 
1353 	if (tmp.start < range_start || tmp.start + tmp.size > range_end) {
1354 		KUNIT_FAIL(test,
1355 			   "Inserted [address=%llu + %llu] did not fit into the request range [%llu, %llu]\n",
1356 			   tmp.start, tmp.size, range_start, range_end);
1357 		err = -EINVAL;
1358 	}
1359 
1360 	if (!assert_node(test, &tmp, mm, size, alignment, 0) ||
1361 	    drm_mm_hole_follows(&tmp)) {
1362 		KUNIT_FAIL(test,
1363 			   "Inserted did not fill the eviction hole: size=%lld [%d], align=%d [rem=%lld], start=%llx, hole-follows?=%d\n",
1364 			   tmp.size, size, alignment, misalignment(&tmp, alignment),
1365 			   tmp.start, drm_mm_hole_follows(&tmp));
1366 		err = -EINVAL;
1367 	}
1368 
1369 	drm_mm_remove_node(&tmp);
1370 	if (err)
1371 		return err;
1372 
1373 	list_for_each_entry(e, &evict_list, link) {
1374 		err = drm_mm_reserve_node(mm, &e->node);
1375 		if (err) {
1376 			KUNIT_FAIL(test, "Failed to reinsert node after eviction: start=%llx\n",
1377 				   e->node.start);
1378 			return err;
1379 		}
1380 	}
1381 
1382 	if (!assert_continuous(test, mm, nodes[0].node.size)) {
1383 		KUNIT_FAIL(test, "range is no longer continuous\n");
1384 		return -EINVAL;
1385 	}
1386 
1387 	return 0;
1388 }
1389 
1390 static void drm_test_mm_evict(struct kunit *test)
1391 {
1392 	DRM_RND_STATE(prng, random_seed);
1393 	const unsigned int size = 8192;
1394 	const struct insert_mode *mode;
1395 	struct drm_mm mm;
1396 	struct evict_node *nodes;
1397 	struct drm_mm_node *node, *next;
1398 	unsigned int *order, n;
1399 
1400 	/* Here we populate a full drm_mm and then try and insert a new node
1401 	 * by evicting other nodes in a random order. The drm_mm_scan should
1402 	 * pick the first matching hole it finds from the random list. We
1403 	 * repeat that for different allocation strategies, alignments and
1404 	 * sizes to try and stress the hole finder.
1405 	 */
1406 
1407 	nodes = vzalloc(array_size(size, sizeof(*nodes)));
1408 	KUNIT_ASSERT_TRUE(test, nodes);
1409 
1410 	order = drm_random_order(size, &prng);
1411 	if (!order)
1412 		goto err_nodes;
1413 
1414 	drm_mm_init(&mm, 0, size);
1415 	for (n = 0; n < size; n++) {
1416 		if (drm_mm_insert_node(&mm, &nodes[n].node, 1)) {
1417 			KUNIT_FAIL(test, "insert failed, step %d\n", n);
1418 			goto out;
1419 		}
1420 	}
1421 
1422 	/* First check that using the scanner doesn't break the mm */
1423 	if (!evict_nothing(test, &mm, size, nodes)) {
1424 		KUNIT_FAIL(test, "evict_nothing() failed\n");
1425 		goto out;
1426 	}
1427 	if (!evict_everything(test, &mm, size, nodes)) {
1428 		KUNIT_FAIL(test, "evict_everything() failed\n");
1429 		goto out;
1430 	}
1431 
1432 	for (mode = evict_modes; mode->name; mode++) {
1433 		for (n = 1; n <= size; n <<= 1) {
1434 			drm_random_reorder(order, size, &prng);
1435 			if (evict_something(test, &mm, 0, U64_MAX, nodes, order, size, n, 1,
1436 					    mode)) {
1437 				KUNIT_FAIL(test, "%s evict_something(size=%u) failed\n",
1438 					   mode->name, n);
1439 				goto out;
1440 			}
1441 		}
1442 
1443 		for (n = 1; n < size; n <<= 1) {
1444 			drm_random_reorder(order, size, &prng);
1445 			if (evict_something(test, &mm, 0, U64_MAX, nodes, order, size,
1446 					    size / 2, n, mode)) {
1447 				KUNIT_FAIL(test,
1448 					   "%s evict_something(size=%u, alignment=%u) failed\n",
1449 					   mode->name, size / 2, n);
1450 				goto out;
1451 			}
1452 		}
1453 
1454 		for_each_prime_number_from(n, 1, min(size, max_prime)) {
1455 			unsigned int nsize = (size - n + 1) / 2;
1456 
1457 			DRM_MM_BUG_ON(!nsize);
1458 
1459 			drm_random_reorder(order, size, &prng);
1460 			if (evict_something(test, &mm, 0, U64_MAX, nodes, order, size,
1461 					    nsize, n, mode)) {
1462 				KUNIT_FAIL(test,
1463 					   "%s evict_something(size=%u, alignment=%u) failed\n",
1464 					   mode->name, nsize, n);
1465 				goto out;
1466 			}
1467 		}
1468 
1469 		cond_resched();
1470 	}
1471 
1472 out:
1473 	drm_mm_for_each_node_safe(node, next, &mm)
1474 		drm_mm_remove_node(node);
1475 	drm_mm_takedown(&mm);
1476 	kfree(order);
1477 err_nodes:
1478 	vfree(nodes);
1479 }
1480 
1481 static void drm_test_mm_evict_range(struct kunit *test)
1482 {
1483 	DRM_RND_STATE(prng, random_seed);
1484 	const unsigned int size = 8192;
1485 	const unsigned int range_size = size / 2;
1486 	const unsigned int range_start = size / 4;
1487 	const unsigned int range_end = range_start + range_size;
1488 	const struct insert_mode *mode;
1489 	struct drm_mm mm;
1490 	struct evict_node *nodes;
1491 	struct drm_mm_node *node, *next;
1492 	unsigned int *order, n;
1493 
1494 	/* Like drm_test_mm_evict() but now we are limiting the search to a
1495 	 * small portion of the full drm_mm.
1496 	 */
1497 
1498 	nodes = vzalloc(array_size(size, sizeof(*nodes)));
1499 	KUNIT_ASSERT_TRUE(test, nodes);
1500 
1501 	order = drm_random_order(size, &prng);
1502 	if (!order)
1503 		goto err_nodes;
1504 
1505 	drm_mm_init(&mm, 0, size);
1506 	for (n = 0; n < size; n++) {
1507 		if (drm_mm_insert_node(&mm, &nodes[n].node, 1)) {
1508 			KUNIT_FAIL(test, "insert failed, step %d\n", n);
1509 			goto out;
1510 		}
1511 	}
1512 
1513 	for (mode = evict_modes; mode->name; mode++) {
1514 		for (n = 1; n <= range_size; n <<= 1) {
1515 			drm_random_reorder(order, size, &prng);
1516 			if (evict_something(test, &mm, range_start, range_end, nodes,
1517 					    order, size, n, 1, mode)) {
1518 				KUNIT_FAIL(test,
1519 					   "%s evict_something(size=%u) failed with range [%u, %u]\n",
1520 					   mode->name, n, range_start, range_end);
1521 				goto out;
1522 			}
1523 		}
1524 
1525 		for (n = 1; n <= range_size; n <<= 1) {
1526 			drm_random_reorder(order, size, &prng);
1527 			if (evict_something(test, &mm, range_start, range_end, nodes,
1528 					    order, size, range_size / 2, n, mode)) {
1529 				KUNIT_FAIL(test,
1530 					   "%s evict_something(size=%u, alignment=%u) failed with range [%u, %u]\n",
1531 					   mode->name, range_size / 2, n, range_start, range_end);
1532 				goto out;
1533 			}
1534 		}
1535 
1536 		for_each_prime_number_from(n, 1, min(range_size, max_prime)) {
1537 			unsigned int nsize = (range_size - n + 1) / 2;
1538 
1539 			DRM_MM_BUG_ON(!nsize);
1540 
1541 			drm_random_reorder(order, size, &prng);
1542 			if (evict_something(test, &mm, range_start, range_end, nodes,
1543 					    order, size, nsize, n, mode)) {
1544 				KUNIT_FAIL(test,
1545 					   "%s evict_something(size=%u, alignment=%u) failed with range [%u, %u]\n",
1546 					   mode->name, nsize, n, range_start, range_end);
1547 				goto out;
1548 			}
1549 		}
1550 
1551 		cond_resched();
1552 	}
1553 
1554 out:
1555 	drm_mm_for_each_node_safe(node, next, &mm)
1556 		drm_mm_remove_node(node);
1557 	drm_mm_takedown(&mm);
1558 	kfree(order);
1559 err_nodes:
1560 	vfree(nodes);
1561 }
1562 
1563 static unsigned int node_index(const struct drm_mm_node *node)
1564 {
1565 	return div64_u64(node->start, node->size);
1566 }
1567 
1568 static void drm_test_mm_topdown(struct kunit *test)
1569 {
1570 	const struct insert_mode *topdown = &insert_modes[TOPDOWN];
1571 
1572 	DRM_RND_STATE(prng, random_seed);
1573 	const unsigned int count = 8192;
1574 	unsigned int size;
1575 	unsigned long *bitmap;
1576 	struct drm_mm mm;
1577 	struct drm_mm_node *nodes, *node, *next;
1578 	unsigned int *order, n, m, o = 0;
1579 
1580 	/* When allocating top-down, we expect to be returned a node
1581 	 * from a suitable hole at the top of the drm_mm. We check that
1582 	 * the returned node does match the highest available slot.
1583 	 */
1584 
1585 	nodes = vzalloc(array_size(count, sizeof(*nodes)));
1586 	KUNIT_ASSERT_TRUE(test, nodes);
1587 
1588 	bitmap = bitmap_zalloc(count, GFP_KERNEL);
1589 	if (!bitmap)
1590 		goto err_nodes;
1591 
1592 	order = drm_random_order(count, &prng);
1593 	if (!order)
1594 		goto err_bitmap;
1595 
1596 	for (size = 1; size <= 64; size <<= 1) {
1597 		drm_mm_init(&mm, 0, size * count);
1598 		for (n = 0; n < count; n++) {
1599 			if (!expect_insert(test, &mm, &nodes[n], size, 0, n, topdown)) {
1600 				KUNIT_FAIL(test, "insert failed, size %u step %d\n", size, n);
1601 				goto out;
1602 			}
1603 
1604 			if (drm_mm_hole_follows(&nodes[n])) {
1605 				KUNIT_FAIL(test,
1606 					   "hole after topdown insert %d, start=%llx\n, size=%u",
1607 					   n, nodes[n].start, size);
1608 				goto out;
1609 			}
1610 
1611 			if (!assert_one_hole(test, &mm, 0, size * (count - n - 1)))
1612 				goto out;
1613 		}
1614 
1615 		if (!assert_continuous(test, &mm, size))
1616 			goto out;
1617 
1618 		drm_random_reorder(order, count, &prng);
1619 		for_each_prime_number_from(n, 1, min(count, max_prime)) {
1620 			for (m = 0; m < n; m++) {
1621 				node = &nodes[order[(o + m) % count]];
1622 				drm_mm_remove_node(node);
1623 				__set_bit(node_index(node), bitmap);
1624 			}
1625 
1626 			for (m = 0; m < n; m++) {
1627 				unsigned int last;
1628 
1629 				node = &nodes[order[(o + m) % count]];
1630 				if (!expect_insert(test, &mm, node, size, 0, 0, topdown)) {
1631 					KUNIT_FAIL(test, "insert failed, step %d/%d\n", m, n);
1632 					goto out;
1633 				}
1634 
1635 				if (drm_mm_hole_follows(node)) {
1636 					KUNIT_FAIL(test,
1637 						   "hole after topdown insert %d/%d, start=%llx\n",
1638 						   m, n, node->start);
1639 					goto out;
1640 				}
1641 
1642 				last = find_last_bit(bitmap, count);
1643 				if (node_index(node) != last) {
1644 					KUNIT_FAIL(test,
1645 						   "node %d/%d, size %d, not inserted into upmost hole, expected %d, found %d\n",
1646 						   m, n, size, last, node_index(node));
1647 					goto out;
1648 				}
1649 
1650 				__clear_bit(last, bitmap);
1651 			}
1652 
1653 			DRM_MM_BUG_ON(find_first_bit(bitmap, count) != count);
1654 
1655 			o += n;
1656 		}
1657 
1658 		drm_mm_for_each_node_safe(node, next, &mm)
1659 			drm_mm_remove_node(node);
1660 		DRM_MM_BUG_ON(!drm_mm_clean(&mm));
1661 		cond_resched();
1662 	}
1663 
1664 out:
1665 	drm_mm_for_each_node_safe(node, next, &mm)
1666 		drm_mm_remove_node(node);
1667 	drm_mm_takedown(&mm);
1668 	kfree(order);
1669 err_bitmap:
1670 	bitmap_free(bitmap);
1671 err_nodes:
1672 	vfree(nodes);
1673 }
1674 
1675 static void drm_test_mm_bottomup(struct kunit *test)
1676 {
1677 	const struct insert_mode *bottomup = &insert_modes[BOTTOMUP];
1678 
1679 	DRM_RND_STATE(prng, random_seed);
1680 	const unsigned int count = 8192;
1681 	unsigned int size;
1682 	unsigned long *bitmap;
1683 	struct drm_mm mm;
1684 	struct drm_mm_node *nodes, *node, *next;
1685 	unsigned int *order, n, m, o = 0;
1686 
1687 	/* Like drm_test_mm_topdown, but instead of searching for the last hole,
1688 	 * we search for the first.
1689 	 */
1690 
1691 	nodes = vzalloc(array_size(count, sizeof(*nodes)));
1692 	KUNIT_ASSERT_TRUE(test, nodes);
1693 
1694 	bitmap = bitmap_zalloc(count, GFP_KERNEL);
1695 	if (!bitmap)
1696 		goto err_nodes;
1697 
1698 	order = drm_random_order(count, &prng);
1699 	if (!order)
1700 		goto err_bitmap;
1701 
1702 	for (size = 1; size <= 64; size <<= 1) {
1703 		drm_mm_init(&mm, 0, size * count);
1704 		for (n = 0; n < count; n++) {
1705 			if (!expect_insert(test, &mm, &nodes[n], size, 0, n, bottomup)) {
1706 				KUNIT_FAIL(test,
1707 					   "bottomup insert failed, size %u step %d\n", size, n);
1708 				goto out;
1709 			}
1710 
1711 			if (!assert_one_hole(test, &mm, size * (n + 1), size * count))
1712 				goto out;
1713 		}
1714 
1715 		if (!assert_continuous(test, &mm, size))
1716 			goto out;
1717 
1718 		drm_random_reorder(order, count, &prng);
1719 		for_each_prime_number_from(n, 1, min(count, max_prime)) {
1720 			for (m = 0; m < n; m++) {
1721 				node = &nodes[order[(o + m) % count]];
1722 				drm_mm_remove_node(node);
1723 				__set_bit(node_index(node), bitmap);
1724 			}
1725 
1726 			for (m = 0; m < n; m++) {
1727 				unsigned int first;
1728 
1729 				node = &nodes[order[(o + m) % count]];
1730 				if (!expect_insert(test, &mm, node, size, 0, 0, bottomup)) {
1731 					KUNIT_FAIL(test, "insert failed, step %d/%d\n", m, n);
1732 					goto out;
1733 				}
1734 
1735 				first = find_first_bit(bitmap, count);
1736 				if (node_index(node) != first) {
1737 					KUNIT_FAIL(test,
1738 						   "node %d/%d not inserted into bottom hole, expected %d, found %d\n",
1739 						   m, n, first, node_index(node));
1740 					goto out;
1741 				}
1742 				__clear_bit(first, bitmap);
1743 			}
1744 
1745 			DRM_MM_BUG_ON(find_first_bit(bitmap, count) != count);
1746 
1747 			o += n;
1748 		}
1749 
1750 		drm_mm_for_each_node_safe(node, next, &mm)
1751 			drm_mm_remove_node(node);
1752 		DRM_MM_BUG_ON(!drm_mm_clean(&mm));
1753 		cond_resched();
1754 	}
1755 
1756 out:
1757 	drm_mm_for_each_node_safe(node, next, &mm)
1758 		drm_mm_remove_node(node);
1759 	drm_mm_takedown(&mm);
1760 	kfree(order);
1761 err_bitmap:
1762 	bitmap_free(bitmap);
1763 err_nodes:
1764 	vfree(nodes);
1765 }
1766 
1767 static void drm_test_mm_once(struct kunit *test, unsigned int mode)
1768 {
1769 	struct drm_mm mm;
1770 	struct drm_mm_node rsvd_lo, rsvd_hi, node;
1771 
1772 	drm_mm_init(&mm, 0, 7);
1773 
1774 	memset(&rsvd_lo, 0, sizeof(rsvd_lo));
1775 	rsvd_lo.start = 1;
1776 	rsvd_lo.size = 1;
1777 	if (drm_mm_reserve_node(&mm, &rsvd_lo)) {
1778 		KUNIT_FAIL(test, "Could not reserve low node\n");
1779 		goto err;
1780 	}
1781 
1782 	memset(&rsvd_hi, 0, sizeof(rsvd_hi));
1783 	rsvd_hi.start = 5;
1784 	rsvd_hi.size = 1;
1785 	if (drm_mm_reserve_node(&mm, &rsvd_hi)) {
1786 		KUNIT_FAIL(test, "Could not reserve low node\n");
1787 		goto err_lo;
1788 	}
1789 
1790 	if (!drm_mm_hole_follows(&rsvd_lo) || !drm_mm_hole_follows(&rsvd_hi)) {
1791 		KUNIT_FAIL(test, "Expected a hole after lo and high nodes!\n");
1792 		goto err_hi;
1793 	}
1794 
1795 	memset(&node, 0, sizeof(node));
1796 	if (drm_mm_insert_node_generic(&mm, &node, 2, 0, 0, mode)) {
1797 		KUNIT_FAIL(test, "Could not insert the node into the available hole!\n");
1798 		goto err_hi;
1799 	}
1800 
1801 	drm_mm_remove_node(&node);
1802 err_hi:
1803 	drm_mm_remove_node(&rsvd_hi);
1804 err_lo:
1805 	drm_mm_remove_node(&rsvd_lo);
1806 err:
1807 	drm_mm_takedown(&mm);
1808 }
1809 
1810 static void drm_test_mm_lowest(struct kunit *test)
1811 {
1812 	drm_test_mm_once(test, DRM_MM_INSERT_LOW);
1813 }
1814 
1815 static void drm_test_mm_highest(struct kunit *test)
1816 {
1817 	drm_test_mm_once(test, DRM_MM_INSERT_HIGH);
1818 }
1819 
1820 static void separate_adjacent_colors(const struct drm_mm_node *node,
1821 				     unsigned long color, u64 *start, u64 *end)
1822 {
1823 	if (drm_mm_node_allocated(node) && node->color != color)
1824 		++*start;
1825 
1826 	node = list_next_entry(node, node_list);
1827 	if (drm_mm_node_allocated(node) && node->color != color)
1828 		--*end;
1829 }
1830 
1831 static bool colors_abutt(struct kunit *test, const struct drm_mm_node *node)
1832 {
1833 	if (!drm_mm_hole_follows(node) &&
1834 	    drm_mm_node_allocated(list_next_entry(node, node_list))) {
1835 		KUNIT_FAIL(test, "colors abutt; %ld [%llx + %llx] is next to %ld [%llx + %llx]!\n",
1836 			   node->color, node->start, node->size,
1837 		       list_next_entry(node, node_list)->color,
1838 		       list_next_entry(node, node_list)->start,
1839 		       list_next_entry(node, node_list)->size);
1840 		return true;
1841 	}
1842 
1843 	return false;
1844 }
1845 
1846 static void drm_test_mm_color(struct kunit *test)
1847 {
1848 	const unsigned int count = min(4096u, max_iterations);
1849 	const struct insert_mode *mode;
1850 	struct drm_mm mm;
1851 	struct drm_mm_node *node, *nn;
1852 	unsigned int n;
1853 
1854 	/* Color adjustment complicates everything. First we just check
1855 	 * that when we insert a node we apply any color_adjustment callback.
1856 	 * The callback we use should ensure that there is a gap between
1857 	 * any two nodes, and so after each insertion we check that those
1858 	 * holes are inserted and that they are preserved.
1859 	 */
1860 
1861 	drm_mm_init(&mm, 0, U64_MAX);
1862 
1863 	for (n = 1; n <= count; n++) {
1864 		node = kzalloc(sizeof(*node), GFP_KERNEL);
1865 		if (!node)
1866 			goto out;
1867 
1868 		if (!expect_insert(test, &mm, node, n, 0, n, &insert_modes[0])) {
1869 			KUNIT_FAIL(test, "insert failed, step %d\n", n);
1870 			kfree(node);
1871 			goto out;
1872 		}
1873 	}
1874 
1875 	drm_mm_for_each_node_safe(node, nn, &mm) {
1876 		if (node->color != node->size) {
1877 			KUNIT_FAIL(test, "invalid color stored: expected %lld, found %ld\n",
1878 				   node->size, node->color);
1879 
1880 			goto out;
1881 		}
1882 
1883 		drm_mm_remove_node(node);
1884 		kfree(node);
1885 	}
1886 
1887 	/* Now, let's start experimenting with applying a color callback */
1888 	mm.color_adjust = separate_adjacent_colors;
1889 	for (mode = insert_modes; mode->name; mode++) {
1890 		u64 last;
1891 
1892 		node = kzalloc(sizeof(*node), GFP_KERNEL);
1893 		if (!node)
1894 			goto out;
1895 
1896 		node->size = 1 + 2 * count;
1897 		node->color = node->size;
1898 
1899 		if (drm_mm_reserve_node(&mm, node)) {
1900 			KUNIT_FAIL(test, "initial reserve failed!\n");
1901 			goto out;
1902 		}
1903 
1904 		last = node->start + node->size;
1905 
1906 		for (n = 1; n <= count; n++) {
1907 			int rem;
1908 
1909 			node = kzalloc(sizeof(*node), GFP_KERNEL);
1910 			if (!node)
1911 				goto out;
1912 
1913 			node->start = last;
1914 			node->size = n + count;
1915 			node->color = node->size;
1916 
1917 			if (drm_mm_reserve_node(&mm, node) != -ENOSPC) {
1918 				KUNIT_FAIL(test, "reserve %d did not report color overlap!", n);
1919 				goto out;
1920 			}
1921 
1922 			node->start += n + 1;
1923 			rem = misalignment(node, n + count);
1924 			node->start += n + count - rem;
1925 
1926 			if (drm_mm_reserve_node(&mm, node)) {
1927 				KUNIT_FAIL(test, "reserve %d failed", n);
1928 				goto out;
1929 			}
1930 
1931 			last = node->start + node->size;
1932 		}
1933 
1934 		for (n = 1; n <= count; n++) {
1935 			node = kzalloc(sizeof(*node), GFP_KERNEL);
1936 			if (!node)
1937 				goto out;
1938 
1939 			if (!expect_insert(test, &mm, node, n, n, n, mode)) {
1940 				KUNIT_FAIL(test, "%s insert failed, step %d\n", mode->name, n);
1941 				kfree(node);
1942 				goto out;
1943 			}
1944 		}
1945 
1946 		drm_mm_for_each_node_safe(node, nn, &mm) {
1947 			u64 rem;
1948 
1949 			if (node->color != node->size) {
1950 				KUNIT_FAIL(test,
1951 					   "%s invalid color stored: expected %lld, found %ld\n",
1952 					   mode->name, node->size, node->color);
1953 
1954 				goto out;
1955 			}
1956 
1957 			if (colors_abutt(test, node))
1958 				goto out;
1959 
1960 			div64_u64_rem(node->start, node->size, &rem);
1961 			if (rem) {
1962 				KUNIT_FAIL(test,
1963 					   "%s colored node misaligned, start=%llx expected alignment=%lld [rem=%lld]\n",
1964 					   mode->name, node->start, node->size, rem);
1965 				goto out;
1966 			}
1967 
1968 			drm_mm_remove_node(node);
1969 			kfree(node);
1970 		}
1971 
1972 		cond_resched();
1973 	}
1974 
1975 out:
1976 	drm_mm_for_each_node_safe(node, nn, &mm) {
1977 		drm_mm_remove_node(node);
1978 		kfree(node);
1979 	}
1980 	drm_mm_takedown(&mm);
1981 }
1982 
1983 static int evict_color(struct kunit *test, struct drm_mm *mm, u64 range_start,
1984 		       u64 range_end, struct evict_node *nodes, unsigned int *order,
1985 		unsigned int count, unsigned int size, unsigned int alignment,
1986 		unsigned long color, const struct insert_mode *mode)
1987 {
1988 	struct drm_mm_scan scan;
1989 	LIST_HEAD(evict_list);
1990 	struct evict_node *e;
1991 	struct drm_mm_node tmp;
1992 	int err;
1993 
1994 	drm_mm_scan_init_with_range(&scan, mm, size, alignment, color, range_start,
1995 				    range_end, mode->mode);
1996 	if (!evict_nodes(test, &scan, nodes, order, count, true, &evict_list))
1997 		return -EINVAL;
1998 
1999 	memset(&tmp, 0, sizeof(tmp));
2000 	err = drm_mm_insert_node_generic(mm, &tmp, size, alignment, color,
2001 					 DRM_MM_INSERT_EVICT);
2002 	if (err) {
2003 		KUNIT_FAIL(test,
2004 			   "Failed to insert into eviction hole: size=%d, align=%d, color=%lu, err=%d\n",
2005 			   size, alignment, color, err);
2006 		show_scan(test, &scan);
2007 		show_holes(test, mm, 3);
2008 		return err;
2009 	}
2010 
2011 	if (tmp.start < range_start || tmp.start + tmp.size > range_end) {
2012 		KUNIT_FAIL(test,
2013 			   "Inserted [address=%llu + %llu] did not fit into the request range [%llu, %llu]\n",
2014 			   tmp.start, tmp.size, range_start, range_end);
2015 		err = -EINVAL;
2016 	}
2017 
2018 	if (colors_abutt(test, &tmp))
2019 		err = -EINVAL;
2020 
2021 	if (!assert_node(test, &tmp, mm, size, alignment, color)) {
2022 		KUNIT_FAIL(test,
2023 			   "Inserted did not fit the eviction hole: size=%lld [%d], align=%d [rem=%lld], start=%llx\n",
2024 			   tmp.size, size, alignment, misalignment(&tmp, alignment), tmp.start);
2025 		err = -EINVAL;
2026 	}
2027 
2028 	drm_mm_remove_node(&tmp);
2029 	if (err)
2030 		return err;
2031 
2032 	list_for_each_entry(e, &evict_list, link) {
2033 		err = drm_mm_reserve_node(mm, &e->node);
2034 		if (err) {
2035 			KUNIT_FAIL(test, "Failed to reinsert node after eviction: start=%llx\n",
2036 				   e->node.start);
2037 			return err;
2038 		}
2039 	}
2040 
2041 	cond_resched();
2042 	return 0;
2043 }
2044 
2045 static void drm_test_mm_color_evict(struct kunit *test)
2046 {
2047 	DRM_RND_STATE(prng, random_seed);
2048 	const unsigned int total_size = min(8192u, max_iterations);
2049 	const struct insert_mode *mode;
2050 	unsigned long color = 0;
2051 	struct drm_mm mm;
2052 	struct evict_node *nodes;
2053 	struct drm_mm_node *node, *next;
2054 	unsigned int *order, n;
2055 
2056 	/* Check that the drm_mm_scan also honours color adjustment when
2057 	 * choosing its victims to create a hole. Our color_adjust does not
2058 	 * allow two nodes to be placed together without an intervening hole
2059 	 * enlarging the set of victims that must be evicted.
2060 	 */
2061 
2062 	nodes = vzalloc(array_size(total_size, sizeof(*nodes)));
2063 	KUNIT_ASSERT_TRUE(test, nodes);
2064 
2065 	order = drm_random_order(total_size, &prng);
2066 	if (!order)
2067 		goto err_nodes;
2068 
2069 	drm_mm_init(&mm, 0, 2 * total_size - 1);
2070 	mm.color_adjust = separate_adjacent_colors;
2071 	for (n = 0; n < total_size; n++) {
2072 		if (!expect_insert(test, &mm, &nodes[n].node,
2073 				   1, 0, color++,
2074 				   &insert_modes[0])) {
2075 			KUNIT_FAIL(test, "insert failed, step %d\n", n);
2076 			goto out;
2077 		}
2078 	}
2079 
2080 	for (mode = evict_modes; mode->name; mode++) {
2081 		for (n = 1; n <= total_size; n <<= 1) {
2082 			drm_random_reorder(order, total_size, &prng);
2083 			if (evict_color(test, &mm, 0, U64_MAX, nodes, order, total_size,
2084 					n, 1, color++, mode)) {
2085 				KUNIT_FAIL(test, "%s evict_color(size=%u) failed\n", mode->name, n);
2086 				goto out;
2087 			}
2088 		}
2089 
2090 		for (n = 1; n < total_size; n <<= 1) {
2091 			drm_random_reorder(order, total_size, &prng);
2092 			if (evict_color(test, &mm, 0, U64_MAX, nodes, order, total_size,
2093 					total_size / 2, n, color++, mode)) {
2094 				KUNIT_FAIL(test, "%s evict_color(size=%u, alignment=%u) failed\n",
2095 					   mode->name, total_size / 2, n);
2096 				goto out;
2097 			}
2098 		}
2099 
2100 		for_each_prime_number_from(n, 1, min(total_size, max_prime)) {
2101 			unsigned int nsize = (total_size - n + 1) / 2;
2102 
2103 			DRM_MM_BUG_ON(!nsize);
2104 
2105 			drm_random_reorder(order, total_size, &prng);
2106 			if (evict_color(test, &mm, 0, U64_MAX, nodes, order, total_size,
2107 					nsize, n, color++, mode)) {
2108 				KUNIT_FAIL(test, "%s evict_color(size=%u, alignment=%u) failed\n",
2109 					   mode->name, nsize, n);
2110 				goto out;
2111 			}
2112 		}
2113 
2114 		cond_resched();
2115 	}
2116 
2117 out:
2118 	drm_mm_for_each_node_safe(node, next, &mm)
2119 		drm_mm_remove_node(node);
2120 	drm_mm_takedown(&mm);
2121 	kfree(order);
2122 err_nodes:
2123 	vfree(nodes);
2124 }
2125 
2126 static void drm_test_mm_color_evict_range(struct kunit *test)
2127 {
2128 	DRM_RND_STATE(prng, random_seed);
2129 	const unsigned int total_size = 8192;
2130 	const unsigned int range_size = total_size / 2;
2131 	const unsigned int range_start = total_size / 4;
2132 	const unsigned int range_end = range_start + range_size;
2133 	const struct insert_mode *mode;
2134 	unsigned long color = 0;
2135 	struct drm_mm mm;
2136 	struct evict_node *nodes;
2137 	struct drm_mm_node *node, *next;
2138 	unsigned int *order, n;
2139 
2140 	/* Like drm_test_mm_color_evict(), but limited to small portion of the full
2141 	 * drm_mm range.
2142 	 */
2143 
2144 	nodes = vzalloc(array_size(total_size, sizeof(*nodes)));
2145 	KUNIT_ASSERT_TRUE(test, nodes);
2146 
2147 	order = drm_random_order(total_size, &prng);
2148 	if (!order)
2149 		goto err_nodes;
2150 
2151 	drm_mm_init(&mm, 0, 2 * total_size - 1);
2152 	mm.color_adjust = separate_adjacent_colors;
2153 	for (n = 0; n < total_size; n++) {
2154 		if (!expect_insert(test, &mm, &nodes[n].node,
2155 				   1, 0, color++,
2156 				   &insert_modes[0])) {
2157 			KUNIT_FAIL(test, "insert failed, step %d\n", n);
2158 			goto out;
2159 		}
2160 	}
2161 
2162 	for (mode = evict_modes; mode->name; mode++) {
2163 		for (n = 1; n <= range_size; n <<= 1) {
2164 			drm_random_reorder(order, range_size, &prng);
2165 			if (evict_color(test, &mm, range_start, range_end, nodes, order,
2166 					total_size, n, 1, color++, mode)) {
2167 				KUNIT_FAIL(test,
2168 					   "%s evict_color(size=%u) failed for range [%x, %x]\n",
2169 						mode->name, n, range_start, range_end);
2170 				goto out;
2171 			}
2172 		}
2173 
2174 		for (n = 1; n < range_size; n <<= 1) {
2175 			drm_random_reorder(order, total_size, &prng);
2176 			if (evict_color(test, &mm, range_start, range_end, nodes, order,
2177 					total_size, range_size / 2, n, color++, mode)) {
2178 				KUNIT_FAIL(test,
2179 					   "%s evict_color(size=%u, alignment=%u) failed for range [%x, %x]\n",
2180 					   mode->name, total_size / 2, n, range_start, range_end);
2181 				goto out;
2182 			}
2183 		}
2184 
2185 		for_each_prime_number_from(n, 1, min(range_size, max_prime)) {
2186 			unsigned int nsize = (range_size - n + 1) / 2;
2187 
2188 			DRM_MM_BUG_ON(!nsize);
2189 
2190 			drm_random_reorder(order, total_size, &prng);
2191 			if (evict_color(test, &mm, range_start, range_end, nodes, order,
2192 					total_size, nsize, n, color++, mode)) {
2193 				KUNIT_FAIL(test,
2194 					   "%s evict_color(size=%u, alignment=%u) failed for range [%x, %x]\n",
2195 					   mode->name, nsize, n, range_start, range_end);
2196 				goto out;
2197 			}
2198 		}
2199 
2200 		cond_resched();
2201 	}
2202 
2203 out:
2204 	drm_mm_for_each_node_safe(node, next, &mm)
2205 		drm_mm_remove_node(node);
2206 	drm_mm_takedown(&mm);
2207 	kfree(order);
2208 err_nodes:
2209 	vfree(nodes);
2210 }
2211 
2212 static int drm_mm_init_test(struct kunit *test)
2213 {
2214 	while (!random_seed)
2215 		random_seed = get_random_u32();
2216 
2217 	return 0;
2218 }
2219 
2220 module_param(random_seed, uint, 0400);
2221 module_param(max_iterations, uint, 0400);
2222 module_param(max_prime, uint, 0400);
2223 
2224 static struct kunit_case drm_mm_tests[] = {
2225 	KUNIT_CASE(drm_test_mm_init),
2226 	KUNIT_CASE(drm_test_mm_debug),
2227 	KUNIT_CASE(drm_test_mm_reserve),
2228 	KUNIT_CASE(drm_test_mm_insert),
2229 	KUNIT_CASE(drm_test_mm_replace),
2230 	KUNIT_CASE(drm_test_mm_insert_range),
2231 	KUNIT_CASE(drm_test_mm_frag),
2232 	KUNIT_CASE(drm_test_mm_align),
2233 	KUNIT_CASE(drm_test_mm_align32),
2234 	KUNIT_CASE(drm_test_mm_align64),
2235 	KUNIT_CASE(drm_test_mm_evict),
2236 	KUNIT_CASE(drm_test_mm_evict_range),
2237 	KUNIT_CASE(drm_test_mm_topdown),
2238 	KUNIT_CASE(drm_test_mm_bottomup),
2239 	KUNIT_CASE(drm_test_mm_lowest),
2240 	KUNIT_CASE(drm_test_mm_highest),
2241 	KUNIT_CASE(drm_test_mm_color),
2242 	KUNIT_CASE(drm_test_mm_color_evict),
2243 	KUNIT_CASE(drm_test_mm_color_evict_range),
2244 	{}
2245 };
2246 
2247 static struct kunit_suite drm_mm_test_suite = {
2248 	.name = "drm_mm",
2249 	.init = drm_mm_init_test,
2250 	.test_cases = drm_mm_tests,
2251 };
2252 
2253 kunit_test_suite(drm_mm_test_suite);
2254 
2255 MODULE_AUTHOR("Intel Corporation");
2256 MODULE_LICENSE("GPL");
2257