xref: /linux/drivers/gpu/drm/tests/drm_mm_test.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
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 enum {
21 	BEST,
22 	BOTTOMUP,
23 	TOPDOWN,
24 	EVICT,
25 };
26 
27 static const struct insert_mode {
28 	const char *name;
29 	enum drm_mm_insert_mode mode;
30 } insert_modes[] = {
31 	[BEST] = { "best", DRM_MM_INSERT_BEST },
32 	[BOTTOMUP] = { "bottom-up", DRM_MM_INSERT_LOW },
33 	[TOPDOWN] = { "top-down", DRM_MM_INSERT_HIGH },
34 	[EVICT] = { "evict", DRM_MM_INSERT_EVICT },
35 	{}
36 };
37 
assert_no_holes(struct kunit * test,const struct drm_mm * mm)38 static bool assert_no_holes(struct kunit *test, const struct drm_mm *mm)
39 {
40 	struct drm_mm_node *hole;
41 	u64 hole_start, __always_unused hole_end;
42 	unsigned long count;
43 
44 	count = 0;
45 	drm_mm_for_each_hole(hole, mm, hole_start, hole_end)
46 		count++;
47 	if (count) {
48 		KUNIT_FAIL(test,
49 			   "Expected to find no holes (after reserve), found %lu instead\n", count);
50 		return false;
51 	}
52 
53 	drm_mm_for_each_node(hole, mm) {
54 		if (drm_mm_hole_follows(hole)) {
55 			KUNIT_FAIL(test, "Hole follows node, expected none!\n");
56 			return false;
57 		}
58 	}
59 
60 	return true;
61 }
62 
assert_one_hole(struct kunit * test,const struct drm_mm * mm,u64 start,u64 end)63 static bool assert_one_hole(struct kunit *test, const struct drm_mm *mm, u64 start, u64 end)
64 {
65 	struct drm_mm_node *hole;
66 	u64 hole_start, hole_end;
67 	unsigned long count;
68 	bool ok = true;
69 
70 	if (end <= start)
71 		return true;
72 
73 	count = 0;
74 	drm_mm_for_each_hole(hole, mm, hole_start, hole_end) {
75 		if (start != hole_start || end != hole_end) {
76 			if (ok)
77 				KUNIT_FAIL(test,
78 					   "empty mm has incorrect hole, found (%llx, %llx), expect (%llx, %llx)\n",
79 					   hole_start, hole_end, start, end);
80 			ok = false;
81 		}
82 		count++;
83 	}
84 	if (count != 1) {
85 		KUNIT_FAIL(test, "Expected to find one hole, found %lu instead\n", count);
86 		ok = false;
87 	}
88 
89 	return ok;
90 }
91 
misalignment(struct drm_mm_node * node,u64 alignment)92 static u64 misalignment(struct drm_mm_node *node, u64 alignment)
93 {
94 	u64 rem;
95 
96 	if (!alignment)
97 		return 0;
98 
99 	div64_u64_rem(node->start, alignment, &rem);
100 	return rem;
101 }
102 
assert_node(struct kunit * test,struct drm_mm_node * node,struct drm_mm * mm,u64 size,u64 alignment,unsigned long color)103 static bool assert_node(struct kunit *test, struct drm_mm_node *node, struct drm_mm *mm,
104 			u64 size, u64 alignment, unsigned long color)
105 {
106 	bool ok = true;
107 
108 	if (!drm_mm_node_allocated(node) || node->mm != mm) {
109 		KUNIT_FAIL(test, "node not allocated\n");
110 		ok = false;
111 	}
112 
113 	if (node->size != size) {
114 		KUNIT_FAIL(test, "node has wrong size, found %llu, expected %llu\n",
115 			   node->size, size);
116 		ok = false;
117 	}
118 
119 	if (misalignment(node, alignment)) {
120 		KUNIT_FAIL(test,
121 			   "node is misaligned, start %llx rem %llu, expected alignment %llu\n",
122 			   node->start, misalignment(node, alignment), alignment);
123 		ok = false;
124 	}
125 
126 	if (node->color != color) {
127 		KUNIT_FAIL(test, "node has wrong color, found %lu, expected %lu\n",
128 			   node->color, color);
129 		ok = false;
130 	}
131 
132 	return ok;
133 }
134 
drm_test_mm_init(struct kunit * test)135 static void drm_test_mm_init(struct kunit *test)
136 {
137 	const unsigned int size = 4096;
138 	struct drm_mm mm;
139 	struct drm_mm_node tmp;
140 
141 	/* Start with some simple checks on initialising the struct drm_mm */
142 	memset(&mm, 0, sizeof(mm));
143 	KUNIT_ASSERT_FALSE_MSG(test, drm_mm_initialized(&mm),
144 			       "zeroed mm claims to be initialized\n");
145 
146 	memset(&mm, 0xff, sizeof(mm));
147 	drm_mm_init(&mm, 0, size);
148 	if (!drm_mm_initialized(&mm)) {
149 		KUNIT_FAIL(test, "mm claims not to be initialized\n");
150 		goto out;
151 	}
152 
153 	if (!drm_mm_clean(&mm)) {
154 		KUNIT_FAIL(test, "mm not empty on creation\n");
155 		goto out;
156 	}
157 
158 	/* After creation, it should all be one massive hole */
159 	if (!assert_one_hole(test, &mm, 0, size)) {
160 		KUNIT_FAIL(test, "mm not one hole on creation");
161 		goto out;
162 	}
163 
164 	memset(&tmp, 0, sizeof(tmp));
165 	tmp.start = 0;
166 	tmp.size = size;
167 	if (drm_mm_reserve_node(&mm, &tmp)) {
168 		KUNIT_FAIL(test, "failed to reserve whole drm_mm\n");
169 		goto out;
170 	}
171 
172 	/* After filling the range entirely, there should be no holes */
173 	if (!assert_no_holes(test, &mm)) {
174 		KUNIT_FAIL(test, "mm has holes when filled");
175 		goto out;
176 	}
177 
178 	/* And then after emptying it again, the massive hole should be back */
179 	drm_mm_remove_node(&tmp);
180 	if (!assert_one_hole(test, &mm, 0, size)) {
181 		KUNIT_FAIL(test, "mm does not have single hole after emptying");
182 		goto out;
183 	}
184 
185 out:
186 	drm_mm_takedown(&mm);
187 }
188 
drm_test_mm_debug(struct kunit * test)189 static void drm_test_mm_debug(struct kunit *test)
190 {
191 	struct drm_printer p = drm_dbg_printer(NULL, DRM_UT_CORE, test->name);
192 	struct drm_mm mm;
193 	struct drm_mm_node nodes[2];
194 
195 	/* Create a small drm_mm with a couple of nodes and a few holes, and
196 	 * check that the debug iterator doesn't explode over a trivial drm_mm.
197 	 */
198 	drm_mm_init(&mm, 0, 4096);
199 
200 	memset(nodes, 0, sizeof(nodes));
201 	nodes[0].start = 512;
202 	nodes[0].size = 1024;
203 	KUNIT_ASSERT_FALSE_MSG(test, drm_mm_reserve_node(&mm, &nodes[0]),
204 			       "failed to reserve node[0] {start=%lld, size=%lld)\n",
205 			       nodes[0].start, nodes[0].size);
206 
207 	nodes[1].size = 1024;
208 	nodes[1].start = 4096 - 512 - nodes[1].size;
209 	KUNIT_ASSERT_FALSE_MSG(test, drm_mm_reserve_node(&mm, &nodes[1]),
210 			       "failed to reserve node[0] {start=%lld, size=%lld)\n",
211 			       nodes[0].start, nodes[0].size);
212 
213 	drm_mm_print(&mm, &p);
214 	KUNIT_SUCCEED(test);
215 }
216 
expect_insert(struct kunit * test,struct drm_mm * mm,struct drm_mm_node * node,u64 size,u64 alignment,unsigned long color,const struct insert_mode * mode)217 static bool expect_insert(struct kunit *test, struct drm_mm *mm,
218 			  struct drm_mm_node *node, u64 size, u64 alignment, unsigned long color,
219 			const struct insert_mode *mode)
220 {
221 	int err;
222 
223 	err = drm_mm_insert_node_generic(mm, node,
224 					 size, alignment, color,
225 					 mode->mode);
226 	if (err) {
227 		KUNIT_FAIL(test,
228 			   "insert (size=%llu, alignment=%llu, color=%lu, mode=%s) failed with err=%d\n",
229 			   size, alignment, color, mode->name, err);
230 		return false;
231 	}
232 
233 	if (!assert_node(test, node, mm, size, alignment, color)) {
234 		drm_mm_remove_node(node);
235 		return false;
236 	}
237 
238 	return true;
239 }
240 
drm_test_mm_align_pot(struct kunit * test,int max)241 static void drm_test_mm_align_pot(struct kunit *test, int max)
242 {
243 	struct drm_mm mm;
244 	struct drm_mm_node *node, *next;
245 	int bit;
246 
247 	/* Check that we can align to the full u64 address space */
248 
249 	drm_mm_init(&mm, 1, U64_MAX - 2);
250 
251 	for (bit = max - 1; bit; bit--) {
252 		u64 align, size;
253 
254 		node = kzalloc(sizeof(*node), GFP_KERNEL);
255 		if (!node) {
256 			KUNIT_FAIL(test, "failed to allocate node");
257 			goto out;
258 		}
259 
260 		align = BIT_ULL(bit);
261 		size = BIT_ULL(bit - 1) + 1;
262 		if (!expect_insert(test, &mm, node, size, align, bit, &insert_modes[0])) {
263 			KUNIT_FAIL(test, "insert failed with alignment=%llx [%d]", align, bit);
264 			goto out;
265 		}
266 
267 		cond_resched();
268 	}
269 
270 out:
271 	drm_mm_for_each_node_safe(node, next, &mm) {
272 		drm_mm_remove_node(node);
273 		kfree(node);
274 	}
275 	drm_mm_takedown(&mm);
276 }
277 
drm_test_mm_align32(struct kunit * test)278 static void drm_test_mm_align32(struct kunit *test)
279 {
280 	drm_test_mm_align_pot(test, 32);
281 }
282 
drm_test_mm_align64(struct kunit * test)283 static void drm_test_mm_align64(struct kunit *test)
284 {
285 	drm_test_mm_align_pot(test, 64);
286 }
287 
drm_test_mm_once(struct kunit * test,unsigned int mode)288 static void drm_test_mm_once(struct kunit *test, unsigned int mode)
289 {
290 	struct drm_mm mm;
291 	struct drm_mm_node rsvd_lo, rsvd_hi, node;
292 
293 	drm_mm_init(&mm, 0, 7);
294 
295 	memset(&rsvd_lo, 0, sizeof(rsvd_lo));
296 	rsvd_lo.start = 1;
297 	rsvd_lo.size = 1;
298 	if (drm_mm_reserve_node(&mm, &rsvd_lo)) {
299 		KUNIT_FAIL(test, "Could not reserve low node\n");
300 		goto err;
301 	}
302 
303 	memset(&rsvd_hi, 0, sizeof(rsvd_hi));
304 	rsvd_hi.start = 5;
305 	rsvd_hi.size = 1;
306 	if (drm_mm_reserve_node(&mm, &rsvd_hi)) {
307 		KUNIT_FAIL(test, "Could not reserve low node\n");
308 		goto err_lo;
309 	}
310 
311 	if (!drm_mm_hole_follows(&rsvd_lo) || !drm_mm_hole_follows(&rsvd_hi)) {
312 		KUNIT_FAIL(test, "Expected a hole after lo and high nodes!\n");
313 		goto err_hi;
314 	}
315 
316 	memset(&node, 0, sizeof(node));
317 	if (drm_mm_insert_node_generic(&mm, &node, 2, 0, 0, mode)) {
318 		KUNIT_FAIL(test, "Could not insert the node into the available hole!\n");
319 		goto err_hi;
320 	}
321 
322 	drm_mm_remove_node(&node);
323 err_hi:
324 	drm_mm_remove_node(&rsvd_hi);
325 err_lo:
326 	drm_mm_remove_node(&rsvd_lo);
327 err:
328 	drm_mm_takedown(&mm);
329 }
330 
drm_test_mm_lowest(struct kunit * test)331 static void drm_test_mm_lowest(struct kunit *test)
332 {
333 	drm_test_mm_once(test, DRM_MM_INSERT_LOW);
334 }
335 
drm_test_mm_highest(struct kunit * test)336 static void drm_test_mm_highest(struct kunit *test)
337 {
338 	drm_test_mm_once(test, DRM_MM_INSERT_HIGH);
339 }
340 
341 static struct kunit_case drm_mm_tests[] = {
342 	KUNIT_CASE(drm_test_mm_init),
343 	KUNIT_CASE(drm_test_mm_debug),
344 	KUNIT_CASE(drm_test_mm_align32),
345 	KUNIT_CASE(drm_test_mm_align64),
346 	KUNIT_CASE(drm_test_mm_lowest),
347 	KUNIT_CASE(drm_test_mm_highest),
348 	{}
349 };
350 
351 static struct kunit_suite drm_mm_test_suite = {
352 	.name = "drm_mm",
353 	.test_cases = drm_mm_tests,
354 };
355 
356 kunit_test_suite(drm_mm_test_suite);
357 
358 MODULE_AUTHOR("Intel Corporation");
359 MODULE_DESCRIPTION("Test cases for the drm_mm range manager");
360 MODULE_LICENSE("GPL");
361