1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * KUnit test suite for GEM objects backed by shmem buffers
4 *
5 * Copyright (C) 2023 Red Hat, Inc.
6 *
7 * Author: Marco Pagani <marpagan@redhat.com>
8 */
9
10 #include <linux/dma-buf.h>
11 #include <linux/iosys-map.h>
12 #include <linux/sizes.h>
13
14 #include <kunit/test.h>
15
16 #include <drm/drm_device.h>
17 #include <drm/drm_drv.h>
18 #include <drm/drm_gem.h>
19 #include <drm/drm_gem_shmem_helper.h>
20 #include <drm/drm_kunit_helpers.h>
21
22 MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
23
24 #define TEST_SIZE SZ_1M
25 #define TEST_BYTE 0xae
26
27 /*
28 * Wrappers to avoid cast warnings when passing action functions
29 * directly to kunit_add_action().
30 */
31 KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfree, const void *);
32
33 KUNIT_DEFINE_ACTION_WRAPPER(sg_free_table_wrapper, sg_free_table,
34 struct sg_table *);
35
36 KUNIT_DEFINE_ACTION_WRAPPER(drm_gem_shmem_free_wrapper, drm_gem_shmem_free,
37 struct drm_gem_shmem_object *);
38
39 KUNIT_DEFINE_ACTION_WRAPPER(drm_gem_shmem_unpin_wrapper, drm_gem_shmem_unpin,
40 struct drm_gem_shmem_object *);
41
42 /*
43 * Test creating a shmem GEM object backed by shmem buffer. The test
44 * case succeeds if the GEM object is successfully allocated with the
45 * shmem file node and object functions attributes set, and the size
46 * attribute is equal to the correct size.
47 */
drm_gem_shmem_test_obj_create(struct kunit * test)48 static void drm_gem_shmem_test_obj_create(struct kunit *test)
49 {
50 struct drm_device *drm_dev = test->priv;
51 struct drm_gem_shmem_object *shmem;
52
53 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
54 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
55 KUNIT_EXPECT_EQ(test, shmem->base.size, TEST_SIZE);
56 KUNIT_EXPECT_NOT_NULL(test, shmem->base.filp);
57 KUNIT_EXPECT_NOT_NULL(test, shmem->base.funcs);
58
59 drm_gem_shmem_free(shmem);
60 }
61
62 /*
63 * Test creating a shmem GEM object from a scatter/gather table exported
64 * via a DMA-BUF. The test case succeed if the GEM object is successfully
65 * created with the shmem file node attribute equal to NULL and the sgt
66 * attribute pointing to the scatter/gather table that has been imported.
67 */
drm_gem_shmem_test_obj_create_private(struct kunit * test)68 static void drm_gem_shmem_test_obj_create_private(struct kunit *test)
69 {
70 struct drm_device *drm_dev = test->priv;
71 struct drm_gem_shmem_object *shmem;
72 struct drm_gem_object *gem_obj;
73 struct dma_buf buf_mock;
74 struct dma_buf_attachment attach_mock;
75 struct sg_table *sgt;
76 char *buf;
77 int ret;
78
79 /* Create a mock scatter/gather table */
80 buf = kunit_kzalloc(test, TEST_SIZE, GFP_KERNEL);
81 KUNIT_ASSERT_NOT_NULL(test, buf);
82
83 sgt = kzalloc_obj(*sgt);
84 KUNIT_ASSERT_NOT_NULL(test, sgt);
85
86 ret = kunit_add_action_or_reset(test, kfree_wrapper, sgt);
87 KUNIT_ASSERT_EQ(test, ret, 0);
88
89 ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
90 KUNIT_ASSERT_EQ(test, ret, 0);
91
92 ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt);
93 KUNIT_ASSERT_EQ(test, ret, 0);
94
95 sg_init_one(sgt->sgl, buf, TEST_SIZE);
96
97 /*
98 * Map the sgtables otherwise drm_gem_shmem_free will cause a warning on
99 * debug kernels.
100 */
101 ret = dma_map_sgtable(drm_dev->dev, sgt, DMA_BIDIRECTIONAL, 0);
102 KUNIT_ASSERT_EQ(test, ret, 0);
103
104 /* Init a mock DMA-BUF */
105 buf_mock.size = TEST_SIZE;
106 attach_mock.dmabuf = &buf_mock;
107
108 gem_obj = drm_gem_shmem_prime_import_sg_table(drm_dev, &attach_mock, sgt);
109 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gem_obj);
110 KUNIT_EXPECT_EQ(test, gem_obj->size, TEST_SIZE);
111 KUNIT_EXPECT_NULL(test, gem_obj->filp);
112 KUNIT_EXPECT_NOT_NULL(test, gem_obj->funcs);
113
114 /* The scatter/gather table will be freed by drm_gem_shmem_free */
115 kunit_remove_action(test, sg_free_table_wrapper, sgt);
116 kunit_remove_action(test, kfree_wrapper, sgt);
117
118 shmem = to_drm_gem_shmem_obj(gem_obj);
119 KUNIT_EXPECT_PTR_EQ(test, shmem->sgt, sgt);
120
121 drm_gem_shmem_free(shmem);
122 }
123
124 /*
125 * Test pinning backing pages for a shmem GEM object. The test case
126 * succeeds if a suitable number of backing pages are allocated, and
127 * the pages table counter attribute is increased by one.
128 */
drm_gem_shmem_test_pin_pages(struct kunit * test)129 static void drm_gem_shmem_test_pin_pages(struct kunit *test)
130 {
131 struct drm_device *drm_dev = test->priv;
132 struct drm_gem_shmem_object *shmem;
133 int i, ret;
134
135 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
136 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
137 KUNIT_EXPECT_NULL(test, shmem->pages);
138 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->pages_use_count), 0);
139
140 ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
141 KUNIT_ASSERT_EQ(test, ret, 0);
142
143 ret = drm_gem_shmem_pin(shmem);
144 KUNIT_ASSERT_EQ(test, ret, 0);
145 KUNIT_ASSERT_NOT_NULL(test, shmem->pages);
146 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->pages_use_count), 1);
147
148 for (i = 0; i < (shmem->base.size >> PAGE_SHIFT); i++)
149 KUNIT_ASSERT_NOT_NULL(test, shmem->pages[i]);
150
151 drm_gem_shmem_unpin(shmem);
152 KUNIT_EXPECT_NULL(test, shmem->pages);
153 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->pages_use_count), 0);
154 }
155
156 /*
157 * Test creating a virtual mapping for a shmem GEM object. The test
158 * case succeeds if the backing memory is mapped and the reference
159 * counter for virtual mapping is increased by one. Moreover, the test
160 * case writes and then reads a test pattern over the mapped memory.
161 */
drm_gem_shmem_test_vmap(struct kunit * test)162 static void drm_gem_shmem_test_vmap(struct kunit *test)
163 {
164 struct drm_device *drm_dev = test->priv;
165 struct drm_gem_shmem_object *shmem;
166 struct iosys_map map;
167 int ret, i;
168
169 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
170 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
171 KUNIT_EXPECT_NULL(test, shmem->vaddr);
172 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->vmap_use_count), 0);
173
174 ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
175 KUNIT_ASSERT_EQ(test, ret, 0);
176
177 ret = drm_gem_shmem_vmap(shmem, &map);
178 KUNIT_ASSERT_EQ(test, ret, 0);
179 KUNIT_ASSERT_NOT_NULL(test, shmem->vaddr);
180 KUNIT_ASSERT_FALSE(test, iosys_map_is_null(&map));
181 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->vmap_use_count), 1);
182
183 iosys_map_memset(&map, 0, TEST_BYTE, TEST_SIZE);
184 for (i = 0; i < TEST_SIZE; i++)
185 KUNIT_EXPECT_EQ(test, iosys_map_rd(&map, i, u8), TEST_BYTE);
186
187 drm_gem_shmem_vunmap(shmem, &map);
188 KUNIT_EXPECT_NULL(test, shmem->vaddr);
189 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->vmap_use_count), 0);
190 }
191
192 /*
193 * Test exporting a scatter/gather table of pinned pages suitable for
194 * PRIME usage from a shmem GEM object. The test case succeeds if a
195 * scatter/gather table large enough to accommodate the backing memory
196 * is successfully exported.
197 */
drm_gem_shmem_test_get_sg_table(struct kunit * test)198 static void drm_gem_shmem_test_get_sg_table(struct kunit *test)
199 {
200 struct drm_device *drm_dev = test->priv;
201 struct drm_gem_shmem_object *shmem;
202 struct sg_table *sgt;
203 struct scatterlist *sg;
204 unsigned int si, len = 0;
205 int ret;
206
207 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
208 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
209
210 ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
211 KUNIT_ASSERT_EQ(test, ret, 0);
212
213 ret = drm_gem_shmem_pin(shmem);
214 KUNIT_ASSERT_EQ(test, ret, 0);
215
216 ret = kunit_add_action_or_reset(test, drm_gem_shmem_unpin_wrapper, shmem);
217 KUNIT_ASSERT_EQ(test, ret, 0);
218
219 sgt = drm_gem_shmem_get_sg_table(shmem);
220 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
221 KUNIT_EXPECT_NULL(test, shmem->sgt);
222
223 ret = kunit_add_action_or_reset(test, kfree_wrapper, sgt);
224 KUNIT_ASSERT_EQ(test, ret, 0);
225
226 ret = kunit_add_action_or_reset(test, sg_free_table_wrapper, sgt);
227 KUNIT_ASSERT_EQ(test, ret, 0);
228
229 for_each_sgtable_sg(sgt, sg, si) {
230 KUNIT_EXPECT_NOT_NULL(test, sg);
231 len += sg->length;
232 }
233
234 KUNIT_EXPECT_GE(test, len, TEST_SIZE);
235 }
236
237 /*
238 * Test pinning pages and exporting a scatter/gather table suitable for
239 * driver usage from a shmem GEM object. The test case succeeds if the
240 * backing pages are pinned and a scatter/gather table large enough to
241 * accommodate the backing memory is successfully exported.
242 */
drm_gem_shmem_test_get_pages_sgt(struct kunit * test)243 static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
244 {
245 struct drm_device *drm_dev = test->priv;
246 struct drm_gem_shmem_object *shmem;
247 struct sg_table *sgt;
248 struct scatterlist *sg;
249 unsigned int si, ret, len = 0;
250
251 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
252 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
253
254 ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
255 KUNIT_ASSERT_EQ(test, ret, 0);
256
257 /* The scatter/gather table will be freed by drm_gem_shmem_free */
258 sgt = drm_gem_shmem_get_pages_sgt(shmem);
259 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
260 KUNIT_ASSERT_NOT_NULL(test, shmem->pages);
261 KUNIT_EXPECT_EQ(test, refcount_read(&shmem->pages_use_count), 1);
262 KUNIT_EXPECT_PTR_EQ(test, sgt, shmem->sgt);
263
264 for_each_sgtable_sg(sgt, sg, si) {
265 KUNIT_EXPECT_NOT_NULL(test, sg);
266 len += sg->length;
267 }
268
269 KUNIT_EXPECT_GE(test, len, TEST_SIZE);
270 }
271
272 /*
273 * Test updating the madvise state of a shmem GEM object. The test
274 * case checks that the function for setting madv updates it only if
275 * its current value is greater or equal than zero and returns false
276 * if it has a negative value.
277 */
drm_gem_shmem_test_madvise(struct kunit * test)278 static void drm_gem_shmem_test_madvise(struct kunit *test)
279 {
280 struct drm_device *drm_dev = test->priv;
281 struct drm_gem_shmem_object *shmem;
282 int ret;
283
284 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
285 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
286 KUNIT_ASSERT_EQ(test, shmem->madv, 0);
287
288 ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
289 KUNIT_ASSERT_EQ(test, ret, 0);
290
291 ret = drm_gem_shmem_madvise(shmem, 1);
292 KUNIT_EXPECT_TRUE(test, ret);
293 KUNIT_ASSERT_EQ(test, shmem->madv, 1);
294
295 /* Set madv to a negative value */
296 ret = drm_gem_shmem_madvise(shmem, -1);
297 KUNIT_EXPECT_FALSE(test, ret);
298 KUNIT_ASSERT_EQ(test, shmem->madv, -1);
299
300 /* Check that madv cannot be set back to a positive value */
301 ret = drm_gem_shmem_madvise(shmem, 0);
302 KUNIT_EXPECT_FALSE(test, ret);
303 KUNIT_ASSERT_EQ(test, shmem->madv, -1);
304 }
305
306 /*
307 * Test purging a shmem GEM object. First, assert that a newly created
308 * shmem GEM object is not purgeable. Then, set madvise to a positive
309 * value and call drm_gem_shmem_get_pages_sgt() to pin and dma-map the
310 * backing pages. Finally, assert that the shmem GEM object is now
311 * purgeable and purge it.
312 */
drm_gem_shmem_test_purge(struct kunit * test)313 static void drm_gem_shmem_test_purge(struct kunit *test)
314 {
315 struct drm_device *drm_dev = test->priv;
316 struct drm_gem_shmem_object *shmem;
317 struct sg_table *sgt;
318 int ret;
319
320 shmem = drm_gem_shmem_create(drm_dev, TEST_SIZE);
321 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, shmem);
322
323 ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
324 KUNIT_ASSERT_EQ(test, ret, 0);
325
326 ret = drm_gem_shmem_is_purgeable(shmem);
327 KUNIT_EXPECT_FALSE(test, ret);
328
329 ret = drm_gem_shmem_madvise(shmem, 1);
330 KUNIT_EXPECT_TRUE(test, ret);
331
332 /* The scatter/gather table will be freed by drm_gem_shmem_free */
333 sgt = drm_gem_shmem_get_pages_sgt(shmem);
334 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
335
336 ret = drm_gem_shmem_is_purgeable(shmem);
337 KUNIT_EXPECT_TRUE(test, ret);
338
339 ret = drm_gem_shmem_purge(shmem);
340 KUNIT_ASSERT_EQ(test, ret, 0);
341
342 KUNIT_EXPECT_NULL(test, shmem->pages);
343 KUNIT_EXPECT_NULL(test, shmem->sgt);
344 KUNIT_EXPECT_EQ(test, shmem->madv, -1);
345 }
346
drm_gem_shmem_test_init(struct kunit * test)347 static int drm_gem_shmem_test_init(struct kunit *test)
348 {
349 struct device *dev;
350 struct drm_device *drm_dev;
351 int ret;
352
353 /* Allocate a parent device */
354 dev = drm_kunit_helper_alloc_device(test);
355 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
356
357 /*
358 * Set the DMA mask to 64-bits to avoid intermittent failures calling
359 * drm_gem_shmem_get_pages_sgt().
360 */
361 ret = dma_set_mask(dev, DMA_BIT_MASK(64));
362 KUNIT_ASSERT_EQ(test, ret, 0);
363
364 /*
365 * The DRM core will automatically initialize the GEM core and create
366 * a DRM Memory Manager object which provides an address space pool
367 * for GEM objects allocation.
368 */
369 drm_dev = __drm_kunit_helper_alloc_drm_device(test, dev, sizeof(*drm_dev),
370 0, DRIVER_GEM);
371 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, drm_dev);
372
373 test->priv = drm_dev;
374
375 return 0;
376 }
377
378 static struct kunit_case drm_gem_shmem_test_cases[] = {
379 KUNIT_CASE(drm_gem_shmem_test_obj_create),
380 KUNIT_CASE(drm_gem_shmem_test_obj_create_private),
381 KUNIT_CASE(drm_gem_shmem_test_pin_pages),
382 KUNIT_CASE(drm_gem_shmem_test_vmap),
383 KUNIT_CASE(drm_gem_shmem_test_get_sg_table),
384 KUNIT_CASE(drm_gem_shmem_test_get_pages_sgt),
385 KUNIT_CASE(drm_gem_shmem_test_madvise),
386 KUNIT_CASE(drm_gem_shmem_test_purge),
387 {}
388 };
389
390 static struct kunit_suite drm_gem_shmem_suite = {
391 .name = "drm_gem_shmem",
392 .init = drm_gem_shmem_test_init,
393 .test_cases = drm_gem_shmem_test_cases
394 };
395
396 kunit_test_suite(drm_gem_shmem_suite);
397
398 MODULE_DESCRIPTION("KUnit test suite for GEM objects backed by shmem buffers");
399 MODULE_LICENSE("GPL");
400