Introduce xe_wedge
Subsystems (4)
v2 cover Introduce xe_wedge
In the history of xe technical debt, this series takes one more step and consolidates all wedging implementation into a dedicated xe_wedge component.
While at it, this fixes a few pre-existing issues related to wedge handling. Detailed description in commit message.
v1: https://patchwork.freedesktop.org/series/172727/
v2: Split fixes into separate patches (Rodrigo, Michal)
Also move struct xe_wedge and wedged_mode debt to xe_wedge (Lukasz, Michal) Naming and aesthetic adjustments (Lukasz, Michal)
Raag Jadav (5):
drm/xe/gt: Use GT ordered workqueue for wedging drm/xe: Make xe_device_declare_wedged() IRQ safe drm/xe: Introduce xe_wedge
drm/xe/debugfs: Consolidate wedged_mode debt into xe_wedge drm/xe/wedge: Update naming to match with xe_wedge
Documentation/gpu/xe/xe_device.rst | 2 +- drivers/gpu/drm/xe/Makefile | 1 + drivers/gpu/drm/xe/tests/xe_kunit_helpers.c | 2 +- drivers/gpu/drm/xe/xe_amc.c | 2 +- drivers/gpu/drm/xe/xe_bo.c | 2 +- drivers/gpu/drm/xe/xe_debugfs.c | 65 +---- drivers/gpu/drm/xe/xe_device.c | 178 +----------- drivers/gpu/drm/xe/xe_device.h | 11 +- drivers/gpu/drm/xe/xe_device_types.h | 28 +- drivers/gpu/drm/xe/xe_gsc.c | 2 +- drivers/gpu/drm/xe/xe_gt.c | 23 +- drivers/gpu/drm/xe/xe_gt.h | 2 +- drivers/gpu/drm/xe/xe_gt_sriov_vf.c | 2 +- drivers/gpu/drm/xe/xe_gt_types.h | 9 + drivers/gpu/drm/xe/xe_guc.c | 4 +- drivers/gpu/drm/xe/xe_guc.h | 2 +- drivers/gpu/drm/xe/xe_guc_ct.c | 6 +- drivers/gpu/drm/xe/xe_guc_rc.c | 4 +- drivers/gpu/drm/xe/xe_guc_submit.c | 12 +- drivers/gpu/drm/xe/xe_guc_tlb_inval.c | 2 +- drivers/gpu/drm/xe/xe_mert.c | 4 +- drivers/gpu/drm/xe/xe_pci_error.c | 8 +- drivers/gpu/drm/xe/xe_ras.c | 4 +- drivers/gpu/drm/xe/xe_sriov_pf.c | 2 +- drivers/gpu/drm/xe/xe_survivability_mode.c | 4 +- drivers/gpu/drm/xe/xe_uc.c | 6 +- drivers/gpu/drm/xe/xe_uc.h | 2 +- drivers/gpu/drm/xe/xe_wedge.c | 288 ++++++++++++++++++++ drivers/gpu/drm/xe/xe_wedge.h | 21 ++ drivers/gpu/drm/xe/xe_wedge_types.h | 45 +++ 30 files changed, 428 insertions(+), 315 deletions(-) create mode 100644 drivers/gpu/drm/xe/xe_wedge.c create mode 100644 drivers/gpu/drm/xe/xe_wedge.h create mode 100644 drivers/gpu/drm/xe/xe_wedge_types.h
Signature · 1 line
2.43.0
PATCH v2 1/5 drm/xe/gt: Use GT ordered workqueue for wedging
Currently, xe_gt_declare_wedged() stops GuC CT and initiates exec queue teardown synchronously. This is problematic in cases where the jobs are still in-flight when the device is declated wedged.
Introduce a worker for GT specific wedge handling and queue the teardown on GT ordered workqueue, so we don't disrupt the scheduler while jobs are still in-flight.
--- drivers/gpu/drm/xe/xe_gt.c | 15 +++++++++++++-- drivers/gpu/drm/xe/xe_gt_types.h | 9 +++++++++ 2 files changed, 22 insertions(+), 2 deletions(-)
drivers/gpu/drm/xe/xe_gt.c +13 -2
@@ -173,6 +173,7 @@ static void xe_gt_enable_comp_1wcoh(struct xe_gt *gt) }static void gt_reset_worker (struct work_struct *w); +static void gt_wedge_worker (struct work_struct *w);static int emit_job_sync (struct xe_exec_queue *q,struct xe_bb *bb,long timeout_jiffies,bool force_reset)
@@ -704,6 +705,8 @@ static void xe_gt_fini(void *arg)struct xe_gt *gt = arg;int i; +disable_work_sync (>->wedge.worker); +if (disable_work_sync (>->reset.worker))/* * If gt_reset_worker was halted from executing, take care of
@@ -723,6 +726,7 @@ int xe_gt_init(struct xe_gt *gt)int i;INIT_WORK (>->reset.worker, gt_reset_worker); +INIT_WORK (>->wedge.worker, gt_wedge_worker);for (i =0 ; i <XE_ENGINE_CLASS_MAX ; ++i) { gt->ring_ops[i] =xe_ring_ops_get (gt, i);
@@ -1005,6 +1009,14 @@ void xe_gt_reset_async(struct xe_gt *gt)xe_pm_runtime_put (xe); } +static void gt_wedge_worker (struct work_struct *w) +{ +struct xe_gt *gt =container_of (w,typeof (*gt), wedge.worker); + +xe_uc_declare_wedged (>->uc); +xe_tlb_inval_reset (>->tlb_inval); +} +void xe_gt_suspend_prepare (struct xe_gt *gt) {xe_uc_suspend_prepare (>->uc);
@@ -1195,6 +1207,5 @@ void xe_gt_declare_wedged(struct xe_gt *gt) {xe_gt_assert (gt,gt_to_xe (gt)->wedged.mode); -xe_uc_declare_wedged (>->uc); -xe_tlb_inval_reset (>->tlb_inval); +queue_work (gt->ordered_wq, >->wedge.worker); }
drivers/gpu/drm/xe/xe_gt_types.h +9 -0
@@ -233,6 +233,15 @@ struct xe_gt {struct work_struct worker; } reset; +/** @wedge: state for GT wedge */ +struct { +/** +* @wedge.worker: work so GT wedge to be done async allowing the wedge +* code to safely flush all code paths +*/ +struct work_struct worker; + } wedge; +/** @tlb_inval: TLB invalidation state */ struct xe_tlb_inval tlb_inval;
Signature · 1 line
2.43.0
PATCH v2 2/5 drm/xe: Make xe_device_declare_wedged() IRQ safe
In reply to Raag JadavCurrently, xe_device_declare_wedged() implementation wedges the GTs and sends wedged uevent to userspace. This is problematic for usecases which require declaring the device as wedged in IRQ context, as it allocates memory for event buffer and acquires mutexes deep into it's call path.
Fix this by deferring wedge handling into its dedicated worker, so that xe_device_declare_wedged() can be called in IRQ context.
First user of this requirement is introduced in commit def675cf3f10 ("drm/xe/mert: Improve handling of MERT CAT errors"), which declares the device as wedged on catastrophic errors received in form of an IRQ.
--- drivers/gpu/drm/xe/xe_device.c | 54 ++++++++++++++++++---------- drivers/gpu/drm/xe/xe_device_types.h | 2 ++ 2 files changed, 37 insertions(+), 19 deletions(-)
drivers/gpu/drm/xe/xe_device.c +35 -19
@@ -924,14 +924,25 @@ static void detect_preproduction_hw(struct xe_device *xe) } } +static void wedged_work (struct work_struct *work); +static void xe_device_wedged_fini (struct drm_device *drm,void *arg) {struct xe_device *xe = arg; +disable_work_sync (&xe->wedged.work); +if (atomic_read (&xe->wedged.flag))xe_pm_runtime_put (xe); } +static int xe_device_wedged_init (struct xe_device *xe) +{ +INIT_WORK (&xe->wedged.work, wedged_work); + +return drmm_add_action_or_reset (&xe->drm, xe_device_wedged_fini, xe); +} +#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE static int xe_debug_page_size_alloc_ctrl_init (struct xe_device *xe) {
@@ -1148,7 +1159,7 @@ int xe_device_probe(struct xe_device *xe)detect_preproduction_hw (xe); - err =drmm_add_action_or_reset (&xe->drm, xe_device_wedged_fini, xe); + err =xe_device_wedged_init (xe);if (err) goto err_unregister_display;
@@ -1443,6 +1454,26 @@ void xe_device_set_wedged_method(struct xe_device *xe, unsigned long method) xe->wedged.method = method; } +static void wedged_work (struct work_struct *work) +{ + struct xe_device *xe = container_of(work, struct xe_device, wedged.work); + +/* +* XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging +* hangs, so wedge the device with 'none' recovery method and have +* it available to the user for debugging. +*/ +if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) +xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_NONE ); +/* If no wedge recovery method is set, use default */ +else if (!xe->wedged.method) +xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_REBIND | +DRM_WEDGE_RECOVERY_BUS_RESET ); + +/* Notify userspace of wedged device */ +drm_dev_wedged_event (&xe->drm, xe->wedged.method,NULL ); +} +#define WEDGED_URL "https://docs.kernel.org/gpu/drm-uapi.html#device-wedging"#define XE_BUG_URL "https://gitlab.freedesktop.org/drm/xe/kernel/issues/new"
@@ -1483,26 +1514,11 @@ void xe_device_declare_wedged(struct xe_device *xe)"For recovery procedure, refer to %s\n" "Please file a _new_ bug report at %s\n" , WEDGED_URL, XE_BUG_URL); - } -for_each_gt (gt, xe, id) -xe_gt_declare_wedged (gt); +for_each_gt (gt, xe, id) +xe_gt_declare_wedged (gt); -if (xe_device_wedged (xe)) { -/* -* XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging -* hangs, so wedge the device with 'none' recovery method and have -* it available to the user for debugging. -*/ -if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_NONE ); -/* If no wedge recovery method is set, use default */ -else if (!xe->wedged.method) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_REBIND | -DRM_WEDGE_RECOVERY_BUS_RESET ); - -/* Notify userspace of wedged device */ -drm_dev_wedged_event (&xe->drm, xe->wedged.method,NULL ); +schedule_work (&xe->wedged.work); } }
drivers/gpu/drm/xe/xe_device_types.h +2 -0
@@ -534,6 +534,8 @@ struct xe_device {unsigned long method;/** @wedged.inconsistent_reset: Inconsistent reset policy state between GTs */ bool inconsistent_reset; +/** @wedged.work: Worker for wedge handling */ +struct work_struct work; } wedged;/** @devres_group: devres group */
Signature · 1 line
2.43.0
[email protected]
AI reviewRe: [PATCH v2 2/5] drm/xe: Make xe_device_declare_wedged() IRQ safe
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Uninitialized work_struct leads to list corruption and kernel panic if an IRQ triggers during…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Uninitialized work_struct leads to list corruption and kernel panic if an IRQ triggers during device probe. --
commit 7cfc61b6d67f6291a4e51db20047caa91bfb3397
Author: Raag Jadav <[email protected]>
drm/xe: Make xe_device_declare_wedged() IRQ safe
This commit defers wedge handling into a dedicated worker so that xe_device_declare_wedged() can be called in IRQ context. This is required for declaring the device as wedged on catastrophic errors received via IRQs.
Quoted 4 lines
drivers/gpu/drm/xe/xe_device.c +0
-0
[ ... ]
drivers/gpu/drm/xe/xe_device.c int xe_device_probe(struct xe_device *xe) · line 1162
Quoted 6 lines
drivers/gpu/drm/xe/xe_device.c +1
-1@@ -1148,7 +1159,7 @@ int xe_device_probe(struct xe_device *xe)detect_preproduction_hw (xe); - err =drmm_add_action_or_reset (&xe->drm, xe_device_wedged_fini, xe); + err =xe_device_wedged_init (xe);
[Severity: High]
Does this initialize the work_struct too late in the probe sequence?
If a hardware error interrupt (like a MERT CAT error) fires during the window after interrupts are enabled (via xe_irq_install() called earlier in xe_device_probe()) but before this initialization completes, the interrupt handler will call xe_device_declare_wedged().
This would attempt to schedule the uninitialized xe->wedged.work structure, potentially leading to list corruption and a kernel panic in the workqueue core.
Quoted 2 lines
drivers/gpu/drm/xe/xe_device.c +0
-0if (err) goto err_unregister_display;
[ ... ]
Quoted 14 lines
drivers/gpu/drm/xe/xe_device.c +0
-8@@ -1483,26 +1514,11 @@ void xe_device_declare_wedged(struct xe_device *xe)"For recovery procedure, refer to %s\n" "Please file a _new_ bug report at %s\n" , WEDGED_URL, XE_BUG_URL); -for_each_gt (gt, xe, id) -xe_gt_declare_wedged (gt); -if (xe_device_wedged (xe)) { -/* -* XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging -* hangs, so wedge the device with 'none' recovery method and have -* it available to the user for debugging. -*/
drivers/gpu/drm/xe/xe_device.c void xe_device_declare_wedged(struct xe_device *xe) · line 1519
Quoted 10 lines
drivers/gpu/drm/xe/xe_device.c +1
-9-if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_NONE ); -/* If no wedge recovery method is set, use default */ -else if (!xe->wedged.method) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_REBIND | -DRM_WEDGE_RECOVERY_BUS_RESET ); - -/* Notify userspace of wedged device */ -drm_dev_wedged_event (&xe->drm, xe->wedged.method,NULL ); +schedule_work (&xe->wedged.work);
[Severity: High]
Could this schedule an uninitialized work_struct?
If xe_device_declare_wedged() is invoked from an early interrupt handler before xe_device_wedged_init() completes, this will attempt to queue xe->wedged.work.
Additionally, the loop right before this calls xe_gt_declare_wedged(gt), which could queue an uninitialized gt->wedge.worker if xe_gt_init() hasn't completed for that GT yet.
Quoted 2 lines
drivers/gpu/drm/xe/xe_device.c +0
-0} }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
PATCH v2 3/5 drm/xe: Introduce xe_wedge
In reply to Raag JadavConsolidate wedging implementation into a dedicated xe_wedge component for better maintainability.
No functional impact.
--- Documentation/gpu/xe/xe_device.rst | 2 +- drivers/gpu/drm/xe/Makefile | 1 + drivers/gpu/drm/xe/xe_device.c | 186 +----------------------- drivers/gpu/drm/xe/xe_device.h | 11 +- drivers/gpu/drm/xe/xe_wedge.c | 219 +++++++++++++++++++++++++++++ drivers/gpu/drm/xe/xe_wedge.h | 20 +++ 6 files changed, 243 insertions(+), 196 deletions(-) create mode 100644 drivers/gpu/drm/xe/xe_wedge.c create mode 100644 drivers/gpu/drm/xe/xe_wedge.h
Documentation/gpu/xe/xe_device.rst +1 -1
@@ -6,7 +6,7 @@ Xe Device Wedging ================== -.. kernel-doc:: drivers/gpu/drm/xe/xe_device.c +.. kernel-doc:: drivers/gpu/drm/xe/xe_wedge.c :doc: Xe Device Wedging ====================
drivers/gpu/drm/xe/Makefile +1 -0
@@ -152,6 +152,7 @@ xe-y += xe_bb.o \ xe_vsec.o \ xe_wa.o \ xe_wait_user_fence.o \ + xe_wedge.o \ xe_wopcm.o xe-$(CONFIG_I2C) += xe_i2c.o \
drivers/gpu/drm/xe/xe_device.c +1 -185
204 lines not on this page · raw message
drivers/gpu/drm/xe/xe_device.h +1 -10
@@ -11,6 +11,7 @@#include "xe_device_types.h" #include "xe_gt_types.h" #include "xe_sriov.h" +#include "xe_wedge.h" struct xe_vm ;
@@ -207,11 +208,6 @@ bool xe_device_is_l2_flush_optimized(struct xe_device *xe);void xe_device_td_flush (struct xe_device *xe);void xe_device_l2_flush (struct xe_device *xe); -static inline bool xe_device_wedged (struct xe_device *xe) -{ -return atomic_read (&xe->wedged.flag); -} -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE static inline bool xe_debug_page_size_supported (struct xe_device *xe) {
@@ -260,11 +256,6 @@ static inline bool xe_debug_page_size_mode_is_mixed(struct xe_device *xe) }#endif -void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); -void xe_device_declare_wedged (struct xe_device *xe); -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode); -const char *xe_wedged_mode_to_string (enum xe_wedged_mode mode); -struct xe_file *xe_file_get (struct xe_file *xef);void xe_file_put (struct xe_file *xef);
drivers/gpu/drm/xe/xe_wedge.c new file +219 -0
219 lines not on this page · raw message
drivers/gpu/drm/xe/xe_wedge.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2026 Intel Corporation +*/ + +#ifndef _XE_WEDGE_H_ +#define _XE_WEDGE_H_ + +#include <linux/types.h> + +struct xe_device ; + +void xe_device_declare_wedged (struct xe_device *xe); +bool xe_device_wedged (struct xe_device *xe); +void xe_device_wedged_init_early (struct xe_device *xe); +int xe_device_wedged_init (struct xe_device *xe); +int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode); +void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); + +#endif
Signature · 1 line
2.43.0
Rodrigo Vivi
maintainerRe: [PATCH v2 3/5] drm/xe: Introduce xe_wedge
Quoted 258 lines · Raag Jadav
Consolidate wedging implementation into a dedicated
xe_wedgecomponent for better maintainability.No functional impact.
Signed-off-by Raag Jadav <[email protected]>--- Documentation/gpu/xe/xe_device.rst | 2 +- drivers/gpu/drm/xe/Makefile | 1 + drivers/gpu/drm/xe/xe_device.c | 186 +----------------------- drivers/gpu/drm/xe/xe_device.h | 11 +- drivers/gpu/drm/xe/xe_wedge.c | 219 +++++++++++++++++++++++++++++ drivers/gpu/drm/xe/xe_wedge.h | 20 +++ 6 files changed, 243 insertions(+), 196 deletions(-) create mode 100644 drivers/gpu/drm/xe/xe_wedge.c create mode 100644 drivers/gpu/drm/xe/xe_wedge.hDocumentation/gpu/xe/xe_device.rst +1
-1@@ -6,7 +6,7 @@ Xe Device Wedging ================== -.. kernel-doc:: drivers/gpu/drm/xe/xe_device.c +.. kernel-doc:: drivers/gpu/drm/xe/xe_wedge.c :doc: Xe Device Wedging ====================drivers/gpu/drm/xe/Makefile +1
-0@@ -152,6 +152,7 @@ xe-y += xe_bb.o \ xe_vsec.o \ xe_wa.o \ xe_wait_user_fence.o \ + xe_wedge.o \ xe_wopcm.o xe-$(CONFIG_I2C) += xe_i2c.o \drivers/gpu/drm/xe/xe_device.c +1
-185@@ -829,10 +829,7 @@ int xe_device_probe_early(struct xe_device *xe)*/ assert_lmem_ready (xe); - xe->wedged.mode =xe_device_validate_wedged_mode (xe, xe_modparam.wedged_mode) ? -XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode; -drm_dbg (&xe->drm,"wedged_mode: setting mode (%u) %s\n" , - xe->wedged.mode,xe_wedged_mode_to_string (xe->wedged.mode)); +xe_device_wedged_init_early (xe); err =xe_device_vram_alloc (xe);if (err)@@ -924,25 +921,6 @@ static void detect_preproduction_hw(struct xe_device *xe) } } -static void wedged_work (struct work_struct *work); - -static void xe_device_wedged_fini (struct drm_device *drm,void *arg) -{ -struct xe_device *xe = arg; - -disable_work_sync (&xe->wedged.work); - -if (atomic_read (&xe->wedged.flag)) -xe_pm_runtime_put (xe); -} - -static int xe_device_wedged_init (struct xe_device *xe) -{ -INIT_WORK (&xe->wedged.work, wedged_work); - -return drmm_add_action_or_reset (&xe->drm, xe_device_wedged_fini, xe); -} -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE static int xe_debug_page_size_alloc_ctrl_init (struct xe_device *xe) {@@ -1405,168 +1383,6 @@ u64 xe_device_uncanonicalize_addr(struct xe_device *xe, u64 address)return address &GENMASK_ULL (xe->info.va_bits -1 ,0 ); } -/** -* DOC: Xe Device Wedging -* -* Xe driver uses drm device wedged uevent as documented in Documentation/gpu/drm-uapi.rst. -* When device is in wedged state, every IOCTL will be blocked and GT cannot -* be used. The conditions under which the driver declares the device wedged -* depend on the wedged mode configuration (see &enum xe_wedged_mode). The -* default recovery method for a wedged state is rebind/bus-reset. -* -* Another recovery method is vendor-specific. Below are the cases that send -* ``WEDGED=vendor-specific`` recovery method in drm device wedged uevent. -* -* Case: Firmware Flash -* -------------------- -* -* Identification Hint -* +++++++++++++++++++ -* -* ``WEDGED=vendor-specific`` drm device wedged uevent with -* :ref:`Runtime Survivability mode <xe-survivability-mode>` is used to notify -* admin/userspace consumer about the need for a firmware flash. -* -* Recovery Procedure -* ++++++++++++++++++ -* -* Once ``WEDGED=vendor-specific`` drm device wedged uevent is received, follow -* the below steps -* -* - Check Runtime Survivability mode sysfs. -* If enabled, firmware flash is required to recover the device. -* -* /sys/bus/pci/devices/<device>/survivability_mode -* -* - Admin/userspace consumer can use firmware flashing tools like fwupd to flash -* firmware and restore device to normal operation. -*/ - -/** -* xe_device_set_wedged_method - Set wedged recovery method -* @xe: xe device instance -* @method: recovery method to set -* -* Set wedged recovery method to be sent in drm wedged uevent. -*/ -void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method) -{ - xe->wedged.method = method; -} - -static void wedged_work (struct work_struct *work) -{ - struct xe_device *xe = container_of(work, struct xe_device, wedged.work); - -/* -* XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging -* hangs, so wedge the device with 'none' recovery method and have -* it available to the user for debugging. -*/ -if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_NONE ); -/* If no wedge recovery method is set, use default */ -else if (!xe->wedged.method) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_REBIND | -DRM_WEDGE_RECOVERY_BUS_RESET ); - -/* Notify userspace of wedged device */ -drm_dev_wedged_event (&xe->drm, xe->wedged.method,NULL ); -} - -#define WEDGED_URL "https://docs.kernel.org/gpu/drm-uapi.html#device-wedging" -#define XE_BUG_URL "https://gitlab.freedesktop.org/drm/xe/kernel/issues/new" - -/** -* xe_device_declare_wedged - Declare device wedged -* @xe: xe device instance -* -* This is a final state that can only be cleared with the recovery method -* specified in the drm wedged uevent. The method can be set using -* xe_device_set_wedged_method before declaring the device as wedged. If no method -* is set, reprobe (unbind/re-bind) will be sent by default. -* -* In this state every IOCTL will be blocked so the GT cannot be used. -* In general it will be called upon any critical error such as gt reset -* failure or guc loading failure. Userspace will be notified of this state -* through device wedged uevent. -* If xe.wedged module parameter is set to 2, this function will be called -* on every single execution timeout (a.k.a. GPU hang) right after devcoredump -* snapshot capture. In this mode, GT reset won't be attempted so the state of -* the issue is preserved for further debugging. -*/ -void xe_device_declare_wedged (struct xe_device *xe) -{ -struct xe_gt *gt; -u8 id; - -if (xe->wedged.mode ==XE_WEDGED_MODE_NEVER ) { -drm_dbg (&xe->drm,"Wedged mode is forcibly disabled\n" ); -return ; - } - -if (!atomic_xchg (&xe->wedged.flag,1 )) { - xe->needs_flr_on_fini = true; -xe_pm_runtime_get_noresume (xe); - -xe_log_err_fatal (xe,WEDGED , -EIO ,"Device declared wedged!\n" ); -xe_err_once (xe,"IOCTLs and executions are now blocked!\n" -"For recovery procedure, refer to %s\n" -"Please file a _new_ bug report at %s\n" , -WEDGED_URL ,XE_BUG_URL ); - -for_each_gt (gt, xe, id) -xe_gt_declare_wedged (gt); - -schedule_work (&xe->wedged.work); - } -} - -/** -* xe_device_validate_wedged_mode - Check if given mode is supported -* @xe: the &xe_device -* @mode: requested mode to validate -* -* Check whether the provided wedged mode is supported. -* -* Return: 0 if mode is supported, error code otherwise. -*/ -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode) -{ -if (mode >XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) { -drm_dbg (&xe->drm,"wedged_mode: invalid value (%u)\n" , mode); -return -EINVAL ; - }else if (mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET && (IS_SRIOV_VF (xe) || - (IS_SRIOV_PF (xe) && !IS_ENABLED (CONFIG_DRM_XE_DEBUG )))) { -drm_dbg (&xe->drm,"wedged_mode: (%u) %s mode is not supported for %s\n" , - mode,xe_wedged_mode_to_string (mode), -xe_sriov_mode_to_string (xe_device_sriov_mode (xe))); -return -EPERM ; - } - -return 0 ; -} - -/** -* xe_wedged_mode_to_string - Convert enum value to string. -* @mode: the &xe_wedged_mode to convert -* -* Returns: wedged mode as a user friendly string. -*/ -const char *xe_wedged_mode_to_string (enum xe_wedged_mode mode) -{ -switch (mode) { -case XE_WEDGED_MODE_NEVER : -return "never" ; -case XE_WEDGED_MODE_UPON_CRITICAL_ERROR : -return "upon-critical-error" ; -case XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET : -return "upon-any-hang-no-reset" ; -default : -return "<invalid>" ; - } -} -/** * xe_device_asid_to_vm() - Find VM from ASID * @xe: the &xe_device drivers/gpu/drm/xe/xe_device.h +0
-0
drivers/gpu/drm/xe/xe_device.h line 14
Quoted 4 lines
drivers/gpu/drm/xe/xe_device.h +1
-0@@ -11,6 +11,7 @@#include "xe_device_types.h" #include "xe_gt_types.h" #include "xe_sriov.h" +#include "xe_wedge.h"
We should avoid chained .h includes._types.h are okay... I don't know what this sriov is doing here :/
Could you please remove the this xe_wedge.h include and move that to the individual users?
Quoted 266 lines
drivers/gpu/drm/xe/xe_device.h +0
-10struct xe_vm ;@@ -207,11 +208,6 @@ bool xe_device_is_l2_flush_optimized(struct xe_device *xe);void xe_device_td_flush (struct xe_device *xe);void xe_device_l2_flush (struct xe_device *xe); -static inline bool xe_device_wedged (struct xe_device *xe) -{ -return atomic_read (&xe->wedged.flag); -} -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE static inline bool xe_debug_page_size_supported (struct xe_device *xe) {@@ -260,11 +256,6 @@ static inline bool xe_debug_page_size_mode_is_mixed(struct xe_device *xe) }#endif -void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); -void xe_device_declare_wedged (struct xe_device *xe); -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode); -const char *xe_wedged_mode_to_string (enum xe_wedged_mode mode); -struct xe_file *xe_file_get (struct xe_file *xef);void xe_file_put (struct xe_file *xef);drivers/gpu/drm/xe/xe_wedge.c new file +219
-0@@ -0,0 +1,219 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2026 Intel Corporation +*/ + +#include <drm/drm_drv.h> +#include <drm/drm_managed.h> + +#include "xe_defaults.h" +#include "xe_device_types.h" +#include "xe_gt.h" +#include "xe_log.h" +#include "xe_module.h" +#include "xe_pm.h" +#include "xe_printk.h" + +/** +* DOC: Xe Device Wedging +* +* Xe driver uses drm device wedged uevent as documented in Documentation/gpu/drm-uapi.rst. +* When device is in wedged state, every IOCTL will be blocked and GT cannot +* be used. The conditions under which the driver declares the device wedged +* depend on the wedge mode configuration (see &enum xe_wedged_mode). The +* default recovery method for a wedged state is rebind/bus-reset. +* +* Another recovery method is vendor-specific. Below are the cases that send +* ``WEDGED=vendor-specific`` recovery method in drm device wedged uevent. +* +* Case: Firmware Flash +* -------------------- +* +* Identification Hint +* +++++++++++++++++++ +* +* ``WEDGED=vendor-specific`` drm device wedged uevent with +* :ref:`Runtime Survivability mode <xe-survivability-mode>` is used to notify +* admin/userspace consumer about the need for a firmware flash. +* +* Recovery Procedure +* ++++++++++++++++++ +* +* Once ``WEDGED=vendor-specific`` drm device wedged uevent is received, follow +* the below steps +* +* - Check Runtime Survivability mode sysfs. +* If enabled, firmware flash is required to recover the device. +* +* /sys/bus/pci/devices/<device>/survivability_mode +* +* - Admin/userspace consumer can use firmware flashing tools like fwupd to flash +* firmware and restore device to normal operation. +*/ + +/** +* xe_device_set_wedged_method() - Set wedge recovery method +* @xe: xe device instance +* @method: recovery method to set +* +* Set wedge recovery method to be sent in drm wedged uevent. +*/ +void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method) +{ + xe->wedged.method = method; +} + +/** +* xe_device_wedged() - Check for wedged device +* @xe: xe device instance +* +* Returns: %true if device is wedged, %false otherwise. +*/ +bool xe_device_wedged (struct xe_device *xe) +{ +return atomic_read (&xe->wedged.flag); +} + +static void wedge_work (struct work_struct *work) +{ + struct xe_device *xe = container_of(work, struct xe_device, wedged.work); + +/* +* XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET is intended for debugging +* hangs, so wedge the device with 'none' recovery method and have +* it available to the user for debugging. +*/ +if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) +xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_NONE ); +/* If no wedge recovery method is set, use default */ +else if (!xe->wedged.method) +xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_REBIND | +DRM_WEDGE_RECOVERY_BUS_RESET ); + +/* Notify userspace of wedged device */ +drm_dev_wedged_event (&xe->drm, xe->wedged.method,NULL ); +} + +#define WEDGED_URL "https://docs.kernel.org/gpu/drm-uapi.html#device-wedging" +#define XE_BUG_URL "https://gitlab.freedesktop.org/drm/xe/kernel/issues/new" + +/** +* xe_device_declare_wedged() - Declare device wedged +* @xe: xe device instance +* +* This is a final state that can only be cleared with the recovery method +* specified in the drm wedged uevent. The method can be set using +* xe_device_set_wedged_method() before declaring the device as wedged. +* If no method is set, rebind/bus-reset will be sent by default. +* +* In this state every IOCTL will be blocked so the GT cannot be used. +* In general it will be called upon any critical error such as gt reset +* failure or guc loading failure. Userspace will be notified of this state +* through device wedged uevent. +* If xe.wedged module parameter is set to 2, this function will be called +* on every single execution timeout (a.k.a. GPU hang) right after devcoredump +* snapshot capture. In this mode, GT reset won't be attempted so the state of +* the issue is preserved for further debugging. +* +* Since the wedge handling is done as part of worker thread, this is safe for +* atomic callers. +*/ +void xe_device_declare_wedged (struct xe_device *xe) +{ +struct xe_gt *gt; +u8 id; + +if (xe->wedged.mode ==XE_WEDGED_MODE_NEVER ) { +xe_dbg (xe,"Wedged mode is forcibly disabled\n" ); +return ; + } + +if (atomic_xchg (&xe->wedged.flag,1 )) +return ; + + xe->needs_flr_on_fini = true; +xe_pm_runtime_get_noresume (xe); + +xe_log_err_fatal (xe,WEDGED , -EIO ,"Device declared wedged!\n" ); +xe_err_once (xe,"IOCTLs and executions are now blocked!\n" +"For recovery procedure, refer to %s\n" +"Please file a _new_ bug report at %s\n" , +WEDGED_URL ,XE_BUG_URL ); + +for_each_gt (gt, xe, id) +xe_gt_declare_wedged (gt); + +schedule_work (&xe->wedged.work); +} + +static const char *wedge_mode_to_string (enum xe_wedged_mode mode) +{ +switch (mode) { +case XE_WEDGED_MODE_NEVER : +return "never" ; +case XE_WEDGED_MODE_UPON_CRITICAL_ERROR : +return "upon-critical-error" ; +case XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET : +return "upon-any-hang-no-reset" ; +default : +return "<invalid>" ; + } +} + +/** +* xe_device_validate_wedged_mode() - Check if given mode is supported +* @xe: the &xe_device +* @mode: requested mode to validate +* +* Check whether the provided wedged mode is supported. +* +* Return: 0 if mode is supported, error code otherwise. +*/ +int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode) +{ +if (mode >XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) { +xe_dbg (xe,"wedged_mode: invalid value (%u)\n" , mode); +return -EINVAL ; + }else if (mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET && (IS_SRIOV_VF (xe) || + (IS_SRIOV_PF (xe) && !IS_ENABLED (CONFIG_DRM_XE_DEBUG )))) { +xe_dbg (xe,"wedged_mode: (%u) %s mode is not supported for %s\n" , + mode,wedge_mode_to_string (mode), +xe_sriov_mode_to_string (xe_device_sriov_mode (xe))); +return -EPERM ; + } + +return 0 ; +} + +/** +* xe_device_wedged_init_early() - Set wedge mode passed as module parameter +* @xe: xe device instance +*/ +void xe_device_wedged_init_early (struct xe_device *xe) +{ + xe->wedged.mode =xe_device_validate_wedged_mode (xe, xe_modparam.wedged_mode) ? +XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode; +xe_dbg (xe,"wedged_mode: setting mode (%u) %s\n" , + xe->wedged.mode,wedge_mode_to_string (xe->wedged.mode)); +} + +static void xe_device_wedged_fini (struct drm_device *drm,void *arg) +{ +struct xe_device *xe = arg; + +disable_work_sync (&xe->wedged.work); + +if (atomic_read (&xe->wedged.flag)) +xe_pm_runtime_put (xe); +} + +/** +* xe_device_wedged_init() - Initialize wedge +* @xe: xe device instance +*/ +int xe_device_wedged_init (struct xe_device *xe) +{ +INIT_WORK (&xe->wedged.work, wedge_work); + +return drmm_add_action_or_reset (&xe->drm, xe_device_wedged_fini, xe); +}drivers/gpu/drm/xe/xe_wedge.h new file +8
-0@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2026 Intel Corporation +*/ + +#ifndef _XE_WEDGE_H_ +#define _XE_WEDGE_H_ +
drivers/gpu/drm/xe/xe_wedge.h line 18
Quoted 10 lines
drivers/gpu/drm/xe/xe_wedge.h new file +10
-0+#include <linux/types.h> + +struct xe_device ; + +void xe_device_declare_wedged (struct xe_device *xe); +bool xe_device_wedged (struct xe_device *xe); +void xe_device_wedged_init_early (struct xe_device *xe); +int xe_device_wedged_init (struct xe_device *xe); +int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode); +void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method);
As I told in the other review, please respect the component namespace:
xe_wedge_ not xe_device anymore...
Quoted 5 lines
drivers/gpu/drm/xe/xe_wedge.h new file +2
-0+ +#endif Signature · 1 line
2.43.0
PATCH v2 4/5 drm/xe/debugfs: Consolidate wedged_mode debt into xe_wedge
In reply to Raag JadavNow that we have a dedicated xe_wedge component, cleanup all wedged_mode implementation and move it to xe_wedge for better maintainability.
No functional impact.
--- drivers/gpu/drm/xe/xe_debugfs.c | 65 +------------------- drivers/gpu/drm/xe/xe_device_types.h | 30 +-------- drivers/gpu/drm/xe/xe_wedge.c | 91 ++++++++++++++++++++++++---- drivers/gpu/drm/xe/xe_wedge.h | 3 +- drivers/gpu/drm/xe/xe_wedge_types.h | 45 ++++++++++++++ 5 files changed, 131 insertions(+), 103 deletions(-) create mode 100644 drivers/gpu/drm/xe/xe_wedge_types.h
drivers/gpu/drm/xe/xe_debugfs.c +2 -63
@@ -18,8 +18,6 @@#include "xe_force_wake.h" #include "xe_gt.h" #include "xe_gt_debugfs.h" -#include "xe_gt_printk.h" -#include "xe_guc_ads.h" #include "xe_hw_engine.h" #include "xe_mmio.h" #include "xe_pagefault.h"
@@ -34,6 +32,7 @@#include "xe_tile_debugfs.h" #include "xe_vsec.h" #include "xe_wa.h" +#include "xe_wedge.h" #ifdef CONFIG_DRM_XE_DEBUG #include "xe_bo_evict.h"
@@ -374,58 +373,6 @@ static ssize_t wedged_mode_show(struct file *f, char __user *ubuf,return simple_read_from_buffer (ubuf, size, pos, buf, len); } -static int __wedged_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) -{ -bool enable_engine_reset; -int ret; - - enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); - ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, - enable_engine_reset); -if (ret) -xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); - -return ret; -} - -static int wedged_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) -{ -struct xe_gt *gt; -int ret; -u8 id; - -guard (xe_pm_runtime)(xe); -for_each_gt (gt, xe, id) { - ret =__wedged_mode_set_reset_policy (gt, mode); -if (ret) { -if (id >0 ) { - xe->wedged.inconsistent_reset = true; -drm_err (&xe->drm,"Inconsistent reset policy state between GTs\n" ); - } -return ret; - } - } - - xe->wedged.inconsistent_reset = false; - -return 0 ; -} - -static bool wedged_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) -{ -if (xe->wedged.inconsistent_reset) -return true; - -if (xe->wedged.mode == mode) -return false; - -if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || - mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -return true; - -return false; -} -static ssize_t wedged_mode_set (struct file *f,const char __user *ubuf,size_t size,loff_t *pos) {
@@ -437,18 +384,10 @@ static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,if (ret)return ret; - ret =xe_device_validate_wedged_mode (xe, wedged_mode); + ret =xe_wedge_set_mode (xe, wedged_mode);if (ret)return ret; -if (wedged_mode_needs_policy_update (xe, wedged_mode)) { - ret =wedged_mode_set_reset_policy (xe, wedged_mode); -if (ret) -return ret; - } - - xe->wedged.mode = wedged_mode; -return size; }
drivers/gpu/drm/xe/xe_device_types.h +2 -28
@@ -30,6 +30,7 @@#include "xe_sysctrl_types.h" #include "xe_tile_types.h" #include "xe_validation.h" +#include "xe_wedge_types.h" #if IS_ENABLED (CONFIG_DRM_XE_DEBUG )#define TEST_VM_OPS_ERROR
@@ -45,22 +46,6 @@ struct xe_pxp;struct xe_ttm_stolen_mgr ;struct xe_vram_region ; -/** -* enum xe_wedged_mode - possible wedged modes -* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. -* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only -* when critical error occurs like GT reset failure or firmware failure. -* This is the default mode. -* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on -* any hang. In this mode, engine resets are disabled to avoid automatic -* recovery attempts. This mode is primarily intended for debugging hangs. -*/ -enum xe_wedged_mode { -XE_WEDGED_MODE_NEVER =0 , -XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , -XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , -}; -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE /** * enum xe_page_size_alloc_ctrl_mode - User BO page-size allocation control modes
@@ -525,18 +510,7 @@ struct xe_device {atomic_t in_reset;/** @wedged: Struct to control Wedged States and mode */ -struct { -/** @wedged.flag: Xe device faced a critical error and is now blocked. */ -atomic_t flag; -/** @wedged.mode: Mode controlled by kernel parameter and debugfs */ -enum xe_wedged_mode mode; -/** @wedged.method: Recovery method to be sent in the drm device wedged uevent */ -unsigned long method; -/** @wedged.inconsistent_reset: Inconsistent reset policy state between GTs */ -bool inconsistent_reset; -/** @wedged.work: Worker for wedge handling */ -struct work_struct work; - } wedged; +struct xe_wedge wedged;/** @devres_group: devres group */ void *devres_group;
drivers/gpu/drm/xe/xe_wedge.c +80 -11
115 lines not on this page · raw message
drivers/gpu/drm/xe/xe_wedge.h +2 -1
@@ -9,12 +9,13 @@#include <linux/types.h> struct xe_device ; +enum xe_wedged_mode ;void xe_device_declare_wedged (struct xe_device *xe);bool xe_device_wedged (struct xe_device *xe);void xe_device_wedged_init_early (struct xe_device *xe);int xe_device_wedged_init (struct xe_device *xe); -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode);void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode);#endif
drivers/gpu/drm/xe/xe_wedge_types.h new file +45 -0
45 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH v2 4/5] drm/xe/debugfs: Consolidate wedged_mode debt into xe_wedge
drivers/gpu/drm/xe/xe_device_types.h
Quoted 121 lines · Raag Jadav
Now that we have a dedicated
xe_wedgecomponent, cleanup allwedged_modeimplementation and move it toxe_wedgefor better maintainability.No functional impact.
Suggested-by Lukasz Laguna <[email protected]>Suggested-by Michal Wajdeczko <[email protected]>Signed-off-by Raag Jadav <[email protected]>--- drivers/gpu/drm/xe/xe_debugfs.c | 65 +------------------- drivers/gpu/drm/xe/xe_device_types.h | 30 +-------- drivers/gpu/drm/xe/xe_wedge.c | 91 ++++++++++++++++++++++++---- drivers/gpu/drm/xe/xe_wedge.h | 3 +- drivers/gpu/drm/xe/xe_wedge_types.h | 45 ++++++++++++++ 5 files changed, 131 insertions(+), 103 deletions(-)create mode 100644
drivers/gpu/drm/xe/xe_wedge_types.hdrivers/gpu/drm/xe/xe_debugfs.c +2
-63@@ -18,8 +18,6 @@#include "xe_force_wake.h" #include "xe_gt.h" #include "xe_gt_debugfs.h" -#include "xe_gt_printk.h" -#include "xe_guc_ads.h" #include "xe_hw_engine.h" #include "xe_mmio.h" #include "xe_pagefault.h" @@ -34,6 +32,7 @@#include "xe_tile_debugfs.h" #include "xe_vsec.h" #include "xe_wa.h" +#include "xe_wedge.h" #ifdef CONFIG_DRM_XE_DEBUG #include "xe_bo_evict.h" @@ -374,58 +373,6 @@ static ssize_t wedged_mode_show(struct file *f, char __user *ubuf,return simple_read_from_buffer (ubuf, size, pos, buf, len); } -static int __wedged_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) -{ -bool enable_engine_reset; -int ret; - - enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); - ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, - enable_engine_reset); -if (ret) -xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); - -return ret; -} - -static int wedged_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) -{ -struct xe_gt *gt; -int ret; -u8 id; - -guard (xe_pm_runtime)(xe); -for_each_gt (gt, xe, id) { - ret =__wedged_mode_set_reset_policy (gt, mode); -if (ret) { -if (id >0 ) { - xe->wedged.inconsistent_reset = true; -drm_err (&xe->drm,"Inconsistent reset policy state between GTs\n" ); - } -return ret; - } - } - - xe->wedged.inconsistent_reset = false; - -return 0 ; -} - -static bool wedged_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) -{ -if (xe->wedged.inconsistent_reset) -return true; - -if (xe->wedged.mode == mode) -return false; - -if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || - mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -return true; - -return false; -} -static ssize_t wedged_mode_set (struct file *f,const char __user *ubuf,size_t size,loff_t *pos) {@@ -437,18 +384,10 @@ static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,if (ret)return ret; - ret =xe_device_validate_wedged_mode (xe, wedged_mode); + ret =xe_wedge_set_mode (xe, wedged_mode);if (ret)return ret; -if (wedged_mode_needs_policy_update (xe, wedged_mode)) { - ret =wedged_mode_set_reset_policy (xe, wedged_mode); -if (ret) -return ret; - } - - xe->wedged.mode = wedged_mode; -return size; }drivers/gpu/drm/xe/xe_device_types.h +0
-0
Shouldn't this be moved in the previous patch "drm/xe: Introduce xe_wedge"?
Lukasz
Quoted 243 lines
drivers/gpu/drm/xe/xe_device_types.h +2
-28@@ -30,6 +30,7 @@#include "xe_sysctrl_types.h" #include "xe_tile_types.h" #include "xe_validation.h" +#include "xe_wedge_types.h" #if IS_ENABLED (CONFIG_DRM_XE_DEBUG )#define TEST_VM_OPS_ERROR @@ -45,22 +46,6 @@ struct xe_pxp;struct xe_ttm_stolen_mgr ;struct xe_vram_region ; -/** -* enum xe_wedged_mode - possible wedged modes -* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. -* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only -* when critical error occurs like GT reset failure or firmware failure. -* This is the default mode. -* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on -* any hang. In this mode, engine resets are disabled to avoid automatic -* recovery attempts. This mode is primarily intended for debugging hangs. -*/ -enum xe_wedged_mode { -XE_WEDGED_MODE_NEVER =0 , -XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , -XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , -}; -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE /** * enum xe_page_size_alloc_ctrl_mode - User BO page-size allocation control modes @@ -525,18 +510,7 @@ struct xe_device {atomic_t in_reset;/** @wedged: Struct to control Wedged States and mode */ -struct { -/** @wedged.flag: Xe device faced a critical error and is now blocked. */ -atomic_t flag; -/** @wedged.mode: Mode controlled by kernel parameter and debugfs */ -enum xe_wedged_mode mode; -/** @wedged.method: Recovery method to be sent in the drm device wedged uevent */ -unsigned long method; -/** @wedged.inconsistent_reset: Inconsistent reset policy state between GTs */ -bool inconsistent_reset; -/** @wedged.work: Worker for wedge handling */ -struct work_struct work; - } wedged; +struct xe_wedge wedged;/** @devres_group: devres group */ void *devres_group;drivers/gpu/drm/xe/xe_wedge.c +80
-11@@ -9,6 +9,8 @@#include "xe_defaults.h" #include "xe_device_types.h" #include "xe_gt.h" +#include "xe_gt_printk.h" +#include "xe_guc_ads.h" #include "xe_log.h" #include "xe_module.h" #include "xe_pm.h" @@ -160,16 +162,7 @@ static const char *wedge_mode_to_string(enum xe_wedged_mode mode) } } -/** -* xe_device_validate_wedged_mode() - Check if given mode is supported -* @xe: the &xe_device -* @mode: requested mode to validate -* -* Check whether the provided wedged mode is supported. -* -* Return: 0 if mode is supported, error code otherwise. -*/ -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode) +static int wedge_validate_mode (struct xe_device *xe,unsigned int mode) {if (mode >XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) {xe_dbg (xe,"wedged_mode: invalid value (%u)\n" , mode);@@ -185,13 +178,89 @@ int xe_device_validate_wedged_mode(struct xe_device *xe, unsigned int mode)return 0 ; } +static bool wedge_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) +{ +if (xe->wedged.inconsistent_reset) +return true; + +if (xe->wedged.mode == mode) +return false; + +if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || + mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) +return true; + +return false; +} + +static int __wedge_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) +{ +bool enable_engine_reset; +int ret; + + enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); + ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, + enable_engine_reset); +if (ret) +xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); + +return ret; +} + +static int wedge_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) +{ +struct xe_gt *gt; +int ret; +u8 id; + +guard (xe_pm_runtime)(xe); +for_each_gt (gt, xe, id) { + ret =__wedge_mode_set_reset_policy (gt, mode); +if (ret) { +if (id >0 ) { + xe->wedged.inconsistent_reset = true; +xe_err (xe,"Inconsistent reset policy state between GTs\n" ); + } +return ret; + } + } + + xe->wedged.inconsistent_reset = false; + +return 0 ; +} + +/** +* xe_wedge_set_mode() - Set wedge mode +* @xe: xe device instance +* @mode: wedge mode to be set +*/ +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode) +{ +int ret; + + ret =wedge_validate_mode (xe, mode); +if (ret) +return ret; + +if (wedge_mode_needs_policy_update (xe, mode)) { + ret =wedge_mode_set_reset_policy (xe, mode); +if (ret) +return ret; + } + + xe->wedged.mode = mode; + +return ret; +} +/** * xe_device_wedged_init_early() - Set wedge mode passed as module parameter * @xe: xe device instance */ void xe_device_wedged_init_early (struct xe_device *xe) { - xe->wedged.mode =xe_device_validate_wedged_mode (xe, xe_modparam.wedged_mode) ? + xe->wedged.mode =wedge_validate_mode (xe, xe_modparam.wedged_mode) ?XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode;xe_dbg (xe,"wedged_mode: setting mode (%u) %s\n" , xe->wedged.mode,wedge_mode_to_string (xe->wedged.mode));drivers/gpu/drm/xe/xe_wedge.h +2
-1@@ -9,12 +9,13 @@#include <linux/types.h> struct xe_device ; +enum xe_wedged_mode ;void xe_device_declare_wedged (struct xe_device *xe);bool xe_device_wedged (struct xe_device *xe);void xe_device_wedged_init_early (struct xe_device *xe);int xe_device_wedged_init (struct xe_device *xe); -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode);void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode);#endif drivers/gpu/drm/xe/xe_wedge_types.h new file +45
-0@@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2026 Intel Corporation +*/ + +#ifndef _XE_WEDGE_TYPES_H_ +#define _XE_WEDGE_TYPES_H_ + +#include <linux/atomic.h> +#include <linux/types.h> +#include <linux/workqueue_types.h> + +/** +* enum xe_wedged_mode - Possible wedge modes +* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. +* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only +* when critical error occurs like GT reset failure or firmware failure. +* This is the default mode. +* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on +* any hang. In this mode, engine resets are disabled to avoid automatic +* recovery attempts. This mode is primarily intended for debugging hangs. +*/ +enum xe_wedged_mode { +XE_WEDGED_MODE_NEVER =0 , +XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , +XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , +}; + +/** +* struct xe_wedge - Struct to control Wedged States and mode +*/ +struct xe_wedge { +/** @flag: Xe device faced a critical error and is now blocked. */ +atomic_t flag; +/** @mode: Mode controlled by kernel parameter and debugfs */ +enum xe_wedged_mode mode; +/** @method: Recovery method to be sent in the drm device wedged uevent */ +unsigned long method; +/** @inconsistent_reset: Inconsistent reset policy state between GTs */ +bool inconsistent_reset; +/** @work: Worker for wedge handling */ +struct work_struct work; +}; + +#endif
Re: [PATCH v2 4/5] drm/xe/debugfs: Consolidate wedged_mode debt into xe_wedge
Quoted 111 lines · Lukasz
Quoted 110 lines · Raag Jadav
Now that we have a dedicated
xe_wedgecomponent, cleanup allwedged_modeimplementation and move it toxe_wedgefor better maintainability.No functional impact.
Suggested-by Lukasz Laguna <[email protected]>Suggested-by Michal Wajdeczko <[email protected]>Signed-off-by Raag Jadav <[email protected]>--- drivers/gpu/drm/xe/xe_debugfs.c | 65 +------------------- drivers/gpu/drm/xe/xe_device_types.h | 30 +-------- drivers/gpu/drm/xe/xe_wedge.c | 91 ++++++++++++++++++++++++---- drivers/gpu/drm/xe/xe_wedge.h | 3 +- drivers/gpu/drm/xe/xe_wedge_types.h | 45 ++++++++++++++ 5 files changed, 131 insertions(+), 103 deletions(-)create mode 100644
drivers/gpu/drm/xe/xe_wedge_types.hdrivers/gpu/drm/xe/xe_debugfs.c +2
-63@@ -18,8 +18,6 @@#include "xe_force_wake.h" #include "xe_gt.h" #include "xe_gt_debugfs.h" -#include "xe_gt_printk.h" -#include "xe_guc_ads.h" #include "xe_hw_engine.h" #include "xe_mmio.h" #include "xe_pagefault.h" @@ -34,6 +32,7 @@#include "xe_tile_debugfs.h" #include "xe_vsec.h" #include "xe_wa.h" +#include "xe_wedge.h" #ifdef CONFIG_DRM_XE_DEBUG #include "xe_bo_evict.h" @@ -374,58 +373,6 @@ static ssize_t wedged_mode_show(struct file *f, char __user *ubuf,return simple_read_from_buffer (ubuf, size, pos, buf, len); } -static int __wedged_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) -{ -bool enable_engine_reset; -int ret; - - enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); - ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, - enable_engine_reset); -if (ret) -xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); - -return ret; -} - -static int wedged_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) -{ -struct xe_gt *gt; -int ret; -u8 id; - -guard (xe_pm_runtime)(xe); -for_each_gt (gt, xe, id) { - ret =__wedged_mode_set_reset_policy (gt, mode); -if (ret) { -if (id >0 ) { - xe->wedged.inconsistent_reset = true; -drm_err (&xe->drm,"Inconsistent reset policy state between GTs\n" ); - } -return ret; - } - } - - xe->wedged.inconsistent_reset = false; - -return 0 ; -} - -static bool wedged_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) -{ -if (xe->wedged.inconsistent_reset) -return true; - -if (xe->wedged.mode == mode) -return false; - -if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || - mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -return true; - -return false; -} -static ssize_t wedged_mode_set (struct file *f,const char __user *ubuf,size_t size,loff_t *pos) {@@ -437,18 +384,10 @@ static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,if (ret)return ret; - ret =xe_device_validate_wedged_mode (xe, wedged_mode); + ret =xe_wedge_set_mode (xe, wedged_mode);if (ret)return ret; -if (wedged_mode_needs_policy_update (xe, wedged_mode)) { - ret =wedged_mode_set_reset_policy (xe, wedged_mode); -if (ret) -return ret; - } - - xe->wedged.mode = wedged_mode; -
Quoted 8 lines
drivers/gpu/drm/xe/xe_device_types.h
Quoted 6 lines
drivers/gpu/drm/xe/xe_debugfs.c +0
-0return size; }drivers/gpu/drm/xe/xe_device_types.h +0
-0Shouldn't this be moved in the previous patch "drm/xe: Introduce
xe_wedge"?
That's what I did locally but it results in a huge patch that's hard to review, hence the 3 patch split here. I don't mind squashing if it makes everyone happy.
Raag
Quoted 234 lines
Quoted 234 lines
drivers/gpu/drm/xe/xe_device_types.h +2
-28@@ -30,6 +30,7 @@#include "xe_sysctrl_types.h" #include "xe_tile_types.h" #include "xe_validation.h" +#include "xe_wedge_types.h" #if IS_ENABLED (CONFIG_DRM_XE_DEBUG )#define TEST_VM_OPS_ERROR @@ -45,22 +46,6 @@ struct xe_pxp;struct xe_ttm_stolen_mgr ;struct xe_vram_region ; -/** -* enum xe_wedged_mode - possible wedged modes -* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. -* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only -* when critical error occurs like GT reset failure or firmware failure. -* This is the default mode. -* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on -* any hang. In this mode, engine resets are disabled to avoid automatic -* recovery attempts. This mode is primarily intended for debugging hangs. -*/ -enum xe_wedged_mode { -XE_WEDGED_MODE_NEVER =0 , -XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , -XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , -}; -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE /** * enum xe_page_size_alloc_ctrl_mode - User BO page-size allocation control modes @@ -525,18 +510,7 @@ struct xe_device {atomic_t in_reset;/** @wedged: Struct to control Wedged States and mode */ -struct { -/** @wedged.flag: Xe device faced a critical error and is now blocked. */ -atomic_t flag; -/** @wedged.mode: Mode controlled by kernel parameter and debugfs */ -enum xe_wedged_mode mode; -/** @wedged.method: Recovery method to be sent in the drm device wedged uevent */ -unsigned long method; -/** @wedged.inconsistent_reset: Inconsistent reset policy state between GTs */ -bool inconsistent_reset; -/** @wedged.work: Worker for wedge handling */ -struct work_struct work; - } wedged; +struct xe_wedge wedged;/** @devres_group: devres group */ void *devres_group;drivers/gpu/drm/xe/xe_wedge.c +80
-11@@ -9,6 +9,8 @@#include "xe_defaults.h" #include "xe_device_types.h" #include "xe_gt.h" +#include "xe_gt_printk.h" +#include "xe_guc_ads.h" #include "xe_log.h" #include "xe_module.h" #include "xe_pm.h" @@ -160,16 +162,7 @@ static const char *wedge_mode_to_string(enum xe_wedged_mode mode) } } -/** -* xe_device_validate_wedged_mode() - Check if given mode is supported -* @xe: the &xe_device -* @mode: requested mode to validate -* -* Check whether the provided wedged mode is supported. -* -* Return: 0 if mode is supported, error code otherwise. -*/ -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode) +static int wedge_validate_mode (struct xe_device *xe,unsigned int mode) {if (mode >XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) {xe_dbg (xe,"wedged_mode: invalid value (%u)\n" , mode);@@ -185,13 +178,89 @@ int xe_device_validate_wedged_mode(struct xe_device *xe, unsigned int mode)return 0 ; } +static bool wedge_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) +{ +if (xe->wedged.inconsistent_reset) +return true; + +if (xe->wedged.mode == mode) +return false; + +if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || + mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) +return true; + +return false; +} + +static int __wedge_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) +{ +bool enable_engine_reset; +int ret; + + enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); + ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, + enable_engine_reset); +if (ret) +xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); + +return ret; +} + +static int wedge_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) +{ +struct xe_gt *gt; +int ret; +u8 id; + +guard (xe_pm_runtime)(xe); +for_each_gt (gt, xe, id) { + ret =__wedge_mode_set_reset_policy (gt, mode); +if (ret) { +if (id >0 ) { + xe->wedged.inconsistent_reset = true; +xe_err (xe,"Inconsistent reset policy state between GTs\n" ); + } +return ret; + } + } + + xe->wedged.inconsistent_reset = false; + +return 0 ; +} + +/** +* xe_wedge_set_mode() - Set wedge mode +* @xe: xe device instance +* @mode: wedge mode to be set +*/ +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode) +{ +int ret; + + ret =wedge_validate_mode (xe, mode); +if (ret) +return ret; + +if (wedge_mode_needs_policy_update (xe, mode)) { + ret =wedge_mode_set_reset_policy (xe, mode); +if (ret) +return ret; + } + + xe->wedged.mode = mode; + +return ret; +} +/** * xe_device_wedged_init_early() - Set wedge mode passed as module parameter * @xe: xe device instance */ void xe_device_wedged_init_early (struct xe_device *xe) { - xe->wedged.mode =xe_device_validate_wedged_mode (xe, xe_modparam.wedged_mode) ? + xe->wedged.mode =wedge_validate_mode (xe, xe_modparam.wedged_mode) ?XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode;xe_dbg (xe,"wedged_mode: setting mode (%u) %s\n" , xe->wedged.mode,wedge_mode_to_string (xe->wedged.mode));drivers/gpu/drm/xe/xe_wedge.h +2
-1@@ -9,12 +9,13 @@#include <linux/types.h> struct xe_device ; +enum xe_wedged_mode ;void xe_device_declare_wedged (struct xe_device *xe);bool xe_device_wedged (struct xe_device *xe);void xe_device_wedged_init_early (struct xe_device *xe);int xe_device_wedged_init (struct xe_device *xe); -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode);void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode);#endif drivers/gpu/drm/xe/xe_wedge_types.h new file +45
-0@@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2026 Intel Corporation +*/ + +#ifndef _XE_WEDGE_TYPES_H_ +#define _XE_WEDGE_TYPES_H_ + +#include <linux/atomic.h> +#include <linux/types.h> +#include <linux/workqueue_types.h> + +/** +* enum xe_wedged_mode - Possible wedge modes +* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. +* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only +* when critical error occurs like GT reset failure or firmware failure. +* This is the default mode. +* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on +* any hang. In this mode, engine resets are disabled to avoid automatic +* recovery attempts. This mode is primarily intended for debugging hangs. +*/ +enum xe_wedged_mode { +XE_WEDGED_MODE_NEVER =0 , +XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , +XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , +}; + +/** +* struct xe_wedge - Struct to control Wedged States and mode +*/ +struct xe_wedge { +/** @flag: Xe device faced a critical error and is now blocked. */ +atomic_t flag; +/** @mode: Mode controlled by kernel parameter and debugfs */ +enum xe_wedged_mode mode; +/** @method: Recovery method to be sent in the drm device wedged uevent */ +unsigned long method; +/** @inconsistent_reset: Inconsistent reset policy state between GTs */ +bool inconsistent_reset; +/** @work: Worker for wedge handling */ +struct work_struct work; +}; + +#endif
Re: [PATCH v2 4/5] drm/xe/debugfs: Consolidate wedged_mode debt into xe_wedge
Quoted 119 lines · Raag Jadav
Quoted 110 lines · Lukasz
Quoted 109 lines · Raag Jadav
Now that we have a dedicated
xe_wedgecomponent, cleanup allwedged_modeimplementation and move it toxe_wedgefor better maintainability.No functional impact.
Suggested-by Lukasz Laguna <[email protected]>Suggested-by Michal Wajdeczko <[email protected]>Signed-off-by Raag Jadav <[email protected]>--- drivers/gpu/drm/xe/xe_debugfs.c | 65 +------------------- drivers/gpu/drm/xe/xe_device_types.h | 30 +-------- drivers/gpu/drm/xe/xe_wedge.c | 91 ++++++++++++++++++++++++---- drivers/gpu/drm/xe/xe_wedge.h | 3 +- drivers/gpu/drm/xe/xe_wedge_types.h | 45 ++++++++++++++ 5 files changed, 131 insertions(+), 103 deletions(-)create mode 100644
drivers/gpu/drm/xe/xe_wedge_types.hdrivers/gpu/drm/xe/xe_debugfs.c +2
-62@@ -18,8 +18,6 @@#include "xe_force_wake.h" #include "xe_gt.h" #include "xe_gt_debugfs.h" -#include "xe_gt_printk.h" -#include "xe_guc_ads.h" #include "xe_hw_engine.h" #include "xe_mmio.h" #include "xe_pagefault.h" @@ -34,6 +32,7 @@#include "xe_tile_debugfs.h" #include "xe_vsec.h" #include "xe_wa.h" +#include "xe_wedge.h" #ifdef CONFIG_DRM_XE_DEBUG #include "xe_bo_evict.h" @@ -374,58 +373,6 @@ static ssize_t wedged_mode_show(struct file *f, char __user *ubuf,return simple_read_from_buffer (ubuf, size, pos, buf, len); } -static int __wedged_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) -{ -bool enable_engine_reset; -int ret; - - enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); - ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, - enable_engine_reset); -if (ret) -xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); - -return ret; -} - -static int wedged_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) -{ -struct xe_gt *gt; -int ret; -u8 id; - -guard (xe_pm_runtime)(xe); -for_each_gt (gt, xe, id) { - ret =__wedged_mode_set_reset_policy (gt, mode); -if (ret) { -if (id >0 ) { - xe->wedged.inconsistent_reset = true; -drm_err (&xe->drm,"Inconsistent reset policy state between GTs\n" ); - } -return ret; - } - } - - xe->wedged.inconsistent_reset = false; - -return 0 ; -} - -static bool wedged_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) -{ -if (xe->wedged.inconsistent_reset) -return true; - -if (xe->wedged.mode == mode) -return false; - -if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || - mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -return true; - -return false; -} -static ssize_t wedged_mode_set (struct file *f,const char __user *ubuf,size_t size,loff_t *pos) {@@ -437,18 +384,10 @@ static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,if (ret)return ret; - ret =xe_device_validate_wedged_mode (xe, wedged_mode); + ret =xe_wedge_set_mode (xe, wedged_mode);if (ret)return ret; -if (wedged_mode_needs_policy_update (xe, wedged_mode)) { - ret =wedged_mode_set_reset_policy (xe, wedged_mode); -if (ret) -return ret; - } - - xe->wedged.mode = wedged_mode;Quoted 8 lines
drivers/gpu/drm/xe/xe_device_types.h
Quoted 7 lines
drivers/gpu/drm/xe/xe_debugfs.c +0
-1-return size; }drivers/gpu/drm/xe/xe_device_types.h +0
-0Shouldn't this be moved in the previous patch "drm/xe: Introduce
xe_wedge"?
Quoted 5 lines
That's what I did locally but it results in a huge patch that's hard to review, hence the 3 patch split here. I don't mind squashing if it makes everyone happy.
Raag
I was thinking about moving enum and struct from xe_device_types.h, but squashing all is also fine for me.
Lukasz
Quoted 235 lines
Quoted 235 lines
Quoted 235 lines
drivers/gpu/drm/xe/xe_device_types.h +2
-28@@ -30,6 +30,7 @@#include "xe_sysctrl_types.h" #include "xe_tile_types.h" #include "xe_validation.h" +#include "xe_wedge_types.h" #if IS_ENABLED (CONFIG_DRM_XE_DEBUG )#define TEST_VM_OPS_ERROR @@ -45,22 +46,6 @@ struct xe_pxp;struct xe_ttm_stolen_mgr ;struct xe_vram_region ; -/** -* enum xe_wedged_mode - possible wedged modes -* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. -* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only -* when critical error occurs like GT reset failure or firmware failure. -* This is the default mode. -* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on -* any hang. In this mode, engine resets are disabled to avoid automatic -* recovery attempts. This mode is primarily intended for debugging hangs. -*/ -enum xe_wedged_mode { -XE_WEDGED_MODE_NEVER =0 , -XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , -XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , -}; -#ifdef CONFIG_DRM_XE_DEBUG_PAGE_SIZE /** * enum xe_page_size_alloc_ctrl_mode - User BO page-size allocation control modes @@ -525,18 +510,7 @@ struct xe_device {atomic_t in_reset;/** @wedged: Struct to control Wedged States and mode */ -struct { -/** @wedged.flag: Xe device faced a critical error and is now blocked. */ -atomic_t flag; -/** @wedged.mode: Mode controlled by kernel parameter and debugfs */ -enum xe_wedged_mode mode; -/** @wedged.method: Recovery method to be sent in the drm device wedged uevent */ -unsigned long method; -/** @wedged.inconsistent_reset: Inconsistent reset policy state between GTs */ -bool inconsistent_reset; -/** @wedged.work: Worker for wedge handling */ -struct work_struct work; - } wedged; +struct xe_wedge wedged;/** @devres_group: devres group */ void *devres_group;drivers/gpu/drm/xe/xe_wedge.c +80
-11@@ -9,6 +9,8 @@#include "xe_defaults.h" #include "xe_device_types.h" #include "xe_gt.h" +#include "xe_gt_printk.h" +#include "xe_guc_ads.h" #include "xe_log.h" #include "xe_module.h" #include "xe_pm.h" @@ -160,16 +162,7 @@ static const char *wedge_mode_to_string(enum xe_wedged_mode mode) } } -/** -* xe_device_validate_wedged_mode() - Check if given mode is supported -* @xe: the &xe_device -* @mode: requested mode to validate -* -* Check whether the provided wedged mode is supported. -* -* Return: 0 if mode is supported, error code otherwise. -*/ -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode) +static int wedge_validate_mode (struct xe_device *xe,unsigned int mode) {if (mode >XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) {xe_dbg (xe,"wedged_mode: invalid value (%u)\n" , mode);@@ -185,13 +178,89 @@ int xe_device_validate_wedged_mode(struct xe_device *xe, unsigned int mode)return 0 ; } +static bool wedge_mode_needs_policy_update (struct xe_device *xe,enum xe_wedged_mode mode) +{ +if (xe->wedged.inconsistent_reset) +return true; + +if (xe->wedged.mode == mode) +return false; + +if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET || + mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) +return true; + +return false; +} + +static int __wedge_mode_set_reset_policy (struct xe_gt *gt,enum xe_wedged_mode mode) +{ +bool enable_engine_reset; +int ret; + + enable_engine_reset = (mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ); + ret =xe_guc_ads_scheduler_policy_toggle_reset (>->uc.guc.ads, + enable_engine_reset); +if (ret) +xe_gt_err (gt,"Failed to update GuC ADS scheduler policy (%pe)\n" ,ERR_PTR (ret)); + +return ret; +} + +static int wedge_mode_set_reset_policy (struct xe_device *xe,enum xe_wedged_mode mode) +{ +struct xe_gt *gt; +int ret; +u8 id; + +guard (xe_pm_runtime)(xe); +for_each_gt (gt, xe, id) { + ret =__wedge_mode_set_reset_policy (gt, mode); +if (ret) { +if (id >0 ) { + xe->wedged.inconsistent_reset = true; +xe_err (xe,"Inconsistent reset policy state between GTs\n" ); + } +return ret; + } + } + + xe->wedged.inconsistent_reset = false; + +return 0 ; +} + +/** +* xe_wedge_set_mode() - Set wedge mode +* @xe: xe device instance +* @mode: wedge mode to be set +*/ +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode) +{ +int ret; + + ret =wedge_validate_mode (xe, mode); +if (ret) +return ret; + +if (wedge_mode_needs_policy_update (xe, mode)) { + ret =wedge_mode_set_reset_policy (xe, mode); +if (ret) +return ret; + } + + xe->wedged.mode = mode; + +return ret; +} +/** * xe_device_wedged_init_early() - Set wedge mode passed as module parameter * @xe: xe device instance */ void xe_device_wedged_init_early (struct xe_device *xe) { - xe->wedged.mode =xe_device_validate_wedged_mode (xe, xe_modparam.wedged_mode) ? + xe->wedged.mode =wedge_validate_mode (xe, xe_modparam.wedged_mode) ?XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode;xe_dbg (xe,"wedged_mode: setting mode (%u) %s\n" , xe->wedged.mode,wedge_mode_to_string (xe->wedged.mode));drivers/gpu/drm/xe/xe_wedge.h +2
-1@@ -9,12 +9,13 @@#include <linux/types.h> struct xe_device ; +enum xe_wedged_mode ;void xe_device_declare_wedged (struct xe_device *xe);bool xe_device_wedged (struct xe_device *xe);void xe_device_wedged_init_early (struct xe_device *xe);int xe_device_wedged_init (struct xe_device *xe); -int xe_device_validate_wedged_mode (struct xe_device *xe,unsigned int mode);void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); +int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode);#endif drivers/gpu/drm/xe/xe_wedge_types.h new file +45
-0@@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2026 Intel Corporation +*/ + +#ifndef _XE_WEDGE_TYPES_H_ +#define _XE_WEDGE_TYPES_H_ + +#include <linux/atomic.h> +#include <linux/types.h> +#include <linux/workqueue_types.h> + +/** +* enum xe_wedged_mode - Possible wedge modes +* @XE_WEDGED_MODE_NEVER: Device will never be declared wedged. +* @XE_WEDGED_MODE_UPON_CRITICAL_ERROR: Device will be declared wedged only +* when critical error occurs like GT reset failure or firmware failure. +* This is the default mode. +* @XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET: Device will be declared wedged on +* any hang. In this mode, engine resets are disabled to avoid automatic +* recovery attempts. This mode is primarily intended for debugging hangs. +*/ +enum xe_wedged_mode { +XE_WEDGED_MODE_NEVER =0 , +XE_WEDGED_MODE_UPON_CRITICAL_ERROR =1 , +XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET =2 , +}; + +/** +* struct xe_wedge - Struct to control Wedged States and mode +*/ +struct xe_wedge { +/** @flag: Xe device faced a critical error and is now blocked. */ +atomic_t flag; +/** @mode: Mode controlled by kernel parameter and debugfs */ +enum xe_wedged_mode mode; +/** @method: Recovery method to be sent in the drm device wedged uevent */ +unsigned long method; +/** @inconsistent_reset: Inconsistent reset policy state between GTs */ +bool inconsistent_reset; +/** @work: Worker for wedge handling */ +struct work_struct work; +}; + +#endif
PATCH v2 5/5 drm/xe/wedge: Update naming to match with xe_wedge
In reply to Raag JadavNow that we have a dedicated xe_wedge component, update all its function names accordingly.
No functional impact.
--- drivers/gpu/drm/xe/tests/xe_kunit_helpers.c | 2 +- drivers/gpu/drm/xe/xe_amc.c | 2 +- drivers/gpu/drm/xe/xe_bo.c | 2 +- drivers/gpu/drm/xe/xe_device.c | 10 +++--- drivers/gpu/drm/xe/xe_gsc.c | 2 +- drivers/gpu/drm/xe/xe_gt.c | 10 +++--- drivers/gpu/drm/xe/xe_gt.h | 2 +- drivers/gpu/drm/xe/xe_gt_sriov_vf.c | 2 +- drivers/gpu/drm/xe/xe_guc.c | 4 +-- drivers/gpu/drm/xe/xe_guc.h | 2 +- drivers/gpu/drm/xe/xe_guc_ct.c | 6 ++-- drivers/gpu/drm/xe/xe_guc_rc.c | 4 +-- drivers/gpu/drm/xe/xe_guc_submit.c | 12 ++++---- drivers/gpu/drm/xe/xe_guc_tlb_inval.c | 2 +- drivers/gpu/drm/xe/xe_mert.c | 4 +-- drivers/gpu/drm/xe/xe_pci_error.c | 8 ++--- drivers/gpu/drm/xe/xe_ras.c | 4 +-- drivers/gpu/drm/xe/xe_sriov_pf.c | 2 +- drivers/gpu/drm/xe/xe_survivability_mode.c | 4 +-- drivers/gpu/drm/xe/xe_uc.c | 6 ++-- drivers/gpu/drm/xe/xe_uc.h | 2 +- drivers/gpu/drm/xe/xe_wedge.c | 34 ++++++++++----------- drivers/gpu/drm/xe/xe_wedge.h | 10 +++--- 23 files changed, 68 insertions(+), 68 deletions(-)
drivers/gpu/drm/xe/tests/xe_kunit_helpers.c +1 -1
@@ -123,7 +123,7 @@ int xe_kunit_helper_xe_device_live_test_init(struct kunit *test)KUNIT_ASSERT_NOT_ERR_OR_NULL (test, xe);kunit_info (test,"running on %s device\n" , xe->info.platform_name); -KUNIT_ASSERT_FALSE (test,xe_device_wedged (xe)); +KUNIT_ASSERT_FALSE (test,xe_wedged (xe));xe_pm_runtime_get (xe);KUNIT_ASSERT_EQ (test,0 ,kunit_add_action_or_reset (test, put_xe_pm_runtime, xe));
drivers/gpu/drm/xe/xe_amc.c +1 -1
@@ -160,7 +160,7 @@ static void xe_amc_work(struct work_struct *work)case AMC_ALERT_OOB_RESET :case AMC_ALERT_CATERR :dev_warn (amc->i2c->drm_dev,"AMC Alert: %s\n" , amc_alert[alert_reason]); -xe_device_declare_wedged (i2c_client_to_xe_device (client)); +xe_wedge_declare (i2c_client_to_xe_device (client));break ;default :dev_warn (amc->i2c->drm_dev,"unknown AMC alert: %d\n" , alert_reason);
drivers/gpu/drm/xe/xe_bo.c +1 -1
@@ -2094,7 +2094,7 @@ static vm_fault_t xe_bo_cpu_fault(struct vm_fault *vmf)int err =0 ;int idx; -if (xe_device_wedged (xe) || !drm_dev_enter (&xe->drm, &idx)) +if (xe_wedged (xe) || !drm_dev_enter (&xe->drm, &idx))return ttm_bo_vm_dummy_page (vmf, vmf->vma->vm_page_prot); ret =xe_bo_cpu_fault_fastpath (vmf, xe, bo, needs_rpm);
drivers/gpu/drm/xe/xe_device.c +5 -5
@@ -225,7 +225,7 @@ static long xe_drm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)struct xe_device *xe =to_xe_device (file_priv->minor->dev);long ret; -if (xe_device_wedged (xe)) +if (xe_wedged (xe))return -ECANCELED ;ACQUIRE (xe_pm_runtime_ioctl, pm)(xe);
@@ -243,7 +243,7 @@ static long xe_drm_compat_ioctl(struct file *file, unsigned int cmd, unsigned lostruct xe_device *xe =to_xe_device (file_priv->minor->dev);long ret; -if (xe_device_wedged (xe)) +if (xe_wedged (xe))return -ECANCELED ;ACQUIRE (xe_pm_runtime_ioctl, pm)(xe);
@@ -829,7 +829,7 @@ int xe_device_probe_early(struct xe_device *xe)*/ assert_lmem_ready (xe); -xe_device_wedged_init_early (xe); +xe_wedge_init_early (xe); err =xe_device_vram_alloc (xe);if (err)
@@ -1137,14 +1137,14 @@ int xe_device_probe(struct xe_device *xe)detect_preproduction_hw (xe); - err =xe_device_wedged_init (xe); + err =xe_wedge_init (xe);if (err) goto err_unregister_display;/* * Process and log any errors detected by hardware. Possible results can * include declaring the device as wedged, which must be done only after -* xe_device_wedged_fini() is registered. +* xe_wedge_fini() is registered. */ xe_ras_process_errors (xe);
drivers/gpu/drm/xe/xe_gsc.c +1 -1
@@ -340,7 +340,7 @@ static int gsc_er_complete(struct xe_gt *gt)* declare the device as wedged. */ xe_gt_err (gt,"GSC ER timed out!\n" ); -xe_device_declare_wedged (gt_to_xe (gt)); +xe_wedge_declare (gt_to_xe (gt));return -EIO ; }
drivers/gpu/drm/xe/xe_gt.c +5 -5
@@ -926,7 +926,7 @@ static void gt_reset_worker(struct work_struct *w)unsigned int fw_ref;int err; -if (xe_device_wedged (gt_to_xe (gt))) +if (xe_wedged (gt_to_xe (gt))) goto err_pm_put;if (xe_device_is_in_reset (gt_to_xe (gt)))
@@ -985,7 +985,7 @@ static void gt_reset_worker(struct work_struct *w) err_fail:xe_log_err_fatal (gt,GT , err,"reset failed\n" ); -xe_device_declare_wedged (gt_to_xe (gt)); +xe_wedge_declare (gt_to_xe (gt)); err_pm_put:xe_pm_runtime_put (gt_to_xe (gt)); }
@@ -1013,7 +1013,7 @@ static void gt_wedge_worker(struct work_struct *w) {struct xe_gt *gt =container_of (w,typeof (*gt), wedge.worker); -xe_uc_declare_wedged (>->uc); +xe_uc_wedge_declare (>->uc);xe_tlb_inval_reset (>->tlb_inval); }
@@ -1197,13 +1197,13 @@ struct xe_hw_engine *xe_gt_any_hw_engine(struct xe_gt *gt) }/** -* xe_gt_declare_wedged() - Declare GT wedged +* xe_gt_wedge_declare() - Declare GT wedged * @gt: the GT object * * Wedge the GT which stops all submission, saves desired debug state, and * cleans up anything which could timeout. */ -void xe_gt_declare_wedged (struct xe_gt *gt) +void xe_gt_wedge_declare (struct xe_gt *gt) {xe_gt_assert (gt,gt_to_xe (gt)->wedged.mode);
drivers/gpu/drm/xe/xe_gt.h +1 -1
@@ -40,7 +40,7 @@ struct xe_gt *xe_gt_alloc(struct xe_tile *tile);int xe_gt_init_early (struct xe_gt *gt);int xe_gt_init (struct xe_gt *gt);void xe_gt_mmio_init (struct xe_gt *gt); -void xe_gt_declare_wedged (struct xe_gt *gt); +void xe_gt_wedge_declare (struct xe_gt *gt);int xe_gt_record_default_lrcs (struct xe_gt *gt);/**
drivers/gpu/drm/xe/xe_gt_sriov_vf.c +1 -1
@@ -1462,7 +1462,7 @@ static void vf_post_migration_recovery(struct xe_gt *gt) fail:vf_post_migration_abort (gt);xe_gt_sriov_err (gt,"migration recovery failed (%pe)\n" ,ERR_PTR (err)); -xe_device_declare_wedged (xe); +xe_wedge_declare (xe);return ; queue:
drivers/gpu/drm/xe/xe_guc.c +2 -2
@@ -1813,13 +1813,13 @@ int xe_guc_print_info(struct xe_guc *guc, struct drm_printer *p) }/** -* xe_guc_declare_wedged() - Declare GuC wedged +* xe_guc_wedge_declare() - Declare GuC wedged * @guc: the GuC object * * Wedge the GuC which stops all submission, saves desired debug state, and * cleans up anything which could timeout. */ -void xe_guc_declare_wedged (struct xe_guc *guc) +void xe_guc_wedge_declare (struct xe_guc *guc) {xe_gt_assert (guc_to_gt (guc),guc_to_xe (guc)->wedged.mode);
drivers/gpu/drm/xe/xe_guc.h +1 -1
@@ -60,7 +60,7 @@ void xe_guc_reset_wait(struct xe_guc *guc);void xe_guc_stop_prepare (struct xe_guc *guc);void xe_guc_stop (struct xe_guc *guc);int xe_guc_start (struct xe_guc *guc); -void xe_guc_declare_wedged (struct xe_guc *guc); +void xe_guc_wedge_declare (struct xe_guc *guc);bool xe_guc_using_main_gamctrl_queues (struct xe_guc *guc);bool xe_guc_has_paging_engine (struct xe_guc *guc);
drivers/gpu/drm/xe/xe_guc_ct.c +3 -3
@@ -1062,7 +1062,7 @@ static int __guc_ct_send_locked(struct xe_guc_ct *ct, const u32 *action,xe_gt_assert (gt, g2h_len || !num_g2h);lockdep_assert_held (&ct->lock); -if (xe_device_wedged (ct_to_xe (ct))) { +if (xe_wedged (ct_to_xe (ct))) { ret = -ENOTRECOVERABLE ; goto out; }
@@ -1474,7 +1474,7 @@ static int guc_ct_send_recv(struct xe_guc_ct *ct, const u32 *action, u32 len,if (g2h_fence.fail) {if (g2h_fence.cancel) {xe_gt_dbg (gt,"H2G request %#x canceled!\n" , action[0 ]); - ret =xe_device_wedged (ct_to_xe (ct)) ? -ENOTRECOVERABLE : -ECANCELED ; + ret =xe_wedged (ct_to_xe (ct)) ? -ENOTRECOVERABLE : -ECANCELED ; goto unlock; } xe_gt_err(gt, "H2G request %#x failed: error %#x hint %#x\n",
@@ -1813,7 +1813,7 @@ static int g2h_read(struct xe_guc_ct *ct, u32 *msg, bool fast_path)xe_gt_assert (gt,xe_guc_ct_initialized (ct));lockdep_assert_held (&ct->fast_lock); -if (xe_device_wedged (xe)) +if (xe_wedged (xe))return -ENOTRECOVERABLE ;if (ct->state ==XE_GUC_CT_STATE_DISABLED )
drivers/gpu/drm/xe/xe_guc_rc.c +2 -2
@@ -40,7 +40,7 @@ static int guc_action_setup_gucrc(struct xe_guc *guc, u32 control)int ret; ret =xe_guc_ct_send (&guc->ct, action,ARRAY_SIZE (action),0 ,0 ); -if (ret && !(xe_device_wedged (guc_to_xe (guc)) && ret == -ECANCELED )) +if (ret && !(xe_wedged (guc_to_xe (guc)) && ret == -ECANCELED )) xe_gt_err(guc_to_gt(guc), "GuC RC setup %s(%u) failed (%pe)\n", control == GUCRC_HOST_CONTROL ? "HOST_CONTROL" :
@@ -73,7 +73,7 @@ static void xe_guc_rc_fini_hw(void *arg)struct xe_device *xe =guc_to_xe (guc);struct xe_gt *gt =guc_to_gt (guc); -if (xe_device_wedged (xe)) +if (xe_wedged (xe))return ;CLASS (xe_force_wake, fw_ref)(gt_to_fw (gt),XE_FW_GT );
drivers/gpu/drm/xe/xe_guc_submit.c +6 -6
@@ -1387,10 +1387,10 @@ static bool guc_submit_hint_wedged(struct xe_guc *guc)if (xe->wedged.mode !=XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET )return false; -if (xe_device_wedged (xe)) +if (xe_wedged (xe))return true; -xe_device_declare_wedged (xe); +xe_wedge_declare (xe);return true; }
@@ -1597,7 +1597,7 @@ guc_exec_queue_timedout_job(struct drm_sched_job *drm_job)if (!exec_queue_killed (q)) wedged =guc_submit_hint_wedged (exec_queue_to_guc (q));else - wedged =xe_device_wedged (xe); + wedged =xe_wedged (xe);set_exec_queue_banned (q);
@@ -1708,7 +1708,7 @@ guc_exec_queue_timedout_job(struct drm_sched_job *drm_job) }if (wedge_device) -xe_device_declare_wedged (gt_to_xe (q->gt)); +xe_wedge_declare (gt_to_xe (q->gt));/* * We want the job added back to the pending list so it gets freed; this
@@ -2452,7 +2452,7 @@ static int guc_exec_queue_wait_suspend_done(struct xe_exec_queue *q, bool blocki WAIT_COND, HZ * 5); } -if (!blocking &&vf_recovery (guc) && !xe_device_wedged (xe)) +if (!blocking &&vf_recovery (guc) && !xe_wedged (xe))return -EAGAIN ;if (!ret)
@@ -2694,7 +2694,7 @@ int xe_guc_submit_reset_prepare(struct xe_guc *guc)void xe_guc_submit_reset_wait (struct xe_guc *guc) { -wait_event (guc->ct.wq,xe_device_wedged (guc_to_xe (guc)) || +wait_event (guc->ct.wq,xe_wedged (guc_to_xe (guc)) || !xe_guc_read_stopped (guc)); }
drivers/gpu/drm/xe/xe_guc_tlb_inval.c +1 -1
@@ -77,7 +77,7 @@ static int send_tlb_inval_ggtt(struct xe_tlb_inval *tlb_inval, u32 seqno) };return send_tlb_inval (guc, action,ARRAY_SIZE (action)); - }else if (xe_device_uc_enabled (xe) && !xe_device_wedged (xe)) { + }else if (xe_device_uc_enabled (xe) && !xe_wedged (xe)) {struct xe_mmio *mmio = >->mmio;if (IS_SRIOV_VF (xe))
drivers/gpu/drm/xe/xe_mert.c +2 -2
@@ -74,7 +74,7 @@ static void mert_handle_cat_error(struct xe_device *xe)break ;case CATERR_UNMAPPED_GGTT :xe_sriov_err (xe,"MERT: CAT_ERR: Access to an unmapped GGTT!\n" ); -xe_device_declare_wedged (xe); +xe_wedge_declare (xe);break ;case CATERR_LMTT_FAULT :xe_sriov_dbg_ratelimited (xe,"MERT: CAT_ERR: VF%u LMTT fault!\n" , vfid);
@@ -82,7 +82,7 @@ static void mert_handle_cat_error(struct xe_device *xe)break ;default :xe_sriov_err (xe,"MERT: Unexpected CAT_ERR code=%#x!\n" , code); -xe_device_declare_wedged (xe); +xe_wedge_declare (xe);break ; } }
drivers/gpu/drm/xe/xe_pci_error.c +4 -4
@@ -22,7 +22,7 @@ static void prepare_device_for_reset(struct pci_dev *pdev)/* * Wedge the device to prevent userspace access but do not send the uevent. -* xe_device_wedged_fini() releases runtime pm if wedged flag is set, so acquire a runtime +* xe_wedge_fini() releases runtime pm if wedged flag is set, so acquire a runtime * pm reference to avoid underflow. */ if (!atomic_xchg (&xe->wedged.flag,1 ))
@@ -31,7 +31,7 @@ static void prepare_device_for_reset(struct pci_dev *pdev)xe_device_set_in_reset (xe);for_each_gt (gt, xe, id) -xe_gt_declare_wedged (gt); +xe_gt_wedge_declare (gt);pci_disable_device (pdev); }
@@ -61,7 +61,7 @@ static pci_ers_result_t xe_pci_error_detected(struct pci_dev *pdev, pci_channel_return PCI_ERS_RESULT_DISCONNECT ;/* If the device is already wedged or in survivability mode, do not attempt recovery */ -if (xe_survivability_mode_is_boot_enabled (xe) ||xe_device_wedged (xe)) +if (xe_survivability_mode_is_boot_enabled (xe) ||xe_wedged (xe))return PCI_ERS_RESULT_DISCONNECT ;switch (state) {
@@ -86,7 +86,7 @@ static pci_ers_result_t xe_pci_error_mmio_enabled(struct pci_dev *pdev)/* User wants to debug the error, prevent reset */ if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) { -xe_device_declare_wedged (xe); +xe_wedge_declare (xe);return PCI_ERS_RESULT_DISCONNECT ; }
drivers/gpu/drm/xe/xe_ras.c +2 -2
@@ -320,8 +320,8 @@ static u8 handle_core_compute_errors(struct xe_ras_error_array *arr)static void punit_error_handler (struct xe_device *xe) { -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_COLD_RESET ); -xe_device_declare_wedged (xe); +xe_wedge_set_method (xe,DRM_WEDGE_RECOVERY_COLD_RESET ); +xe_wedge_declare (xe); }static u8 handle_soc_internal_errors (struct xe_device *xe,struct xe_ras_error_array *arr)
drivers/gpu/drm/xe/xe_sriov_pf.c +1 -1
@@ -157,7 +157,7 @@ int xe_sriov_pf_wait_ready(struct xe_device *xe)unsigned int id;int err; -if (xe_device_wedged (xe)) +if (xe_wedged (xe))return -ECANCELED ;for_each_gt (gt, xe, id) {
drivers/gpu/drm/xe/xe_survivability_mode.c +2 -2
@@ -446,8 +446,8 @@ void xe_survivability_mode_runtime_enable(struct xe_device *xe) survivability->type =XE_SURVIVABILITY_TYPE_RUNTIME ;xe_log_err (xe,SURVIVABILITY ,0 ,"Runtime Mode enabled!\n" ); -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_VENDOR ); -xe_device_declare_wedged (xe); +xe_wedge_set_method (xe,DRM_WEDGE_RECOVERY_VENDOR ); +xe_wedge_declare (xe);xe_log_err (xe,SURVIVABILITY ,0 ,"Firmware flash required!\n" ); xe_info(xe, "Please refer to the userspace documentation for more details how to flash the firmware on %s!\n",
drivers/gpu/drm/xe/xe_uc.c +3 -3
@@ -326,15 +326,15 @@ void xe_uc_runtime_resume(struct xe_uc *uc) }/** -* xe_uc_declare_wedged() - Declare UC wedged +* xe_uc_wedge_declare() - Declare UC wedged * @uc: the UC object * * Wedge the UC which stops all submission, saves desired debug state, and * cleans up anything which could timeout. */ -void xe_uc_declare_wedged (struct xe_uc *uc) +void xe_uc_wedge_declare (struct xe_uc *uc) {xe_gt_assert (uc_to_gt (uc),uc_to_xe (uc)->wedged.mode); -xe_guc_declare_wedged (&uc->guc); +xe_guc_wedge_declare (&uc->guc); }
drivers/gpu/drm/xe/xe_uc.h +1 -1
@@ -21,6 +21,6 @@ int xe_uc_start(struct xe_uc *uc);void xe_uc_suspend_prepare (struct xe_uc *uc);int xe_uc_suspend (struct xe_uc *uc);int xe_uc_sanitize_reset (struct xe_uc *uc); -void xe_uc_declare_wedged (struct xe_uc *uc); +void xe_uc_wedge_declare (struct xe_uc *uc);#endif
drivers/gpu/drm/xe/xe_wedge.c +17 -17
@@ -54,24 +54,24 @@*/ /** -* xe_device_set_wedged_method() - Set wedge recovery method +* xe_wedge_set_method() - Set wedge recovery method * @xe: xe device instance * @method: recovery method to set * * Set wedge recovery method to be sent in drm wedged uevent. */ -void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method) +void xe_wedge_set_method (struct xe_device *xe,unsigned long method) { xe->wedged.method = method; }/** -* xe_device_wedged() - Check for wedged device +* xe_wedged() - Check for wedged device * @xe: xe device instance * * Returns: %true if device is wedged, %false otherwise. */ -bool xe_device_wedged (struct xe_device *xe) +bool xe_wedged (struct xe_device *xe) {return atomic_read (&xe->wedged.flag); }
@@ -86,11 +86,11 @@ static void wedge_work(struct work_struct *work)* it available to the user for debugging. */ if (xe->wedged.mode ==XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_NONE ); +xe_wedge_set_method (xe,DRM_WEDGE_RECOVERY_NONE );/* If no wedge recovery method is set, use default */ else if (!xe->wedged.method) -xe_device_set_wedged_method (xe,DRM_WEDGE_RECOVERY_REBIND | -DRM_WEDGE_RECOVERY_BUS_RESET ); +xe_wedge_set_method (xe,DRM_WEDGE_RECOVERY_REBIND | +DRM_WEDGE_RECOVERY_BUS_RESET );/* Notify userspace of wedged device */ drm_dev_wedged_event (&xe->drm, xe->wedged.method,NULL );
@@ -100,12 +100,12 @@ static void wedge_work(struct work_struct *work)#define XE_BUG_URL "https://gitlab.freedesktop.org/drm/xe/kernel/issues/new"/** -* xe_device_declare_wedged() - Declare device wedged +* xe_wedge_declare() - Declare device wedged * @xe: xe device instance * * This is a final state that can only be cleared with the recovery method * specified in the drm wedged uevent. The method can be set using -* xe_device_set_wedged_method() before declaring the device as wedged. +* xe_wedge_set_method() before declaring the device as wedged. * If no method is set, rebind/bus-reset will be sent by default. * * In this state every IOCTL will be blocked so the GT cannot be used.
@@ -120,7 +120,7 @@ static void wedge_work(struct work_struct *work)* Since the wedge handling is done as part of worker thread, this is safe for * atomic callers. */ -void xe_device_declare_wedged (struct xe_device *xe) +void xe_wedge_declare (struct xe_device *xe) {struct xe_gt *gt;u8 id;
@@ -143,7 +143,7 @@ void xe_device_declare_wedged(struct xe_device *xe) WEDGED_URL, XE_BUG_URL);for_each_gt (gt, xe, id) -xe_gt_declare_wedged (gt); +xe_gt_wedge_declare (gt);schedule_work (&xe->wedged.work); }
@@ -255,10 +255,10 @@ int xe_wedge_set_mode(struct xe_device *xe, enum xe_wedged_mode mode) }/** -* xe_device_wedged_init_early() - Set wedge mode passed as module parameter +* xe_wedge_init_early() - Set wedge mode passed as module parameter * @xe: xe device instance */ -void xe_device_wedged_init_early (struct xe_device *xe) +void xe_wedge_init_early (struct xe_device *xe) { xe->wedged.mode =wedge_validate_mode (xe, xe_modparam.wedged_mode) ?XE_DEFAULT_WEDGED_MODE : xe_modparam.wedged_mode;
@@ -266,7 +266,7 @@ void xe_device_wedged_init_early(struct xe_device *xe) xe->wedged.mode, wedge_mode_to_string(xe->wedged.mode)); } -static void xe_device_wedged_fini (struct drm_device *drm,void *arg) +static void xe_wedge_fini (struct drm_device *drm,void *arg) {struct xe_device *xe = arg;
@@ -277,12 +277,12 @@ static void xe_device_wedged_fini(struct drm_device *drm, void *arg) }/** -* xe_device_wedged_init() - Initialize wedge +* xe_wedge_init() - Initialize wedge * @xe: xe device instance */ -int xe_device_wedged_init (struct xe_device *xe) +int xe_wedge_init (struct xe_device *xe) {INIT_WORK (&xe->wedged.work, wedge_work); -return drmm_add_action_or_reset (&xe->drm, xe_device_wedged_fini, xe); +return drmm_add_action_or_reset (&xe->drm, xe_wedge_fini, xe); }
drivers/gpu/drm/xe/xe_wedge.h +5 -5
@@ -11,11 +11,11 @@struct xe_device ;enum xe_wedged_mode ; -void xe_device_declare_wedged (struct xe_device *xe); -bool xe_device_wedged (struct xe_device *xe); -void xe_device_wedged_init_early (struct xe_device *xe); -int xe_device_wedged_init (struct xe_device *xe); -void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method); +bool xe_wedged (struct xe_device *xe); +void xe_wedge_declare (struct xe_device *xe); +void xe_wedge_init_early (struct xe_device *xe); +int xe_wedge_init (struct xe_device *xe); +void xe_wedge_set_method (struct xe_device *xe,unsigned long method);int xe_wedge_set_mode (struct xe_device *xe,enum xe_wedged_mode mode);#endif
Signature · 1 line
2.43.0
[email protected]
AI reviewRe: [PATCH v2 5/5] drm/xe/wedge: Update naming to match with xe_wedge
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The function `xe_device_wedged` was renamed to `xe_wedged` across the codebase, but the call sites…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The function xe_device_wedged was renamed to xe_wedged across the codebase, but the call sites in drivers/gpu/drm/xe/xe_guc_pc.c were missed. This will cause an implicit function declaration error and break the build. --
commit 0a6019f57c4cdf740c1b6783f7839f86d0fd9f5c
Author: Raag Jadav <[email protected]>
drm/xe/wedge: Update naming to match with xe_wedge
Now that we have a dedicated xe_wedge component, update all its function names accordingly.
Quoted 4 lines
drivers/gpu/drm/xe/xe_wedge.c +0
-0
[ ... ]
Quoted 19 lines
drivers/gpu/drm/xe/xe_wedge.c +2
-3@@ -54,24 +54,24 @@*/ /** -* xe_device_set_wedged_method() - Set wedge recovery method +* xe_wedge_set_method() - Set wedge recovery method * @xe: xe device instance * @method: recovery method to set * * Set wedge recovery method to be sent in drm wedged uevent. */ -void xe_device_set_wedged_method (struct xe_device *xe,unsigned long method) +void xe_wedge_set_method (struct xe_device *xe,unsigned long method) { xe->wedged.method = method; }/** -* xe_device_wedged() - Check for wedged device
drivers/gpu/drm/xe/xe_wedge.c line 77
Quoted 10 lines
drivers/gpu/drm/xe/xe_wedge.c +2
-1+* xe_wedged() - Check for wedged device * @xe: xe device instance * * Returns: %true if device is wedged, %false otherwise. */ -bool xe_device_wedged (struct xe_device *xe) +bool xe_wedged (struct xe_device *xe) {return atomic_read (&xe->wedged.flag); }
[Severity: Low]
Does this rename break the build by missing call sites in drivers/gpu/drm/xe/xe_guc_pc.c?
Looking at xe_guc_pc.c, it seems xe_device_wedged() is still being called in several places:
drivers/gpu/drm/xe/xe_guc_pc.c:pc_action_reset() {
...
ret = xe_guc_ct_send(ct, action, ARRAY_SIZE(action), 0, 0);
if (ret && !(xe_device_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
xe_gt_err(pc_to_gt(pc), "GuC PC reset failed: %pe\n",
ERR_PTR(ret));
...
}Similar missed renames exist in pc_action_query_task_state(), pc_action_set_param(), pc_action_unset_param(), and xe_guc_pc_fini_hw().
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Patchwork
CI✗ CI.checkpatch: warning for Introduce xe_wedge
In reply to Raag Jadav== Series Details ==
== Series Details ==
Series: Introduce xe_wedge
URL : https://patchwork.freedesktop.org/series/173011/
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 683591ab8823bc0e7a4c95dd97c6e374a7f68ba6
Author: Raag Jadav <[email protected]> Date: Mon Aug 31 09:55:53 2026 +0530
drm/xe/wedge: Update naming to match with xe_wedge
Now that we have a dedicated xe_wedge component, update all its function names accordingly.
No functional impact.
+ /mt/dim checkpatch 046bcac5ed22b09812cec3b0aef678195f1eae71 drm-intel 1a57c3072ca4 drm/xe/gt: Use GT ordered workqueue for wedgingd4157fd48b5a drm/xe: Make xe_device_declare_wedged() IRQ safe68ec5450048c drm/xe: Introduce xe_wedge
-:286: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #286:
new file mode 100644
total: 0 errors, 1 warnings, 0 checks, 487 lines checked53dfde2eedec drm/xe/debugfs: Consolidate wedged_mode debt into xe_wedge
-:312: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #312:
new file mode 100644
total: 0 errors, 1 warnings, 0 checks, 314 lines checked 683591ab8823 drm/xe/wedge: Update naming to match with xe_wedge
Patchwork
CI✗ CI.KUnit: failure for Introduce xe_wedge
In reply to Raag Jadav== Series Details ==
== Series Details ==
Series: Introduce xe_wedge
URL : https://patchwork.freedesktop.org/series/173011/
State : failure
== Summary ==
+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
ERROR:root:../drivers/gpu/drm/xe/xe_guc_pc.c: In function ‘pc_action_reset’:../drivers/gpu/drm/xe/xe_guc_pc.c:191:22: error: implicit declaration of function ‘xe_device_wedged’; did you mean ‘xe_device_get_gt’? [-Werror=implicit-function-declaration]
191 | if (ret && !(xe_device_wedged(pc_to_xe(pc)) && ret == -ECANCELED))
| ^~~~~~~~~~~~~~~~
| xe_device_get_gtcc1: some warnings being treated as errors
make[7]: *** [../scripts/Makefile.build:289: drivers/gpu/drm/xe/xe_guc_pc.o] Error 1 make[7]: *** Waiting for unfinished jobs....
make[6]: *** [../scripts/Makefile.build:549: drivers/gpu/drm/xe] Error 2 make[5]: *** [../scripts/Makefile.build:549: drivers/gpu/drm] Error 2 make[4]: *** [../scripts/Makefile.build:549: drivers/gpu] Error 2 make[3]: *** [../scripts/Makefile.build:549: drivers] Error 2
make[2]: *** [/kernel/Makefile:2187: .] Error 2
make[1]: *** [/kernel/Makefile:248: __sub-make] Error 2
make: *** [Makefile:248: __sub-make] Error 2
[04:33:31] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig [04:33:36] 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 + cleanup ++ stat -c %u:%g /kernel + chown -R 1003:1003 /kernel