Lines Matching refs:engine
104 hang_create_request(struct hang *h, struct intel_engine_cs *engine)
157 rq = igt_request_alloc(h->ctx, engine);
226 intel_gt_chipset_flush(engine->gt);
228 if (rq->engine->emit_init_breadcrumb) {
229 err = rq->engine->emit_init_breadcrumb(rq);
238 err = rq->engine->emit_bb_start(rq, i915_vma_offset(vma), PAGE_SIZE, flags);
288 struct intel_engine_cs *engine;
299 for_each_engine(engine, gt, id) {
303 if (!intel_engine_can_store_dword(engine))
306 rq = hang_create_request(&h, engine);
310 engine->name, err);
317 intel_gt_chipset_flush(engine->gt);
333 engine->name, err);
343 static bool wait_for_idle(struct intel_engine_cs *engine)
345 return wait_for(intel_engine_is_idle(engine), IGT_IDLE_TIMEOUT) == 0;
352 struct intel_engine_cs *engine;
363 for_each_engine(engine, gt, id) {
367 ce = intel_context_create(engine);
370 pr_err("[%s] Create context failed: %d!\n", engine->name, err);
381 engine->name, err);
396 pr_err("[%s] GT is wedged!\n", engine->name);
403 engine->name, i915_reset_count(global), reset_count, count);
410 pr_err("[%s] Flush failed: %d!\n", engine->name, err);
428 struct intel_engine_cs *engine;
431 /* Check that we can engine-reset during non-user portions */
436 for_each_engine(engine, gt, id) {
442 if (intel_engine_uses_guc(engine)) {
450 ce = intel_context_create(engine);
452 pr_err("[%s] Create context failed: %pe!\n", engine->name, ce);
457 reset_engine_count = i915_reset_engine_count(global, engine);
460 st_engine_heartbeat_disable(engine);
466 if (!wait_for_idle(engine)) {
468 engine->name);
480 intel_engine_dump(engine, &p,
483 engine->name);
487 engine->name);
498 err = intel_engine_reset(engine, NULL);
501 engine->name, err);
506 pr_err("Full GPU reset recorded! (engine reset expected)\n");
511 if (i915_reset_engine_count(global, engine) !=
513 pr_err("%s engine reset not recorded!\n",
514 engine->name);
520 st_engine_heartbeat_enable(engine);
522 pr_info("%s(%s): %d resets\n", __func__, engine->name, count);
534 static void force_reset_timeout(struct intel_engine_cs *engine)
536 engine->reset_timeout.probability = 999;
537 atomic_set(&engine->reset_timeout.times, -1);
540 static void cancel_reset_timeout(struct intel_engine_cs *engine)
542 memset(&engine->reset_timeout, 0, sizeof(engine->reset_timeout));
548 struct intel_engine_cs *engine;
551 /* Check that we can recover from engine-reset failures */
556 for_each_engine(engine, gt, id) {
563 if (intel_engine_uses_guc(engine))
566 ce = intel_context_create(engine);
568 pr_err("[%s] Create context failed: %pe!\n", engine->name, ce);
572 st_engine_heartbeat_disable(engine);
576 force_reset_timeout(engine);
577 err = intel_engine_reset(engine, NULL);
578 cancel_reset_timeout(engine);
587 if (!wait_for_idle(engine)) {
589 engine->name);
601 intel_engine_dump(engine, &p,
604 engine->name);
608 engine->name);
626 err = intel_engine_reset(engine, NULL);
629 engine->name, err);
635 force_reset_timeout(engine);
636 err = intel_engine_reset(engine, NULL);
637 cancel_reset_timeout(engine);
640 engine->name, err);
652 intel_engine_dump(engine, &p,
655 engine->name);
659 engine->name);
669 pr_info("%s(%s): %d resets\n", __func__, engine->name, count);
672 st_engine_heartbeat_enable(engine);
687 struct intel_engine_cs *engine;
692 /* Check that we can issue an engine reset on an idle engine (no-op) */
703 for_each_engine(engine, gt, id) {
706 bool using_guc = intel_engine_uses_guc(engine);
712 if (active && !intel_engine_can_store_dword(engine))
715 if (!wait_for_idle(engine)) {
717 engine->name);
723 reset_engine_count = i915_reset_engine_count(global, engine);
725 st_engine_heartbeat_disable(engine);
734 err = intel_selftest_modify_policy(engine, &saved,
737 pr_err("[%s] Modify policy failed: %d!\n", engine->name, err);
742 rq = hang_create_request(&h, engine);
746 engine->name, err);
758 intel_engine_dump(engine, &p,
759 "%s\n", engine->name);
768 err = intel_engine_reset(engine, NULL);
771 engine->name, err);
777 /* Ensure the reset happens and kills the engine */
781 engine->name, rq->fence.context,
790 pr_err("Full GPU reset recorded! (engine reset expected)\n");
795 /* GuC based resets are not logged per engine */
797 if (i915_reset_engine_count(global, engine) !=
799 pr_err("%s engine reset not recorded!\n",
800 engine->name);
809 err2 = intel_selftest_restore_policy(engine, &saved);
811 pr_err("[%s] Restore policy failed: %d!\n", engine->name, err);
818 st_engine_heartbeat_enable(engine);
820 engine->name, count, active ? "active" : "idle");
827 pr_err("[%s] Flush failed: %d!\n", engine->name, err);
856 struct intel_engine_cs *engine;
877 rq->engine->name,
882 intel_gt_set_wedged(rq->engine->gt);
895 struct intel_engine_cs *engine = arg->engine;
902 ce[count] = intel_context_create(engine);
906 engine->name, count, arg->result);
922 pr_err("[%s] Create request #%d failed: %d!\n", engine->name, idx, err);
929 if (engine->sched_engine->schedule && arg->flags & TEST_PRIORITY) {
934 engine->sched_engine->schedule(rq[idx], &attr);
939 pr_err("[%s] Request put failed: %d!\n", engine->name, err);
950 pr_err("[%s] Request put #%ld failed: %d!\n", engine->name, count, err);
967 struct intel_engine_cs *engine, *other;
973 /* Check that issuing a reset on one engine does not interfere
974 * with any other engine.
993 for_each_engine(engine, gt, id) {
996 bool using_guc = intel_engine_uses_guc(engine);
1000 if (!intel_engine_can_store_dword(engine))
1005 if (!wait_for_idle(engine)) {
1007 engine->name, test_name);
1019 if (other == engine && !(flags & TEST_SELF))
1022 if (other != engine && !(flags & TEST_OTHERS))
1025 threads[tmp].engine = other;
1033 engine->name, err);
1044 st_engine_heartbeat_disable_no_pm(engine);
1052 err = intel_selftest_modify_policy(engine, &saved,
1055 pr_err("[%s] Modify policy failed: %d!\n", engine->name, err);
1060 rq = hang_create_request(&h, engine);
1064 engine->name, err);
1076 intel_engine_dump(engine, &p,
1077 "%s\n", engine->name);
1084 intel_engine_pm_get(engine);
1088 err = intel_engine_reset(engine, NULL);
1091 engine->name, test_name, err);
1097 /* Ensure the reset happens and kills the engine */
1101 engine->name, rq->fence.context,
1110 engine->name, test_name,
1127 engine->name, test_name,
1130 intel_engine_dump(engine, &p,
1131 "%s\n", engine->name);
1144 intel_engine_pm_put(engine);
1146 if (!(flags & TEST_SELF) && !wait_for_idle(engine)) {
1152 engine->name, test_name);
1153 intel_engine_dump(engine, &p,
1154 "%s\n", engine->name);
1161 err2 = intel_selftest_restore_policy(engine, &saved);
1163 pr_err("[%s] Restore policy failed: %d!\n", engine->name, err2);
1170 st_engine_heartbeat_enable_no_pm(engine);
1173 engine->name, test_name, count);
1175 /* GuC based resets are not logged per engine */
1177 reported = i915_reset_engine_count(global, engine);
1178 reported -= threads[engine->id].resets;
1181 engine->name, test_name, count, reported);
1198 pr_err("kthread for other engine %s failed, err=%d\n",
1206 /* GuC based resets are not logged per engine */
1208 if (other->uabi_class != engine->uabi_class &&
1211 pr_err("Innocent engine %s was reset (count=%ld)\n",
1233 pr_err("[%s] Flush failed: %d!\n", engine->name, err);
1299 struct intel_engine_cs *engine;
1306 engine = intel_selftest_find_any_engine(gt);
1308 if (!engine || !intel_engine_can_store_dword(engine))
1317 pr_err("[%s] Hang init failed: %d!\n", engine->name, err);
1321 rq = hang_create_request(&h, engine);
1324 pr_err("[%s] Create hang request failed: %d!\n", engine->name, err);
1336 intel_engine_dump(rq->engine, &p, "%s\n", rq->engine->name);
1431 struct intel_engine_cs *engine;
1443 engine = intel_selftest_find_any_engine(gt);
1445 if (!engine || !intel_engine_can_store_dword(engine))
1452 pr_err("[%s] Hang init failed: %d!\n", engine->name, err);
1459 pr_err("[%s] Create object failed: %d!\n", engine->name, err);
1474 pr_err("[%s] VMA instance failed: %d!\n", engine->name, err);
1478 rq = hang_create_request(&h, engine);
1481 pr_err("[%s] Create hang request failed: %d!\n", engine->name, err);
1493 pr_err("[%s] VMA pin failed: %d!\n", engine->name, err);
1509 pr_err("[%s] Move to active failed: %d!\n", engine->name, err);
1525 intel_engine_dump(rq->engine, &p, "%s\n", rq->engine->name);
1536 pr_err("[%s] Thread spawn failed: %d!\n", engine->name, err);
1548 intel_engine_dump(rq->engine, &p, "%s\n", rq->engine->name);
1556 fake_hangcheck(gt, rq->engine->mask);
1621 struct intel_engine_cs *engine;
1624 for_each_engine(engine, gt, id) {
1625 if (engine == exclude)
1628 if (!wait_for_idle(engine))
1639 struct intel_engine_cs *engine;
1652 for_each_engine(engine, gt, id) {
1657 bool using_guc = intel_engine_uses_guc(engine);
1659 if (!intel_engine_can_store_dword(engine))
1663 err = intel_selftest_modify_policy(engine, &saved,
1666 pr_err("[%s] Modify policy failed: %d!\n", engine->name, err);
1671 prev = hang_create_request(&h, engine);
1674 pr_err("[%s] Create 'prev' hang request failed: %d!\n", engine->name, err);
1686 rq = hang_create_request(&h, engine);
1689 pr_err("[%s] Create hang request failed: %d!\n", engine->name, err);
1704 * engine and so avoid repeatedly resetting innocents.
1706 err = wait_for_others(gt, engine);
1709 __func__, engine->name);
1722 __func__, engine->name,
1724 intel_engine_dump(engine, &p,
1725 "%s\n", engine->name);
1769 engine->name, count);
1772 intel_gt_chipset_flush(engine->gt);
1778 int err2 = intel_selftest_restore_policy(engine, &saved);
1782 __func__, __LINE__, engine->name, err2);
1791 pr_err("[%s] Flush failed: %d!\n", engine->name, err);
1811 struct intel_engine_cs *engine;
1817 engine = intel_selftest_find_any_engine(gt);
1819 /* Check that we can issue a global GPU and engine reset */
1824 if (!engine || !intel_engine_can_store_dword(engine))
1829 pr_err("[%s] Hang init failed: %d!\n", engine->name, err);
1833 rq = hang_create_request(&h, engine);
1836 pr_err("[%s] Create hang request failed: %d!\n", engine->name, err);
1848 intel_engine_dump(rq->engine, &p, "%s\n", rq->engine->name);
1859 intel_gt_handle_error(gt, engine->mask, 0, NULL);
1876 static int __igt_atomic_reset_engine(struct intel_engine_cs *engine,
1880 struct tasklet_struct * const t = &engine->sched_engine->tasklet;
1884 engine->name, mode, p->name);
1892 err = __intel_engine_reset_bh(engine, NULL);
1904 engine->name, mode, p->name);
1909 static int igt_atomic_reset_engine(struct intel_engine_cs *engine,
1916 err = __igt_atomic_reset_engine(engine, p, "idle");
1920 err = hang_init(&h, engine->gt);
1922 pr_err("[%s] Hang init failed: %d!\n", engine->name, err);
1926 rq = hang_create_request(&h, engine);
1929 pr_err("[%s] Create hang request failed: %d!\n", engine->name, err);
1937 err = __igt_atomic_reset_engine(engine, p, "active");
1940 __func__, engine->name,
1942 intel_gt_set_wedged(engine->gt);
1949 intel_wedge_on_timeout(&w, engine->gt, HZ / 20 /* 50ms */)
1951 if (intel_gt_is_wedged(engine->gt))
1982 struct intel_engine_cs *engine;
1985 for_each_engine(engine, gt, id) {
1986 err = igt_atomic_reset_engine(engine, p);