drm/i915: Remove GPU reset dependence on struct_mutex

Now that the submission backends are controlled via their own spinlocks,
with a wave of a magic wand we can lift the struct_mutex requirement
around GPU reset. That is we allow the submission frontend (userspace)
to keep on submitting while we process the GPU reset as we can suspend
the backend independently.

The major change is around the backoff/handoff strategy for performing
the reset. With no mutex deadlock, we no longer have to coordinate with
any waiter, and just perform the reset immediately.

Testcase: igt/gem_mmap_gtt/hang # regresses
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190125132230.22221-3-chris@chris-wilson.co.uk

1 files changed, 0 insertions, 47 deletions

diff --git a/drivers/gpu/drm/i915/i915_request.c b/drivers/gpu/drm/i915/i915_request.c
index ddc35e9dc0c0..f4241a17e2ad 100644
--- a/drivers/gpu/drm/i915/i915_request.c
+++ b/drivers/gpu/drm/i915/i915_request.c
@@ -1083,18 +1083,6 @@ static bool __i915_spin_request(const struct i915_request *rq,
         return false;
 }
 
-static bool __i915_wait_request_check_and_reset(struct i915_request *request)
-{
-        struct i915_gpu_error *error = &request->i915->gpu_error;
-
-        if (likely(!i915_reset_handoff(error)))
-                return false;
-
-        __set_current_state(TASK_RUNNING);
-        i915_reset(request->i915, error->stalled_mask, error->reason);
-        return true;
-}
-
 /**
  * i915_request_wait - wait until execution of request has finished
  * @rq: the request to wait upon
@@ -1120,17 +1108,10 @@ long i915_request_wait(struct i915_request *rq,
 {
         const int state = flags & I915_WAIT_INTERRUPTIBLE ?
                 TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE;
-        wait_queue_head_t *errq = &rq->i915->gpu_error.wait_queue;
-        DEFINE_WAIT_FUNC(reset, default_wake_function);
         DEFINE_WAIT_FUNC(exec, default_wake_function);
         struct intel_wait wait;
 
         might_sleep();
-#if IS_ENABLED(CONFIG_LOCKDEP)
-        GEM_BUG_ON(debug_locks &&
-                   !!lockdep_is_held(&rq->i915->drm.struct_mutex) !=
-                   !!(flags & I915_WAIT_LOCKED));
-#endif
         GEM_BUG_ON(timeout < 0);
 
         if (i915_request_completed(rq))
@@ -1140,11 +1121,7 @@ long i915_request_wait(struct i915_request *rq,
                 return -ETIME;
 
         trace_i915_request_wait_begin(rq, flags);
-
         add_wait_queue(&rq->execute, &exec);
-        if (flags & I915_WAIT_LOCKED)
-                add_wait_queue(errq, &reset);
-
         intel_wait_init(&wait);
         if (flags & I915_WAIT_PRIORITY)
                 i915_schedule_bump_priority(rq, I915_PRIORITY_WAIT);
@@ -1155,10 +1132,6 @@ restart:
                 if (intel_wait_update_request(&wait, rq))
                         break;
 
-                if (flags & I915_WAIT_LOCKED &&
-                    __i915_wait_request_check_and_reset(rq))
-                        continue;
-
                 if (signal_pending_state(state, current)) {
                         timeout = -ERESTARTSYS;
                         goto complete;
@@ -1188,9 +1161,6 @@ restart:
                  */
                 goto wakeup;
 
-        if (flags & I915_WAIT_LOCKED)
-                __i915_wait_request_check_and_reset(rq);
-
         for (;;) {
                 if (signal_pending_state(state, current)) {
                         timeout = -ERESTARTSYS;
@@ -1214,21 +1184,6 @@ wakeup:
                 if (i915_request_completed(rq))
                         break;
 
-                /*
-                 * If the GPU is hung, and we hold the lock, reset the GPU
-                 * and then check for completion. On a full reset, the engine's
-                 * HW seqno will be advanced passed us and we are complete.
-                 * If we do a partial reset, we have to wait for the GPU to
-                 * resume and update the breadcrumb.
-                 *
-                 * If we don't hold the mutex, we can just wait for the worker
-                 * to come along and update the breadcrumb (either directly
-                 * itself, or indirectly by recovering the GPU).
-                 */
-                if (flags & I915_WAIT_LOCKED &&
-                    __i915_wait_request_check_and_reset(rq))
-                        continue;
-
                 /* Only spin if we know the GPU is processing this request */
                 if (__i915_spin_request(rq, wait.seqno, state, 2))
                         break;
@@ -1242,8 +1197,6 @@ wakeup:
         intel_engine_remove_wait(rq->engine, &wait);
 complete:
         __set_current_state(TASK_RUNNING);
-        if (flags & I915_WAIT_LOCKED)
-                remove_wait_queue(errq, &reset);
         remove_wait_queue(&rq->execute, &exec);
         trace_i915_request_wait_end(rq);