hung_task: fix false positive during vfork
[linux-2.6.git] / kernel / ptrace.c
index e609843..a70d2a5 100644 (file)
 #include <linux/syscalls.h>
 #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)
+{
+       schedule();
+       return 0;
+}
+
 /*
  * ptrace a task: make the debugger its new parent and
  * move it to the ptrace list.
@@ -41,7 +49,26 @@ void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
  * __ptrace_unlink - unlink ptracee and restore its execution state
  * @child: ptracee to be unlinked
  *
- * Remove @child from the ptrace list, move it back to the original parent.
+ * Remove @child from the ptrace list, move it back to the original parent,
+ * and restore the execution state so that it conforms to the group stop
+ * state.
+ *
+ * Unlinking can happen via two paths - explicit PTRACE_DETACH or ptracer
+ * exiting.  For PTRACE_DETACH, unless the ptracee has been killed between
+ * ptrace_check_attach() and here, it's guaranteed to be in TASK_TRACED.
+ * If the ptracer is exiting, the ptracee can be in any state.
+ *
+ * After detach, the ptracee should be in a state which conforms to the
+ * group stop.  If the group is stopped or in the process of stopping, the
+ * ptracee should be put into TASK_STOPPED; otherwise, it should be woken
+ * up from TASK_TRACED.
+ *
+ * If the ptracee is in TASK_TRACED and needs to be moved to TASK_STOPPED,
+ * it goes through TRACED -> RUNNING -> STOPPED transition which is similar
+ * to but in the opposite direction of what happens while attaching to a
+ * stopped task.  However, in this direction, the intermediate RUNNING
+ * state is not hidden even from the current ptracer and if it immediately
+ * re-attaches and performs a WNOHANG wait(2), it may fail.
  *
  * CONTEXT:
  * write_lock_irq(tasklist_lock)
@@ -55,32 +82,53 @@ void __ptrace_unlink(struct task_struct *child)
        list_del_init(&child->ptrace_entry);
 
        spin_lock(&child->sighand->siglock);
-       if (task_is_traced(child)) {
-               /*
-                * If group stop is completed or in progress, it should
-                * participate in the group stop.  Set GROUP_STOP_PENDING
-                * before kicking it.
-                *
-                * This involves TRACED -> RUNNING -> STOPPED transition
-                * which is similar to but in the opposite direction of
-                * what happens while attaching to a stopped task.
-                * However, in this direction, the intermediate RUNNING
-                * state is not hidden even from the current ptracer and if
-                * it immediately re-attaches and performs a WNOHANG
-                * wait(2), it may fail.
-                */
-               if (child->signal->flags & SIGNAL_STOP_STOPPED ||
-                   child->signal->group_stop_count)
-                       child->group_stop |= GROUP_STOP_PENDING;
-               signal_wake_up(child, 1);
-       }
+
+       /*
+        * Clear all pending traps and TRAPPING.  TRAPPING should be
+        * cleared regardless of JOBCTL_STOP_PENDING.  Do it explicitly.
+        */
+       task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK);
+       task_clear_jobctl_trapping(child);
+
+       /*
+        * Reinstate JOBCTL_STOP_PENDING if group stop is in effect and
+        * @child isn't dead.
+        */
+       if (!(child->flags & PF_EXITING) &&
+           (child->signal->flags & SIGNAL_STOP_STOPPED ||
+            child->signal->group_stop_count))
+               child->jobctl |= JOBCTL_STOP_PENDING;
+
+       /*
+        * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick
+        * @child in the butt.  Note that @resume should be used iff @child
+        * is in TASK_TRACED; otherwise, we might unduly disrupt
+        * TASK_KILLABLE sleeps.
+        */
+       if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child))
+               signal_wake_up(child, task_is_traced(child));
+
        spin_unlock(&child->sighand->siglock);
 }
 
-/*
- * Check that we have indeed attached to the thing..
+/**
+ * ptrace_check_attach - check whether ptracee is ready for ptrace operation
+ * @child: ptracee to check for
+ * @ignore_state: don't check whether @child is currently %TASK_TRACED
+ *
+ * Check whether @child is being ptraced by %current and ready for further
+ * ptrace operations.  If @ignore_state is %false, @child also should be in
+ * %TASK_TRACED state and on return the child is guaranteed to be traced
+ * and not executing.  If @ignore_state is %true, @child can be in any
+ * state.
+ *
+ * CONTEXT:
+ * Grabs and releases tasklist_lock and @child->sighand->siglock.
+ *
+ * RETURNS:
+ * 0 on success, -ESRCH if %child is not ready.
  */
-int ptrace_check_attach(struct task_struct *child, int kill)
+int ptrace_check_attach(struct task_struct *child, bool ignore_state)
 {
        int ret = -ESRCH;
 
@@ -93,21 +141,20 @@ int ptrace_check_attach(struct task_struct *child, int kill)
         */
        read_lock(&tasklist_lock);
        if ((child->ptrace & PT_PTRACED) && child->parent == current) {
-               ret = 0;
                /*
                 * child->sighand can't be NULL, release_task()
                 * does ptrace_unlink() before __exit_signal().
                 */
                spin_lock_irq(&child->sighand->siglock);
-               if (task_is_stopped(child))
-                       child->state = TASK_TRACED;
-               else if (!task_is_traced(child) && !kill)
-                       ret = -ESRCH;
+               WARN_ON_ONCE(task_is_stopped(child));
+               if (ignore_state || (task_is_traced(child) &&
+                                    !(child->jobctl & JOBCTL_LISTENING)))
+                       ret = 0;
                spin_unlock_irq(&child->sighand->siglock);
        }
        read_unlock(&tasklist_lock);
 
-       if (!ret && !kill)
+       if (!ret && !ignore_state)
                ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH;
 
        /* All systems go.. */
@@ -132,21 +179,24 @@ int __ptrace_may_access(struct task_struct *task, unsigned int mode)
                return 0;
        rcu_read_lock();
        tcred = __task_cred(task);
-       if ((cred->uid != tcred->euid ||
-            cred->uid != tcred->suid ||
-            cred->uid != tcred->uid  ||
-            cred->gid != tcred->egid ||
-            cred->gid != tcred->sgid ||
-            cred->gid != tcred->gid) &&
-           !capable(CAP_SYS_PTRACE)) {
-               rcu_read_unlock();
-               return -EPERM;
-       }
+       if (cred->user->user_ns == tcred->user->user_ns &&
+           (cred->uid == tcred->euid &&
+            cred->uid == tcred->suid &&
+            cred->uid == tcred->uid  &&
+            cred->gid == tcred->egid &&
+            cred->gid == tcred->sgid &&
+            cred->gid == tcred->gid))
+               goto ok;
+       if (ns_capable(tcred->user->user_ns, CAP_SYS_PTRACE))
+               goto ok;
+       rcu_read_unlock();
+       return -EPERM;
+ok:
        rcu_read_unlock();
        smp_rmb();
        if (task->mm)
                dumpable = get_dumpable(task->mm);
-       if (!dumpable && !capable(CAP_SYS_PTRACE))
+       if (!dumpable && !task_ns_capable(task, CAP_SYS_PTRACE))
                return -EPERM;
 
        return security_ptrace_access_check(task, mode);
@@ -161,11 +211,28 @@ bool ptrace_may_access(struct task_struct *task, unsigned int mode)
        return !err;
 }
 
-static int ptrace_attach(struct task_struct *task)
+static int ptrace_attach(struct task_struct *task, long request,
+                        unsigned long flags)
 {
-       bool wait_trap = false;
+       bool seize = (request == PTRACE_SEIZE);
        int retval;
 
+       /*
+        * SEIZE will enable new ptrace behaviors which will be implemented
+        * gradually.  SEIZE_DEVEL is used to prevent applications
+        * expecting full SEIZE behaviors trapping on kernel commits which
+        * are still in the process of implementing them.
+        *
+        * Only test programs for new ptrace behaviors being implemented
+        * should set SEIZE_DEVEL.  If unset, SEIZE will fail with -EIO.
+        *
+        * Once SEIZE behaviors are completely implemented, this flag and
+        * the following test will be removed.
+        */
+       retval = -EIO;
+       if (seize && !(flags & PTRACE_SEIZE_DEVEL))
+               goto out;
+
        audit_ptrace(task);
 
        retval = -EPERM;
@@ -197,16 +264,21 @@ static int ptrace_attach(struct task_struct *task)
                goto unlock_tasklist;
 
        task->ptrace = PT_PTRACED;
-       if (capable(CAP_SYS_PTRACE))
+       if (seize)
+               task->ptrace |= PT_SEIZED;
+       if (task_ns_capable(task, CAP_SYS_PTRACE))
                task->ptrace |= PT_PTRACE_CAP;
 
        __ptrace_link(task, current);
-       send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
+
+       /* SEIZE doesn't trap tracee on attach */
+       if (!seize)
+               send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
 
        spin_lock(&task->sighand->siglock);
 
        /*
-        * If the task is already STOPPED, set GROUP_STOP_PENDING and
+        * If the task is already STOPPED, set JOBCTL_TRAP_STOP and
         * TRAPPING, and kick it so that it transits to TRACED.  TRAPPING
         * will be cleared if the child completes the transition or any
         * event which clears the group stop states happens.  We'll wait
@@ -222,11 +294,9 @@ static int ptrace_attach(struct task_struct *task)
         * The following task_is_stopped() test is safe as both transitions
         * in and out of STOPPED are protected by siglock.
         */
-       if (task_is_stopped(task)) {
-               task->group_stop |= GROUP_STOP_PENDING | GROUP_STOP_TRAPPING;
+       if (task_is_stopped(task) &&
+           task_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING))
                signal_wake_up(task, 1);
-               wait_trap = true;
-       }
 
        spin_unlock(&task->sighand->siglock);
 
@@ -236,9 +306,12 @@ unlock_tasklist:
 unlock_creds:
        mutex_unlock(&task->signal->cred_guard_mutex);
 out:
-       if (wait_trap)
-               wait_event(current->signal->wait_chldexit,
-                          !(task->group_stop & GROUP_STOP_TRAPPING));
+       if (!retval) {
+               wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT,
+                           ptrace_trapping_sleep_fn, TASK_UNINTERRUPTIBLE);
+               proc_ptrace_connector(task, PTRACE_ATTACH);
+       }
+
        return retval;
 }
 
@@ -301,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)
@@ -344,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);
 
@@ -541,7 +617,7 @@ static int ptrace_resume(struct task_struct *child, long request,
        }
 
        child->exit_code = data;
-       wake_up_process(child);
+       wake_up_state(child, __TASK_TRACED);
 
        return 0;
 }
@@ -590,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:
@@ -626,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;
@@ -740,8 +871,8 @@ SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,
                goto out;
        }
 
-       if (request == PTRACE_ATTACH) {
-               ret = ptrace_attach(child);
+       if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
+               ret = ptrace_attach(child, request, data);
                /*
                 * Some architectures need to do book-keeping after
                 * a ptrace attach.
@@ -751,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;
 
@@ -882,8 +1014,8 @@ asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
                goto out;
        }
 
-       if (request == PTRACE_ATTACH) {
-               ret = ptrace_attach(child);
+       if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
+               ret = ptrace_attach(child, request, data);
                /*
                 * Some architectures need to do book-keeping after
                 * a ptrace attach.
@@ -893,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);
 
@@ -903,3 +1036,19 @@ asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
        return ret;
 }
 #endif /* CONFIG_COMPAT */
+
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+int ptrace_get_breakpoints(struct task_struct *tsk)
+{
+       if (atomic_inc_not_zero(&tsk->ptrace_bp_refcnt))
+               return 0;
+
+       return -1;
+}
+
+void ptrace_put_breakpoints(struct task_struct *tsk)
+{
+       if (atomic_dec_and_test(&tsk->ptrace_bp_refcnt))
+               flush_ptrace_hw_breakpoint(tsk);
+}
+#endif /* CONFIG_HAVE_HW_BREAKPOINT */