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 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 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 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 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 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 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 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 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 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, GPU_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 GPU_BUDDY_TOPDOWN_ALLOCATION); 267 268 ttm_bo_fini(bo); 269 ttm_mock_manager_fini(priv->ttm_dev, snd_mem); 270 } 271 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 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 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 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 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 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 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 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 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 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 689 static int threaded_fence_signal(void *arg) 690 { 691 struct dma_fence *fence = arg; 692 693 msleep(20); 694 695 return dma_fence_check_and_signal(fence) ? -EINVAL : 0; 696 } 697 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 762 static void ttm_bo_validate_swapout(struct kunit *test) 763 { 764 u32 mem_type = TTM_PL_TT; 765 struct ttm_test_devices *priv = test->priv; 766 struct ttm_operation_ctx ctx_init = { }; 767 enum ttm_bo_type bo_type = ttm_bo_type_device; 768 struct ttm_resource_manager *man; 769 struct ttm_placement *placement; 770 struct ttm_buffer_object *bo; 771 struct ttm_place *place; 772 int err; 773 s64 swapped; 774 775 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 776 man = ttm_manager_type(priv->ttm_dev, mem_type); 777 KUNIT_ASSERT_NOT_NULL(test, man); 778 779 place = ttm_place_kunit_init(test, mem_type, 0); 780 placement = ttm_placement_kunit_init(test, place, 1); 781 782 bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL); 783 KUNIT_ASSERT_NOT_NULL(test, bo); 784 785 drm_gem_private_object_init(priv->drm, &bo->base, MANAGER_SIZE); 786 err = ttm_bo_init_reserved(priv->ttm_dev, bo, bo_type, placement, 787 PAGE_SIZE, &ctx_init, NULL, NULL, 788 &dummy_ttm_bo_destroy); 789 KUNIT_EXPECT_EQ(test, err, 0); 790 dma_resv_unlock(bo->base.resv); 791 792 swapped = ttm_bo_swapout(priv->ttm_dev, &ctx_init, man, GFP_KERNEL, 793 MANAGER_SIZE / PAGE_SIZE); 794 KUNIT_EXPECT_EQ(test, swapped, MANAGER_SIZE / PAGE_SIZE); 795 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, TTM_PL_SYSTEM); 796 KUNIT_EXPECT_TRUE(test, bo->ttm->page_flags & TTM_TT_FLAG_SWAPPED); 797 798 ttm_bo_fini(bo); 799 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 800 } 801 802 static void ttm_bo_validate_happy_evict(struct kunit *test) 803 { 804 u32 mem_type = TTM_PL_VRAM, mem_multihop = TTM_PL_TT, 805 mem_type_evict = TTM_PL_SYSTEM; 806 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 807 enum ttm_bo_type bo_type = ttm_bo_type_device; 808 u32 small = SZ_8K, medium = SZ_512K, 809 big = MANAGER_SIZE - (small + medium); 810 u32 bo_sizes[] = { small, medium, big }; 811 struct ttm_test_devices *priv = test->priv; 812 struct ttm_buffer_object *bos, *bo_val; 813 struct ttm_placement *placement; 814 struct ttm_place *place; 815 u32 bo_no = 3; 816 int i, err; 817 818 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 819 ttm_mock_manager_init(priv->ttm_dev, mem_multihop, MANAGER_SIZE); 820 821 place = ttm_place_kunit_init(test, mem_type, 0); 822 placement = ttm_placement_kunit_init(test, place, 1); 823 824 bos = kunit_kmalloc_array(test, bo_no, sizeof(*bos), GFP_KERNEL); 825 KUNIT_ASSERT_NOT_NULL(test, bos); 826 827 memset(bos, 0, sizeof(*bos) * bo_no); 828 for (i = 0; i < bo_no; i++) { 829 drm_gem_private_object_init(priv->drm, &bos[i].base, bo_sizes[i]); 830 err = ttm_bo_init_reserved(priv->ttm_dev, &bos[i], bo_type, placement, 831 PAGE_SIZE, &ctx_init, NULL, NULL, 832 &dummy_ttm_bo_destroy); 833 dma_resv_unlock(bos[i].base.resv); 834 } 835 836 bo_val = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL); 837 bo_val->type = bo_type; 838 839 ttm_bo_reserve(bo_val, false, false, NULL); 840 err = ttm_bo_validate(bo_val, placement, &ctx_val); 841 ttm_bo_unreserve(bo_val); 842 843 KUNIT_EXPECT_EQ(test, err, 0); 844 KUNIT_EXPECT_EQ(test, bos[0].resource->mem_type, mem_type_evict); 845 KUNIT_EXPECT_TRUE(test, bos[0].ttm->page_flags & TTM_TT_FLAG_ZERO_ALLOC); 846 KUNIT_EXPECT_TRUE(test, bos[0].ttm->page_flags & TTM_TT_FLAG_PRIV_POPULATED); 847 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, small * 2 + BO_SIZE); 848 KUNIT_EXPECT_EQ(test, bos[1].resource->mem_type, mem_type); 849 850 for (i = 0; i < bo_no; i++) 851 ttm_bo_fini(&bos[i]); 852 ttm_bo_fini(bo_val); 853 854 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 855 ttm_mock_manager_fini(priv->ttm_dev, mem_multihop); 856 } 857 858 static void ttm_bo_validate_all_pinned_evict(struct kunit *test) 859 { 860 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 861 enum ttm_bo_type bo_type = ttm_bo_type_device; 862 struct ttm_buffer_object *bo_big, *bo_small; 863 struct ttm_test_devices *priv = test->priv; 864 struct ttm_placement *placement; 865 u32 mem_type = TTM_PL_VRAM, mem_multihop = TTM_PL_TT; 866 struct ttm_place *place; 867 int err; 868 869 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 870 ttm_mock_manager_init(priv->ttm_dev, mem_multihop, MANAGER_SIZE); 871 872 place = ttm_place_kunit_init(test, mem_type, 0); 873 placement = ttm_placement_kunit_init(test, place, 1); 874 875 bo_big = kunit_kzalloc(test, sizeof(*bo_big), GFP_KERNEL); 876 KUNIT_ASSERT_NOT_NULL(test, bo_big); 877 878 drm_gem_private_object_init(priv->drm, &bo_big->base, MANAGER_SIZE); 879 err = ttm_bo_init_reserved(priv->ttm_dev, bo_big, bo_type, placement, 880 PAGE_SIZE, &ctx_init, NULL, NULL, 881 &dummy_ttm_bo_destroy); 882 KUNIT_EXPECT_EQ(test, err, 0); 883 884 ttm_bo_pin(bo_big); 885 dma_resv_unlock(bo_big->base.resv); 886 887 bo_small = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL); 888 bo_small->type = bo_type; 889 890 ttm_bo_reserve(bo_small, false, false, NULL); 891 err = ttm_bo_validate(bo_small, placement, &ctx_val); 892 ttm_bo_unreserve(bo_small); 893 894 KUNIT_EXPECT_EQ(test, err, -ENOMEM); 895 896 ttm_bo_fini(bo_small); 897 898 ttm_bo_reserve(bo_big, false, false, NULL); 899 ttm_bo_unpin(bo_big); 900 dma_resv_unlock(bo_big->base.resv); 901 ttm_bo_fini(bo_big); 902 903 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 904 ttm_mock_manager_fini(priv->ttm_dev, mem_multihop); 905 } 906 907 static void ttm_bo_validate_allowed_only_evict(struct kunit *test) 908 { 909 u32 mem_type = TTM_PL_VRAM, mem_multihop = TTM_PL_TT, 910 mem_type_evict = TTM_PL_SYSTEM; 911 struct ttm_buffer_object *bo, *bo_evictable, *bo_pinned; 912 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 913 enum ttm_bo_type bo_type = ttm_bo_type_device; 914 struct ttm_test_devices *priv = test->priv; 915 struct ttm_placement *placement; 916 struct ttm_place *place; 917 u32 size = SZ_512K; 918 int err; 919 920 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 921 ttm_mock_manager_init(priv->ttm_dev, mem_multihop, MANAGER_SIZE); 922 923 place = ttm_place_kunit_init(test, mem_type, 0); 924 placement = ttm_placement_kunit_init(test, place, 1); 925 926 bo_pinned = kunit_kzalloc(test, sizeof(*bo_pinned), GFP_KERNEL); 927 KUNIT_ASSERT_NOT_NULL(test, bo_pinned); 928 929 drm_gem_private_object_init(priv->drm, &bo_pinned->base, size); 930 err = ttm_bo_init_reserved(priv->ttm_dev, bo_pinned, bo_type, placement, 931 PAGE_SIZE, &ctx_init, NULL, NULL, 932 &dummy_ttm_bo_destroy); 933 KUNIT_EXPECT_EQ(test, err, 0); 934 ttm_bo_pin(bo_pinned); 935 dma_resv_unlock(bo_pinned->base.resv); 936 937 bo_evictable = kunit_kzalloc(test, sizeof(*bo_evictable), GFP_KERNEL); 938 KUNIT_ASSERT_NOT_NULL(test, bo_evictable); 939 940 drm_gem_private_object_init(priv->drm, &bo_evictable->base, size); 941 err = ttm_bo_init_reserved(priv->ttm_dev, bo_evictable, bo_type, placement, 942 PAGE_SIZE, &ctx_init, NULL, NULL, 943 &dummy_ttm_bo_destroy); 944 KUNIT_EXPECT_EQ(test, err, 0); 945 dma_resv_unlock(bo_evictable->base.resv); 946 947 bo = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL); 948 bo->type = bo_type; 949 950 ttm_bo_reserve(bo, false, false, NULL); 951 err = ttm_bo_validate(bo, placement, &ctx_val); 952 ttm_bo_unreserve(bo); 953 954 KUNIT_EXPECT_EQ(test, err, 0); 955 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, mem_type); 956 KUNIT_EXPECT_EQ(test, bo_pinned->resource->mem_type, mem_type); 957 KUNIT_EXPECT_EQ(test, bo_evictable->resource->mem_type, mem_type_evict); 958 KUNIT_EXPECT_EQ(test, ctx_val.bytes_moved, size * 2 + BO_SIZE); 959 960 ttm_bo_fini(bo); 961 ttm_bo_fini(bo_evictable); 962 963 ttm_bo_reserve(bo_pinned, false, false, NULL); 964 ttm_bo_unpin(bo_pinned); 965 dma_resv_unlock(bo_pinned->base.resv); 966 ttm_bo_fini(bo_pinned); 967 968 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 969 ttm_mock_manager_fini(priv->ttm_dev, mem_multihop); 970 } 971 972 static void ttm_bo_validate_deleted_evict(struct kunit *test) 973 { 974 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 975 u32 small = SZ_8K, big = MANAGER_SIZE - BO_SIZE; 976 enum ttm_bo_type bo_type = ttm_bo_type_device; 977 struct ttm_buffer_object *bo_big, *bo_small; 978 struct ttm_test_devices *priv = test->priv; 979 struct ttm_resource_manager *man; 980 u32 mem_type = TTM_PL_VRAM; 981 struct ttm_placement *placement; 982 struct ttm_place *place; 983 int err; 984 985 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 986 man = ttm_manager_type(priv->ttm_dev, mem_type); 987 988 place = ttm_place_kunit_init(test, mem_type, 0); 989 placement = ttm_placement_kunit_init(test, place, 1); 990 991 bo_big = kunit_kzalloc(test, sizeof(*bo_big), GFP_KERNEL); 992 KUNIT_ASSERT_NOT_NULL(test, bo_big); 993 994 drm_gem_private_object_init(priv->drm, &bo_big->base, big); 995 err = ttm_bo_init_reserved(priv->ttm_dev, bo_big, bo_type, placement, 996 PAGE_SIZE, &ctx_init, NULL, NULL, 997 &dummy_ttm_bo_destroy); 998 KUNIT_EXPECT_EQ(test, err, 0); 999 KUNIT_EXPECT_EQ(test, ttm_resource_manager_usage(man), big); 1000 1001 dma_resv_unlock(bo_big->base.resv); 1002 bo_big->deleted = true; 1003 1004 bo_small = ttm_bo_kunit_init(test, test->priv, small, NULL); 1005 bo_small->type = bo_type; 1006 1007 ttm_bo_reserve(bo_small, false, false, NULL); 1008 err = ttm_bo_validate(bo_small, placement, &ctx_val); 1009 ttm_bo_unreserve(bo_small); 1010 1011 KUNIT_EXPECT_EQ(test, err, 0); 1012 KUNIT_EXPECT_EQ(test, bo_small->resource->mem_type, mem_type); 1013 KUNIT_EXPECT_EQ(test, ttm_resource_manager_usage(man), small); 1014 KUNIT_EXPECT_NULL(test, bo_big->ttm); 1015 KUNIT_EXPECT_NULL(test, bo_big->resource); 1016 1017 ttm_bo_fini(bo_small); 1018 ttm_bo_fini(bo_big); 1019 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 1020 } 1021 1022 static void ttm_bo_validate_busy_domain_evict(struct kunit *test) 1023 { 1024 u32 mem_type = TTM_PL_VRAM, mem_type_evict = TTM_PL_MOCK1; 1025 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 1026 enum ttm_bo_type bo_type = ttm_bo_type_device; 1027 struct ttm_test_devices *priv = test->priv; 1028 struct ttm_buffer_object *bo_init, *bo_val; 1029 struct ttm_placement *placement; 1030 struct ttm_place *place; 1031 int err; 1032 1033 /* 1034 * Drop the default device and setup a new one that points to busy 1035 * thus unsuitable eviction domain 1036 */ 1037 ttm_device_fini(priv->ttm_dev); 1038 1039 err = ttm_device_kunit_init_bad_evict(test->priv, priv->ttm_dev); 1040 KUNIT_ASSERT_EQ(test, err, 0); 1041 1042 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 1043 ttm_busy_manager_init(priv->ttm_dev, mem_type_evict, MANAGER_SIZE); 1044 1045 place = ttm_place_kunit_init(test, mem_type, 0); 1046 placement = ttm_placement_kunit_init(test, place, 1); 1047 1048 bo_init = kunit_kzalloc(test, sizeof(*bo_init), GFP_KERNEL); 1049 KUNIT_ASSERT_NOT_NULL(test, bo_init); 1050 1051 drm_gem_private_object_init(priv->drm, &bo_init->base, MANAGER_SIZE); 1052 err = ttm_bo_init_reserved(priv->ttm_dev, bo_init, bo_type, placement, 1053 PAGE_SIZE, &ctx_init, NULL, NULL, 1054 &dummy_ttm_bo_destroy); 1055 KUNIT_EXPECT_EQ(test, err, 0); 1056 dma_resv_unlock(bo_init->base.resv); 1057 1058 bo_val = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL); 1059 bo_val->type = bo_type; 1060 1061 ttm_bo_reserve(bo_val, false, false, NULL); 1062 err = ttm_bo_validate(bo_val, placement, &ctx_val); 1063 ttm_bo_unreserve(bo_val); 1064 1065 KUNIT_EXPECT_EQ(test, err, -ENOMEM); 1066 KUNIT_EXPECT_EQ(test, bo_init->resource->mem_type, mem_type); 1067 KUNIT_EXPECT_NULL(test, bo_val->resource); 1068 1069 ttm_bo_fini(bo_init); 1070 ttm_bo_fini(bo_val); 1071 1072 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 1073 ttm_bad_manager_fini(priv->ttm_dev, mem_type_evict); 1074 } 1075 1076 static void ttm_bo_validate_evict_gutting(struct kunit *test) 1077 { 1078 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 1079 enum ttm_bo_type bo_type = ttm_bo_type_device; 1080 struct ttm_test_devices *priv = test->priv; 1081 struct ttm_buffer_object *bo, *bo_evict; 1082 u32 mem_type = TTM_PL_MOCK1; 1083 struct ttm_placement *placement; 1084 struct ttm_place *place; 1085 int err; 1086 1087 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 1088 1089 place = ttm_place_kunit_init(test, mem_type, 0); 1090 placement = ttm_placement_kunit_init(test, place, 1); 1091 1092 bo_evict = kunit_kzalloc(test, sizeof(*bo_evict), GFP_KERNEL); 1093 KUNIT_ASSERT_NOT_NULL(test, bo_evict); 1094 1095 drm_gem_private_object_init(priv->drm, &bo_evict->base, MANAGER_SIZE); 1096 err = ttm_bo_init_reserved(priv->ttm_dev, bo_evict, bo_type, placement, 1097 PAGE_SIZE, &ctx_init, NULL, NULL, 1098 &dummy_ttm_bo_destroy); 1099 KUNIT_EXPECT_EQ(test, err, 0); 1100 dma_resv_unlock(bo_evict->base.resv); 1101 1102 bo = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL); 1103 bo->type = bo_type; 1104 1105 ttm_bo_reserve(bo, false, false, NULL); 1106 err = ttm_bo_validate(bo, placement, &ctx_val); 1107 ttm_bo_unreserve(bo); 1108 1109 KUNIT_EXPECT_EQ(test, err, 0); 1110 KUNIT_EXPECT_EQ(test, bo->resource->mem_type, mem_type); 1111 KUNIT_ASSERT_NULL(test, bo_evict->resource); 1112 KUNIT_ASSERT_TRUE(test, bo_evict->ttm->page_flags & TTM_TT_FLAG_ZERO_ALLOC); 1113 1114 ttm_bo_fini(bo_evict); 1115 ttm_bo_fini(bo); 1116 1117 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 1118 } 1119 1120 static void ttm_bo_validate_recrusive_evict(struct kunit *test) 1121 { 1122 u32 mem_type = TTM_PL_TT, mem_type_evict = TTM_PL_MOCK2; 1123 struct ttm_operation_ctx ctx_init = { }, ctx_val = { }; 1124 struct ttm_placement *placement_tt, *placement_mock; 1125 struct ttm_buffer_object *bo_tt, *bo_mock, *bo_val; 1126 enum ttm_bo_type bo_type = ttm_bo_type_device; 1127 struct ttm_test_devices *priv = test->priv; 1128 struct ttm_place *place_tt, *place_mock; 1129 int err; 1130 1131 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE); 1132 ttm_mock_manager_init(priv->ttm_dev, mem_type_evict, MANAGER_SIZE); 1133 1134 place_tt = ttm_place_kunit_init(test, mem_type, 0); 1135 place_mock = ttm_place_kunit_init(test, mem_type_evict, 0); 1136 1137 placement_tt = ttm_placement_kunit_init(test, place_tt, 1); 1138 placement_mock = ttm_placement_kunit_init(test, place_mock, 1); 1139 1140 bo_tt = kunit_kzalloc(test, sizeof(*bo_tt), GFP_KERNEL); 1141 KUNIT_ASSERT_NOT_NULL(test, bo_tt); 1142 1143 bo_mock = kunit_kzalloc(test, sizeof(*bo_mock), GFP_KERNEL); 1144 KUNIT_ASSERT_NOT_NULL(test, bo_mock); 1145 1146 drm_gem_private_object_init(priv->drm, &bo_tt->base, MANAGER_SIZE); 1147 err = ttm_bo_init_reserved(priv->ttm_dev, bo_tt, bo_type, placement_tt, 1148 PAGE_SIZE, &ctx_init, NULL, NULL, 1149 &dummy_ttm_bo_destroy); 1150 KUNIT_EXPECT_EQ(test, err, 0); 1151 dma_resv_unlock(bo_tt->base.resv); 1152 1153 drm_gem_private_object_init(priv->drm, &bo_mock->base, MANAGER_SIZE); 1154 err = ttm_bo_init_reserved(priv->ttm_dev, bo_mock, bo_type, placement_mock, 1155 PAGE_SIZE, &ctx_init, NULL, NULL, 1156 &dummy_ttm_bo_destroy); 1157 KUNIT_EXPECT_EQ(test, err, 0); 1158 dma_resv_unlock(bo_mock->base.resv); 1159 1160 bo_val = ttm_bo_kunit_init(test, test->priv, BO_SIZE, NULL); 1161 bo_val->type = bo_type; 1162 1163 ttm_bo_reserve(bo_val, false, false, NULL); 1164 err = ttm_bo_validate(bo_val, placement_tt, &ctx_val); 1165 ttm_bo_unreserve(bo_val); 1166 1167 KUNIT_EXPECT_EQ(test, err, 0); 1168 1169 ttm_mock_manager_fini(priv->ttm_dev, mem_type); 1170 ttm_mock_manager_fini(priv->ttm_dev, mem_type_evict); 1171 1172 ttm_bo_fini(bo_val); 1173 ttm_bo_fini(bo_tt); 1174 ttm_bo_fini(bo_mock); 1175 } 1176 1177 static struct kunit_case ttm_bo_validate_test_cases[] = { 1178 KUNIT_CASE_PARAM(ttm_bo_init_reserved_sys_man, ttm_bo_types_gen_params), 1179 KUNIT_CASE_PARAM(ttm_bo_init_reserved_mock_man, ttm_bo_types_gen_params), 1180 KUNIT_CASE(ttm_bo_init_reserved_resv), 1181 KUNIT_CASE_PARAM(ttm_bo_validate_basic, ttm_bo_types_gen_params), 1182 KUNIT_CASE(ttm_bo_validate_invalid_placement), 1183 KUNIT_CASE_PARAM(ttm_bo_validate_same_placement, 1184 ttm_bo_validate_mem_gen_params), 1185 KUNIT_CASE(ttm_bo_validate_failed_alloc), 1186 KUNIT_CASE(ttm_bo_validate_pinned), 1187 KUNIT_CASE(ttm_bo_validate_busy_placement), 1188 KUNIT_CASE_PARAM(ttm_bo_validate_multihop, ttm_bo_types_gen_params), 1189 KUNIT_CASE_PARAM(ttm_bo_validate_no_placement_signaled, 1190 ttm_bo_no_placement_gen_params), 1191 KUNIT_CASE_PARAM(ttm_bo_validate_no_placement_not_signaled, 1192 ttm_bo_types_gen_params), 1193 KUNIT_CASE(ttm_bo_validate_move_fence_signaled), 1194 KUNIT_CASE_PARAM(ttm_bo_validate_move_fence_not_signaled, 1195 ttm_bo_validate_wait_gen_params), 1196 KUNIT_CASE(ttm_bo_validate_swapout), 1197 KUNIT_CASE(ttm_bo_validate_happy_evict), 1198 KUNIT_CASE(ttm_bo_validate_all_pinned_evict), 1199 KUNIT_CASE(ttm_bo_validate_allowed_only_evict), 1200 KUNIT_CASE(ttm_bo_validate_deleted_evict), 1201 KUNIT_CASE(ttm_bo_validate_busy_domain_evict), 1202 KUNIT_CASE(ttm_bo_validate_evict_gutting), 1203 KUNIT_CASE(ttm_bo_validate_recrusive_evict), 1204 {} 1205 }; 1206 1207 static struct kunit_suite ttm_bo_validate_test_suite = { 1208 .name = "ttm_bo_validate", 1209 .init = ttm_test_devices_all_init, 1210 .exit = ttm_test_devices_fini, 1211 .test_cases = ttm_bo_validate_test_cases, 1212 }; 1213 1214 kunit_test_suites(&ttm_bo_validate_test_suite); 1215 1216 MODULE_DESCRIPTION("KUnit tests for ttm_bo APIs"); 1217 MODULE_LICENSE("GPL and additional rights"); 1218