[PATCH i-g-t 2/2] tests/core_hotunplug: Add exec-fork-unbind-rebind subtest

[Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>]

Add coverage for unbind/rebind with live child-process GPU handles.

Signed-off-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
Cc: Janusz Krzysztofik <janusz.krzysztofik@linux.intel.com>
Cc: Lukasz Laguna <lukasz.laguna@intel.com>
Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Stuart Summers <stuart.summers@intel.com>
---
 tests/core_hotunplug.c | 98 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)

diff --git a/tests/core_hotunplug.c b/tests/core_hotunplug.c
index 7c9dae1bf..2e5aa8d5c 100644
--- a/tests/core_hotunplug.c
+++ b/tests/core_hotunplug.c
@@ -605,6 +605,92 @@ static void hotunbind_rebind(struct hotunplug *priv)
 	igt_assert_f(healthcheck(priv, false), "%s\n", priv->failure);
 }
 
+/*
+ * Start a spinner in a child process, then end it while keeping child-side
+ * handles alive. Verifies the parent can unbind and rebind the driver while
+ * those child handles are still open.
+ */
+static void exec_fork_unbind_rebind_run(struct hotunplug *priv)
+{
+	struct igt_helper_process child = {};
+	int ready_pipe[2], stop_pipe[2];
+	char msg = 0;
+
+	igt_assert_eq(pipe(ready_pipe), 0);
+	igt_assert_eq(pipe(stop_pipe), 0);
+
+	igt_fork_helper(&child) {
+		const intel_ctx_t *ctx = NULL;
+		uint64_t ahnd = 0;
+		igt_spin_t *spin;
+		int fd;
+
+		close(ready_pipe[0]);
+		close(stop_pipe[1]);
+
+		fd = local_drm_open_driver(false, "", " for spinner workload child");
+
+		if (is_i915_device(fd)) {
+			ctx = intel_ctx_create_all_physical(fd);
+			ahnd = get_reloc_ahnd(fd, ctx->id);
+			spin = igt_spin_new(fd, .ahnd = ahnd, .ctx = ctx,
+					    .flags = IGT_SPIN_POLL_RUN);
+		} else {
+			ahnd = intel_allocator_open(fd, 0, INTEL_ALLOCATOR_RELOC);
+			spin = igt_spin_new(fd, .ahnd = ahnd);
+		}
+
+		igt_spin_busywait_until_started(spin);
+		igt_spin_end(spin);
+
+		msg = 1;
+		igt_assert_eq(write(ready_pipe[1], &msg, sizeof(msg)), sizeof(msg));
+		close(ready_pipe[1]);
+
+		/*
+		 * Block until parent completes the driver unbind.
+		 * Intentionally skip spinner teardown: we want handles (ex. exec_queue) to
+		 * remain alive until fd close.
+		 */
+		read(stop_pipe[0], &msg, sizeof(msg));
+		close(stop_pipe[0]);
+
+		if (ahnd)
+			put_ahnd(ahnd);
+		fd = close_device(fd, "child late ", "rebound ");
+		igt_assert_eq(fd, -1);
+	}
+
+	close(ready_pipe[1]);
+	close(stop_pipe[0]);
+
+	igt_assert_eq(read(ready_pipe[0], &msg, sizeof(msg)), sizeof(msg));
+	close(ready_pipe[0]);
+
+	driver_unbind(priv, "", 0);
+
+	close(stop_pipe[1]);
+	igt_wait_helper(&child);
+
+	driver_bind(priv, 0);
+}
+
+/**
+ * SUBTEST: exec-fork-unbind-rebind
+ * Description: Check if the driver can be cleanly unbound and rebound while
+ *		child-process handles remain open
+ */
+static void exec_fork_unbind_rebind(struct hotunplug *priv)
+{
+	igt_require(priv->chipset == DRIVER_INTEL || priv->chipset == DRIVER_XE);
+
+	pre_check(priv);
+
+	exec_fork_unbind_rebind_run(priv);
+
+	igt_assert_f(healthcheck(priv, false), "%s\n", priv->failure);
+}
+
 static void hotunplug_rescan(struct hotunplug *priv)
 {
 	pre_check(priv);
@@ -757,6 +843,18 @@ int igt_main()
 			recover(&priv);
 	}
 
+	igt_fixture()
+		post_healthcheck(&priv);
+
+	igt_subtest_group() {
+		igt_describe("Check if the driver can be cleanly unbound and rebound while child-process handles remain open");
+		igt_subtest("exec-fork-unbind-rebind")
+			exec_fork_unbind_rebind(&priv);
+
+		igt_fixture()
+			recover(&priv);
+	}
+
 	igt_fixture()
 		post_healthcheck(&priv);
 
-- 
2.43.0