ptrace: __ptrace_detach: do __wake_up_parent() if we reap the tracee
Subsystems (2)
Oleg Nesterov
maintainerPATCH 1/1 ptrace: __ptrace_detach: do __wake_up_parent() if we reap the tracee
The bug is old, it wasn't cause by recent changes.
Test case:
static void *tfunc(void *arg)
{
int pid = (long)arg;
assert(ptrace(PTRACE_ATTACH, pid, NULL, NULL) == 0);
kill(pid, SIGKILL);
sleep(1);
return NULL;
}
int main(void)
{
pthread_t th;
long pid = fork();
if (!pid)
pause();
signal(SIGCHLD, SIG_IGN);
assert(pthread_create(&th, NULL, tfunc, (void*)pid) == 0);
int r = waitpid(-1, NULL, __WNOTHREAD);
printf("waitpid: %d %m\n", r);
return 0;
}Before the patch this program hangs, after this patch waitpid() correctly fails with errno == -ECHILD.
The problem is, __ptrace_detach() reaps the EXIT_ZOMBIE tracee if its ->real_parent is our sub-thread and we ignore SIGCHLD. But in this case we should wake up other threads which can sleep in do_wait().
---
include/linux/sched.h | 1 + kernel/signal.c | 9 --------- kernel/exit.c | 5 +++++ kernel/ptrace.c | 11 +++++++---- 4 files changed, 13 insertions(+), 13 deletions(-)
include/linux/sched.h renamed from include/linux/sched.h~PT_DETACH_WAKE_PARENT +1 -0
@@ -1951,6 +1951,7 @@ extern int kill_pgrp(struct pid *pid, inextern int kill_pid (struct pid *pid,int sig,int priv);extern int kill_proc_info (int ,struct siginfo *,pid_t );extern int do_notify_parent (struct task_struct *,int ); +extern void __wake_up_parent (struct task_struct *p,struct task_struct *parent);extern void force_sig (int ,struct task_struct *);extern void force_sig_specific (int ,struct task_struct *);extern int send_sig (int ,struct task_struct *,int );
kernel/signal.c renamed from kernel/signal.c~PT_DETACH_WAKE_PARENT +0 -9
@@ -1383,15 +1383,6 @@ ret: }/* -* Wake up any threads in the parent blocked in wait* syscalls. -*/ -static inline void __wake_up_parent (struct task_struct *p, -struct task_struct *parent) -{ -wake_up_interruptible_sync (&parent->signal->wait_chldexit); -} - -/* * Let a parent know about the death of a child. * For a stopped/continued status change, use do_notify_parent_cldstop instead. *
kernel/exit.c renamed from kernel/exit.c~PT_DETACH_WAKE_PARENT +5 -0
@@ -1563,6 +1563,11 @@ static int ptrace_do_wait(struct wait_opreturn 0 ; } +void __wake_up_parent (struct task_struct *p,struct task_struct *parent) +{ +wake_up_interruptible_sync (&parent->signal->wait_chldexit); +} +static long do_wait (struct wait_opts *wo) {DECLARE_WAITQUEUE (wait, current);
kernel/ptrace.c renamed from kernel/ptrace.c~PT_DETACH_WAKE_PARENT +7 -4
@@ -266,9 +266,10 @@ static int ignoring_children(struct sigh* or self-reaping. Do notification now if it would have happened earlier. * If it should reap itself, return true. * -* If it's our own child, there is no notification to do. -* But if our normal children self-reap, then this child -* was prevented by ptrace and we must reap it now. +* If it's our own child, there is no notification to do. But if our normal +* children self-reap, then this child was prevented by ptrace and we must +* reap it now, in that case we must also wake up sub-threads sleeping in +* do_wait(). */ static bool __ptrace_detach (struct task_struct *tracer,struct task_struct *p) {
@@ -278,8 +279,10 @@ static bool __ptrace_detach(struct task_if (!task_detached (p) &&thread_group_empty (p)) {if (!same_thread_group (p->real_parent, tracer))do_notify_parent (p, p->exit_signal); -else if (ignoring_children (tracer->sighand)) +else if (ignoring_children (tracer->sighand)) { +__wake_up_parent (p, tracer); p->exit_signal =-1 ; + } }if (task_detached (p)) {/* Mark it as in the process of being reaped. */
Oleg Nesterov
maintainerQuoted 18 lines · Oleg Nesterov
kernel/ptrace.c renamed from kernel/ptrace.c~PT_DETACH_WAKE_PARENT +4
-3@@ -266,9 +266,10 @@ static int ignoring_children(struct sigh* or self-reaping. Do notification now if it would have happened earlier. * If it should reap itself, return true. * -* If it's our own child, there is no notification to do. -* But if our normal children self-reap, then this child -* was prevented by ptrace and we must reap it now. +* If it's our own child, there is no notification to do. But if our normal +* children self-reap, then this child was prevented by ptrace and we must +* reap it now, in that case we must also wake up sub-threads sleeping in +* do_wait(). */ static bool __ptrace_detach (struct task_struct *tracer,struct task_struct *p) {
kernel/ptrace.c static bool __ptrace_detach(struct task_ · line 285
Quoted 8 lines
kernel/ptrace.c renamed from kernel/ptrace.c~PT_DETACH_WAKE_PARENT +3
-1@@ -278,8 +279,10 @@ static bool __ptrace_detach(struct task_if (!task_detached (p) &&thread_group_empty (p)) {if (!same_thread_group (p->real_parent, tracer))do_notify_parent (p, p->exit_signal); -else if (ignoring_children (tracer->sighand)) +else if (ignoring_children (tracer->sighand)) { +__wake_up_parent (p, tracer); p->exit_signal =-1 ; + }
I wonder if we need more fixes here.
ignoring_children() is not exactly right afaics, we assume that tracee->exit_signal == SIGCHLD.
But I guess this can be ignored, it falls into "ptracing with SIGCHLD ignored asks for trouble" category.
But !same_thread_group() doesn't look 100% right too, for the same reason. If ->exit_signal != SIGCHLD, we can't assume we already had the correct notification. Hopefully this can be ignored too.
Oleg.