1 files changed, 165 insertions, 42 deletions

diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 2df115790cd..67d1fdd3c55 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -23,8 +23,15 @@
 #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.
@@ -77,13 +84,31 @@ void __ptrace_unlink(struct task_struct *child)
         spin_lock(&child->sighand->siglock);
 
         /*
-         * Reinstate GROUP_STOP_PENDING if group stop is in effect and
+         * 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->group_stop |= GROUP_STOP_PENDING;
+             child->signal->group_stop_count)) {
+                child->jobctl |= JOBCTL_STOP_PENDING;
+
+                /*
+                 * This is only possible if this thread was cloned by the
+                 * traced task running in the stopped group, set the signal
+                 * for the future reports.
+                 * FIXME: we should change ptrace_init_task() to handle this
+                 * case.
+                 */
+                if (!(child->jobctl & JOBCTL_STOP_SIGMASK))
+                        child->jobctl |= SIGSTOP;
+        }
 
         /*
          * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick
@@ -91,16 +116,30 @@ void __ptrace_unlink(struct task_struct *child)
          * is in TASK_TRACED; otherwise, we might unduly disrupt
          * TASK_KILLABLE sleeps.
          */
-        if (child->group_stop & GROUP_STOP_PENDING || task_is_traced(child))
+        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;
 
@@ -119,13 +158,14 @@ int ptrace_check_attach(struct task_struct *child, int kill)
                  */
                 spin_lock_irq(&child->sighand->siglock);
                 WARN_ON_ONCE(task_is_stopped(child));
-                if (task_is_traced(child) || kill)
+                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.. */
@@ -182,11 +222,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;
@@ -218,16 +275,21 @@ static int ptrace_attach(struct task_struct *task)
                 goto unlock_tasklist;
 
         task->ptrace = PT_PTRACED;
+        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
@@ -243,11 +305,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);
 
@@ -257,9 +317,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;
 }
 
@@ -322,25 +385,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)
@@ -365,6 +430,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);
 
@@ -611,10 +677,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:
@@ -647,6 +715,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;
@@ -761,8 +882,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.
@@ -772,7 +893,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;
 
@@ -903,8 +1025,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.
@@ -914,7 +1036,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);