1 /* 2 * Copyright © 2017 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 * 23 */ 24 25 #include <linux/completion.h> 26 #include <linux/delay.h> 27 #include <linux/prime_numbers.h> 28 29 #include "../i915_selftest.h" 30 31 static int __i915_sw_fence_call 32 fence_notify(struct i915_sw_fence *fence, enum i915_sw_fence_notify state) 33 { 34 switch (state) { 35 case FENCE_COMPLETE: 36 break; 37 38 case FENCE_FREE: 39 /* Leave the fence for the caller to free it after testing */ 40 break; 41 } 42 43 return NOTIFY_DONE; 44 } 45 46 static struct i915_sw_fence *alloc_fence(void) 47 { 48 struct i915_sw_fence *fence; 49 50 fence = kmalloc(sizeof(*fence), GFP_KERNEL); 51 if (!fence) 52 return NULL; 53 54 i915_sw_fence_init(fence, fence_notify); 55 return fence; 56 } 57 58 static void free_fence(struct i915_sw_fence *fence) 59 { 60 i915_sw_fence_fini(fence); 61 kfree(fence); 62 } 63 64 static int __test_self(struct i915_sw_fence *fence) 65 { 66 if (i915_sw_fence_done(fence)) 67 return -EINVAL; 68 69 i915_sw_fence_commit(fence); 70 if (!i915_sw_fence_done(fence)) 71 return -EINVAL; 72 73 i915_sw_fence_wait(fence); 74 if (!i915_sw_fence_done(fence)) 75 return -EINVAL; 76 77 return 0; 78 } 79 80 static int test_self(void *arg) 81 { 82 struct i915_sw_fence *fence; 83 int ret; 84 85 /* Test i915_sw_fence signaling and completion testing */ 86 fence = alloc_fence(); 87 if (!fence) 88 return -ENOMEM; 89 90 ret = __test_self(fence); 91 92 free_fence(fence); 93 return ret; 94 } 95 96 static int test_dag(void *arg) 97 { 98 struct i915_sw_fence *A, *B, *C; 99 int ret = -EINVAL; 100 101 /* Test detection of cycles within the i915_sw_fence graphs */ 102 if (!IS_ENABLED(CONFIG_DRM_I915_SW_FENCE_CHECK_DAG)) 103 return 0; 104 105 A = alloc_fence(); 106 if (!A) 107 return -ENOMEM; 108 109 if (i915_sw_fence_await_sw_fence_gfp(A, A, GFP_KERNEL) != -EINVAL) { 110 pr_err("recursive cycle not detected (AA)\n"); 111 goto err_A; 112 } 113 114 B = alloc_fence(); 115 if (!B) { 116 ret = -ENOMEM; 117 goto err_A; 118 } 119 120 i915_sw_fence_await_sw_fence_gfp(A, B, GFP_KERNEL); 121 if (i915_sw_fence_await_sw_fence_gfp(B, A, GFP_KERNEL) != -EINVAL) { 122 pr_err("single depth cycle not detected (BAB)\n"); 123 goto err_B; 124 } 125 126 C = alloc_fence(); 127 if (!C) { 128 ret = -ENOMEM; 129 goto err_B; 130 } 131 132 if (i915_sw_fence_await_sw_fence_gfp(B, C, GFP_KERNEL) == -EINVAL) { 133 pr_err("invalid cycle detected\n"); 134 goto err_C; 135 } 136 if (i915_sw_fence_await_sw_fence_gfp(C, B, GFP_KERNEL) != -EINVAL) { 137 pr_err("single depth cycle not detected (CBC)\n"); 138 goto err_C; 139 } 140 if (i915_sw_fence_await_sw_fence_gfp(C, A, GFP_KERNEL) != -EINVAL) { 141 pr_err("cycle not detected (BA, CB, AC)\n"); 142 goto err_C; 143 } 144 if (i915_sw_fence_await_sw_fence_gfp(A, C, GFP_KERNEL) == -EINVAL) { 145 pr_err("invalid cycle detected\n"); 146 goto err_C; 147 } 148 149 i915_sw_fence_commit(A); 150 i915_sw_fence_commit(B); 151 i915_sw_fence_commit(C); 152 153 ret = 0; 154 if (!i915_sw_fence_done(C)) { 155 pr_err("fence C not done\n"); 156 ret = -EINVAL; 157 } 158 if (!i915_sw_fence_done(B)) { 159 pr_err("fence B not done\n"); 160 ret = -EINVAL; 161 } 162 if (!i915_sw_fence_done(A)) { 163 pr_err("fence A not done\n"); 164 ret = -EINVAL; 165 } 166 err_C: 167 free_fence(C); 168 err_B: 169 free_fence(B); 170 err_A: 171 free_fence(A); 172 return ret; 173 } 174 175 static int test_AB(void *arg) 176 { 177 struct i915_sw_fence *A, *B; 178 int ret; 179 180 /* Test i915_sw_fence (A) waiting on an event source (B) */ 181 A = alloc_fence(); 182 if (!A) 183 return -ENOMEM; 184 B = alloc_fence(); 185 if (!B) { 186 ret = -ENOMEM; 187 goto err_A; 188 } 189 190 ret = i915_sw_fence_await_sw_fence_gfp(A, B, GFP_KERNEL); 191 if (ret < 0) 192 goto err_B; 193 if (ret == 0) { 194 pr_err("Incorrectly reported fence A was complete before await\n"); 195 ret = -EINVAL; 196 goto err_B; 197 } 198 199 ret = -EINVAL; 200 i915_sw_fence_commit(A); 201 if (i915_sw_fence_done(A)) 202 goto err_B; 203 204 i915_sw_fence_commit(B); 205 if (!i915_sw_fence_done(B)) { 206 pr_err("Fence B is not done\n"); 207 goto err_B; 208 } 209 210 if (!i915_sw_fence_done(A)) { 211 pr_err("Fence A is not done\n"); 212 goto err_B; 213 } 214 215 ret = 0; 216 err_B: 217 free_fence(B); 218 err_A: 219 free_fence(A); 220 return ret; 221 } 222 223 static int test_ABC(void *arg) 224 { 225 struct i915_sw_fence *A, *B, *C; 226 int ret; 227 228 /* Test a chain of fences, A waits on B who waits on C */ 229 A = alloc_fence(); 230 if (!A) 231 return -ENOMEM; 232 233 B = alloc_fence(); 234 if (!B) { 235 ret = -ENOMEM; 236 goto err_A; 237 } 238 239 C = alloc_fence(); 240 if (!C) { 241 ret = -ENOMEM; 242 goto err_B; 243 } 244 245 ret = i915_sw_fence_await_sw_fence_gfp(A, B, GFP_KERNEL); 246 if (ret < 0) 247 goto err_C; 248 if (ret == 0) { 249 pr_err("Incorrectly reported fence B was complete before await\n"); 250 goto err_C; 251 } 252 253 ret = i915_sw_fence_await_sw_fence_gfp(B, C, GFP_KERNEL); 254 if (ret < 0) 255 goto err_C; 256 if (ret == 0) { 257 pr_err("Incorrectly reported fence C was complete before await\n"); 258 goto err_C; 259 } 260 261 ret = -EINVAL; 262 i915_sw_fence_commit(A); 263 if (i915_sw_fence_done(A)) { 264 pr_err("Fence A completed early\n"); 265 goto err_C; 266 } 267 268 i915_sw_fence_commit(B); 269 if (i915_sw_fence_done(B)) { 270 pr_err("Fence B completed early\n"); 271 goto err_C; 272 } 273 274 if (i915_sw_fence_done(A)) { 275 pr_err("Fence A completed early (after signaling B)\n"); 276 goto err_C; 277 } 278 279 i915_sw_fence_commit(C); 280 281 ret = 0; 282 if (!i915_sw_fence_done(C)) { 283 pr_err("Fence C not done\n"); 284 ret = -EINVAL; 285 } 286 if (!i915_sw_fence_done(B)) { 287 pr_err("Fence B not done\n"); 288 ret = -EINVAL; 289 } 290 if (!i915_sw_fence_done(A)) { 291 pr_err("Fence A not done\n"); 292 ret = -EINVAL; 293 } 294 err_C: 295 free_fence(C); 296 err_B: 297 free_fence(B); 298 err_A: 299 free_fence(A); 300 return ret; 301 } 302 303 static int test_AB_C(void *arg) 304 { 305 struct i915_sw_fence *A, *B, *C; 306 int ret = -EINVAL; 307 308 /* Test multiple fences (AB) waiting on a single event (C) */ 309 A = alloc_fence(); 310 if (!A) 311 return -ENOMEM; 312 313 B = alloc_fence(); 314 if (!B) { 315 ret = -ENOMEM; 316 goto err_A; 317 } 318 319 C = alloc_fence(); 320 if (!C) { 321 ret = -ENOMEM; 322 goto err_B; 323 } 324 325 ret = i915_sw_fence_await_sw_fence_gfp(A, C, GFP_KERNEL); 326 if (ret < 0) 327 goto err_C; 328 if (ret == 0) { 329 ret = -EINVAL; 330 goto err_C; 331 } 332 333 ret = i915_sw_fence_await_sw_fence_gfp(B, C, GFP_KERNEL); 334 if (ret < 0) 335 goto err_C; 336 if (ret == 0) { 337 ret = -EINVAL; 338 goto err_C; 339 } 340 341 i915_sw_fence_commit(A); 342 i915_sw_fence_commit(B); 343 344 ret = 0; 345 if (i915_sw_fence_done(A)) { 346 pr_err("Fence A completed early\n"); 347 ret = -EINVAL; 348 } 349 350 if (i915_sw_fence_done(B)) { 351 pr_err("Fence B completed early\n"); 352 ret = -EINVAL; 353 } 354 355 i915_sw_fence_commit(C); 356 if (!i915_sw_fence_done(C)) { 357 pr_err("Fence C not done\n"); 358 ret = -EINVAL; 359 } 360 361 if (!i915_sw_fence_done(B)) { 362 pr_err("Fence B not done\n"); 363 ret = -EINVAL; 364 } 365 366 if (!i915_sw_fence_done(A)) { 367 pr_err("Fence A not done\n"); 368 ret = -EINVAL; 369 } 370 371 err_C: 372 free_fence(C); 373 err_B: 374 free_fence(B); 375 err_A: 376 free_fence(A); 377 return ret; 378 } 379 380 static int test_C_AB(void *arg) 381 { 382 struct i915_sw_fence *A, *B, *C; 383 int ret; 384 385 /* Test multiple event sources (A,B) for a single fence (C) */ 386 A = alloc_fence(); 387 if (!A) 388 return -ENOMEM; 389 390 B = alloc_fence(); 391 if (!B) { 392 ret = -ENOMEM; 393 goto err_A; 394 } 395 396 C = alloc_fence(); 397 if (!C) { 398 ret = -ENOMEM; 399 goto err_B; 400 } 401 402 ret = i915_sw_fence_await_sw_fence_gfp(C, A, GFP_KERNEL); 403 if (ret < 0) 404 goto err_C; 405 if (ret == 0) { 406 ret = -EINVAL; 407 goto err_C; 408 } 409 410 ret = i915_sw_fence_await_sw_fence_gfp(C, B, GFP_KERNEL); 411 if (ret < 0) 412 goto err_C; 413 if (ret == 0) { 414 ret = -EINVAL; 415 goto err_C; 416 } 417 418 ret = 0; 419 i915_sw_fence_commit(C); 420 if (i915_sw_fence_done(C)) 421 ret = -EINVAL; 422 423 i915_sw_fence_commit(A); 424 i915_sw_fence_commit(B); 425 426 if (!i915_sw_fence_done(A)) { 427 pr_err("Fence A not done\n"); 428 ret = -EINVAL; 429 } 430 431 if (!i915_sw_fence_done(B)) { 432 pr_err("Fence B not done\n"); 433 ret = -EINVAL; 434 } 435 436 if (!i915_sw_fence_done(C)) { 437 pr_err("Fence C not done\n"); 438 ret = -EINVAL; 439 } 440 441 err_C: 442 free_fence(C); 443 err_B: 444 free_fence(B); 445 err_A: 446 free_fence(A); 447 return ret; 448 } 449 450 static int test_chain(void *arg) 451 { 452 int nfences = 4096; 453 struct i915_sw_fence **fences; 454 int ret, i; 455 456 /* Test a long chain of fences */ 457 fences = kmalloc_array(nfences, sizeof(*fences), GFP_KERNEL); 458 if (!fences) 459 return -ENOMEM; 460 461 for (i = 0; i < nfences; i++) { 462 fences[i] = alloc_fence(); 463 if (!fences[i]) { 464 nfences = i; 465 ret = -ENOMEM; 466 goto err; 467 } 468 469 if (i > 0) { 470 ret = i915_sw_fence_await_sw_fence_gfp(fences[i], 471 fences[i - 1], 472 GFP_KERNEL); 473 if (ret < 0) { 474 nfences = i + 1; 475 goto err; 476 } 477 478 i915_sw_fence_commit(fences[i]); 479 } 480 } 481 482 ret = 0; 483 for (i = nfences; --i; ) { 484 if (i915_sw_fence_done(fences[i])) { 485 if (ret == 0) 486 pr_err("Fence[%d] completed early\n", i); 487 ret = -EINVAL; 488 } 489 } 490 i915_sw_fence_commit(fences[0]); 491 for (i = 0; ret == 0 && i < nfences; i++) { 492 if (!i915_sw_fence_done(fences[i])) { 493 pr_err("Fence[%d] is not done\n", i); 494 ret = -EINVAL; 495 } 496 } 497 498 err: 499 for (i = 0; i < nfences; i++) 500 free_fence(fences[i]); 501 kfree(fences); 502 return ret; 503 } 504 505 struct task_ipc { 506 struct work_struct work; 507 struct completion started; 508 struct i915_sw_fence *in, *out; 509 int value; 510 }; 511 512 static void task_ipc(struct work_struct *work) 513 { 514 struct task_ipc *ipc = container_of(work, typeof(*ipc), work); 515 516 complete(&ipc->started); 517 518 i915_sw_fence_wait(ipc->in); 519 smp_store_mb(ipc->value, 1); 520 i915_sw_fence_commit(ipc->out); 521 } 522 523 static int test_ipc(void *arg) 524 { 525 struct task_ipc ipc; 526 int ret = 0; 527 528 /* Test use of i915_sw_fence as an interprocess signaling mechanism */ 529 ipc.in = alloc_fence(); 530 if (!ipc.in) 531 return -ENOMEM; 532 ipc.out = alloc_fence(); 533 if (!ipc.out) { 534 ret = -ENOMEM; 535 goto err_in; 536 } 537 538 /* use a completion to avoid chicken-and-egg testing */ 539 init_completion(&ipc.started); 540 541 ipc.value = 0; 542 INIT_WORK_ONSTACK(&ipc.work, task_ipc); 543 schedule_work(&ipc.work); 544 545 wait_for_completion(&ipc.started); 546 547 usleep_range(1000, 2000); 548 if (READ_ONCE(ipc.value)) { 549 pr_err("worker updated value before i915_sw_fence was signaled\n"); 550 ret = -EINVAL; 551 } 552 553 i915_sw_fence_commit(ipc.in); 554 i915_sw_fence_wait(ipc.out); 555 556 if (!READ_ONCE(ipc.value)) { 557 pr_err("worker signaled i915_sw_fence before value was posted\n"); 558 ret = -EINVAL; 559 } 560 561 flush_work(&ipc.work); 562 destroy_work_on_stack(&ipc.work); 563 free_fence(ipc.out); 564 err_in: 565 free_fence(ipc.in); 566 return ret; 567 } 568 569 static int test_timer(void *arg) 570 { 571 unsigned long target, delay; 572 struct timed_fence tf; 573 574 preempt_disable(); 575 timed_fence_init(&tf, target = jiffies); 576 if (!i915_sw_fence_done(&tf.fence)) { 577 pr_err("Fence with immediate expiration not signaled\n"); 578 goto err; 579 } 580 preempt_enable(); 581 timed_fence_fini(&tf); 582 583 for_each_prime_number(delay, i915_selftest.timeout_jiffies/2) { 584 preempt_disable(); 585 timed_fence_init(&tf, target = jiffies + delay); 586 if (i915_sw_fence_done(&tf.fence)) { 587 pr_err("Fence with future expiration (%lu jiffies) already signaled\n", delay); 588 goto err; 589 } 590 preempt_enable(); 591 592 i915_sw_fence_wait(&tf.fence); 593 594 preempt_disable(); 595 if (!i915_sw_fence_done(&tf.fence)) { 596 pr_err("Fence not signaled after wait\n"); 597 goto err; 598 } 599 if (time_before(jiffies, target)) { 600 pr_err("Fence signaled too early, target=%lu, now=%lu\n", 601 target, jiffies); 602 goto err; 603 } 604 preempt_enable(); 605 timed_fence_fini(&tf); 606 } 607 608 return 0; 609 610 err: 611 preempt_enable(); 612 timed_fence_fini(&tf); 613 return -EINVAL; 614 } 615 616 static const char *mock_name(struct dma_fence *fence) 617 { 618 return "mock"; 619 } 620 621 static const struct dma_fence_ops mock_fence_ops = { 622 .get_driver_name = mock_name, 623 .get_timeline_name = mock_name, 624 }; 625 626 static DEFINE_SPINLOCK(mock_fence_lock); 627 628 static struct dma_fence *alloc_dma_fence(void) 629 { 630 struct dma_fence *dma; 631 632 dma = kmalloc(sizeof(*dma), GFP_KERNEL); 633 if (dma) 634 dma_fence_init(dma, &mock_fence_ops, &mock_fence_lock, 0, 0); 635 636 return dma; 637 } 638 639 static struct i915_sw_fence * 640 wrap_dma_fence(struct dma_fence *dma, unsigned long delay) 641 { 642 struct i915_sw_fence *fence; 643 int err; 644 645 fence = alloc_fence(); 646 if (!fence) 647 return ERR_PTR(-ENOMEM); 648 649 err = i915_sw_fence_await_dma_fence(fence, dma, delay, GFP_NOWAIT); 650 i915_sw_fence_commit(fence); 651 if (err < 0) { 652 free_fence(fence); 653 return ERR_PTR(err); 654 } 655 656 return fence; 657 } 658 659 static int test_dma_fence(void *arg) 660 { 661 struct i915_sw_fence *timeout = NULL, *not = NULL; 662 unsigned long delay = i915_selftest.timeout_jiffies; 663 unsigned long end, sleep; 664 struct dma_fence *dma; 665 int err; 666 667 dma = alloc_dma_fence(); 668 if (!dma) 669 return -ENOMEM; 670 671 timeout = wrap_dma_fence(dma, delay); 672 if (IS_ERR(timeout)) { 673 err = PTR_ERR(timeout); 674 goto err; 675 } 676 677 not = wrap_dma_fence(dma, 0); 678 if (IS_ERR(not)) { 679 err = PTR_ERR(not); 680 goto err; 681 } 682 683 err = -EINVAL; 684 if (i915_sw_fence_done(timeout) || i915_sw_fence_done(not)) { 685 pr_err("Fences immediately signaled\n"); 686 goto err; 687 } 688 689 /* We round the timeout for the fence up to the next second */ 690 end = round_jiffies_up(jiffies + delay); 691 692 sleep = jiffies_to_usecs(delay) / 3; 693 usleep_range(sleep, 2 * sleep); 694 if (time_after(jiffies, end)) { 695 pr_debug("Slept too long, delay=%lu, (target=%lu, now=%lu) skipping\n", 696 delay, end, jiffies); 697 goto skip; 698 } 699 700 if (i915_sw_fence_done(timeout) || i915_sw_fence_done(not)) { 701 pr_err("Fences signaled too early\n"); 702 goto err; 703 } 704 705 if (!wait_event_timeout(timeout->wait, 706 i915_sw_fence_done(timeout), 707 2 * (end - jiffies) + 1)) { 708 pr_err("Timeout fence unsignaled!\n"); 709 goto err; 710 } 711 712 if (i915_sw_fence_done(not)) { 713 pr_err("No timeout fence signaled!\n"); 714 goto err; 715 } 716 717 skip: 718 dma_fence_signal(dma); 719 720 if (!i915_sw_fence_done(timeout) || !i915_sw_fence_done(not)) { 721 pr_err("Fences unsignaled\n"); 722 goto err; 723 } 724 725 free_fence(not); 726 free_fence(timeout); 727 dma_fence_put(dma); 728 729 return 0; 730 731 err: 732 dma_fence_signal(dma); 733 if (!IS_ERR_OR_NULL(timeout)) 734 free_fence(timeout); 735 if (!IS_ERR_OR_NULL(not)) 736 free_fence(not); 737 dma_fence_put(dma); 738 return err; 739 } 740 741 int i915_sw_fence_mock_selftests(void) 742 { 743 static const struct i915_subtest tests[] = { 744 SUBTEST(test_self), 745 SUBTEST(test_dag), 746 SUBTEST(test_AB), 747 SUBTEST(test_ABC), 748 SUBTEST(test_AB_C), 749 SUBTEST(test_C_AB), 750 SUBTEST(test_chain), 751 SUBTEST(test_ipc), 752 SUBTEST(test_timer), 753 SUBTEST(test_dma_fence), 754 }; 755 756 return i915_subtests(tests, NULL); 757 } 758