All of lore.kernel.org
 help / color / mirror / Atom feed
* [RFC] [PATCH i-g-t] tests/intel/xe_fault_injection: Inject errors for VF provision
@ 2025-05-26 14:01 Satyanarayana K V P
  2025-05-27  0:01 ` ✗ Xe.CI.BAT: failure for " Patchwork
                   ` (4 more replies)
  0 siblings, 5 replies; 6+ messages in thread
From: Satyanarayana K V P @ 2025-05-26 14:01 UTC (permalink / raw)
  To: igt-dev; +Cc: Satyanarayana K V P, Michal Wajdeczko

Use the kernel fault injection infrastructure to test error handling of xe
during VF provisioning of various resources like GGTT, contexts, lmem (in
case of DGFX) and doorbells so that more code paths are tested, such as
error handling and unwinding.

The test injects multiple errors into each resource and tests all possible
ways of error handling.

Error can be injected using:
igt@xe_fault_injection@probe-fail-vf-provision-xe_should_fail_vf_provisioning_ggtt
igt@xe_fault_injection@probe-fail-vf-provision-xe_should_fail_vf_provisioning_ctxs
igt@xe_fault_injection@probe-fail-vf-provision-xe_should_fail_vf_provisioning_dbs
igt@xe_fault_injection@probe-fail-vf-provision-xe_should_fail_vf_provisioning_lmem

Signed-off-by: Satyanarayana K V P <satyanarayana.k.v.p@intel.com>
---
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>

Test-With: 20250523073638.24842-1-satyanarayana.k.v.p@intel.com
---
 tests/intel/xe_fault_injection.c | 166 +++++++++++++++++++++++++++++++
 1 file changed, 166 insertions(+)

diff --git a/tests/intel/xe_fault_injection.c b/tests/intel/xe_fault_injection.c
index f9bd5c761..40b5b2e16 100644
--- a/tests/intel/xe_fault_injection.c
+++ b/tests/intel/xe_fault_injection.c
@@ -29,6 +29,42 @@
 #define BO_SIZE		(1024*1024)
 #define INJECT_ITERATIONS	100
 
+enum {
+	VF_PROVISION_MIN  = 0,
+	VF_PROVISION_GGTT = VF_PROVISION_MIN,
+	VF_PROVISION_LMEM,
+	VF_PROVISION_CTXS,
+	VF_PROVISION_DBS,
+	VF_PROVISION_MAX,
+};
+
+enum {
+	VF_PROVISION_ERR_MIN,
+	/* Force resource location invalid  */
+	VF_PROVISION_ERR_EINVAL = VF_PROVISION_ERR_MIN,
+	/* Force resource size bigger than HW limit */
+	VF_PROVISION_ERR_ENOSPC,
+	/* Force resource size to zero */
+	VF_PROVISION_ERR_ENODATA,
+	/* Force resource size larger than received with invalid base address. */
+	VF_PROVISION_ERR_ESRMNT,
+	/* Force resource size smaller than received */
+	VF_PROVISION_ERR_EREMCHG,
+	/* Force resource size larger than received */
+	VF_PROVISION_ERR_EDQUOT,
+	VF_PROVISION_ERR_MAX
+};
+
+int vf_provision_err_inject_list[VF_PROVISION_ERR_MAX] = {
+	-22 /* VF_PROVISION_ERR_EINVAL */,
+	-28 /* VF_PROVISION_ERR_ENOSPC */,
+	-61 /*VF_PROVISION_ERR_ENODATA */,
+	-69 /* VF_PROVISION_ERR_ESRMNT */,
+	-78 /* VF_PROVISION_ERR_EREMCHG */,
+	-122 /* VF_PROVISION_ERR_EDQUOT */
+};
+
+
 int32_t inject_iters_raw;
 struct fault_injection_params {
 	/* @probability: Likelihood of failure injection, in percent. */
@@ -71,6 +107,11 @@ static bool function_is_part_of_guc(const char function_name[])
 	       strstr(function_name, "_wopcm_") != NULL;
 }
 
+static bool function_is_part_of_vf(const char function_name[])
+{
+	return strstr(function_name, "_vf_") != NULL;
+}
+
 static void ignore_faults_in_dmesg(const char function_name[])
 {
 	/* Driver probe is expected to fail in all cases, so ignore in igt_runner */
@@ -87,6 +128,19 @@ static void ignore_faults_in_dmesg(const char function_name[])
 		strcat(regex, "|GT[0-9a-fA-F]*: GuC PC query task state failed:	-ENOMEM");
 	}
 
+	/*
+	 * If VF provisiong faults are injected, Guc and VF provision is
+	 * expected fail. So, ignore failures in igt_runner.
+	 */
+	if (function_is_part_of_vf(function_name)) {
+		strcat(regex, "|GT[0-9a-fA-F]*: GuC init failed with -ENOMEM");
+		strcat(regex, "|GT[0-9a-fA-F]*: Failed to initialize uC .-ENOMEM");
+		strcat(regex, "|GT[0-9a-fA-F]*: VF: Unexpected GGTT reassignment: [0-9] != [0-9]");
+		strcat(regex, "|GT[0-9a-fA-F]*: VF: Unexpected CTXs reassignment: [0-9] != [0-9]");
+		strcat(regex, "|GT[0-9a-fA-F]*: VF: Unexpected DBs reassignment: [0-9] != [0-9]");
+		strcat(regex, "|GT[0-9a-fA-F]*: VF: Unexpected LMEM reassignment: [0-9] != [0-9]");
+	}
+
 	igt_emit_ignore_dmesg_regex(regex);
 }
 
@@ -278,6 +332,103 @@ static void probe_fail_guc(int fd, char pci_slot[], const char function_name[],
 	}
 }
 
+static void get_fault_params(int fault_type, int has_vram,
+			     struct fault_injection_params *fault_params)
+{
+	igt_assert(fault_params);
+
+	igt_debug("has_vram = %d, fault_type = %d\n", has_vram, fault_type);
+
+	if (has_vram) {
+		switch (fault_type) {
+		case VF_PROVISION_GGTT:
+			fault_params->space = 1;
+			break;
+		case VF_PROVISION_LMEM:
+			fault_params->space = 2;
+			break;
+		case VF_PROVISION_CTXS:
+			fault_params->space = 3;
+			break;
+		case VF_PROVISION_DBS:
+			fault_params->space = 4;
+			break;
+		default:
+			return;
+		}
+	} else {
+		switch (fault_type) {
+		case VF_PROVISION_GGTT:
+			fault_params->space = 1;
+			break;
+		case VF_PROVISION_CTXS:
+			fault_params->space = 2;
+			break;
+		case VF_PROVISION_DBS:
+			fault_params->space = 3;
+			break;
+		default:
+			return;
+		}
+	}
+
+	fault_params->times = 1;
+}
+/**
+ * SUBTEST: probe-fail-vf-provision-%s
+ * Description: inject an error in the injectable function %arg[1] then reprobe driver
+ * Functionality: fault
+ *
+ * arg[1]:
+ * @xe_should_fail_vf_provisioning_ggtt:     Inject an error when provisoning ggtt.
+ * @xe_should_fail_vf_provisioning_lmem:     Inject an error when provisoning lmem.
+ * @xe_should_fail_vf_provisioning_ctxs:     Inject an error when provisoning ctxs.
+ * @xe_should_fail_vf_provisioning_dbs:     Inject an error when provisoning dbs.
+ */
+static void probe_fail_vf_provision(int fd, char pci_slot[], const char function_name[],
+               struct fault_injection_params *fault_params)
+{
+	int auto_probe_en = igt_sriov_is_driver_autoprobe_enabled(fd);
+	const char *func_name = "xe_should_fail_vf_provisioning";
+	unsigned int totalvfs = igt_sriov_get_total_vfs(fd);
+	int fault_type, i;
+
+	igt_skip_on(!totalvfs);
+	igt_assert(fault_params);
+
+	if (!strcmp("xe_should_fail_vf_provisioning_ggtt", function_name))
+		fault_type = VF_PROVISION_GGTT;
+	else if (!strcmp("xe_should_fail_vf_provisioning_lmem", function_name))
+		fault_type = VF_PROVISION_LMEM;
+	else if (!strcmp("xe_should_fail_vf_provisioning_ctxs", function_name))
+		fault_type = VF_PROVISION_CTXS;
+	else if (!strcmp("xe_should_fail_vf_provisioning_dbs", function_name))
+		fault_type = VF_PROVISION_DBS;
+	else
+		fault_type = VF_PROVISION_GGTT;
+
+	igt_skip_on(!strcmp("xe_should_fail_vf_provisioning_lmem", function_name) &&
+		    !xe_has_vram(fd));
+
+	ignore_faults_in_dmesg(function_name);
+	for (i = VF_PROVISION_ERR_MIN; i < VF_PROVISION_ERR_MAX; i++) {
+		if (igt_sriov_get_enabled_vfs(fd))
+			igt_sriov_disable_vfs(fd);
+
+		get_fault_params(fault_type, xe_has_vram(fd), fault_params);
+		setup_injection_fault(fault_params);
+
+		injection_list_add(func_name);
+		set_retval(func_name, vf_provision_err_inject_list[i]);
+
+		igt_sriov_enable_driver_autoprobe(fd);
+		igt_sriov_enable_vfs(fd, totalvfs);
+		igt_sriov_disable_vfs(fd);
+		if (!auto_probe_en)
+			igt_sriov_disable_driver_autoprobe(fd);
+		injection_list_remove(func_name);
+	}
+}
 /**
  * SUBTEST: exec-queue-create-fail-%s
  * Description: inject an error in function %arg[1] used in exec queue create IOCTL to make it fail
@@ -551,6 +702,14 @@ igt_main_args("I:", NULL, help_str, opt_handler, NULL)
 		{ }
 	};
 
+	const struct section vf_proviosin_fail_functions[] = {
+		{ "xe_should_fail_vf_provisioning_ggtt" },
+		{ "xe_should_fail_vf_provisioning_lmem" },
+		{ "xe_should_fail_vf_provisioning_ctxs" },
+		{ "xe_should_fail_vf_provisioning_dbs" },
+		{}
+	};
+
 	igt_fixture {
 		igt_require(fail_function_injection_enabled());
 		fd = drm_open_driver(DRIVER_XE);
@@ -586,6 +745,13 @@ igt_main_args("I:", NULL, help_str, opt_handler, NULL)
 		igt_subtest_f("oa-add-config-fail-%s", s->name)
 			oa_add_config_fail(fd, sysfs, devid, s->name);
 
+	for (const struct section *s = vf_proviosin_fail_functions; s->name; s++)
+		igt_subtest_f("probe-fail-vf-provision-%s", s->name) {
+			memcpy(&fault_params, &default_fault_params,
+					sizeof(struct fault_injection_params));
+			probe_fail_vf_provision(fd, pci_slot, s->name, &fault_params);
+		}
+
 	igt_fixture {
 		igt_kmod_unbind("xe", pci_slot);
 	}
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 6+ messages in thread
end of thread, other threads:[~2025-05-27 10:47 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-05-26 14:01 [RFC] [PATCH i-g-t] tests/intel/xe_fault_injection: Inject errors for VF provision Satyanarayana K V P
2025-05-27  0:01 ` ✗ Xe.CI.BAT: failure for " Patchwork
2025-05-27  0:12 ` ✗ Xe.CI.Full: " Patchwork
2025-05-27  0:24 ` ✓ i915.CI.BAT: success " Patchwork
2025-05-27  2:19 ` ✗ i915.CI.Full: failure " Patchwork
2025-05-27 10:46 ` [RFC] [PATCH i-g-t] " Michal Wajdeczko

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.