1 // SPDX-License-Identifier: GPL-2.0 AND MIT
2 /*
3 * Copyright © 2023 Intel Corporation
4 */
5 #include <linux/delay.h>
6 #include <linux/kthread.h>
7
8 #include <drm/ttm/ttm_resource.h>
9 #include <drm/ttm/ttm_placement.h>
10 #include <drm/ttm/ttm_tt.h>
11
12 #include "ttm_kunit_helpers.h"
13 #include "ttm_mock_manager.h"
14
15 #define BO_SIZE SZ_4K
16 #define MANAGER_SIZE SZ_1M
17
18 static struct spinlock fence_lock;
19
20 struct ttm_bo_validate_test_case {
21 const char *description;
22 enum ttm_bo_type bo_type;
23 u32 mem_type;
24 bool with_ttm;
25 bool no_gpu_wait;
26 };
27
ttm_placement_kunit_init(struct kunit * test,struct ttm_place * places,unsigned int num_places)28 static struct ttm_placement *ttm_placement_kunit_init(struct kunit *test,
29 struct ttm_place *places,
30 unsigned int num_places)
31 {
32 struct ttm_placement *placement;
33
34 placement = kunit_kzalloc(test, sizeof(*placement), GFP_KERNEL);
35 KUNIT_ASSERT_NOT_NULL(test, placement);
36
37 placement->num_placement = num_places;
38 placement->placement = places;
39
40 return placement;
41 }
42
fence_name(struct dma_fence * f)43 static const char *fence_name(struct dma_fence *f)
44 {
45 return "ttm-bo-validate-fence";
46 }
47
48 static const struct dma_fence_ops fence_ops = {
49 .get_driver_name = fence_name,
50 .get_timeline_name = fence_name,
51 };
52
alloc_mock_fence(struct kunit * test)53 static struct dma_fence *alloc_mock_fence(struct kunit *test)
54 {
55 struct dma_fence *fence;
56
57 fence = kunit_kzalloc(test, sizeof(*fence), GFP_KERNEL);
58 KUNIT_ASSERT_NOT_NULL(test, fence);
59
60 dma_fence_init(fence, &fence_ops, &fence_lock, 0, 0);
61
62 return fence;
63 }
64
dma_resv_kunit_active_fence_init(struct kunit * test,struct dma_resv * resv,enum dma_resv_usage usage)65 static void dma_resv_kunit_active_fence_init(struct kunit *test,
66 struct dma_resv *resv,
67 enum dma_resv_usage usage)
68 {
69 struct dma_fence *fence;
70
71 fence = alloc_mock_fence(test);
72 dma_fence_enable_sw_signaling(fence);
73
74 dma_resv_lock(resv, NULL);
75 dma_resv_reserve_fences(resv, 1);
76 dma_resv_add_fence(resv, fence, usage);
77 dma_resv_unlock(resv);
78 }
79
ttm_bo_validate_case_desc(const struct ttm_bo_validate_test_case * t,char * desc)80 static void ttm_bo_validate_case_desc(const struct ttm_bo_validate_test_case *t,
81 char *desc)
82 {
83 strscpy(desc, t->description, KUNIT_PARAM_DESC_SIZE);
84 }
85
86 static const struct ttm_bo_validate_test_case ttm_bo_type_cases[] = {
87 {
88 .description = "Buffer object for userspace",
89 .bo_type = ttm_bo_type_device,
90 },
91 {
92 .description = "Kernel buffer object",
93 .bo_type = ttm_bo_type_kernel,
94 },
95 {
96 .description = "Shared buffer object",
97 .bo_type = ttm_bo_type_sg,
98 },
99 };
100
101 KUNIT_ARRAY_PARAM(ttm_bo_types, ttm_bo_type_cases,
102 ttm_bo_validate_case_desc);
103
ttm_bo_init_reserved_sys_man(struct kunit * test)104 static void ttm_bo_init_reserved_sys_man(struct kunit *test)
105 {
106 const struct ttm_bo_validate_test_case *params = test->param_value;
107 struct ttm_test_devices *priv = test->priv;
108 enum ttm_bo_type bo_type = params->bo_type;
109 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
110 struct ttm_operation_ctx ctx = { };
111 struct ttm_placement *placement;
112 struct ttm_buffer_object *bo;
113 struct ttm_place *place;
114 int err;
115
116 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
117 KUNIT_ASSERT_NOT_NULL(test, bo);
118
119 place = ttm_place_kunit_init(test, TTM_PL_SYSTEM, 0);
120 placement = ttm_placement_kunit_init(test, place, 1);
121
122 drm_gem_private_object_init(priv->drm, &bo->base, size);
123
124 err = ttm_bo_init_reserved(priv->ttm_dev, bo, bo_type, placement,
125 PAGE_SIZE, &ctx, NULL, NULL,
126 &dummy_ttm_bo_destroy);
127 dma_resv_unlock(bo->base.resv);
128
129 KUNIT_EXPECT_EQ(test, err, 0);
130 KUNIT_EXPECT_EQ(test, kref_read(&bo->kref), 1);
131 KUNIT_EXPECT_PTR_EQ(test, bo->bdev, priv->ttm_dev);
132 KUNIT_EXPECT_EQ(test, bo->type, bo_type);
133 KUNIT_EXPECT_EQ(test, bo->page_alignment, PAGE_SIZE);
134 KUNIT_EXPECT_PTR_EQ(test, bo->destroy, &dummy_ttm_bo_destroy);
135 KUNIT_EXPECT_EQ(test, bo->pin_count, 0);
136 KUNIT_EXPECT_NULL(test, bo->bulk_move);
137 KUNIT_EXPECT_NOT_NULL(test, bo->ttm);
138 KUNIT_EXPECT_FALSE(test, ttm_tt_is_populated(bo->ttm));
139 KUNIT_EXPECT_NOT_NULL(test, (void *)bo->base.resv->fences);
140 KUNIT_EXPECT_EQ(test, ctx.bytes_moved, size);
141
142 if (bo_type != ttm_bo_type_kernel)
143 KUNIT_EXPECT_TRUE(test,
144 drm_mm_node_allocated(&bo->base.vma_node.vm_node));
145
146 ttm_resource_free(bo, &bo->resource);
147 ttm_bo_fini(bo);
148 }
149
ttm_bo_init_reserved_mock_man(struct kunit * test)150 static void ttm_bo_init_reserved_mock_man(struct kunit *test)
151 {
152 const struct ttm_bo_validate_test_case *params = test->param_value;
153 enum ttm_bo_type bo_type = params->bo_type;
154 struct ttm_test_devices *priv = test->priv;
155 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
156 struct ttm_operation_ctx ctx = { };
157 struct ttm_placement *placement;
158 u32 mem_type = TTM_PL_VRAM;
159 struct ttm_buffer_object *bo;
160 struct ttm_place *place;
161 int err;
162
163 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
164
165 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
166 KUNIT_ASSERT_NOT_NULL(test, bo);
167
168 place = ttm_place_kunit_init(test, mem_type, 0);
169 placement = ttm_placement_kunit_init(test, place, 1);
170
171 drm_gem_private_object_init(priv->drm, &bo->base, size);
172
173 err = ttm_bo_init_reserved(priv->ttm_dev, bo, bo_type, placement,
174 PAGE_SIZE, &ctx, NULL, NULL,
175 &dummy_ttm_bo_destroy);
176 dma_resv_unlock(bo->base.resv);
177
178 KUNIT_EXPECT_EQ(test, err, 0);
179 KUNIT_EXPECT_EQ(test, kref_read(&bo->kref), 1);
180 KUNIT_EXPECT_PTR_EQ(test, bo->bdev, priv->ttm_dev);
181 KUNIT_EXPECT_EQ(test, bo->type, bo_type);
182 KUNIT_EXPECT_EQ(test, ctx.bytes_moved, size);
183
184 if (bo_type != ttm_bo_type_kernel)
185 KUNIT_EXPECT_TRUE(test,
186 drm_mm_node_allocated(&bo->base.vma_node.vm_node));
187
188 ttm_resource_free(bo, &bo->resource);
189 ttm_bo_fini(bo);
190 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
191 }
192
ttm_bo_init_reserved_resv(struct kunit * test)193 static void ttm_bo_init_reserved_resv(struct kunit *test)
194 {
195 enum ttm_bo_type bo_type = ttm_bo_type_device;
196 struct ttm_test_devices *priv = test->priv;
197 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
198 struct ttm_operation_ctx ctx = { };
199 struct ttm_placement *placement;
200 struct ttm_buffer_object *bo;
201 struct ttm_place *place;
202 struct dma_resv resv;
203 int err;
204
205 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
206 KUNIT_ASSERT_NOT_NULL(test, bo);
207
208 place = ttm_place_kunit_init(test, TTM_PL_SYSTEM, 0);
209 placement = ttm_placement_kunit_init(test, place, 1);
210
211 drm_gem_private_object_init(priv->drm, &bo->base, size);
212 dma_resv_init(&resv);
213 dma_resv_lock(&resv, NULL);
214
215 err = ttm_bo_init_reserved(priv->ttm_dev, bo, bo_type, placement,
216 PAGE_SIZE, &ctx, NULL, &resv,
217 &dummy_ttm_bo_destroy);
218 dma_resv_unlock(bo->base.resv);
219
220 KUNIT_EXPECT_EQ(test, err, 0);
221 KUNIT_EXPECT_PTR_EQ(test, bo->base.resv, &resv);
222
223 ttm_resource_free(bo, &bo->resource);
224 ttm_bo_fini(bo);
225 }
226
ttm_bo_validate_basic(struct kunit * test)227 static void ttm_bo_validate_basic(struct kunit *test)
228 {
229 const struct ttm_bo_validate_test_case *params = test->param_value;
230 u32 fst_mem = TTM_PL_SYSTEM, snd_mem = TTM_PL_VRAM;
231 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
232 struct ttm_placement *fst_placement, *snd_placement;
233 struct ttm_test_devices *priv = test->priv;
234 struct ttm_place *fst_place, *snd_place;
235 u32 size = ALIGN(SZ_8K, PAGE_SIZE);
236 struct ttm_buffer_object *bo;
237 int err;
238
239 ttm_mock_manager_init(priv->ttm_dev, snd_mem, MANAGER_SIZE);
240
241 fst_place = ttm_place_kunit_init(test, fst_mem, 0);
242 fst_placement = ttm_placement_kunit_init(test, fst_place, 1);
243
244 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
245 KUNIT_ASSERT_NOT_NULL(test, bo);
246
247 drm_gem_private_object_init(priv->drm, &bo->base, size);
248
249 err = ttm_bo_init_reserved(priv->ttm_dev, bo, params->bo_type,
250 fst_placement, PAGE_SIZE, &ctx_init, NULL,
251 NULL, &dummy_ttm_bo_destroy);
252 KUNIT_EXPECT_EQ(test, err, 0);
253
254 snd_place = ttm_place_kunit_init(test, snd_mem, DRM_BUDDY_TOPDOWN_ALLOCATION);
255 snd_placement = ttm_placement_kunit_init(test, snd_place, 1);
256
257 err = ttm_bo_validate(bo, snd_placement, &ctx_val);
258 dma_resv_unlock(bo->base.resv);
259
260 KUNIT_EXPECT_EQ(test, err, 0);
261 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, bo->base.size);
262 KUNIT_EXPECT_NOT_NULL(test, bo->ttm);
263 KUNIT_EXPECT_TRUE(test, ttm_tt_is_populated(bo->ttm));
264 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, snd_mem);
265 KUNIT_EXPECT_EQ(test, bo->resource->placement,
266 DRM_BUDDY_TOPDOWN_ALLOCATION);
267
268 ttm_bo_fini(bo);
269 ttm_mock_manager_fini(priv->ttm_dev, snd_mem);
270 }
271
ttm_bo_validate_invalid_placement(struct kunit * test)272 static void ttm_bo_validate_invalid_placement(struct kunit *test)
273 {
274 enum ttm_bo_type bo_type = ttm_bo_type_device;
275 u32 unknown_mem_type = TTM_PL_PRIV + 1;
276 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
277 struct ttm_operation_ctx ctx = { };
278 struct ttm_placement *placement;
279 struct ttm_buffer_object *bo;
280 struct ttm_place *place;
281 int err;
282
283 place = ttm_place_kunit_init(test, unknown_mem_type, 0);
284 placement = ttm_placement_kunit_init(test, place, 1);
285
286 bo = ttm_bo_kunit_init(test, test->priv, size, NULL);
287 bo->type = bo_type;
288
289 ttm_bo_reserve(bo, false, false, NULL);
290 err = ttm_bo_validate(bo, placement, &ctx);
291 dma_resv_unlock(bo->base.resv);
292
293 KUNIT_EXPECT_EQ(test, err, -ENOMEM);
294
295 ttm_bo_fini(bo);
296 }
297
ttm_bo_validate_failed_alloc(struct kunit * test)298 static void ttm_bo_validate_failed_alloc(struct kunit *test)
299 {
300 enum ttm_bo_type bo_type = ttm_bo_type_device;
301 struct ttm_test_devices *priv = test->priv;
302 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
303 struct ttm_operation_ctx ctx = { };
304 struct ttm_placement *placement;
305 u32 mem_type = TTM_PL_VRAM;
306 struct ttm_buffer_object *bo;
307 struct ttm_place *place;
308 int err;
309
310 bo = ttm_bo_kunit_init(test, test->priv, size, NULL);
311 bo->type = bo_type;
312
313 ttm_bad_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
314
315 place = ttm_place_kunit_init(test, mem_type, 0);
316 placement = ttm_placement_kunit_init(test, place, 1);
317
318 ttm_bo_reserve(bo, false, false, NULL);
319 err = ttm_bo_validate(bo, placement, &ctx);
320 dma_resv_unlock(bo->base.resv);
321
322 KUNIT_EXPECT_EQ(test, err, -ENOMEM);
323
324 ttm_bo_fini(bo);
325 ttm_bad_manager_fini(priv->ttm_dev, mem_type);
326 }
327
ttm_bo_validate_pinned(struct kunit * test)328 static void ttm_bo_validate_pinned(struct kunit *test)
329 {
330 enum ttm_bo_type bo_type = ttm_bo_type_device;
331 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
332 struct ttm_operation_ctx ctx = { };
333 u32 mem_type = TTM_PL_SYSTEM;
334 struct ttm_placement *placement;
335 struct ttm_buffer_object *bo;
336 struct ttm_place *place;
337 int err;
338
339 place = ttm_place_kunit_init(test, mem_type, 0);
340 placement = ttm_placement_kunit_init(test, place, 1);
341
342 bo = ttm_bo_kunit_init(test, test->priv, size, NULL);
343 bo->type = bo_type;
344
345 ttm_bo_reserve(bo, false, false, NULL);
346 ttm_bo_pin(bo);
347 err = ttm_bo_validate(bo, placement, &ctx);
348 dma_resv_unlock(bo->base.resv);
349
350 KUNIT_EXPECT_EQ(test, err, -EINVAL);
351
352 ttm_bo_reserve(bo, false, false, NULL);
353 ttm_bo_unpin(bo);
354 dma_resv_unlock(bo->base.resv);
355
356 ttm_bo_fini(bo);
357 }
358
359 static const struct ttm_bo_validate_test_case ttm_mem_type_cases[] = {
360 {
361 .description = "System manager",
362 .mem_type = TTM_PL_SYSTEM,
363 },
364 {
365 .description = "VRAM manager",
366 .mem_type = TTM_PL_VRAM,
367 },
368 };
369
370 KUNIT_ARRAY_PARAM(ttm_bo_validate_mem, ttm_mem_type_cases,
371 ttm_bo_validate_case_desc);
372
ttm_bo_validate_same_placement(struct kunit * test)373 static void ttm_bo_validate_same_placement(struct kunit *test)
374 {
375 const struct ttm_bo_validate_test_case *params = test->param_value;
376 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
377 struct ttm_test_devices *priv = test->priv;
378 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
379 struct ttm_placement *placement;
380 struct ttm_buffer_object *bo;
381 struct ttm_place *place;
382 int err;
383
384 place = ttm_place_kunit_init(test, params->mem_type, 0);
385 placement = ttm_placement_kunit_init(test, place, 1);
386
387 if (params->mem_type != TTM_PL_SYSTEM)
388 ttm_mock_manager_init(priv->ttm_dev, params->mem_type, MANAGER_SIZE);
389
390 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
391 KUNIT_ASSERT_NOT_NULL(test, bo);
392
393 drm_gem_private_object_init(priv->drm, &bo->base, size);
394
395 err = ttm_bo_init_reserved(priv->ttm_dev, bo, params->bo_type,
396 placement, PAGE_SIZE, &ctx_init, NULL,
397 NULL, &dummy_ttm_bo_destroy);
398 KUNIT_EXPECT_EQ(test, err, 0);
399
400 err = ttm_bo_validate(bo, placement, &ctx_val);
401 dma_resv_unlock(bo->base.resv);
402
403 KUNIT_EXPECT_EQ(test, err, 0);
404 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, 0);
405
406 ttm_bo_fini(bo);
407
408 if (params->mem_type != TTM_PL_SYSTEM)
409 ttm_mock_manager_fini(priv->ttm_dev, params->mem_type);
410 }
411
ttm_bo_validate_busy_placement(struct kunit * test)412 static void ttm_bo_validate_busy_placement(struct kunit *test)
413 {
414 u32 fst_mem = TTM_PL_VRAM, snd_mem = TTM_PL_VRAM + 1;
415 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
416 struct ttm_placement *placement_init, *placement_val;
417 enum ttm_bo_type bo_type = ttm_bo_type_device;
418 struct ttm_test_devices *priv = test->priv;
419 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
420 struct ttm_place *init_place, places[2];
421 struct ttm_resource_manager *man;
422 struct ttm_buffer_object *bo;
423 int err;
424
425 ttm_bad_manager_init(priv->ttm_dev, fst_mem, MANAGER_SIZE);
426 ttm_mock_manager_init(priv->ttm_dev, snd_mem, MANAGER_SIZE);
427
428 init_place = ttm_place_kunit_init(test, TTM_PL_SYSTEM, 0);
429 placement_init = ttm_placement_kunit_init(test, init_place, 1);
430
431 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
432 KUNIT_ASSERT_NOT_NULL(test, bo);
433
434 drm_gem_private_object_init(priv->drm, &bo->base, size);
435
436 err = ttm_bo_init_reserved(priv->ttm_dev, bo, bo_type, placement_init,
437 PAGE_SIZE, &ctx_init, NULL, NULL,
438 &dummy_ttm_bo_destroy);
439 KUNIT_EXPECT_EQ(test, err, 0);
440
441 places[0] = (struct ttm_place){ .mem_type = fst_mem, .flags = TTM_PL_FLAG_DESIRED };
442 places[1] = (struct ttm_place){ .mem_type = snd_mem, .flags = TTM_PL_FLAG_FALLBACK };
443 placement_val = ttm_placement_kunit_init(test, places, 2);
444
445 err = ttm_bo_validate(bo, placement_val, &ctx_val);
446 dma_resv_unlock(bo->base.resv);
447
448 man = ttm_manager_type(priv->ttm_dev, snd_mem);
449
450 KUNIT_EXPECT_EQ(test, err, 0);
451 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, bo->base.size);
452 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, snd_mem);
453 KUNIT_ASSERT_TRUE(test, list_is_singular(&man->lru[bo->priority]));
454
455 ttm_bo_fini(bo);
456 ttm_bad_manager_fini(priv->ttm_dev, fst_mem);
457 ttm_mock_manager_fini(priv->ttm_dev, snd_mem);
458 }
459
ttm_bo_validate_multihop(struct kunit * test)460 static void ttm_bo_validate_multihop(struct kunit *test)
461 {
462 const struct ttm_bo_validate_test_case *params = test->param_value;
463 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
464 struct ttm_placement *placement_init, *placement_val;
465 u32 fst_mem = TTM_PL_VRAM, tmp_mem = TTM_PL_TT, final_mem = TTM_PL_SYSTEM;
466 struct ttm_test_devices *priv = test->priv;
467 struct ttm_place *fst_place, *final_place;
468 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
469 struct ttm_buffer_object *bo;
470 int err;
471
472 ttm_mock_manager_init(priv->ttm_dev, fst_mem, MANAGER_SIZE);
473 ttm_mock_manager_init(priv->ttm_dev, tmp_mem, MANAGER_SIZE);
474
475 fst_place = ttm_place_kunit_init(test, fst_mem, 0);
476 placement_init = ttm_placement_kunit_init(test, fst_place, 1);
477
478 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
479 KUNIT_ASSERT_NOT_NULL(test, bo);
480
481 drm_gem_private_object_init(priv->drm, &bo->base, size);
482
483 err = ttm_bo_init_reserved(priv->ttm_dev, bo, params->bo_type,
484 placement_init, PAGE_SIZE, &ctx_init, NULL,
485 NULL, &dummy_ttm_bo_destroy);
486 KUNIT_EXPECT_EQ(test, err, 0);
487
488 final_place = ttm_place_kunit_init(test, final_mem, 0);
489 placement_val = ttm_placement_kunit_init(test, final_place, 1);
490
491 err = ttm_bo_validate(bo, placement_val, &ctx_val);
492 dma_resv_unlock(bo->base.resv);
493
494 KUNIT_EXPECT_EQ(test, err, 0);
495 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, size * 2);
496 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, final_mem);
497
498 ttm_bo_fini(bo);
499
500 ttm_mock_manager_fini(priv->ttm_dev, fst_mem);
501 ttm_mock_manager_fini(priv->ttm_dev, tmp_mem);
502 }
503
504 static const struct ttm_bo_validate_test_case ttm_bo_no_placement_cases[] = {
505 {
506 .description = "Buffer object in system domain, no page vector",
507 },
508 {
509 .description = "Buffer object in system domain with an existing page vector",
510 .with_ttm = true,
511 },
512 };
513
514 KUNIT_ARRAY_PARAM(ttm_bo_no_placement, ttm_bo_no_placement_cases,
515 ttm_bo_validate_case_desc);
516
ttm_bo_validate_no_placement_signaled(struct kunit * test)517 static void ttm_bo_validate_no_placement_signaled(struct kunit *test)
518 {
519 const struct ttm_bo_validate_test_case *params = test->param_value;
520 enum ttm_bo_type bo_type = ttm_bo_type_device;
521 struct ttm_test_devices *priv = test->priv;
522 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
523 struct ttm_operation_ctx ctx = { };
524 u32 mem_type = TTM_PL_SYSTEM;
525 struct ttm_resource_manager *man;
526 struct ttm_placement *placement;
527 struct ttm_buffer_object *bo;
528 struct ttm_place *place;
529 struct ttm_tt *old_tt;
530 u32 flags;
531 int err;
532
533 place = ttm_place_kunit_init(test, mem_type, 0);
534 man = ttm_manager_type(priv->ttm_dev, mem_type);
535
536 bo = ttm_bo_kunit_init(test, test->priv, size, NULL);
537 bo->type = bo_type;
538
539 if (params->with_ttm) {
540 old_tt = priv->ttm_dev->funcs->ttm_tt_create(bo, 0);
541 ttm_pool_alloc(&priv->ttm_dev->pool, old_tt, &ctx);
542 bo->ttm = old_tt;
543 }
544
545 placement = kunit_kzalloc(test, sizeof(*placement), GFP_KERNEL);
546 KUNIT_ASSERT_NOT_NULL(test, placement);
547
548 ttm_bo_reserve(bo, false, false, NULL);
549
550 err = ttm_resource_alloc(bo, place, &bo->resource, NULL);
551 KUNIT_EXPECT_EQ(test, err, 0);
552 KUNIT_ASSERT_EQ(test, man->usage, size);
553
554 err = ttm_bo_validate(bo, placement, &ctx);
555 ttm_bo_unreserve(bo);
556
557 KUNIT_EXPECT_EQ(test, err, 0);
558 KUNIT_ASSERT_EQ(test, man->usage, 0);
559 KUNIT_ASSERT_NOT_NULL(test, bo->ttm);
560 KUNIT_EXPECT_EQ(test, ctx.bytes_moved, 0);
561
562 if (params->with_ttm) {
563 flags = bo->ttm->page_flags;
564
565 KUNIT_ASSERT_PTR_EQ(test, bo->ttm, old_tt);
566 KUNIT_ASSERT_FALSE(test, flags & TTM_TT_FLAG_PRIV_POPULATED);
567 KUNIT_ASSERT_TRUE(test, flags & TTM_TT_FLAG_ZERO_ALLOC);
568 }
569
570 ttm_bo_fini(bo);
571 }
572
threaded_dma_resv_signal(void * arg)573 static int threaded_dma_resv_signal(void *arg)
574 {
575 struct ttm_buffer_object *bo = arg;
576 struct dma_resv *resv = bo->base.resv;
577 struct dma_resv_iter cursor;
578 struct dma_fence *fence;
579
580 dma_resv_iter_begin(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP);
581 dma_resv_for_each_fence_unlocked(&cursor, fence) {
582 dma_fence_signal(fence);
583 }
584 dma_resv_iter_end(&cursor);
585
586 return 0;
587 }
588
ttm_bo_validate_no_placement_not_signaled(struct kunit * test)589 static void ttm_bo_validate_no_placement_not_signaled(struct kunit *test)
590 {
591 const struct ttm_bo_validate_test_case *params = test->param_value;
592 enum dma_resv_usage usage = DMA_RESV_USAGE_BOOKKEEP;
593 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
594 struct ttm_operation_ctx ctx = { };
595 u32 mem_type = TTM_PL_SYSTEM;
596 struct ttm_placement *placement;
597 struct ttm_buffer_object *bo;
598 struct task_struct *task;
599 struct ttm_place *place;
600 int err;
601
602 place = ttm_place_kunit_init(test, mem_type, 0);
603
604 bo = ttm_bo_kunit_init(test, test->priv, size, NULL);
605 bo->type = params->bo_type;
606
607 err = ttm_resource_alloc(bo, place, &bo->resource, NULL);
608 KUNIT_EXPECT_EQ(test, err, 0);
609
610 placement = kunit_kzalloc(test, sizeof(*placement), GFP_KERNEL);
611 KUNIT_ASSERT_NOT_NULL(test, placement);
612
613 /* Create an active fence to simulate a non-idle resv object */
614 spin_lock_init(&fence_lock);
615 dma_resv_kunit_active_fence_init(test, bo->base.resv, usage);
616
617 task = kthread_create(threaded_dma_resv_signal, bo, "dma-resv-signal");
618 if (IS_ERR(task))
619 KUNIT_FAIL(test, "Couldn't create dma resv signal task\n");
620
621 wake_up_process(task);
622 ttm_bo_reserve(bo, false, false, NULL);
623 err = ttm_bo_validate(bo, placement, &ctx);
624 ttm_bo_unreserve(bo);
625
626 KUNIT_EXPECT_EQ(test, err, 0);
627 KUNIT_ASSERT_NOT_NULL(test, bo->ttm);
628 KUNIT_ASSERT_NULL(test, bo->resource);
629 KUNIT_ASSERT_NULL(test, bo->bulk_move);
630 KUNIT_EXPECT_EQ(test, ctx.bytes_moved, 0);
631
632 if (bo->type != ttm_bo_type_sg)
633 KUNIT_ASSERT_PTR_EQ(test, bo->base.resv, &bo->base._resv);
634
635 /* Make sure we have an idle object at this point */
636 dma_resv_wait_timeout(bo->base.resv, usage, false, MAX_SCHEDULE_TIMEOUT);
637
638 ttm_bo_fini(bo);
639 }
640
ttm_bo_validate_move_fence_signaled(struct kunit * test)641 static void ttm_bo_validate_move_fence_signaled(struct kunit *test)
642 {
643 enum ttm_bo_type bo_type = ttm_bo_type_device;
644 struct ttm_test_devices *priv = test->priv;
645 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
646 struct ttm_operation_ctx ctx = { };
647 u32 mem_type = TTM_PL_SYSTEM;
648 struct ttm_resource_manager *man;
649 struct ttm_placement *placement;
650 struct ttm_buffer_object *bo;
651 struct ttm_place *place;
652 int err;
653
654 man = ttm_manager_type(priv->ttm_dev, mem_type);
655 man->eviction_fences[0] = dma_fence_get_stub();
656
657 bo = ttm_bo_kunit_init(test, test->priv, size, NULL);
658 bo->type = bo_type;
659
660 place = ttm_place_kunit_init(test, mem_type, 0);
661 placement = ttm_placement_kunit_init(test, place, 1);
662
663 ttm_bo_reserve(bo, false, false, NULL);
664 err = ttm_bo_validate(bo, placement, &ctx);
665 ttm_bo_unreserve(bo);
666
667 KUNIT_EXPECT_EQ(test, err, 0);
668 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, mem_type);
669 KUNIT_EXPECT_EQ(test, ctx.bytes_moved, size);
670
671 ttm_bo_fini(bo);
672 dma_fence_put(man->eviction_fences[0]);
673 }
674
675 static const struct ttm_bo_validate_test_case ttm_bo_validate_wait_cases[] = {
676 {
677 .description = "Waits for GPU",
678 .no_gpu_wait = false,
679 },
680 {
681 .description = "Tries to lock straight away",
682 .no_gpu_wait = true,
683 },
684 };
685
686 KUNIT_ARRAY_PARAM(ttm_bo_validate_wait, ttm_bo_validate_wait_cases,
687 ttm_bo_validate_case_desc);
688
threaded_fence_signal(void * arg)689 static int threaded_fence_signal(void *arg)
690 {
691 struct dma_fence *fence = arg;
692
693 msleep(20);
694
695 return dma_fence_signal(fence);
696 }
697
ttm_bo_validate_move_fence_not_signaled(struct kunit * test)698 static void ttm_bo_validate_move_fence_not_signaled(struct kunit *test)
699 {
700 const struct ttm_bo_validate_test_case *params = test->param_value;
701 struct ttm_operation_ctx ctx_init = { },
702 ctx_val = { .no_wait_gpu = params->no_gpu_wait };
703 u32 fst_mem = TTM_PL_VRAM, snd_mem = TTM_PL_VRAM + 1;
704 struct ttm_placement *placement_init, *placement_val;
705 enum ttm_bo_type bo_type = ttm_bo_type_device;
706 struct ttm_test_devices *priv = test->priv;
707 u32 size = ALIGN(BO_SIZE, PAGE_SIZE);
708 struct ttm_place *init_place, places[2];
709 struct ttm_resource_manager *man;
710 struct ttm_buffer_object *bo;
711 struct task_struct *task;
712 int err;
713
714 init_place = ttm_place_kunit_init(test, TTM_PL_SYSTEM, 0);
715 placement_init = ttm_placement_kunit_init(test, init_place, 1);
716
717 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
718 KUNIT_ASSERT_NOT_NULL(test, bo);
719
720 drm_gem_private_object_init(priv->drm, &bo->base, size);
721
722 err = ttm_bo_init_reserved(priv->ttm_dev, bo, bo_type, placement_init,
723 PAGE_SIZE, &ctx_init, NULL, NULL,
724 &dummy_ttm_bo_destroy);
725 KUNIT_EXPECT_EQ(test, err, 0);
726
727 ttm_mock_manager_init(priv->ttm_dev, fst_mem, MANAGER_SIZE);
728 ttm_mock_manager_init(priv->ttm_dev, snd_mem, MANAGER_SIZE);
729
730 places[0] = (struct ttm_place){ .mem_type = fst_mem, .flags = TTM_PL_FLAG_DESIRED };
731 places[1] = (struct ttm_place){ .mem_type = snd_mem, .flags = TTM_PL_FLAG_FALLBACK };
732 placement_val = ttm_placement_kunit_init(test, places, 2);
733
734 spin_lock_init(&fence_lock);
735 man = ttm_manager_type(priv->ttm_dev, fst_mem);
736 man->eviction_fences[0] = alloc_mock_fence(test);
737
738 task = kthread_create(threaded_fence_signal, man->eviction_fences[0], "move-fence-signal");
739 if (IS_ERR(task))
740 KUNIT_FAIL(test, "Couldn't create move fence signal task\n");
741
742 wake_up_process(task);
743 err = ttm_bo_validate(bo, placement_val, &ctx_val);
744 dma_resv_unlock(bo->base.resv);
745
746 dma_fence_wait_timeout(man->eviction_fences[0], false, MAX_SCHEDULE_TIMEOUT);
747 man->eviction_fences[0] = NULL;
748
749 KUNIT_EXPECT_EQ(test, err, 0);
750 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, size);
751
752 if (params->no_gpu_wait)
753 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, snd_mem);
754 else
755 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, fst_mem);
756
757 ttm_bo_fini(bo);
758 ttm_mock_manager_fini(priv->ttm_dev, fst_mem);
759 ttm_mock_manager_fini(priv->ttm_dev, snd_mem);
760 }
761
ttm_bo_validate_happy_evict(struct kunit * test)762 static void ttm_bo_validate_happy_evict(struct kunit *test)
763 {
764 u32 mem_type = TTM_PL_VRAM, mem_multihop = TTM_PL_TT,
765 mem_type_evict = TTM_PL_SYSTEM;
766 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
767 enum ttm_bo_type bo_type = ttm_bo_type_device;
768 u32 small = SZ_8K, medium = SZ_512K,
769 big = MANAGER_SIZE - (small + medium);
770 u32 bo_sizes[] = { small, medium, big };
771 struct ttm_test_devices *priv = test->priv;
772 struct ttm_buffer_object *bos, *bo_val;
773 struct ttm_placement *placement;
774 struct ttm_place *place;
775 u32 bo_no = 3;
776 int i, err;
777
778 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
779 ttm_mock_manager_init(priv->ttm_dev, mem_multihop, MANAGER_SIZE);
780
781 place = ttm_place_kunit_init(test, mem_type, 0);
782 placement = ttm_placement_kunit_init(test, place, 1);
783
784 bos = kunit_kmalloc_array(test, bo_no, sizeof(*bos), GFP_KERNEL);
785 KUNIT_ASSERT_NOT_NULL(test, bos);
786
787 memset(bos, 0, sizeof(*bos) * bo_no);
788 for (i = 0; i < bo_no; i++) {
789 drm_gem_private_object_init(priv->drm, &bos[i].base, bo_sizes[i]);
790 err = ttm_bo_init_reserved(priv->ttm_dev, &bos[i], bo_type, placement,
791 PAGE_SIZE, &ctx_init, NULL, NULL,
792 &dummy_ttm_bo_destroy);
793 dma_resv_unlock(bos[i].base.resv);
794 }
795
796 bo_val = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL);
797 bo_val->type = bo_type;
798
799 ttm_bo_reserve(bo_val, false, false, NULL);
800 err = ttm_bo_validate(bo_val, placement, &ctx_val);
801 ttm_bo_unreserve(bo_val);
802
803 KUNIT_EXPECT_EQ(test, err, 0);
804 KUNIT_EXPECT_EQ(test, bos[0].resource->mem_type, mem_type_evict);
805 KUNIT_EXPECT_TRUE(test, bos[0].ttm->page_flags & TTM_TT_FLAG_ZERO_ALLOC);
806 KUNIT_EXPECT_TRUE(test, bos[0].ttm->page_flags & TTM_TT_FLAG_PRIV_POPULATED);
807 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, small * 2 + BO_SIZE);
808 KUNIT_EXPECT_EQ(test, bos[1].resource->mem_type, mem_type);
809
810 for (i = 0; i < bo_no; i++)
811 ttm_bo_fini(&bos[i]);
812 ttm_bo_fini(bo_val);
813
814 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
815 ttm_mock_manager_fini(priv->ttm_dev, mem_multihop);
816 }
817
ttm_bo_validate_all_pinned_evict(struct kunit * test)818 static void ttm_bo_validate_all_pinned_evict(struct kunit *test)
819 {
820 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
821 enum ttm_bo_type bo_type = ttm_bo_type_device;
822 struct ttm_buffer_object *bo_big, *bo_small;
823 struct ttm_test_devices *priv = test->priv;
824 struct ttm_placement *placement;
825 u32 mem_type = TTM_PL_VRAM, mem_multihop = TTM_PL_TT;
826 struct ttm_place *place;
827 int err;
828
829 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
830 ttm_mock_manager_init(priv->ttm_dev, mem_multihop, MANAGER_SIZE);
831
832 place = ttm_place_kunit_init(test, mem_type, 0);
833 placement = ttm_placement_kunit_init(test, place, 1);
834
835 bo_big = kunit_kzalloc(test, sizeof(*bo_big), GFP_KERNEL);
836 KUNIT_ASSERT_NOT_NULL(test, bo_big);
837
838 drm_gem_private_object_init(priv->drm, &bo_big->base, MANAGER_SIZE);
839 err = ttm_bo_init_reserved(priv->ttm_dev, bo_big, bo_type, placement,
840 PAGE_SIZE, &ctx_init, NULL, NULL,
841 &dummy_ttm_bo_destroy);
842 KUNIT_EXPECT_EQ(test, err, 0);
843
844 ttm_bo_pin(bo_big);
845 dma_resv_unlock(bo_big->base.resv);
846
847 bo_small = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL);
848 bo_small->type = bo_type;
849
850 ttm_bo_reserve(bo_small, false, false, NULL);
851 err = ttm_bo_validate(bo_small, placement, &ctx_val);
852 ttm_bo_unreserve(bo_small);
853
854 KUNIT_EXPECT_EQ(test, err, -ENOMEM);
855
856 ttm_bo_fini(bo_small);
857
858 ttm_bo_reserve(bo_big, false, false, NULL);
859 ttm_bo_unpin(bo_big);
860 dma_resv_unlock(bo_big->base.resv);
861 ttm_bo_fini(bo_big);
862
863 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
864 ttm_mock_manager_fini(priv->ttm_dev, mem_multihop);
865 }
866
ttm_bo_validate_allowed_only_evict(struct kunit * test)867 static void ttm_bo_validate_allowed_only_evict(struct kunit *test)
868 {
869 u32 mem_type = TTM_PL_VRAM, mem_multihop = TTM_PL_TT,
870 mem_type_evict = TTM_PL_SYSTEM;
871 struct ttm_buffer_object *bo, *bo_evictable, *bo_pinned;
872 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
873 enum ttm_bo_type bo_type = ttm_bo_type_device;
874 struct ttm_test_devices *priv = test->priv;
875 struct ttm_placement *placement;
876 struct ttm_place *place;
877 u32 size = SZ_512K;
878 int err;
879
880 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
881 ttm_mock_manager_init(priv->ttm_dev, mem_multihop, MANAGER_SIZE);
882
883 place = ttm_place_kunit_init(test, mem_type, 0);
884 placement = ttm_placement_kunit_init(test, place, 1);
885
886 bo_pinned = kunit_kzalloc(test, sizeof(*bo_pinned), GFP_KERNEL);
887 KUNIT_ASSERT_NOT_NULL(test, bo_pinned);
888
889 drm_gem_private_object_init(priv->drm, &bo_pinned->base, size);
890 err = ttm_bo_init_reserved(priv->ttm_dev, bo_pinned, bo_type, placement,
891 PAGE_SIZE, &ctx_init, NULL, NULL,
892 &dummy_ttm_bo_destroy);
893 KUNIT_EXPECT_EQ(test, err, 0);
894 ttm_bo_pin(bo_pinned);
895 dma_resv_unlock(bo_pinned->base.resv);
896
897 bo_evictable = kunit_kzalloc(test, sizeof(*bo_evictable), GFP_KERNEL);
898 KUNIT_ASSERT_NOT_NULL(test, bo_evictable);
899
900 drm_gem_private_object_init(priv->drm, &bo_evictable->base, size);
901 err = ttm_bo_init_reserved(priv->ttm_dev, bo_evictable, bo_type, placement,
902 PAGE_SIZE, &ctx_init, NULL, NULL,
903 &dummy_ttm_bo_destroy);
904 KUNIT_EXPECT_EQ(test, err, 0);
905 dma_resv_unlock(bo_evictable->base.resv);
906
907 bo = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL);
908 bo->type = bo_type;
909
910 ttm_bo_reserve(bo, false, false, NULL);
911 err = ttm_bo_validate(bo, placement, &ctx_val);
912 ttm_bo_unreserve(bo);
913
914 KUNIT_EXPECT_EQ(test, err, 0);
915 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, mem_type);
916 KUNIT_EXPECT_EQ(test, bo_pinned->resource->mem_type, mem_type);
917 KUNIT_EXPECT_EQ(test, bo_evictable->resource->mem_type, mem_type_evict);
918 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, size * 2 + BO_SIZE);
919
920 ttm_bo_fini(bo);
921 ttm_bo_fini(bo_evictable);
922
923 ttm_bo_reserve(bo_pinned, false, false, NULL);
924 ttm_bo_unpin(bo_pinned);
925 dma_resv_unlock(bo_pinned->base.resv);
926 ttm_bo_fini(bo_pinned);
927
928 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
929 ttm_mock_manager_fini(priv->ttm_dev, mem_multihop);
930 }
931
ttm_bo_validate_deleted_evict(struct kunit * test)932 static void ttm_bo_validate_deleted_evict(struct kunit *test)
933 {
934 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
935 u32 small = SZ_8K, big = MANAGER_SIZE - BO_SIZE;
936 enum ttm_bo_type bo_type = ttm_bo_type_device;
937 struct ttm_buffer_object *bo_big, *bo_small;
938 struct ttm_test_devices *priv = test->priv;
939 struct ttm_resource_manager *man;
940 u32 mem_type = TTM_PL_VRAM;
941 struct ttm_placement *placement;
942 struct ttm_place *place;
943 int err;
944
945 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
946 man = ttm_manager_type(priv->ttm_dev, mem_type);
947
948 place = ttm_place_kunit_init(test, mem_type, 0);
949 placement = ttm_placement_kunit_init(test, place, 1);
950
951 bo_big = kunit_kzalloc(test, sizeof(*bo_big), GFP_KERNEL);
952 KUNIT_ASSERT_NOT_NULL(test, bo_big);
953
954 drm_gem_private_object_init(priv->drm, &bo_big->base, big);
955 err = ttm_bo_init_reserved(priv->ttm_dev, bo_big, bo_type, placement,
956 PAGE_SIZE, &ctx_init, NULL, NULL,
957 &dummy_ttm_bo_destroy);
958 KUNIT_EXPECT_EQ(test, err, 0);
959 KUNIT_EXPECT_EQ(test, ttm_resource_manager_usage(man), big);
960
961 dma_resv_unlock(bo_big->base.resv);
962 bo_big->deleted = true;
963
964 bo_small = ttm_bo_kunit_init(test, test->priv, small, NULL);
965 bo_small->type = bo_type;
966
967 ttm_bo_reserve(bo_small, false, false, NULL);
968 err = ttm_bo_validate(bo_small, placement, &ctx_val);
969 ttm_bo_unreserve(bo_small);
970
971 KUNIT_EXPECT_EQ(test, err, 0);
972 KUNIT_EXPECT_EQ(test, bo_small->resource->mem_type, mem_type);
973 KUNIT_EXPECT_EQ(test, ttm_resource_manager_usage(man), small);
974 KUNIT_EXPECT_NULL(test, bo_big->ttm);
975 KUNIT_EXPECT_NULL(test, bo_big->resource);
976
977 ttm_bo_fini(bo_small);
978 ttm_bo_fini(bo_big);
979 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
980 }
981
ttm_bo_validate_busy_domain_evict(struct kunit * test)982 static void ttm_bo_validate_busy_domain_evict(struct kunit *test)
983 {
984 u32 mem_type = TTM_PL_VRAM, mem_type_evict = TTM_PL_MOCK1;
985 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
986 enum ttm_bo_type bo_type = ttm_bo_type_device;
987 struct ttm_test_devices *priv = test->priv;
988 struct ttm_buffer_object *bo_init, *bo_val;
989 struct ttm_placement *placement;
990 struct ttm_place *place;
991 int err;
992
993 /*
994 * Drop the default device and setup a new one that points to busy
995 * thus unsuitable eviction domain
996 */
997 ttm_device_fini(priv->ttm_dev);
998
999 err = ttm_device_kunit_init_bad_evict(test->priv, priv->ttm_dev);
1000 KUNIT_ASSERT_EQ(test, err, 0);
1001
1002 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
1003 ttm_busy_manager_init(priv->ttm_dev, mem_type_evict, MANAGER_SIZE);
1004
1005 place = ttm_place_kunit_init(test, mem_type, 0);
1006 placement = ttm_placement_kunit_init(test, place, 1);
1007
1008 bo_init = kunit_kzalloc(test, sizeof(*bo_init), GFP_KERNEL);
1009 KUNIT_ASSERT_NOT_NULL(test, bo_init);
1010
1011 drm_gem_private_object_init(priv->drm, &bo_init->base, MANAGER_SIZE);
1012 err = ttm_bo_init_reserved(priv->ttm_dev, bo_init, bo_type, placement,
1013 PAGE_SIZE, &ctx_init, NULL, NULL,
1014 &dummy_ttm_bo_destroy);
1015 KUNIT_EXPECT_EQ(test, err, 0);
1016 dma_resv_unlock(bo_init->base.resv);
1017
1018 bo_val = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL);
1019 bo_val->type = bo_type;
1020
1021 ttm_bo_reserve(bo_val, false, false, NULL);
1022 err = ttm_bo_validate(bo_val, placement, &ctx_val);
1023 ttm_bo_unreserve(bo_val);
1024
1025 KUNIT_EXPECT_EQ(test, err, -ENOMEM);
1026 KUNIT_EXPECT_EQ(test, bo_init->resource->mem_type, mem_type);
1027 KUNIT_EXPECT_NULL(test, bo_val->resource);
1028
1029 ttm_bo_fini(bo_init);
1030 ttm_bo_fini(bo_val);
1031
1032 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
1033 ttm_bad_manager_fini(priv->ttm_dev, mem_type_evict);
1034 }
1035
ttm_bo_validate_evict_gutting(struct kunit * test)1036 static void ttm_bo_validate_evict_gutting(struct kunit *test)
1037 {
1038 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
1039 enum ttm_bo_type bo_type = ttm_bo_type_device;
1040 struct ttm_test_devices *priv = test->priv;
1041 struct ttm_buffer_object *bo, *bo_evict;
1042 u32 mem_type = TTM_PL_MOCK1;
1043 struct ttm_placement *placement;
1044 struct ttm_place *place;
1045 int err;
1046
1047 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
1048
1049 place = ttm_place_kunit_init(test, mem_type, 0);
1050 placement = ttm_placement_kunit_init(test, place, 1);
1051
1052 bo_evict = kunit_kzalloc(test, sizeof(*bo_evict), GFP_KERNEL);
1053 KUNIT_ASSERT_NOT_NULL(test, bo_evict);
1054
1055 drm_gem_private_object_init(priv->drm, &bo_evict->base, MANAGER_SIZE);
1056 err = ttm_bo_init_reserved(priv->ttm_dev, bo_evict, bo_type, placement,
1057 PAGE_SIZE, &ctx_init, NULL, NULL,
1058 &dummy_ttm_bo_destroy);
1059 KUNIT_EXPECT_EQ(test, err, 0);
1060 dma_resv_unlock(bo_evict->base.resv);
1061
1062 bo = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL);
1063 bo->type = bo_type;
1064
1065 ttm_bo_reserve(bo, false, false, NULL);
1066 err = ttm_bo_validate(bo, placement, &ctx_val);
1067 ttm_bo_unreserve(bo);
1068
1069 KUNIT_EXPECT_EQ(test, err, 0);
1070 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, mem_type);
1071 KUNIT_ASSERT_NULL(test, bo_evict->resource);
1072 KUNIT_ASSERT_TRUE(test, bo_evict->ttm->page_flags & TTM_TT_FLAG_ZERO_ALLOC);
1073
1074 ttm_bo_fini(bo_evict);
1075 ttm_bo_fini(bo);
1076
1077 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
1078 }
1079
ttm_bo_validate_recrusive_evict(struct kunit * test)1080 static void ttm_bo_validate_recrusive_evict(struct kunit *test)
1081 {
1082 u32 mem_type = TTM_PL_TT, mem_type_evict = TTM_PL_MOCK2;
1083 struct ttm_operation_ctx ctx_init = { }, ctx_val = { };
1084 struct ttm_placement *placement_tt, *placement_mock;
1085 struct ttm_buffer_object *bo_tt, *bo_mock, *bo_val;
1086 enum ttm_bo_type bo_type = ttm_bo_type_device;
1087 struct ttm_test_devices *priv = test->priv;
1088 struct ttm_place *place_tt, *place_mock;
1089 int err;
1090
1091 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
1092 ttm_mock_manager_init(priv->ttm_dev, mem_type_evict, MANAGER_SIZE);
1093
1094 place_tt = ttm_place_kunit_init(test, mem_type, 0);
1095 place_mock = ttm_place_kunit_init(test, mem_type_evict, 0);
1096
1097 placement_tt = ttm_placement_kunit_init(test, place_tt, 1);
1098 placement_mock = ttm_placement_kunit_init(test, place_mock, 1);
1099
1100 bo_tt = kunit_kzalloc(test, sizeof(*bo_tt), GFP_KERNEL);
1101 KUNIT_ASSERT_NOT_NULL(test, bo_tt);
1102
1103 bo_mock = kunit_kzalloc(test, sizeof(*bo_mock), GFP_KERNEL);
1104 KUNIT_ASSERT_NOT_NULL(test, bo_mock);
1105
1106 drm_gem_private_object_init(priv->drm, &bo_tt->base, MANAGER_SIZE);
1107 err = ttm_bo_init_reserved(priv->ttm_dev, bo_tt, bo_type, placement_tt,
1108 PAGE_SIZE, &ctx_init, NULL, NULL,
1109 &dummy_ttm_bo_destroy);
1110 KUNIT_EXPECT_EQ(test, err, 0);
1111 dma_resv_unlock(bo_tt->base.resv);
1112
1113 drm_gem_private_object_init(priv->drm, &bo_mock->base, MANAGER_SIZE);
1114 err = ttm_bo_init_reserved(priv->ttm_dev, bo_mock, bo_type, placement_mock,
1115 PAGE_SIZE, &ctx_init, NULL, NULL,
1116 &dummy_ttm_bo_destroy);
1117 KUNIT_EXPECT_EQ(test, err, 0);
1118 dma_resv_unlock(bo_mock->base.resv);
1119
1120 bo_val = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL);
1121 bo_val->type = bo_type;
1122
1123 ttm_bo_reserve(bo_val, false, false, NULL);
1124 err = ttm_bo_validate(bo_val, placement_tt, &ctx_val);
1125 ttm_bo_unreserve(bo_val);
1126
1127 KUNIT_EXPECT_EQ(test, err, 0);
1128
1129 ttm_mock_manager_fini(priv->ttm_dev, mem_type);
1130 ttm_mock_manager_fini(priv->ttm_dev, mem_type_evict);
1131
1132 ttm_bo_fini(bo_val);
1133 ttm_bo_fini(bo_tt);
1134 ttm_bo_fini(bo_mock);
1135 }
1136
1137 static struct kunit_case ttm_bo_validate_test_cases[] = {
1138 KUNIT_CASE_PARAM(ttm_bo_init_reserved_sys_man, ttm_bo_types_gen_params),
1139 KUNIT_CASE_PARAM(ttm_bo_init_reserved_mock_man, ttm_bo_types_gen_params),
1140 KUNIT_CASE(ttm_bo_init_reserved_resv),
1141 KUNIT_CASE_PARAM(ttm_bo_validate_basic, ttm_bo_types_gen_params),
1142 KUNIT_CASE(ttm_bo_validate_invalid_placement),
1143 KUNIT_CASE_PARAM(ttm_bo_validate_same_placement,
1144 ttm_bo_validate_mem_gen_params),
1145 KUNIT_CASE(ttm_bo_validate_failed_alloc),
1146 KUNIT_CASE(ttm_bo_validate_pinned),
1147 KUNIT_CASE(ttm_bo_validate_busy_placement),
1148 KUNIT_CASE_PARAM(ttm_bo_validate_multihop, ttm_bo_types_gen_params),
1149 KUNIT_CASE_PARAM(ttm_bo_validate_no_placement_signaled,
1150 ttm_bo_no_placement_gen_params),
1151 KUNIT_CASE_PARAM(ttm_bo_validate_no_placement_not_signaled,
1152 ttm_bo_types_gen_params),
1153 KUNIT_CASE(ttm_bo_validate_move_fence_signaled),
1154 KUNIT_CASE_PARAM(ttm_bo_validate_move_fence_not_signaled,
1155 ttm_bo_validate_wait_gen_params),
1156 KUNIT_CASE(ttm_bo_validate_happy_evict),
1157 KUNIT_CASE(ttm_bo_validate_all_pinned_evict),
1158 KUNIT_CASE(ttm_bo_validate_allowed_only_evict),
1159 KUNIT_CASE(ttm_bo_validate_deleted_evict),
1160 KUNIT_CASE(ttm_bo_validate_busy_domain_evict),
1161 KUNIT_CASE(ttm_bo_validate_evict_gutting),
1162 KUNIT_CASE(ttm_bo_validate_recrusive_evict),
1163 {}
1164 };
1165
1166 static struct kunit_suite ttm_bo_validate_test_suite = {
1167 .name = "ttm_bo_validate",
1168 .init = ttm_test_devices_all_init,
1169 .exit = ttm_test_devices_fini,
1170 .test_cases = ttm_bo_validate_test_cases,
1171 };
1172
1173 kunit_test_suites(&ttm_bo_validate_test_suite);
1174
1175 MODULE_DESCRIPTION("KUnit tests for ttm_bo APIs");
1176 MODULE_LICENSE("GPL and additional rights");
1177