Merge branch 'ptrace' of git://git.kernel.org/pub/scm/linux/kernel/git/oleg/misc

* 'ptrace' of git://git.kernel.org/pub/scm/linux/kernel/git/oleg/misc: (39 commits)
  ptrace: do_wait(traced_leader_killed_by_mt_exec) can block forever
  ptrace: fix ptrace_signal() && STOP_DEQUEUED interaction
  connector: add an event for monitoring process tracers
  ptrace: dont send SIGSTOP on auto-attach if PT_SEIZED
  ptrace: mv send-SIGSTOP from do_fork() to ptrace_init_task()
  ptrace_init_task: initialize child->jobctl explicitly
  has_stopped_jobs: s/task_is_stopped/SIGNAL_STOP_STOPPED/
  ptrace: make former thread ID available via PTRACE_GETEVENTMSG after PTRACE_EVENT_EXEC stop
  ptrace: wait_consider_task: s/same_thread_group/ptrace_reparented/
  ptrace: kill real_parent_is_ptracer() in in favor of ptrace_reparented()
  ptrace: ptrace_reparented() should check same_thread_group()
  redefine thread_group_leader() as exit_signal >= 0
  do not change dead_task->exit_signal
  kill task_detached()
  reparent_leader: check EXIT_DEAD instead of task_detached()
  make do_notify_parent() __must_check, update the callers
  __ptrace_detach: avoid task_detached(), check do_notify_parent()
  kill tracehook_notify_death()
  make do_notify_parent() return bool
  ptrace: s/tracehook_tracer_task()/ptrace_parent()/
  ...

1 files changed, 40 insertions, 51 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index f2b321bae440..73bb192a3d32 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -169,7 +169,6 @@ void release_task(struct task_struct * p)
         struct task_struct *leader;
         int zap_leader;
 repeat:
-        tracehook_prepare_release_task(p);
         /* don't need to get the RCU readlock here - the process is dead and
          * can't be modifying its own credentials. But shut RCU-lockdep up */
         rcu_read_lock();
@@ -179,7 +178,7 @@ repeat:
         proc_flush_task(p);
 
         write_lock_irq(&tasklist_lock);
-        tracehook_finish_release_task(p);
+        ptrace_release_task(p);
         __exit_signal(p);
 
         /*
@@ -190,22 +189,12 @@ repeat:
         zap_leader = 0;
         leader = p->group_leader;
         if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
-                BUG_ON(task_detached(leader));
-                do_notify_parent(leader, leader->exit_signal);
                 /*
                  * If we were the last child thread and the leader has
                  * exited already, and the leader's parent ignores SIGCHLD,
                  * then we are the one who should release the leader.
-                 *
-                 * do_notify_parent() will have marked it self-reaping in
-                 * that case.
-                 */
-                zap_leader = task_detached(leader);
-
-                /*
-                 * This maintains the invariant that release_task()
-                 * only runs on a task in EXIT_DEAD, just for sanity.
                  */
+                zap_leader = do_notify_parent(leader, leader->exit_signal);
                 if (zap_leader)
                         leader->exit_state = EXIT_DEAD;
         }
@@ -277,18 +266,16 @@ int is_current_pgrp_orphaned(void)
         return retval;
 }
 
-static int has_stopped_jobs(struct pid *pgrp)
+static bool has_stopped_jobs(struct pid *pgrp)
 {
-        int retval = 0;
         struct task_struct *p;
 
         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-                if (!task_is_stopped(p))
-                        continue;
-                retval = 1;
-                break;
+                if (p->signal->flags & SIGNAL_STOP_STOPPED)
+                        return true;
         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-        return retval;
+
+        return false;
 }
 
 /*
@@ -751,7 +738,7 @@ static void reparent_leader(struct task_struct *father, struct task_struct *p,
 {
         list_move_tail(&p->sibling, &p->real_parent->children);
 
-        if (task_detached(p))
+        if (p->exit_state == EXIT_DEAD)
                 return;
         /*
          * If this is a threaded reparent there is no need to
@@ -764,10 +751,9 @@ static void reparent_leader(struct task_struct *father, struct task_struct *p,
         p->exit_signal = SIGCHLD;
 
         /* If it has exited notify the new parent about this child's death. */
-        if (!task_ptrace(p) &&
+        if (!p->ptrace &&
             p->exit_state == EXIT_ZOMBIE && thread_group_empty(p)) {
-                do_notify_parent(p, p->exit_signal);
-                if (task_detached(p)) {
+                if (do_notify_parent(p, p->exit_signal)) {
                         p->exit_state = EXIT_DEAD;
                         list_move_tail(&p->sibling, dead);
                 }
@@ -794,7 +780,7 @@ static void forget_original_parent(struct task_struct *father)
                 do {
                         t->real_parent = reaper;
                         if (t->parent == father) {
-                                BUG_ON(task_ptrace(t));
+                                BUG_ON(t->ptrace);
                                 t->parent = t->real_parent;
                         }
                         if (t->pdeath_signal)
@@ -819,8 +805,7 @@ static void forget_original_parent(struct task_struct *father)
  */
 static void exit_notify(struct task_struct *tsk, int group_dead)
 {
-        int signal;
-        void *cookie;
+        bool autoreap;
 
         /*
          * This does two things:
@@ -851,26 +836,33 @@ static void exit_notify(struct task_struct *tsk, int group_dead)
          * we have changed execution domain as these two values started
          * the same after a fork.
          */
-        if (tsk->exit_signal != SIGCHLD && !task_detached(tsk) &&
+        if (thread_group_leader(tsk) && tsk->exit_signal != SIGCHLD &&
             (tsk->parent_exec_id != tsk->real_parent->self_exec_id ||
              tsk->self_exec_id != tsk->parent_exec_id))
                 tsk->exit_signal = SIGCHLD;
 
-        signal = tracehook_notify_death(tsk, &cookie, group_dead);
-        if (signal >= 0)
-                signal = do_notify_parent(tsk, signal);
+        if (unlikely(tsk->ptrace)) {
+                int sig = thread_group_leader(tsk) &&
+                                thread_group_empty(tsk) &&
+                                !ptrace_reparented(tsk) ?
+                        tsk->exit_signal : SIGCHLD;
+                autoreap = do_notify_parent(tsk, sig);
+        } else if (thread_group_leader(tsk)) {
+                autoreap = thread_group_empty(tsk) &&
+                        do_notify_parent(tsk, tsk->exit_signal);
+        } else {
+                autoreap = true;
+        }
 
-        tsk->exit_state = signal == DEATH_REAP ? EXIT_DEAD : EXIT_ZOMBIE;
+        tsk->exit_state = autoreap ? EXIT_DEAD : EXIT_ZOMBIE;
 
         /* mt-exec, de_thread() is waiting for group leader */
         if (unlikely(tsk->signal->notify_count < 0))
                 wake_up_process(tsk->signal->group_exit_task);
         write_unlock_irq(&tasklist_lock);
 
-        tracehook_report_death(tsk, signal, cookie, group_dead);
-
         /* If the process is dead, release it - nobody will wait for it */
-        if (signal == DEATH_REAP)
+        if (autoreap)
                 release_task(tsk);
 }
 
@@ -923,7 +915,7 @@ NORET_TYPE void do_exit(long code)
          */
         set_fs(USER_DS);
 
-        tracehook_report_exit(&code);
+        ptrace_event(PTRACE_EVENT_EXIT, code);
 
         validate_creds_for_do_exit(tsk);
 
@@ -1235,9 +1227,9 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
         traced = ptrace_reparented(p);
         /*
          * It can be ptraced but not reparented, check
-         * !task_detached() to filter out sub-threads.
+         * thread_group_leader() to filter out sub-threads.
          */
-        if (likely(!traced) && likely(!task_detached(p))) {
+        if (likely(!traced) && thread_group_leader(p)) {
                 struct signal_struct *psig;
                 struct signal_struct *sig;
                 unsigned long maxrss;
@@ -1345,16 +1337,13 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
                 /* We dropped tasklist, ptracer could die and untrace */
                 ptrace_unlink(p);
                 /*
-                 * If this is not a detached task, notify the parent.
-                 * If it's still not detached after that, don't release
-                 * it now.
+                 * If this is not a sub-thread, notify the parent.
+                 * If parent wants a zombie, don't release it now.
                  */
-                if (!task_detached(p)) {
-                        do_notify_parent(p, p->exit_signal);
-                        if (!task_detached(p)) {
-                                p->exit_state = EXIT_ZOMBIE;
-                                p = NULL;
-                        }
+                if (thread_group_leader(p) &&
+                    !do_notify_parent(p, p->exit_signal)) {
+                        p->exit_state = EXIT_ZOMBIE;
+                        p = NULL;
                 }
                 write_unlock_irq(&tasklist_lock);
         }
@@ -1367,7 +1356,8 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
 static int *task_stopped_code(struct task_struct *p, bool ptrace)
 {
         if (ptrace) {
-                if (task_is_stopped_or_traced(p))
+                if (task_is_stopped_or_traced(p) &&
+                    !(p->jobctl & JOBCTL_LISTENING))
                         return &p->exit_code;
         } else {
                 if (p->signal->flags & SIGNAL_STOP_STOPPED)
@@ -1563,7 +1553,7 @@ static int wait_consider_task(struct wait_opts *wo, int ptrace,
                  * Notification and reaping will be cascaded to the real
                  * parent when the ptracer detaches.
                  */
-                if (likely(!ptrace) && unlikely(task_ptrace(p))) {
+                if (likely(!ptrace) && unlikely(p->ptrace)) {
                         /* it will become visible, clear notask_error */
                         wo->notask_error = 0;
                         return 0;
@@ -1606,8 +1596,7 @@ static int wait_consider_task(struct wait_opts *wo, int ptrace,
                  * own children, it should create a separate process which
                  * takes the role of real parent.
                  */
-                if (likely(!ptrace) && task_ptrace(p) &&
-                    same_thread_group(p->parent, p->real_parent))
+                if (likely(!ptrace) && p->ptrace && !ptrace_reparented(p))
                         return 0;
 
                 /*