Re: [PATCH v2 12/34] drm/xe/vf: Make VF recovery run on per-GT worker

[Matthew Brost <matthew.brost@intel.com>]

On Wed, Sep 24, 2025 at 10:21:32PM +0200, Michal Wajdeczko wrote:
> 
> 
> On 9/24/2025 9:50 PM, Matthew Brost wrote:
> > On Wed, Sep 24, 2025 at 12:49:25PM +0200, Michal Wajdeczko wrote:
> >>
> >>
> >> On 9/24/2025 3:15 AM, Matthew Brost wrote:
> >>> VF recovery is a per-GT operation, so it makes sense to isolate it to a
> >>
> >> that was also my suggestion to make it per-GT, good to see it happen now
> >>
> > 
> > +1
> > 
> >>> per-GT queue. Scheduling this operation on the same worker as the GT
> >>> reset and TDR not only aligns with this design but also helps avoid race
> >>> conditions, as those operations can also modify the queue state.
> >>
> >> but while the recovery is per-GT, we should still protect against that
> >> one GT starts the recovery sooner then other GTs notice about it
> >>
> > 
> > Yes. There is shared state in 2 places:
> > 
> >  - The GGTT shifting, this handled by [1] in my series.
> >  - CCS restore on iGPU (PTL) handled by [2] [3] in my series.
> > 
> > [1] https://patchwork.freedesktop.org/patch/676394/?series=154627&rev=2
> > [2] https://patchwork.freedesktop.org/patch/676393/?series=154627&rev=2
> > [3] https://patchwork.freedesktop.org/patch/676397/?series=154627&rev=2
> > 
> >>>
> >>> v2:
> >>>  - Fix lockdep splat (Adam)
> >>>  - Use xe_sriov_vf_migration_supported helper
> >>>
> >>> Signed-off-by: Matthew Brost <matthew.brost@intel.com>
> >>> ---
> >>>  drivers/gpu/drm/xe/xe_gt_sriov_vf.c       | 170 ++++++++++++++-
> >>>  drivers/gpu/drm/xe/xe_gt_sriov_vf.h       |   3 +-
> >>>  drivers/gpu/drm/xe/xe_gt_sriov_vf_types.h |   7 +
> >>>  drivers/gpu/drm/xe/xe_sriov_vf.c          | 242 +---------------------
> >>>  drivers/gpu/drm/xe/xe_sriov_vf.h          |   1 -
> >>>  drivers/gpu/drm/xe/xe_sriov_vf_types.h    |   4 -
> >>>  6 files changed, 169 insertions(+), 258 deletions(-)
> >>>
> >>> diff --git a/drivers/gpu/drm/xe/xe_gt_sriov_vf.c b/drivers/gpu/drm/xe/xe_gt_sriov_vf.c
> >>> index c9d0e32e7a15..cfb71b749e52 100644
> >>> --- a/drivers/gpu/drm/xe/xe_gt_sriov_vf.c
> >>> +++ b/drivers/gpu/drm/xe/xe_gt_sriov_vf.c
> >>> @@ -25,11 +25,15 @@
> >>>  #include "xe_guc.h"
> >>>  #include "xe_guc_hxg_helpers.h"
> >>>  #include "xe_guc_relay.h"
> >>> +#include "xe_guc_submit.h"
> >>> +#include "xe_irq.h"
> >>>  #include "xe_lrc.h"
> >>>  #include "xe_memirq.h"
> >>>  #include "xe_mmio.h"
> >>> +#include "xe_pm.h"
> >>>  #include "xe_sriov.h"
> >>>  #include "xe_sriov_vf.h"
> >>> +#include "xe_tile_sriov_vf.h"
> >>>  #include "xe_uc_fw.h"
> >>>  #include "xe_wopcm.h"
> >>>  
> >>> @@ -314,7 +318,7 @@ static int guc_action_vf_notify_resfix_done(struct xe_guc *guc)
> >>>   * Returns: 0 if the operation completed successfully, or a negative error
> >>>   * code otherwise.
> >>>   */
> >>> -int xe_gt_sriov_vf_notify_resfix_done(struct xe_gt *gt)
> >>> +static int xe_gt_sriov_vf_notify_resfix_done(struct xe_gt *gt)
> >>>  {
> >>>  	struct xe_guc *guc = &gt->uc.guc;
> >>>  	int err;
> >>> @@ -808,7 +812,7 @@ int xe_gt_sriov_vf_connect(struct xe_gt *gt)
> >>>   * xe_gt_sriov_vf_default_lrcs_hwsp_rebase - Update GGTT references in HWSP of default LRCs.
> >>>   * @gt: the &xe_gt struct instance
> >>>   */
> >>> -void xe_gt_sriov_vf_default_lrcs_hwsp_rebase(struct xe_gt *gt)
> >>> +static void xe_gt_sriov_vf_default_lrcs_hwsp_rebase(struct xe_gt *gt)
> >>>  {
> >>>  	struct xe_hw_engine *hwe;
> >>>  	enum xe_hw_engine_id id;
> >>> @@ -817,6 +821,26 @@ void xe_gt_sriov_vf_default_lrcs_hwsp_rebase(struct xe_gt *gt)
> >>>  		xe_default_lrc_update_memirq_regs_with_address(hwe);
> >>>  }
> >>>  
> >>> +static void xe_gt_sriov_vf_start_migration_recovery(struct xe_gt *gt)
> >>
> >> nit: if this is static then could be just:
> >>
> >> 	vf_start_migration_recovery(gt)
> >>
> > 
> > Sure.
> > 
> >>> +{
> >>> +	bool started;
> >>> +
> >>> +	xe_gt_assert(gt, IS_SRIOV_VF(gt_to_xe(gt)));
> >>> +
> >>> +	spin_lock(&gt->sriov.vf.migration.lock);
> >>> +
> >>> +	if (!gt->sriov.vf.migration.recovery_queued) {
> >>> +		gt->sriov.vf.migration.recovery_queued = true;
> >>> +		WRITE_ONCE(gt->sriov.vf.migration.recovery_inprogress, true);
> >>> +
> >>> +		started = queue_work(gt->ordered_wq, &gt->sriov.vf.migration.worker);
> >>> +		xe_gt_sriov_info(gt, "VF migration recovery %s\n", started ?
> >>> +				 "scheduled" : "already in progress");
> >>
> >> with this .recovery_queued flag, can we hit "already in progress" case?
> >>
> > 
> > This was existing code so kept it but I'm really unclear how we can get
> 
> I can't find "recovery_queued" flag in upstream code
> 

This is akin to comment in upstream code. Again, I'm not really
convienced this is something we need to handle as I suspect this is not
possible.

/* skip asking GuC for RESFIX exit if new recovery request arrived */

> > multiple resfix IRQs without the prior resfix flow being completed.
> > Maybe Tomasz can clear this one up? Ideally I'd like to remove multiple
> > resfix IRQ handled code if this is not possible.
> > 
> >>> +	}
> >>> +
> >>> +	spin_unlock(&gt->sriov.vf.migration.lock);
> >>> +}
> >>> +
> >>>  /**
> >>>   * xe_gt_sriov_vf_migrated_event_handler - Start a VF migration recovery,
> >>>   *   or just mark that a GuC is ready for it.
> >>> @@ -831,15 +855,8 @@ void xe_gt_sriov_vf_migrated_event_handler(struct xe_gt *gt)
> >>>  	xe_gt_assert(gt, IS_SRIOV_VF(xe));
> >>>  	xe_gt_assert(gt, xe_gt_sriov_vf_recovery_inprogress(gt));
> >>>  
> >>> -	set_bit(gt->info.id, &xe->sriov.vf.migration.gt_flags);
> >>> -	/*
> >>> -	 * We need to be certain that if all flags were set, at least one
> >>> -	 * thread will notice that and schedule the recovery.
> >>> -	 */
> >>> -	smp_mb__after_atomic();
> >>> -
> >>>  	xe_gt_sriov_info(gt, "ready for recovery after migration\n");
> >>> -	xe_sriov_vf_start_migration_recovery(xe);
> >>> +	xe_gt_sriov_vf_start_migration_recovery(gt);
> >>>  }
> >>>  
> >>>  static bool vf_is_negotiated(struct xe_gt *gt, u16 major, u16 minor)
> >>> @@ -1175,6 +1192,139 @@ void xe_gt_sriov_vf_print_version(struct xe_gt *gt, struct drm_printer *p)
> >>>  		   pf_version->major, pf_version->minor);
> >>>  }
> >>>  
> >>> +static void vf_post_migration_shutdown(struct xe_gt *gt)
> >>> +{
> >>> +	int ret = 0;
> >>> +
> >>> +	spin_lock_irq(&gt->sriov.vf.migration.lock);
> >>> +	gt->sriov.vf.migration.recovery_queued = false;
> >>> +	spin_unlock_irq(&gt->sriov.vf.migration.lock);
> >>> +
> >>> +	xe_guc_submit_pause(&gt->uc.guc);
> >>> +	ret |= xe_guc_submit_reset_block(&gt->uc.guc);
> >>
> >> this |= seem unneeded
> >>
> > 
> > This is existing code copy / pasted and is removed in [4].
> > 
> > [4] https://patchwork.freedesktop.org/patch/676382/?series=154627&rev=2
> > 
> >>> +
> >>> +	if (ret)
> >>> +		xe_gt_sriov_info(gt, "migration recovery encountered ongoing reset\n");
> >>
> >> is this the only possible reason? maybe worth to add %pe ?
> >>
> > 
> > Again this existing code and will be removed in [4].
> > 
> > So with above statements, I'd prefer just to leave as is.
> > 
> >>> +}
> >>> +
> >>> +static size_t post_migration_scratch_size(struct xe_device *xe)
> >>> +{
> >>> +	return max(xe_lrc_reg_size(xe), LRC_WA_BB_SIZE);
> >>> +}
> >>> +
> >>> +static int vf_post_migration_fixups(struct xe_gt *gt)
> >>> +{
> >>> +	s64 shift;
> >>> +	void *buf;
> >>> +	int err;
> >>> +
> >>> +	buf = kmalloc(post_migration_scratch_size(gt_to_xe(gt)), GFP_ATOMIC);
> >>> +	if (!buf)
> >>> +		return -ENOMEM;
> >>> +
> >>> +	err = xe_gt_sriov_vf_query_config(gt);
> >>> +	if (err)
> >>> +		goto out;
> >>> +
> >>> +	shift = xe_gt_sriov_vf_ggtt_shift(gt);
> >>> +	if (shift) {
> >>> +		xe_tile_sriov_vf_fixup_ggtt_nodes(gt_to_tile(gt), shift);
> >>> +		xe_gt_sriov_vf_default_lrcs_hwsp_rebase(gt);
> >>> +		err = xe_guc_contexts_hwsp_rebase(&gt->uc.guc, buf);
> >>> +		if (err)
> >>> +			goto out;
> >>> +	}
> >>> +
> >>> +out:
> >>> +	kfree(buf);
> >>> +	return err;
> >>> +}
> >>> +
> >>> +static void vf_post_migration_kickstart(struct xe_gt *gt)
> >>> +{
> >>> +	/*
> >>> +	 * Make sure interrupts on the new HW are properly set. The GuC IRQ
> >>> +	 * must be working at this point, since the recovery did started,
> >>> +	 * but the rest was not enabled using the procedure from spec.
> >>> +	 */
> >>> +	xe_irq_resume(gt_to_xe(gt));
> >>> +
> >>> +	xe_guc_submit_reset_unblock(&gt->uc.guc);
> >>> +	xe_guc_submit_unpause(&gt->uc.guc);
> >>> +}
> >>> +
> >>> +static int vf_post_migration_notify_resfix_done(struct xe_gt *gt)
> >>> +{
> >>> +	bool skip_resfix = false;
> >>> +
> >>> +	spin_lock_irq(&gt->sriov.vf.migration.lock);
> >>> +	if (gt->sriov.vf.migration.recovery_queued) {
> >>> +		skip_resfix = true;
> >>> +		xe_gt_sriov_dbg(gt, "another recovery imminent, skipped some notifications\n");
> >>> +	} else {
> >>> +		WRITE_ONCE(gt->sriov.vf.migration.recovery_inprogress, false);
> >>> +	}
> >>> +	spin_unlock_irq(&gt->sriov.vf.migration.lock);
> >>> +
> >>> +	return skip_resfix ? -EAGAIN : xe_gt_sriov_vf_notify_resfix_done(gt);
> >>
> >> nit: this looks cleaner:
> >>
> >> 	if (skip_resfix)
> >> 		return -EAGAIN;
> >>
> >> 	return xe_gt_sriov_vf_notify_resfix_done(gt);
> >>
> > 
> > Sure.
> > 
> >>> +}
> >>> +
> >>> +static void vf_post_migration_recovery(struct xe_gt *gt)
> >>> +{
> >>> +	struct xe_device *xe = gt_to_xe(gt);
> >>> +	int err;
> >>> +
> >>> +	xe_gt_sriov_dbg(gt, "migration recovery in progress\n");
> >>> +
> >>> +	xe_pm_runtime_get(xe);
> >>> +	vf_post_migration_shutdown(gt);
> >>> +
> >>> +	if (!xe_sriov_vf_migration_supported(xe)) {
> >>> +		xe_gt_sriov_err(gt, "migration is not supported\n");
> >>> +		err = -ENOTRECOVERABLE;
> >>> +		goto fail;
> >>> +	}
> >>> +
> >>> +	err = vf_post_migration_fixups(gt);
> >>> +	if (err)
> >>> +		goto fail;
> >>> +
> >>> +	vf_post_migration_kickstart(gt);
> >>> +	err = vf_post_migration_notify_resfix_done(gt);
> >>> +	if (err && err != -EAGAIN)
> >>> +		goto fail;
> >>> +
> >>> +	xe_pm_runtime_put(xe);
> >>> +	xe_gt_sriov_notice(gt, "migration recovery ended\n");
> >>> +	return;
> >>> +fail:
> >>> +	xe_pm_runtime_put(xe);
> >>> +	xe_gt_sriov_err(gt, "migration recovery failed (%pe)\n", ERR_PTR(err));
> >>> +	xe_device_declare_wedged(xe);
> >>> +}
> >>> +
> >>> +static void migration_worker_func(struct work_struct *w)
> >>> +{
> >>> +	struct xe_gt *gt = container_of(w, struct xe_gt,
> >>> +					sriov.vf.migration.worker);
> >>> +
> >>> +	vf_post_migration_recovery(gt);
> >>> +}
> >>> +
> >>> +/**
> >>> + * xe_gt_sriov_vf_migration_init_early() - VF post migration init early
> >>> + * @gt: the &xe_gt
> >>> + */
> >>> +void xe_gt_sriov_vf_migration_init_early(struct xe_gt *gt)
> >>> +{
> >>> +	init_rwsem(&gt->sriov.vf.self_config.lock);
> >>> +	spin_lock_init(&gt->sriov.vf.migration.lock);
> >>> +	INIT_WORK(&gt->sriov.vf.migration.worker, migration_worker_func);
> >>> +
> >>> +	if (!xe_sriov_vf_migration_supported(gt_to_xe(gt)))
> >>> +		xe_gt_sriov_info(gt, "migration not supported by this module version\n");
> >>
> >> we likely don't want to repeat that message on every GT
> >>
> > 
> > So move this to xe_sriov_vf_init_early?
> 
> hmm, maybe it is even already there
> 

Let me check on that. Either way will remove this from the GT layer.

> > 
> >>> +}
> >>> +
> >>>  /**
> >>>   * xe_gt_sriov_vf_recovery_inprogress() - VF post migration recovery in progress
> >>>   * @gt: the &xe_gt
> >>> diff --git a/drivers/gpu/drm/xe/xe_gt_sriov_vf.h b/drivers/gpu/drm/xe/xe_gt_sriov_vf.h
> >>> index bb5f8eace19b..2ac6775b52f0 100644
> >>> --- a/drivers/gpu/drm/xe/xe_gt_sriov_vf.h
> >>> +++ b/drivers/gpu/drm/xe/xe_gt_sriov_vf.h
> >>> @@ -21,10 +21,9 @@ void xe_gt_sriov_vf_guc_versions(struct xe_gt *gt,
> >>>  int xe_gt_sriov_vf_query_config(struct xe_gt *gt);
> >>>  int xe_gt_sriov_vf_connect(struct xe_gt *gt);
> >>>  int xe_gt_sriov_vf_query_runtime(struct xe_gt *gt);
> >>> -void xe_gt_sriov_vf_default_lrcs_hwsp_rebase(struct xe_gt *gt);
> >>> -int xe_gt_sriov_vf_notify_resfix_done(struct xe_gt *gt);
> >>>  void xe_gt_sriov_vf_migrated_event_handler(struct xe_gt *gt);
> >>>  
> >>> +void xe_gt_sriov_vf_migration_init_early(struct xe_gt *gt);
> >>>  bool xe_gt_sriov_vf_recovery_inprogress(struct xe_gt *gt);
> >>>  
> >>>  u32 xe_gt_sriov_vf_gmdid(struct xe_gt *gt);
> >>> diff --git a/drivers/gpu/drm/xe/xe_gt_sriov_vf_types.h b/drivers/gpu/drm/xe/xe_gt_sriov_vf_types.h
> >>> index 7b10b8e1e10e..53680a2f188a 100644
> >>> --- a/drivers/gpu/drm/xe/xe_gt_sriov_vf_types.h
> >>> +++ b/drivers/gpu/drm/xe/xe_gt_sriov_vf_types.h
> >>> @@ -8,6 +8,7 @@
> >>>  
> >>>  #include <linux/rwsem.h>
> >>>  #include <linux/types.h>
> >>> +#include <linux/workqueue.h>
> >>>  #include "xe_uc_fw_types.h"
> >>>  
> >>>  /**
> >>> @@ -53,6 +54,12 @@ struct xe_gt_sriov_vf_runtime {
> >>>   * xe_gt_sriov_vf_migration - VF migration data.
> >>>   */
> >>>  struct xe_gt_sriov_vf_migration {
> >>> +	/** @migration: VF migration recovery worker */
> >>> +	struct work_struct worker;
> >>> +	/** @lock: Protects recovery_queued */
> >>> +	spinlock_t lock;
> >>> +	/** @recovery_queued: VF post migration recovery in queued */
> >>> +	bool recovery_queued;
> >>>  	/** @recovery_inprogress: VF post migration recovery in progress */
> >>>  	bool recovery_inprogress;
> >>>  };
> >>> diff --git a/drivers/gpu/drm/xe/xe_sriov_vf.c b/drivers/gpu/drm/xe/xe_sriov_vf.c
> >>> index da064a1e7419..7d91553c4acc 100644
> >>> --- a/drivers/gpu/drm/xe/xe_sriov_vf.c
> >>> +++ b/drivers/gpu/drm/xe/xe_sriov_vf.c
> >>> @@ -6,21 +6,12 @@
> >>>  #include <drm/drm_debugfs.h>
> >>>  #include <drm/drm_managed.h>
> >>>  
> >>> -#include "xe_assert.h"
> >>> -#include "xe_device.h"
> >>>  #include "xe_gt.h"
> >>> -#include "xe_gt_sriov_printk.h"
> >>>  #include "xe_gt_sriov_vf.h"
> >>>  #include "xe_guc.h"
> >>> -#include "xe_guc_submit.h"
> >>> -#include "xe_irq.h"
> >>> -#include "xe_lrc.h"
> >>> -#include "xe_pm.h"
> >>> -#include "xe_sriov.h"
> >>>  #include "xe_sriov_printk.h"
> >>>  #include "xe_sriov_vf.h"
> >>>  #include "xe_sriov_vf_ccs.h"
> >>> -#include "xe_tile_sriov_vf.h"
> >>>  
> >>>  /**
> >>>   * DOC: VF restore procedure in PF KMD and VF KMD
> >>> @@ -158,8 +149,6 @@ static void vf_disable_migration(struct xe_device *xe, const char *fmt, ...)
> >>>  	xe->sriov.vf.migration.enabled = false;
> >>>  }
> >>>  
> >>> -static void migration_worker_func(struct work_struct *w);
> >>> -
> >>>  static void vf_migration_init_early(struct xe_device *xe)
> >>>  {
> >>>  	/*
> >>> @@ -184,8 +173,6 @@ static void vf_migration_init_early(struct xe_device *xe)
> >>>  						    guc_version.major, guc_version.minor);
> >>>  	}
> >>>  
> >>> -	INIT_WORK(&xe->sriov.vf.migration.worker, migration_worker_func);
> >>> -
> >>>  	xe->sriov.vf.migration.enabled = true;
> >>>  	xe_sriov_dbg(xe, "migration support enabled\n");
> >>>  }
> >>> @@ -200,238 +187,11 @@ void xe_sriov_vf_init_early(struct xe_device *xe)
> >>>  	unsigned int id;
> >>>  
> >>>  	for_each_gt(gt, xe, id)
> >>> -		init_rwsem(&gt->sriov.vf.self_config.lock);
> >>> +		xe_gt_sriov_vf_migration_init_early(gt);
> >>
> >> still, this should be called from gt_init_early kind of functions
> >>
> > 
> > Kinda a nit that I'm not convinced is worth while to have
> > xe_sriov_vf_init_early and then xe_gt_sriov_vf_migration_init_early
> > called in gt_init_early...
> 
> we have global xe level initialization, something like:
> 
> 	xe_device_init_early
> 		xe_sriov_vf_init_early
> 	xe_device_init
> 		xe_sriov_vf_init
> 
> then per-gt initialization, that follows the native flow, something like
> 
> 	xe_gt_init_early
> 		xe_gt_sriov_vf_init_early
> 			xe_gt_sriov_vf_migration_init_early
> 	xe_gt_init
> 		xe_gt_sriov_vf_init
> 			xe_gt_sriov_vf_migration_init
> 
> IMO we shouldn't jump in sriov code from xe level to gt level init on our own
> 

Ok, let me refactor this. Easy enough to do.

Matt

> > 
> > Matt
> > 
> >>>  
> >>>  	vf_migration_init_early(xe);
> >>>  }
> >>>  
> >>> -/**
> >>> - * vf_post_migration_shutdown - Stop the driver activities after VF migration.
> >>> - * @xe: the &xe_device struct instance
> >>> - *
> >>> - * After this VM is migrated and assigned to a new VF, it is running on a new
> >>> - * hardware, and therefore many hardware-dependent states and related structures
> >>> - * require fixups. Without fixups, the hardware cannot do any work, and therefore
> >>> - * all GPU pipelines are stalled.
> >>> - * Stop some of kernel activities to make the fixup process faster.
> >>> - */
> >>> -static void vf_post_migration_shutdown(struct xe_device *xe)
> >>> -{
> >>> -	struct xe_gt *gt;
> >>> -	unsigned int id;
> >>> -	int ret = 0;
> >>> -
> >>> -	for_each_gt(gt, xe, id) {
> >>> -		xe_guc_submit_pause(&gt->uc.guc);
> >>> -		ret |= xe_guc_submit_reset_block(&gt->uc.guc);
> >>> -	}
> >>> -
> >>> -	if (ret)
> >>> -		drm_info(&xe->drm, "migration recovery encountered ongoing reset\n");
> >>> -}
> >>> -
> >>> -/**
> >>> - * vf_post_migration_kickstart - Re-start the driver activities under new hardware.
> >>> - * @xe: the &xe_device struct instance
> >>> - *
> >>> - * After we have finished with all post-migration fixups, restart the driver
> >>> - * activities to continue feeding the GPU with workloads.
> >>> - */
> >>> -static void vf_post_migration_kickstart(struct xe_device *xe)
> >>> -{
> >>> -	struct xe_gt *gt;
> >>> -	unsigned int id;
> >>> -
> >>> -	/*
> >>> -	 * Make sure interrupts on the new HW are properly set. The GuC IRQ
> >>> -	 * must be working at this point, since the recovery did started,
> >>> -	 * but the rest was not enabled using the procedure from spec.
> >>> -	 */
> >>> -	xe_irq_resume(xe);
> >>> -
> >>> -	for_each_gt(gt, xe, id) {
> >>> -		xe_guc_submit_reset_unblock(&gt->uc.guc);
> >>> -		xe_guc_submit_unpause(&gt->uc.guc);
> >>> -	}
> >>> -}
> >>> -
> >>> -static bool gt_vf_post_migration_needed(struct xe_gt *gt)
> >>> -{
> >>> -	return test_bit(gt->info.id, &gt_to_xe(gt)->sriov.vf.migration.gt_flags);
> >>> -}
> >>> -
> >>> -/*
> >>> - * Notify GuCs marked in flags about resource fixups apply finished.
> >>> - * @xe: the &xe_device struct instance
> >>> - * @gt_flags: flags marking to which GTs the notification shall be sent
> >>> - */
> >>> -static int vf_post_migration_notify_resfix_done(struct xe_device *xe, unsigned long gt_flags)
> >>> -{
> >>> -	struct xe_gt *gt;
> >>> -	unsigned int id;
> >>> -	int err = 0;
> >>> -
> >>> -	for_each_gt(gt, xe, id) {
> >>> -		if (!test_bit(id, &gt_flags))
> >>> -			continue;
> >>> -		/* skip asking GuC for RESFIX exit if new recovery request arrived */
> >>> -		if (gt_vf_post_migration_needed(gt))
> >>> -			continue;
> >>> -		err = xe_gt_sriov_vf_notify_resfix_done(gt);
> >>> -		if (err)
> >>> -			break;
> >>> -		clear_bit(id, &gt_flags);
> >>> -	}
> >>> -
> >>> -	if (gt_flags && !err)
> >>> -		drm_dbg(&xe->drm, "another recovery imminent, skipped some notifications\n");
> >>> -	return err;
> >>> -}
> >>> -
> >>> -static int vf_get_next_migrated_gt_id(struct xe_device *xe)
> >>> -{
> >>> -	struct xe_gt *gt;
> >>> -	unsigned int id;
> >>> -
> >>> -	for_each_gt(gt, xe, id) {
> >>> -		if (test_and_clear_bit(id, &xe->sriov.vf.migration.gt_flags))
> >>> -			return id;
> >>> -	}
> >>> -	return -1;
> >>> -}
> >>> -
> >>> -static size_t post_migration_scratch_size(struct xe_device *xe)
> >>> -{
> >>> -	return max(xe_lrc_reg_size(xe), LRC_WA_BB_SIZE);
> >>> -}
> >>> -
> >>> -/**
> >>> - * Perform post-migration fixups on a single GT.
> >>> - *
> >>> - * After migration, GuC needs to be re-queried for VF configuration to check
> >>> - * if it matches previous provisioning. Most of VF provisioning shall be the
> >>> - * same, except GGTT range, since GGTT is not virtualized per-VF. If GGTT
> >>> - * range has changed, we have to perform fixups - shift all GGTT references
> >>> - * used anywhere within the driver. After the fixups in this function succeed,
> >>> - * it is allowed to ask the GuC bound to this GT to continue normal operation.
> >>> - *
> >>> - * Returns: 0 if the operation completed successfully, or a negative error
> >>> - * code otherwise.
> >>> - */
> >>> -static int gt_vf_post_migration_fixups(struct xe_gt *gt)
> >>> -{
> >>> -	s64 shift;
> >>> -	void *buf;
> >>> -	int err;
> >>> -
> >>> -	buf = kmalloc(post_migration_scratch_size(gt_to_xe(gt)), GFP_KERNEL);
> >>> -	if (!buf)
> >>> -		return -ENOMEM;
> >>> -
> >>> -	err = xe_gt_sriov_vf_query_config(gt);
> >>> -	if (err)
> >>> -		goto out;
> >>> -
> >>> -	shift = xe_gt_sriov_vf_ggtt_shift(gt);
> >>> -	if (shift) {
> >>> -		xe_tile_sriov_vf_fixup_ggtt_nodes(gt_to_tile(gt), shift);
> >>> -		xe_gt_sriov_vf_default_lrcs_hwsp_rebase(gt);
> >>> -		err = xe_guc_contexts_hwsp_rebase(&gt->uc.guc, buf);
> >>> -		if (err)
> >>> -			goto out;
> >>> -	}
> >>> -
> >>> -out:
> >>> -	kfree(buf);
> >>> -	return err;
> >>> -}
> >>> -
> >>> -static void vf_post_migration_recovery(struct xe_device *xe)
> >>> -{
> >>> -	unsigned long fixed_gts = 0;
> >>> -	int id, err;
> >>> -
> >>> -	drm_dbg(&xe->drm, "migration recovery in progress\n");
> >>> -	xe_pm_runtime_get(xe);
> >>> -	vf_post_migration_shutdown(xe);
> >>> -
> >>> -	if (!xe_sriov_vf_migration_supported(xe)) {
> >>> -		xe_sriov_err(xe, "migration is not supported\n");
> >>> -		err = -ENOTRECOVERABLE;
> >>> -		goto fail;
> >>> -	}
> >>> -
> >>> -	while (id = vf_get_next_migrated_gt_id(xe), id >= 0) {
> >>> -		struct xe_gt *gt = xe_device_get_gt(xe, id);
> >>> -
> >>> -		err = gt_vf_post_migration_fixups(gt);
> >>> -		if (err)
> >>> -			goto fail;
> >>> -
> >>> -		set_bit(id, &fixed_gts);
> >>> -	}
> >>> -
> >>> -	vf_post_migration_kickstart(xe);
> >>> -	err = vf_post_migration_notify_resfix_done(xe, fixed_gts);
> >>> -	if (err)
> >>> -		goto fail;
> >>> -
> >>> -	xe_pm_runtime_put(xe);
> >>> -	drm_notice(&xe->drm, "migration recovery ended\n");
> >>> -	return;
> >>> -fail:
> >>> -	xe_pm_runtime_put(xe);
> >>> -	drm_err(&xe->drm, "migration recovery failed (%pe)\n", ERR_PTR(err));
> >>> -	xe_device_declare_wedged(xe);
> >>> -}
> >>> -
> >>> -static void migration_worker_func(struct work_struct *w)
> >>> -{
> >>> -	struct xe_device *xe = container_of(w, struct xe_device,
> >>> -					    sriov.vf.migration.worker);
> >>> -
> >>> -	vf_post_migration_recovery(xe);
> >>> -}
> >>> -
> >>> -/*
> >>> - * Check if post-restore recovery is coming on any of GTs.
> >>> - * @xe: the &xe_device struct instance
> >>> - *
> >>> - * Return: True if migration recovery worker will soon be running. Any worker currently
> >>> - * executing does not affect the result.
> >>> - */
> >>> -static bool vf_ready_to_recovery_on_any_gts(struct xe_device *xe)
> >>> -{
> >>> -	struct xe_gt *gt;
> >>> -	unsigned int id;
> >>> -
> >>> -	for_each_gt(gt, xe, id) {
> >>> -		if (test_bit(id, &xe->sriov.vf.migration.gt_flags))
> >>> -			return true;
> >>> -	}
> >>> -	return false;
> >>> -}
> >>> -
> >>> -/**
> >>> - * xe_sriov_vf_start_migration_recovery - Start VF migration recovery.
> >>> - * @xe: the &xe_device to start recovery on
> >>> - *
> >>> - * This function shall be called only by VF.
> >>> - */
> >>> -void xe_sriov_vf_start_migration_recovery(struct xe_device *xe)
> >>> -{
> >>> -	bool started;
> >>> -
> >>> -	xe_assert(xe, IS_SRIOV_VF(xe));
> >>> -
> >>> -	if (!vf_ready_to_recovery_on_any_gts(xe))
> >>> -		return;
> >>> -
> >>> -	started = queue_work(xe->sriov.wq, &xe->sriov.vf.migration.worker);
> >>> -	drm_info(&xe->drm, "VF migration recovery %s\n", started ?
> >>> -		 "scheduled" : "already in progress");
> >>> -}
> >>> -
> >>>  /**
> >>>   * xe_sriov_vf_init_late() - SR-IOV VF late initialization functions.
> >>>   * @xe: the &xe_device to initialize
> >>> diff --git a/drivers/gpu/drm/xe/xe_sriov_vf.h b/drivers/gpu/drm/xe/xe_sriov_vf.h
> >>> index 9e752105ec2a..4df95266b261 100644
> >>> --- a/drivers/gpu/drm/xe/xe_sriov_vf.h
> >>> +++ b/drivers/gpu/drm/xe/xe_sriov_vf.h
> >>> @@ -13,7 +13,6 @@ struct xe_device;
> >>>  
> >>>  void xe_sriov_vf_init_early(struct xe_device *xe);
> >>>  int xe_sriov_vf_init_late(struct xe_device *xe);
> >>> -void xe_sriov_vf_start_migration_recovery(struct xe_device *xe);
> >>>  bool xe_sriov_vf_migration_supported(struct xe_device *xe);
> >>>  void xe_sriov_vf_debugfs_register(struct xe_device *xe, struct dentry *root);
> >>>  
> >>> diff --git a/drivers/gpu/drm/xe/xe_sriov_vf_types.h b/drivers/gpu/drm/xe/xe_sriov_vf_types.h
> >>> index 426cc5841958..6a0fd0f5463e 100644
> >>> --- a/drivers/gpu/drm/xe/xe_sriov_vf_types.h
> >>> +++ b/drivers/gpu/drm/xe/xe_sriov_vf_types.h
> >>> @@ -33,10 +33,6 @@ struct xe_device_vf {
> >>>  
> >>>  	/** @migration: VF Migration state data */
> >>>  	struct {
> >>> -		/** @migration.worker: VF migration recovery worker */
> >>> -		struct work_struct worker;
> >>> -		/** @migration.gt_flags: Per-GT request flags for VF migration recovery */
> >>> -		unsigned long gt_flags;
> >>>  		/**
> >>>  		 * @migration.enabled: flag indicating if migration support
> >>>  		 * was enabled or not due to missing prerequisites
> >>
>