hung_task: fix false positive during vfork
[linux-2.6.git] / kernel / ptrace.c
index dcf9f97..a70d2a5 100644 (file)
@@ -23,6 +23,7 @@
 #include <linux/uaccess.h>
 #include <linux/regset.h>
 #include <linux/hw_breakpoint.h>
+#include <linux/cn_proc.h>
 
 
 static int ptrace_trapping_sleep_fn(void *flags)
@@ -146,7 +147,8 @@ int ptrace_check_attach(struct task_struct *child, bool ignore_state)
                 */
                spin_lock_irq(&child->sighand->siglock);
                WARN_ON_ONCE(task_is_stopped(child));
-               if (task_is_traced(child) || ignore_state)
+               if (ignore_state || (task_is_traced(child) &&
+                                    !(child->jobctl & JOBCTL_LISTENING)))
                        ret = 0;
                spin_unlock_irq(&child->sighand->siglock);
        }
@@ -304,9 +306,12 @@ unlock_tasklist:
 unlock_creds:
        mutex_unlock(&task->signal->cred_guard_mutex);
 out:
-       if (!retval)
+       if (!retval) {
                wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT,
                            ptrace_trapping_sleep_fn, TASK_UNINTERRUPTIBLE);
+               proc_ptrace_connector(task, PTRACE_ATTACH);
+       }
+
        return retval;
 }
 
@@ -369,25 +374,27 @@ static int ignoring_children(struct sighand_struct *sigh)
  */
 static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
 {
+       bool dead;
+
        __ptrace_unlink(p);
 
-       if (p->exit_state == EXIT_ZOMBIE) {
-               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)) {
-                               __wake_up_parent(p, tracer);
-                               p->exit_signal = -1;
-                       }
-               }
-               if (task_detached(p)) {
-                       /* Mark it as in the process of being reaped. */
-                       p->exit_state = EXIT_DEAD;
-                       return true;
+       if (p->exit_state != EXIT_ZOMBIE)
+               return false;
+
+       dead = !thread_group_leader(p);
+
+       if (!dead && thread_group_empty(p)) {
+               if (!same_thread_group(p->real_parent, tracer))
+                       dead = do_notify_parent(p, p->exit_signal);
+               else if (ignoring_children(tracer->sighand)) {
+                       __wake_up_parent(p, tracer);
+                       dead = true;
                }
        }
-
-       return false;
+       /* Mark it as in the process of being reaped. */
+       if (dead)
+               p->exit_state = EXIT_DEAD;
+       return dead;
 }
 
 static int ptrace_detach(struct task_struct *child, unsigned int data)
@@ -412,6 +419,7 @@ static int ptrace_detach(struct task_struct *child, unsigned int data)
        }
        write_unlock_irq(&tasklist_lock);
 
+       proc_ptrace_connector(child, PTRACE_DETACH);
        if (unlikely(dead))
                release_task(child);
 
@@ -658,10 +666,12 @@ static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
 int ptrace_request(struct task_struct *child, long request,
                   unsigned long addr, unsigned long data)
 {
+       bool seized = child->ptrace & PT_SEIZED;
        int ret = -EIO;
-       siginfo_t siginfo;
+       siginfo_t siginfo, *si;
        void __user *datavp = (void __user *) data;
        unsigned long __user *datalp = datavp;
+       unsigned long flags;
 
        switch (request) {
        case PTRACE_PEEKTEXT:
@@ -694,6 +704,59 @@ int ptrace_request(struct task_struct *child, long request,
                        ret = ptrace_setsiginfo(child, &siginfo);
                break;
 
+       case PTRACE_INTERRUPT:
+               /*
+                * Stop tracee without any side-effect on signal or job
+                * control.  At least one trap is guaranteed to happen
+                * after this request.  If @child is already trapped, the
+                * current trap is not disturbed and another trap will
+                * happen after the current trap is ended with PTRACE_CONT.
+                *
+                * The actual trap might not be PTRACE_EVENT_STOP trap but
+                * the pending condition is cleared regardless.
+                */
+               if (unlikely(!seized || !lock_task_sighand(child, &flags)))
+                       break;
+
+               /*
+                * INTERRUPT doesn't disturb existing trap sans one
+                * exception.  If ptracer issued LISTEN for the current
+                * STOP, this INTERRUPT should clear LISTEN and re-trap
+                * tracee into STOP.
+                */
+               if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP)))
+                       signal_wake_up(child, child->jobctl & JOBCTL_LISTENING);
+
+               unlock_task_sighand(child, &flags);
+               ret = 0;
+               break;
+
+       case PTRACE_LISTEN:
+               /*
+                * Listen for events.  Tracee must be in STOP.  It's not
+                * resumed per-se but is not considered to be in TRACED by
+                * wait(2) or ptrace(2).  If an async event (e.g. group
+                * stop state change) happens, tracee will enter STOP trap
+                * again.  Alternatively, ptracer can issue INTERRUPT to
+                * finish listening and re-trap tracee into STOP.
+                */
+               if (unlikely(!seized || !lock_task_sighand(child, &flags)))
+                       break;
+
+               si = child->last_siginfo;
+               if (likely(si && (si->si_code >> 8) == PTRACE_EVENT_STOP)) {
+                       child->jobctl |= JOBCTL_LISTENING;
+                       /*
+                        * If NOTIFY is set, it means event happened between
+                        * start of this trap and now.  Trigger re-trap.
+                        */
+                       if (child->jobctl & JOBCTL_TRAP_NOTIFY)
+                               signal_wake_up(child, true);
+                       ret = 0;
+               }
+               unlock_task_sighand(child, &flags);
+               break;
+
        case PTRACE_DETACH:      /* detach a process that was attached. */
                ret = ptrace_detach(child, data);
                break;
@@ -819,7 +882,8 @@ SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,
                goto out_put_task_struct;
        }
 
-       ret = ptrace_check_attach(child, request == PTRACE_KILL);
+       ret = ptrace_check_attach(child, request == PTRACE_KILL ||
+                                 request == PTRACE_INTERRUPT);
        if (ret < 0)
                goto out_put_task_struct;
 
@@ -961,7 +1025,8 @@ asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
                goto out_put_task_struct;
        }
 
-       ret = ptrace_check_attach(child, request == PTRACE_KILL);
+       ret = ptrace_check_attach(child, request == PTRACE_KILL ||
+                                 request == PTRACE_INTERRUPT);
        if (!ret)
                ret = compat_arch_ptrace(child, request, addr, data);