On Wed, Nov 18, 2026 at 01:38:30PM -0700, Summers, Stuart wrote:
> On Mon, 2026-11-16 at 15:50 +0530, Arvind Yadav wrote:
> > The memory CAT error handler uses the same cleanup path as the
> > context-reset handler. This immediately triggers the TDR, which can
> > send a scheduling-disable request before the context-reset
> > notification
> > arrives.

So as below - a CAT error is immediately followed by an engine reset
G2H?

> > 
> > On a BMG dGPU, an early disable after a CCS memory CAT error is
> > associated with subsequent contexts being enabled but never starting
> > work. Recovery occurs later when a scheduling-disable timeout
> > triggers
> > a GT reset.
> > 
> > Separate waking user-fence waiters from triggering the TDR. On a
> > memory
> > CAT notification, mark the queue reset and wake waiters without
> > starting
> > the TDR. Keep the existing cleanup triggered by the context-reset
> > notification.
> > 
> > Leave the uncorrectable-error and CGP context-error paths unchanged.
> > 
> > Tested on a BMG dGPU using a standalone SYCL reproducer with two
> > separate processes.
> > 
> > The first process submits a kernel that reads an unmapped GPU
> > address,
> > causing a page fault followed by a memory CAT error. It then calls
> > abort() without waiting for the kernel to finish.
> > 
> > After that process exits, a second process, called "victim", starts.
> > It submits a simple kernel that writes 7 to a device allocation,
> > copies the value back to the CPU and checks the result.
> > 
> > Without the patch, the victim can hang and reach its 60-second
> > userspace timeout. With the patch, the victim completed and returned
> > the expected value in all tested rounds where the first process
> > triggered
> > the fault.
> > 
> > Recovery without a context-reset notification still needs
> > confirmation,
> > particularly for LR queues, which have no normal finite job timeout.
> > Independent queue-kill and cleanup paths are unchanged.
> > 
> > Cc: Matthew Brost <[email protected]>
> > Cc: Thomas Hellström <[email protected]>
> > Cc: Himal Prasad Ghimiray <[email protected]>
> > Cc: Rodrigo Vivi <[email protected]>
> > Cc: Tejas Upadhyay <[email protected]>
> > Assisted-by: LLM

Fixes: ...

> > Signed-off-by: Arvind Yadav <[email protected]>
> 
> This isn't right... I'm not clear on what problem we're trying to solve
> here. Is it that the engine reset happening after CAT error is taking

I'm little unclear too. I haven't looked in depth - but are we saying
every CAT error is also followed by an engine reset? iirc - that is some
GuC klv option. If we always get a CAT error + engine reset G2H - this
patch is generally ok, but TBH as with Stuart I'm a little confused what
exactly the problem is here but Arvind appears to have data back to this
up, perhaps a GuC or HW quirk. Assuming this some quirk, I'd say we get
in this into the GuC spec if has programming flows section.

> too long? And where is the schedule disable originating? If it's part

The schedule disable originates from the TDR.

> of the TDR that means we likely want to re-arrange the TDR sequence
> rather than just skip it.

Well the TDR can't signal any fences (this is the job of TDR) until a
schedule disable returns to avoid any possible memory corruption which
infinitely worse than a long hang as that can take down the OS.

> 
> Engine reset is required after a CAT error to recover and the driver is
> doing that as part of this flow (vs an engine reset due to a preemption
> failure which originates from GuC and the driver just reacts to that).

Right, iirc we always get a engine reset after CAT error - but my
assumption was schedule disable from the TDR was the source of the
engine reset, not from the CAT error.

So TL;DR, I think this patch is fine with a bit more explaination and
possible GuC spec follow up.

Matt

> 
> Thanks,
> Stuart
> 
> > ---
> >  drivers/gpu/drm/xe/xe_guc_submit.c | 50 ++++++++++++++++++++++------
> > --
> >  1 file changed, 37 insertions(+), 13 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c
> > b/drivers/gpu/drm/xe/xe_guc_submit.c
> > index d76f125f9c3a..aa382634a235 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> > @@ -557,17 +557,39 @@ static bool vf_recovery(struct xe_guc *guc)
> >         return xe_gt_recovery_pending(guc_to_gt(guc));
> >  }
> >  
> > -static void xe_guc_exec_queue_trigger_cleanup(struct xe_exec_queue
> > *q)
> > +static void xe_guc_exec_queue_wake_ufence(struct xe_exec_queue *q)
> >  {
> >         struct xe_guc *guc = exec_queue_to_guc(q);
> >         struct xe_device *xe = guc_to_xe(guc);
> >  
> >         /** to wakeup xe_wait_user_fence ioctl if exec queue is reset
> > */
> >         wake_up_all(&xe->ufence_wq);
> > +}
> > +
> > +static void xe_guc_exec_queue_trigger_cleanup(struct xe_exec_queue
> > *q)
> > +{
> > +       xe_guc_exec_queue_wake_ufence(q);
> >  
> >         xe_sched_tdr_queue_imm(&q->guc->sched);
> >  }
> >  
> > +/*
> > + * Allow callers to wake user-fence waiters without triggering the
> > TDR.
> > + * The memory CAT handler uses this to avoid starting cleanup before
> > + * the context-reset notification arrives.
> > + */
> > +static void xe_queue_trigger_cleanup_for_reset(struct xe_exec_queue
> > *q,
> > +                                              bool trigger_tdr)
> > +{
> > +       if (exec_queue_banned(q))
> > +               return;
> > +
> > +       if (trigger_tdr)
> > +               xe_guc_exec_queue_trigger_cleanup(q);
> > +       else
> > +               xe_guc_exec_queue_wake_ufence(q);
> > +}
> > +
> >  static void xe_guc_exec_queue_group_stop(struct xe_exec_queue *q)
> >  {
> >         struct xe_exec_queue *primary =
> > xe_exec_queue_multi_queue_primary(q);
> > @@ -653,7 +675,8 @@ static void
> > xe_guc_exec_queue_group_trigger_cleanup(struct xe_exec_queue *q)
> >         mutex_unlock(&group->list_lock);
> >  }
> >  
> > -static void xe_guc_exec_queue_reset_trigger_cleanup(struct
> > xe_exec_queue *q)
> > +static void xe_guc_exec_queue_reset_trigger_cleanup(struct
> > xe_exec_queue *q,
> > +                                                   bool trigger_tdr)
> >  {
> >         if (xe_exec_queue_is_multi_queue(q)) {
> >                 struct xe_exec_queue *primary =
> > xe_exec_queue_multi_queue_primary(q);
> > @@ -664,20 +687,17 @@ static void
> > xe_guc_exec_queue_reset_trigger_cleanup(struct xe_exec_queue *q)
> >                 WRITE_ONCE(group->banned, true);
> >  
> >                 set_exec_queue_reset(primary);
> > -               if (!exec_queue_banned(primary))
> > -                       xe_guc_exec_queue_trigger_cleanup(primary);
> > +               xe_queue_trigger_cleanup_for_reset(primary,
> > trigger_tdr);
> >  
> >                 mutex_lock(&group->list_lock);
> >                 list_for_each_entry(eq, &group->list,
> > multi_queue.link) {
> >                         set_exec_queue_reset(eq);
> > -                       if (!exec_queue_banned(eq))
> > -
> >                                xe_guc_exec_queue_trigger_cleanup(eq);
> > +                       xe_queue_trigger_cleanup_for_reset(eq,
> > trigger_tdr);
> >                 }
> >                 mutex_unlock(&group->list_lock);
> >         } else {
> >                 set_exec_queue_reset(q);
> > -               if (!exec_queue_banned(q))
> > -                       xe_guc_exec_queue_trigger_cleanup(q);
> > +               xe_queue_trigger_cleanup_for_reset(q, trigger_tdr);
> >         }
> >  }
> >  
> > @@ -3523,7 +3543,7 @@ int xe_guc_exec_queue_reset_handler(struct
> > xe_guc *guc, u32 *msg, u32 len)
> >          * jobs by setting timeout of the job to the minimum value
> > kicking
> >          * guc_exec_queue_timedout_job.
> >          */
> > -       xe_guc_exec_queue_reset_trigger_cleanup(q);
> > +       xe_guc_exec_queue_reset_trigger_cleanup(q, true);
> >  
> >         return 0;
> >  }
> > @@ -3601,8 +3621,12 @@ int
> > xe_guc_exec_queue_memory_cat_error_handler(struct xe_guc *guc, u32
> > *msg,
> >  
> >         trace_xe_exec_queue_memory_cat_error(q);
> >  
> > -       /* Treat the same as engine reset */
> > -       xe_guc_exec_queue_reset_trigger_cleanup(q);
> > +       /*
> > +        * Starting the TDR here can send a scheduling-disable
> > request before
> > +        * the context-reset notification arrives. Mark the queue
> > reset and
> > +        * wake user-fence waiters, leaving that notification to
> > trigger cleanup.
> > +        */
> > +       xe_guc_exec_queue_reset_trigger_cleanup(q, false);
> >  
> >         return 0;
> >  }
> > @@ -3644,7 +3668,7 @@ int xe_guc_uncorrectable_error_handler(struct
> > xe_guc *guc, u32 *msg, u32 len)
> >         trace_xe_guc_uncorrectable_error(q);
> >  
> >         /* Treat the same as engine reset */
> > -       xe_guc_exec_queue_reset_trigger_cleanup(q);
> > +       xe_guc_exec_queue_reset_trigger_cleanup(q, true);
> >  
> >         return 0;
> >  }
> > @@ -3696,7 +3720,7 @@ int
> > xe_guc_exec_queue_cgp_context_error_handler(struct xe_guc *guc, u32
> > *msg,
> >         trace_xe_exec_queue_cgp_context_error(q);
> >  
> >         /* Treat the same as engine reset */
> > -       xe_guc_exec_queue_reset_trigger_cleanup(q);
> > +       xe_guc_exec_queue_reset_trigger_cleanup(q, true);
> >  
> >         return 0;
> >  }
> 

Reply via email to