Blob Blame History Raw
From 14ae61f37b7c4ec236f011ab5c5866b43f6766b4 Mon Sep 17 00:00:00 2001
From: "Dmitry V. Levin" <ldv@altlinux.org>
Date: Tue, 14 Aug 2018 13:43:34 +0000
Subject: [PATCH] strace.c: introduce struct tcb_wait_data

Introduce a new structure to pass information between next_event(),
restart_delayed_tcb(), and dispatch_event().

This is going to be used by a subsequent change of next_event().

* strace.c (struct tcb_wait_data): New type.
(next_event): Remove parameters, return a pointer
to const struct tcb_wait_data.  Return NULL instead of TE_BREAK.
(dispatch_event): Replace all parameters with a pointer
to const struct tcb_wait_data, obtain the trace event, siginfo,
and status from its fields.
(restart_delayed_tcb): Add local struct tcb_wait_data variable
with te field set to TE_RESTART, pass it to dispatch_event().
(main): Remove status and si variables, update next_event()
and dispatch_event() invocations.

Co-Authored-by: Eugene Syromyatnikov <evgsyr@gmail.com>
---
 strace.c | 107 ++++++++++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 69 insertions(+), 38 deletions(-)

diff --git a/strace.c b/strace.c
index cd04b98..6d70d20 100644
--- a/strace.c
+++ b/strace.c
@@ -158,6 +158,12 @@ static bool open_append;
 struct tcb *printing_tcp;
 static struct tcb *current_tcp;
 
+struct tcb_wait_data {
+	enum trace_event te; /**< Event passed to dispatch_event() */
+	int status;          /**< status, returned by wait4() */
+	siginfo_t si;        /**< siginfo, returned by PTRACE_GETSIGINFO */
+};
+
 static struct tcb **tcbtab;
 static unsigned int nprocs;
 static size_t tcbtabsize;
@@ -2226,16 +2232,19 @@ print_event_exit(struct tcb *tcp)
 	line_ended();
 }
 
-static enum trace_event
-next_event(int *pstatus, siginfo_t *si)
+static const struct tcb_wait_data *
+next_event(void)
 {
+	static struct tcb_wait_data wait_data;
+
 	int pid;
 	int status;
 	struct tcb *tcp;
+	struct tcb_wait_data *wd = &wait_data;
 	struct rusage ru;
 
 	if (interrupted)
-		return TE_BREAK;
+		return NULL;
 
 	/*
 	 * Used to exit simply when nprocs hits zero, but in this testcase:
@@ -2255,7 +2264,7 @@ next_event(int *pstatus, siginfo_t *si)
 		 * on exit. Oh well...
 		 */
 		if (nprocs == 0)
-			return TE_BREAK;
+			return NULL;
 	}
 
 	const bool unblock_delay_timer = is_delay_timer_armed();
@@ -2278,7 +2287,7 @@ next_event(int *pstatus, siginfo_t *si)
 	 * then the system call will be interrupted and
 	 * the expiration will be handled by the signal handler.
 	 */
-	pid = wait4(-1, pstatus, __WALL, (cflag ? &ru : NULL));
+	pid = wait4(-1, &status, __WALL, (cflag ? &ru : NULL));
 	const int wait_errno = errno;
 
 	/*
@@ -2292,14 +2301,16 @@ next_event(int *pstatus, siginfo_t *si)
 		sigprocmask(SIG_BLOCK, &timer_set, NULL);
 
 		if (restart_failed)
-			return TE_BREAK;
+			return NULL;
 	}
 
 	if (pid < 0) {
-		if (wait_errno == EINTR)
-			return TE_NEXT;
+		if (wait_errno == EINTR) {
+			wd->te = TE_NEXT;
+			return wd;
+		}
 		if (nprocs == 0 && wait_errno == ECHILD)
-			return TE_BREAK;
+			return NULL;
 		/*
 		 * If nprocs > 0, ECHILD is not expected,
 		 * treat it as any other error here:
@@ -2308,12 +2319,13 @@ next_event(int *pstatus, siginfo_t *si)
 		perror_msg_and_die("wait4(__WALL)");
 	}
 
-	status = *pstatus;
+	wd->status = status;
 
 	if (pid == popen_pid) {
 		if (!WIFSTOPPED(status))
 			popen_pid = 0;
-		return TE_NEXT;
+		wd->te = TE_NEXT;
+		return wd;
 	}
 
 	if (debug_flag)
@@ -2324,8 +2336,10 @@ next_event(int *pstatus, siginfo_t *si)
 
 	if (!tcp) {
 		tcp = maybe_allocate_tcb(pid, status);
-		if (!tcp)
-			return TE_NEXT;
+		if (!tcp) {
+			wd->te = TE_NEXT;
+			return wd;
+		}
 	}
 
 	clear_regs(tcp);
@@ -2342,11 +2356,15 @@ next_event(int *pstatus, siginfo_t *si)
 		tcp->stime = stime;
 	}
 
-	if (WIFSIGNALED(status))
-		return TE_SIGNALLED;
+	if (WIFSIGNALED(status)) {
+		wd->te = TE_SIGNALLED;
+		return wd;
+	}
 
-	if (WIFEXITED(status))
-		return TE_EXITED;
+	if (WIFEXITED(status)) {
+		wd->te = TE_EXITED;
+		return wd;
+	}
 
 	/*
 	 * As WCONTINUED flag has not been specified to wait4,
@@ -2373,19 +2391,19 @@ next_event(int *pstatus, siginfo_t *si)
 		if (sig == SIGSTOP && (tcp->flags & TCB_IGNORE_ONE_SIGSTOP)) {
 			debug_func_msg("ignored SIGSTOP on pid %d", tcp->pid);
 			tcp->flags &= ~TCB_IGNORE_ONE_SIGSTOP;
-			return TE_RESTART;
+			wd->te = TE_RESTART;
 		} else if (sig == syscall_trap_sig) {
-			return TE_SYSCALL_STOP;
+			wd->te = TE_SYSCALL_STOP;
 		} else {
-			*si = (siginfo_t) {};
+			memset(&wd->si, 0, sizeof(wd->si));
 			/*
 			 * True if tracee is stopped by signal
 			 * (as opposed to "tracee received signal").
 			 * TODO: shouldn't we check for errno == EINVAL too?
 			 * We can get ESRCH instead, you know...
 			 */
-			bool stopped = ptrace(PTRACE_GETSIGINFO, pid, 0, si) < 0;
-			return stopped ? TE_GROUP_STOP : TE_SIGNAL_DELIVERY_STOP;
+			bool stopped = ptrace(PTRACE_GETSIGINFO, pid, 0, &wd->si) < 0;
+			wd->te = stopped ? TE_GROUP_STOP : TE_SIGNAL_DELIVERY_STOP;
 		}
 		break;
 	case PTRACE_EVENT_STOP:
@@ -2398,16 +2416,23 @@ next_event(int *pstatus, siginfo_t *si)
 		case SIGTSTP:
 		case SIGTTIN:
 		case SIGTTOU:
-			return TE_GROUP_STOP;
+			wd->te = TE_GROUP_STOP;
+			break;
+		default:
+			wd->te = TE_RESTART;
 		}
-		return TE_RESTART;
+		break;
 	case PTRACE_EVENT_EXEC:
-		return TE_STOP_BEFORE_EXECVE;
+		wd->te = TE_STOP_BEFORE_EXECVE;
+		break;
 	case PTRACE_EVENT_EXIT:
-		return TE_STOP_BEFORE_EXIT;
+		wd->te = TE_STOP_BEFORE_EXIT;
+		break;
 	default:
-		return TE_RESTART;
+		wd->te = TE_RESTART;
 	}
+
+	return wd;
 }
 
 static int
@@ -2436,12 +2461,18 @@ trace_syscall(struct tcb *tcp, unsigned int *sig)
 
 /* Returns true iff the main trace loop has to continue. */
 static bool
-dispatch_event(enum trace_event ret, int *pstatus, siginfo_t *si)
+dispatch_event(const struct tcb_wait_data *wd)
 {
 	unsigned int restart_op = PTRACE_SYSCALL;
 	unsigned int restart_sig = 0;
+	enum trace_event te = wd ? wd->te : TE_BREAK;
+	/*
+	 * Copy wd->status to a non-const variable to workaround glibc bugs
+	 * around union wait fixed by glibc commit glibc-2.24~391
+	 */
+	int status = wd ? wd->status : 0;
 
-	switch (ret) {
+	switch (te) {
 	case TE_BREAK:
 		return false;
 
@@ -2469,17 +2500,17 @@ dispatch_event(enum trace_event ret, int *pstatus, siginfo_t *si)
 		break;
 
 	case TE_SIGNAL_DELIVERY_STOP:
-		restart_sig = WSTOPSIG(*pstatus);
-		print_stopped(current_tcp, si, restart_sig);
+		restart_sig = WSTOPSIG(status);
+		print_stopped(current_tcp, &wd->si, restart_sig);
 		break;
 
 	case TE_SIGNALLED:
-		print_signalled(current_tcp, current_tcp->pid, *pstatus);
+		print_signalled(current_tcp, current_tcp->pid, status);
 		droptcb(current_tcp);
 		return true;
 
 	case TE_GROUP_STOP:
-		restart_sig = WSTOPSIG(*pstatus);
+		restart_sig = WSTOPSIG(status);
 		print_stopped(current_tcp, NULL, restart_sig);
 		if (use_seize) {
 			/*
@@ -2494,7 +2525,7 @@ dispatch_event(enum trace_event ret, int *pstatus, siginfo_t *si)
 		break;
 
 	case TE_EXITED:
-		print_exited(current_tcp, current_tcp->pid, *pstatus);
+		print_exited(current_tcp, current_tcp->pid, status);
 		droptcb(current_tcp);
 		return true;
 
@@ -2577,13 +2608,15 @@ dispatch_event(enum trace_event ret, int *pstatus, siginfo_t *si)
 static bool
 restart_delayed_tcb(struct tcb *const tcp)
 {
+	const struct tcb_wait_data wd = { .te = TE_RESTART };
+
 	debug_func_msg("pid %d", tcp->pid);
 
 	tcp->flags &= ~TCB_DELAYED;
 
 	struct tcb *const prev_tcp = current_tcp;
 	current_tcp = tcp;
-	bool ret = dispatch_event(TE_RESTART, NULL, NULL);
+	bool ret = dispatch_event(&wd);
 	current_tcp = prev_tcp;
 
 	return ret;
@@ -2694,9 +2727,7 @@ main(int argc, char *argv[])
 
 	exit_code = !nprocs;
 
-	int status;
-	siginfo_t si;
-	while (dispatch_event(next_event(&status, &si), &status, &si))
+	while (dispatch_event(next_event()))
 		;
 	terminate();
 }
-- 
2.1.4