[PATCH i-g-t v3 4/6] tests/intel/xe_fault_injection: Inject errors during xe_guc_ct_send_recv & xe_guc_mmio_send_recv.

[Satyanarayana K V P]

Use the kernel fault injection infrastructure to test error handling
of xe during driver probe when executing xe_guc_ct_send_recv() /
xe_guc_mmio_send_recv() so that more code paths are tested, such as
error handling and unwinding.

All xe_init() kind of functions are called just once during driver probe,
so it is sufficient to fail first/all calls to them. Driver communicates
with the GuC multiple times, and the real failure can happen at different
call, hence the need to inject failure in GuC communication functions,
like guc_mmio_send() or guc_ct_send(), but it can't be just first call or
all calls, but we need to be able to select specific iteration to fail.

To address this problem, the environmental variable IGT_FAULT_INJECT_ITERATION
is used. If the IGT_FAULT_INJECT_ITERATION is not exported, an error will
be injected in every possible function call starting from first up to the
max number of iteration defined by INJECT_ITERATIONS, currently hardcoded
as 100.

Error can be injected using:
igt at xe_fault_injection@probe-fail-guc-xe_guc_ct_send_recv
igt at xe_fault_injection@probe-fail-guc-xe_guc_mmio_send_recv

Signed-off-by: Satyanarayana K V P <satyanarayana.k.v.p at intel.com>
Cc: Michał Wajdeczko <michal.wajdeczko at intel.com>
Cc: Francois Dugast <francois.dugast at intel.com>
---
 tests/intel/xe_fault_injection.c | 44 ++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/tests/intel/xe_fault_injection.c b/tests/intel/xe_fault_injection.c
index 1bf8ef1d8..de9ae02f1 100644
--- a/tests/intel/xe_fault_injection.c
+++ b/tests/intel/xe_fault_injection.c
@@ -25,6 +25,7 @@
 #define INJECT_ERRNO	-ENOMEM
 #define BO_ADDR		0x1a0000
 #define BO_SIZE		(1024*1024)
+#define INJECT_ITERATIONS	100
 
 enum injection_list_action {
 	INJECTION_LIST_ADD,
@@ -45,6 +46,9 @@ struct fault_injection_params {
 /**
  *  Introduce a new environmental variable IGT_FAULT_INJECT_ITERATION
  *  using which an error can be injected at specific function call.
+ *  When unset test will run for INJECT_ITERATIONS iterations.
+ *  When set to <=0 or malformed - same as unset.
+ *  When set to >0 it will run single n-th iteration only.
  */
 static int get_fault_inject_iter(void)
 {
@@ -228,6 +232,33 @@ inject_fault_probe(int fd, char pci_slot[], const char function_name[])
 	injection_list_do(INJECTION_LIST_REMOVE, function_name);
 }
 
+/**
+ * SUBTEST: probe-fail-guc-%s
+ * Description: inject an error in the injectable function %arg[1] then reprobe driver
+ * Functionality: fault
+ *
+ * arg[1]:
+ * @xe_guc_mmio_send_recv:     Inject an error when calling xe_guc_mmio_send_recv
+ * @xe_guc_ct_send_recv:       Inject an error when calling xe_guc_ct_send_recv
+ */
+static void probe_fail_guc(int fd, char pci_slot[], const char function_name[],
+               struct fault_injection_params *fault_params)
+{
+	int iter_start = 0, iter_end = 0, iter = 0;
+
+	igt_assert(fault_params);
+
+	/* Get the iteration count from environment */
+	iter = get_fault_inject_iter();
+	iter_start = iter ? : 0;
+	iter_end = iter ? iter + 1 : INJECT_ITERATIONS;
+	for (int i = iter_start; i < iter_end; i++) {
+		fault_params->space = i;
+		setup_injection_fault(fault_params);
+		inject_fault_probe(fd, pci_slot, function_name);
+	}
+}
+
 static int
 simple_vm_create(int fd, unsigned int flags)
 {
@@ -329,6 +360,7 @@ igt_main
 {
 	int fd;
 	char pci_slot[NAME_MAX];
+	struct fault_injection_params fault_params;
 	const struct section {
 		const char *name;
 		unsigned int flags;
@@ -363,6 +395,11 @@ igt_main
 		{ "xe_sync_entry_parse" },
 		{ }
 	};
+	const struct section guc_fail_functions[] = {
+		{ "xe_guc_mmio_send_recv" },
+		{ "xe_guc_ct_send_recv" },
+		{ }
+	};
 
 	igt_fixture {
 		igt_require(fail_function_injection_enabled());
@@ -386,6 +423,13 @@ igt_main
 	for (const struct section *s = probe_fail_functions; s->name; s++)
 		igt_subtest_f("inject-fault-probe-function-%s", s->name)
 			inject_fault_probe(fd, pci_slot, s->name);
+	
+	for (const struct section *s = guc_fail_functions; s->name; s++)
+		igt_subtest_f("probe-fail-guc-%s", s->name) {
+			memcpy(&fault_params, &default_fault_params,
+					sizeof(struct fault_injection_params));
+			probe_fail_guc(fd, pci_slot, s->name, &fault_params);
+		}
 
 	igt_fixture {
 		drm_close_driver(fd);
-- 
2.35.3