[PATCH i-g-t v2 04/66] lib/xe_eudebug: Allow client to wait for debugger

[Christoph Manszewski <christoph.manszewski@intel.com>]

From: Mika Kuoppala <mika.kuoppala@linux.intel.com>

In some tests, we need to pause the client into a certain
stage it has setup so that debugger can then examine that
setup and crosscheck.

Add a possibility to pause client and debugger to signal
continuation.

We need to take into account that the debugger might
disappear before signaling continuation so a timeout
mechanism for all pipe token reads needs to be added.

Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Cc: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
---
 lib/xe/xe_eudebug.c | 159 +++++++++++++++++++++++++++++++++-----------
 lib/xe/xe_eudebug.h |   8 ++-
 2 files changed, 129 insertions(+), 38 deletions(-)

diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
index 6f14bf374..caca91d1e 100644
--- a/lib/xe/xe_eudebug.c
+++ b/lib/xe/xe_eudebug.c
@@ -24,6 +24,7 @@ struct event_trigger {
 #define CLIENT_RUN  2
 #define CLIENT_FINI 3
 #define CLIENT_STOP 4
+#define CLIENT_STAGE 5
 
 #define DEBUGGER_WORKER_INACTIVE  0
 #define DEBUGGER_WORKER_ACTIVE  1
@@ -129,9 +130,10 @@ static void catch_child_failure(void)
 	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
 }
 
-static int safe_pipe_read(int pipe[2], void *buf, int nbytes)
+static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
 {
 	int ret;
+	int t = 0;
 	struct pollfd fd = {
 		.fd = pipe[0],
 		.events = POLLIN,
@@ -142,36 +144,33 @@ static int safe_pipe_read(int pipe[2], void *buf, int nbytes)
 	 * the child process ended with an error.
 	 */
 	do {
-		ret = poll(&fd, 1, 1000);
+		const int interval_ms = 1000;
 
-		if (!ret)
+		ret = poll(&fd, 1, interval_ms);
+
+		if (!ret) {
 			catch_child_failure();
-	} while (!ret);
+			t += interval_ms;
+		}
+	} while (!ret && t < timeout_ms);
 
-	return read(pipe[0], buf, nbytes);
+	if (ret > 0)
+		return read(pipe[0], buf, nbytes);
+
+	return 0;
 }
 
-static uint64_t pipe_wait_u64(int pipe[2])
+static uint64_t pipe_read(int pipe[2], int timeout_ms)
 {
 	uint64_t in;
 	uint64_t ret;
 
-	ret = safe_pipe_read(pipe, &in, sizeof(in));
+	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
 	igt_assert(ret == sizeof(in));
 
 	return in;
 }
 
-#define pipe_wait pipe_wait_u64
-
-static void pipe_wait_token(int pipe[2], uint64_t token)
-{
-	uint64_t in;
-
-	in = pipe_wait_u64(pipe);
-	igt_assert_eq(token, in);
-}
-
 static void pipe_signal(int pipe[2], uint64_t token)
 {
 	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
@@ -186,6 +185,42 @@ static void pipe_close(int pipe[2])
 		close(pipe[1]);
 }
 
+static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
+{
+	uint64_t in;
+
+	in = pipe_read(p, timeout_ms);
+
+	igt_assert_eq(in, token);
+
+	return pipe_read(p, timeout_ms);
+}
+
+static uint64_t client_wait_token(struct xe_eudebug_client *c,
+				 const uint64_t token)
+{
+	return __wait_token(c->p_in, token, c->timeout_ms);
+}
+
+static uint64_t wait_from_client(struct xe_eudebug_client *c,
+				 const uint64_t token)
+{
+	return __wait_token(c->p_out, token, c->timeout_ms);
+}
+
+static void token_signal(int p[2], const uint64_t token, const uint64_t value)
+{
+	pipe_signal(p, token);
+	pipe_signal(p, value);
+}
+
+static void client_signal(struct xe_eudebug_client *c,
+			  const uint64_t token,
+			  const uint64_t value)
+{
+	token_signal(c->p_out, token, value);
+}
+
 static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
 {
 	struct drm_xe_eudebug_connect param = {
@@ -741,24 +776,28 @@ void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
 /**
  * xe_eudebug_debugger_attach:
  * @d: pointer to the debugger
- * @target: pid of the process to attach debugger
+ * @c: pointer to the client
  *
- * Opens the xe eu debugger connection to the @target proccess.
+ * Opens the xe eu debugger connection to the process described by @c (c->pid)
  *
  * Returns: 0 if the debugger was successfully attached, -errno otherwise.
  */
-int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d, pid_t target)
+int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
+			       struct xe_eudebug_client *c)
 {
 	int ret;
 
 	igt_assert_eq(d->fd, -1);
-	ret = xe_eudebug_connect(d->master_fd, target, 0);
+	igt_assert_neq(c->pid, 0);
+	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
 
 	if (ret < 0)
 		return ret;
 
 	d->fd = ret;
-	d->target_pid = target;
+	d->target_pid = c->pid;
+	d->p_client[0] = c->p_in[0];
+	d->p_client[1] = c->p_in[1];
 
 	igt_debug("debugger connected to %lu\n", d->target_pid);
 
@@ -854,6 +893,19 @@ void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
 	event_log_sort(d->log);
 }
 
+/**
+ * xe_eudebug_debugger_signal_stage:
+ * @d: pointer to the debugger
+ * @stage: stage to signal
+ *
+ * Signals to client, waiting in xe_eudebug_client_wait_stage(),
+ * releasing it to proceed.
+ */
+void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
+{
+	token_signal(d->p_client, CLIENT_STAGE, stage);
+}
+
 /**
  * xe_eudebug_client_create:
  * @master_fd: xe client used to open the debugger connection
@@ -885,8 +937,11 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cli
 	c->done = 0;
 	c->ptr = data;
 	c->master_fd = master_fd;
+	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
 
 	igt_fork(child, 1) {
+		int mypid;
+
 		igt_assert_eq(c->pid, 0);
 
 		close(c->p_out[0]);
@@ -894,17 +949,20 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cli
 		close(c->p_in[1]);
 		c->p_in[1] = -1;
 
-		pipe_signal(c->p_out, CLIENT_PID);
-		pipe_signal(c->p_out, getpid());
+		mypid = getpid();
+		client_signal(c, CLIENT_PID, mypid);
 
-		pipe_wait_token(c->p_in, CLIENT_RUN);
-		work(c);
-		pipe_signal(c->p_out, CLIENT_FINI);
+		c->pid = client_wait_token(c, CLIENT_RUN);
+		igt_assert_eq(c->pid, mypid);
+		if (work)
+			work(c);
+
+		client_signal(c, CLIENT_FINI, c->seqno);
 
-		igt_assert_eq(c->pid, 0);
 		event_log_write_to_fd(c->log, c->p_out[1]);
-		pipe_signal(c->p_out, c->seqno);
-		pipe_wait_token(c->p_in, CLIENT_STOP);
+
+		c->pid = client_wait_token(c, CLIENT_STOP);
+		igt_assert_eq(c->pid, mypid);
 	}
 
 	close(c->p_out[1]);
@@ -912,8 +970,7 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cli
 	close(c->p_in[0]);
 	c->p_in[0] = -1;
 
-	pipe_wait_token(c->p_out, CLIENT_PID);
-	c->pid = pipe_wait(c->p_out);
+	c->pid = wait_from_client(c, CLIENT_PID);
 
 	igt_info("client running with pid %d\n", c->pid);
 
@@ -933,7 +990,7 @@ void xe_eudebug_client_stop(struct xe_eudebug_client *c)
 
 		xe_eudebug_client_wait_done(c);
 
-		pipe_signal(c->p_in, CLIENT_STOP);
+		token_signal(c->p_in, CLIENT_STOP, c->pid);
 		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
 			      c->pid);
 		c->pid = 0;
@@ -977,7 +1034,7 @@ uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
  */
 void xe_eudebug_client_start(struct xe_eudebug_client *c)
 {
-	pipe_signal(c->p_in, CLIENT_RUN);
+	token_signal(c->p_in, CLIENT_RUN, c->pid);
 }
 
 /**
@@ -991,12 +1048,40 @@ void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
 {
 	if (!c->done) {
 		c->done = 1;
-		pipe_wait_token(c->p_out, CLIENT_FINI);
+		c->seqno = wait_from_client(c, CLIENT_FINI);
 		event_log_read_from_fd(c->log, c->p_out[0]);
-		c->seqno = pipe_wait(c->p_out);
 	}
 }
 
+/**
+ * xe_eudebug_client_wait_stage:
+ * @c: pointer to xe_eudebug_client structure
+ * @stage: stage to wait on
+ *
+ * Pauses client until the debugger has signalled the corresponding stage with
+ * xe_eudebug_debugger_signal_stage. This is only for situations where the
+ * actual event flow is not enough to coordinate between client/debugger and extra
+ * sync mechanism is needed.
+ *
+ */
+void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
+{
+	u64 stage_in;
+
+	if (c->done) {
+		igt_warn("client: %d already done before %lu\n", c->pid, stage);
+		return;
+	}
+
+	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
+
+	stage_in = client_wait_token(c, CLIENT_STAGE);
+	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
+
+	igt_assert_eq(stage_in, stage);
+}
+
+
 /**
  * xe_eudebug_session_create:
  * @fd: XE file descriptor
@@ -1037,7 +1122,7 @@ void xe_eudebug_session_run(struct xe_eudebug_session *s)
 	struct xe_eudebug_debugger *debugger = s->d;
 	struct xe_eudebug_client *client = s->c;
 
-	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client->pid), 0);
+	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
 
 	xe_eudebug_debugger_start_worker(debugger);
 
diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
index a0cae245d..5ec63e46b 100644
--- a/lib/xe/xe_eudebug.h
+++ b/lib/xe/xe_eudebug.h
@@ -36,6 +36,7 @@ struct xe_eudebug_debugger {
 	pthread_t worker_thread;
 	int worker_state;
 
+	int p_client[2];
 };
 
 struct xe_eudebug_client {
@@ -54,6 +55,8 @@ struct xe_eudebug_client {
 
 	/* Used to pickup right device (the one used in debugger) */
 	int master_fd;
+
+	int timeout_ms;
 };
 
 struct xe_eudebug_session {
@@ -110,13 +113,14 @@ void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l);
 struct xe_eudebug_debugger *
 xe_eudebug_debugger_create(int xe, uint64_t flags, void *data);
 void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d);
-int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d, pid_t pid);
+int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d, struct xe_eudebug_client *c);
 void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d);
 void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d, int timeout_s);
 void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
 void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
 void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
 				     xe_eudebug_trigger_fn fn);
+void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
 
 struct xe_eudebug_client *
 xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
@@ -124,6 +128,8 @@ void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
 void xe_eudebug_client_start(struct xe_eudebug_client *c);
 void xe_eudebug_client_stop(struct xe_eudebug_client *c);
 void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
+void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
+
 uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
 void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
 
-- 
2.34.1