[PATCH v2 0/5] drm/xe: balance exec queue suspend/resume

[PATCH v2 0/5] drm/xe: balance exec queue suspend/resume

[Niranjana Vishwanathapura]

This series fixes and hardens the exec queue suspend/resume balance in
the Xe driver, and builds on that to make multi-queue group suspend
actually preempt the group's GuC context.

Today a consumer that suspends an exec queue (preempt fences, the hw
engine group fault-mode switch, ...) unconditionally issues the
matching resume(), even when the suspend() never took effect because the
queue was killed, banned or wedged in the meantime. Resuming a queue
that was never suspended is incorrect: with the GuC backend it can trip
the !suspend_pending assertion or leave scheduling state inconsistent.

The series addresses this in layers:

 - Track whether a consumer's suspend() actually succeeded and only
   issue resume() when one is owed (patch 1), and apply the same
   discipline to the hw engine group fault-mode switch, including
   undoing partial suspends on failure (patch 2).

 - Harden the GuC suspend wait so an in-flight suspend is not abandoned
   by an arbitrary (non-fatal) signal, and so a GuC timeout bans the
   queue and tears it down instead of leaving it suspended forever
   (patch 3).

 - Add a suspend reference count to the exec queue ops so overlapping
   suspends from independent callers stay balanced (patch 4).

 - Use that refcount to forward a multi-queue secondary's suspend to the
   group's primary, so suspending a secondary actually disables the
   primary's GuC context and preempts the group's in-flight GPU work
   (patch 5).

v2: In suspend_wait(), add additional comment and ban whole group
    upon error.

Assisted-by: Github-Copilot:Claude-opus-4.8
Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>

Niranjana Vishwanathapura (4):
  drm/xe: only resume exec queues that were actually suspended
  drm/xe/hw_engine_group: propagate suspend failures during mode switch
  drm/xe/guc: wait killably for suspend and ban queue on timeout
  drm/xe/multi_queue: preempt primary on queue group suspend

Thomas Hellström (1):
  drm/xe/guc: Add suspend refcount to exec queue ops

 drivers/gpu/drm/xe/xe_exec_queue.c           |   1 +
 drivers/gpu/drm/xe/xe_exec_queue_types.h     |  18 ++
 drivers/gpu/drm/xe/xe_guc_exec_queue_types.h |   7 +
 drivers/gpu/drm/xe/xe_guc_submit.c           | 213 +++++++++++++++++--
 drivers/gpu/drm/xe/xe_hw_engine_group.c      |  76 ++++++-
 drivers/gpu/drm/xe/xe_preempt_fence.c        |   7 +
 drivers/gpu/drm/xe/xe_vm.c                   |  18 +-
 7 files changed, 315 insertions(+), 25 deletions(-)

-- 
2.43.0

[PATCH v2 1/5] drm/xe: only resume exec queues that were actually suspended

[Niranjana Vishwanathapura]

A consumer-issued suspend() can fail (e.g. the queue is killed, banned
or wedged), leaving the queue un-suspended. The consumer must then not
issue the matching resume(): resuming a queue that was never suspended
is incorrect.

Add an lr.suspended flag to struct xe_exec_queue that records whether a
consumer suspend() succeeded and a matching resume() is still owed. Set
it on a successful suspend() in the preempt-fence path, clear it on
resume(), and only resume queues that have it set.

In resume_and_reinstall_preempt_fences() also skip queues that have
since been reset/killed/banned/wedged: such a queue's suspend may not
have completed (suspend_pending can still be set, e.g. a preempt fence
signalled with -ENOENT without waiting), so resuming it would trip the
!suspend_pending assert in the backend. Leave it marked suspended and
let teardown resolve its state.

A queue is only ever suspended by a single consumer at a time
(preempt-fence mode and hw engine group fault mode are mutually
exclusive), so a single flag is sufficient.

Assisted-by: Github-Copilot:Claude-opus-4.8
Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
---
 drivers/gpu/drm/xe/xe_exec_queue_types.h | 12 ++++++++++++
 drivers/gpu/drm/xe/xe_preempt_fence.c    |  7 +++++++
 drivers/gpu/drm/xe/xe_vm.c               | 18 +++++++++++++++++-
 3 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/xe/xe_exec_queue_types.h b/drivers/gpu/drm/xe/xe_exec_queue_types.h
index d27ce24daae5..dbb2ee8eb5de 100644
--- a/drivers/gpu/drm/xe/xe_exec_queue_types.h
+++ b/drivers/gpu/drm/xe/xe_exec_queue_types.h
@@ -200,6 +200,18 @@ struct xe_exec_queue {
 		u32 seqno;
 		/** @lr.link: link into VM's list of exec queues */
 		struct list_head link;
+		/**
+		 * @lr.suspended: Tracks whether the consumer-issued suspend()
+		 * succeeded and a matching resume() is still owed. suspend() can
+		 * fail (e.g. killed/banned/wedged), leaving the queue
+		 * un-suspended, so consumers must only resume() queues that were
+		 * actually suspended. Set by the suspend caller on success and
+		 * cleared by the resume caller. A queue is only ever suspended by
+		 * a single consumer at a time (preempt-fence mode and hw engine
+		 * group fault mode are mutually exclusive), so a single flag is
+		 * sufficient.
+		 */
+		bool suspended;
 	} lr;
 
 #define XE_EXEC_QUEUE_TLB_INVAL_PRIMARY_GT	0
diff --git a/drivers/gpu/drm/xe/xe_preempt_fence.c b/drivers/gpu/drm/xe/xe_preempt_fence.c
index d6427b473ddd..4aa570fe745d 100644
--- a/drivers/gpu/drm/xe/xe_preempt_fence.c
+++ b/drivers/gpu/drm/xe/xe_preempt_fence.c
@@ -74,6 +74,13 @@ static bool preempt_fence_enable_signaling(struct dma_fence *fence)
 	struct xe_exec_queue *q = pfence->q;
 
 	pfence->error = q->ops->suspend(q);
+	/*
+	 * Record a successful suspend so the rebind worker only resumes queues
+	 * that were actually suspended; a failed suspend() leaves the queue
+	 * un-suspended and must not be paired with a resume().
+	 */
+	if (!pfence->error)
+		WRITE_ONCE(q->lr.suspended, true);
 	queue_work(q->vm->xe->preempt_fence_wq, &pfence->preempt_work);
 	return true;
 }
diff --git a/drivers/gpu/drm/xe/xe_vm.c b/drivers/gpu/drm/xe/xe_vm.c
index 080c2fff0e95..23f4a9fb9a49 100644
--- a/drivers/gpu/drm/xe/xe_vm.c
+++ b/drivers/gpu/drm/xe/xe_vm.c
@@ -206,7 +206,23 @@ static void resume_and_reinstall_preempt_fences(struct xe_vm *vm,
 	xe_vm_assert_held(vm);
 
 	list_for_each_entry(q, &vm->preempt.exec_queues, lr.link) {
-		q->ops->resume(q);
+		/*
+		 * Only resume queues whose suspend() actually succeeded. A
+		 * failed suspend() (e.g. killed/banned/wedged) leaves the queue
+		 * un-suspended, so it must not be resumed.
+		 *
+		 * Also skip queues that have since been reset/killed/banned/
+		 * wedged: their suspend may not have completed (suspend_pending
+		 * can still be set, e.g. a preempt fence signalled with -ENOENT
+		 * without waiting), so resuming would trip the !suspend_pending
+		 * assert in the backend. Such queues are being torn down anyway,
+		 * so leave them marked suspended and let teardown resolve their
+		 * state.
+		 */
+		if (READ_ONCE(q->lr.suspended) && !q->ops->reset_status(q)) {
+			WRITE_ONCE(q->lr.suspended, false);
+			q->ops->resume(q);
+		}
 
 		drm_gpuvm_resv_add_fence(&vm->gpuvm, exec, q->lr.pfence,
 					 DMA_RESV_USAGE_BOOKKEEP, DMA_RESV_USAGE_BOOKKEEP);
-- 
2.43.0

Re: [PATCH v2 1/5] drm/xe: only resume exec queues that were actually suspended

[Matthew Brost]

On Tue, Jun 30, 2026 at 10:07:29PM -0700, Niranjana Vishwanathapura wrote:
> A consumer-issued suspend() can fail (e.g. the queue is killed, banned
> or wedged), leaving the queue un-suspended. The consumer must then not
> issue the matching resume(): resuming a queue that was never suspended
> is incorrect.
> 
> Add an lr.suspended flag to struct xe_exec_queue that records whether a
> consumer suspend() succeeded and a matching resume() is still owed. Set
> it on a successful suspend() in the preempt-fence path, clear it on
> resume(), and only resume queues that have it set.
> 
> In resume_and_reinstall_preempt_fences() also skip queues that have
> since been reset/killed/banned/wedged: such a queue's suspend may not
> have completed (suspend_pending can still be set, e.g. a preempt fence
> signalled with -ENOENT without waiting), so resuming it would trip the
> !suspend_pending assert in the backend. Leave it marked suspended and
> let teardown resolve its state.
> 
> A queue is only ever suspended by a single consumer at a time
> (preempt-fence mode and hw engine group fault mode are mutually
> exclusive), so a single flag is sufficient.
> 
> Assisted-by: Github-Copilot:Claude-opus-4.8
> Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>

Reviewed-by: Matthew Brost <matthew.brost@intel.com>

> ---
>  drivers/gpu/drm/xe/xe_exec_queue_types.h | 12 ++++++++++++
>  drivers/gpu/drm/xe/xe_preempt_fence.c    |  7 +++++++
>  drivers/gpu/drm/xe/xe_vm.c               | 18 +++++++++++++++++-
>  3 files changed, 36 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/gpu/drm/xe/xe_exec_queue_types.h b/drivers/gpu/drm/xe/xe_exec_queue_types.h
> index d27ce24daae5..dbb2ee8eb5de 100644
> --- a/drivers/gpu/drm/xe/xe_exec_queue_types.h
> +++ b/drivers/gpu/drm/xe/xe_exec_queue_types.h
> @@ -200,6 +200,18 @@ struct xe_exec_queue {
>  		u32 seqno;
>  		/** @lr.link: link into VM's list of exec queues */
>  		struct list_head link;
> +		/**
> +		 * @lr.suspended: Tracks whether the consumer-issued suspend()
> +		 * succeeded and a matching resume() is still owed. suspend() can
> +		 * fail (e.g. killed/banned/wedged), leaving the queue
> +		 * un-suspended, so consumers must only resume() queues that were
> +		 * actually suspended. Set by the suspend caller on success and
> +		 * cleared by the resume caller. A queue is only ever suspended by
> +		 * a single consumer at a time (preempt-fence mode and hw engine
> +		 * group fault mode are mutually exclusive), so a single flag is
> +		 * sufficient.
> +		 */
> +		bool suspended;
>  	} lr;
>  
>  #define XE_EXEC_QUEUE_TLB_INVAL_PRIMARY_GT	0
> diff --git a/drivers/gpu/drm/xe/xe_preempt_fence.c b/drivers/gpu/drm/xe/xe_preempt_fence.c
> index d6427b473ddd..4aa570fe745d 100644
> --- a/drivers/gpu/drm/xe/xe_preempt_fence.c
> +++ b/drivers/gpu/drm/xe/xe_preempt_fence.c
> @@ -74,6 +74,13 @@ static bool preempt_fence_enable_signaling(struct dma_fence *fence)
>  	struct xe_exec_queue *q = pfence->q;
>  
>  	pfence->error = q->ops->suspend(q);
> +	/*
> +	 * Record a successful suspend so the rebind worker only resumes queues
> +	 * that were actually suspended; a failed suspend() leaves the queue
> +	 * un-suspended and must not be paired with a resume().
> +	 */
> +	if (!pfence->error)
> +		WRITE_ONCE(q->lr.suspended, true);
>  	queue_work(q->vm->xe->preempt_fence_wq, &pfence->preempt_work);
>  	return true;
>  }
> diff --git a/drivers/gpu/drm/xe/xe_vm.c b/drivers/gpu/drm/xe/xe_vm.c
> index 080c2fff0e95..23f4a9fb9a49 100644
> --- a/drivers/gpu/drm/xe/xe_vm.c
> +++ b/drivers/gpu/drm/xe/xe_vm.c
> @@ -206,7 +206,23 @@ static void resume_and_reinstall_preempt_fences(struct xe_vm *vm,
>  	xe_vm_assert_held(vm);
>  
>  	list_for_each_entry(q, &vm->preempt.exec_queues, lr.link) {
> -		q->ops->resume(q);
> +		/*
> +		 * Only resume queues whose suspend() actually succeeded. A
> +		 * failed suspend() (e.g. killed/banned/wedged) leaves the queue
> +		 * un-suspended, so it must not be resumed.
> +		 *
> +		 * Also skip queues that have since been reset/killed/banned/
> +		 * wedged: their suspend may not have completed (suspend_pending
> +		 * can still be set, e.g. a preempt fence signalled with -ENOENT
> +		 * without waiting), so resuming would trip the !suspend_pending
> +		 * assert in the backend. Such queues are being torn down anyway,
> +		 * so leave them marked suspended and let teardown resolve their
> +		 * state.
> +		 */
> +		if (READ_ONCE(q->lr.suspended) && !q->ops->reset_status(q)) {
> +			WRITE_ONCE(q->lr.suspended, false);
> +			q->ops->resume(q);
> +		}
>  
>  		drm_gpuvm_resv_add_fence(&vm->gpuvm, exec, q->lr.pfence,
>  					 DMA_RESV_USAGE_BOOKKEEP, DMA_RESV_USAGE_BOOKKEEP);
> -- 
> 2.43.0
> 

[PATCH v2 2/5] drm/xe/hw_engine_group: propagate suspend failures during mode switch

[Niranjana Vishwanathapura]

The hw engine group fault-mode switch suspends all faulting LR queues
but ignored the suspend()/suspend_wait() return value. A suspend() can
fail (e.g. the queue is killed/banned/wedged), leaving the queue
un-suspended, so silently continuing could later resume a queue that was
never suspended.

Propagate the failure instead: in xe_hw_engine_group_add_exec_queue()
bail out if suspend() fails, and in
xe_hw_engine_group_suspend_faulting_lr_jobs() undo the partial suspend
via a new err_resume path that resumes the sibling queues already
suspended in this call. Record per-queue success with lr.suspended so
only queues that were actually suspended are waited on and resumed, and
skip the cleanup resume() when suspend_wait() failed or the queue was
reset/killed/banned/wedged (its suspend may not have completed, so
resuming would trip the !suspend_pending assert in the resume path;
teardown resolves its state instead).

Gate the group resume worker (hw_engine_group_resume_lr_jobs_func()) on
lr.suspended for the same reason, so it only resumes queues that were
actually suspended.

Assisted-by: Github-Copilot:Claude-opus-4.8
Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
---
 drivers/gpu/drm/xe/xe_hw_engine_group.c | 76 ++++++++++++++++++++++++-
 1 file changed, 73 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_hw_engine_group.c b/drivers/gpu/drm/xe/xe_hw_engine_group.c
index 02cf32ae5aa9..84851929c16f 100644
--- a/drivers/gpu/drm/xe/xe_hw_engine_group.c
+++ b/drivers/gpu/drm/xe/xe_hw_engine_group.c
@@ -34,6 +34,15 @@ hw_engine_group_resume_lr_jobs_func(struct work_struct *w)
 		if (!xe_vm_in_fault_mode(q->vm))
 			continue;
 
+		/*
+		 * Only resume queues that were actually suspended. A queue whose
+		 * suspend() failed (e.g. killed/banned/wedged) was never
+		 * suspended, so it must not be resumed.
+		 */
+		if (!READ_ONCE(q->lr.suspended))
+			continue;
+
+		WRITE_ONCE(q->lr.suspended, false);
 		q->ops->resume(q);
 	}
 
@@ -140,7 +149,18 @@ int xe_hw_engine_group_add_exec_queue(struct xe_hw_engine_group *group, struct x
 		return err;
 
 	if (xe_vm_in_fault_mode(q->vm) && group->cur_mode == EXEC_MODE_DMA_FENCE) {
-		q->ops->suspend(q);
+		/*
+		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
+		 * queue un-suspended. Propagate the failure so the queue is not
+		 * added; on failure nothing was suspended, so there is nothing to
+		 * undo. Only record the queue as suspended (and later resume it)
+		 * once suspend() has succeeded.
+		 */
+		err = q->ops->suspend(q);
+		if (err)
+			goto err_suspend;
+
+		WRITE_ONCE(q->lr.suspended, true);
 		err = q->ops->suspend_wait(q);
 		if (err)
 			goto err_suspend;
@@ -216,8 +236,20 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
 			return -EAGAIN;
 
 		xe_gt_stats_incr(q->gt, XE_GT_STATS_ID_HW_ENGINE_GROUP_SUSPEND_LR_QUEUE_COUNT, 1);
+		/*
+		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
+		 * queue un-suspended. Propagate the failure, but first undo the
+		 * partial suspend by resuming the sibling queues already
+		 * suspended in this call (see err_resume). Record per-queue that
+		 * the suspend succeeded so only those queues are later waited on
+		 * and resumed.
+		 */
+		err = q->ops->suspend(q);
+		if (err)
+			goto err_resume;
+
+		WRITE_ONCE(q->lr.suspended, true);
 		need_resume = true;
-		q->ops->suspend(q);
 		gt = q->gt;
 	}
 
@@ -225,9 +257,13 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
 		if (!xe_vm_in_fault_mode(q->vm))
 			continue;
 
+		/* Only wait on queues that were actually suspended above. */
+		if (!READ_ONCE(q->lr.suspended))
+			continue;
+
 		err = q->ops->suspend_wait(q);
 		if (err)
-			return err;
+			goto err_resume;
 	}
 
 	if (gt) {
@@ -240,6 +276,40 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
 		xe_hw_engine_group_resume_faulting_lr_jobs(group);
 
 	return 0;
+
+err_resume:
+	/*
+	 * A suspend()/suspend_wait() failed partway through the mode switch.
+	 * Resume the sibling queues that were already suspended in this call so
+	 * they are not left suspended forever.
+	 *
+	 * resume() requires the suspend to have completed (suspend_pending
+	 * cleared) or it trips the !suspend_pending assert. So skip the resume
+	 * when either:
+	 *  - suspend_wait() fails: the suspend did not complete (timeout, VF
+	 *    recovery, interrupt), so suspend_pending may still be set; or
+	 *  - reset_status() is true: the queue was reset/killed/banned/wedged.
+	 *    suspend_wait() can return success in this case via its killed/
+	 *    stopped wait condition while suspend_pending is still set, and the
+	 *    queue is being torn down anyway, so its state is resolved by
+	 *    teardown rather than by a resume here.
+	 * In either case leave the queue marked suspended.
+	 */
+	list_for_each_entry(q, &group->exec_queue_list, hw_engine_group_link) {
+		if (!xe_vm_in_fault_mode(q->vm))
+			continue;
+
+		if (!READ_ONCE(q->lr.suspended))
+			continue;
+
+		if (q->ops->suspend_wait(q) || q->ops->reset_status(q))
+			continue;
+
+		WRITE_ONCE(q->lr.suspended, false);
+		q->ops->resume(q);
+	}
+
+	return err;
 }
 
 /**
-- 
2.43.0

Re: [PATCH v2 2/5] drm/xe/hw_engine_group: propagate suspend failures during mode switch

[Matthew Brost]

On Tue, Jun 30, 2026 at 10:07:30PM -0700, Niranjana Vishwanathapura wrote:
> The hw engine group fault-mode switch suspends all faulting LR queues
> but ignored the suspend()/suspend_wait() return value. A suspend() can
> fail (e.g. the queue is killed/banned/wedged), leaving the queue
> un-suspended, so silently continuing could later resume a queue that was
> never suspended.
> 
> Propagate the failure instead: in xe_hw_engine_group_add_exec_queue()
> bail out if suspend() fails, and in
> xe_hw_engine_group_suspend_faulting_lr_jobs() undo the partial suspend
> via a new err_resume path that resumes the sibling queues already
> suspended in this call. Record per-queue success with lr.suspended so
> only queues that were actually suspended are waited on and resumed, and
> skip the cleanup resume() when suspend_wait() failed or the queue was
> reset/killed/banned/wedged (its suspend may not have completed, so
> resuming would trip the !suspend_pending assert in the resume path;
> teardown resolves its state instead).
> 
> Gate the group resume worker (hw_engine_group_resume_lr_jobs_func()) on
> lr.suspended for the same reason, so it only resumes queues that were
> actually suspended.
> 
> Assisted-by: Github-Copilot:Claude-opus-4.8
> Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_hw_engine_group.c | 76 ++++++++++++++++++++++++-
>  1 file changed, 73 insertions(+), 3 deletions(-)
> 
> diff --git a/drivers/gpu/drm/xe/xe_hw_engine_group.c b/drivers/gpu/drm/xe/xe_hw_engine_group.c
> index 02cf32ae5aa9..84851929c16f 100644
> --- a/drivers/gpu/drm/xe/xe_hw_engine_group.c
> +++ b/drivers/gpu/drm/xe/xe_hw_engine_group.c
> @@ -34,6 +34,15 @@ hw_engine_group_resume_lr_jobs_func(struct work_struct *w)
>  		if (!xe_vm_in_fault_mode(q->vm))
>  			continue;
>  
> +		/*
> +		 * Only resume queues that were actually suspended. A queue whose
> +		 * suspend() failed (e.g. killed/banned/wedged) was never
> +		 * suspended, so it must not be resumed.
> +		 */
> +		if (!READ_ONCE(q->lr.suspended))
> +			continue;
> +
> +		WRITE_ONCE(q->lr.suspended, false);
>  		q->ops->resume(q);
>  	}
>  
> @@ -140,7 +149,18 @@ int xe_hw_engine_group_add_exec_queue(struct xe_hw_engine_group *group, struct x
>  		return err;
>  
>  	if (xe_vm_in_fault_mode(q->vm) && group->cur_mode == EXEC_MODE_DMA_FENCE) {
> -		q->ops->suspend(q);
> +		/*
> +		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
> +		 * queue un-suspended. Propagate the failure so the queue is not
> +		 * added; on failure nothing was suspended, so there is nothing to
> +		 * undo. Only record the queue as suspended (and later resume it)
> +		 * once suspend() has succeeded.
> +		 */
> +		err = q->ops->suspend(q);
> +		if (err)
> +			goto err_suspend;
> +
> +		WRITE_ONCE(q->lr.suspended, true);
>  		err = q->ops->suspend_wait(q);
>  		if (err)
>  			goto err_suspend;
> @@ -216,8 +236,20 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
>  			return -EAGAIN;
>  
>  		xe_gt_stats_incr(q->gt, XE_GT_STATS_ID_HW_ENGINE_GROUP_SUSPEND_LR_QUEUE_COUNT, 1);
> +		/*
> +		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
> +		 * queue un-suspended. Propagate the failure, but first undo the
> +		 * partial suspend by resuming the sibling queues already
> +		 * suspended in this call (see err_resume). Record per-queue that
> +		 * the suspend succeeded so only those queues are later waited on
> +		 * and resumed.
> +		 */
> +		err = q->ops->suspend(q);
> +		if (err)
> +			goto err_resume;


This is not right. I think what you want here is:

err = q->ops->suspend(q);
if (err)
        continue;

A killed, banned, or wedged job should not abort the entire suspend
flow and propagate an error back through the user IOCTL. The "group" is
a cross-process concept (i.e., a global concept), so a queue tearing
down in one process should not affect submissions from another process.

I'm pretty sure you could trivially cause a compositor exec IOCTL to
fail by running applications that page-fault and hang, or by killing
them with Ctrl-C. Under the right conditions, the compositor could then
see an error from its exec IOCTL while trying to render a frame.

> +
> +		WRITE_ONCE(q->lr.suspended, true);
>  		need_resume = true;
> -		q->ops->suspend(q);
>  		gt = q->gt;
>  	}
>  
> @@ -225,9 +257,13 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
>  		if (!xe_vm_in_fault_mode(q->vm))
>  			continue;
>  
> +		/* Only wait on queues that were actually suspended above. */
> +		if (!READ_ONCE(q->lr.suspended))
> +			continue;
> +
>  		err = q->ops->suspend_wait(q);
>  		if (err)
> -			return err;
> +			goto err_resume;
>  	}
>  
>  	if (gt) {
> @@ -240,6 +276,40 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
>  		xe_hw_engine_group_resume_faulting_lr_jobs(group);
>  
>  	return 0;
> +
> +err_resume:
> +	/*
> +	 * A suspend()/suspend_wait() failed partway through the mode switch.
> +	 * Resume the sibling queues that were already suspended in this call so
> +	 * they are not left suspended forever.
> +	 *
> +	 * resume() requires the suspend to have completed (suspend_pending
> +	 * cleared) or it trips the !suspend_pending assert. So skip the resume
> +	 * when either:
> +	 *  - suspend_wait() fails: the suspend did not complete (timeout, VF

VF recovery is a non-issue given page faults are not enabled on VFs which
can migrate. Don't bring that up here as if that needs to be handled
this code would have to look different, or mentiond VF recovery doesn't
need to be considered.

> +	 *    recovery, interrupt), so suspend_pending may still be set; or

IRQs are a valid concern and this part doesn't look right.

> +	 *  - reset_status() is true: the queue was reset/killed/banned/wedged.
> +	 *    suspend_wait() can return success in this case via its killed/
> +	 *    stopped wait condition while suspend_pending is still set, and the
> +	 *    queue is being torn down anyway, so its state is resolved by
> +	 *    teardown rather than by a resume here.
> +	 * In either case leave the queue marked suspended.
> +	 */
> +	list_for_each_entry(q, &group->exec_queue_list, hw_engine_group_link) {
> +		if (!xe_vm_in_fault_mode(q->vm))
> +			continue;
> +
> +		if (!READ_ONCE(q->lr.suspended))
> +			continue;
> +
> +		if (q->ops->suspend_wait(q) || q->ops->reset_status(q))

-ERESTARTSYS on this process doesn't mean a different processes queues
are bad. I believe what we need to here is suspend_wait_no_irq(q) to
recover any suspended queues back to the resume state. Yes, ctrl-c /
process kill will have block but I don't see any other option to
maintain balance.

So I'd write this like:

if (q->ops->reset_status(q))
	continue;

q->ops->suspend_wait_no_irq(q);

Or feel free to a no_irq argument to suspend_wait.

Matt

> +			continue;
> +
> +		WRITE_ONCE(q->lr.suspended, false);
> +		q->ops->resume(q);
> +	}
> +
> +	return err;
>  }
>  
>  /**
> -- 
> 2.43.0
> 

Re: [PATCH v2 2/5] drm/xe/hw_engine_group: propagate suspend failures during mode switch

[Niranjana Vishwanathapura]

On Thu, Jul 09, 2026 at 01:20:12PM -0700, Matthew Brost wrote:
>On Tue, Jun 30, 2026 at 10:07:30PM -0700, Niranjana Vishwanathapura wrote:
>> The hw engine group fault-mode switch suspends all faulting LR queues
>> but ignored the suspend()/suspend_wait() return value. A suspend() can
>> fail (e.g. the queue is killed/banned/wedged), leaving the queue
>> un-suspended, so silently continuing could later resume a queue that was
>> never suspended.
>>
>> Propagate the failure instead: in xe_hw_engine_group_add_exec_queue()
>> bail out if suspend() fails, and in
>> xe_hw_engine_group_suspend_faulting_lr_jobs() undo the partial suspend
>> via a new err_resume path that resumes the sibling queues already
>> suspended in this call. Record per-queue success with lr.suspended so
>> only queues that were actually suspended are waited on and resumed, and
>> skip the cleanup resume() when suspend_wait() failed or the queue was
>> reset/killed/banned/wedged (its suspend may not have completed, so
>> resuming would trip the !suspend_pending assert in the resume path;
>> teardown resolves its state instead).
>>
>> Gate the group resume worker (hw_engine_group_resume_lr_jobs_func()) on
>> lr.suspended for the same reason, so it only resumes queues that were
>> actually suspended.
>>
>> Assisted-by: Github-Copilot:Claude-opus-4.8
>> Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
>> ---
>>  drivers/gpu/drm/xe/xe_hw_engine_group.c | 76 ++++++++++++++++++++++++-
>>  1 file changed, 73 insertions(+), 3 deletions(-)
>>
>> diff --git a/drivers/gpu/drm/xe/xe_hw_engine_group.c b/drivers/gpu/drm/xe/xe_hw_engine_group.c
>> index 02cf32ae5aa9..84851929c16f 100644
>> --- a/drivers/gpu/drm/xe/xe_hw_engine_group.c
>> +++ b/drivers/gpu/drm/xe/xe_hw_engine_group.c
>> @@ -34,6 +34,15 @@ hw_engine_group_resume_lr_jobs_func(struct work_struct *w)
>>  		if (!xe_vm_in_fault_mode(q->vm))
>>  			continue;
>>
>> +		/*
>> +		 * Only resume queues that were actually suspended. A queue whose
>> +		 * suspend() failed (e.g. killed/banned/wedged) was never
>> +		 * suspended, so it must not be resumed.
>> +		 */
>> +		if (!READ_ONCE(q->lr.suspended))
>> +			continue;
>> +
>> +		WRITE_ONCE(q->lr.suspended, false);
>>  		q->ops->resume(q);
>>  	}
>>
>> @@ -140,7 +149,18 @@ int xe_hw_engine_group_add_exec_queue(struct xe_hw_engine_group *group, struct x
>>  		return err;
>>
>>  	if (xe_vm_in_fault_mode(q->vm) && group->cur_mode == EXEC_MODE_DMA_FENCE) {
>> -		q->ops->suspend(q);
>> +		/*
>> +		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
>> +		 * queue un-suspended. Propagate the failure so the queue is not
>> +		 * added; on failure nothing was suspended, so there is nothing to
>> +		 * undo. Only record the queue as suspended (and later resume it)
>> +		 * once suspend() has succeeded.
>> +		 */
>> +		err = q->ops->suspend(q);
>> +		if (err)
>> +			goto err_suspend;
>> +
>> +		WRITE_ONCE(q->lr.suspended, true);
>>  		err = q->ops->suspend_wait(q);
>>  		if (err)
>>  			goto err_suspend;
>> @@ -216,8 +236,20 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
>>  			return -EAGAIN;
>>
>>  		xe_gt_stats_incr(q->gt, XE_GT_STATS_ID_HW_ENGINE_GROUP_SUSPEND_LR_QUEUE_COUNT, 1);
>> +		/*
>> +		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
>> +		 * queue un-suspended. Propagate the failure, but first undo the
>> +		 * partial suspend by resuming the sibling queues already
>> +		 * suspended in this call (see err_resume). Record per-queue that
>> +		 * the suspend succeeded so only those queues are later waited on
>> +		 * and resumed.
>> +		 */
>> +		err = q->ops->suspend(q);
>> +		if (err)
>> +			goto err_resume;
>
>
>This is not right. I think what you want here is:
>
>err = q->ops->suspend(q);
>if (err)
>        continue;
>
>A killed, banned, or wedged job should not abort the entire suspend
>flow and propagate an error back through the user IOCTL. The "group" is
>a cross-process concept (i.e., a global concept), so a queue tearing
>down in one process should not affect submissions from another process.
>
>I'm pretty sure you could trivially cause a compositor exec IOCTL to
>fail by running applications that page-fault and hang, or by killing
>them with Ctrl-C. Under the right conditions, the compositor could then
>see an error from its exec IOCTL while trying to render a frame.
>

Ok got it, will 'continue' if suspend() returns error here.

>> +
>> +		WRITE_ONCE(q->lr.suspended, true);
>>  		need_resume = true;
>> -		q->ops->suspend(q);
>>  		gt = q->gt;
>>  	}
>>
>> @@ -225,9 +257,13 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
>>  		if (!xe_vm_in_fault_mode(q->vm))
>>  			continue;
>>
>> +		/* Only wait on queues that were actually suspended above. */
>> +		if (!READ_ONCE(q->lr.suspended))
>> +			continue;
>> +
>>  		err = q->ops->suspend_wait(q);
>>  		if (err)
>> -			return err;
>> +			goto err_resume;
>>  	}
>>
>>  	if (gt) {
>> @@ -240,6 +276,40 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
>>  		xe_hw_engine_group_resume_faulting_lr_jobs(group);
>>
>>  	return 0;
>> +
>> +err_resume:
>> +	/*
>> +	 * A suspend()/suspend_wait() failed partway through the mode switch.
>> +	 * Resume the sibling queues that were already suspended in this call so
>> +	 * they are not left suspended forever.
>> +	 *
>> +	 * resume() requires the suspend to have completed (suspend_pending
>> +	 * cleared) or it trips the !suspend_pending assert. So skip the resume
>> +	 * when either:
>> +	 *  - suspend_wait() fails: the suspend did not complete (timeout, VF
>
>VF recovery is a non-issue given page faults are not enabled on VFs which
>can migrate. Don't bring that up here as if that needs to be handled
>this code would have to look different, or mentiond VF recovery doesn't
>need to be considered.

Ok, will update comment here.

>
>> +	 *    recovery, interrupt), so suspend_pending may still be set; or
>
>IRQs are a valid concern and this part doesn't look right.
>
>> +	 *  - reset_status() is true: the queue was reset/killed/banned/wedged.
>> +	 *    suspend_wait() can return success in this case via its killed/
>> +	 *    stopped wait condition while suspend_pending is still set, and the
>> +	 *    queue is being torn down anyway, so its state is resolved by
>> +	 *    teardown rather than by a resume here.
>> +	 * In either case leave the queue marked suspended.
>> +	 */
>> +	list_for_each_entry(q, &group->exec_queue_list, hw_engine_group_link) {
>> +		if (!xe_vm_in_fault_mode(q->vm))
>> +			continue;
>> +
>> +		if (!READ_ONCE(q->lr.suspended))
>> +			continue;
>> +
>> +		if (q->ops->suspend_wait(q) || q->ops->reset_status(q))
>
>-ERESTARTSYS on this process doesn't mean a different processes queues
>are bad. I believe what we need to here is suspend_wait_no_irq(q) to
>recover any suspended queues back to the resume state. Yes, ctrl-c /
>process kill will have block but I don't see any other option to
>maintain balance.
>
>So I'd write this like:
>
>if (q->ops->reset_status(q))
>	continue;
>
>q->ops->suspend_wait_no_irq(q);
>
>Or feel free to a no_irq argument to suspend_wait.
>

Ok, will add a q->ops->suspend_wait_blocking() to be called from
the error path here which will just use wait_event() variant (the
non-interruptible variant) and will not include vf_recovery()
check also. So, it will be absolute wait in the error path.
Is that fine?

Niranjana

>Matt
>
>> +			continue;
>> +
>> +		WRITE_ONCE(q->lr.suspended, false);
>> +		q->ops->resume(q);
>> +	}
>> +
>> +	return err;
>>  }
>>
>>  /**
>> --
>> 2.43.0
>>

Re: [PATCH v2 2/5] drm/xe/hw_engine_group: propagate suspend failures during mode switch

[Matthew Brost]

On Thu, Jul 09, 2026 at 09:13:59PM -0700, Niranjana Vishwanathapura wrote:
> On Thu, Jul 09, 2026 at 01:20:12PM -0700, Matthew Brost wrote:
> > On Tue, Jun 30, 2026 at 10:07:30PM -0700, Niranjana Vishwanathapura wrote:
> > > The hw engine group fault-mode switch suspends all faulting LR queues
> > > but ignored the suspend()/suspend_wait() return value. A suspend() can
> > > fail (e.g. the queue is killed/banned/wedged), leaving the queue
> > > un-suspended, so silently continuing could later resume a queue that was
> > > never suspended.
> > > 
> > > Propagate the failure instead: in xe_hw_engine_group_add_exec_queue()
> > > bail out if suspend() fails, and in
> > > xe_hw_engine_group_suspend_faulting_lr_jobs() undo the partial suspend
> > > via a new err_resume path that resumes the sibling queues already
> > > suspended in this call. Record per-queue success with lr.suspended so
> > > only queues that were actually suspended are waited on and resumed, and
> > > skip the cleanup resume() when suspend_wait() failed or the queue was
> > > reset/killed/banned/wedged (its suspend may not have completed, so
> > > resuming would trip the !suspend_pending assert in the resume path;
> > > teardown resolves its state instead).
> > > 
> > > Gate the group resume worker (hw_engine_group_resume_lr_jobs_func()) on
> > > lr.suspended for the same reason, so it only resumes queues that were
> > > actually suspended.
> > > 
> > > Assisted-by: Github-Copilot:Claude-opus-4.8
> > > Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> > > ---
> > >  drivers/gpu/drm/xe/xe_hw_engine_group.c | 76 ++++++++++++++++++++++++-
> > >  1 file changed, 73 insertions(+), 3 deletions(-)
> > > 
> > > diff --git a/drivers/gpu/drm/xe/xe_hw_engine_group.c b/drivers/gpu/drm/xe/xe_hw_engine_group.c
> > > index 02cf32ae5aa9..84851929c16f 100644
> > > --- a/drivers/gpu/drm/xe/xe_hw_engine_group.c
> > > +++ b/drivers/gpu/drm/xe/xe_hw_engine_group.c
> > > @@ -34,6 +34,15 @@ hw_engine_group_resume_lr_jobs_func(struct work_struct *w)
> > >  		if (!xe_vm_in_fault_mode(q->vm))
> > >  			continue;
> > > 
> > > +		/*
> > > +		 * Only resume queues that were actually suspended. A queue whose
> > > +		 * suspend() failed (e.g. killed/banned/wedged) was never
> > > +		 * suspended, so it must not be resumed.
> > > +		 */
> > > +		if (!READ_ONCE(q->lr.suspended))
> > > +			continue;
> > > +
> > > +		WRITE_ONCE(q->lr.suspended, false);
> > >  		q->ops->resume(q);
> > >  	}
> > > 
> > > @@ -140,7 +149,18 @@ int xe_hw_engine_group_add_exec_queue(struct xe_hw_engine_group *group, struct x
> > >  		return err;
> > > 
> > >  	if (xe_vm_in_fault_mode(q->vm) && group->cur_mode == EXEC_MODE_DMA_FENCE) {
> > > -		q->ops->suspend(q);
> > > +		/*
> > > +		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
> > > +		 * queue un-suspended. Propagate the failure so the queue is not
> > > +		 * added; on failure nothing was suspended, so there is nothing to
> > > +		 * undo. Only record the queue as suspended (and later resume it)
> > > +		 * once suspend() has succeeded.
> > > +		 */
> > > +		err = q->ops->suspend(q);
> > > +		if (err)
> > > +			goto err_suspend;
> > > +
> > > +		WRITE_ONCE(q->lr.suspended, true);
> > >  		err = q->ops->suspend_wait(q);
> > >  		if (err)
> > >  			goto err_suspend;
> > > @@ -216,8 +236,20 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
> > >  			return -EAGAIN;
> > > 
> > >  		xe_gt_stats_incr(q->gt, XE_GT_STATS_ID_HW_ENGINE_GROUP_SUSPEND_LR_QUEUE_COUNT, 1);
> > > +		/*
> > > +		 * suspend() can fail (e.g. killed/banned/wedged), leaving the
> > > +		 * queue un-suspended. Propagate the failure, but first undo the
> > > +		 * partial suspend by resuming the sibling queues already
> > > +		 * suspended in this call (see err_resume). Record per-queue that
> > > +		 * the suspend succeeded so only those queues are later waited on
> > > +		 * and resumed.
> > > +		 */
> > > +		err = q->ops->suspend(q);
> > > +		if (err)
> > > +			goto err_resume;
> > 
> > 
> > This is not right. I think what you want here is:
> > 
> > err = q->ops->suspend(q);
> > if (err)
> >        continue;
> > 
> > A killed, banned, or wedged job should not abort the entire suspend
> > flow and propagate an error back through the user IOCTL. The "group" is
> > a cross-process concept (i.e., a global concept), so a queue tearing
> > down in one process should not affect submissions from another process.
> > 
> > I'm pretty sure you could trivially cause a compositor exec IOCTL to
> > fail by running applications that page-fault and hang, or by killing
> > them with Ctrl-C. Under the right conditions, the compositor could then
> > see an error from its exec IOCTL while trying to render a frame.
> > 
> 
> Ok got it, will 'continue' if suspend() returns error here.
> 
> > > +
> > > +		WRITE_ONCE(q->lr.suspended, true);
> > >  		need_resume = true;
> > > -		q->ops->suspend(q);
> > >  		gt = q->gt;
> > >  	}
> > > 
> > > @@ -225,9 +257,13 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
> > >  		if (!xe_vm_in_fault_mode(q->vm))
> > >  			continue;
> > > 
> > > +		/* Only wait on queues that were actually suspended above. */
> > > +		if (!READ_ONCE(q->lr.suspended))
> > > +			continue;
> > > +
> > >  		err = q->ops->suspend_wait(q);
> > >  		if (err)
> > > -			return err;
> > > +			goto err_resume;
> > >  	}
> > > 
> > >  	if (gt) {
> > > @@ -240,6 +276,40 @@ static int xe_hw_engine_group_suspend_faulting_lr_jobs(struct xe_hw_engine_group
> > >  		xe_hw_engine_group_resume_faulting_lr_jobs(group);
> > > 
> > >  	return 0;
> > > +
> > > +err_resume:
> > > +	/*
> > > +	 * A suspend()/suspend_wait() failed partway through the mode switch.
> > > +	 * Resume the sibling queues that were already suspended in this call so
> > > +	 * they are not left suspended forever.
> > > +	 *
> > > +	 * resume() requires the suspend to have completed (suspend_pending
> > > +	 * cleared) or it trips the !suspend_pending assert. So skip the resume
> > > +	 * when either:
> > > +	 *  - suspend_wait() fails: the suspend did not complete (timeout, VF
> > 
> > VF recovery is a non-issue given page faults are not enabled on VFs which
> > can migrate. Don't bring that up here as if that needs to be handled
> > this code would have to look different, or mentiond VF recovery doesn't
> > need to be considered.
> 
> Ok, will update comment here.
> 
> > 
> > > +	 *    recovery, interrupt), so suspend_pending may still be set; or
> > 
> > IRQs are a valid concern and this part doesn't look right.
> > 
> > > +	 *  - reset_status() is true: the queue was reset/killed/banned/wedged.
> > > +	 *    suspend_wait() can return success in this case via its killed/
> > > +	 *    stopped wait condition while suspend_pending is still set, and the
> > > +	 *    queue is being torn down anyway, so its state is resolved by
> > > +	 *    teardown rather than by a resume here.
> > > +	 * In either case leave the queue marked suspended.
> > > +	 */
> > > +	list_for_each_entry(q, &group->exec_queue_list, hw_engine_group_link) {
> > > +		if (!xe_vm_in_fault_mode(q->vm))
> > > +			continue;
> > > +
> > > +		if (!READ_ONCE(q->lr.suspended))
> > > +			continue;
> > > +
> > > +		if (q->ops->suspend_wait(q) || q->ops->reset_status(q))
> > 
> > -ERESTARTSYS on this process doesn't mean a different processes queues
> > are bad. I believe what we need to here is suspend_wait_no_irq(q) to
> > recover any suspended queues back to the resume state. Yes, ctrl-c /
> > process kill will have block but I don't see any other option to
> > maintain balance.
> > 
> > So I'd write this like:
> > 
> > if (q->ops->reset_status(q))
> > 	continue;
> > 
> > q->ops->suspend_wait_no_irq(q);
> > 
> > Or feel free to a no_irq argument to suspend_wait.
> > 
> 
> Ok, will add a q->ops->suspend_wait_blocking() to be called from
> the error path here which will just use wait_event() variant (the
> non-interruptible variant) and will not include vf_recovery()
> check also. So, it will be absolute wait in the error path.
> Is that fine?

Yes, that sounds right.

Matt

> 
> Niranjana
> 
> > Matt
> > 
> > > +			continue;
> > > +
> > > +		WRITE_ONCE(q->lr.suspended, false);
> > > +		q->ops->resume(q);
> > > +	}
> > > +
> > > +	return err;
> > >  }
> > > 
> > >  /**
> > > --
> > > 2.43.0
> > > 

[PATCH v2 3/5] drm/xe/guc: wait killably for suspend and ban queue on timeout

[Niranjana Vishwanathapura]

Harden guc_exec_queue_suspend_wait():

 - Wait killably rather than interruptibly. Once a suspend has been
   issued it must be waited to completion (or timeout); an arbitrary
   non-fatal signal must not abandon an in-flight suspend, otherwise the
   wait reports a spurious failure while the suspend is still pending.
   Only a fatal signal aborts, in which case the dying task tears the
   queue down (clearing suspend_pending), so no stuck state persists.

 - On timeout, ban the queue and trigger cleanup rather than leaving it
   suspended forever. Clearing suspend_pending via __suspend_fence_signal()
   lets a subsequent resume() proceed without tripping the
   !suspend_pending assert.

v2: Add comment about -ERESTARTSYS in suspend_wait

Assisted-by: Github-Copilot:Claude-opus-4.8
Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
---
 drivers/gpu/drm/xe/xe_guc_submit.c | 39 ++++++++++++++++++++++++------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
index 9458bf477fa6..3d9bdc22c89f 100644
--- a/drivers/gpu/drm/xe/xe_guc_submit.c
+++ b/drivers/gpu/drm/xe/xe_guc_submit.c
@@ -2195,22 +2195,41 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
 	 xe_guc_read_stopped(guc))
 
 retry:
+	/*
+	 * Wait killably rather than interruptibly: once a suspend has been
+	 * issued it must be waited to completion (or timeout), otherwise an
+	 * arbitrary (non-fatal) signal would abandon an in-flight suspend and
+	 * the wait would report a spurious failure while suspend_pending is
+	 * still set. Only a fatal signal aborts here; in that case the dying
+	 * task tears the queue down (clearing suspend_pending), so no stuck
+	 * state persists.
+	 */
 	if (IS_SRIOV_VF(xe))
-		ret = wait_event_interruptible_timeout(guc->ct.wq, WAIT_COND ||
-						       vf_recovery(guc),
-						       HZ * 5);
+		ret = wait_event_killable_timeout(guc->ct.wq, WAIT_COND ||
+						  vf_recovery(guc), HZ * 5);
 	else
-		ret = wait_event_interruptible_timeout(q->guc->suspend_wait,
-						       WAIT_COND, HZ * 5);
+		ret = wait_event_killable_timeout(q->guc->suspend_wait,
+						  WAIT_COND, HZ * 5);
 
 	if (vf_recovery(guc) && !xe_device_wedged((guc_to_xe(guc))))
 		return -EAGAIN;
 
 	if (!ret) {
 		xe_gt_warn(guc_to_gt(guc),
-			   "Suspend fence, guc_id=%d, failed to respond",
+			   "Suspend fence, guc_id=%d, failed to respond, banning queue",
 			   q->guc->id);
-		/* XXX: Trigger GT reset? */
+		/*
+		 * The GuC failed to respond to the suspend within the timeout.
+		 * This is not recoverable for this context, so ban it rather
+		 * than leave it suspended forever (unmarked). Clearing
+		 * suspend_pending lets a subsequent resume() proceed without
+		 * tripping the !suspend_pending assert (the RESUME message is
+		 * dropped for a banned queue), and triggering cleanup tears the
+		 * context down.
+		 */
+		set_exec_queue_banned(q);
+		__suspend_fence_signal(q);
+		xe_guc_exec_queue_trigger_cleanup(q);
 		return -ETIME;
 	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
 		/* Corner case on RESFIX DONE where vf_recovery() changes */
@@ -2219,6 +2238,12 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
 
 #undef WAIT_COND
 
+	/*
+	 * ret < 0 (-ERESTARTSYS): aborted by a fatal signal. The queue is not
+	 * banned - the failure is in the waiter, not the queue. The suspend is
+	 * not confirmed complete, so suspend_pending may still be set; callers
+	 * must not resume() on this error without re-confirming the suspend.
+	 */
 	return ret < 0 ? ret : 0;
 }
 
-- 
2.43.0

Re: [PATCH v2 3/5] drm/xe/guc: wait killably for suspend and ban queue on timeout

[Matthew Brost]

On Tue, Jun 30, 2026 at 10:07:31PM -0700, Niranjana Vishwanathapura wrote:
> Harden guc_exec_queue_suspend_wait():
> 
>  - Wait killably rather than interruptibly. Once a suspend has been
>    issued it must be waited to completion (or timeout); an arbitrary
>    non-fatal signal must not abandon an in-flight suspend, otherwise the
>    wait reports a spurious failure while the suspend is still pending.
>    Only a fatal signal aborts, in which case the dying task tears the
>    queue down (clearing suspend_pending), so no stuck state persists.
> 
>  - On timeout, ban the queue and trigger cleanup rather than leaving it
>    suspended forever. Clearing suspend_pending via __suspend_fence_signal()
>    lets a subsequent resume() proceed without tripping the
>    !suspend_pending assert.
> 
> v2: Add comment about -ERESTARTSYS in suspend_wait
> 

This doesn't actually help per my comments in patch #2 given sigkill on
one process doesn't mean another processes queues are being torn down.

I'd drop this patch as I dont see this buying us anything.

Matt

> Assisted-by: Github-Copilot:Claude-opus-4.8
> Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_guc_submit.c | 39 ++++++++++++++++++++++++------
>  1 file changed, 32 insertions(+), 7 deletions(-)
> 
> diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
> index 9458bf477fa6..3d9bdc22c89f 100644
> --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> @@ -2195,22 +2195,41 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>  	 xe_guc_read_stopped(guc))
>  
>  retry:
> +	/*
> +	 * Wait killably rather than interruptibly: once a suspend has been
> +	 * issued it must be waited to completion (or timeout), otherwise an
> +	 * arbitrary (non-fatal) signal would abandon an in-flight suspend and
> +	 * the wait would report a spurious failure while suspend_pending is
> +	 * still set. Only a fatal signal aborts here; in that case the dying
> +	 * task tears the queue down (clearing suspend_pending), so no stuck
> +	 * state persists.
> +	 */
>  	if (IS_SRIOV_VF(xe))
> -		ret = wait_event_interruptible_timeout(guc->ct.wq, WAIT_COND ||
> -						       vf_recovery(guc),
> -						       HZ * 5);
> +		ret = wait_event_killable_timeout(guc->ct.wq, WAIT_COND ||
> +						  vf_recovery(guc), HZ * 5);
>  	else
> -		ret = wait_event_interruptible_timeout(q->guc->suspend_wait,
> -						       WAIT_COND, HZ * 5);
> +		ret = wait_event_killable_timeout(q->guc->suspend_wait,
> +						  WAIT_COND, HZ * 5);
>  
>  	if (vf_recovery(guc) && !xe_device_wedged((guc_to_xe(guc))))
>  		return -EAGAIN;
>  
>  	if (!ret) {
>  		xe_gt_warn(guc_to_gt(guc),
> -			   "Suspend fence, guc_id=%d, failed to respond",
> +			   "Suspend fence, guc_id=%d, failed to respond, banning queue",
>  			   q->guc->id);
> -		/* XXX: Trigger GT reset? */
> +		/*
> +		 * The GuC failed to respond to the suspend within the timeout.
> +		 * This is not recoverable for this context, so ban it rather
> +		 * than leave it suspended forever (unmarked). Clearing
> +		 * suspend_pending lets a subsequent resume() proceed without
> +		 * tripping the !suspend_pending assert (the RESUME message is
> +		 * dropped for a banned queue), and triggering cleanup tears the
> +		 * context down.
> +		 */
> +		set_exec_queue_banned(q);
> +		__suspend_fence_signal(q);
> +		xe_guc_exec_queue_trigger_cleanup(q);
>  		return -ETIME;
>  	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
>  		/* Corner case on RESFIX DONE where vf_recovery() changes */
> @@ -2219,6 +2238,12 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>  
>  #undef WAIT_COND
>  
> +	/*
> +	 * ret < 0 (-ERESTARTSYS): aborted by a fatal signal. The queue is not
> +	 * banned - the failure is in the waiter, not the queue. The suspend is
> +	 * not confirmed complete, so suspend_pending may still be set; callers
> +	 * must not resume() on this error without re-confirming the suspend.
> +	 */
>  	return ret < 0 ? ret : 0;
>  }
>  
> -- 
> 2.43.0
> 

Re: [PATCH v2 3/5] drm/xe/guc: wait killably for suspend and ban queue on timeout

[Matthew Brost]

On Thu, Jul 09, 2026 at 01:36:14PM -0700, Matthew Brost wrote:


> On Tue, Jun 30, 2026 at 10:07:31PM -0700, Niranjana Vishwanathapura wrote:
> > Harden guc_exec_queue_suspend_wait():
> > 
> >  - Wait killably rather than interruptibly. Once a suspend has been
> >    issued it must be waited to completion (or timeout); an arbitrary
> >    non-fatal signal must not abandon an in-flight suspend, otherwise the
> >    wait reports a spurious failure while the suspend is still pending.
> >    Only a fatal signal aborts, in which case the dying task tears the
> >    queue down (clearing suspend_pending), so no stuck state persists.
> > 
> >  - On timeout, ban the queue and trigger cleanup rather than leaving it
> >    suspended forever. Clearing suspend_pending via __suspend_fence_signal()
> >    lets a subsequent resume() proceed without tripping the
> >    !suspend_pending assert.
> > 
> > v2: Add comment about -ERESTARTSYS in suspend_wait
> > 
> 
> This doesn't actually help per my comments in patch #2 given sigkill on
> one process doesn't mean another processes queues are being torn down.
> 
> I'd drop this patch as I dont see this buying us anything.
> 
> Matt
> 

Sorry typing too fast... More below.

> > Assisted-by: Github-Copilot:Claude-opus-4.8
> > Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> > ---
> >  drivers/gpu/drm/xe/xe_guc_submit.c | 39 ++++++++++++++++++++++++------
> >  1 file changed, 32 insertions(+), 7 deletions(-)
> > 
> > diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
> > index 9458bf477fa6..3d9bdc22c89f 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> > @@ -2195,22 +2195,41 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
> >  	 xe_guc_read_stopped(guc))
> >  
> >  retry:
> > +	/*
> > +	 * Wait killably rather than interruptibly: once a suspend has been
> > +	 * issued it must be waited to completion (or timeout), otherwise an
> > +	 * arbitrary (non-fatal) signal would abandon an in-flight suspend and
> > +	 * the wait would report a spurious failure while suspend_pending is
> > +	 * still set. Only a fatal signal aborts here; in that case the dying
> > +	 * task tears the queue down (clearing suspend_pending), so no stuck
> > +	 * state persists.
> > +	 */
> >  	if (IS_SRIOV_VF(xe))
> > -		ret = wait_event_interruptible_timeout(guc->ct.wq, WAIT_COND ||
> > -						       vf_recovery(guc),
> > -						       HZ * 5);
> > +		ret = wait_event_killable_timeout(guc->ct.wq, WAIT_COND ||
> > +						  vf_recovery(guc), HZ * 5);
> >  	else
> > -		ret = wait_event_interruptible_timeout(q->guc->suspend_wait,
> > -						       WAIT_COND, HZ * 5);
> > +		ret = wait_event_killable_timeout(q->guc->suspend_wait,
> > +						  WAIT_COND, HZ * 5);

Drop this part.

> >  
> >  	if (vf_recovery(guc) && !xe_device_wedged((guc_to_xe(guc))))
> >  		return -EAGAIN;
> >  
> >  	if (!ret) {
> >  		xe_gt_warn(guc_to_gt(guc),
> > -			   "Suspend fence, guc_id=%d, failed to respond",
> > +			   "Suspend fence, guc_id=%d, failed to respond, banning queue",
> >  			   q->guc->id);
> > -		/* XXX: Trigger GT reset? */
> > +		/*
> > +		 * The GuC failed to respond to the suspend within the timeout.
> > +		 * This is not recoverable for this context, so ban it rather
> > +		 * than leave it suspended forever (unmarked). Clearing
> > +		 * suspend_pending lets a subsequent resume() proceed without
> > +		 * tripping the !suspend_pending assert (the RESUME message is
> > +		 * dropped for a banned queue), and triggering cleanup tears the
> > +		 * context down.
> > +		 */
> > +		set_exec_queue_banned(q);
> > +		__suspend_fence_signal(q);
> > +		xe_guc_exec_queue_trigger_cleanup(q);

This part mostly looks good but __suspend_fence_signal should actually
be signaled in the TDR after queue is off the hardware as without that
we could get a memory corruption signaling suspend fence early while the
hardware could possibly be touching memory.

guc_exec_queue_kill has the same bug which should also be fixed.

Matt 

> >  		return -ETIME;
> >  	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
> >  		/* Corner case on RESFIX DONE where vf_recovery() changes */
> > @@ -2219,6 +2238,12 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
> >  
> >  #undef WAIT_COND
> >  
> > +	/*
> > +	 * ret < 0 (-ERESTARTSYS): aborted by a fatal signal. The queue is not
> > +	 * banned - the failure is in the waiter, not the queue. The suspend is
> > +	 * not confirmed complete, so suspend_pending may still be set; callers
> > +	 * must not resume() on this error without re-confirming the suspend.
> > +	 */
> >  	return ret < 0 ? ret : 0;
> >  }
> >  
> > -- 
> > 2.43.0
> > 

Re: [PATCH v2 3/5] drm/xe/guc: wait killably for suspend and ban queue on timeout

[Niranjana Vishwanathapura]

On Thu, Jul 09, 2026 at 01:40:49PM -0700, Matthew Brost wrote:
>On Thu, Jul 09, 2026 at 01:36:14PM -0700, Matthew Brost wrote:
>
>
>> On Tue, Jun 30, 2026 at 10:07:31PM -0700, Niranjana Vishwanathapura wrote:
>> > Harden guc_exec_queue_suspend_wait():
>> >
>> >  - Wait killably rather than interruptibly. Once a suspend has been
>> >    issued it must be waited to completion (or timeout); an arbitrary
>> >    non-fatal signal must not abandon an in-flight suspend, otherwise the
>> >    wait reports a spurious failure while the suspend is still pending.
>> >    Only a fatal signal aborts, in which case the dying task tears the
>> >    queue down (clearing suspend_pending), so no stuck state persists.
>> >
>> >  - On timeout, ban the queue and trigger cleanup rather than leaving it
>> >    suspended forever. Clearing suspend_pending via __suspend_fence_signal()
>> >    lets a subsequent resume() proceed without tripping the
>> >    !suspend_pending assert.
>> >
>> > v2: Add comment about -ERESTARTSYS in suspend_wait
>> >
>>
>> This doesn't actually help per my comments in patch #2 given sigkill on
>> one process doesn't mean another processes queues are being torn down.
>>
>> I'd drop this patch as I dont see this buying us anything.
>>
>> Matt
>>
>
>Sorry typing too fast... More below.
>
>> > Assisted-by: Github-Copilot:Claude-opus-4.8
>> > Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
>> > ---
>> >  drivers/gpu/drm/xe/xe_guc_submit.c | 39 ++++++++++++++++++++++++------
>> >  1 file changed, 32 insertions(+), 7 deletions(-)
>> >
>> > diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
>> > index 9458bf477fa6..3d9bdc22c89f 100644
>> > --- a/drivers/gpu/drm/xe/xe_guc_submit.c
>> > +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
>> > @@ -2195,22 +2195,41 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>> >  	 xe_guc_read_stopped(guc))
>> >
>> >  retry:
>> > +	/*
>> > +	 * Wait killably rather than interruptibly: once a suspend has been
>> > +	 * issued it must be waited to completion (or timeout), otherwise an
>> > +	 * arbitrary (non-fatal) signal would abandon an in-flight suspend and
>> > +	 * the wait would report a spurious failure while suspend_pending is
>> > +	 * still set. Only a fatal signal aborts here; in that case the dying
>> > +	 * task tears the queue down (clearing suspend_pending), so no stuck
>> > +	 * state persists.
>> > +	 */
>> >  	if (IS_SRIOV_VF(xe))
>> > -		ret = wait_event_interruptible_timeout(guc->ct.wq, WAIT_COND ||
>> > -						       vf_recovery(guc),
>> > -						       HZ * 5);
>> > +		ret = wait_event_killable_timeout(guc->ct.wq, WAIT_COND ||
>> > +						  vf_recovery(guc), HZ * 5);
>> >  	else
>> > -		ret = wait_event_interruptible_timeout(q->guc->suspend_wait,
>> > -						       WAIT_COND, HZ * 5);
>> > +		ret = wait_event_killable_timeout(q->guc->suspend_wait,
>> > +						  WAIT_COND, HZ * 5);
>
>Drop this part.
>

wait_event_interruptible_timeout() will get woken up for user signals (SIGINT)
also with -ERESTARTSYS as return value and I am not sure if it is ok to treat that
as an error condition without a retry. The wait_event_killable_timeout() only gets
woken for fatal signals (and not SIGINT).

>> >
>> >  	if (vf_recovery(guc) && !xe_device_wedged((guc_to_xe(guc))))
>> >  		return -EAGAIN;
>> >
>> >  	if (!ret) {
>> >  		xe_gt_warn(guc_to_gt(guc),
>> > -			   "Suspend fence, guc_id=%d, failed to respond",
>> > +			   "Suspend fence, guc_id=%d, failed to respond, banning queue",
>> >  			   q->guc->id);
>> > -		/* XXX: Trigger GT reset? */
>> > +		/*
>> > +		 * The GuC failed to respond to the suspend within the timeout.
>> > +		 * This is not recoverable for this context, so ban it rather
>> > +		 * than leave it suspended forever (unmarked). Clearing
>> > +		 * suspend_pending lets a subsequent resume() proceed without
>> > +		 * tripping the !suspend_pending assert (the RESUME message is
>> > +		 * dropped for a banned queue), and triggering cleanup tears the
>> > +		 * context down.
>> > +		 */
>> > +		set_exec_queue_banned(q);
>> > +		__suspend_fence_signal(q);
>> > +		xe_guc_exec_queue_trigger_cleanup(q);
>
>This part mostly looks good but __suspend_fence_signal should actually
>be signaled in the TDR after queue is off the hardware as without that
>we could get a memory corruption signaling suspend fence early while the
>hardware could possibly be touching memory.
>
>guc_exec_queue_kill has the same bug which should also be fixed.
>

Ok. It seems there are 2 issues here, but both of them also apply to
existing cases like guc_exec_queue_kill().

1. The one you mentioned above. It seems the fix will be bit more involved
as suspend_wait() returns immediately if the queue is killed before TDR can
run and take the job off of HW. So, caller of suspend_wait() must handle it
somehow and not trigger any fences.

2. handle_sched_done()/guc_exec_queue_stop() reading suspend_pending and calling
suspend_fence_signal() might race against guc_exec_queue_kill()/suspend_wait()
clearing the suspend_pending. This might lead to hitting suspend_pending assert
in suspend_fence_signal(). Some some kind of locking is required here. Probably
xe_sched_msg_lock() will do here.

But both of these cases goes beyond this patch series. Is it ok if we can take
it separately and address it in a later patch series?

Niranjana

>Matt
>
>> >  		return -ETIME;
>> >  	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
>> >  		/* Corner case on RESFIX DONE where vf_recovery() changes */
>> > @@ -2219,6 +2238,12 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>> >
>> >  #undef WAIT_COND
>> >
>> > +	/*
>> > +	 * ret < 0 (-ERESTARTSYS): aborted by a fatal signal. The queue is not
>> > +	 * banned - the failure is in the waiter, not the queue. The suspend is
>> > +	 * not confirmed complete, so suspend_pending may still be set; callers
>> > +	 * must not resume() on this error without re-confirming the suspend.
>> > +	 */
>> >  	return ret < 0 ? ret : 0;
>> >  }
>> >
>> > --
>> > 2.43.0
>> >

Re: [PATCH v2 3/5] drm/xe/guc: wait killably for suspend and ban queue on timeout

[Matthew Brost]

On Thu, Jul 09, 2026 at 09:30:30PM -0700, Niranjana Vishwanathapura wrote:
> On Thu, Jul 09, 2026 at 01:40:49PM -0700, Matthew Brost wrote:
> > On Thu, Jul 09, 2026 at 01:36:14PM -0700, Matthew Brost wrote:
> > 
> > 
> > > On Tue, Jun 30, 2026 at 10:07:31PM -0700, Niranjana Vishwanathapura wrote:
> > > > Harden guc_exec_queue_suspend_wait():
> > > >
> > > >  - Wait killably rather than interruptibly. Once a suspend has been
> > > >    issued it must be waited to completion (or timeout); an arbitrary
> > > >    non-fatal signal must not abandon an in-flight suspend, otherwise the
> > > >    wait reports a spurious failure while the suspend is still pending.
> > > >    Only a fatal signal aborts, in which case the dying task tears the
> > > >    queue down (clearing suspend_pending), so no stuck state persists.
> > > >
> > > >  - On timeout, ban the queue and trigger cleanup rather than leaving it
> > > >    suspended forever. Clearing suspend_pending via __suspend_fence_signal()
> > > >    lets a subsequent resume() proceed without tripping the
> > > >    !suspend_pending assert.
> > > >
> > > > v2: Add comment about -ERESTARTSYS in suspend_wait
> > > >
> > > 
> > > This doesn't actually help per my comments in patch #2 given sigkill on
> > > one process doesn't mean another processes queues are being torn down.
> > > 
> > > I'd drop this patch as I dont see this buying us anything.
> > > 
> > > Matt
> > > 
> > 
> > Sorry typing too fast... More below.
> > 
> > > > Assisted-by: Github-Copilot:Claude-opus-4.8
> > > > Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> > > > ---
> > > >  drivers/gpu/drm/xe/xe_guc_submit.c | 39 ++++++++++++++++++++++++------
> > > >  1 file changed, 32 insertions(+), 7 deletions(-)
> > > >
> > > > diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
> > > > index 9458bf477fa6..3d9bdc22c89f 100644
> > > > --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> > > > +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> > > > @@ -2195,22 +2195,41 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
> > > >  	 xe_guc_read_stopped(guc))
> > > >
> > > >  retry:
> > > > +	/*
> > > > +	 * Wait killably rather than interruptibly: once a suspend has been
> > > > +	 * issued it must be waited to completion (or timeout), otherwise an
> > > > +	 * arbitrary (non-fatal) signal would abandon an in-flight suspend and
> > > > +	 * the wait would report a spurious failure while suspend_pending is
> > > > +	 * still set. Only a fatal signal aborts here; in that case the dying
> > > > +	 * task tears the queue down (clearing suspend_pending), so no stuck
> > > > +	 * state persists.
> > > > +	 */
> > > >  	if (IS_SRIOV_VF(xe))
> > > > -		ret = wait_event_interruptible_timeout(guc->ct.wq, WAIT_COND ||
> > > > -						       vf_recovery(guc),
> > > > -						       HZ * 5);
> > > > +		ret = wait_event_killable_timeout(guc->ct.wq, WAIT_COND ||
> > > > +						  vf_recovery(guc), HZ * 5);
> > > >  	else
> > > > -		ret = wait_event_interruptible_timeout(q->guc->suspend_wait,
> > > > -						       WAIT_COND, HZ * 5);
> > > > +		ret = wait_event_killable_timeout(q->guc->suspend_wait,
> > > > +						  WAIT_COND, HZ * 5);
> > 
> > Drop this part.
> > 
> 
> wait_event_interruptible_timeout() will get woken up for user signals (SIGINT)
> also with -ERESTARTSYS as return value and I am not sure if it is ok to treat that
> as an error condition without a retry. The wait_event_killable_timeout() only gets
> woken for fatal signals (and not SIGINT).
> 

My point is if you can make sigkill work, you get sigint for free as to
the upper layers the handling is the same, so might as leave this as is.

> > > >
> > > >  	if (vf_recovery(guc) && !xe_device_wedged((guc_to_xe(guc))))
> > > >  		return -EAGAIN;
> > > >
> > > >  	if (!ret) {
> > > >  		xe_gt_warn(guc_to_gt(guc),
> > > > -			   "Suspend fence, guc_id=%d, failed to respond",
> > > > +			   "Suspend fence, guc_id=%d, failed to respond, banning queue",
> > > >  			   q->guc->id);
> > > > -		/* XXX: Trigger GT reset? */
> > > > +		/*
> > > > +		 * The GuC failed to respond to the suspend within the timeout.
> > > > +		 * This is not recoverable for this context, so ban it rather
> > > > +		 * than leave it suspended forever (unmarked). Clearing
> > > > +		 * suspend_pending lets a subsequent resume() proceed without
> > > > +		 * tripping the !suspend_pending assert (the RESUME message is
> > > > +		 * dropped for a banned queue), and triggering cleanup tears the
> > > > +		 * context down.
> > > > +		 */
> > > > +		set_exec_queue_banned(q);
> > > > +		__suspend_fence_signal(q);
> > > > +		xe_guc_exec_queue_trigger_cleanup(q);
> > 
> > This part mostly looks good but __suspend_fence_signal should actually
> > be signaled in the TDR after queue is off the hardware as without that
> > we could get a memory corruption signaling suspend fence early while the
> > hardware could possibly be touching memory.
> > 
> > guc_exec_queue_kill has the same bug which should also be fixed.
> > 
> 
> Ok. It seems there are 2 issues here, but both of them also apply to
> existing cases like guc_exec_queue_kill().
> 
> 1. The one you mentioned above. It seems the fix will be bit more involved
> as suspend_wait() returns immediately if the queue is killed before TDR can
> run and take the job off of HW. So, caller of suspend_wait() must handle it
> somehow and not trigger any fences.
> 
> 2. handle_sched_done()/guc_exec_queue_stop() reading suspend_pending and calling
> suspend_fence_signal() might race against guc_exec_queue_kill()/suspend_wait()
> clearing the suspend_pending. This might lead to hitting suspend_pending assert
> in suspend_fence_signal(). Some some kind of locking is required here. Probably
> xe_sched_msg_lock() will do here.
> 
> But both of these cases goes beyond this patch series. Is it ok if we can take
> it separately and address it in a later patch series?

No problem fixing up this part of later. I was going to rework the
guc_exec_queue_kill() logic to avoid faults on FD close and fix up
guc_exec_queue_kill() then and if this merged will also fix this part
up.

Matt

> 
> Niranjana
> 
> > Matt
> > 
> > > >  		return -ETIME;
> > > >  	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
> > > >  		/* Corner case on RESFIX DONE where vf_recovery() changes */
> > > > @@ -2219,6 +2238,12 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
> > > >
> > > >  #undef WAIT_COND
> > > >
> > > > +	/*
> > > > +	 * ret < 0 (-ERESTARTSYS): aborted by a fatal signal. The queue is not
> > > > +	 * banned - the failure is in the waiter, not the queue. The suspend is
> > > > +	 * not confirmed complete, so suspend_pending may still be set; callers
> > > > +	 * must not resume() on this error without re-confirming the suspend.
> > > > +	 */
> > > >  	return ret < 0 ? ret : 0;
> > > >  }
> > > >
> > > > --
> > > > 2.43.0
> > > >

[PATCH v2 4/5] drm/xe/guc: Add suspend refcount to exec queue ops

[Niranjana Vishwanathapura]

From: Thomas Hellström <thomas.hellstrom@linux.intel.com>

With the lr.suspended flag a consumer already pairs its own suspend()
and resume() correctly, and no current path issues overlapping suspends
on the same queue.

Add a reference count to the exec queue suspend operations, as a small
self-contained building block for callers that can genuinely overlap.
A queue stays suspended as long as any caller holds a suspend and only
resumes once the last caller releases it, so each caller pairs its own
suspend/resume without needing to know about the others. This is what
the upcoming multi-queue support needs, where queues in a group share
a primary and may be suspended concurrently.

Assisted-by: GitHub_Copilot:claude-sonnet-4.6
Co-authored-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
Signed-off-by: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
---
 drivers/gpu/drm/xe/xe_guc_exec_queue_types.h |  7 +++++
 drivers/gpu/drm/xe/xe_guc_submit.c           | 30 ++++++++++++++------
 2 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h b/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
index e5e53b421f29..1207d51cf770 100644
--- a/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
+++ b/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
@@ -49,6 +49,13 @@ struct xe_guc_exec_queue {
 	wait_queue_head_t suspend_wait;
 	/** @suspend_pending: a suspend of the exec_queue is pending */
 	bool suspend_pending;
+	/**
+	 * @suspend_count: Reference count of active suspend requests. The
+	 * exec_queue remains suspended while this is non-zero, allowing
+	 * multiple concurrent callers to independently hold a suspend without
+	 * prematurely re-enabling the queue. Protected by @sched.msg_lock.
+	 */
+	int suspend_count;
 	/**
 	 * @needs_cleanup: Needs a cleanup message during VF post migration
 	 * recovery.
diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
index 3d9bdc22c89f..f7a3ff0d0b1d 100644
--- a/drivers/gpu/drm/xe/xe_guc_submit.c
+++ b/drivers/gpu/drm/xe/xe_guc_submit.c
@@ -2165,15 +2165,21 @@ static int guc_exec_queue_set_multi_queue_priority(struct xe_exec_queue *q,
 
 static int guc_exec_queue_suspend(struct xe_exec_queue *q)
 {
-	struct xe_gpu_scheduler *sched = &q->guc->sched;
-	struct xe_sched_msg *msg = q->guc->static_msgs + STATIC_MSG_SUSPEND;
+	struct xe_guc_exec_queue *ge = q->guc;
+	struct xe_gpu_scheduler *sched = &ge->sched;
+	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_SUSPEND;
 
 	if (exec_queue_killed_or_banned_or_wedged(q))
 		return -EINVAL;
 
 	xe_sched_msg_lock(sched);
-	if (guc_exec_queue_try_add_msg(q, msg, SUSPEND))
-		q->guc->suspend_pending = true;
+	if (++ge->suspend_count == 1) {
+		bool added = guc_exec_queue_try_add_msg(q, msg, SUSPEND);
+
+		/* slot must be free at 0->1 */
+		xe_gt_assert(guc_to_gt(exec_queue_to_guc(q)), added);
+		ge->suspend_pending = true;
+	}
 	xe_sched_msg_unlock(sched);
 
 	return 0;
@@ -2249,14 +2255,20 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
 
 static void guc_exec_queue_resume(struct xe_exec_queue *q)
 {
-	struct xe_gpu_scheduler *sched = &q->guc->sched;
-	struct xe_sched_msg *msg = q->guc->static_msgs + STATIC_MSG_RESUME;
+	struct xe_guc_exec_queue *ge = q->guc;
+	struct xe_gpu_scheduler *sched = &ge->sched;
+	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_RESUME;
 	struct xe_guc *guc = exec_queue_to_guc(q);
 
-	xe_gt_assert(guc_to_gt(guc), !q->guc->suspend_pending);
-
 	xe_sched_msg_lock(sched);
-	guc_exec_queue_try_add_msg(q, msg, RESUME);
+	xe_gt_assert(guc_to_gt(guc), !ge->suspend_pending);
+	xe_gt_assert(guc_to_gt(guc), ge->suspend_count > 0);
+	if (--ge->suspend_count == 0) {
+		bool added = guc_exec_queue_try_add_msg(q, msg, RESUME);
+
+		/* slot must be free at 1->0 */
+		xe_gt_assert(guc_to_gt(guc), added);
+	}
 	xe_sched_msg_unlock(sched);
 }
 
-- 
2.43.0

Re: [PATCH v2 4/5] drm/xe/guc: Add suspend refcount to exec queue ops

[Matthew Brost]

On Tue, Jun 30, 2026 at 10:07:32PM -0700, Niranjana Vishwanathapura wrote:
> From: Thomas Hellström <thomas.hellstrom@linux.intel.com>
> 
> With the lr.suspended flag a consumer already pairs its own suspend()
> and resume() correctly, and no current path issues overlapping suspends
> on the same queue.
> 
> Add a reference count to the exec queue suspend operations, as a small
> self-contained building block for callers that can genuinely overlap.
> A queue stays suspended as long as any caller holds a suspend and only
> resumes once the last caller releases it, so each caller pairs its own
> suspend/resume without needing to know about the others. This is what
> the upcoming multi-queue support needs, where queues in a group share
> a primary and may be suspended concurrently.
> 
> Assisted-by: GitHub_Copilot:claude-sonnet-4.6
> Co-authored-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> Signed-off-by: Thomas Hellström <thomas.hellstrom@linux.intel.com>
> Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>

With the upper layer fixed in previous patches, this part LGTM.

Reviewed-by: Matthew Brost <matthew.brost@intel.com>

> ---
>  drivers/gpu/drm/xe/xe_guc_exec_queue_types.h |  7 +++++
>  drivers/gpu/drm/xe/xe_guc_submit.c           | 30 ++++++++++++++------
>  2 files changed, 28 insertions(+), 9 deletions(-)
> 
> diff --git a/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h b/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
> index e5e53b421f29..1207d51cf770 100644
> --- a/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
> +++ b/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
> @@ -49,6 +49,13 @@ struct xe_guc_exec_queue {
>  	wait_queue_head_t suspend_wait;
>  	/** @suspend_pending: a suspend of the exec_queue is pending */
>  	bool suspend_pending;
> +	/**
> +	 * @suspend_count: Reference count of active suspend requests. The
> +	 * exec_queue remains suspended while this is non-zero, allowing
> +	 * multiple concurrent callers to independently hold a suspend without
> +	 * prematurely re-enabling the queue. Protected by @sched.msg_lock.
> +	 */
> +	int suspend_count;
>  	/**
>  	 * @needs_cleanup: Needs a cleanup message during VF post migration
>  	 * recovery.
> diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
> index 3d9bdc22c89f..f7a3ff0d0b1d 100644
> --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> @@ -2165,15 +2165,21 @@ static int guc_exec_queue_set_multi_queue_priority(struct xe_exec_queue *q,
>  
>  static int guc_exec_queue_suspend(struct xe_exec_queue *q)
>  {
> -	struct xe_gpu_scheduler *sched = &q->guc->sched;
> -	struct xe_sched_msg *msg = q->guc->static_msgs + STATIC_MSG_SUSPEND;
> +	struct xe_guc_exec_queue *ge = q->guc;
> +	struct xe_gpu_scheduler *sched = &ge->sched;
> +	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_SUSPEND;
>  
>  	if (exec_queue_killed_or_banned_or_wedged(q))
>  		return -EINVAL;
>  
>  	xe_sched_msg_lock(sched);
> -	if (guc_exec_queue_try_add_msg(q, msg, SUSPEND))
> -		q->guc->suspend_pending = true;
> +	if (++ge->suspend_count == 1) {
> +		bool added = guc_exec_queue_try_add_msg(q, msg, SUSPEND);
> +
> +		/* slot must be free at 0->1 */
> +		xe_gt_assert(guc_to_gt(exec_queue_to_guc(q)), added);
> +		ge->suspend_pending = true;
> +	}
>  	xe_sched_msg_unlock(sched);
>  
>  	return 0;
> @@ -2249,14 +2255,20 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>  
>  static void guc_exec_queue_resume(struct xe_exec_queue *q)
>  {
> -	struct xe_gpu_scheduler *sched = &q->guc->sched;
> -	struct xe_sched_msg *msg = q->guc->static_msgs + STATIC_MSG_RESUME;
> +	struct xe_guc_exec_queue *ge = q->guc;
> +	struct xe_gpu_scheduler *sched = &ge->sched;
> +	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_RESUME;
>  	struct xe_guc *guc = exec_queue_to_guc(q);
>  
> -	xe_gt_assert(guc_to_gt(guc), !q->guc->suspend_pending);
> -
>  	xe_sched_msg_lock(sched);
> -	guc_exec_queue_try_add_msg(q, msg, RESUME);
> +	xe_gt_assert(guc_to_gt(guc), !ge->suspend_pending);
> +	xe_gt_assert(guc_to_gt(guc), ge->suspend_count > 0);
> +	if (--ge->suspend_count == 0) {
> +		bool added = guc_exec_queue_try_add_msg(q, msg, RESUME);
> +
> +		/* slot must be free at 1->0 */
> +		xe_gt_assert(guc_to_gt(guc), added);
> +	}
>  	xe_sched_msg_unlock(sched);
>  }
>  
> -- 
> 2.43.0
> 

[PATCH v2 5/5] drm/xe/multi_queue: preempt primary on queue group suspend

[Niranjana Vishwanathapura]

In a multi-queue group only the group's primary queue interfaces with
GuC for scheduling; suspend/resume of secondary queues is handled
internally and is not forwarded to GuC. As a result, suspending a
secondary queue alone (e.g. on its preempt fence signalling) does not
disable the primary's GuC context, so in-flight GPU work of the group
is not actually preempted.

Make a secondary queue suspend/resume like any other queue, driven by
its own xe_guc_exec_queue.suspend_count, and additionally forward the
suspend/resume to the primary so the GPU is actually preempted. The
forward is gated on the secondary's own 0->1 / 1->0 suspend_count
transition, so each group member contributes exactly one suspend
reference to the primary: the primary keeps its GuC context disabled
until every member that suspended it has resumed, including across the
resume-all-queues-each-rebind-cycle behavior. group->suspend_lock makes
the secondary transition and the primary forward atomic, and a member
leaving while still suspended (queue teardown) drops its reference on
the primary.

guc_exec_queue_suspend_wait() now waits on the primary, so on a suspend
timeout ban and tear down the whole group (set_exec_queue_group_banned()
and xe_guc_exec_queue_group_trigger_cleanup()) rather than just the
primary: the primary owns the group's GuC context, so its failure to
suspend wedges every member.

v2: suspend whole group upon error in suspend_wait

Assisted-by: Github-Copilot:Claude-opus-4.8
Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
---
 drivers/gpu/drm/xe/xe_exec_queue.c       |   1 +
 drivers/gpu/drm/xe/xe_exec_queue_types.h |   6 +
 drivers/gpu/drm/xe/xe_guc_submit.c       | 174 ++++++++++++++++++++---
 3 files changed, 161 insertions(+), 20 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_exec_queue.c b/drivers/gpu/drm/xe/xe_exec_queue.c
index 1b5ca3ce578a..df95855a3d61 100644
--- a/drivers/gpu/drm/xe/xe_exec_queue.c
+++ b/drivers/gpu/drm/xe/xe_exec_queue.c
@@ -842,6 +842,7 @@ static int xe_exec_queue_group_init(struct xe_device *xe, struct xe_exec_queue *
 	group->primary = q;
 	group->cgp_bo = bo;
 	INIT_LIST_HEAD(&group->list);
+	spin_lock_init(&group->suspend_lock);
 	xa_init_flags(&group->xa, XA_FLAGS_ALLOC1);
 	mutex_init(&group->list_lock);
 	q->multi_queue.group = group;
diff --git a/drivers/gpu/drm/xe/xe_exec_queue_types.h b/drivers/gpu/drm/xe/xe_exec_queue_types.h
index dbb2ee8eb5de..bf76a879aedc 100644
--- a/drivers/gpu/drm/xe/xe_exec_queue_types.h
+++ b/drivers/gpu/drm/xe/xe_exec_queue_types.h
@@ -62,6 +62,12 @@ struct xe_exec_queue_group {
 	struct list_head list;
 	/** @list_lock: Secondary queue list lock */
 	struct mutex list_lock;
+	/**
+	 * @suspend_lock: Makes a secondary's suspend/resume and its forwarding
+	 * to the primary atomic. Nested outside of the queue's message lock
+	 * (@xe_guc_exec_queue.sched.msg_lock).
+	 */
+	spinlock_t suspend_lock;
 	/** @sync_pending: CGP_SYNC_DONE g2h response pending */
 	bool sync_pending;
 	/** @banned: Group banned */
diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
index f7a3ff0d0b1d..b1591d02eed0 100644
--- a/drivers/gpu/drm/xe/xe_guc_submit.c
+++ b/drivers/gpu/drm/xe/xe_guc_submit.c
@@ -1681,11 +1681,24 @@ guc_exec_queue_timedout_job(struct drm_sched_job *drm_job)
 	return DRM_GPU_SCHED_STAT_NO_HANG;
 }
 
+static void guc_exec_queue_multi_queue_drop_suspend(struct xe_exec_queue *q);
+
 static void guc_exec_queue_fini(struct xe_exec_queue *q)
 {
 	struct xe_guc_exec_queue *ge = q->guc;
 	struct xe_guc *guc = exec_queue_to_guc(q);
 
+	/*
+	 * A secondary can leave the group while still preempt suspended (e.g.
+	 * xe_vm_remove_compute_exec_queue() forces its preempt fence to signal,
+	 * which suspends it). It holds one forwarded suspend reference on the
+	 * primary, so drop it and resume the primary if it was the last member
+	 * that had it suspended. Primaries forward to nobody, so they don't need
+	 * this.
+	 */
+	if (xe_exec_queue_is_multi_queue_secondary(q))
+		guc_exec_queue_multi_queue_drop_suspend(q);
+
 	if (xe_exec_queue_is_multi_queue_secondary(q)) {
 		struct xe_exec_queue_group *group = q->multi_queue.group;
 
@@ -2163,17 +2176,22 @@ static int guc_exec_queue_set_multi_queue_priority(struct xe_exec_queue *q,
 	return 0;
 }
 
-static int guc_exec_queue_suspend(struct xe_exec_queue *q)
+/*
+ * Core suspend: take a suspend reference on @q and, on the first reference,
+ * disable its GuC context so the GPU is actually preempted. Caller must have
+ * ensured @q is not killed/banned/wedged. Returns true if this was the first
+ * suspend reference (the 0->1 transition).
+ */
+static bool __guc_exec_queue_suspend(struct xe_exec_queue *q)
 {
 	struct xe_guc_exec_queue *ge = q->guc;
 	struct xe_gpu_scheduler *sched = &ge->sched;
 	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_SUSPEND;
-
-	if (exec_queue_killed_or_banned_or_wedged(q))
-		return -EINVAL;
+	bool first;
 
 	xe_sched_msg_lock(sched);
-	if (++ge->suspend_count == 1) {
+	first = (++ge->suspend_count == 1);
+	if (first) {
 		bool added = guc_exec_queue_try_add_msg(q, msg, SUSPEND);
 
 		/* slot must be free at 0->1 */
@@ -2182,6 +2200,68 @@ static int guc_exec_queue_suspend(struct xe_exec_queue *q)
 	}
 	xe_sched_msg_unlock(sched);
 
+	return first;
+}
+
+/*
+ * Core resume: drop a suspend reference on @q and, on the last reference,
+ * re-enable its GuC context. Returns true if this dropped the last suspend
+ * reference (the 1->0 transition).
+ */
+static bool __guc_exec_queue_resume(struct xe_exec_queue *q)
+{
+	struct xe_guc_exec_queue *ge = q->guc;
+	struct xe_gpu_scheduler *sched = &ge->sched;
+	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_RESUME;
+	struct xe_guc *guc = exec_queue_to_guc(q);
+	bool last;
+
+	xe_sched_msg_lock(sched);
+	xe_gt_assert(guc_to_gt(guc), !ge->suspend_pending);
+	xe_gt_assert(guc_to_gt(guc), ge->suspend_count > 0);
+	last = (--ge->suspend_count == 0);
+	if (last) {
+		bool added = guc_exec_queue_try_add_msg(q, msg, RESUME);
+
+		/* slot must be free at 1->0 */
+		xe_gt_assert(guc_to_gt(guc), added);
+	}
+	xe_sched_msg_unlock(sched);
+
+	return last;
+}
+
+static int guc_exec_queue_suspend(struct xe_exec_queue *q)
+{
+	if (exec_queue_killed_or_banned_or_wedged(q))
+		return -EINVAL;
+
+	/*
+	 * Non-multi-queue queues and multi-queue primaries suspend themselves
+	 * directly: their own msg_lock makes the suspend_count 0->1 transition
+	 * and the suspend_pending update atomic, so no group level serialization
+	 * is needed.
+	 */
+	if (!xe_exec_queue_is_multi_queue_secondary(q)) {
+		__guc_exec_queue_suspend(q);
+		return 0;
+	}
+
+	/*
+	 * A secondary doesn't interface with GuC: suspend it like any other
+	 * queue (its own suspend_count drives its internally handled scheduler
+	 * state) and, only on its own 0->1 transition, forward the suspend to the
+	 * primary so the GPU is actually preempted. Hold @suspend_lock so that
+	 * observing the secondary's transition and forwarding it to the primary
+	 * happen atomically; this keeps the primary's refcount paired with member
+	 * transitions even if the same secondary is suspended and resumed
+	 * concurrently across rebind cycles.
+	 */
+	scoped_guard(spinlock, &q->multi_queue.group->suspend_lock) {
+		if (__guc_exec_queue_suspend(q))
+			__guc_exec_queue_suspend(xe_exec_queue_multi_queue_primary(q));
+	}
+
 	return 0;
 }
 
@@ -2191,6 +2271,19 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
 	struct xe_device *xe = guc_to_xe(guc);
 	int ret;
 
+	/*
+	 * In multi-queue mode the primary owns the GuC scheduling context for
+	 * the whole group, so wait on the primary's suspend to complete. All
+	 * group members share the same GuC/device, so guc, xe and timeout above
+	 * are computed from @q directly.
+	 *
+	 * A secondary's suspend is short-circuited (no GuC round-trip) and, as
+	 * its SUSPEND message precedes the primary's on the shared FIFO
+	 * submit_wq, completes before the primary's. So waiting on the primary
+	 * is sufficient.
+	 */
+	q = xe_exec_queue_multi_queue_primary(q);
+
 	/*
 	 * Likely don't need to check exec_queue_killed() as we clear
 	 * suspend_pending upon kill but to be paranoid but races in which
@@ -2232,10 +2325,20 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
 		 * tripping the !suspend_pending assert (the RESUME message is
 		 * dropped for a banned queue), and triggering cleanup tears the
 		 * context down.
+		 *
+		 * @q is the primary here; it owns the group's GuC context, so a
+		 * failure to suspend it wedges the whole group. Ban and tear
+		 * down the entire group in the multi-queue case.
 		 */
-		set_exec_queue_banned(q);
-		__suspend_fence_signal(q);
-		xe_guc_exec_queue_trigger_cleanup(q);
+		if (xe_exec_queue_is_multi_queue(q)) {
+			set_exec_queue_group_banned(q);
+			__suspend_fence_signal(q);
+			xe_guc_exec_queue_group_trigger_cleanup(q);
+		} else {
+			set_exec_queue_banned(q);
+			__suspend_fence_signal(q);
+			xe_guc_exec_queue_trigger_cleanup(q);
+		}
 		return -ETIME;
 	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
 		/* Corner case on RESFIX DONE where vf_recovery() changes */
@@ -2255,21 +2358,52 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
 
 static void guc_exec_queue_resume(struct xe_exec_queue *q)
 {
-	struct xe_guc_exec_queue *ge = q->guc;
-	struct xe_gpu_scheduler *sched = &ge->sched;
-	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_RESUME;
-	struct xe_guc *guc = exec_queue_to_guc(q);
+	/*
+	 * Non-multi-queue queues and multi-queue primaries resume themselves
+	 * directly; their own msg_lock is sufficient.
+	 */
+	if (!xe_exec_queue_is_multi_queue_secondary(q)) {
+		__guc_exec_queue_resume(q);
+		return;
+	}
 
-	xe_sched_msg_lock(sched);
-	xe_gt_assert(guc_to_gt(guc), !ge->suspend_pending);
-	xe_gt_assert(guc_to_gt(guc), ge->suspend_count > 0);
-	if (--ge->suspend_count == 0) {
-		bool added = guc_exec_queue_try_add_msg(q, msg, RESUME);
+	/*
+	 * Mirror of guc_exec_queue_suspend(): resume the secondary like any
+	 * other queue and, only on its own 1->0 transition, forward the resume
+	 * to the primary so the primary's GuC context is re-enabled once the
+	 * last member that suspended it resumes. @suspend_lock keeps the
+	 * secondary transition and the primary forward atomic.
+	 */
+	scoped_guard(spinlock, &q->multi_queue.group->suspend_lock) {
+		if (__guc_exec_queue_resume(q))
+			__guc_exec_queue_resume(xe_exec_queue_multi_queue_primary(q));
+	}
+}
 
-		/* slot must be free at 1->0 */
-		xe_gt_assert(guc_to_gt(guc), added);
+/*
+ * Drop a leaving secondary's forwarded suspend reference on the primary and
+ * resume the primary if this was the last member that had it suspended.
+ * See guc_exec_queue_fini().
+ */
+static void guc_exec_queue_multi_queue_drop_suspend(struct xe_exec_queue *q)
+{
+	scoped_guard(spinlock, &q->multi_queue.group->suspend_lock) {
+		struct xe_exec_queue *primary = xe_exec_queue_multi_queue_primary(q);
+
+		/*
+		 * A suspended secondary holds exactly one suspend reference on the
+		 * primary (forwarded on its 0->1 transition). If it leaves while
+		 * still suspended, release that reference so the primary is not
+		 * kept disabled forever.
+		 */
+		if (!READ_ONCE(q->guc->suspend_count))
+			break;
+
+		if (exec_queue_killed_or_banned_or_wedged(primary))
+			break;
+
+		__guc_exec_queue_resume(primary);
 	}
-	xe_sched_msg_unlock(sched);
 }
 
 static bool guc_exec_queue_reset_status(struct xe_exec_queue *q)
-- 
2.43.0

Re: [PATCH v2 5/5] drm/xe/multi_queue: preempt primary on queue group suspend

[Matthew Brost]

On Tue, Jun 30, 2026 at 10:07:33PM -0700, Niranjana Vishwanathapura wrote:
> In a multi-queue group only the group's primary queue interfaces with
> GuC for scheduling; suspend/resume of secondary queues is handled
> internally and is not forwarded to GuC. As a result, suspending a
> secondary queue alone (e.g. on its preempt fence signalling) does not
> disable the primary's GuC context, so in-flight GPU work of the group
> is not actually preempted.
> 
> Make a secondary queue suspend/resume like any other queue, driven by
> its own xe_guc_exec_queue.suspend_count, and additionally forward the
> suspend/resume to the primary so the GPU is actually preempted. The
> forward is gated on the secondary's own 0->1 / 1->0 suspend_count
> transition, so each group member contributes exactly one suspend
> reference to the primary: the primary keeps its GuC context disabled
> until every member that suspended it has resumed, including across the
> resume-all-queues-each-rebind-cycle behavior. group->suspend_lock makes
> the secondary transition and the primary forward atomic, and a member
> leaving while still suspended (queue teardown) drops its reference on
> the primary.
> 
> guc_exec_queue_suspend_wait() now waits on the primary, so on a suspend
> timeout ban and tear down the whole group (set_exec_queue_group_banned()
> and xe_guc_exec_queue_group_trigger_cleanup()) rather than just the
> primary: the primary owns the group's GuC context, so its failure to
> suspend wedges every member.
> 
> v2: suspend whole group upon error in suspend_wait
> 

Same as last patch, if the upper layers are fixed this one LGTM:

Reviewed-by: Matthew Brost <matthew.brost@intel.com>

> Assisted-by: Github-Copilot:Claude-opus-4.8
> Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_exec_queue.c       |   1 +
>  drivers/gpu/drm/xe/xe_exec_queue_types.h |   6 +
>  drivers/gpu/drm/xe/xe_guc_submit.c       | 174 ++++++++++++++++++++---
>  3 files changed, 161 insertions(+), 20 deletions(-)
> 
> diff --git a/drivers/gpu/drm/xe/xe_exec_queue.c b/drivers/gpu/drm/xe/xe_exec_queue.c
> index 1b5ca3ce578a..df95855a3d61 100644
> --- a/drivers/gpu/drm/xe/xe_exec_queue.c
> +++ b/drivers/gpu/drm/xe/xe_exec_queue.c
> @@ -842,6 +842,7 @@ static int xe_exec_queue_group_init(struct xe_device *xe, struct xe_exec_queue *
>  	group->primary = q;
>  	group->cgp_bo = bo;
>  	INIT_LIST_HEAD(&group->list);
> +	spin_lock_init(&group->suspend_lock);
>  	xa_init_flags(&group->xa, XA_FLAGS_ALLOC1);
>  	mutex_init(&group->list_lock);
>  	q->multi_queue.group = group;
> diff --git a/drivers/gpu/drm/xe/xe_exec_queue_types.h b/drivers/gpu/drm/xe/xe_exec_queue_types.h
> index dbb2ee8eb5de..bf76a879aedc 100644
> --- a/drivers/gpu/drm/xe/xe_exec_queue_types.h
> +++ b/drivers/gpu/drm/xe/xe_exec_queue_types.h
> @@ -62,6 +62,12 @@ struct xe_exec_queue_group {
>  	struct list_head list;
>  	/** @list_lock: Secondary queue list lock */
>  	struct mutex list_lock;
> +	/**
> +	 * @suspend_lock: Makes a secondary's suspend/resume and its forwarding
> +	 * to the primary atomic. Nested outside of the queue's message lock
> +	 * (@xe_guc_exec_queue.sched.msg_lock).
> +	 */
> +	spinlock_t suspend_lock;
>  	/** @sync_pending: CGP_SYNC_DONE g2h response pending */
>  	bool sync_pending;
>  	/** @banned: Group banned */
> diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
> index f7a3ff0d0b1d..b1591d02eed0 100644
> --- a/drivers/gpu/drm/xe/xe_guc_submit.c
> +++ b/drivers/gpu/drm/xe/xe_guc_submit.c
> @@ -1681,11 +1681,24 @@ guc_exec_queue_timedout_job(struct drm_sched_job *drm_job)
>  	return DRM_GPU_SCHED_STAT_NO_HANG;
>  }
>  
> +static void guc_exec_queue_multi_queue_drop_suspend(struct xe_exec_queue *q);
> +
>  static void guc_exec_queue_fini(struct xe_exec_queue *q)
>  {
>  	struct xe_guc_exec_queue *ge = q->guc;
>  	struct xe_guc *guc = exec_queue_to_guc(q);
>  
> +	/*
> +	 * A secondary can leave the group while still preempt suspended (e.g.
> +	 * xe_vm_remove_compute_exec_queue() forces its preempt fence to signal,
> +	 * which suspends it). It holds one forwarded suspend reference on the
> +	 * primary, so drop it and resume the primary if it was the last member
> +	 * that had it suspended. Primaries forward to nobody, so they don't need
> +	 * this.
> +	 */
> +	if (xe_exec_queue_is_multi_queue_secondary(q))
> +		guc_exec_queue_multi_queue_drop_suspend(q);
> +
>  	if (xe_exec_queue_is_multi_queue_secondary(q)) {
>  		struct xe_exec_queue_group *group = q->multi_queue.group;
>  
> @@ -2163,17 +2176,22 @@ static int guc_exec_queue_set_multi_queue_priority(struct xe_exec_queue *q,
>  	return 0;
>  }
>  
> -static int guc_exec_queue_suspend(struct xe_exec_queue *q)
> +/*
> + * Core suspend: take a suspend reference on @q and, on the first reference,
> + * disable its GuC context so the GPU is actually preempted. Caller must have
> + * ensured @q is not killed/banned/wedged. Returns true if this was the first
> + * suspend reference (the 0->1 transition).
> + */
> +static bool __guc_exec_queue_suspend(struct xe_exec_queue *q)
>  {
>  	struct xe_guc_exec_queue *ge = q->guc;
>  	struct xe_gpu_scheduler *sched = &ge->sched;
>  	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_SUSPEND;
> -
> -	if (exec_queue_killed_or_banned_or_wedged(q))
> -		return -EINVAL;
> +	bool first;
>  
>  	xe_sched_msg_lock(sched);
> -	if (++ge->suspend_count == 1) {
> +	first = (++ge->suspend_count == 1);
> +	if (first) {
>  		bool added = guc_exec_queue_try_add_msg(q, msg, SUSPEND);
>  
>  		/* slot must be free at 0->1 */
> @@ -2182,6 +2200,68 @@ static int guc_exec_queue_suspend(struct xe_exec_queue *q)
>  	}
>  	xe_sched_msg_unlock(sched);
>  
> +	return first;
> +}
> +
> +/*
> + * Core resume: drop a suspend reference on @q and, on the last reference,
> + * re-enable its GuC context. Returns true if this dropped the last suspend
> + * reference (the 1->0 transition).
> + */
> +static bool __guc_exec_queue_resume(struct xe_exec_queue *q)
> +{
> +	struct xe_guc_exec_queue *ge = q->guc;
> +	struct xe_gpu_scheduler *sched = &ge->sched;
> +	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_RESUME;
> +	struct xe_guc *guc = exec_queue_to_guc(q);
> +	bool last;
> +
> +	xe_sched_msg_lock(sched);
> +	xe_gt_assert(guc_to_gt(guc), !ge->suspend_pending);
> +	xe_gt_assert(guc_to_gt(guc), ge->suspend_count > 0);
> +	last = (--ge->suspend_count == 0);
> +	if (last) {
> +		bool added = guc_exec_queue_try_add_msg(q, msg, RESUME);
> +
> +		/* slot must be free at 1->0 */
> +		xe_gt_assert(guc_to_gt(guc), added);
> +	}
> +	xe_sched_msg_unlock(sched);
> +
> +	return last;
> +}
> +
> +static int guc_exec_queue_suspend(struct xe_exec_queue *q)
> +{
> +	if (exec_queue_killed_or_banned_or_wedged(q))
> +		return -EINVAL;
> +
> +	/*
> +	 * Non-multi-queue queues and multi-queue primaries suspend themselves
> +	 * directly: their own msg_lock makes the suspend_count 0->1 transition
> +	 * and the suspend_pending update atomic, so no group level serialization
> +	 * is needed.
> +	 */
> +	if (!xe_exec_queue_is_multi_queue_secondary(q)) {
> +		__guc_exec_queue_suspend(q);
> +		return 0;
> +	}
> +
> +	/*
> +	 * A secondary doesn't interface with GuC: suspend it like any other
> +	 * queue (its own suspend_count drives its internally handled scheduler
> +	 * state) and, only on its own 0->1 transition, forward the suspend to the
> +	 * primary so the GPU is actually preempted. Hold @suspend_lock so that
> +	 * observing the secondary's transition and forwarding it to the primary
> +	 * happen atomically; this keeps the primary's refcount paired with member
> +	 * transitions even if the same secondary is suspended and resumed
> +	 * concurrently across rebind cycles.
> +	 */
> +	scoped_guard(spinlock, &q->multi_queue.group->suspend_lock) {
> +		if (__guc_exec_queue_suspend(q))
> +			__guc_exec_queue_suspend(xe_exec_queue_multi_queue_primary(q));
> +	}
> +
>  	return 0;
>  }
>  
> @@ -2191,6 +2271,19 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>  	struct xe_device *xe = guc_to_xe(guc);
>  	int ret;
>  
> +	/*
> +	 * In multi-queue mode the primary owns the GuC scheduling context for
> +	 * the whole group, so wait on the primary's suspend to complete. All
> +	 * group members share the same GuC/device, so guc, xe and timeout above
> +	 * are computed from @q directly.
> +	 *
> +	 * A secondary's suspend is short-circuited (no GuC round-trip) and, as
> +	 * its SUSPEND message precedes the primary's on the shared FIFO
> +	 * submit_wq, completes before the primary's. So waiting on the primary
> +	 * is sufficient.
> +	 */
> +	q = xe_exec_queue_multi_queue_primary(q);
> +
>  	/*
>  	 * Likely don't need to check exec_queue_killed() as we clear
>  	 * suspend_pending upon kill but to be paranoid but races in which
> @@ -2232,10 +2325,20 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>  		 * tripping the !suspend_pending assert (the RESUME message is
>  		 * dropped for a banned queue), and triggering cleanup tears the
>  		 * context down.
> +		 *
> +		 * @q is the primary here; it owns the group's GuC context, so a
> +		 * failure to suspend it wedges the whole group. Ban and tear
> +		 * down the entire group in the multi-queue case.
>  		 */
> -		set_exec_queue_banned(q);
> -		__suspend_fence_signal(q);
> -		xe_guc_exec_queue_trigger_cleanup(q);
> +		if (xe_exec_queue_is_multi_queue(q)) {
> +			set_exec_queue_group_banned(q);
> +			__suspend_fence_signal(q);
> +			xe_guc_exec_queue_group_trigger_cleanup(q);
> +		} else {
> +			set_exec_queue_banned(q);
> +			__suspend_fence_signal(q);
> +			xe_guc_exec_queue_trigger_cleanup(q);
> +		}
>  		return -ETIME;
>  	} else if (IS_SRIOV_VF(xe) && !WAIT_COND) {
>  		/* Corner case on RESFIX DONE where vf_recovery() changes */
> @@ -2255,21 +2358,52 @@ static int guc_exec_queue_suspend_wait(struct xe_exec_queue *q)
>  
>  static void guc_exec_queue_resume(struct xe_exec_queue *q)
>  {
> -	struct xe_guc_exec_queue *ge = q->guc;
> -	struct xe_gpu_scheduler *sched = &ge->sched;
> -	struct xe_sched_msg *msg = ge->static_msgs + STATIC_MSG_RESUME;
> -	struct xe_guc *guc = exec_queue_to_guc(q);
> +	/*
> +	 * Non-multi-queue queues and multi-queue primaries resume themselves
> +	 * directly; their own msg_lock is sufficient.
> +	 */
> +	if (!xe_exec_queue_is_multi_queue_secondary(q)) {
> +		__guc_exec_queue_resume(q);
> +		return;
> +	}
>  
> -	xe_sched_msg_lock(sched);
> -	xe_gt_assert(guc_to_gt(guc), !ge->suspend_pending);
> -	xe_gt_assert(guc_to_gt(guc), ge->suspend_count > 0);
> -	if (--ge->suspend_count == 0) {
> -		bool added = guc_exec_queue_try_add_msg(q, msg, RESUME);
> +	/*
> +	 * Mirror of guc_exec_queue_suspend(): resume the secondary like any
> +	 * other queue and, only on its own 1->0 transition, forward the resume
> +	 * to the primary so the primary's GuC context is re-enabled once the
> +	 * last member that suspended it resumes. @suspend_lock keeps the
> +	 * secondary transition and the primary forward atomic.
> +	 */
> +	scoped_guard(spinlock, &q->multi_queue.group->suspend_lock) {
> +		if (__guc_exec_queue_resume(q))
> +			__guc_exec_queue_resume(xe_exec_queue_multi_queue_primary(q));
> +	}
> +}
>  
> -		/* slot must be free at 1->0 */
> -		xe_gt_assert(guc_to_gt(guc), added);
> +/*
> + * Drop a leaving secondary's forwarded suspend reference on the primary and
> + * resume the primary if this was the last member that had it suspended.
> + * See guc_exec_queue_fini().
> + */
> +static void guc_exec_queue_multi_queue_drop_suspend(struct xe_exec_queue *q)
> +{
> +	scoped_guard(spinlock, &q->multi_queue.group->suspend_lock) {
> +		struct xe_exec_queue *primary = xe_exec_queue_multi_queue_primary(q);
> +
> +		/*
> +		 * A suspended secondary holds exactly one suspend reference on the
> +		 * primary (forwarded on its 0->1 transition). If it leaves while
> +		 * still suspended, release that reference so the primary is not
> +		 * kept disabled forever.
> +		 */
> +		if (!READ_ONCE(q->guc->suspend_count))
> +			break;
> +
> +		if (exec_queue_killed_or_banned_or_wedged(primary))
> +			break;
> +
> +		__guc_exec_queue_resume(primary);
>  	}
> -	xe_sched_msg_unlock(sched);
>  }
>  
>  static bool guc_exec_queue_reset_status(struct xe_exec_queue *q)
> -- 
> 2.43.0
> 

✗ CI.checkpatch: warning for drm/xe: balance exec queue suspend/resume (rev4)

[Patchwork]

== Series Details ==

Series: drm/xe: balance exec queue suspend/resume (rev4)
URL   : https://patchwork.freedesktop.org/series/169125/
State : warning

== Summary ==

+ KERNEL=/kernel
+ git clone https://gitlab.freedesktop.org/drm/maintainer-tools mt
Cloning into 'mt'...
warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/
+ git -C mt rev-list -n1 origin/master
061140b9bc586ae7f40abc1249c97e1cc72d1b9d
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ git log -n1
commit 16c93de176709851663fa7737d6ab67f9824eb85
Author: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
Date:   Tue Jun 30 22:07:33 2026 -0700

    drm/xe/multi_queue: preempt primary on queue group suspend
    
    In a multi-queue group only the group's primary queue interfaces with
    GuC for scheduling; suspend/resume of secondary queues is handled
    internally and is not forwarded to GuC. As a result, suspending a
    secondary queue alone (e.g. on its preempt fence signalling) does not
    disable the primary's GuC context, so in-flight GPU work of the group
    is not actually preempted.
    
    Make a secondary queue suspend/resume like any other queue, driven by
    its own xe_guc_exec_queue.suspend_count, and additionally forward the
    suspend/resume to the primary so the GPU is actually preempted. The
    forward is gated on the secondary's own 0->1 / 1->0 suspend_count
    transition, so each group member contributes exactly one suspend
    reference to the primary: the primary keeps its GuC context disabled
    until every member that suspended it has resumed, including across the
    resume-all-queues-each-rebind-cycle behavior. group->suspend_lock makes
    the secondary transition and the primary forward atomic, and a member
    leaving while still suspended (queue teardown) drops its reference on
    the primary.
    
    guc_exec_queue_suspend_wait() now waits on the primary, so on a suspend
    timeout ban and tear down the whole group (set_exec_queue_group_banned()
    and xe_guc_exec_queue_group_trigger_cleanup()) rather than just the
    primary: the primary owns the group's GuC context, so its failure to
    suspend wedges every member.
    
    v2: suspend whole group upon error in suspend_wait
    
    Assisted-by: Github-Copilot:Claude-opus-4.8
    Signed-off-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
+ /mt/dim checkpatch 7100870965845da8c31005c07fd1b390bbe96b20 drm-intel
92c711d4097a drm/xe: only resume exec queues that were actually suspended
09920d3bd6be drm/xe/hw_engine_group: propagate suspend failures during mode switch
e359adfd92f1 drm/xe/guc: wait killably for suspend and ban queue on timeout
01dec9fc3c77 drm/xe/guc: Add suspend refcount to exec queue ops
-:22: WARNING:BAD_SIGN_OFF: Non-standard signature: Co-authored-by:
#22: 
Co-authored-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>

-:22: WARNING:COMMIT_LOG_LONG_LINE: Prefer a maximum 75 chars per line (possible unwrapped commit description?)
#22: 
Co-authored-by: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>

total: 0 errors, 2 warnings, 0 checks, 63 lines checked
16c93de17670 drm/xe/multi_queue: preempt primary on queue group suspend

✓ CI.KUnit: success for drm/xe: balance exec queue suspend/resume (rev4)

[Patchwork]

== Series Details ==

Series: drm/xe: balance exec queue suspend/resume (rev4)
URL   : https://patchwork.freedesktop.org/series/169125/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
[05:14:23] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[05:14:27] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
../drivers/gpu/drm/xe/xe_pt.c:1418:13: warning: ‘xe_pt_svm_userptr_notifier_lock’ defined but not used [-Wunused-function]
 1418 | static void xe_pt_svm_userptr_notifier_lock(struct xe_vm *vm)
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[05:14:59] Starting KUnit Kernel (1/1)...
[05:14:59] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[05:14:59] ================== guc_buf (11 subtests) ===================
[05:14:59] [PASSED] test_smallest
[05:14:59] [PASSED] test_largest
[05:14:59] [PASSED] test_granular
[05:14:59] [PASSED] test_unique
[05:14:59] [PASSED] test_overlap
[05:14:59] [PASSED] test_reusable
[05:14:59] [PASSED] test_too_big
[05:14:59] [PASSED] test_flush
[05:14:59] [PASSED] test_lookup
[05:14:59] [PASSED] test_data
[05:14:59] [PASSED] test_class
[05:14:59] ===================== [PASSED] guc_buf =====================
[05:14:59] =================== guc_dbm (7 subtests) ===================
[05:14:59] [PASSED] test_empty
[05:14:59] [PASSED] test_default
[05:14:59] ======================== test_size  ========================
[05:14:59] [PASSED] 4
[05:14:59] [PASSED] 8
[05:14:59] [PASSED] 32
[05:14:59] [PASSED] 256
[05:14:59] ==================== [PASSED] test_size ====================
[05:14:59] ======================= test_reuse  ========================
[05:14:59] [PASSED] 4
[05:14:59] [PASSED] 8
[05:14:59] [PASSED] 32
[05:14:59] [PASSED] 256
[05:14:59] =================== [PASSED] test_reuse ====================
[05:14:59] =================== test_range_overlap  ====================
[05:14:59] [PASSED] 4
[05:14:59] [PASSED] 8
[05:14:59] [PASSED] 32
[05:14:59] [PASSED] 256
[05:14:59] =============== [PASSED] test_range_overlap ================
[05:14:59] =================== test_range_compact  ====================
[05:14:59] [PASSED] 4
[05:14:59] [PASSED] 8
[05:14:59] [PASSED] 32
[05:14:59] [PASSED] 256
[05:14:59] =============== [PASSED] test_range_compact ================
[05:14:59] ==================== test_range_spare  =====================
[05:14:59] [PASSED] 4
[05:14:59] [PASSED] 8
[05:14:59] [PASSED] 32
[05:14:59] [PASSED] 256
[05:14:59] ================ [PASSED] test_range_spare =================
[05:14:59] ===================== [PASSED] guc_dbm =====================
[05:14:59] =================== guc_idm (6 subtests) ===================
[05:14:59] [PASSED] bad_init
[05:14:59] [PASSED] no_init
[05:14:59] [PASSED] init_fini
[05:14:59] [PASSED] check_used
[05:14:59] [PASSED] check_quota
[05:14:59] [PASSED] check_all
[05:14:59] ===================== [PASSED] guc_idm =====================
[05:14:59] ================== no_relay (3 subtests) ===================
[05:14:59] [PASSED] xe_drops_guc2pf_if_not_ready
[05:14:59] [PASSED] xe_drops_guc2vf_if_not_ready
[05:14:59] [PASSED] xe_rejects_send_if_not_ready
[05:14:59] ==================== [PASSED] no_relay =====================
[05:14:59] ================== pf_relay (14 subtests) ==================
[05:14:59] [PASSED] pf_rejects_guc2pf_too_short
[05:14:59] [PASSED] pf_rejects_guc2pf_too_long
[05:14:59] [PASSED] pf_rejects_guc2pf_no_payload
[05:14:59] [PASSED] pf_fails_no_payload
[05:14:59] [PASSED] pf_fails_bad_origin
[05:14:59] [PASSED] pf_fails_bad_type
[05:14:59] [PASSED] pf_txn_reports_error
[05:14:59] [PASSED] pf_txn_sends_pf2guc
[05:14:59] [PASSED] pf_sends_pf2guc
[05:14:59] [SKIPPED] pf_loopback_nop (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[05:14:59] [SKIPPED] pf_loopback_echo (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[05:14:59] [SKIPPED] pf_loopback_fail (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[05:14:59] [SKIPPED] pf_loopback_busy (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[05:14:59] [SKIPPED] pf_loopback_retry (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[05:14:59] ==================== [PASSED] pf_relay =====================
[05:14:59] ================== vf_relay (3 subtests) ===================
[05:14:59] [PASSED] vf_rejects_guc2vf_too_short
[05:14:59] [PASSED] vf_rejects_guc2vf_too_long
[05:14:59] [PASSED] vf_rejects_guc2vf_no_payload
[05:14:59] ==================== [PASSED] vf_relay =====================
[05:14:59] ================ pf_gt_config (9 subtests) =================
[05:14:59] [PASSED] fair_contexts_1vf
[05:14:59] [PASSED] fair_doorbells_1vf
[05:14:59] [PASSED] fair_ggtt_1vf
[05:14:59] ====================== fair_vram_1vf  ======================
[05:14:59] [PASSED] 3.50 GiB
[05:14:59] [PASSED] 11.5 GiB
[05:14:59] [PASSED] 15.5 GiB
[05:14:59] [PASSED] 31.5 GiB
[05:14:59] [PASSED] 63.5 GiB
[05:14:59] [PASSED] 1.91 GiB
[05:14:59] ================== [PASSED] fair_vram_1vf ==================
[05:14:59] ================ fair_vram_1vf_admin_only  =================
[05:14:59] [PASSED] 3.50 GiB
[05:14:59] [PASSED] 11.5 GiB
[05:14:59] [PASSED] 15.5 GiB
[05:14:59] [PASSED] 31.5 GiB
[05:14:59] [PASSED] 63.5 GiB
[05:14:59] [PASSED] 1.91 GiB
[05:14:59] ============ [PASSED] fair_vram_1vf_admin_only =============
[05:14:59] ====================== fair_contexts  ======================
[05:14:59] [PASSED] 1 VF
[05:14:59] [PASSED] 2 VFs
[05:14:59] [PASSED] 3 VFs
[05:14:59] [PASSED] 4 VFs
[05:14:59] [PASSED] 5 VFs
[05:14:59] [PASSED] 6 VFs
[05:14:59] [PASSED] 7 VFs
[05:14:59] [PASSED] 8 VFs
[05:14:59] [PASSED] 9 VFs
[05:14:59] [PASSED] 10 VFs
[05:14:59] [PASSED] 11 VFs
[05:14:59] [PASSED] 12 VFs
[05:14:59] [PASSED] 13 VFs
[05:14:59] [PASSED] 14 VFs
[05:14:59] [PASSED] 15 VFs
[05:14:59] [PASSED] 16 VFs
[05:14:59] [PASSED] 17 VFs
[05:14:59] [PASSED] 18 VFs
[05:14:59] [PASSED] 19 VFs
[05:14:59] [PASSED] 20 VFs
[05:14:59] [PASSED] 21 VFs
[05:14:59] [PASSED] 22 VFs
[05:14:59] [PASSED] 23 VFs
[05:14:59] [PASSED] 24 VFs
[05:14:59] [PASSED] 25 VFs
[05:14:59] [PASSED] 26 VFs
[05:14:59] [PASSED] 27 VFs
[05:14:59] [PASSED] 28 VFs
[05:14:59] [PASSED] 29 VFs
[05:14:59] [PASSED] 30 VFs
[05:14:59] [PASSED] 31 VFs
[05:14:59] [PASSED] 32 VFs
[05:14:59] [PASSED] 33 VFs
[05:14:59] [PASSED] 34 VFs
[05:14:59] [PASSED] 35 VFs
[05:14:59] [PASSED] 36 VFs
[05:14:59] [PASSED] 37 VFs
[05:14:59] [PASSED] 38 VFs
[05:14:59] [PASSED] 39 VFs
[05:14:59] [PASSED] 40 VFs
[05:14:59] [PASSED] 41 VFs
[05:14:59] [PASSED] 42 VFs
[05:14:59] [PASSED] 43 VFs
[05:14:59] [PASSED] 44 VFs
[05:14:59] [PASSED] 45 VFs
[05:14:59] [PASSED] 46 VFs
[05:14:59] [PASSED] 47 VFs
[05:14:59] [PASSED] 48 VFs
[05:14:59] [PASSED] 49 VFs
[05:14:59] [PASSED] 50 VFs
[05:14:59] [PASSED] 51 VFs
[05:14:59] [PASSED] 52 VFs
[05:14:59] [PASSED] 53 VFs
[05:14:59] [PASSED] 54 VFs
[05:14:59] [PASSED] 55 VFs
[05:14:59] [PASSED] 56 VFs
[05:14:59] [PASSED] 57 VFs
[05:14:59] [PASSED] 58 VFs
[05:14:59] [PASSED] 59 VFs
[05:14:59] [PASSED] 60 VFs
[05:14:59] [PASSED] 61 VFs
[05:14:59] [PASSED] 62 VFs
[05:14:59] [PASSED] 63 VFs
[05:14:59] ================== [PASSED] fair_contexts ==================
[05:14:59] ===================== fair_doorbells  ======================
[05:14:59] [PASSED] 1 VF
[05:14:59] [PASSED] 2 VFs
[05:14:59] [PASSED] 3 VFs
[05:14:59] [PASSED] 4 VFs
[05:14:59] [PASSED] 5 VFs
[05:14:59] [PASSED] 6 VFs
[05:14:59] [PASSED] 7 VFs
[05:14:59] [PASSED] 8 VFs
[05:14:59] [PASSED] 9 VFs
[05:14:59] [PASSED] 10 VFs
[05:14:59] [PASSED] 11 VFs
[05:14:59] [PASSED] 12 VFs
[05:14:59] [PASSED] 13 VFs
[05:14:59] [PASSED] 14 VFs
[05:14:59] [PASSED] 15 VFs
[05:14:59] [PASSED] 16 VFs
[05:14:59] [PASSED] 17 VFs
[05:14:59] [PASSED] 18 VFs
[05:14:59] [PASSED] 19 VFs
[05:14:59] [PASSED] 20 VFs
[05:14:59] [PASSED] 21 VFs
[05:14:59] [PASSED] 22 VFs
[05:14:59] [PASSED] 23 VFs
[05:14:59] [PASSED] 24 VFs
[05:14:59] [PASSED] 25 VFs
[05:14:59] [PASSED] 26 VFs
[05:14:59] [PASSED] 27 VFs
[05:14:59] [PASSED] 28 VFs
[05:14:59] [PASSED] 29 VFs
[05:14:59] [PASSED] 30 VFs
[05:14:59] [PASSED] 31 VFs
[05:14:59] [PASSED] 32 VFs
[05:14:59] [PASSED] 33 VFs
[05:14:59] [PASSED] 34 VFs
[05:14:59] [PASSED] 35 VFs
[05:14:59] [PASSED] 36 VFs
[05:14:59] [PASSED] 37 VFs
[05:14:59] [PASSED] 38 VFs
[05:14:59] [PASSED] 39 VFs
[05:14:59] [PASSED] 40 VFs
[05:14:59] [PASSED] 41 VFs
[05:14:59] [PASSED] 42 VFs
[05:14:59] [PASSED] 43 VFs
[05:14:59] [PASSED] 44 VFs
[05:14:59] [PASSED] 45 VFs
[05:14:59] [PASSED] 46 VFs
[05:14:59] [PASSED] 47 VFs
[05:14:59] [PASSED] 48 VFs
[05:14:59] [PASSED] 49 VFs
[05:14:59] [PASSED] 50 VFs
[05:14:59] [PASSED] 51 VFs
[05:14:59] [PASSED] 52 VFs
[05:14:59] [PASSED] 53 VFs
[05:14:59] [PASSED] 54 VFs
[05:14:59] [PASSED] 55 VFs
[05:14:59] [PASSED] 56 VFs
[05:14:59] [PASSED] 57 VFs
[05:14:59] [PASSED] 58 VFs
[05:14:59] [PASSED] 59 VFs
[05:14:59] [PASSED] 60 VFs
[05:14:59] [PASSED] 61 VFs
[05:14:59] [PASSED] 62 VFs
[05:14:59] [PASSED] 63 VFs
[05:14:59] ================= [PASSED] fair_doorbells ==================
[05:14:59] ======================== fair_ggtt  ========================
[05:14:59] [PASSED] 1 VF
[05:14:59] [PASSED] 2 VFs
[05:14:59] [PASSED] 3 VFs
[05:14:59] [PASSED] 4 VFs
[05:14:59] [PASSED] 5 VFs
[05:14:59] [PASSED] 6 VFs
[05:14:59] [PASSED] 7 VFs
[05:14:59] [PASSED] 8 VFs
[05:14:59] [PASSED] 9 VFs
[05:14:59] [PASSED] 10 VFs
[05:14:59] [PASSED] 11 VFs
[05:14:59] [PASSED] 12 VFs
[05:14:59] [PASSED] 13 VFs
[05:14:59] [PASSED] 14 VFs
[05:14:59] [PASSED] 15 VFs
[05:14:59] [PASSED] 16 VFs
[05:14:59] [PASSED] 17 VFs
[05:14:59] [PASSED] 18 VFs
[05:14:59] [PASSED] 19 VFs
[05:14:59] [PASSED] 20 VFs
[05:14:59] [PASSED] 21 VFs
[05:14:59] [PASSED] 22 VFs
[05:14:59] [PASSED] 23 VFs
[05:14:59] [PASSED] 24 VFs
[05:14:59] [PASSED] 25 VFs
[05:14:59] [PASSED] 26 VFs
[05:14:59] [PASSED] 27 VFs
[05:14:59] [PASSED] 28 VFs
[05:14:59] [PASSED] 29 VFs
[05:14:59] [PASSED] 30 VFs
[05:14:59] [PASSED] 31 VFs
[05:14:59] [PASSED] 32 VFs
[05:14:59] [PASSED] 33 VFs
[05:14:59] [PASSED] 34 VFs
[05:14:59] [PASSED] 35 VFs
[05:14:59] [PASSED] 36 VFs
[05:14:59] [PASSED] 37 VFs
[05:14:59] [PASSED] 38 VFs
[05:14:59] [PASSED] 39 VFs
[05:14:59] [PASSED] 40 VFs
[05:14:59] [PASSED] 41 VFs
[05:14:59] [PASSED] 42 VFs
[05:14:59] [PASSED] 43 VFs
[05:14:59] [PASSED] 44 VFs
[05:14:59] [PASSED] 45 VFs
[05:14:59] [PASSED] 46 VFs
[05:14:59] [PASSED] 47 VFs
[05:14:59] [PASSED] 48 VFs
[05:14:59] [PASSED] 49 VFs
[05:14:59] [PASSED] 50 VFs
[05:14:59] [PASSED] 51 VFs
[05:14:59] [PASSED] 52 VFs
[05:14:59] [PASSED] 53 VFs
[05:14:59] [PASSED] 54 VFs
[05:14:59] [PASSED] 55 VFs
[05:14:59] [PASSED] 56 VFs
[05:14:59] [PASSED] 57 VFs
[05:14:59] [PASSED] 58 VFs
[05:14:59] [PASSED] 59 VFs
[05:14:59] [PASSED] 60 VFs
[05:14:59] [PASSED] 61 VFs
[05:14:59] [PASSED] 62 VFs
[05:14:59] [PASSED] 63 VFs
[05:14:59] ==================== [PASSED] fair_ggtt ====================
[05:14:59] ======================== fair_vram  ========================
[05:14:59] [PASSED] 1 VF
[05:14:59] [PASSED] 2 VFs
[05:14:59] [PASSED] 3 VFs
[05:14:59] [PASSED] 4 VFs
[05:14:59] [PASSED] 5 VFs
[05:14:59] [PASSED] 6 VFs
[05:14:59] [PASSED] 7 VFs
[05:14:59] [PASSED] 8 VFs
[05:14:59] [PASSED] 9 VFs
[05:14:59] [PASSED] 10 VFs
[05:14:59] [PASSED] 11 VFs
[05:14:59] [PASSED] 12 VFs
[05:14:59] [PASSED] 13 VFs
[05:14:59] [PASSED] 14 VFs
[05:14:59] [PASSED] 15 VFs
[05:14:59] [PASSED] 16 VFs
[05:14:59] [PASSED] 17 VFs
[05:14:59] [PASSED] 18 VFs
[05:14:59] [PASSED] 19 VFs
[05:14:59] [PASSED] 20 VFs
[05:14:59] [PASSED] 21 VFs
[05:14:59] [PASSED] 22 VFs
[05:14:59] [PASSED] 23 VFs
[05:14:59] [PASSED] 24 VFs
[05:14:59] [PASSED] 25 VFs
[05:14:59] [PASSED] 26 VFs
[05:14:59] [PASSED] 27 VFs
[05:14:59] [PASSED] 28 VFs
[05:14:59] [PASSED] 29 VFs
[05:14:59] [PASSED] 30 VFs
[05:14:59] [PASSED] 31 VFs
[05:14:59] [PASSED] 32 VFs
[05:14:59] [PASSED] 33 VFs
[05:14:59] [PASSED] 34 VFs
[05:14:59] [PASSED] 35 VFs
[05:14:59] [PASSED] 36 VFs
[05:14:59] [PASSED] 37 VFs
[05:14:59] [PASSED] 38 VFs
[05:14:59] [PASSED] 39 VFs
[05:14:59] [PASSED] 40 VFs
[05:14:59] [PASSED] 41 VFs
[05:14:59] [PASSED] 42 VFs
[05:14:59] [PASSED] 43 VFs
[05:14:59] [PASSED] 44 VFs
[05:14:59] [PASSED] 45 VFs
[05:14:59] [PASSED] 46 VFs
[05:14:59] [PASSED] 47 VFs
[05:14:59] [PASSED] 48 VFs
[05:14:59] [PASSED] 49 VFs
[05:14:59] [PASSED] 50 VFs
[05:15:00] [PASSED] 51 VFs
[05:15:00] [PASSED] 52 VFs
[05:15:00] [PASSED] 53 VFs
[05:15:00] [PASSED] 54 VFs
[05:15:00] [PASSED] 55 VFs
[05:15:00] [PASSED] 56 VFs
[05:15:00] [PASSED] 57 VFs
[05:15:00] [PASSED] 58 VFs
[05:15:00] [PASSED] 59 VFs
[05:15:00] [PASSED] 60 VFs
[05:15:00] [PASSED] 61 VFs
[05:15:00] [PASSED] 62 VFs
[05:15:00] [PASSED] 63 VFs
[05:15:00] ==================== [PASSED] fair_vram ====================
[05:15:00] ================== [PASSED] pf_gt_config ===================
[05:15:00] ===================== lmtt (1 subtest) =====================
[05:15:00] ======================== test_ops  =========================
[05:15:00] [PASSED] 2-level
[05:15:00] [PASSED] multi-level
[05:15:00] ==================== [PASSED] test_ops =====================
[05:15:00] ====================== [PASSED] lmtt =======================
[05:15:00] ================= pf_service (11 subtests) =================
[05:15:00] [PASSED] pf_negotiate_any
[05:15:00] [PASSED] pf_negotiate_base_match
[05:15:00] [PASSED] pf_negotiate_base_newer
[05:15:00] [PASSED] pf_negotiate_base_next
[05:15:00] [SKIPPED] pf_negotiate_base_older (no older minor)
[05:15:00] [PASSED] pf_negotiate_base_prev
[05:15:00] [PASSED] pf_negotiate_latest_match
[05:15:00] [PASSED] pf_negotiate_latest_newer
[05:15:00] [PASSED] pf_negotiate_latest_next
[05:15:00] [SKIPPED] pf_negotiate_latest_older (no older minor)
[05:15:00] [SKIPPED] pf_negotiate_latest_prev (no prev major)
[05:15:00] =================== [PASSED] pf_service ====================
[05:15:00] ================= xe_guc_g2g (2 subtests) ==================
[05:15:00] ============== xe_live_guc_g2g_kunit_default  ==============
[05:15:00] ========= [SKIPPED] xe_live_guc_g2g_kunit_default ==========
[05:15:00] ============== xe_live_guc_g2g_kunit_allmem  ===============
[05:15:00] ========== [SKIPPED] xe_live_guc_g2g_kunit_allmem ==========
[05:15:00] =================== [SKIPPED] xe_guc_g2g ===================
[05:15:00] =================== xe_mocs (2 subtests) ===================
[05:15:00] ================ xe_live_mocs_kernel_kunit  ================
[05:15:00] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[05:15:00] ================ xe_live_mocs_reset_kunit  =================
[05:15:00] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[05:15:00] ==================== [SKIPPED] xe_mocs =====================
[05:15:00] ================= xe_migrate (2 subtests) ==================
[05:15:00] ================= xe_migrate_sanity_kunit  =================
[05:15:00] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[05:15:00] ================== xe_validate_ccs_kunit  ==================
[05:15:00] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[05:15:00] =================== [SKIPPED] xe_migrate ===================
[05:15:00] ================== xe_dma_buf (1 subtest) ==================
[05:15:00] ==================== xe_dma_buf_kunit  =====================
[05:15:00] ================ [SKIPPED] xe_dma_buf_kunit ================
[05:15:00] =================== [SKIPPED] xe_dma_buf ===================
[05:15:00] ================= xe_bo_shrink (1 subtest) =================
[05:15:00] =================== xe_bo_shrink_kunit  ====================
[05:15:00] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[05:15:00] ================== [SKIPPED] xe_bo_shrink ==================
[05:15:00] ==================== xe_bo (2 subtests) ====================
[05:15:00] ================== xe_ccs_migrate_kunit  ===================
[05:15:00] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
[05:15:00] ==================== xe_bo_evict_kunit  ====================
[05:15:00] =============== [SKIPPED] xe_bo_evict_kunit ================
[05:15:00] ===================== [SKIPPED] xe_bo ======================
[05:15:00] ==================== args (13 subtests) ====================
[05:15:00] [PASSED] count_args_test
[05:15:00] [PASSED] call_args_example
[05:15:00] [PASSED] call_args_test
[05:15:00] [PASSED] drop_first_arg_example
[05:15:00] [PASSED] drop_first_arg_test
[05:15:00] [PASSED] first_arg_example
[05:15:00] [PASSED] first_arg_test
[05:15:00] [PASSED] last_arg_example
[05:15:00] [PASSED] last_arg_test
[05:15:00] [PASSED] pick_arg_example
[05:15:00] [PASSED] if_args_example
[05:15:00] [PASSED] if_args_test
[05:15:00] [PASSED] sep_comma_example
[05:15:00] ====================== [PASSED] args =======================
[05:15:00] =================== xe_pci (3 subtests) ====================
[05:15:00] ==================== check_graphics_ip  ====================
[05:15:00] [PASSED] 12.00 Xe_LP
[05:15:00] [PASSED] 12.10 Xe_LP+
[05:15:00] [PASSED] 12.55 Xe_HPG
[05:15:00] [PASSED] 12.60 Xe_HPC
[05:15:00] [PASSED] 12.70 Xe_LPG
[05:15:00] [PASSED] 12.71 Xe_LPG
[05:15:00] [PASSED] 12.74 Xe_LPG+
[05:15:00] [PASSED] 20.01 Xe2_HPG
[05:15:00] [PASSED] 20.02 Xe2_HPG
[05:15:00] [PASSED] 20.04 Xe2_LPG
[05:15:00] [PASSED] 30.00 Xe3_LPG
[05:15:00] [PASSED] 30.01 Xe3_LPG
[05:15:00] [PASSED] 30.03 Xe3_LPG
[05:15:00] [PASSED] 30.04 Xe3_LPG
[05:15:00] [PASSED] 30.05 Xe3_LPG
[05:15:00] [PASSED] 35.10 Xe3p_LPG
[05:15:00] [PASSED] 35.11 Xe3p_XPC
[05:15:00] ================ [PASSED] check_graphics_ip ================
[05:15:00] ===================== check_media_ip  ======================
[05:15:00] [PASSED] 12.00 Xe_M
[05:15:00] [PASSED] 12.55 Xe_HPM
[05:15:00] [PASSED] 13.00 Xe_LPM+
[05:15:00] [PASSED] 13.01 Xe2_HPM
[05:15:00] [PASSED] 20.00 Xe2_LPM
[05:15:00] [PASSED] 30.00 Xe3_LPM
[05:15:00] [PASSED] 30.02 Xe3_LPM
[05:15:00] [PASSED] 35.00 Xe3p_LPM
[05:15:00] [PASSED] 35.03 Xe3p_HPM
[05:15:00] ================= [PASSED] check_media_ip ==================
[05:15:00] =================== check_platform_desc  ===================
[05:15:00] [PASSED] 0x9A60 (TIGERLAKE)
[05:15:00] [PASSED] 0x9A68 (TIGERLAKE)
[05:15:00] [PASSED] 0x9A70 (TIGERLAKE)
[05:15:00] [PASSED] 0x9A40 (TIGERLAKE)
[05:15:00] [PASSED] 0x9A49 (TIGERLAKE)
[05:15:00] [PASSED] 0x9A59 (TIGERLAKE)
[05:15:00] [PASSED] 0x9A78 (TIGERLAKE)
[05:15:00] [PASSED] 0x9AC0 (TIGERLAKE)
[05:15:00] [PASSED] 0x9AC9 (TIGERLAKE)
[05:15:00] [PASSED] 0x9AD9 (TIGERLAKE)
[05:15:00] [PASSED] 0x9AF8 (TIGERLAKE)
[05:15:00] [PASSED] 0x4C80 (ROCKETLAKE)
[05:15:00] [PASSED] 0x4C8A (ROCKETLAKE)
[05:15:00] [PASSED] 0x4C8B (ROCKETLAKE)
[05:15:00] [PASSED] 0x4C8C (ROCKETLAKE)
[05:15:00] [PASSED] 0x4C90 (ROCKETLAKE)
[05:15:00] [PASSED] 0x4C9A (ROCKETLAKE)
[05:15:00] [PASSED] 0x4680 (ALDERLAKE_S)
[05:15:00] [PASSED] 0x4682 (ALDERLAKE_S)
[05:15:00] [PASSED] 0x4688 (ALDERLAKE_S)
[05:15:00] [PASSED] 0x468A (ALDERLAKE_S)
[05:15:00] [PASSED] 0x468B (ALDERLAKE_S)
[05:15:00] [PASSED] 0x4690 (ALDERLAKE_S)
[05:15:00] [PASSED] 0x4692 (ALDERLAKE_S)
[05:15:00] [PASSED] 0x4693 (ALDERLAKE_S)
[05:15:00] [PASSED] 0x46A0 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46A1 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46A2 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46A3 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46A6 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46A8 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46AA (ALDERLAKE_P)
[05:15:00] [PASSED] 0x462A (ALDERLAKE_P)
[05:15:00] [PASSED] 0x4626 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x4628 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46B0 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46B1 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46B2 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46B3 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46C0 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46C1 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46C2 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46C3 (ALDERLAKE_P)
[05:15:00] [PASSED] 0x46D0 (ALDERLAKE_N)
[05:15:00] [PASSED] 0x46D1 (ALDERLAKE_N)
[05:15:00] [PASSED] 0x46D2 (ALDERLAKE_N)
[05:15:00] [PASSED] 0x46D3 (ALDERLAKE_N)
[05:15:00] [PASSED] 0x46D4 (ALDERLAKE_N)
[05:15:00] [PASSED] 0xA721 (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7A1 (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7A9 (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7AC (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7AD (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA720 (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7A0 (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7A8 (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7AA (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA7AB (ALDERLAKE_P)
[05:15:00] [PASSED] 0xA780 (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA781 (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA782 (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA783 (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA788 (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA789 (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA78A (ALDERLAKE_S)
[05:15:00] [PASSED] 0xA78B (ALDERLAKE_S)
[05:15:00] [PASSED] 0x4905 (DG1)
[05:15:00] [PASSED] 0x4906 (DG1)
[05:15:00] [PASSED] 0x4907 (DG1)
[05:15:00] [PASSED] 0x4908 (DG1)
[05:15:00] [PASSED] 0x4909 (DG1)
[05:15:00] [PASSED] 0x56C0 (DG2)
[05:15:00] [PASSED] 0x56C2 (DG2)
[05:15:00] [PASSED] 0x56C1 (DG2)
[05:15:00] [PASSED] 0x7D51 (METEORLAKE)
[05:15:00] [PASSED] 0x7DD1 (METEORLAKE)
[05:15:00] [PASSED] 0x7D41 (METEORLAKE)
[05:15:00] [PASSED] 0x7D67 (METEORLAKE)
[05:15:00] [PASSED] 0xB640 (METEORLAKE)
[05:15:00] [PASSED] 0x56A0 (DG2)
[05:15:00] [PASSED] 0x56A1 (DG2)
[05:15:00] [PASSED] 0x56A2 (DG2)
[05:15:00] [PASSED] 0x56BE (DG2)
[05:15:00] [PASSED] 0x56BF (DG2)
[05:15:00] [PASSED] 0x5690 (DG2)
[05:15:00] [PASSED] 0x5691 (DG2)
[05:15:00] [PASSED] 0x5692 (DG2)
[05:15:00] [PASSED] 0x56A5 (DG2)
[05:15:00] [PASSED] 0x56A6 (DG2)
[05:15:00] [PASSED] 0x56B0 (DG2)
[05:15:00] [PASSED] 0x56B1 (DG2)
[05:15:00] [PASSED] 0x56BA (DG2)
[05:15:00] [PASSED] 0x56BB (DG2)
[05:15:00] [PASSED] 0x56BC (DG2)
[05:15:00] [PASSED] 0x56BD (DG2)
[05:15:00] [PASSED] 0x5693 (DG2)
[05:15:00] [PASSED] 0x5694 (DG2)
[05:15:00] [PASSED] 0x5695 (DG2)
[05:15:00] [PASSED] 0x56A3 (DG2)
[05:15:00] [PASSED] 0x56A4 (DG2)
[05:15:00] [PASSED] 0x56B2 (DG2)
[05:15:00] [PASSED] 0x56B3 (DG2)
[05:15:00] [PASSED] 0x5696 (DG2)
[05:15:00] [PASSED] 0x5697 (DG2)
[05:15:00] [PASSED] 0xB69 (PVC)
[05:15:00] [PASSED] 0xB6E (PVC)
[05:15:00] [PASSED] 0xBD4 (PVC)
[05:15:00] [PASSED] 0xBD5 (PVC)
[05:15:00] [PASSED] 0xBD6 (PVC)
[05:15:00] [PASSED] 0xBD7 (PVC)
[05:15:00] [PASSED] 0xBD8 (PVC)
[05:15:00] [PASSED] 0xBD9 (PVC)
[05:15:00] [PASSED] 0xBDA (PVC)
[05:15:00] [PASSED] 0xBDB (PVC)
[05:15:00] [PASSED] 0xBE0 (PVC)
[05:15:00] [PASSED] 0xBE1 (PVC)
[05:15:00] [PASSED] 0xBE5 (PVC)
[05:15:00] [PASSED] 0x7D40 (METEORLAKE)
[05:15:00] [PASSED] 0x7D45 (METEORLAKE)
[05:15:00] [PASSED] 0x7D55 (METEORLAKE)
[05:15:00] [PASSED] 0x7D60 (METEORLAKE)
[05:15:00] [PASSED] 0x7DD5 (METEORLAKE)
[05:15:00] [PASSED] 0x6420 (LUNARLAKE)
[05:15:00] [PASSED] 0x64A0 (LUNARLAKE)
[05:15:00] [PASSED] 0x64B0 (LUNARLAKE)
[05:15:00] [PASSED] 0xE202 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE209 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE20B (BATTLEMAGE)
[05:15:00] [PASSED] 0xE20C (BATTLEMAGE)
[05:15:00] [PASSED] 0xE20D (BATTLEMAGE)
[05:15:00] [PASSED] 0xE210 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE211 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE212 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE216 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE220 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE221 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE222 (BATTLEMAGE)
[05:15:00] [PASSED] 0xE223 (BATTLEMAGE)
[05:15:00] [PASSED] 0xB080 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB081 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB082 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB083 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB084 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB085 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB086 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB087 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB08F (PANTHERLAKE)
[05:15:00] [PASSED] 0xB090 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB0A0 (PANTHERLAKE)
[05:15:00] [PASSED] 0xB0B0 (PANTHERLAKE)
[05:15:00] [PASSED] 0xFD80 (PANTHERLAKE)
[05:15:00] [PASSED] 0xFD81 (PANTHERLAKE)
[05:15:00] [PASSED] 0xD740 (NOVALAKE_S)
[05:15:00] [PASSED] 0xD741 (NOVALAKE_S)
[05:15:00] [PASSED] 0xD742 (NOVALAKE_S)
[05:15:00] [PASSED] 0xD743 (NOVALAKE_S)
[05:15:00] [PASSED] 0xD745 (NOVALAKE_S)
[05:15:00] [PASSED] 0xD74A (NOVALAKE_S)
[05:15:00] [PASSED] 0xD74B (NOVALAKE_S)
[05:15:00] [PASSED] 0x674C (CRESCENTISLAND)
[05:15:00] [PASSED] 0x674D (CRESCENTISLAND)
[05:15:00] [PASSED] 0x674E (CRESCENTISLAND)
[05:15:00] [PASSED] 0x674F (CRESCENTISLAND)
[05:15:00] [PASSED] 0x6750 (CRESCENTISLAND)
[05:15:00] [PASSED] 0xD750 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD751 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD752 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD753 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD754 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD755 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD756 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD757 (NOVALAKE_P)
[05:15:00] [PASSED] 0xD75F (NOVALAKE_P)
[05:15:00] =============== [PASSED] check_platform_desc ===============
[05:15:00] ===================== [PASSED] xe_pci ======================
[05:15:00] ============= xe_rtp_tables_test (5 subtests) ==============
[05:15:00] ================== xe_rtp_table_gt_test  ===================
[05:15:00] [PASSED] gt_was/14011060649
[05:15:00] [PASSED] gt_was/14011059788
[05:15:00] [PASSED] gt_was/14015795083
[05:15:00] [PASSED] gt_was/16021867713
[05:15:00] [PASSED] gt_was/14019449301
[05:15:00] [PASSED] gt_was/16028005424
[05:15:00] [PASSED] gt_was/14026578760
[05:15:00] [PASSED] gt_was/1409420604
[05:15:00] [PASSED] gt_was/1408615072
[05:15:00] [PASSED] gt_was/22010523718
[05:15:00] [PASSED] gt_was/14011006942
[05:15:00] [PASSED] gt_was/14014830051
[05:15:00] [PASSED] gt_was/18018781329
[05:15:00] [PASSED] gt_was/1509235366
[05:15:00] [PASSED] gt_was/18018781329
[05:15:00] [PASSED] gt_was/16016694945
[05:15:00] [PASSED] gt_was/14018575942
[05:15:00] [PASSED] gt_was/22016670082
[05:15:00] [PASSED] gt_was/22016670082
[05:15:00] [PASSED] gt_was/14017421178
[05:15:00] [PASSED] gt_was/16025250150
[05:15:00] [PASSED] gt_was/14021871409
[05:15:00] [PASSED] gt_was/16021865536
[05:15:00] [PASSED] gt_was/14021486841
[05:15:00] [PASSED] gt_was/14025160223
[05:15:00] [PASSED] gt_was/14026144927, 16029437861, 14026127056
[05:15:00] [PASSED] gt_was/14025635424
[05:15:00] [PASSED] gt_was/16028005424
[05:15:00] ============== [PASSED] xe_rtp_table_gt_test ===============
[05:15:00] ================== xe_rtp_table_gt_test  ===================
[05:15:00] [PASSED] gt_tunings/Tuning: Blend Fill Caching Optimization Disable
[05:15:00] [PASSED] gt_tunings/Tuning: 32B Access Enable
[05:15:00] [PASSED] gt_tunings/Tuning: L3 cache
[05:15:00] [PASSED] gt_tunings/Tuning: L3 cache - media
[05:15:00] [PASSED] gt_tunings/Tuning: Compression Overfetch
[05:15:00] [PASSED] gt_tunings/Tuning: Compression Overfetch - media
[05:15:00] [PASSED] gt_tunings/Tuning: Enable compressible partial write overfetch in L3
[05:15:00] [PASSED] gt_tunings/Tuning: Enable compressible partial write overfetch in L3 - media
[05:15:00] [PASSED] gt_tunings/Tuning: L2 Overfetch Compressible Only
[05:15:00] [PASSED] gt_tunings/Tuning: L2 Overfetch Compressible Only - media
[05:15:00] [PASSED] gt_tunings/Tuning: Stateless compression control
[05:15:00] [PASSED] gt_tunings/Tuning: Stateless compression control - media
[05:15:00] [PASSED] gt_tunings/Tuning: L3 RW flush all Cache
[05:15:00] [PASSED] gt_tunings/Tuning: L3 RW flush all cache - media
[05:15:00] [PASSED] gt_tunings/Tuning: Set STLB Bank Hash Mode to 4KB
[05:15:00] ============== [PASSED] xe_rtp_table_gt_test ===============
[05:15:00] ================== xe_rtp_table_oob_test  ==================
[05:15:00] [PASSED] oob_was/1607983814
[05:15:00] [PASSED] oob_was/16010904313
[05:15:00] [PASSED] oob_was/18022495364
[05:15:00] [PASSED] oob_was/22012773006
[05:15:00] [PASSED] oob_was/14014475959
[05:15:00] [PASSED] oob_was/22011391025
[05:15:00] [PASSED] oob_was/22012727170
[05:15:00] [PASSED] oob_was/22012727685
[05:15:00] [PASSED] oob_was/22016596838
[05:15:00] [PASSED] oob_was/18020744125
[05:15:00] [PASSED] oob_was/1409600907
[05:15:00] [PASSED] oob_was/22014953428
[05:15:00] [PASSED] oob_was/16017236439
[05:15:00] [PASSED] oob_was/14019821291
[05:15:00] [PASSED] oob_was/14015076503
[05:15:00] [PASSED] oob_was/14018913170
[05:15:00] [PASSED] oob_was/14018094691
[05:15:00] [PASSED] oob_was/18024947630
[05:15:00] [PASSED] oob_was/16022287689
[05:15:00] [PASSED] oob_was/13011645652
[05:15:00] [PASSED] oob_was/14022293748
[05:15:00] [PASSED] oob_was/22019794406
[05:15:00] [PASSED] oob_was/22019338487
[05:15:00] [PASSED] oob_was/16023588340
[05:15:00] [PASSED] oob_was/14019789679
[05:15:00] [PASSED] oob_was/14022866841
[05:15:00] [PASSED] oob_was/16021333562
[05:15:00] [PASSED] oob_was/14016712196
[05:15:00] [PASSED] oob_was/14015568240
[05:15:00] [PASSED] oob_was/18013179988
[05:15:00] [PASSED] oob_was/1508761755
[05:15:00] [PASSED] oob_was/16023105232
[05:15:00] [PASSED] oob_was/16026508708
[05:15:00] [PASSED] oob_was/14020001231
[05:15:00] [PASSED] oob_was/16023683509
[05:15:00] [PASSED] oob_was/14025515070
[05:15:00] [PASSED] oob_was/15015404425_disable
[05:15:00] [PASSED] oob_was/16026007364
[05:15:00] [PASSED] oob_was/14020316580
[05:15:00] [PASSED] oob_was/14025883347
[05:15:00] [PASSED] oob_was/16029380221
[05:15:00] ============== [PASSED] xe_rtp_table_oob_test ==============
[05:15:00] ================ xe_rtp_table_dev_oob_test  ================
[05:15:00] [PASSED] device_oob_was/22010954014
[05:15:00] [PASSED] device_oob_was/15015404425
[05:15:00] [PASSED] device_oob_was/22019338487_display
[05:15:00] [PASSED] device_oob_was/14022085890
[05:15:00] [PASSED] device_oob_was/14026539277
[05:15:00] [PASSED] device_oob_was/14026633728
[05:15:00] [PASSED] device_oob_was/14026746987
[05:15:00] [PASSED] device_oob_was/14026779378
[05:15:00] ============ [PASSED] xe_rtp_table_dev_oob_test ============
[05:15:00] ========== xe_rtp_table_missing_upper_bound_test  ==========
[05:15:00] [PASSED] register_whitelist/WaAllowPMDepthAndInvocationCountAccessFromUMD, 1408556865
[05:15:00] [PASSED] register_whitelist/1508744258, 14012131227, 1808121037
[05:15:00] [PASSED] register_whitelist/1806527549
[05:15:00] [PASSED] register_whitelist/allow_read_ctx_timestamp
[05:15:00] [PASSED] register_whitelist/allow_read_queue_timestamp
[05:15:00] [PASSED] register_whitelist/16014440446
[05:15:00] [PASSED] register_whitelist/16017236439
[05:15:00] [PASSED] register_whitelist/16020183090
[05:15:00] [PASSED] register_whitelist/14024997852
[05:15:00] [PASSED] register_whitelist/14024997852
[05:15:00] ====== [PASSED] xe_rtp_table_missing_upper_bound_test ======
[05:15:00] =============== [PASSED] xe_rtp_tables_test ================
[05:15:00] =================== xe_rtp (3 subtests) ====================
[05:15:00] =================== xe_rtp_rules_tests  ====================
[05:15:00] [PASSED] no
[05:15:00] [PASSED] yes
[05:15:00] [PASSED] no-and-no
[05:15:00] [PASSED] no-and-yes
[05:15:00] [PASSED] yes-and-no
[05:15:00] [PASSED] yes-and-yes
[05:15:00] [PASSED] no-or-no
[05:15:00] [PASSED] no-or-yes
[05:15:00] [PASSED] yes-or-no
[05:15:00] [PASSED] yes-or-yes
[05:15:00] [PASSED] no-yes-or-yes-no
[05:15:00] [PASSED] no-yes-or-yes-yes
[05:15:00] [PASSED] yes-yes-or-no-yes
[05:15:00] [PASSED] yes-yes-or-yes-yes
[05:15:00] [PASSED] no-no-or-yes-or-no
[05:15:00] [PASSED] or
[05:15:00] [PASSED] or-yes
[05:15:00] [PASSED] or-no
[05:15:00] [PASSED] yes-or
[05:15:00] [PASSED] no-or
[05:15:00] [PASSED] no-or-or-yes
[05:15:00] [PASSED] yes-or-or-no
[05:15:00] [PASSED] no-or-or-no
[05:15:00] [PASSED] missing-context-engine-class
[05:15:00] [PASSED] missing-context-engine-class-or-yes
[05:15:00] [PASSED] missing-context-engine-class-or-or-yes
[05:15:00] =============== [PASSED] xe_rtp_rules_tests ================
[05:15:00] =============== xe_rtp_process_to_sr_tests  ================
[05:15:00] [PASSED] coalesce-same-reg
[05:15:00] [PASSED] coalesce-same-reg-literal-and-func
[05:15:00] [PASSED] no-match-no-add
[05:15:00] [PASSED] two-regs-two-entries
[05:15:00] [PASSED] clr-one-set-other
[05:15:00] [PASSED] set-field
[05:15:00] [PASSED] conflict-duplicate
[05:15:00] [PASSED] conflict-not-disjoint
[05:15:00] [PASSED] conflict-not-disjoint-literal-and-func
[05:15:00] [PASSED] conflict-reg-type
[05:15:00] [PASSED] bad-mcr-reg-forced-to-regular
[05:15:00] [PASSED] bad-regular-reg-forced-to-mcr
[05:15:00] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[05:15:00] ================== xe_rtp_process_tests  ===================
[05:15:00] [PASSED] active1
[05:15:00] [PASSED] active2
[05:15:00] [PASSED] active-inactive
[05:15:00] [PASSED] inactive-active
[05:15:00] [PASSED] inactive-active-inactive
[05:15:00] [PASSED] inactive-inactive-inactive
[05:15:00] ============== [PASSED] xe_rtp_process_tests ===============
[05:15:00] ===================== [PASSED] xe_rtp ======================
[05:15:00] ==================== xe_wa (1 subtest) =====================
[05:15:00] ======================== xe_wa_gt  =========================
[05:15:00] [PASSED] TIGERLAKE B0
[05:15:00] [PASSED] DG1 A0
[05:15:00] [PASSED] DG1 B0
[05:15:00] [PASSED] ALDERLAKE_S A0
[05:15:00] [PASSED] ALDERLAKE_S B0
[05:15:00] [PASSED] ALDERLAKE_S C0
[05:15:00] [PASSED] ALDERLAKE_S D0
[05:15:00] [PASSED] ALDERLAKE_P A0
[05:15:00] [PASSED] ALDERLAKE_P B0
[05:15:00] [PASSED] ALDERLAKE_P C0
[05:15:00] [PASSED] ALDERLAKE_S RPLS D0
[05:15:00] [PASSED] ALDERLAKE_P RPLU E0
[05:15:00] [PASSED] DG2 G10 C0
[05:15:00] [PASSED] DG2 G11 B1
[05:15:00] [PASSED] DG2 G12 A1
[05:15:00] [PASSED] METEORLAKE 12.70(Xe_LPG) A0 13.00(Xe_LPM+) A0
[05:15:00] [PASSED] METEORLAKE 12.71(Xe_LPG) A0 13.00(Xe_LPM+) A0
[05:15:00] [PASSED] METEORLAKE 12.74(Xe_LPG+) A0 13.00(Xe_LPM+) A0
[05:15:00] [PASSED] LUNARLAKE 20.04(Xe2_LPG) A0 20.00(Xe2_LPM) A0
[05:15:00] [PASSED] LUNARLAKE 20.04(Xe2_LPG) B0 20.00(Xe2_LPM) A0
[05:15:00] [PASSED] BATTLEMAGE 20.01(Xe2_HPG) A0 13.01(Xe2_HPM) A1
[05:15:00] [PASSED] PANTHERLAKE 30.00(Xe3_LPG) A0 30.00(Xe3_LPM) A0
[05:15:00] ==================== [PASSED] xe_wa_gt =====================
[05:15:00] ====================== [PASSED] xe_wa ======================
[05:15:00] ============================================================
[05:15:00] Testing complete. Ran 729 tests: passed: 711, skipped: 18
[05:15:00] Elapsed time: 36.550s total, 4.369s configuring, 31.512s building, 0.649s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig
[05:15:00] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[05:15:02] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[05:15:26] Starting KUnit Kernel (1/1)...
[05:15:26] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[05:15:26] ============ drm_test_pick_cmdline (2 subtests) ============
[05:15:26] [PASSED] drm_test_pick_cmdline_res_1920_1080_60
[05:15:26] =============== drm_test_pick_cmdline_named  ===============
[05:15:26] [PASSED] NTSC
[05:15:26] [PASSED] NTSC-J
[05:15:26] [PASSED] PAL
[05:15:26] [PASSED] PAL-M
[05:15:26] =========== [PASSED] drm_test_pick_cmdline_named ===========
[05:15:26] ============== [PASSED] drm_test_pick_cmdline ==============
[05:15:26] == drm_test_atomic_get_connector_for_encoder (1 subtest) ===
[05:15:26] [PASSED] drm_test_drm_atomic_get_connector_for_encoder
[05:15:26] ==== [PASSED] drm_test_atomic_get_connector_for_encoder ====
[05:15:26] =========== drm_validate_clone_mode (2 subtests) ===========
[05:15:26] ============== drm_test_check_in_clone_mode  ===============
[05:15:26] [PASSED] in_clone_mode
[05:15:26] [PASSED] not_in_clone_mode
[05:15:26] ========== [PASSED] drm_test_check_in_clone_mode ===========
[05:15:26] =============== drm_test_check_valid_clones  ===============
[05:15:26] [PASSED] not_in_clone_mode
[05:15:26] [PASSED] valid_clone
[05:15:26] [PASSED] invalid_clone
[05:15:26] =========== [PASSED] drm_test_check_valid_clones ===========
[05:15:26] ============= [PASSED] drm_validate_clone_mode =============
[05:15:26] ============= drm_validate_modeset (1 subtest) =============
[05:15:26] [PASSED] drm_test_check_connector_changed_modeset
[05:15:26] ============== [PASSED] drm_validate_modeset ===============
[05:15:26] ====== drm_test_bridge_get_current_state (2 subtests) ======
[05:15:26] [PASSED] drm_test_drm_bridge_get_current_state_atomic
[05:15:26] [PASSED] drm_test_drm_bridge_get_current_state_legacy
[05:15:26] ======== [PASSED] drm_test_bridge_get_current_state ========
[05:15:26] ====== drm_test_bridge_helper_reset_crtc (4 subtests) ======
[05:15:26] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic
[05:15:26] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic_disabled
[05:15:26] [PASSED] drm_test_drm_bridge_helper_reset_crtc_legacy
[05:15:26] [PASSED] drm_test_drm_bridge_helper_hdmi_output_bus_fmts
[05:15:26] ======== [PASSED] drm_test_bridge_helper_reset_crtc ========
[05:15:26] ============== drm_bridge_alloc (2 subtests) ===============
[05:15:26] [PASSED] drm_test_drm_bridge_alloc_basic
[05:15:26] [PASSED] drm_test_drm_bridge_alloc_get_put
[05:15:26] ================ [PASSED] drm_bridge_alloc =================
[05:15:26] ============= drm_bridge_bus_fmt (5 subtests) ==============
[05:15:26] [PASSED] drm_test_bridge_rgb_yuv_rgb
[05:15:26] [PASSED] drm_test_bridge_must_convert_to_yuv444
[05:15:26] [PASSED] drm_test_bridge_hdmi_auto_rgb
[05:15:26] [PASSED] drm_test_bridge_auto_first
[05:15:26] [PASSED] drm_test_bridge_rgb_yuv_no_path
[05:15:26] =============== [PASSED] drm_bridge_bus_fmt ================
[05:15:26] ============= drm_cmdline_parser (40 subtests) =============
[05:15:26] [PASSED] drm_test_cmdline_force_d_only
[05:15:26] [PASSED] drm_test_cmdline_force_D_only_dvi
[05:15:26] [PASSED] drm_test_cmdline_force_D_only_hdmi
[05:15:26] [PASSED] drm_test_cmdline_force_D_only_not_digital
[05:15:26] [PASSED] drm_test_cmdline_force_e_only
[05:15:26] [PASSED] drm_test_cmdline_res
[05:15:26] [PASSED] drm_test_cmdline_res_vesa
[05:15:26] [PASSED] drm_test_cmdline_res_vesa_rblank
[05:15:26] [PASSED] drm_test_cmdline_res_rblank
[05:15:26] [PASSED] drm_test_cmdline_res_bpp
[05:15:26] [PASSED] drm_test_cmdline_res_refresh
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_margins
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_force_off
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_analog
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_digital
[05:15:26] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on
[05:15:26] [PASSED] drm_test_cmdline_res_margins_force_on
[05:15:26] [PASSED] drm_test_cmdline_res_vesa_margins
[05:15:26] [PASSED] drm_test_cmdline_name
[05:15:26] [PASSED] drm_test_cmdline_name_bpp
[05:15:26] [PASSED] drm_test_cmdline_name_option
[05:15:26] [PASSED] drm_test_cmdline_name_bpp_option
[05:15:26] [PASSED] drm_test_cmdline_rotate_0
[05:15:26] [PASSED] drm_test_cmdline_rotate_90
[05:15:26] [PASSED] drm_test_cmdline_rotate_180
[05:15:26] [PASSED] drm_test_cmdline_rotate_270
[05:15:26] [PASSED] drm_test_cmdline_hmirror
[05:15:26] [PASSED] drm_test_cmdline_vmirror
[05:15:26] [PASSED] drm_test_cmdline_margin_options
[05:15:26] [PASSED] drm_test_cmdline_multiple_options
[05:15:26] [PASSED] drm_test_cmdline_bpp_extra_and_option
[05:15:26] [PASSED] drm_test_cmdline_extra_and_option
[05:15:26] [PASSED] drm_test_cmdline_freestanding_options
[05:15:26] [PASSED] drm_test_cmdline_freestanding_force_e_and_options
[05:15:26] [PASSED] drm_test_cmdline_panel_orientation
[05:15:26] ================ drm_test_cmdline_invalid  =================
[05:15:26] [PASSED] margin_only
[05:15:26] [PASSED] interlace_only
[05:15:26] [PASSED] res_missing_x
[05:15:26] [PASSED] res_missing_y
[05:15:26] [PASSED] res_bad_y
[05:15:26] [PASSED] res_missing_y_bpp
[05:15:26] [PASSED] res_bad_bpp
[05:15:26] [PASSED] res_bad_refresh
[05:15:26] [PASSED] res_bpp_refresh_force_on_off
[05:15:26] [PASSED] res_invalid_mode
[05:15:26] [PASSED] res_bpp_wrong_place_mode
[05:15:26] [PASSED] name_bpp_refresh
[05:15:26] [PASSED] name_refresh
[05:15:26] [PASSED] name_refresh_wrong_mode
[05:15:26] [PASSED] name_refresh_invalid_mode
[05:15:26] [PASSED] rotate_multiple
[05:15:26] [PASSED] rotate_invalid_val
[05:15:26] [PASSED] rotate_truncated
[05:15:26] [PASSED] invalid_option
[05:15:26] [PASSED] invalid_tv_option
[05:15:26] [PASSED] truncated_tv_option
[05:15:26] ============ [PASSED] drm_test_cmdline_invalid =============
[05:15:26] =============== drm_test_cmdline_tv_options  ===============
[05:15:26] [PASSED] NTSC
[05:15:26] [PASSED] NTSC_443
[05:15:26] [PASSED] NTSC_J
[05:15:26] [PASSED] PAL
[05:15:26] [PASSED] PAL_M
[05:15:26] [PASSED] PAL_N
[05:15:26] [PASSED] SECAM
[05:15:26] [PASSED] MONO_525
[05:15:26] [PASSED] MONO_625
[05:15:26] =========== [PASSED] drm_test_cmdline_tv_options ===========
[05:15:26] =============== [PASSED] drm_cmdline_parser ================
[05:15:26] ========== drmm_connector_hdmi_init (20 subtests) ==========
[05:15:26] [PASSED] drm_test_connector_hdmi_init_valid
[05:15:26] [PASSED] drm_test_connector_hdmi_init_bpc_8
[05:15:26] [PASSED] drm_test_connector_hdmi_init_bpc_10
[05:15:26] [PASSED] drm_test_connector_hdmi_init_bpc_12
[05:15:26] [PASSED] drm_test_connector_hdmi_init_bpc_invalid
[05:15:26] [PASSED] drm_test_connector_hdmi_init_bpc_null
[05:15:26] [PASSED] drm_test_connector_hdmi_init_formats_empty
[05:15:26] [PASSED] drm_test_connector_hdmi_init_formats_no_rgb
[05:15:26] === drm_test_connector_hdmi_init_formats_yuv420_allowed  ===
[05:15:26] [PASSED] supported_formats=0x9 yuv420_allowed=1
[05:15:26] [PASSED] supported_formats=0x9 yuv420_allowed=0
[05:15:26] [PASSED] supported_formats=0x5 yuv420_allowed=1
[05:15:26] [PASSED] supported_formats=0x5 yuv420_allowed=0
[05:15:26] === [PASSED] drm_test_connector_hdmi_init_formats_yuv420_allowed ===
[05:15:26] [PASSED] drm_test_connector_hdmi_init_null_ddc
[05:15:26] [PASSED] drm_test_connector_hdmi_init_null_product
[05:15:26] [PASSED] drm_test_connector_hdmi_init_null_vendor
[05:15:26] [PASSED] drm_test_connector_hdmi_init_product_length_exact
[05:15:26] [PASSED] drm_test_connector_hdmi_init_product_length_too_long
[05:15:26] [PASSED] drm_test_connector_hdmi_init_product_valid
[05:15:26] [PASSED] drm_test_connector_hdmi_init_vendor_length_exact
[05:15:26] [PASSED] drm_test_connector_hdmi_init_vendor_length_too_long
[05:15:26] [PASSED] drm_test_connector_hdmi_init_vendor_valid
[05:15:26] ========= drm_test_connector_hdmi_init_type_valid  =========
[05:15:26] [PASSED] HDMI-A
[05:15:26] [PASSED] HDMI-B
[05:15:26] ===== [PASSED] drm_test_connector_hdmi_init_type_valid =====
[05:15:26] ======== drm_test_connector_hdmi_init_type_invalid  ========
[05:15:26] [PASSED] Unknown
[05:15:26] [PASSED] VGA
[05:15:26] [PASSED] DVI-I
[05:15:26] [PASSED] DVI-D
[05:15:26] [PASSED] DVI-A
[05:15:26] [PASSED] Composite
[05:15:26] [PASSED] SVIDEO
[05:15:26] [PASSED] LVDS
[05:15:26] [PASSED] Component
[05:15:26] [PASSED] DIN
[05:15:26] [PASSED] DP
[05:15:26] [PASSED] TV
[05:15:26] [PASSED] eDP
[05:15:26] [PASSED] Virtual
[05:15:26] [PASSED] DSI
[05:15:26] [PASSED] DPI
[05:15:26] [PASSED] Writeback
[05:15:26] [PASSED] SPI
[05:15:26] [PASSED] USB
[05:15:26] ==== [PASSED] drm_test_connector_hdmi_init_type_invalid ====
[05:15:26] ============ [PASSED] drmm_connector_hdmi_init =============
[05:15:26] ============= drmm_connector_init (3 subtests) =============
[05:15:26] [PASSED] drm_test_drmm_connector_init
[05:15:26] [PASSED] drm_test_drmm_connector_init_null_ddc
[05:15:26] ========= drm_test_drmm_connector_init_type_valid  =========
[05:15:26] [PASSED] Unknown
[05:15:26] [PASSED] VGA
[05:15:26] [PASSED] DVI-I
[05:15:26] [PASSED] DVI-D
[05:15:26] [PASSED] DVI-A
[05:15:26] [PASSED] Composite
[05:15:26] [PASSED] SVIDEO
[05:15:26] [PASSED] LVDS
[05:15:26] [PASSED] Component
[05:15:26] [PASSED] DIN
[05:15:26] [PASSED] DP
[05:15:26] [PASSED] HDMI-A
[05:15:26] [PASSED] HDMI-B
[05:15:26] [PASSED] TV
[05:15:26] [PASSED] eDP
[05:15:26] [PASSED] Virtual
[05:15:26] [PASSED] DSI
[05:15:26] [PASSED] DPI
[05:15:26] [PASSED] Writeback
[05:15:26] [PASSED] SPI
[05:15:26] [PASSED] USB
[05:15:26] ===== [PASSED] drm_test_drmm_connector_init_type_valid =====
[05:15:26] =============== [PASSED] drmm_connector_init ===============
[05:15:26] ========= drm_connector_dynamic_init (6 subtests) ==========
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_init
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_init_null_ddc
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_init_not_added
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_init_properties
[05:15:26] ===== drm_test_drm_connector_dynamic_init_type_valid  ======
[05:15:26] [PASSED] Unknown
[05:15:26] [PASSED] VGA
[05:15:26] [PASSED] DVI-I
[05:15:26] [PASSED] DVI-D
[05:15:26] [PASSED] DVI-A
[05:15:26] [PASSED] Composite
[05:15:26] [PASSED] SVIDEO
[05:15:26] [PASSED] LVDS
[05:15:26] [PASSED] Component
[05:15:26] [PASSED] DIN
[05:15:26] [PASSED] DP
[05:15:26] [PASSED] HDMI-A
[05:15:26] [PASSED] HDMI-B
[05:15:26] [PASSED] TV
[05:15:26] [PASSED] eDP
[05:15:26] [PASSED] Virtual
[05:15:26] [PASSED] DSI
[05:15:26] [PASSED] DPI
[05:15:26] [PASSED] Writeback
[05:15:26] [PASSED] SPI
[05:15:26] [PASSED] USB
[05:15:26] = [PASSED] drm_test_drm_connector_dynamic_init_type_valid ==
[05:15:26] ======== drm_test_drm_connector_dynamic_init_name  =========
[05:15:26] [PASSED] Unknown
[05:15:26] [PASSED] VGA
[05:15:26] [PASSED] DVI-I
[05:15:26] [PASSED] DVI-D
[05:15:26] [PASSED] DVI-A
[05:15:26] [PASSED] Composite
[05:15:26] [PASSED] SVIDEO
[05:15:26] [PASSED] LVDS
[05:15:26] [PASSED] Component
[05:15:26] [PASSED] DIN
[05:15:26] [PASSED] DP
[05:15:26] [PASSED] HDMI-A
[05:15:26] [PASSED] HDMI-B
[05:15:26] [PASSED] TV
[05:15:26] [PASSED] eDP
[05:15:26] [PASSED] Virtual
[05:15:26] [PASSED] DSI
[05:15:26] [PASSED] DPI
[05:15:26] [PASSED] Writeback
[05:15:26] [PASSED] SPI
[05:15:26] [PASSED] USB
[05:15:26] ==== [PASSED] drm_test_drm_connector_dynamic_init_name =====
[05:15:26] =========== [PASSED] drm_connector_dynamic_init ============
[05:15:26] ==== drm_connector_dynamic_register_early (4 subtests) =====
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_early_on_list
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_early_defer
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_early_no_init
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_early_no_mode_object
[05:15:26] ====== [PASSED] drm_connector_dynamic_register_early =======
[05:15:26] ======= drm_connector_dynamic_register (7 subtests) ========
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_on_list
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_no_defer
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_no_init
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_mode_object
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_sysfs
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_sysfs_name
[05:15:26] [PASSED] drm_test_drm_connector_dynamic_register_debugfs
[05:15:26] ========= [PASSED] drm_connector_dynamic_register ==========
[05:15:26] = drm_connector_attach_broadcast_rgb_property (2 subtests) =
[05:15:26] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property
[05:15:26] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector
[05:15:26] === [PASSED] drm_connector_attach_broadcast_rgb_property ===
[05:15:26] ========== drm_get_tv_mode_from_name (2 subtests) ==========
[05:15:26] ========== drm_test_get_tv_mode_from_name_valid  ===========
[05:15:26] [PASSED] NTSC
[05:15:26] [PASSED] NTSC-443
[05:15:26] [PASSED] NTSC-J
[05:15:26] [PASSED] PAL
[05:15:26] [PASSED] PAL-M
[05:15:26] [PASSED] PAL-N
[05:15:26] [PASSED] SECAM
[05:15:26] [PASSED] Mono
[05:15:26] ====== [PASSED] drm_test_get_tv_mode_from_name_valid =======
[05:15:26] [PASSED] drm_test_get_tv_mode_from_name_truncated
[05:15:26] ============ [PASSED] drm_get_tv_mode_from_name ============
[05:15:26] = drm_test_connector_hdmi_compute_mode_clock (12 subtests) =
[05:15:26] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb
[05:15:26] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc
[05:15:26] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1
[05:15:26] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc
[05:15:26] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1
[05:15:26] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_double
[05:15:26] = drm_test_connector_hdmi_compute_mode_clock_yuv420_valid  =
[05:15:26] [PASSED] VIC 96
[05:15:26] [PASSED] VIC 97
[05:15:26] [PASSED] VIC 101
[05:15:26] [PASSED] VIC 102
[05:15:26] [PASSED] VIC 106
[05:15:26] [PASSED] VIC 107
[05:15:26] === [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_valid ===
[05:15:26] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc
[05:15:26] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc
[05:15:26] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc
[05:15:26] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc
[05:15:26] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc
[05:15:26] === [PASSED] drm_test_connector_hdmi_compute_mode_clock ====
[05:15:26] == drm_hdmi_connector_get_broadcast_rgb_name (2 subtests) ==
[05:15:26] === drm_test_drm_hdmi_connector_get_broadcast_rgb_name  ====
[05:15:26] [PASSED] Automatic
[05:15:26] [PASSED] Full
[05:15:26] [PASSED] Limited 16:235
[05:15:26] === [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name ===
[05:15:26] [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid
[05:15:26] ==== [PASSED] drm_hdmi_connector_get_broadcast_rgb_name ====
[05:15:26] == drm_hdmi_connector_get_output_format_name (2 subtests) ==
[05:15:26] === drm_test_drm_hdmi_connector_get_output_format_name  ====
[05:15:26] [PASSED] RGB
[05:15:26] [PASSED] YUV 4:2:0
[05:15:26] [PASSED] YUV 4:2:2
[05:15:26] [PASSED] YUV 4:4:4
[05:15:26] === [PASSED] drm_test_drm_hdmi_connector_get_output_format_name ===
[05:15:26] [PASSED] drm_test_drm_hdmi_connector_get_output_format_name_invalid
[05:15:26] ==== [PASSED] drm_hdmi_connector_get_output_format_name ====
[05:15:26] ============= drm_damage_helper (21 subtests) ==============
[05:15:26] [PASSED] drm_test_damage_iter_no_damage
[05:15:26] [PASSED] drm_test_damage_iter_no_damage_fractional_src
[05:15:26] [PASSED] drm_test_damage_iter_no_damage_src_moved
[05:15:26] [PASSED] drm_test_damage_iter_no_damage_fractional_src_moved
[05:15:26] [PASSED] drm_test_damage_iter_no_damage_not_visible
[05:15:26] [PASSED] drm_test_damage_iter_no_damage_no_crtc
[05:15:26] [PASSED] drm_test_damage_iter_no_damage_no_fb
[05:15:26] [PASSED] drm_test_damage_iter_simple_damage
[05:15:26] [PASSED] drm_test_damage_iter_single_damage
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_intersect_src
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_outside_src
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_fractional_src
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_intersect_fractional_src
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_outside_fractional_src
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_src_moved
[05:15:26] [PASSED] drm_test_damage_iter_single_damage_fractional_src_moved
[05:15:26] [PASSED] drm_test_damage_iter_damage
[05:15:26] [PASSED] drm_test_damage_iter_damage_one_intersect
[05:15:26] [PASSED] drm_test_damage_iter_damage_one_outside
[05:15:26] [PASSED] drm_test_damage_iter_damage_src_moved
[05:15:26] [PASSED] drm_test_damage_iter_damage_not_visible
[05:15:26] ================ [PASSED] drm_damage_helper ================
[05:15:26] ============== drm_dp_mst_helper (3 subtests) ==============
[05:15:26] ============== drm_test_dp_mst_calc_pbn_mode  ==============
[05:15:26] [PASSED] Clock 154000 BPP 30 DSC disabled
[05:15:26] [PASSED] Clock 234000 BPP 30 DSC disabled
[05:15:26] [PASSED] Clock 297000 BPP 24 DSC disabled
[05:15:26] [PASSED] Clock 332880 BPP 24 DSC enabled
[05:15:26] [PASSED] Clock 324540 BPP 24 DSC enabled
[05:15:26] ========== [PASSED] drm_test_dp_mst_calc_pbn_mode ==========
[05:15:26] ============== drm_test_dp_mst_calc_pbn_div  ===============
[05:15:26] [PASSED] Link rate 2000000 lane count 4
[05:15:26] [PASSED] Link rate 2000000 lane count 2
[05:15:26] [PASSED] Link rate 2000000 lane count 1
[05:15:26] [PASSED] Link rate 1350000 lane count 4
[05:15:26] [PASSED] Link rate 1350000 lane count 2
[05:15:26] [PASSED] Link rate 1350000 lane count 1
[05:15:26] [PASSED] Link rate 1000000 lane count 4
[05:15:26] [PASSED] Link rate 1000000 lane count 2
[05:15:26] [PASSED] Link rate 1000000 lane count 1
[05:15:26] [PASSED] Link rate 810000 lane count 4
[05:15:26] [PASSED] Link rate 810000 lane count 2
[05:15:26] [PASSED] Link rate 810000 lane count 1
[05:15:26] [PASSED] Link rate 540000 lane count 4
[05:15:26] [PASSED] Link rate 540000 lane count 2
[05:15:26] [PASSED] Link rate 540000 lane count 1
[05:15:26] [PASSED] Link rate 270000 lane count 4
[05:15:26] [PASSED] Link rate 270000 lane count 2
[05:15:26] [PASSED] Link rate 270000 lane count 1
[05:15:26] [PASSED] Link rate 162000 lane count 4
[05:15:26] [PASSED] Link rate 162000 lane count 2
[05:15:26] [PASSED] Link rate 162000 lane count 1
[05:15:26] ========== [PASSED] drm_test_dp_mst_calc_pbn_div ===========
[05:15:26] ========= drm_test_dp_mst_sideband_msg_req_decode  =========
[05:15:26] [PASSED] DP_ENUM_PATH_RESOURCES with port number
[05:15:26] [PASSED] DP_POWER_UP_PHY with port number
[05:15:26] [PASSED] DP_POWER_DOWN_PHY with port number
[05:15:26] [PASSED] DP_ALLOCATE_PAYLOAD with SDP stream sinks
[05:15:26] [PASSED] DP_ALLOCATE_PAYLOAD with port number
[05:15:26] [PASSED] DP_ALLOCATE_PAYLOAD with VCPI
[05:15:26] [PASSED] DP_ALLOCATE_PAYLOAD with PBN
[05:15:26] [PASSED] DP_QUERY_PAYLOAD with port number
[05:15:26] [PASSED] DP_QUERY_PAYLOAD with VCPI
[05:15:26] [PASSED] DP_REMOTE_DPCD_READ with port number
[05:15:26] [PASSED] DP_REMOTE_DPCD_READ with DPCD address
[05:15:26] [PASSED] DP_REMOTE_DPCD_READ with max number of bytes
[05:15:26] [PASSED] DP_REMOTE_DPCD_WRITE with port number
[05:15:26] [PASSED] DP_REMOTE_DPCD_WRITE with DPCD address
[05:15:26] [PASSED] DP_REMOTE_DPCD_WRITE with data array
[05:15:26] [PASSED] DP_REMOTE_I2C_READ with port number
[05:15:26] [PASSED] DP_REMOTE_I2C_READ with I2C device ID
[05:15:26] [PASSED] DP_REMOTE_I2C_READ with transactions array
[05:15:26] [PASSED] DP_REMOTE_I2C_WRITE with port number
[05:15:26] [PASSED] DP_REMOTE_I2C_WRITE with I2C device ID
[05:15:26] [PASSED] DP_REMOTE_I2C_WRITE with data array
[05:15:26] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream ID
[05:15:26] [PASSED] DP_QUERY_STREAM_ENC_STATUS with client ID
[05:15:26] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream event
[05:15:26] [PASSED] DP_QUERY_STREAM_ENC_STATUS with valid stream event
[05:15:26] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream behavior
[05:15:26] [PASSED] DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior
[05:15:26] ===== [PASSED] drm_test_dp_mst_sideband_msg_req_decode =====
[05:15:26] ================ [PASSED] drm_dp_mst_helper ================
[05:15:26] ================== drm_exec (7 subtests) ===================
[05:15:26] [PASSED] sanitycheck
[05:15:26] [PASSED] test_lock
[05:15:26] [PASSED] test_lock_unlock
[05:15:26] [PASSED] test_duplicates
[05:15:26] [PASSED] test_prepare
[05:15:26] [PASSED] test_prepare_array
[05:15:26] [PASSED] test_multiple_loops
[05:15:26] ==================== [PASSED] drm_exec =====================
[05:15:26] =========== drm_format_helper_test (17 subtests) ===========
[05:15:26] ============== drm_test_fb_xrgb8888_to_gray8  ==============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ========== [PASSED] drm_test_fb_xrgb8888_to_gray8 ==========
[05:15:26] ============= drm_test_fb_xrgb8888_to_rgb332  ==============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb332 ==========
[05:15:26] ============= drm_test_fb_xrgb8888_to_rgb565  ==============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb565 ==========
[05:15:26] ============ drm_test_fb_xrgb8888_to_xrgb1555  =============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======== [PASSED] drm_test_fb_xrgb8888_to_xrgb1555 =========
[05:15:26] ============ drm_test_fb_xrgb8888_to_argb1555  =============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======== [PASSED] drm_test_fb_xrgb8888_to_argb1555 =========
[05:15:26] ============ drm_test_fb_xrgb8888_to_rgba5551  =============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======== [PASSED] drm_test_fb_xrgb8888_to_rgba5551 =========
[05:15:26] ============= drm_test_fb_xrgb8888_to_rgb888  ==============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb888 ==========
[05:15:26] ============= drm_test_fb_xrgb8888_to_bgr888  ==============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ========= [PASSED] drm_test_fb_xrgb8888_to_bgr888 ==========
[05:15:26] ============ drm_test_fb_xrgb8888_to_argb8888  =============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======== [PASSED] drm_test_fb_xrgb8888_to_argb8888 =========
[05:15:26] =========== drm_test_fb_xrgb8888_to_xrgb2101010  ===========
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======= [PASSED] drm_test_fb_xrgb8888_to_xrgb2101010 =======
[05:15:26] =========== drm_test_fb_xrgb8888_to_argb2101010  ===========
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======= [PASSED] drm_test_fb_xrgb8888_to_argb2101010 =======
[05:15:26] ============== drm_test_fb_xrgb8888_to_mono  ===============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ========== [PASSED] drm_test_fb_xrgb8888_to_mono ===========
[05:15:26] ==================== drm_test_fb_swab  =====================
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ================ [PASSED] drm_test_fb_swab =================
[05:15:26] ============ drm_test_fb_xrgb8888_to_xbgr8888  =============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======== [PASSED] drm_test_fb_xrgb8888_to_xbgr8888 =========
[05:15:26] ============ drm_test_fb_xrgb8888_to_abgr8888  =============
[05:15:26] [PASSED] single_pixel_source_buffer
[05:15:26] [PASSED] single_pixel_clip_rectangle
[05:15:26] [PASSED] well_known_colors
[05:15:26] [PASSED] destination_pitch
[05:15:26] ======== [PASSED] drm_test_fb_xrgb8888_to_abgr8888 =========
[05:15:26] ================= drm_test_fb_clip_offset  =================
[05:15:26] [PASSED] pass through
[05:15:26] [PASSED] horizontal offset
[05:15:26] [PASSED] vertical offset
[05:15:26] [PASSED] horizontal and vertical offset
[05:15:26] [PASSED] horizontal offset (custom pitch)
[05:15:26] [PASSED] vertical offset (custom pitch)
[05:15:26] [PASSED] horizontal and vertical offset (custom pitch)
[05:15:26] ============= [PASSED] drm_test_fb_clip_offset =============
[05:15:26] =================== drm_test_fb_memcpy  ====================
[05:15:26] [PASSED] single_pixel_source_buffer: XR24 little-endian (0x34325258)
[05:15:26] [PASSED] single_pixel_source_buffer: XRA8 little-endian (0x38415258)
[05:15:26] [PASSED] single_pixel_source_buffer: YU24 little-endian (0x34325559)
[05:15:26] [PASSED] single_pixel_clip_rectangle: XB24 little-endian (0x34324258)
[05:15:26] [PASSED] single_pixel_clip_rectangle: XRA8 little-endian (0x38415258)
[05:15:26] [PASSED] single_pixel_clip_rectangle: YU24 little-endian (0x34325559)
[05:15:26] [PASSED] well_known_colors: XB24 little-endian (0x34324258)
[05:15:26] [PASSED] well_known_colors: XRA8 little-endian (0x38415258)
[05:15:26] [PASSED] well_known_colors: YU24 little-endian (0x34325559)
[05:15:26] [PASSED] destination_pitch: XB24 little-endian (0x34324258)
[05:15:26] [PASSED] destination_pitch: XRA8 little-endian (0x38415258)
[05:15:26] [PASSED] destination_pitch: YU24 little-endian (0x34325559)
[05:15:26] =============== [PASSED] drm_test_fb_memcpy ================
[05:15:26] ============= [PASSED] drm_format_helper_test ==============
[05:15:26] ================= drm_format (18 subtests) =================
[05:15:26] [PASSED] drm_test_format_block_width_invalid
[05:15:26] [PASSED] drm_test_format_block_width_one_plane
[05:15:26] [PASSED] drm_test_format_block_width_two_plane
[05:15:26] [PASSED] drm_test_format_block_width_three_plane
[05:15:26] [PASSED] drm_test_format_block_width_tiled
[05:15:26] [PASSED] drm_test_format_block_height_invalid
[05:15:26] [PASSED] drm_test_format_block_height_one_plane
[05:15:26] [PASSED] drm_test_format_block_height_two_plane
[05:15:26] [PASSED] drm_test_format_block_height_three_plane
[05:15:26] [PASSED] drm_test_format_block_height_tiled
[05:15:26] [PASSED] drm_test_format_min_pitch_invalid
[05:15:26] [PASSED] drm_test_format_min_pitch_one_plane_8bpp
[05:15:26] [PASSED] drm_test_format_min_pitch_one_plane_16bpp
[05:15:26] [PASSED] drm_test_format_min_pitch_one_plane_24bpp
[05:15:26] [PASSED] drm_test_format_min_pitch_one_plane_32bpp
[05:15:26] [PASSED] drm_test_format_min_pitch_two_plane
[05:15:26] [PASSED] drm_test_format_min_pitch_three_plane_8bpp
[05:15:26] [PASSED] drm_test_format_min_pitch_tiled
[05:15:26] =================== [PASSED] drm_format ====================
[05:15:26] ============== drm_framebuffer (10 subtests) ===============
[05:15:26] ========== drm_test_framebuffer_check_src_coords  ==========
[05:15:26] [PASSED] Success: source fits into fb
[05:15:26] [PASSED] Fail: overflowing fb with x-axis coordinate
[05:15:26] [PASSED] Fail: overflowing fb with y-axis coordinate
[05:15:26] [PASSED] Fail: overflowing fb with source width
[05:15:26] [PASSED] Fail: overflowing fb with source height
[05:15:26] ====== [PASSED] drm_test_framebuffer_check_src_coords ======
[05:15:26] [PASSED] drm_test_framebuffer_cleanup
[05:15:26] =============== drm_test_framebuffer_create  ===============
[05:15:26] [PASSED] ABGR8888 normal sizes
[05:15:26] [PASSED] ABGR8888 max sizes
[05:15:26] [PASSED] ABGR8888 pitch greater than min required
[05:15:26] [PASSED] ABGR8888 pitch less than min required
[05:15:26] [PASSED] ABGR8888 Invalid width
[05:15:26] [PASSED] ABGR8888 Invalid buffer handle
[05:15:26] [PASSED] No pixel format
[05:15:26] [PASSED] ABGR8888 Width 0
[05:15:26] [PASSED] ABGR8888 Height 0
[05:15:26] [PASSED] ABGR8888 Out of bound height * pitch combination
[05:15:26] [PASSED] ABGR8888 Large buffer offset
[05:15:26] [PASSED] ABGR8888 Buffer offset for inexistent plane
[05:15:26] [PASSED] ABGR8888 Invalid flag
[05:15:26] [PASSED] ABGR8888 Set DRM_MODE_FB_MODIFIERS without modifiers
[05:15:26] [PASSED] ABGR8888 Valid buffer modifier
[05:15:26] [PASSED] ABGR8888 Invalid buffer modifier(DRM_FORMAT_MOD_SAMSUNG_64_32_TILE)
[05:15:26] [PASSED] ABGR8888 Extra pitches without DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] ABGR8888 Extra pitches with DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] NV12 Normal sizes
[05:15:26] [PASSED] NV12 Max sizes
[05:15:26] [PASSED] NV12 Invalid pitch
[05:15:26] [PASSED] NV12 Invalid modifier/missing DRM_MODE_FB_MODIFIERS flag
[05:15:26] [PASSED] NV12 different  modifier per-plane
[05:15:26] [PASSED] NV12 with DRM_FORMAT_MOD_SAMSUNG_64_32_TILE
[05:15:26] [PASSED] NV12 Valid modifiers without DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] NV12 Modifier for inexistent plane
[05:15:26] [PASSED] NV12 Handle for inexistent plane
[05:15:26] [PASSED] NV12 Handle for inexistent plane without DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] YVU420 DRM_MODE_FB_MODIFIERS set without modifier
[05:15:26] [PASSED] YVU420 Normal sizes
[05:15:26] [PASSED] YVU420 Max sizes
[05:15:26] [PASSED] YVU420 Invalid pitch
[05:15:26] [PASSED] YVU420 Different pitches
[05:15:26] [PASSED] YVU420 Different buffer offsets/pitches
[05:15:26] [PASSED] YVU420 Modifier set just for plane 0, without DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] YVU420 Modifier set just for planes 0, 1, without DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] YVU420 Modifier set just for plane 0, 1, with DRM_MODE_FB_MODIFIERS
[05:15:26] [PASSED] YVU420 Valid modifier
[05:15:26] [PASSED] YVU420 Different modifiers per plane
[05:15:26] [PASSED] YVU420 Modifier for inexistent plane
[05:15:26] [PASSED] YUV420_10BIT Invalid modifier(DRM_FORMAT_MOD_LINEAR)
[05:15:26] [PASSED] X0L2 Normal sizes
[05:15:26] [PASSED] X0L2 Max sizes
[05:15:26] [PASSED] X0L2 Invalid pitch
[05:15:26] [PASSED] X0L2 Pitch greater than minimum required
[05:15:26] [PASSED] X0L2 Handle for inexistent plane
[05:15:26] [PASSED] X0L2 Offset for inexistent plane, without DRM_MODE_FB_MODIFIERS set
[05:15:26] [PASSED] X0L2 Modifier without DRM_MODE_FB_MODIFIERS set
[05:15:26] [PASSED] X0L2 Valid modifier
[05:15:26] [PASSED] X0L2 Modifier for inexistent plane
[05:15:26] =========== [PASSED] drm_test_framebuffer_create ===========
[05:15:26] [PASSED] drm_test_framebuffer_free
[05:15:26] [PASSED] drm_test_framebuffer_init
[05:15:26] [PASSED] drm_test_framebuffer_init_bad_format
[05:15:26] [PASSED] drm_test_framebuffer_init_dev_mismatch
[05:15:26] [PASSED] drm_test_framebuffer_lookup
[05:15:26] [PASSED] drm_test_framebuffer_lookup_inexistent
[05:15:26] [PASSED] drm_test_framebuffer_modifiers_not_supported
[05:15:26] ================= [PASSED] drm_framebuffer =================
[05:15:26] ================ drm_gem_shmem (8 subtests) ================
[05:15:26] [PASSED] drm_gem_shmem_test_obj_create
[05:15:26] [PASSED] drm_gem_shmem_test_obj_create_private
[05:15:26] [PASSED] drm_gem_shmem_test_pin_pages
[05:15:26] [PASSED] drm_gem_shmem_test_vmap
[05:15:26] [PASSED] drm_gem_shmem_test_get_sg_table
[05:15:26] [PASSED] drm_gem_shmem_test_get_pages_sgt
[05:15:26] [PASSED] drm_gem_shmem_test_madvise
[05:15:26] [PASSED] drm_gem_shmem_test_purge
[05:15:26] ================== [PASSED] drm_gem_shmem ==================
[05:15:26] === drm_atomic_helper_connector_hdmi_check (29 subtests) ===
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode_vic_1
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode_vic_1
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode_vic_1
[05:15:26] ====== drm_test_check_broadcast_rgb_cea_mode_yuv420  =======
[05:15:26] [PASSED] Automatic
[05:15:26] [PASSED] Full
[05:15:26] [PASSED] Limited 16:235
[05:15:26] == [PASSED] drm_test_check_broadcast_rgb_cea_mode_yuv420 ===
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_changed
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_not_changed
[05:15:26] [PASSED] drm_test_check_disable_connector
[05:15:26] [PASSED] drm_test_check_hdmi_funcs_reject_rate
[05:15:26] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_rgb
[05:15:26] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_yuv420
[05:15:26] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv422
[05:15:26] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv420
[05:15:26] [PASSED] drm_test_check_driver_unsupported_fallback_yuv420
[05:15:26] [PASSED] drm_test_check_output_bpc_crtc_mode_changed
[05:15:26] [PASSED] drm_test_check_output_bpc_crtc_mode_not_changed
[05:15:26] [PASSED] drm_test_check_output_bpc_dvi
[05:15:26] [PASSED] drm_test_check_output_bpc_format_vic_1
[05:15:26] [PASSED] drm_test_check_output_bpc_format_display_8bpc_only
[05:15:26] [PASSED] drm_test_check_output_bpc_format_display_rgb_only
[05:15:26] [PASSED] drm_test_check_output_bpc_format_driver_8bpc_only
[05:15:26] [PASSED] drm_test_check_output_bpc_format_driver_rgb_only
[05:15:26] [PASSED] drm_test_check_tmds_char_rate_rgb_8bpc
[05:15:26] [PASSED] drm_test_check_tmds_char_rate_rgb_10bpc
[05:15:26] [PASSED] drm_test_check_tmds_char_rate_rgb_12bpc
[05:15:26] ============ drm_test_check_hdmi_color_format  =============
[05:15:26] [PASSED] AUTO -> RGB
[05:15:26] [PASSED] YCBCR422 -> YUV422
[05:15:26] [PASSED] YCBCR420 -> YUV420
[05:15:26] [PASSED] YCBCR444 -> YUV444
[05:15:26] [PASSED] RGB -> RGB
[05:15:26] ======== [PASSED] drm_test_check_hdmi_color_format =========
[05:15:26] ======== drm_test_check_hdmi_color_format_420_only  ========
[05:15:26] [PASSED] RGB should fail
[05:15:26] [PASSED] YUV444 should fail
[05:15:26] [PASSED] YUV422 should fail
[05:15:26] [PASSED] YUV420 should work
[05:15:26] ==== [PASSED] drm_test_check_hdmi_color_format_420_only ====
[05:15:26] ===== [PASSED] drm_atomic_helper_connector_hdmi_check ======
[05:15:26] === drm_atomic_helper_connector_hdmi_reset (6 subtests) ====
[05:15:26] [PASSED] drm_test_check_broadcast_rgb_value
[05:15:26] [PASSED] drm_test_check_bpc_8_value
[05:15:26] [PASSED] drm_test_check_bpc_10_value
[05:15:26] [PASSED] drm_test_check_bpc_12_value
[05:15:26] [PASSED] drm_test_check_format_value
[05:15:26] [PASSED] drm_test_check_tmds_char_value
[05:15:26] ===== [PASSED] drm_atomic_helper_connector_hdmi_reset ======
[05:15:26] = drm_atomic_helper_connector_hdmi_mode_valid (7 subtests) =
[05:15:26] [PASSED] drm_test_check_mode_valid
[05:15:26] [PASSED] drm_test_check_mode_valid_reject
[05:15:26] [PASSED] drm_test_check_mode_valid_reject_rate
[05:15:26] [PASSED] drm_test_check_mode_valid_reject_max_clock
[05:15:26] [PASSED] drm_test_check_mode_valid_yuv420_only_max_clock
[05:15:26] [PASSED] drm_test_check_mode_valid_reject_yuv420_only_connector
[05:15:26] [PASSED] drm_test_check_mode_valid_accept_yuv420_also_connector_rgb
[05:15:26] === [PASSED] drm_atomic_helper_connector_hdmi_mode_valid ===
[05:15:26] = drm_atomic_helper_connector_hdmi_infoframes (5 subtests) =
[05:15:26] [PASSED] drm_test_check_infoframes
[05:15:26] [PASSED] drm_test_check_reject_avi_infoframe
[05:15:26] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_8
[05:15:26] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_10
[05:15:26] [PASSED] drm_test_check_reject_audio_infoframe
[05:15:26] === [PASSED] drm_atomic_helper_connector_hdmi_infoframes ===
[05:15:26] ================= drm_managed (2 subtests) =================
[05:15:26] [PASSED] drm_test_managed_release_action
[05:15:26] [PASSED] drm_test_managed_run_action
[05:15:26] =================== [PASSED] drm_managed ===================
[05:15:26] =================== drm_mm (6 subtests) ====================
[05:15:26] [PASSED] drm_test_mm_init
[05:15:26] [PASSED] drm_test_mm_debug
[05:15:26] [PASSED] drm_test_mm_align32
[05:15:26] [PASSED] drm_test_mm_align64
[05:15:26] [PASSED] drm_test_mm_lowest
[05:15:26] [PASSED] drm_test_mm_highest
[05:15:26] ===================== [PASSED] drm_mm ======================
[05:15:26] ============= drm_modes_analog_tv (5 subtests) =============
[05:15:26] [PASSED] drm_test_modes_analog_tv_mono_576i
[05:15:26] [PASSED] drm_test_modes_analog_tv_ntsc_480i
[05:15:26] [PASSED] drm_test_modes_analog_tv_ntsc_480i_inlined
[05:15:26] [PASSED] drm_test_modes_analog_tv_pal_576i
[05:15:26] [PASSED] drm_test_modes_analog_tv_pal_576i_inlined
[05:15:26] =============== [PASSED] drm_modes_analog_tv ===============
[05:15:26] ============== drm_plane_helper (2 subtests) ===============
[05:15:26] =============== drm_test_check_plane_state  ================
[05:15:26] [PASSED] clipping_simple
[05:15:26] [PASSED] clipping_rotate_reflect
[05:15:26] [PASSED] positioning_simple
[05:15:26] [PASSED] upscaling
[05:15:26] [PASSED] downscaling
[05:15:26] [PASSED] rounding1
[05:15:26] [PASSED] rounding2
[05:15:26] [PASSED] rounding3
[05:15:26] [PASSED] rounding4
[05:15:26] =========== [PASSED] drm_test_check_plane_state ============
[05:15:26] =========== drm_test_check_invalid_plane_state  ============
[05:15:26] [PASSED] positioning_invalid
[05:15:26] [PASSED] upscaling_invalid
[05:15:26] [PASSED] downscaling_invalid
[05:15:26] ======= [PASSED] drm_test_check_invalid_plane_state ========
[05:15:26] ================ [PASSED] drm_plane_helper =================
[05:15:26] ====== drm_connector_helper_tv_get_modes (1 subtest) =======
[05:15:26] ====== drm_test_connector_helper_tv_get_modes_check  =======
[05:15:26] [PASSED] None
[05:15:26] [PASSED] PAL
[05:15:26] [PASSED] NTSC
[05:15:26] [PASSED] Both, NTSC Default
[05:15:26] [PASSED] Both, PAL Default
[05:15:26] [PASSED] Both, NTSC Default, with PAL on command-line
[05:15:26] [PASSED] Both, PAL Default, with NTSC on command-line
[05:15:26] == [PASSED] drm_test_connector_helper_tv_get_modes_check ===
[05:15:26] ======== [PASSED] drm_connector_helper_tv_get_modes ========
[05:15:26] ================== drm_rect (9 subtests) ===================
[05:15:26] [PASSED] drm_test_rect_clip_scaled_div_by_zero
[05:15:26] [PASSED] drm_test_rect_clip_scaled_not_clipped
[05:15:26] [PASSED] drm_test_rect_clip_scaled_clipped
[05:15:26] [PASSED] drm_test_rect_clip_scaled_signed_vs_unsigned
[05:15:26] ================= drm_test_rect_intersect  =================
[05:15:26] [PASSED] top-left x bottom-right: 2x2+1+1 x 2x2+0+0
[05:15:26] [PASSED] top-right x bottom-left: 2x2+0+0 x 2x2+1-1
[05:15:26] [PASSED] bottom-left x top-right: 2x2+1-1 x 2x2+0+0
[05:15:26] [PASSED] bottom-right x top-left: 2x2+0+0 x 2x2+1+1
[05:15:26] [PASSED] right x left: 2x1+0+0 x 3x1+1+0
[05:15:26] [PASSED] left x right: 3x1+1+0 x 2x1+0+0
[05:15:26] [PASSED] up x bottom: 1x2+0+0 x 1x3+0-1
[05:15:26] [PASSED] bottom x up: 1x3+0-1 x 1x2+0+0
[05:15:26] [PASSED] touching corner: 1x1+0+0 x 2x2+1+1
[05:15:26] [PASSED] touching side: 1x1+0+0 x 1x1+1+0
[05:15:26] [PASSED] equal rects: 2x2+0+0 x 2x2+0+0
[05:15:26] [PASSED] inside another: 2x2+0+0 x 1x1+1+1
[05:15:26] [PASSED] far away: 1x1+0+0 x 1x1+3+6
[05:15:26] [PASSED] points intersecting: 0x0+5+10 x 0x0+5+10
[05:15:26] [PASSED] points not intersecting: 0x0+0+0 x 0x0+5+10
[05:15:26] ============= [PASSED] drm_test_rect_intersect =============
[05:15:26] ================ drm_test_rect_calc_hscale  ================
[05:15:26] [PASSED] normal use
[05:15:26] [PASSED] out of max range
[05:15:26] [PASSED] out of min range
[05:15:26] [PASSED] zero dst
[05:15:26] [PASSED] negative src
[05:15:26] [PASSED] negative dst
[05:15:26] ============ [PASSED] drm_test_rect_calc_hscale ============
[05:15:26] ================ drm_test_rect_calc_vscale  ================
[05:15:26] [PASSED] normal use
[05:15:26] [PASSED] out of max range
[05:15:26] [PASSED] out of min range
[05:15:26] [PASSED] zero dst
[05:15:26] [PASSED] negative src
[05:15:26] [PASSED] negative dst
[05:15:26] ============ [PASSED] drm_test_rect_calc_vscale ============
[05:15:26] ================== drm_test_rect_rotate  ===================
[05:15:26] [PASSED] reflect-x
[05:15:26] [PASSED] reflect-y
[05:15:26] [PASSED] rotate-0
[05:15:26] [PASSED] rotate-90
[05:15:26] [PASSED] rotate-180
[05:15:26] [PASSED] rotate-270
[05:15:26] ============== [PASSED] drm_test_rect_rotate ===============
[05:15:26] ================ drm_test_rect_rotate_inv  =================
[05:15:26] [PASSED] reflect-x
[05:15:26] [PASSED] reflect-y
[05:15:26] [PASSED] rotate-0
[05:15:26] [PASSED] rotate-90
[05:15:26] [PASSED] rotate-180
[05:15:26] [PASSED] rotate-270
[05:15:26] ============ [PASSED] drm_test_rect_rotate_inv =============
[05:15:26] ==================== [PASSED] drm_rect =====================
[05:15:26] ============ drm_sysfb_modeset_test (1 subtest) ============
[05:15:26] ============ drm_test_sysfb_build_fourcc_list  =============
[05:15:26] [PASSED] no native formats
[05:15:26] [PASSED] XRGB8888 as native format
[05:15:26] [PASSED] remove duplicates
[05:15:26] [PASSED] convert alpha formats
[05:15:26] [PASSED] random formats
[05:15:26] ======== [PASSED] drm_test_sysfb_build_fourcc_list =========
[05:15:26] ============= [PASSED] drm_sysfb_modeset_test ==============
[05:15:26] ================== drm_fixp (2 subtests) ===================
[05:15:26] [PASSED] drm_test_int2fixp
[05:15:26] [PASSED] drm_test_sm2fixp
[05:15:26] ==================== [PASSED] drm_fixp =====================
[05:15:26] ============================================================
[05:15:26] Testing complete. Ran 639 tests: passed: 639
[05:15:26] Elapsed time: 26.614s total, 1.843s configuring, 24.606s building, 0.147s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/ttm/tests/.kunitconfig
[05:15:27] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[05:15:28] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[05:15:38] Starting KUnit Kernel (1/1)...
[05:15:38] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[05:15:38] ================= ttm_device (5 subtests) ==================
[05:15:38] [PASSED] ttm_device_init_basic
[05:15:38] [PASSED] ttm_device_init_multiple
[05:15:38] [PASSED] ttm_device_fini_basic
[05:15:38] [PASSED] ttm_device_init_no_vma_man
[05:15:38] ================== ttm_device_init_pools  ==================
[05:15:38] [PASSED] No DMA allocations, no DMA32 required
[05:15:38] [PASSED] DMA allocations, DMA32 required
[05:15:38] [PASSED] No DMA allocations, DMA32 required
[05:15:38] [PASSED] DMA allocations, no DMA32 required
[05:15:38] ============== [PASSED] ttm_device_init_pools ==============
[05:15:38] =================== [PASSED] ttm_device ====================
[05:15:38] ================== ttm_pool (8 subtests) ===================
[05:15:38] ================== ttm_pool_alloc_basic  ===================
[05:15:38] [PASSED] One page
[05:15:38] [PASSED] More than one page
[05:15:38] [PASSED] Above the allocation limit
[05:15:38] [PASSED] One page, with coherent DMA mappings enabled
[05:15:38] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[05:15:38] ============== [PASSED] ttm_pool_alloc_basic ===============
[05:15:38] ============== ttm_pool_alloc_basic_dma_addr  ==============
[05:15:38] [PASSED] One page
[05:15:38] [PASSED] More than one page
[05:15:38] [PASSED] Above the allocation limit
[05:15:38] [PASSED] One page, with coherent DMA mappings enabled
[05:15:38] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[05:15:38] ========== [PASSED] ttm_pool_alloc_basic_dma_addr ==========
[05:15:38] [PASSED] ttm_pool_alloc_order_caching_match
[05:15:38] [PASSED] ttm_pool_alloc_caching_mismatch
[05:15:38] [PASSED] ttm_pool_alloc_order_mismatch
[05:15:38] [PASSED] ttm_pool_free_dma_alloc
[05:15:38] [PASSED] ttm_pool_free_no_dma_alloc
[05:15:38] [PASSED] ttm_pool_fini_basic
[05:15:38] ==================== [PASSED] ttm_pool =====================
[05:15:38] ================ ttm_resource (8 subtests) =================
[05:15:38] ================= ttm_resource_init_basic  =================
[05:15:38] [PASSED] Init resource in TTM_PL_SYSTEM
[05:15:38] [PASSED] Init resource in TTM_PL_VRAM
[05:15:38] [PASSED] Init resource in a private placement
[05:15:38] [PASSED] Init resource in TTM_PL_SYSTEM, set placement flags
[05:15:38] ============= [PASSED] ttm_resource_init_basic =============
[05:15:38] [PASSED] ttm_resource_init_pinned
[05:15:38] [PASSED] ttm_resource_fini_basic
[05:15:38] [PASSED] ttm_resource_manager_init_basic
[05:15:38] [PASSED] ttm_resource_manager_usage_basic
[05:15:38] [PASSED] ttm_resource_manager_set_used_basic
[05:15:38] [PASSED] ttm_sys_man_alloc_basic
[05:15:38] [PASSED] ttm_sys_man_free_basic
[05:15:38] ================== [PASSED] ttm_resource ===================
[05:15:38] =================== ttm_tt (15 subtests) ===================
[05:15:38] ==================== ttm_tt_init_basic  ====================
[05:15:38] [PASSED] Page-aligned size
[05:15:38] [PASSED] Extra pages requested
[05:15:38] ================ [PASSED] ttm_tt_init_basic ================
[05:15:38] [PASSED] ttm_tt_init_misaligned
[05:15:38] [PASSED] ttm_tt_fini_basic
[05:15:38] [PASSED] ttm_tt_fini_sg
[05:15:38] [PASSED] ttm_tt_fini_shmem
[05:15:38] [PASSED] ttm_tt_create_basic
[05:15:38] [PASSED] ttm_tt_create_invalid_bo_type
[05:15:38] [PASSED] ttm_tt_create_ttm_exists
[05:15:38] [PASSED] ttm_tt_create_failed
[05:15:38] [PASSED] ttm_tt_destroy_basic
[05:15:38] [PASSED] ttm_tt_populate_null_ttm
[05:15:38] [PASSED] ttm_tt_populate_populated_ttm
[05:15:38] [PASSED] ttm_tt_unpopulate_basic
[05:15:38] [PASSED] ttm_tt_unpopulate_empty_ttm
[05:15:38] [PASSED] ttm_tt_swapin_basic
[05:15:38] ===================== [PASSED] ttm_tt ======================
[05:15:38] =================== ttm_bo (14 subtests) ===================
[05:15:38] =========== ttm_bo_reserve_optimistic_no_ticket  ===========
[05:15:38] [PASSED] Cannot be interrupted and sleeps
[05:15:38] [PASSED] Cannot be interrupted, locks straight away
[05:15:38] [PASSED] Can be interrupted, sleeps
[05:15:38] ======= [PASSED] ttm_bo_reserve_optimistic_no_ticket =======
[05:15:38] [PASSED] ttm_bo_reserve_locked_no_sleep
[05:15:38] [PASSED] ttm_bo_reserve_no_wait_ticket
[05:15:38] [PASSED] ttm_bo_reserve_double_resv
[05:15:38] [PASSED] ttm_bo_reserve_interrupted
[05:15:38] [PASSED] ttm_bo_reserve_deadlock
[05:15:38] [PASSED] ttm_bo_unreserve_basic
[05:15:38] [PASSED] ttm_bo_unreserve_pinned
[05:15:38] [PASSED] ttm_bo_unreserve_bulk
[05:15:38] [PASSED] ttm_bo_fini_basic
[05:15:38] [PASSED] ttm_bo_fini_shared_resv
[05:15:38] [PASSED] ttm_bo_pin_basic
[05:15:38] [PASSED] ttm_bo_pin_unpin_resource
[05:15:38] [PASSED] ttm_bo_multiple_pin_one_unpin
[05:15:38] ===================== [PASSED] ttm_bo ======================
[05:15:38] ============== ttm_bo_validate (22 subtests) ===============
[05:15:38] ============== ttm_bo_init_reserved_sys_man  ===============
[05:15:38] [PASSED] Buffer object for userspace
[05:15:38] [PASSED] Kernel buffer object
[05:15:38] [PASSED] Shared buffer object
[05:15:38] ========== [PASSED] ttm_bo_init_reserved_sys_man ===========
[05:15:38] ============== ttm_bo_init_reserved_mock_man  ==============
[05:15:38] [PASSED] Buffer object for userspace
[05:15:38] [PASSED] Kernel buffer object
[05:15:38] [PASSED] Shared buffer object
[05:15:38] ========== [PASSED] ttm_bo_init_reserved_mock_man ==========
[05:15:38] [PASSED] ttm_bo_init_reserved_resv
[05:15:38] ================== ttm_bo_validate_basic  ==================
[05:15:38] [PASSED] Buffer object for userspace
[05:15:38] [PASSED] Kernel buffer object
[05:15:38] [PASSED] Shared buffer object
[05:15:38] ============== [PASSED] ttm_bo_validate_basic ==============
[05:15:38] [PASSED] ttm_bo_validate_invalid_placement
[05:15:38] ============= ttm_bo_validate_same_placement  ==============
[05:15:38] [PASSED] System manager
[05:15:38] [PASSED] VRAM manager
[05:15:38] ========= [PASSED] ttm_bo_validate_same_placement ==========
[05:15:38] [PASSED] ttm_bo_validate_failed_alloc
[05:15:38] [PASSED] ttm_bo_validate_pinned
[05:15:38] [PASSED] ttm_bo_validate_busy_placement
[05:15:38] ================ ttm_bo_validate_multihop  =================
[05:15:38] [PASSED] Buffer object for userspace
[05:15:38] [PASSED] Kernel buffer object
[05:15:38] [PASSED] Shared buffer object
[05:15:38] ============ [PASSED] ttm_bo_validate_multihop =============
[05:15:38] ========== ttm_bo_validate_no_placement_signaled  ==========
[05:15:38] [PASSED] Buffer object in system domain, no page vector
[05:15:38] [PASSED] Buffer object in system domain with an existing page vector
[05:15:38] ====== [PASSED] ttm_bo_validate_no_placement_signaled ======
[05:15:38] ======== ttm_bo_validate_no_placement_not_signaled  ========
[05:15:38] [PASSED] Buffer object for userspace
[05:15:38] [PASSED] Kernel buffer object
[05:15:38] [PASSED] Shared buffer object
[05:15:38] ==== [PASSED] ttm_bo_validate_no_placement_not_signaled ====
[05:15:38] [PASSED] ttm_bo_validate_move_fence_signaled
[05:15:38] ========= ttm_bo_validate_move_fence_not_signaled  =========
[05:15:38] [PASSED] Waits for GPU
[05:15:38] [PASSED] Tries to lock straight away
[05:15:38] ===== [PASSED] ttm_bo_validate_move_fence_not_signaled =====
[05:15:38] [PASSED] ttm_bo_validate_swapout
[05:15:38] [PASSED] ttm_bo_validate_happy_evict
[05:15:38] [PASSED] ttm_bo_validate_all_pinned_evict
[05:15:38] [PASSED] ttm_bo_validate_allowed_only_evict
[05:15:38] [PASSED] ttm_bo_validate_deleted_evict
[05:15:38] [PASSED] ttm_bo_validate_busy_domain_evict
[05:15:38] [PASSED] ttm_bo_validate_evict_gutting
[05:15:38] [PASSED] ttm_bo_validate_recrusive_evict
[05:15:38] ================= [PASSED] ttm_bo_validate =================
[05:15:38] ============================================================
[05:15:38] Testing complete. Ran 102 tests: passed: 102
[05:15:38] Elapsed time: 11.782s total, 1.738s configuring, 9.829s building, 0.185s running

+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

✓ Xe.CI.BAT: success for drm/xe: balance exec queue suspend/resume (rev4)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 962 bytes --]

== Series Details ==

Series: drm/xe: balance exec queue suspend/resume (rev4)
URL   : https://patchwork.freedesktop.org/series/169125/
State : success

== Summary ==

CI Bug Log - changes from xe-5316-7100870965845da8c31005c07fd1b390bbe96b20_BAT -> xe-pw-169125v4_BAT
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (13 -> 13)
------------------------------

  No changes in participating hosts


Changes
-------

  No changes found


Build changes
-------------

  * Linux: xe-5316-7100870965845da8c31005c07fd1b390bbe96b20 -> xe-pw-169125v4

  IGT_8989: a8e2cbd2854d7980a9eccecc6e0c801d0824b88f @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-5316-7100870965845da8c31005c07fd1b390bbe96b20: 7100870965845da8c31005c07fd1b390bbe96b20
  xe-pw-169125v4: 169125v4

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/index.html

[-- Attachment #2: Type: text/html, Size: 1510 bytes --]

✓ Xe.CI.FULL: success for drm/xe: balance exec queue suspend/resume (rev4)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 29521 bytes --]

== Series Details ==

Series: drm/xe: balance exec queue suspend/resume (rev4)
URL   : https://patchwork.freedesktop.org/series/169125/
State : success

== Summary ==

CI Bug Log - changes from xe-5316-7100870965845da8c31005c07fd1b390bbe96b20_FULL -> xe-pw-169125v4_FULL
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (2 -> 2)
------------------------------

  No changes in participating hosts

Known issues
------------

  Here are the changes found in xe-pw-169125v4_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_addfb_basic@invalid-smem-bo-on-discrete:
    - shard-lnl:          NOTRUN -> [SKIP][1] ([Intel XE#3157])
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_addfb_basic@invalid-smem-bo-on-discrete.html

  * igt@kms_big_fb@linear-max-hw-stride-32bpp-rotate-0-hflip:
    - shard-bmg:          NOTRUN -> [SKIP][2] ([Intel XE#7059] / [Intel XE#7085])
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_big_fb@linear-max-hw-stride-32bpp-rotate-0-hflip.html

  * igt@kms_big_fb@y-tiled-8bpp-rotate-270:
    - shard-bmg:          NOTRUN -> [SKIP][3] ([Intel XE#1124]) +4 other tests skip
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_big_fb@y-tiled-8bpp-rotate-270.html

  * igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-async-flip:
    - shard-lnl:          NOTRUN -> [SKIP][4] ([Intel XE#1124])
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-async-flip.html

  * igt@kms_bw@linear-tiling-4-displays-target-2560x1440p:
    - shard-bmg:          NOTRUN -> [SKIP][5] ([Intel XE#367]) +1 other test skip
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_bw@linear-tiling-4-displays-target-2560x1440p.html
    - shard-lnl:          NOTRUN -> [SKIP][6] ([Intel XE#8365])
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_bw@linear-tiling-4-displays-target-2560x1440p.html

  * igt@kms_ccs@bad-aux-stride-yf-tiled-ccs:
    - shard-bmg:          NOTRUN -> [SKIP][7] ([Intel XE#2887]) +4 other tests skip
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_ccs@bad-aux-stride-yf-tiled-ccs.html

  * igt@kms_chamelium_color@ctm-negative:
    - shard-bmg:          NOTRUN -> [SKIP][8] ([Intel XE#2325] / [Intel XE#7358])
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_chamelium_color@ctm-negative.html

  * igt@kms_chamelium_hpd@dp-hpd-after-suspend:
    - shard-bmg:          NOTRUN -> [SKIP][9] ([Intel XE#2252]) +2 other tests skip
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_chamelium_hpd@dp-hpd-after-suspend.html

  * igt@kms_content_protection@lic-type-1:
    - shard-lnl:          NOTRUN -> [SKIP][10] ([Intel XE#7642])
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_content_protection@lic-type-1.html
    - shard-bmg:          NOTRUN -> [SKIP][11] ([Intel XE#7642])
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_content_protection@lic-type-1.html

  * igt@kms_cursor_crc@cursor-offscreen-512x512:
    - shard-lnl:          NOTRUN -> [SKIP][12] ([Intel XE#2321] / [Intel XE#7355])
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_cursor_crc@cursor-offscreen-512x512.html
    - shard-bmg:          NOTRUN -> [SKIP][13] ([Intel XE#2321] / [Intel XE#7355]) +1 other test skip
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_cursor_crc@cursor-offscreen-512x512.html

  * igt@kms_cursor_crc@cursor-sliding-256x85:
    - shard-bmg:          NOTRUN -> [SKIP][14] ([Intel XE#2320]) +2 other tests skip
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_cursor_crc@cursor-sliding-256x85.html
    - shard-lnl:          NOTRUN -> [SKIP][15] ([Intel XE#1424])
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_cursor_crc@cursor-sliding-256x85.html

  * igt@kms_dsc@dsc-with-bpc-bigjoiner:
    - shard-bmg:          NOTRUN -> [SKIP][16] ([Intel XE#8265])
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_dsc@dsc-with-bpc-bigjoiner.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible:
    - shard-lnl:          [PASS][17] -> [FAIL][18] ([Intel XE#301] / [Intel XE#3149]) +1 other test fail
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-lnl-8/igt@kms_flip@flip-vs-expired-vblank-interruptible.html
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-2/igt@kms_flip@flip-vs-expired-vblank-interruptible.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1:
    - shard-lnl:          [PASS][19] -> [FAIL][20] ([Intel XE#301])
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-lnl-8/igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1.html
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-2/igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling:
    - shard-bmg:          NOTRUN -> [SKIP][21] ([Intel XE#7178] / [Intel XE#7349])
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling:
    - shard-bmg:          NOTRUN -> [SKIP][22] ([Intel XE#7178] / [Intel XE#7351]) +2 other tests skip
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilercccs-downscaling:
    - shard-lnl:          NOTRUN -> [SKIP][23] ([Intel XE#7178] / [Intel XE#7351])
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilercccs-downscaling.html

  * igt@kms_frontbuffer_tracking@drrs-abgr161616f-draw-blt:
    - shard-lnl:          NOTRUN -> [SKIP][24] ([Intel XE#7061] / [Intel XE#7356])
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_frontbuffer_tracking@drrs-abgr161616f-draw-blt.html

  * igt@kms_frontbuffer_tracking@drrshdr-slowdraw:
    - shard-bmg:          NOTRUN -> [SKIP][25] ([Intel XE#2311]) +23 other tests skip
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_frontbuffer_tracking@drrshdr-slowdraw.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-indfb-pgflip-blt:
    - shard-lnl:          NOTRUN -> [SKIP][26] ([Intel XE#656] / [Intel XE#7905]) +4 other tests skip
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-indfb-pgflip-blt.html
    - shard-bmg:          NOTRUN -> [SKIP][27] ([Intel XE#4141]) +3 other tests skip
   [27]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-indfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-shrfb-pgflip-blt:
    - shard-lnl:          NOTRUN -> [SKIP][28] ([Intel XE#6312] / [Intel XE#651]) +2 other tests skip
   [28]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-shrfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-abgr161616f-draw-render:
    - shard-bmg:          NOTRUN -> [SKIP][29] ([Intel XE#7061] / [Intel XE#7356]) +1 other test skip
   [29]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcdrrs-abgr161616f-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrshdr-abgr161616f-draw-blt:
    - shard-bmg:          NOTRUN -> [SKIP][30] ([Intel XE#7061]) +2 other tests skip
   [30]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcdrrshdr-abgr161616f-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbchdr-2p-scndscrn-spr-indfb-draw-render:
    - shard-lnl:          NOTRUN -> [SKIP][31] ([Intel XE#7905]) +5 other tests skip
   [31]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_frontbuffer_tracking@fbchdr-2p-scndscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcpsrhdr-1p-primscrn-cur-indfb-move:
    - shard-lnl:          NOTRUN -> [SKIP][32] ([Intel XE#7865]) +1 other test skip
   [32]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_frontbuffer_tracking@fbcpsrhdr-1p-primscrn-cur-indfb-move.html

  * igt@kms_frontbuffer_tracking@fbcpsrhdr-abgr161616f-draw-render:
    - shard-lnl:          NOTRUN -> [SKIP][33] ([Intel XE#7061])
   [33]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_frontbuffer_tracking@fbcpsrhdr-abgr161616f-draw-render.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-mmap-wc:
    - shard-bmg:          NOTRUN -> [SKIP][34] ([Intel XE#2313]) +24 other tests skip
   [34]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-mmap-wc.html

  * igt@kms_joiner@basic-ultra-joiner:
    - shard-bmg:          NOTRUN -> [SKIP][35] ([Intel XE#6911] / [Intel XE#7378])
   [35]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_joiner@basic-ultra-joiner.html

  * igt@kms_plane@pixel-format-4-tiled-mtl-rc-ccs-modifier:
    - shard-lnl:          NOTRUN -> [SKIP][36] ([Intel XE#7283])
   [36]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_plane@pixel-format-4-tiled-mtl-rc-ccs-modifier.html
    - shard-bmg:          NOTRUN -> [SKIP][37] ([Intel XE#7283])
   [37]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_plane@pixel-format-4-tiled-mtl-rc-ccs-modifier.html

  * igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75@pipe-b:
    - shard-bmg:          NOTRUN -> [SKIP][38] ([Intel XE#2763] / [Intel XE#6886]) +4 other tests skip
   [38]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75@pipe-b.html

  * igt@kms_pm_rpm@dpms-non-lpsp:
    - shard-lnl:          NOTRUN -> [SKIP][39] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#7383])
   [39]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_pm_rpm@dpms-non-lpsp.html

  * igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area-big-fb:
    - shard-bmg:          NOTRUN -> [SKIP][40] ([Intel XE#1489]) +2 other tests skip
   [40]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area-big-fb.html

  * igt@kms_psr2_su@page_flip-p010:
    - shard-lnl:          NOTRUN -> [SKIP][41] ([Intel XE#1128] / [Intel XE#7413])
   [41]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@kms_psr2_su@page_flip-p010.html
    - shard-bmg:          NOTRUN -> [SKIP][42] ([Intel XE#2387] / [Intel XE#7429])
   [42]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_psr2_su@page_flip-p010.html

  * igt@kms_psr@psr-no-drrs:
    - shard-bmg:          NOTRUN -> [SKIP][43] ([Intel XE#2234] / [Intel XE#2850]) +2 other tests skip
   [43]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_psr@psr-no-drrs.html

  * igt@kms_psr@psr2-primary-render:
    - shard-bmg:          NOTRUN -> [SKIP][44] ([Intel XE#2234])
   [44]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_psr@psr2-primary-render.html

  * igt@kms_sharpness_filter@invalid-filter-with-nearest-neighbor:
    - shard-bmg:          NOTRUN -> [SKIP][45] ([Intel XE#6503])
   [45]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@kms_sharpness_filter@invalid-filter-with-nearest-neighbor.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-bmg:          NOTRUN -> [SKIP][46] ([Intel XE#2426] / [Intel XE#5848])
   [46]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@xe_compute_preempt@compute-preempt-many-vram-evict@engine-drm_xe_engine_class_compute:
    - shard-bmg:          [PASS][47] -> [ABORT][48] ([Intel XE#8536]) +1 other test abort
   [47]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-bmg-9/igt@xe_compute_preempt@compute-preempt-many-vram-evict@engine-drm_xe_engine_class_compute.html
   [48]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-3/igt@xe_compute_preempt@compute-preempt-many-vram-evict@engine-drm_xe_engine_class_compute.html

  * igt@xe_eudebug@basic-vm-access:
    - shard-lnl:          NOTRUN -> [SKIP][49] ([Intel XE#7636]) +1 other test skip
   [49]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_eudebug@basic-vm-access.html

  * igt@xe_eudebug@basic-vm-access-userptr:
    - shard-bmg:          NOTRUN -> [SKIP][50] ([Intel XE#7636]) +6 other tests skip
   [50]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_eudebug@basic-vm-access-userptr.html

  * igt@xe_evict@evict-beng-mixed-many-threads-small:
    - shard-bmg:          [PASS][51] -> [INCOMPLETE][52] ([Intel XE#6321] / [Intel XE#8355])
   [51]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-bmg-5/igt@xe_evict@evict-beng-mixed-many-threads-small.html
   [52]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-5/igt@xe_evict@evict-beng-mixed-many-threads-small.html

  * igt@xe_evict@evict-small-external-cm:
    - shard-lnl:          NOTRUN -> [SKIP][53] ([Intel XE#6540] / [Intel XE#688]) +1 other test skip
   [53]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_evict@evict-small-external-cm.html

  * igt@xe_evict@evict-small-multi-queue:
    - shard-bmg:          NOTRUN -> [SKIP][54] ([Intel XE#8370])
   [54]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_evict@evict-small-multi-queue.html

  * igt@xe_exec_basic@multigpu-once-bindexecqueue-userptr-invalidate:
    - shard-bmg:          NOTRUN -> [SKIP][55] ([Intel XE#2322] / [Intel XE#7372]) +3 other tests skip
   [55]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_exec_basic@multigpu-once-bindexecqueue-userptr-invalidate.html

  * igt@xe_exec_basic@multigpu-once-userptr-invalidate:
    - shard-lnl:          NOTRUN -> [SKIP][56] ([Intel XE#1392]) +1 other test skip
   [56]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_exec_basic@multigpu-once-userptr-invalidate.html

  * igt@xe_exec_fault_mode@many-multi-queue-userptr-imm:
    - shard-lnl:          NOTRUN -> [SKIP][57] ([Intel XE#8374])
   [57]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_exec_fault_mode@many-multi-queue-userptr-imm.html

  * igt@xe_exec_fault_mode@once-multi-queue-userptr-invalidate-prefetch:
    - shard-bmg:          NOTRUN -> [SKIP][58] ([Intel XE#8374]) +5 other tests skip
   [58]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_exec_fault_mode@once-multi-queue-userptr-invalidate-prefetch.html

  * igt@xe_exec_multi_queue@many-queues-dyn-priority-smem:
    - shard-bmg:          NOTRUN -> [SKIP][59] ([Intel XE#8364]) +13 other tests skip
   [59]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_exec_multi_queue@many-queues-dyn-priority-smem.html

  * igt@xe_exec_multi_queue@two-queues-preempt-mode-basic-smem:
    - shard-lnl:          NOTRUN -> [SKIP][60] ([Intel XE#8364]) +2 other tests skip
   [60]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_exec_multi_queue@two-queues-preempt-mode-basic-smem.html

  * igt@xe_exec_reset@cm-multi-queue-cat-error-on-secondary:
    - shard-bmg:          NOTRUN -> [SKIP][61] ([Intel XE#8369])
   [61]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_exec_reset@cm-multi-queue-cat-error-on-secondary.html

  * igt@xe_exec_reset@long-spin-many-preempt:
    - shard-bmg:          [PASS][62] -> [FAIL][63] ([Intel XE#7956])
   [62]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-bmg-7/igt@xe_exec_reset@long-spin-many-preempt.html
   [63]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-3/igt@xe_exec_reset@long-spin-many-preempt.html

  * igt@xe_exec_threads@threads-multi-queue-mixed-fd-basic:
    - shard-lnl:          NOTRUN -> [SKIP][64] ([Intel XE#8378])
   [64]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_exec_threads@threads-multi-queue-mixed-fd-basic.html

  * igt@xe_exec_threads@threads-multi-queue-shared-vm-basic:
    - shard-bmg:          NOTRUN -> [SKIP][65] ([Intel XE#8378]) +1 other test skip
   [65]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_exec_threads@threads-multi-queue-shared-vm-basic.html

  * igt@xe_fault_injection@inject-fault-probe-function-xe_guc_ct_init:
    - shard-bmg:          [PASS][66] -> [ABORT][67] ([Intel XE#8007]) +1 other test abort
   [66]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-bmg-10/igt@xe_fault_injection@inject-fault-probe-function-xe_guc_ct_init.html
   [67]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-9/igt@xe_fault_injection@inject-fault-probe-function-xe_guc_ct_init.html

  * igt@xe_media_fill@media-fill:
    - shard-bmg:          NOTRUN -> [SKIP][68] ([Intel XE#2459] / [Intel XE#2596] / [Intel XE#7321] / [Intel XE#7453])
   [68]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_media_fill@media-fill.html

  * igt@xe_multigpu_svm@mgpu-pagefault-prefetch:
    - shard-bmg:          NOTRUN -> [SKIP][69] ([Intel XE#6964]) +1 other test skip
   [69]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_multigpu_svm@mgpu-pagefault-prefetch.html

  * igt@xe_page_reclaim@prl-max-entries:
    - shard-lnl:          NOTRUN -> [SKIP][70] ([Intel XE#7793])
   [70]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_page_reclaim@prl-max-entries.html
    - shard-bmg:          NOTRUN -> [SKIP][71] ([Intel XE#7793]) +1 other test skip
   [71]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_page_reclaim@prl-max-entries.html

  * igt@xe_pat@pat-index-xelp:
    - shard-bmg:          NOTRUN -> [SKIP][72] ([Intel XE#2245] / [Intel XE#7590])
   [72]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_pat@pat-index-xelp.html

  * igt@xe_pm@d3hot-i2c:
    - shard-bmg:          NOTRUN -> [SKIP][73] ([Intel XE#5742] / [Intel XE#7328] / [Intel XE#7400])
   [73]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_pm@d3hot-i2c.html

  * igt@xe_prefetch_fault@prefetch-fault-svm:
    - shard-bmg:          NOTRUN -> [SKIP][74] ([Intel XE#7599])
   [74]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_prefetch_fault@prefetch-fault-svm.html
    - shard-lnl:          NOTRUN -> [SKIP][75] ([Intel XE#7599])
   [75]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_prefetch_fault@prefetch-fault-svm.html

  * igt@xe_pxp@pxp-termination-key-update-post-suspend:
    - shard-bmg:          NOTRUN -> [SKIP][76] ([Intel XE#4733] / [Intel XE#7417])
   [76]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-10/igt@xe_pxp@pxp-termination-key-update-post-suspend.html

  * igt@xe_query@multigpu-query-invalid-size:
    - shard-bmg:          NOTRUN -> [SKIP][77] ([Intel XE#944]) +1 other test skip
   [77]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_query@multigpu-query-invalid-size.html

  * igt@xe_sriov_flr@flr-vfs-parallel:
    - shard-bmg:          NOTRUN -> [FAIL][78] ([Intel XE#7992])
   [78]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@xe_sriov_flr@flr-vfs-parallel.html

  * igt@xe_sriov_vfio@open-basic:
    - shard-lnl:          NOTRUN -> [SKIP][79] ([Intel XE#7724])
   [79]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-5/igt@xe_sriov_vfio@open-basic.html

  * igt@xe_wedged@wedged-mode-toggle:
    - shard-lnl:          [PASS][80] -> [ABORT][81] ([Intel XE#8007])
   [80]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-lnl-3/igt@xe_wedged@wedged-mode-toggle.html
   [81]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-3/igt@xe_wedged@wedged-mode-toggle.html

  
#### Possible fixes ####

  * igt@core_hotunplug@hotreplug-lateclose:
    - shard-bmg:          [ABORT][82] ([Intel XE#8007]) -> [PASS][83]
   [82]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-bmg-1/igt@core_hotunplug@hotreplug-lateclose.html
   [83]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-7/igt@core_hotunplug@hotreplug-lateclose.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs:
    - shard-bmg:          [INCOMPLETE][84] ([Intel XE#7084] / [Intel XE#8150]) -> [PASS][85] +1 other test pass
   [84]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-bmg-2/igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs.html
   [85]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-bmg-1/igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs.html

  * igt@kms_vrr@seamless-rr-switch-virtual@pipe-a-edp-1:
    - shard-lnl:          [FAIL][86] ([Intel XE#2142]) -> [PASS][87] +1 other test pass
   [86]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5316-7100870965845da8c31005c07fd1b390bbe96b20/shard-lnl-3/igt@kms_vrr@seamless-rr-switch-virtual@pipe-a-edp-1.html
   [87]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/shard-lnl-3/igt@kms_vrr@seamless-rr-switch-virtual@pipe-a-edp-1.html

  
  [Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
  [Intel XE#1128]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1128
  [Intel XE#1392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1392
  [Intel XE#1424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1424
  [Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439
  [Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
  [Intel XE#2142]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2142
  [Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
  [Intel XE#2245]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2245
  [Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
  [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
  [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
  [Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
  [Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321
  [Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
  [Intel XE#2325]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2325
  [Intel XE#2387]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2387
  [Intel XE#2426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2426
  [Intel XE#2459]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2459
  [Intel XE#2596]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2596
  [Intel XE#2763]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2763
  [Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
  [Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
  [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
  [Intel XE#3141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3141
  [Intel XE#3149]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3149
  [Intel XE#3157]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3157
  [Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
  [Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
  [Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733
  [Intel XE#5742]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5742
  [Intel XE#5848]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5848
  [Intel XE#6312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6312
  [Intel XE#6321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6321
  [Intel XE#6503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6503
  [Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
  [Intel XE#6540]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6540
  [Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
  [Intel XE#688]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/688
  [Intel XE#6886]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6886
  [Intel XE#6911]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6911
  [Intel XE#6964]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6964
  [Intel XE#7059]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7059
  [Intel XE#7061]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7061
  [Intel XE#7084]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7084
  [Intel XE#7085]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7085
  [Intel XE#7178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7178
  [Intel XE#7283]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7283
  [Intel XE#7321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7321
  [Intel XE#7328]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7328
  [Intel XE#7349]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7349
  [Intel XE#7351]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7351
  [Intel XE#7355]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7355
  [Intel XE#7356]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7356
  [Intel XE#7358]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7358
  [Intel XE#7372]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7372
  [Intel XE#7378]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7378
  [Intel XE#7383]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7383
  [Intel XE#7400]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7400
  [Intel XE#7413]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7413
  [Intel XE#7417]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7417
  [Intel XE#7429]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7429
  [Intel XE#7453]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7453
  [Intel XE#7590]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7590
  [Intel XE#7599]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7599
  [Intel XE#7636]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7636
  [Intel XE#7642]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7642
  [Intel XE#7724]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7724
  [Intel XE#7793]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7793
  [Intel XE#7865]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7865
  [Intel XE#7905]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7905
  [Intel XE#7956]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7956
  [Intel XE#7992]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7992
  [Intel XE#8007]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8007
  [Intel XE#8150]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8150
  [Intel XE#8265]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8265
  [Intel XE#8355]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8355
  [Intel XE#8364]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8364
  [Intel XE#8365]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8365
  [Intel XE#8369]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8369
  [Intel XE#8370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8370
  [Intel XE#8374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8374
  [Intel XE#8378]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8378
  [Intel XE#8536]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8536
  [Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944


Build changes
-------------

  * Linux: xe-5316-7100870965845da8c31005c07fd1b390bbe96b20 -> xe-pw-169125v4

  IGT_8989: a8e2cbd2854d7980a9eccecc6e0c801d0824b88f @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-5316-7100870965845da8c31005c07fd1b390bbe96b20: 7100870965845da8c31005c07fd1b390bbe96b20
  xe-pw-169125v4: 169125v4

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-169125v4/index.html

[-- Attachment #2: Type: text/html, Size: 33098 bytes --]