Unverified Commit 17d3c336 authored by Lukasz Laguna's avatar Lukasz Laguna Committed by Rodrigo Vivi
Browse files

drm/xe: Validate wedged_mode parameter and define enum for modes 



Check correctness of the wedged_mode parameter input to ensure only
supported values are accepted. Additionally, replace magic numbers with
a clearly defined enum.

Signed-off-by: default avatarLukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: default avatarRodrigo Vivi <rodrigo.vivi@intel.com>
Link: https://patch.msgid.link/20260107174741.29163-2-lukasz.laguna@intel.com


Signed-off-by: default avatarRodrigo Vivi <rodrigo.vivi@intel.com>
parent 644673a6

drivers/gpu/drm/xe/xe_debugfs.c

+3 −2
Original line number Diff line number Diff line
@@ -267,8 +267,9 @@ static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf, 
	if (ret)

		return ret;



	if (wedged_mode > 2)

		return -EINVAL;

	ret = xe_device_validate_wedged_mode(xe, wedged_mode);

	if (ret)

		return ret;



	if (xe->wedged.mode == wedged_mode)

		return size;

drivers/gpu/drm/xe/xe_device.c

+48 −6
Original line number Diff line number Diff line
@@ -784,7 +784,10 @@ int xe_device_probe_early(struct xe_device *xe) 
	if (err)

		return err;



	xe->wedged.mode = xe_modparam.wedged_mode;

	xe->wedged.mode = xe_device_validate_wedged_mode(xe, xe_modparam.wedged_mode) ?

			  XE_WEDGED_MODE_DEFAULT : 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));



	err = xe_device_vram_alloc(xe);

	if (err)
@@ -1267,10 +1270,10 @@ static void xe_device_wedged_fini(struct drm_device *drm, void *arg) 
 * 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. Certain critical errors like gt reset failure, firmware failures can cause

 * the device to be wedged. The default recovery method for a wedged state

 * is rebind/bus-reset.

 * 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.
@@ -1335,7 +1338,7 @@ void xe_device_declare_wedged(struct xe_device *xe) 
	struct xe_gt *gt;

	u8 id;



	if (xe->wedged.mode == 0) {

	if (xe->wedged.mode == XE_WEDGED_MODE_NEVER) {

		drm_dbg(&xe->drm, "Wedged mode is forcibly disabled\n");

		return;

	}
@@ -1369,3 +1372,42 @@ void xe_device_declare_wedged(struct xe_device *xe) 
		drm_dev_wedged_event(&xe->drm, xe->wedged.method, NULL);

	}

}



/**

 * 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;

	}



	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>";

	}

}

drivers/gpu/drm/xe/xe_device.h

+2 −0
Original line number Diff line number Diff line
@@ -194,6 +194,8 @@ static inline bool xe_device_wedged(struct xe_device *xe) 


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_device_types.h

+20 −1
Original line number Diff line number Diff line
@@ -46,6 +46,25 @@ struct xe_pat_ops; 
struct xe_pxp;

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,

};



#define XE_WEDGED_MODE_DEFAULT		XE_WEDGED_MODE_UPON_CRITICAL_ERROR

#define XE_WEDGED_MODE_DEFAULT_STR	"upon-critical-error"



#define XE_BO_INVALID_OFFSET	LONG_MAX



#define GRAPHICS_VER(xe) ((xe)->info.graphics_verx100 / 100)
@@ -626,7 +645,7 @@ struct xe_device { 
		/** @wedged.flag: Xe device faced a critical error and is now blocked. */

		atomic_t flag;

		/** @wedged.mode: Mode controlled by kernel parameter and debugfs */

		int mode;

		enum xe_wedged_mode mode;

		/** @wedged.method: Recovery method to be sent in the drm device wedged uevent */

		unsigned long method;

	} wedged;

drivers/gpu/drm/xe/xe_guc_ads.c

+2 −2
Original line number Diff line number Diff line
@@ -451,7 +451,7 @@ static void guc_policies_init(struct xe_guc_ads *ads) 
	ads_blob_write(ads, policies.max_num_work_items,

		       GLOBAL_POLICY_MAX_NUM_WI);



	if (xe->wedged.mode == 2)

	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)

		global_flags |= GLOBAL_POLICY_DISABLE_ENGINE_RESET;



	ads_blob_write(ads, policies.global_flags, global_flags);
@@ -1004,7 +1004,7 @@ int xe_guc_ads_scheduler_policy_toggle_reset(struct xe_guc_ads *ads) 
	policies->dpc_promote_time = ads_blob_read(ads, policies.dpc_promote_time);

	policies->max_num_work_items = ads_blob_read(ads, policies.max_num_work_items);

	policies->is_valid = 1;

	if (xe->wedged.mode == 2)

	if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)

		policies->global_flags |= GLOBAL_POLICY_DISABLE_ENGINE_RESET;

	else

		policies->global_flags &= ~GLOBAL_POLICY_DISABLE_ENGINE_RESET;