Execlist based Engine reset patches
Subsystems (2)
v2 cover Execlist based Engine reset patches
These patches are to add engine reset feature from Gen8. This is also referred to as Timeout detection and recovery (TDR). This complements to the full gpu reset feature available in i915 but it only allows to reset a particular engine instead of all engines thus providing a light weight engine reset and recovery mechanism.
This implementation is for execlist based submission only hence limited from Gen8 onwards.
Timeout detection is by means of existing hangcheck which remains the same, main changes are to the recovery mechanism. Once we detect a hang on a particular engine we identify the request that caused the hang, skip the request and adjust head pointers to allow the execution to proceed normally. After some cleanup, submissions are restarted to process remaining work queued to that engine.
If engine reset fails to recover engine correctly then we fallback to full gpu reset.
v2: ELSP queue request tracking and reset path changes to handle incomplete requests during reset. Thanks to Chris Wilson for providing these patches.
Arun Siluvery (6):
drm/i915: Update i915.reset to handle engine resets drm/i915/tdr: Modify error handler for per engine hang recovery drm/i915/tdr: Add support for per engine reset recovery drm/i915/tdr: Add engine reset count to error state drm/i915/tdr: Export reset count info to debugfs drm/i915/tdr: Enable Engine reset and recovery support
Chris Wilson (4):
drm/i915: Record the position of the start of the request drm/i915: Simplify ELSP queue request tracking drm/i915: Update reset path to fix incomplete requests drm/i915: Separate out reset flags from the reset counter
Mika Kuoppala (1):
drm/i915: Skip reset request if there is one already
drivers/gpu/drm/i915/i915_debugfs.c | 21 +- drivers/gpu/drm/i915/i915_drv.c | 90 ++++++- drivers/gpu/drm/i915/i915_drv.h | 59 ++--- drivers/gpu/drm/i915/i915_gem.c | 74 ++++-- drivers/gpu/drm/i915/i915_gem_context.c | 16 -- drivers/gpu/drm/i915/i915_gem_request.c | 37 +-- drivers/gpu/drm/i915/i915_gem_request.h | 24 +- drivers/gpu/drm/i915/i915_gpu_error.c | 9 +- drivers/gpu/drm/i915/i915_irq.c | 125 +++++---- drivers/gpu/drm/i915/i915_params.c | 6 +- drivers/gpu/drm/i915/i915_params.h | 2 +- drivers/gpu/drm/i915/intel_display.c | 25 +- drivers/gpu/drm/i915/intel_drv.h | 4 +- drivers/gpu/drm/i915/intel_lrc.c | 455 +++++++++++++------------------- drivers/gpu/drm/i915/intel_lrc.h | 3 +- drivers/gpu/drm/i915/intel_ringbuffer.c | 32 ++- drivers/gpu/drm/i915/intel_ringbuffer.h | 9 +- drivers/gpu/drm/i915/intel_uncore.c | 55 +++- 18 files changed, 565 insertions(+), 481 deletions(-)
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 1/11 drm/i915: Record the position of the start of the request
From: Chris Wilson <[email protected]>
Not only does it make for good documentation and debugging aide, but it is also vital for when we want to unwind requests - such as when throwing away an incomplete request.
--- drivers/gpu/drm/i915/i915_drv.h | 1 + drivers/gpu/drm/i915/i915_gem_request.c | 13 +++++++++---- drivers/gpu/drm/i915/i915_gpu_error.c | 6 ++++-- 3 files changed, 14 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +1 -0
@@ -557,6 +557,7 @@ struct drm_i915_error_state {struct drm_i915_error_request {long jiffies;u32 seqno; +u32 head;u32 tail; } *requests;
drivers/gpu/drm/i915/i915_gem_request.c +9 -4
@@ -391,6 +391,13 @@ i915_gem_request_alloc(struct intel_engine_cs *engine,if (ret) goto err_ctx; +/* Record the position of the start of the request so that +* should we detect the updated seqno part-way through the +* GPU processing the request, we never over-estimate the +* position of the head. +*/ + req->head = req->ring->tail; +return req; err_ctx:
@@ -467,8 +474,6 @@ void __i915_add_request(struct drm_i915_gem_request *request,trace_i915_gem_request_add (request); - request->head = request_start; -/* Whilst this request exists, batch_obj will be on the * active_list, and so will hold the active reference. Only when this * request is retired will the the batch_obj be moved onto the
@@ -489,10 +494,10 @@ void __i915_add_request(struct drm_i915_gem_request *request,list_add_tail (&request->link, &engine->request_list);list_add_tail (&request->ring_link, &ring->request_list); -/* Record the position of the start of the request so that +/* Record the position of the start of the breadcrumb so that * should we detect the updated seqno part-way through the * GPU processing the request, we never over-estimate the -* position of the head. +* position of the ring's HEAD. */ request->postfix = ring->tail;
drivers/gpu/drm/i915/i915_gpu_error.c +4 -2
@@ -455,9 +455,10 @@ int i915_error_state_to_str(struct drm_i915_error_state_buf *m, dev_priv->engine[i].name, ee->num_requests);for (j =0 ; j < ee->num_requests; j++) { -err_printf (m," seqno 0x%08x, emitted %ld, tail 0x%08x\n" , +err_printf (m," seqno 0x%08x, emitted %ld, head 0x%08x tail 0x%08x\n" , ee->requests[j].seqno, ee->requests[j].jiffies, + ee->requests[j].head, ee->requests[j].tail); } }
@@ -1205,7 +1206,8 @@ static void i915_gem_record_rings(struct drm_i915_private *dev_priv, erq = &ee->requests[count++]; erq->seqno = request->fence.seqno; erq->jiffies = request->emitted_jiffies; - erq->tail = request->postfix; + erq->head = request->head; + erq->tail = request->tail; } } }
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 2/11 drm/i915: Simplify ELSP queue request tracking
In reply to Arun SiluveryFrom: Chris Wilson <[email protected]>
Emulate HW to track and manage ELSP queue. A set of SW ports are defined and requests are assigned to these ports before submitting them to HW. This helps in cleaning up incomplete requests during reset recovery easier especially after engine reset by decoupling elsp queue management. This will become more clear in the next patch.
In the engine reset case we want to resume where we left-off after skipping the incomplete batch which requires checking the elsp queue, removing element and fixing elsp_submitted counts in some cases. Instead of directly manipulating the elsp queue from reset path we can examine these ports, fix up ringbuffer pointers using the incomplete request and restart submissions again after reset.
--- drivers/gpu/drm/i915/i915_debugfs.c | 2 +- drivers/gpu/drm/i915/i915_gem.c | 6 +- drivers/gpu/drm/i915/i915_gem_request.c | 11 +- drivers/gpu/drm/i915/i915_gem_request.h | 24 +- drivers/gpu/drm/i915/intel_lrc.c | 417 +++++++++++--------------------- drivers/gpu/drm/i915/intel_lrc.h | 2 - drivers/gpu/drm/i915/intel_ringbuffer.h | 7 +- 7 files changed, 159 insertions(+), 310 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +1 -1
@@ -2200,7 +2200,7 @@ static int i915_execlists(struct seq_file *m, void *data) status_pointer =I915_READ (RING_CONTEXT_STATUS_PTR (engine));seq_printf (m,"\tStatus pointer: 0x%08X\n" , status_pointer); - read_pointer = engine->next_context_status_buffer; + read_pointer =GEN8_CSB_READ_PTR (status_pointer); write_pointer =GEN8_CSB_WRITE_PTR (status_pointer);if (read_pointer > write_pointer) write_pointer +=GEN8_CSB_ENTRIES ;
drivers/gpu/drm/i915/i915_gem.c +5 -1
@@ -2443,7 +2443,11 @@ static void i915_gem_reset_engine_cleanup(struct intel_engine_cs *engine)/* Ensure irq handler finishes or is cancelled. */ tasklet_kill (&engine->irq_tasklet); -intel_execlists_cancel_requests (engine); +INIT_LIST_HEAD (&engine->execlist_queue); +i915_gem_request_assign (&engine->execlist_port[0 ].request, +NULL ); +i915_gem_request_assign (&engine->execlist_port[1 ].request, +NULL ); }/*
drivers/gpu/drm/i915/i915_gem_request.c +6 -5
@@ -736,16 +736,18 @@ complete:return ret; } -static void engine_retire_requests (struct intel_engine_cs *engine) +static bool engine_retire_requests (struct intel_engine_cs *engine) {struct drm_i915_gem_request *request, *next;list_for_each_entry_safe (request, next, &engine->request_list, link) {if (!i915_gem_request_completed (request)) -break ; +return false;i915_gem_request_retire (request); } + +return true; }void i915_gem_retire_requests (struct drm_i915_private *dev_priv)
@@ -759,9 +761,8 @@ void i915_gem_retire_requests(struct drm_i915_private *dev_priv)GEM_BUG_ON (!dev_priv->gt.awake); -for_each_engine (engine, dev_priv) { -engine_retire_requests (engine); -if (!intel_engine_is_active (engine)) +for_each_engine_masked (engine, dev_priv, dev_priv->gt.active_engines) { +if (engine_retire_requests (engine)) dev_priv->gt.active_engines &= ~intel_engine_flag (engine); }
drivers/gpu/drm/i915/i915_gem_request.h +4 -20
@@ -94,6 +94,9 @@ struct drm_i915_gem_request {/** Position in the ringbuffer of the end of the whole request */ u32 tail; +/** Position in the ringbuffer after the end of the whole request */ +u32 wa_tail; +/** Preallocate space in the ringbuffer for the emitting the request */ u32 reserved_space;
@@ -130,27 +133,8 @@ struct drm_i915_gem_request {/** process identifier submitting this request */ struct pid *pid; -/** -* The ELSP only accepts two elements at a time, so we queue -* context/tail pairs on a given queue (ring->execlist_queue) until the -* hardware is available. The queue serves a double purpose: we also use -* it to keep track of the up to 2 contexts currently in the hardware -* (usually one in execution and the other queued up by the GPU): We -* only remove elements from the head of the queue when the hardware -* informs us that an element has been completed. -* -* All accesses to the queue are mediated by a spinlock -* (ring->execlist_lock). -*/ - -/** Execlist link in the submission queue.*/ +/** Link in the execlist submission queue, guarded by execlist_lock. */ struct list_head execlist_link; - -/** Execlists no. of times this request has been sent to the ELSP */ -int elsp_submitted; - -/** Execlists context hardware id. */ -unsigned int ctx_hw_id; };extern const struct fence_ops i915_fence_ops;
drivers/gpu/drm/i915/intel_lrc.c +138 -279
532 lines not on this page · raw message
drivers/gpu/drm/i915/intel_lrc.h +0 -2
@@ -97,6 +97,4 @@ int intel_sanitize_enable_execlists(struct drm_i915_private *dev_priv, int enable_execlists);void intel_execlists_enable_submission (struct drm_i915_private *dev_priv); -void intel_execlists_cancel_requests (struct intel_engine_cs *engine); -#endif /* _INTEL_LRC_H_ */
drivers/gpu/drm/i915/intel_ringbuffer.h +5 -2
@@ -288,11 +288,14 @@ struct intel_engine_cs {/* Execlists */ struct tasklet_struct irq_tasklet;spinlock_t execlist_lock;/* used inside tasklet, use spin_lock_bh */ +struct execlist_port { +struct drm_i915_gem_request *request; +unsigned count; + } execlist_port[2 ];struct list_head execlist_queue;unsigned int fw_domains; -unsigned int next_context_status_buffer; -unsigned int idle_lite_restore_wa;bool disable_lite_restore_wa; +bool preempt_wa;u32 ctx_desc_template;/**
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 3/11 drm/i915: Update reset path to fix incomplete requests
In reply to Arun SiluveryFrom: Chris Wilson <[email protected]>
Update reset path in preparation for engine reset which requires identification of incomplete requests and associated context and fixing their state so that engine can resume correctly after reset.
The request that caused the hang will be skipped and head is reset to the start of breadcrumb. This allows us to resume from where we left-off. Since this request didn't complete normally we also need to cleanup elsp queue manually.
--- drivers/gpu/drm/i915/i915_drv.c | 4 +- drivers/gpu/drm/i915/i915_drv.h | 2 +- drivers/gpu/drm/i915/i915_gem.c | 68 ++++++++++++++++++++++----------- drivers/gpu/drm/i915/i915_gem_context.c | 16 -------- drivers/gpu/drm/i915/intel_lrc.c | 34 ++++++++++++++++- drivers/gpu/drm/i915/intel_ringbuffer.c | 32 ++++++++++------ drivers/gpu/drm/i915/intel_ringbuffer.h | 2 + 7 files changed, 104 insertions(+), 54 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +2 -2
@@ -1578,7 +1578,7 @@ static int i915_drm_resume(struct drm_device *dev)mutex_lock (&dev->struct_mutex);if (i915_gem_init_hw (dev)) {DRM_ERROR ("failed to re-initialize GPU, declaring wedged!\n" ); -atomic_or (I915_WEDGED , &dev_priv->gpu_error.reset_counter); +i915_gem_set_wedged (dev_priv); }mutex_unlock (&dev->struct_mutex);
@@ -1802,7 +1802,7 @@ int i915_reset(struct drm_i915_private *dev_priv)return 0 ; error: -atomic_or (I915_WEDGED , &error->reset_counter); +i915_gem_set_wedged (dev_priv);mutex_unlock (&dev->struct_mutex);return ret; }
drivers/gpu/drm/i915/i915_drv.h +1 -1
@@ -3245,6 +3245,7 @@ static inline u32 i915_reset_count(struct i915_gpu_error *error) }void i915_gem_reset (struct drm_device *dev); +void i915_gem_set_wedged (struct drm_i915_private *dev_priv);bool i915_gem_clflush_object (struct drm_i915_gem_object *obj,bool force);int __must_check i915_gem_init (struct drm_device *dev);int __must_check i915_gem_init_hw (struct drm_device *dev);
@@ -3364,7 +3365,6 @@ void i915_gem_object_save_bit_17_swizzle(struct drm_i915_gem_object *obj);int __must_check i915_gem_context_init (struct drm_device *dev);void i915_gem_context_lost (struct drm_i915_private *dev_priv);void i915_gem_context_fini (struct drm_device *dev); -void i915_gem_context_reset (struct drm_device *dev);int i915_gem_context_open (struct drm_device *dev,struct drm_file *file);void i915_gem_context_close (struct drm_device *dev,struct drm_file *file);int i915_switch_context (struct drm_i915_gem_request *req);
drivers/gpu/drm/i915/i915_gem.c +46 -22
111 lines not on this page · raw message
drivers/gpu/drm/i915/i915_gem_context.c +0 -16
@@ -405,22 +405,6 @@ static void i915_gem_context_unpin(struct i915_gem_context *ctx, } } -void i915_gem_context_reset (struct drm_device *dev) -{ -struct drm_i915_private *dev_priv =to_i915 (dev); - -lockdep_assert_held (&dev->struct_mutex); - -if (i915.enable_execlists) { -struct i915_gem_context *ctx; - -list_for_each_entry (ctx, &dev_priv->context_list, link) -intel_lr_context_reset (dev_priv, ctx); - } - -i915_gem_context_lost (dev_priv); -} -int i915_gem_context_init (struct drm_device *dev) {struct drm_i915_private *dev_priv =to_i915 (dev);
drivers/gpu/drm/i915/intel_lrc.c +33 -1
@@ -1171,6 +1171,7 @@ static int gen8_init_common_ring(struct intel_engine_cs *engine) {struct drm_i915_private *dev_priv = engine->i915; +intel_mocs_init_engine (engine);lrc_init_hws (engine); I915_WRITE_IMR(engine,
@@ -1186,7 +1187,10 @@ static int gen8_init_common_ring(struct intel_engine_cs *engine)intel_engine_init_hangcheck (engine); -return intel_mocs_init_engine (engine); +if (engine->execlist_port[0 ].request) +execlists_submit_ports (engine); + +return 0 ; }static int gen8_init_render_ring (struct intel_engine_cs *engine)
@@ -1222,6 +1226,33 @@ static int gen9_init_render_ring(struct intel_engine_cs *engine)return init_workarounds_ring (engine); } +static void reset_common_ring (struct intel_engine_cs *engine, +struct drm_i915_gem_request *request) +{ +struct drm_i915_private *dev_priv = engine->i915; +struct i915_gem_context *ctx = request->ctx; +struct intel_context *ce = &ctx->engine[engine->id]; +u32 *reg_state; + + reg_state = ce->lrc_reg_state; + reg_state[CTX_RING_HEAD +1 ] = request->postfix; + + request->ring->head = request->postfix; + request->ring->last_retired_head =-1 ; +intel_ring_update_space (request->ring); + +if (request == engine->execlist_port[1 ].request) { +i915_gem_request_put (engine->execlist_port[0 ].request); + engine->execlist_port[0 ] = engine->execlist_port[1 ]; +memset (&engine->execlist_port[1 ],0 , +sizeof (engine->execlist_port[1 ])); + } + + engine->execlist_port[0 ].count =0 ; + +I915_WRITE (RING_CONTEXT_STATUS_PTR (engine),_MASKED_FIELD (0xffff ,0 )); +} +static int intel_logical_ring_emit_pdps (struct drm_i915_gem_request *req) {struct i915_hw_ppgtt *ppgtt = req->ctx->ppgtt;
@@ -1586,6 +1617,7 @@ logical_ring_default_vfuncs(struct intel_engine_cs *engine) {/* Default vfuncs which can be overriden by each engine. */ engine->init_hw = gen8_init_common_ring; + engine->reset_hw = reset_common_ring; engine->emit_flush = gen8_emit_flush; engine->emit_request = gen8_emit_request; engine->submit_request = execlists_submit_request;
drivers/gpu/drm/i915/intel_ringbuffer.c +20 -12
@@ -577,34 +577,31 @@ static int init_ring_common(struct intel_engine_cs *engine)if (I915_READ_HEAD (engine))DRM_DEBUG ("%s initialization failed [head=%08x], fudging\n" , engine->name,I915_READ_HEAD (engine)); -I915_WRITE_HEAD (engine,0 ); - (void )I915_READ_HEAD (engine); +I915_WRITE_HEAD (engine, ring->head); +I915_WRITE_TAIL (engine, ring->tail); + (void )I915_READ_TAIL (engine);I915_WRITE_CTL (engine, ((ring->size -PAGE_SIZE ) &RING_NR_PAGES ) |RING_VALID );/* If the head is still not zero, the ring is dead */ -if (wait_for ((I915_READ_CTL (engine) &RING_VALID ) !=0 && -I915_READ_START (engine) ==i915_gem_obj_ggtt_offset (obj) && - (I915_READ_HEAD (engine) &HEAD_ADDR ) ==0 ,50 )) { +if (intel_wait_for_register_fw (dev_priv,RING_CTL (engine->mmio_base), +RING_VALID ,RING_VALID , +50 )) {DRM_ERROR ("%s initialization failed " -"ctl %08x (valid? %d) head %08x tail %08x start %08x [expected %08lx]\n" , +"ctl %08x (valid? %d) head %08x [%08x] tail %08x [%08x] start %08x [expected %08lx]\n" , engine->name,I915_READ_CTL (engine),I915_READ_CTL (engine) &RING_VALID , -I915_READ_HEAD (engine),I915_READ_TAIL (engine), +I915_READ_HEAD (engine), ring->head, +I915_READ_TAIL (engine), ring->tail,I915_READ_START (engine), (unsigned long )i915_gem_obj_ggtt_offset (obj)); ret = -EIO ; goto out; } - ring->last_retired_head =-1 ; - ring->head =I915_READ_HEAD (engine); - ring->tail =I915_READ_TAIL (engine) &TAIL_ADDR ; -intel_ring_update_space (ring); -intel_engine_init_hangcheck (engine); out:
@@ -613,6 +610,16 @@ out:return ret; } +static void reset_ring_common (struct intel_engine_cs *engine, +struct drm_i915_gem_request *request) +{ +struct intel_ring *ring = request->ring; + + ring->head = request->postfix; + ring->last_retired_head =-1 ; +intel_ring_update_space (ring); +} +void intel_fini_pipe_control (struct intel_engine_cs *engine) {if (engine->scratch.obj ==NULL )
@@ -2748,6 +2755,7 @@ static void intel_ring_default_vfuncs(struct drm_i915_private *dev_priv,intel_ring_init_semaphores (dev_priv, engine); engine->init_hw = init_ring_common; + engine->reset_hw = reset_ring_common; engine->emit_request = i9xx_emit_request;if (i915.semaphores)
drivers/gpu/drm/i915/intel_ringbuffer.h +2 -0
@@ -204,6 +204,8 @@ struct intel_engine_cs {void (*irq_disable)(struct intel_engine_cs *engine);int (*init_hw)(struct intel_engine_cs *engine); +void (*reset_hw)(struct intel_engine_cs *engine, +struct drm_i915_gem_request *req);int (*init_context)(struct drm_i915_gem_request *req);
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 4/11 drm/i915: Update i915.reset to handle engine resets
In reply to Arun SiluveryIn preparation for engine reset work update this parameter to handle more than one type of reset. Default at the moment is still full gpu reset.
--- drivers/gpu/drm/i915/i915_params.c | 6 +++--- drivers/gpu/drm/i915/i915_params.h | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_params.c +3 -3
@@ -45,7 +45,7 @@ struct i915_params i915 __read_mostly = { .fastboot = 0, .prefault_disable = 0, .load_detect_test = 0, - .reset = true, + .reset = 1, .invert_brightness = 0, .disable_display = 0, .enable_cmd_parser = 1,
@@ -111,8 +111,8 @@ MODULE_PARM_DESC(vbt_sdvo_panel_type,"Override/Ignore selection of SDVO panel mode in the VBT " "(-2=ignore, -1=auto [default], index in VBT BIOS table)"); -module_param_named_unsafe (reset, i915.reset, bool,0600 ); -MODULE_PARM_DESC (reset,"Attempt GPU resets (default: true)" ); +module_param_named_unsafe (reset, i915.reset, int,0600 ); +MODULE_PARM_DESC (reset,"Attempt GPU resets (0=disabled, 1=full gpu reset [default], 2=engine reset)" );module_param_named_unsafe (enable_hangcheck, i915.enable_hangcheck, bool,0644 ); MODULE_PARM_DESC(enable_hangcheck,
drivers/gpu/drm/i915/i915_params.h +1 -1
@@ -34,6 +34,7 @@ struct i915_params {int lvds_channel_mode;int panel_use_ssc;int vbt_sdvo_panel_type; +int reset;int enable_rc6;int enable_dc;int enable_fbc;
@@ -57,7 +58,6 @@ struct i915_params {bool fastboot;bool prefault_disable;bool load_detect_test; -bool reset;bool disable_display;bool verbose_state_checks;bool nuclear_pageflip;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 5/11 drm/i915: Separate out reset flags from the reset counter
In reply to Arun SiluveryFrom: Chris Wilson <[email protected]>
In preparation for introducing a per-engine reset, we can first separate the mixing of the reset state from the global reset counter.
The loss of atomicity in updating the reset state poses a small problem for handling the waiters. For requests, this is solved by advancing the seqno so that a waiter waking up after the reset knows the request is complete. For pending flips, we still rely on the increment of the global reset epoch (as well as the reset-in-progress flag) to signify when the hardware was reset.
The advantage, now that we do not inspect the reset state during reset itself i.e. we no longer emit requests during reset, is that we can use the atomic updates of the state flags to ensure that only one reset worker is active.
--- drivers/gpu/drm/i915/i915_drv.c | 12 +--- drivers/gpu/drm/i915/i915_drv.h | 46 +++++--------- drivers/gpu/drm/i915/i915_gem.c | 2 +- drivers/gpu/drm/i915/i915_gem_request.c | 13 ++-- drivers/gpu/drm/i915/i915_irq.c | 104 +++++++++++++++----------------- drivers/gpu/drm/i915/intel_display.c | 25 +++++--- drivers/gpu/drm/i915/intel_drv.h | 4 +- 7 files changed, 91 insertions(+), 115 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +3 -9
@@ -1739,20 +1739,13 @@ int i915_reset(struct drm_i915_private *dev_priv) {struct drm_device *dev = &dev_priv->drm;struct i915_gpu_error *error = &dev_priv->gpu_error; -unsigned reset_counter;int ret;mutex_lock (&dev->struct_mutex);/* Clear any previous failed attempts at recovery. Time to try again. */ -atomic_andnot (I915_WEDGED , &error->reset_counter); - -/* Clear the reset-in-progress flag and increment the reset epoch. */ - reset_counter =atomic_inc_return (&error->reset_counter); -if (WARN_ON (__i915_reset_in_progress (reset_counter))) { - ret = -EIO ; - goto error; - } +__clear_bit (I915_WEDGED , &error->flags); + error->reset_count++;pr_notice ("drm/i915: Resetting chip after gpu hang\n" );
@@ -1789,6 +1782,7 @@ int i915_reset(struct drm_i915_private *dev_priv) goto error; } +clear_bit (I915_RESET_IN_PROGRESS , &error->flags);mutex_unlock (&dev->struct_mutex);/*
drivers/gpu/drm/i915/i915_drv.h +14 -32
77 lines not on this page · raw message
drivers/gpu/drm/i915/i915_gem.c +1 -1
@@ -2515,7 +2515,7 @@ void i915_gem_set_wedged(struct drm_i915_private *dev_priv) {struct intel_engine_cs *engine; -atomic_or (I915_WEDGED , &dev_priv->gpu_error.reset_counter); +set_bit (I915_WEDGED , &dev_priv->gpu_error.flags);for_each_engine (engine, dev_priv)i915_gem_cleanup_engine (engine);
drivers/gpu/drm/i915/i915_gem_request.c +7 -6
@@ -238,16 +238,18 @@ void i915_gem_request_retire_upto(struct drm_i915_gem_request *req) }while (tmp != req); } -static int i915_gem_check_wedge (unsigned int reset_counter,bool interruptible) +static int i915_gem_check_wedge (struct drm_i915_private *dev_priv) { -if (__i915_terminally_wedged (reset_counter)) +struct i915_gpu_error *error = &dev_priv->gpu_error; + +if (i915_terminally_wedged (error))return -EIO ; -if (__i915_reset_in_progress (reset_counter)) { +if (i915_reset_in_progress (error)) {/* Non-interruptible callers can't handle -EAGAIN, hence return * -EIO unconditionally for these. */ -if (!interruptible) +if (!dev_priv->mm.interruptible)return -EIO ;return -EAGAIN ;
@@ -336,7 +338,6 @@ i915_gem_request_alloc(struct intel_engine_cs *engine, struct i915_gem_context *ctx) {struct drm_i915_private *dev_priv = engine->i915; -unsigned int reset_counter =i915_reset_counter (&dev_priv->gpu_error);struct drm_i915_gem_request *req;u32 seqno;int ret;
@@ -345,7 +346,7 @@ i915_gem_request_alloc(struct intel_engine_cs *engine,* EIO if the GPU is already wedged, or EAGAIN to drop the struct_mutex * and restart. */ - ret =i915_gem_check_wedge (reset_counter, dev_priv->mm.interruptible); + ret =i915_gem_check_wedge (dev_priv);if (ret)return ERR_PTR (ret);
drivers/gpu/drm/i915/i915_irq.c +47 -57
125 lines not on this page · raw message
drivers/gpu/drm/i915/intel_display.c +17 -8
@@ -3174,15 +3174,26 @@ void intel_finish_reset(struct drm_i915_private *dev_priv)drm_modeset_unlock_all (&dev_priv->drm); } +static bool abort_flip_on_reset (struct intel_crtc *crtc) +{ +struct i915_gpu_error *error = &to_i915 (crtc->base.dev)->gpu_error; + +if (i915_reset_in_progress (error)) +return true; + +if (crtc->reset_count !=i915_reset_count (error)) +return true; + +return false; +} +static bool intel_crtc_has_pending_flip (struct drm_crtc *crtc) {struct drm_device *dev = crtc->dev;struct intel_crtc *intel_crtc =to_intel_crtc (crtc); -unsigned reset_counter;bool pending; - reset_counter =i915_reset_counter (&to_i915 (dev)->gpu_error); -if (intel_crtc->reset_counter != reset_counter) +if (abort_flip_on_reset (intel_crtc))return false;spin_lock_irq (&dev->event_lock);
@@ -10971,10 +10982,8 @@ static bool __pageflip_finished_cs(struct intel_crtc *crtc, {struct drm_device *dev = crtc->base.dev;struct drm_i915_private *dev_priv =to_i915 (dev); -unsigned reset_counter; - reset_counter =i915_reset_counter (&dev_priv->gpu_error); -if (crtc->reset_counter != reset_counter) +if (abort_flip_on_reset (crtc))return true;/*
@@ -11655,8 +11664,8 @@ static int intel_crtc_page_flip(struct drm_crtc *crtc,if (ret) goto cleanup; - intel_crtc->reset_counter =i915_reset_counter (&dev_priv->gpu_error); -if (__i915_reset_in_progress_or_wedged (intel_crtc->reset_counter)) { + intel_crtc->reset_count =i915_reset_count (&dev_priv->gpu_error); +if (i915_reset_in_progress_or_wedged (&dev_priv->gpu_error)) { ret = -EIO ; goto cleanup; }
drivers/gpu/drm/i915/intel_drv.h +2 -2
@@ -683,8 +683,8 @@ struct intel_crtc {struct intel_crtc_state *config; -/* reset counter value when the last flip was submitted */ -unsigned int reset_counter; +/* global reset count when the last flip was submitted */ +unsigned int reset_count;/* Access to these should be protected by dev_priv->irq_lock. */ bool cpu_fifo_underrun_disabled;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 6/11 drm/i915/tdr: Modify error handler for per engine hang recovery
In reply to Arun SiluveryThis is a preparatory patch which modifies error handler to do per engine hang recovery. The actual patch which implements this sequence follows later in the series. The aim is to prepare existing recovery function to adapt to this new function where applicable (which fails at this point because core implementation is lacking) and continue recovery using legacy full gpu reset.
A helper function is also added to query the availability of engine reset.
The error events behaviour that are used to notify user of reset are adapted to engine reset such that it doesn't break users listening to these events. In legacy we report an error event, a reset event before resetting the gpu and a reset done event marking the completion of reset. The same behaviour is adapted but reset event is only dispatched once even when multiple engines are hung. Finally once reset is complete we send reset done event as usual.
--- drivers/gpu/drm/i915/i915_drv.c | 26 +++++++++++++ drivers/gpu/drm/i915/i915_drv.h | 2 + drivers/gpu/drm/i915/i915_irq.c | 73 ++++++++++++++++++++++++++++--------- drivers/gpu/drm/i915/intel_uncore.c | 5 +++ 4 files changed, 88 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +26 -0
@@ -1801,6 +1801,32 @@ error:return ret; } +/** +* i915_reset_engine - reset GPU engine to recover from a hang +* @engine: engine to reset +* +* Reset a specific GPU engine. Useful if a hang is detected. +* Returns zero on successful reset or otherwise an error code. +* +* Procedure is fairly simple: +* - force engine to idle +* - save current state which includes head and current request +* - reset engine +* - restore saved state and resubmit context +*/ +int i915_reset_engine (struct intel_engine_cs *engine) +{ +int ret; +struct drm_i915_private *dev_priv = engine->i915; + +/* FIXME: replace me with engine reset sequence */ + ret = -ENODEV ; + +set_bit (I915_RESET_IN_PROGRESS , &dev_priv->gpu_error.flags); + +return ret; +} +static int i915_pm_suspend (struct device *dev) {struct pci_dev *pdev =to_pci_dev (dev);
drivers/gpu/drm/i915/i915_drv.h +2 -0
@@ -2868,6 +2868,8 @@ extern long i915_compat_ioctl(struct file *filp, unsigned int cmd,extern int intel_gpu_reset (struct drm_i915_private *dev_priv,u32 engine_mask);extern bool intel_has_gpu_reset (struct drm_i915_private *dev_priv);extern int i915_reset (struct drm_i915_private *dev_priv); +extern bool intel_has_engine_reset (struct drm_i915_private *dev_priv); +extern int i915_reset_engine (struct intel_engine_cs *engine);extern int intel_guc_reset (struct drm_i915_private *dev_priv);extern void intel_engine_init_hangcheck (struct intel_engine_cs *engine);extern unsigned long i915_chipset_val (struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/i915_irq.c +55 -18
121 lines not on this page · raw message
drivers/gpu/drm/i915/intel_uncore.c +5 -0
@@ -1775,6 +1775,11 @@ bool intel_has_gpu_reset(struct drm_i915_private *dev_priv)return intel_get_gpu_reset (dev_priv) !=NULL ; } +bool intel_has_engine_reset (struct drm_i915_private *dev_priv) +{ +return (INTEL_INFO (dev_priv)->gen >=8 && i915.reset ==2 ); +} +int intel_guc_reset (struct drm_i915_private *dev_priv) {int ret;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 7/11 drm/i915/tdr: Add support for per engine reset recovery
In reply to Arun SiluveryThis change implements support for per-engine reset as an initial, less intrusive hang recovery option to be attempted before falling back to the legacy full GPU reset recovery mode if necessary. This is only supported from Gen8 onwards.
Hangchecker determines which engines are hung and invokes error handler to recover from it. Error handler schedules recovery for each of those engines that are hung. The recovery procedure is as follows,
- identifies the request that caused the hang and it is dropped
- force engine to idle: this is done by issuing a reset request
- reset and re-init engine
- restart submissions to the engine
If engine reset fails then we fall back to heavy weight full gpu reset which resets all engines and reinitiazes complete state of HW and SW.
--- drivers/gpu/drm/i915/i915_drv.c | 59 +++++++++++++++++++++++++++++++++---- drivers/gpu/drm/i915/i915_drv.h | 3 ++ drivers/gpu/drm/i915/i915_gem.c | 2 +- drivers/gpu/drm/i915/intel_lrc.c | 10 +++++++ drivers/gpu/drm/i915/intel_lrc.h | 1 + drivers/gpu/drm/i915/intel_uncore.c | 41 +++++++++++++++++++++++--- 6 files changed, 105 insertions(+), 11 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +53 -6
@@ -1809,21 +1809,68 @@ error:* Returns zero on successful reset or otherwise an error code. * * Procedure is fairly simple: -* - force engine to idle -* - save current state which includes head and current request -* - reset engine -* - restore saved state and resubmit context +* - identifies the request that caused the hang and it is dropped +* - force engine to idle: this is done by issuing a reset request +* - reset engine +* - restart submissions to the engine */ int i915_reset_engine (struct intel_engine_cs *engine) {int ret;struct drm_i915_private *dev_priv = engine->i915; -/* FIXME: replace me with engine reset sequence */ - ret = -ENODEV ; +/* +* We need to first idle the engine by issuing a reset request, +* then perform soft reset and re-initialize hw state, for all of +* this GT power need to be awake so ensure it does throughout the +* process +*/ +intel_uncore_forcewake_get (dev_priv,FORCEWAKE_ALL ); + +/* +* the request that caused the hang is stuck on elsp, identify the +* active request and drop it, adjust head to skip the offending +* request to resume executing remaining requests in the queue. +*/ +i915_gem_reset_engine (engine); + + ret =intel_engine_reset_begin (engine); +if (ret) { +DRM_ERROR ("Failed to disable %s\n" , engine->name); + goto error; + } + + ret =intel_gpu_reset (dev_priv,intel_engine_flag (engine)); +if (ret) { +DRM_ERROR ("Failed to reset %s, ret=%d\n" , engine->name, ret); +intel_engine_reset_cancel (engine); + goto error; + } + + ret = engine->init_hw (engine); +if (ret) + goto error; + +intel_engine_reset_cancel (engine); +intel_execlists_restart_submission (engine); +intel_uncore_forcewake_put (dev_priv,FORCEWAKE_ALL ); +return 0 ; + +error: +/* use full gpu reset to recover on error */ set_bit (I915_RESET_IN_PROGRESS , &dev_priv->gpu_error.flags); +/* Engine reset is performed without taking struct_mutex, since it +* failed we now fallback to full gpu reset. Wakeup any waiters +* which should now see the reset_in_progress and release +* struct_mutex for us to continue recovery. +*/ +rcu_read_lock (); +intel_engine_wakeup (engine); +rcu_read_unlock (); + +intel_uncore_forcewake_put (dev_priv,FORCEWAKE_ALL );return ret; }
drivers/gpu/drm/i915/i915_drv.h +3 -0
@@ -2869,6 +2869,8 @@ extern int intel_gpu_reset(struct drm_i915_private *dev_priv, u32 engine_mask);extern bool intel_has_gpu_reset (struct drm_i915_private *dev_priv);extern int i915_reset (struct drm_i915_private *dev_priv);extern bool intel_has_engine_reset (struct drm_i915_private *dev_priv); +extern int intel_engine_reset_begin (struct intel_engine_cs *engine); +extern int intel_engine_reset_cancel (struct intel_engine_cs *engine);extern int i915_reset_engine (struct intel_engine_cs *engine);extern int intel_guc_reset (struct drm_i915_private *dev_priv);extern void intel_engine_init_hangcheck (struct intel_engine_cs *engine);
@@ -3230,6 +3232,7 @@ static inline u32 i915_reset_count(struct i915_gpu_error *error)void i915_gem_reset (struct drm_device *dev);void i915_gem_set_wedged (struct drm_i915_private *dev_priv); +void i915_gem_reset_engine (struct intel_engine_cs *engine);bool i915_gem_clflush_object (struct drm_i915_gem_object *obj,bool force);int __must_check i915_gem_init (struct drm_device *dev);int __must_check i915_gem_init_hw (struct drm_device *dev);
drivers/gpu/drm/i915/i915_gem.c +1 -1
@@ -2402,7 +2402,7 @@ i915_gem_find_active_request(struct intel_engine_cs *engine)return NULL ; } -static void i915_gem_reset_engine (struct intel_engine_cs *engine) +void i915_gem_reset_engine (struct intel_engine_cs *engine) {struct drm_i915_gem_request *request;struct i915_gem_context *incomplete_ctx;
drivers/gpu/drm/i915/intel_lrc.c +10 -0
@@ -543,6 +543,16 @@ static void execlists_submit_request(struct drm_i915_gem_request *request)spin_unlock_bh (&engine->execlist_lock); } +void intel_execlists_restart_submission (struct intel_engine_cs *engine) +{ +spin_lock_bh (&engine->execlist_lock); + +if (execlists_elsp_idle (engine)) +tasklet_hi_schedule (&engine->irq_tasklet); + +spin_unlock_bh (&engine->execlist_lock); +} +int intel_logical_ring_alloc_request_extras (struct drm_i915_gem_request *request) {struct intel_engine_cs *engine = request->engine;
drivers/gpu/drm/i915/intel_lrc.h +1 -0
@@ -96,5 +96,6 @@ uint64_t intel_lr_context_descriptor(struct i915_gem_context *ctx,int intel_sanitize_enable_execlists (struct drm_i915_private *dev_priv,int enable_execlists);void intel_execlists_enable_submission (struct drm_i915_private *dev_priv); +void intel_execlists_restart_submission (struct intel_engine_cs *engine);#endif /* _INTEL_LRC_H_ */
drivers/gpu/drm/i915/intel_uncore.c +37 -4
71 lines not on this page · raw message
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 8/11 drm/i915: Skip reset request if there is one already
In reply to Arun SiluveryFrom: Mika Kuoppala <[email protected]>
To perform engine reset we first disable engine to capture its state. This is done by issuing a reset request. Because we are reusing existing infrastructure, again when we actually reset an engine, reset function checks engine mask and issues reset request again which is unnecessary. To avoid this we check if the engine is already prepared, if so we just exit from that point.
--- drivers/gpu/drm/i915/intel_uncore.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/intel_uncore.c +7 -2
@@ -1686,10 +1686,15 @@ int intel_wait_for_register(struct drm_i915_private *dev_priv,static int gen8_engine_reset_begin (struct intel_engine_cs *engine) {struct drm_i915_private *dev_priv = engine->i915; +const i915_reg_t reset_ctrl =RING_RESET_CTL (engine->mmio_base); +const u32 ready =RESET_CTL_REQUEST_RESET |RESET_CTL_READY_TO_RESET ;int ret; -I915_WRITE_FW (RING_RESET_CTL (engine->mmio_base), -_MASKED_BIT_ENABLE (RESET_CTL_REQUEST_RESET )); +/* If engine has been already prepared, we can shortcut here */ +if ((I915_READ_FW (reset_ctrl) & ready) == ready) +return 0 ; + +I915_WRITE_FW (reset_ctrl,_MASKED_BIT_ENABLE (RESET_CTL_REQUEST_RESET )); ret = intel_wait_for_register_fw(dev_priv, RING_RESET_CTL(engine->mmio_base),
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 9/11 drm/i915/tdr: Add engine reset count to error state
In reply to Arun SiluveryDriver maintains count of how many times a given engine is reset, useful to capture this in error state also. It gives an idea of how engine is coping up with the workloads it is executing before this error state.
--- drivers/gpu/drm/i915/i915_drv.c | 1 + drivers/gpu/drm/i915/i915_drv.h | 9 +++++++++ drivers/gpu/drm/i915/i915_gpu_error.c | 3 +++ 3 files changed, 13 insertions(+)
drivers/gpu/drm/i915/i915_drv.c +1 -0
@@ -1854,6 +1854,7 @@ int i915_reset_engine(struct intel_engine_cs *engine)intel_engine_reset_cancel (engine);intel_execlists_restart_submission (engine); + dev_priv->gpu_error.engine_reset_count[engine->id]++;intel_uncore_forcewake_put (dev_priv,FORCEWAKE_ALL );return 0 ;
drivers/gpu/drm/i915/i915_drv.h +9 -0
@@ -518,6 +518,7 @@ struct drm_i915_error_state {int hangcheck_score;enum intel_engine_hangcheck_action hangcheck_action;int num_requests; +u32 reset_count;/* our own tracking of ring head and tail */ u32 cpu_ring_head;
@@ -1402,6 +1403,8 @@ struct i915_gpu_error {#define I915_RESET_IN_PROGRESS 0#define I915_WEDGED (BITS_PER_LONG-1) +unsigned long engine_reset_count[I915_NUM_ENGINES ]; +/** * Waitqueue to signal when a hang is detected. Used to for waiters * to release the struct_mutex for the reset to procede.
@@ -3230,6 +3233,12 @@ static inline u32 i915_reset_count(struct i915_gpu_error *error)return READ_ONCE (error->reset_count); } +static inline u32 i915_engine_reset_count (struct i915_gpu_error *error, +struct intel_engine_cs *engine) +{ +return READ_ONCE (error->engine_reset_count[engine->id]); +} +void i915_gem_reset (struct drm_device *dev);void i915_gem_set_wedged (struct drm_i915_private *dev_priv);void i915_gem_reset_engine (struct intel_engine_cs *engine);
drivers/gpu/drm/i915/i915_gpu_error.c +3 -0
@@ -298,6 +298,7 @@ static void error_print_engine(struct drm_i915_error_state_buf *m,err_printf (m," hangcheck: %s [%d]\n" ,hangcheck_action_to_str (ee->hangcheck_action), ee->hangcheck_score); +err_printf (m," engine reset count: %u\n" , ee->reset_count); }void i915_error_printf (struct drm_i915_error_state_buf *e,const char *f, ...)
@@ -1040,6 +1041,8 @@ static void error_record_engine_registers(struct drm_i915_error_state *error, ee->hangcheck_score = engine->hangcheck.score; ee->hangcheck_action = engine->hangcheck.action; + ee->reset_count =i915_engine_reset_count (&dev_priv->gpu_error, + engine);if (USES_PPGTT (dev_priv)) {int i;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 10/11 drm/i915/tdr: Export reset count info to debugfs
In reply to Arun SiluveryA new variable is added to export the reset counts to debugfs, this includes full gpu reset and engine reset count. This is useful for tests where they areexpected to trigger reset; these counts are checked before and after the test to ensure the same.
--- drivers/gpu/drm/i915/i915_debugfs.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/i915_debugfs.c +19 -0
@@ -1464,6 +1464,24 @@ static int i915_hangcheck_info(struct seq_file *m, void *unused)return 0 ; } +static int i915_reset_info (struct seq_file *m,void *unused) +{ +struct drm_info_node *node = m->private; +struct drm_device *dev = node->minor->dev; +struct drm_i915_private *dev_priv = dev->dev_private; +struct i915_gpu_error *error = &dev_priv->gpu_error; +struct intel_engine_cs *engine; + +seq_printf (m,"full gpu reset = %u\n" ,i915_reset_count (error)); + +for_each_engine (engine, dev_priv) { +seq_printf (m,"%s = %u\n" , engine->name, +i915_engine_reset_count (error, engine)); + } + +return 0 ; +} +static int ironlake_drpc_info (struct seq_file *m) {struct drm_info_node *node = m->private;
@@ -5398,6 +5416,7 @@ static const struct drm_info_list i915_debugfs_list[] = { {"i915_guc_log_dump", i915_guc_log_dump, 0}, {"i915_frequency_info", i915_frequency_info, 0}, {"i915_hangcheck_info", i915_hangcheck_info, 0}, + {"i915_reset_info", i915_reset_info, 0}, {"i915_drpc_info", i915_drpc_info, 0}, {"i915_emon_status", i915_emon_status, 0}, {"i915_ring_freq_table", i915_ring_freq_table, 0},
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 11/11 drm/i915/tdr: Enable Engine reset and recovery support
In reply to Arun SiluveryThis feature is made available only from Gen8, for previous gen devices driver uses legacy full gpu reset.
--- drivers/gpu/drm/i915/i915_params.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_params.c +2 -2
@@ -45,7 +45,7 @@ struct i915_params i915 __read_mostly = { .fastboot = 0, .prefault_disable = 0, .load_detect_test = 0, - .reset = 1, + .reset = 2, .invert_brightness = 0, .disable_display = 0, .enable_cmd_parser = 1,
@@ -112,7 +112,7 @@ MODULE_PARM_DESC(vbt_sdvo_panel_type, "(-2=ignore, -1=auto [default], index in VBT BIOS table)");module_param_named_unsafe (reset, i915.reset, int,0600 ); -MODULE_PARM_DESC (reset,"Attempt GPU resets (0=disabled, 1=full gpu reset [default], 2=engine reset)" ); +MODULE_PARM_DESC (reset,"Attempt GPU resets (0=disabled, 1=full gpu reset, 2=engine reset [default])" );module_param_named_unsafe (enable_hangcheck, i915.enable_hangcheck, bool,0644 ); MODULE_PARM_DESC(enable_hangcheck,
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Patchwork
CI✗ Ro.CI.BAT: failure for Execlist based Engine reset patches (rev5)
In reply to Arun Siluvery== Series Details ==
== Series Details ==
Series: Execlist based Engine reset patches (rev5)
URL : https://patchwork.freedesktop.org/series/10283/
State : failure
== Summary ==
Series 10283v5 Execlist based Engine reset patches
http://patchwork.freedesktop.org/api/1.0/series/10283/revisions/5/mbox
Test drv_hangman:
Subgroup error-state-basic:
pass -> INCOMPLETE (ro-bdw-i7-5600u)
Test gem_exec_flush:
Subgroup basic-wb-set-default:
pass -> DMESG-FAIL (ro-ivb-i7-3770)
Test gem_exec_suspend:
Subgroup basic-s3:
pass -> FAIL (ro-hsw-i3-4010u)
pass -> INCOMPLETE (ro-snb-i7-2620M)
pass -> FAIL (ro-hsw-i7-4770r)
pass -> FAIL (ro-ivb-i7-3770)
pass -> FAIL (ro-ivb2-i7-3770)
pass -> INCOMPLETE (ro-byt-n2820)
Subgroup basic-s4:
skip -> FAIL (ro-ivb-i7-3770)
skip -> INCOMPLETE (ro-ivb2-i7-3770)
skip -> FAIL (ro-hsw-i3-4010u)
skip -> FAIL (ro-hsw-i7-4770r)
Test gem_flink_basic:
Subgroup bad-flink:
pass -> INCOMPLETE (ro-ivb-i7-3770)
Subgroup basic:
pass -> INCOMPLETE (ro-hsw-i3-4010u)
Test gem_ringfill:
Subgroup basic-default-forked:
pass -> INCOMPLETE (ro-hsw-i7-4770r)
pass -> SKIP (ro-ilk1-i5-650)
Test kms_addfb_basic:
Subgroup basic-y-tiled:
pass -> INCOMPLETE (ro-ilk1-i5-650)
Test kms_cursor_legacy:
Subgroup basic-flip-vs-cursor-legacy:
pass -> FAIL (ro-skl3-i5-6260u)
Subgroup basic-flip-vs-cursor-varying-size:
fail -> PASS (ro-skl3-i5-6260u)
pass -> FAIL (ro-bdw-i7-5557U)fi-kbl-qkkr total:244 pass:185 dwarn:29 dfail:0 fail:3 skip:27 ro-bdw-i5-5250u total:240 pass:218 dwarn:4 dfail:0 fail:2 skip:16 ro-bdw-i7-5557U total:240 pass:223 dwarn:0 dfail:0 fail:1 skip:16 ro-bdw-i7-5600u total:34 pass:21 dwarn:0 dfail:0 fail:0 skip:12 ro-bsw-n3050 total:240 pass:194 dwarn:0 dfail:0 fail:4 skip:42 ro-byt-n2820 total:107 pass:79 dwarn:0 dfail:0 fail:1 skip:26 ro-hsw-i3-4010u total:109 pass:87 dwarn:0 dfail:0 fail:2 skip:19 ro-hsw-i7-4770r total:142 pass:120 dwarn:0 dfail:0 fail:2 skip:19 ro-ilk-i7-620lm total:174 pass:118 dwarn:0 dfail:0 fail:2 skip:53 ro-ilk1-i5-650 total:175 pass:125 dwarn:0 dfail:0 fail:1 skip:48 ro-ivb-i7-3770 total:111 pass:81 dwarn:0 dfail:1 fail:2 skip:26 ro-ivb2-i7-3770 total:108 pass:84 dwarn:0 dfail:0 fail:1 skip:22 ro-skl3-i5-6260u total:240 pass:223 dwarn:0 dfail:0 fail:3 skip:14 ro-snb-i7-2620M total:107 pass:77 dwarn:0 dfail:0 fail:0 skip:29
Results at /archive/results/CI_IGT_test/RO_Patchwork_1734/
b834992 drm-intel-nightly: 2016y-08m-05d-20h-40m-44s UTC integration manifest f3f929f drm/i915/tdr: Enable Engine reset and recovery support 8763591 drm/i915/tdr: Export reset count info to debugfs
1994ef8 drm/i915/tdr: Add engine reset count to error state 8adb9e2 drm/i915: Skip reset request if there is one already b4d8e3a drm/i915/tdr: Add support for per engine reset recovery 07c54c6 drm/i915/tdr: Modify error handler for per engine hang recovery 790764f drm/i915: Separate out reset flags from the reset counter 27d93eb drm/i915: Update i915.reset to handle engine resets 84d2923 drm/i915: Update reset path to fix incomplete requests 3edb3f0 drm/i915: Simplify ELSP queue request tracking
635e395 drm/i915: Record the position of the start of the request
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx