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