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

source code of linux/drivers/gpu/drm/tests/drm_mm_test.c