HACK: ARM: disable sleeping while atomic warning in do_signal
[linux-2.6.git] / kernel / ptrace.c
index e2302e4..ee8d49b 100644 (file)
@@ -8,7 +8,7 @@
  */
 
 #include <linux/capability.h>
-#include <linux/module.h>
+#include <linux/export.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/mm.h>
 #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.
@@ -37,35 +45,33 @@ void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
        child->parent = new_parent;
 }
 
-/*
- * Turn a tracing stop into a normal stop now, since with no tracer there
- * would be no way to wake it up with SIGCONT or SIGKILL.  If there was a
- * signal sent that would resume the child, but didn't because it was in
- * TASK_TRACED, resume it now.
- * Requires that irqs be disabled.
- */
-static void ptrace_untrace(struct task_struct *child)
-{
-       spin_lock(&child->sighand->siglock);
-       if (task_is_traced(child)) {
-               /*
-                * If the group stop is completed or in progress,
-                * this thread was already counted as stopped.
-                */
-               if (child->signal->flags & SIGNAL_STOP_STOPPED ||
-                   child->signal->group_stop_count)
-                       __set_task_state(child, TASK_STOPPED);
-               else
-                       signal_wake_up(child, 1);
-       }
-       spin_unlock(&child->sighand->siglock);
-}
-
-/*
- * unptrace a task: move it back to its original parent and
- * remove it from the ptrace list.
+/**
+ * __ptrace_unlink - unlink ptracee and restore its execution state
+ * @child: ptracee to be unlinked
  *
- * Must be called with the tasklist lock write-held.
+ * 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)
  */
 void __ptrace_unlink(struct task_struct *child)
 {
@@ -75,14 +81,65 @@ void __ptrace_unlink(struct task_struct *child)
        child->parent = child->real_parent;
        list_del_init(&child->ptrace_entry);
 
-       if (task_is_traced(child))
-               ptrace_untrace(child);
+       spin_lock(&child->sighand->siglock);
+
+       /*
+        * 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;
+
+               /*
+                * 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
+        * @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;
 
@@ -95,27 +152,34 @@ 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.. */
        return ret;
 }
 
+static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode)
+{
+       if (mode & PTRACE_MODE_NOAUDIT)
+               return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE);
+       else
+               return has_ns_capability(current, ns, CAP_SYS_PTRACE);
+}
+
 int __ptrace_may_access(struct task_struct *task, unsigned int mode)
 {
        const struct cred *cred = current_cred(), *tcred;
@@ -134,21 +198,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 (ptrace_has_cap(tcred->user->user_ns, mode))
+               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  && !ptrace_has_cap(task_user_ns(task), mode))
                return -EPERM;
 
        return security_ptrace_access_check(task, mode);
@@ -163,10 +230,24 @@ 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 addr,
+                        unsigned long flags)
 {
+       bool seize = (request == PTRACE_SEIZE);
        int retval;
 
+       retval = -EIO;
+       if (seize) {
+               if (addr != 0)
+                       goto out;
+               if (flags & ~(unsigned long)PTRACE_O_MASK)
+                       goto out;
+               flags = PT_PTRACED | PT_SEIZED | (flags << PT_OPT_FLAG_SHIFT);
+       } else {
+               flags = PT_PTRACED;
+       }
+
        audit_ptrace(task);
 
        retval = -EPERM;
@@ -177,7 +258,7 @@ static int ptrace_attach(struct task_struct *task)
 
        /*
         * Protect exec's credential calculations against our interference;
-        * interference; SUID, SGID and LSM creds get determined differently
+        * SUID, SGID and LSM creds get determined differently
         * under ptrace.
         */
        retval = -ERESTARTNOINTR;
@@ -197,12 +278,42 @@ static int ptrace_attach(struct task_struct *task)
        if (task->ptrace)
                goto unlock_tasklist;
 
-       task->ptrace = PT_PTRACED;
-       if (capable(CAP_SYS_PTRACE))
-               task->ptrace |= PT_PTRACE_CAP;
+       if (seize)
+               flags |= PT_SEIZED;
+       if (ns_capable(task_user_ns(task), CAP_SYS_PTRACE))
+               flags |= PT_PTRACE_CAP;
+       task->ptrace = flags;
 
        __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 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
+        * for the transition to complete before returning from this
+        * function.
+        *
+        * This hides STOPPED -> RUNNING -> TRACED transition from the
+        * attaching thread but a different thread in the same group can
+        * still observe the transient RUNNING state.  IOW, if another
+        * thread's WNOHANG wait(2) on the stopped tracee races against
+        * ATTACH, the wait(2) may fail due to the transient RUNNING.
+        *
+        * 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_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING))
+               signal_wake_up(task, 1);
+
+       spin_unlock(&task->sighand->siglock);
 
        retval = 0;
 unlock_tasklist:
@@ -210,6 +321,12 @@ unlock_tasklist:
 unlock_creds:
        mutex_unlock(&task->signal->cred_guard_mutex);
 out:
+       if (!retval) {
+               wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT,
+                           ptrace_trapping_sleep_fn, TASK_UNINTERRUPTIBLE);
+               proc_ptrace_connector(task, PTRACE_ATTACH);
+       }
+
        return retval;
 }
 
@@ -272,25 +389,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)
@@ -312,11 +431,10 @@ static int ptrace_detach(struct task_struct *child, unsigned int data)
        if (child->ptrace) {
                child->exit_code = data;
                dead = __ptrace_detach(current, child);
-               if (!child->exit_state)
-                       wake_up_state(child, TASK_TRACED | TASK_STOPPED);
        }
        write_unlock_irq(&tasklist_lock);
 
+       proc_ptrace_connector(child, PTRACE_DETACH);
        if (unlikely(dead))
                release_task(child);
 
@@ -406,30 +524,18 @@ int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long ds
 
 static int ptrace_setoptions(struct task_struct *child, unsigned long data)
 {
-       child->ptrace &= ~PT_TRACE_MASK;
-
-       if (data & PTRACE_O_TRACESYSGOOD)
-               child->ptrace |= PT_TRACESYSGOOD;
-
-       if (data & PTRACE_O_TRACEFORK)
-               child->ptrace |= PT_TRACE_FORK;
-
-       if (data & PTRACE_O_TRACEVFORK)
-               child->ptrace |= PT_TRACE_VFORK;
-
-       if (data & PTRACE_O_TRACECLONE)
-               child->ptrace |= PT_TRACE_CLONE;
+       unsigned flags;
 
-       if (data & PTRACE_O_TRACEEXEC)
-               child->ptrace |= PT_TRACE_EXEC;
-
-       if (data & PTRACE_O_TRACEVFORKDONE)
-               child->ptrace |= PT_TRACE_VFORK_DONE;
+       if (data & ~(unsigned long)PTRACE_O_MASK)
+               return -EINVAL;
 
-       if (data & PTRACE_O_TRACEEXIT)
-               child->ptrace |= PT_TRACE_EXIT;
+       /* Avoid intermediate state when all opts are cleared */
+       flags = child->ptrace;
+       flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT);
+       flags |= (data << PT_OPT_FLAG_SHIFT);
+       child->ptrace = flags;
 
-       return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
+       return 0;
 }
 
 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
@@ -514,7 +620,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;
 }
@@ -563,10 +669,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:
@@ -599,6 +707,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;
@@ -713,8 +874,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, addr, data);
                /*
                 * Some architectures need to do book-keeping after
                 * a ptrace attach.
@@ -724,7 +885,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;
 
@@ -855,8 +1017,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, addr, data);
                /*
                 * Some architectures need to do book-keeping after
                 * a ptrace attach.
@@ -866,7 +1028,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);
 
@@ -876,3 +1039,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 */