summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
authorNiranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>2026-08-03 16:05:32 -0700
committerNiranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>2026-08-03 16:19:14 -0700
commit116a19d83efe02f3b2e6352f6f2b2e2f79054de2 (patch)
treecc0364c5d0da59f36112cb42ebd36fc9870bd3db /drivers
parent713d515168bdac14a230caac1d4df838d263f0e4 (diff)
drm/xe/multi_queue: track and recover lost CGP updates across VF migration
When a CGP_SYNC (or REGISTER_CONTEXT_MULTI_QUEUE with CGP) is in flight during VF migration, GuC loses the message and never sends CGP_SYNC_DONE. Two failure modes exist: 1. The send was already issued (CGP_SYNC_DONE not received): group->sync_pending stays set and cgp_update_q points to the queue that owns the outstanding sync. 2. The wait woke early (send not issued): The queue returned from xe_guc_exec_queue_group_cgp_sync() without sending after vf_recovery() became true. Track which kind of sync is outstanding (registering_cgp / updating_cgp) and the owning queue (cgp_update_q) so guc_exec_queue_revert_pending_state_change() can recover both cases: - A registration-time CGP bails or is lost → clear registered flag so run_job re-registers after unpause (re_register / registering_cgp paths). - A dynamic CGP update bails or is lost → set needs_cgp_sync so replay re-issues the update after unpause (re_update / updating_cgp paths). Tag all registration call sites with CGP_SYNC_REGISTRATION so the bail path distinguishes them from dynamic updates. 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> Link: https://patch.msgid.link/20260803230528.3428029-9-niranjana.vishwanathapura@intel.com
Diffstat (limited to 'drivers')
-rw-r--r--drivers/gpu/drm/xe/xe_exec_queue_types.h7
-rw-r--r--drivers/gpu/drm/xe/xe_guc_exec_queue_types.h30
-rw-r--r--drivers/gpu/drm/xe/xe_guc_submit.c112
3 files changed, 141 insertions, 8 deletions
diff --git a/drivers/gpu/drm/xe/xe_exec_queue_types.h b/drivers/gpu/drm/xe/xe_exec_queue_types.h
index 53b6c0bf4849..b2276559c2f6 100644
--- a/drivers/gpu/drm/xe/xe_exec_queue_types.h
+++ b/drivers/gpu/drm/xe/xe_exec_queue_types.h
@@ -70,6 +70,13 @@ struct xe_exec_queue_group {
spinlock_t suspend_lock;
/** @sync_pending: CGP_SYNC_DONE g2h response pending */
bool sync_pending;
+ /**
+ * @cgp_update_q: Queue that issued the currently outstanding (sent)
+ * CGP_SYNC or REGISTER_CONTEXT_MULTI_QUEUE; NULL when none is
+ * outstanding. Used during VF recovery to identify and replay the
+ * message whose CGP_SYNC_DONE was not received.
+ */
+ struct xe_exec_queue *cgp_update_q;
/** @banned: Group banned */
bool banned;
/** @stopped: Group is stopped, protected by list_lock */
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 acdc24d1a6bd..573b920edb41 100644
--- a/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
+++ b/drivers/gpu/drm/xe/xe_guc_exec_queue_types.h
@@ -76,6 +76,36 @@ struct xe_guc_exec_queue {
* recovery.
*/
bool needs_resume;
+ /** @multi_queue: multi-queue group CGP state for VF post migration recovery */
+ struct {
+ /**
+ * @multi_queue.needs_cgp_sync: Needs a CGP_SYNC (dynamic CGP
+ * update) message replayed during recovery.
+ */
+ u8 needs_cgp_sync:1;
+ /**
+ * @multi_queue.re_register: A registration-time CGP update was
+ * interrupted by recovery; the queue must be re-registered.
+ */
+ u8 re_register:1;
+ /**
+ * @multi_queue.re_update: A dynamic CGP update was interrupted
+ * by recovery; the CGP update must be replayed.
+ */
+ u8 re_update:1;
+ /**
+ * @multi_queue.registering_cgp: This queue's currently
+ * outstanding CGP_SYNC is a registration (matched against
+ * group->cgp_update_q in revert).
+ */
+ u8 registering_cgp:1;
+ /**
+ * @multi_queue.updating_cgp: This queue's currently outstanding
+ * CGP_SYNC is a dynamic update (matched against
+ * group->cgp_update_q in revert).
+ */
+ u8 updating_cgp:1;
+ } multi_queue;
};
#endif
diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
index 13d0ab8052e5..c018bc0d8d6f 100644
--- a/drivers/gpu/drm/xe/xe_guc_submit.c
+++ b/drivers/gpu/drm/xe/xe_guc_submit.c
@@ -800,9 +800,12 @@ static void xe_guc_exec_queue_group_cgp_update(struct xe_device *xe,
}
}
+#define CGP_SYNC_REGISTRATION BIT(0)
+
static void xe_guc_exec_queue_group_cgp_sync(struct xe_guc *guc,
struct xe_exec_queue *q,
- const u32 *action, u32 len)
+ const u32 *action, u32 len,
+ unsigned int flags)
{
struct xe_exec_queue_group *group = q->multi_queue.group;
struct xe_device *xe = guc_to_xe(guc);
@@ -829,17 +832,45 @@ static void xe_guc_exec_queue_group_cgp_sync(struct xe_guc *guc,
return;
}
+ /*
+ * If woken by VF migration recovery, do not touch the CGP or send: the
+ * message would be lost and, for a registration, GuC must (re-)register
+ * the context before its CGP entry may be read. Flag the queue so revert
+ * replays it - a registration by re-registration, a dynamic update by a
+ * replayed CGP_SYNC - and bail.
+ */
+ if (vf_recovery(guc)) {
+ if (flags & CGP_SYNC_REGISTRATION)
+ q->guc->multi_queue.re_register = true;
+ else
+ q->guc->multi_queue.re_update = true;
+ return;
+ }
+
scoped_guard(spinlock, &q->multi_queue.lock)
priority = q->multi_queue.priority;
xe_lrc_set_multi_queue_priority(q->lrc[0], priority);
xe_guc_exec_queue_group_cgp_update(xe, q);
+ /*
+ * Record the nature of this outstanding sync so revert can replay it if
+ * its CGP_SYNC_DONE is lost across a migration: a registration is
+ * recovered by re-registration, a dynamic update by a replayed CGP_SYNC.
+ */
+ if (flags & CGP_SYNC_REGISTRATION) {
+ q->guc->multi_queue.registering_cgp = true;
+ q->guc->multi_queue.updating_cgp = false;
+ } else {
+ q->guc->multi_queue.updating_cgp = true;
+ q->guc->multi_queue.registering_cgp = false;
+ }
+ WRITE_ONCE(group->cgp_update_q, q);
WRITE_ONCE(group->sync_pending, true);
xe_guc_ct_send(&guc->ct, action, len, G2H_LEN_DW_MULTI_QUEUE_CONTEXT, 1);
}
-static void guc_exec_queue_send_cgp_sync(struct xe_exec_queue *q)
+static void guc_exec_queue_send_cgp_sync(struct xe_exec_queue *q, unsigned int flags)
{
#define MAX_MULTI_QUEUE_CGP_SYNC_SIZE (2)
struct xe_guc *guc = exec_queue_to_guc(q);
@@ -853,7 +884,7 @@ static void guc_exec_queue_send_cgp_sync(struct xe_exec_queue *q)
xe_gt_assert(guc_to_gt(guc), len <= MAX_MULTI_QUEUE_CGP_SYNC_SIZE);
#undef MAX_MULTI_QUEUE_CGP_SYNC_SIZE
- xe_guc_exec_queue_group_cgp_sync(guc, q, action, len);
+ xe_guc_exec_queue_group_cgp_sync(guc, q, action, len, flags);
}
static void __register_exec_queue_group(struct xe_exec_queue *q,
@@ -881,7 +912,8 @@ static void __register_exec_queue_group(struct xe_exec_queue *q,
* XE_GUC_ACTION_NOTIFY_MULTI_QUEUE_CONTEXT_CGP_SYNC_DONE response
* from guc.
*/
- xe_guc_exec_queue_group_cgp_sync(guc, q, action, len);
+ xe_guc_exec_queue_group_cgp_sync(guc, q, action, len,
+ CGP_SYNC_REGISTRATION);
}
static void __register_mlrc_exec_queue(struct xe_guc *guc,
@@ -1041,7 +1073,7 @@ static void register_exec_queue(struct xe_exec_queue *q, int ctx_type)
init_policies(guc, q);
if (xe_exec_queue_is_multi_queue_secondary(q))
- guc_exec_queue_send_cgp_sync(q);
+ guc_exec_queue_send_cgp_sync(q, CGP_SYNC_REGISTRATION);
}
static u32 wq_space_until_wrap(struct xe_exec_queue *q)
@@ -1923,7 +1955,7 @@ static void __guc_exec_queue_process_msg_set_multi_queue_priority(struct xe_sche
struct xe_exec_queue *q = msg->private_data;
if (guc_exec_queue_allowed_to_change_state(q))
- guc_exec_queue_send_cgp_sync(q);
+ guc_exec_queue_send_cgp_sync(q, 0);
kfree(msg);
}
@@ -2716,6 +2748,57 @@ static void guc_exec_queue_revert_pending_state_change(struct xe_guc *guc,
q->guc->id);
}
+ /*
+ * A registration time CGP update that bailed when woken by VF recovery.
+ * Re-register the queue.
+ */
+ if (q->guc->multi_queue.re_register) {
+ clear_exec_queue_registered(q);
+ q->guc->multi_queue.re_register = false;
+ xe_gt_dbg(guc_to_gt(guc), "Replay REGISTER (cgp) - guc_id=%d",
+ q->guc->id);
+ }
+
+ /*
+ * If a CGP update gets dropped during migration, CGP_SYNC_DONE will not
+ * be received (sync_pending still set and this queue owns it). Recover
+ * it the same way and clear the stuck sync_pending.
+ */
+ if (xe_exec_queue_is_multi_queue(q)) {
+ struct xe_exec_queue_group *group = q->multi_queue.group;
+
+ if (q == READ_ONCE(group->cgp_update_q) &&
+ READ_ONCE(group->sync_pending)) {
+ if (q->guc->multi_queue.registering_cgp) {
+ clear_exec_queue_registered(q);
+ xe_gt_dbg(guc_to_gt(guc), "Replay REGISTER (cgp sync) - guc_id=%d",
+ q->guc->id);
+ } else if (q->guc->multi_queue.updating_cgp) {
+ q->guc->multi_queue.needs_cgp_sync = true;
+ xe_gt_dbg(guc_to_gt(guc), "Replay CGP_SYNC - guc_id=%d",
+ q->guc->id);
+ }
+ q->guc->multi_queue.registering_cgp = false;
+ q->guc->multi_queue.updating_cgp = false;
+ WRITE_ONCE(group->cgp_update_q, NULL);
+ WRITE_ONCE(group->sync_pending, false);
+ }
+ }
+
+ /*
+ * A dynamic-time CGP update that bailed when woken by VF recovery.
+ * Replay the dynamic CGP update unless the queue is registered or being
+ * re-registered, which re-does the CGP anyway.
+ */
+ if (q->guc->multi_queue.re_update) {
+ q->guc->multi_queue.re_update = false;
+ if (exec_queue_registered(q)) {
+ q->guc->multi_queue.needs_cgp_sync = true;
+ xe_gt_dbg(guc_to_gt(guc), "Replay CGP_SYNC (re-update) - guc_id=%d",
+ q->guc->id);
+ }
+ }
+
q->guc->resume_time = 0;
}
@@ -3424,7 +3507,8 @@ int xe_guc_exec_queue_cgp_context_error_handler(struct xe_guc *guc, u32 *msg,
int xe_guc_exec_queue_cgp_sync_done_handler(struct xe_guc *guc, u32 *msg, u32 len)
{
struct xe_device *xe = guc_to_xe(guc);
- struct xe_exec_queue *q;
+ struct xe_exec_queue_group *group;
+ struct xe_exec_queue *q, *upd_q;
u32 guc_id = msg[0];
if (unlikely(len < 1)) {
@@ -3441,8 +3525,20 @@ int xe_guc_exec_queue_cgp_sync_done_handler(struct xe_guc *guc, u32 *msg, u32 le
return -EPROTO;
}
+ /*
+ * The outstanding CGP update is now confirmed; clear the owning queue's
+ * tracking so a later migration does not needlessly replay it.
+ */
+ group = q->multi_queue.group;
+ upd_q = READ_ONCE(group->cgp_update_q);
+ if (upd_q) {
+ upd_q->guc->multi_queue.registering_cgp = false;
+ upd_q->guc->multi_queue.updating_cgp = false;
+ WRITE_ONCE(group->cgp_update_q, NULL);
+ }
+
/* Wakeup the serialized cgp update wait */
- WRITE_ONCE(q->multi_queue.group->sync_pending, false);
+ WRITE_ONCE(group->sync_pending, false);
xe_guc_ct_wake_waiters(&guc->ct);
return 0;