1// SPDX-License-Identifier: GPL-2.0 AND MIT
2/*
3 * Copyright © 2023 Intel Corporation
4 */
5#include <linux/shmem_fs.h>
6#include <drm/ttm/ttm_tt.h>
7
8#include "ttm_kunit_helpers.h"
9
10#define BO_SIZE SZ_4K
11
12struct ttm_tt_test_case {
13 const char *description;
14 u32 size;
15 u32 extra_pages_num;
16};
17
18static const struct ttm_tt_test_case ttm_tt_init_basic_cases[] = {
19 {
20 .description = "Page-aligned size",
21 .size = SZ_4K,
22 },
23 {
24 .description = "Extra pages requested",
25 .size = SZ_4K,
26 .extra_pages_num = 1,
27 },
28};
29
30static void ttm_tt_init_case_desc(const struct ttm_tt_test_case *t,
31 char *desc)
32{
33 strscpy(desc, t->description, KUNIT_PARAM_DESC_SIZE);
34}
35
36KUNIT_ARRAY_PARAM(ttm_tt_init_basic, ttm_tt_init_basic_cases,
37 ttm_tt_init_case_desc);
38
39static void ttm_tt_init_basic(struct kunit *test)
40{
41 const struct ttm_tt_test_case *params = test->param_value;
42 struct ttm_buffer_object *bo;
43 struct ttm_tt *tt;
44 u32 page_flags = TTM_TT_FLAG_ZERO_ALLOC;
45 enum ttm_caching caching = ttm_cached;
46 u32 extra_pages = params->extra_pages_num;
47 int num_pages = params->size >> PAGE_SHIFT;
48 int err;
49
50 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
51 KUNIT_ASSERT_NOT_NULL(test, tt);
52
53 bo = ttm_bo_kunit_init(test, devs: test->priv, size: params->size, NULL);
54
55 err = ttm_tt_init(ttm: tt, bo, page_flags, caching, extra_pages);
56 KUNIT_ASSERT_EQ(test, err, 0);
57
58 KUNIT_ASSERT_EQ(test, tt->num_pages, num_pages + extra_pages);
59
60 KUNIT_ASSERT_EQ(test, tt->page_flags, page_flags);
61 KUNIT_ASSERT_EQ(test, tt->caching, caching);
62
63 KUNIT_ASSERT_NULL(test, tt->dma_address);
64 KUNIT_ASSERT_NULL(test, tt->swap_storage);
65}
66
67static void ttm_tt_init_misaligned(struct kunit *test)
68{
69 struct ttm_buffer_object *bo;
70 struct ttm_tt *tt;
71 enum ttm_caching caching = ttm_cached;
72 u32 size = SZ_8K;
73 int num_pages = (size + SZ_4K) >> PAGE_SHIFT;
74 int err;
75
76 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
77 KUNIT_ASSERT_NOT_NULL(test, tt);
78
79 bo = ttm_bo_kunit_init(test, devs: test->priv, size, NULL);
80
81 /* Make the object size misaligned */
82 bo->base.size += 1;
83
84 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching, extra_pages: 0);
85 KUNIT_ASSERT_EQ(test, err, 0);
86
87 KUNIT_ASSERT_EQ(test, tt->num_pages, num_pages);
88}
89
90static void ttm_tt_fini_basic(struct kunit *test)
91{
92 struct ttm_buffer_object *bo;
93 struct ttm_tt *tt;
94 enum ttm_caching caching = ttm_cached;
95 int err;
96
97 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
98 KUNIT_ASSERT_NOT_NULL(test, tt);
99
100 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
101
102 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching, extra_pages: 0);
103 KUNIT_ASSERT_EQ(test, err, 0);
104 KUNIT_ASSERT_NOT_NULL(test, tt->pages);
105
106 ttm_tt_fini(ttm: tt);
107 KUNIT_ASSERT_NULL(test, tt->pages);
108}
109
110static void ttm_tt_fini_sg(struct kunit *test)
111{
112 struct ttm_buffer_object *bo;
113 struct ttm_tt *tt;
114 enum ttm_caching caching = ttm_cached;
115 int err;
116
117 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
118 KUNIT_ASSERT_NOT_NULL(test, tt);
119
120 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
121
122 err = ttm_sg_tt_init(ttm_dma: tt, bo, page_flags: 0, caching);
123 KUNIT_ASSERT_EQ(test, err, 0);
124 KUNIT_ASSERT_NOT_NULL(test, tt->dma_address);
125
126 ttm_tt_fini(ttm: tt);
127 KUNIT_ASSERT_NULL(test, tt->dma_address);
128}
129
130static void ttm_tt_fini_shmem(struct kunit *test)
131{
132 struct ttm_buffer_object *bo;
133 struct ttm_tt *tt;
134 struct file *shmem;
135 enum ttm_caching caching = ttm_cached;
136 int err;
137
138 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
139 KUNIT_ASSERT_NOT_NULL(test, tt);
140
141 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
142
143 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching, extra_pages: 0);
144 KUNIT_ASSERT_EQ(test, err, 0);
145
146 shmem = shmem_file_setup(name: "ttm swap", BO_SIZE, flags: 0);
147 tt->swap_storage = shmem;
148
149 ttm_tt_fini(ttm: tt);
150 KUNIT_ASSERT_NULL(test, tt->swap_storage);
151}
152
153static void ttm_tt_create_basic(struct kunit *test)
154{
155 struct ttm_buffer_object *bo;
156 int err;
157
158 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
159 bo->type = ttm_bo_type_device;
160
161 dma_resv_lock(obj: bo->base.resv, NULL);
162 err = ttm_tt_create(bo, zero_alloc: false);
163 dma_resv_unlock(obj: bo->base.resv);
164
165 KUNIT_EXPECT_EQ(test, err, 0);
166 KUNIT_EXPECT_NOT_NULL(test, bo->ttm);
167
168 /* Free manually, as it was allocated outside of KUnit */
169 kfree(objp: bo->ttm);
170}
171
172static void ttm_tt_create_invalid_bo_type(struct kunit *test)
173{
174 struct ttm_buffer_object *bo;
175 int err;
176
177 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
178 bo->type = ttm_bo_type_sg + 1;
179
180 dma_resv_lock(obj: bo->base.resv, NULL);
181 err = ttm_tt_create(bo, zero_alloc: false);
182 dma_resv_unlock(obj: bo->base.resv);
183
184 KUNIT_EXPECT_EQ(test, err, -EINVAL);
185 KUNIT_EXPECT_NULL(test, bo->ttm);
186}
187
188static void ttm_tt_create_ttm_exists(struct kunit *test)
189{
190 struct ttm_buffer_object *bo;
191 struct ttm_tt *tt;
192 enum ttm_caching caching = ttm_cached;
193 int err;
194
195 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
196 KUNIT_ASSERT_NOT_NULL(test, tt);
197
198 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
199
200 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching, extra_pages: 0);
201 KUNIT_ASSERT_EQ(test, err, 0);
202 bo->ttm = tt;
203
204 dma_resv_lock(obj: bo->base.resv, NULL);
205 err = ttm_tt_create(bo, zero_alloc: false);
206 dma_resv_unlock(obj: bo->base.resv);
207
208 /* Expect to keep the previous TTM */
209 KUNIT_ASSERT_EQ(test, err, 0);
210 KUNIT_ASSERT_PTR_EQ(test, tt, bo->ttm);
211}
212
213static struct ttm_tt *ttm_tt_null_create(struct ttm_buffer_object *bo,
214 u32 page_flags)
215{
216 return NULL;
217}
218
219static struct ttm_device_funcs ttm_dev_empty_funcs = {
220 .ttm_tt_create = ttm_tt_null_create,
221};
222
223static void ttm_tt_create_failed(struct kunit *test)
224{
225 const struct ttm_test_devices *devs = test->priv;
226 struct ttm_buffer_object *bo;
227 int err;
228
229 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
230
231 /* Update ttm_device_funcs so we don't alloc ttm_tt */
232 devs->ttm_dev->funcs = &ttm_dev_empty_funcs;
233
234 dma_resv_lock(obj: bo->base.resv, NULL);
235 err = ttm_tt_create(bo, zero_alloc: false);
236 dma_resv_unlock(obj: bo->base.resv);
237
238 KUNIT_ASSERT_EQ(test, err, -ENOMEM);
239}
240
241static void ttm_tt_destroy_basic(struct kunit *test)
242{
243 const struct ttm_test_devices *devs = test->priv;
244 struct ttm_buffer_object *bo;
245 int err;
246
247 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
248
249 dma_resv_lock(obj: bo->base.resv, NULL);
250 err = ttm_tt_create(bo, zero_alloc: false);
251 dma_resv_unlock(obj: bo->base.resv);
252
253 KUNIT_ASSERT_EQ(test, err, 0);
254 KUNIT_ASSERT_NOT_NULL(test, bo->ttm);
255
256 ttm_tt_destroy(bdev: devs->ttm_dev, ttm: bo->ttm);
257}
258
259static void ttm_tt_populate_null_ttm(struct kunit *test)
260{
261 const struct ttm_test_devices *devs = test->priv;
262 struct ttm_operation_ctx ctx = { };
263 int err;
264
265 err = ttm_tt_populate(bdev: devs->ttm_dev, NULL, ctx: &ctx);
266 KUNIT_ASSERT_EQ(test, err, -EINVAL);
267}
268
269static void ttm_tt_populate_populated_ttm(struct kunit *test)
270{
271 const struct ttm_test_devices *devs = test->priv;
272 struct ttm_operation_ctx ctx = { };
273 struct ttm_buffer_object *bo;
274 struct ttm_tt *tt;
275 struct page *populated_page;
276 int err;
277
278 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
279
280 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
281 KUNIT_ASSERT_NOT_NULL(test, tt);
282
283 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching: ttm_cached, extra_pages: 0);
284 KUNIT_ASSERT_EQ(test, err, 0);
285
286 err = ttm_tt_populate(bdev: devs->ttm_dev, ttm: tt, ctx: &ctx);
287 KUNIT_ASSERT_EQ(test, err, 0);
288 populated_page = *tt->pages;
289
290 err = ttm_tt_populate(bdev: devs->ttm_dev, ttm: tt, ctx: &ctx);
291 KUNIT_ASSERT_PTR_EQ(test, populated_page, *tt->pages);
292}
293
294static void ttm_tt_unpopulate_basic(struct kunit *test)
295{
296 const struct ttm_test_devices *devs = test->priv;
297 struct ttm_operation_ctx ctx = { };
298 struct ttm_buffer_object *bo;
299 struct ttm_tt *tt;
300 int err;
301
302 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
303
304 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
305 KUNIT_ASSERT_NOT_NULL(test, tt);
306
307 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching: ttm_cached, extra_pages: 0);
308 KUNIT_ASSERT_EQ(test, err, 0);
309
310 err = ttm_tt_populate(bdev: devs->ttm_dev, ttm: tt, ctx: &ctx);
311 KUNIT_ASSERT_EQ(test, err, 0);
312 KUNIT_ASSERT_TRUE(test, ttm_tt_is_populated(tt));
313
314 ttm_tt_unpopulate(bdev: devs->ttm_dev, ttm: tt);
315 KUNIT_ASSERT_FALSE(test, ttm_tt_is_populated(tt));
316}
317
318static void ttm_tt_unpopulate_empty_ttm(struct kunit *test)
319{
320 const struct ttm_test_devices *devs = test->priv;
321 struct ttm_buffer_object *bo;
322 struct ttm_tt *tt;
323 int err;
324
325 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
326
327 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
328 KUNIT_ASSERT_NOT_NULL(test, tt);
329
330 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching: ttm_cached, extra_pages: 0);
331 KUNIT_ASSERT_EQ(test, err, 0);
332
333 ttm_tt_unpopulate(bdev: devs->ttm_dev, ttm: tt);
334 /* Expect graceful handling of unpopulated TTs */
335}
336
337static void ttm_tt_swapin_basic(struct kunit *test)
338{
339 const struct ttm_test_devices *devs = test->priv;
340 int expected_num_pages = BO_SIZE >> PAGE_SHIFT;
341 struct ttm_operation_ctx ctx = { };
342 struct ttm_buffer_object *bo;
343 struct ttm_tt *tt;
344 int err, num_pages;
345
346 bo = ttm_bo_kunit_init(test, devs: test->priv, BO_SIZE, NULL);
347
348 tt = kunit_kzalloc(test, size: sizeof(*tt), GFP_KERNEL);
349 KUNIT_ASSERT_NOT_NULL(test, tt);
350
351 err = ttm_tt_init(ttm: tt, bo, page_flags: 0, caching: ttm_cached, extra_pages: 0);
352 KUNIT_ASSERT_EQ(test, err, 0);
353
354 err = ttm_tt_populate(bdev: devs->ttm_dev, ttm: tt, ctx: &ctx);
355 KUNIT_ASSERT_EQ(test, err, 0);
356 KUNIT_ASSERT_TRUE(test, ttm_tt_is_populated(tt));
357
358 num_pages = ttm_tt_swapout(bdev: devs->ttm_dev, ttm: tt, GFP_KERNEL);
359 KUNIT_ASSERT_EQ(test, num_pages, expected_num_pages);
360 KUNIT_ASSERT_NOT_NULL(test, tt->swap_storage);
361 KUNIT_ASSERT_TRUE(test, tt->page_flags & TTM_TT_FLAG_SWAPPED);
362
363 /* Swapout depopulates TT, allocate pages and then swap them in */
364 err = ttm_pool_alloc(pool: &devs->ttm_dev->pool, tt, ctx: &ctx);
365 KUNIT_ASSERT_EQ(test, err, 0);
366
367 err = ttm_tt_swapin(ttm: tt);
368 KUNIT_ASSERT_EQ(test, err, 0);
369 KUNIT_ASSERT_NULL(test, tt->swap_storage);
370 KUNIT_ASSERT_FALSE(test, tt->page_flags & TTM_TT_FLAG_SWAPPED);
371}
372
373static struct kunit_case ttm_tt_test_cases[] = {
374 KUNIT_CASE_PARAM(ttm_tt_init_basic, ttm_tt_init_basic_gen_params),
375 KUNIT_CASE(ttm_tt_init_misaligned),
376 KUNIT_CASE(ttm_tt_fini_basic),
377 KUNIT_CASE(ttm_tt_fini_sg),
378 KUNIT_CASE(ttm_tt_fini_shmem),
379 KUNIT_CASE(ttm_tt_create_basic),
380 KUNIT_CASE(ttm_tt_create_invalid_bo_type),
381 KUNIT_CASE(ttm_tt_create_ttm_exists),
382 KUNIT_CASE(ttm_tt_create_failed),
383 KUNIT_CASE(ttm_tt_destroy_basic),
384 KUNIT_CASE(ttm_tt_populate_null_ttm),
385 KUNIT_CASE(ttm_tt_populate_populated_ttm),
386 KUNIT_CASE(ttm_tt_unpopulate_basic),
387 KUNIT_CASE(ttm_tt_unpopulate_empty_ttm),
388 KUNIT_CASE(ttm_tt_swapin_basic),
389 {}
390};
391
392static struct kunit_suite ttm_tt_test_suite = {
393 .name = "ttm_tt",
394 .init = ttm_test_devices_all_init,
395 .exit = ttm_test_devices_fini,
396 .test_cases = ttm_tt_test_cases,
397};
398
399kunit_test_suites(&ttm_tt_test_suite);
400
401MODULE_DESCRIPTION("KUnit tests for ttm_tt APIs");
402MODULE_LICENSE("GPL and additional rights");
403

source code of linux/drivers/gpu/drm/ttm/tests/ttm_tt_test.c