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

[mirror_ubuntu-artful-kernel.git] / kernel / exit.c

diff --git a/kernel/exit.c b/kernel/exit.c
index 6a488ad2dce5bf9a1b6ba24376e1449e603687e4..5cbc83e83a5d7858a2a3309a41ae59d422c044c7 100644 (file)
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1538,33 +1538,83 @@ static int wait_consider_task(struct wait_opts *wo, int ptrace,
                return 0;
        }
 
-       if (likely(!ptrace) && unlikely(task_ptrace(p))) {
+       /* dead body doesn't have much to contribute */
+       if (p->exit_state == EXIT_DEAD)
+               return 0;
+
+       /* slay zombie? */
+       if (p->exit_state == EXIT_ZOMBIE) {
                /*
-                * This child is hidden by ptrace.
-                * We aren't allowed to see it now, but eventually we will.
+                * A zombie ptracee is only visible to its ptracer.
+                * Notification and reaping will be cascaded to the real
+                * parent when the ptracer detaches.
                 */
-               wo->notask_error = 0;
-               return 0;
-       }
+               if (likely(!ptrace) && unlikely(task_ptrace(p))) {
+                       /* it will become visible, clear notask_error */
+                       wo->notask_error = 0;
+                       return 0;
+               }
 
-       if (p->exit_state == EXIT_DEAD)
-               return 0;
+               /* we don't reap group leaders with subthreads */
+               if (!delay_group_leader(p))
+                       return wait_task_zombie(wo, p);
 
-       /*
-        * We don't reap group leaders with subthreads.
-        */
-       if (p->exit_state == EXIT_ZOMBIE && !delay_group_leader(p))
-               return wait_task_zombie(wo, p);
+               /*
+                * Allow access to stopped/continued state via zombie by
+                * falling through.  Clearing of notask_error is complex.
+                *
+                * When !@ptrace:
+                *
+                * If WEXITED is set, notask_error should naturally be
+                * cleared.  If not, subset of WSTOPPED|WCONTINUED is set,
+                * so, if there are live subthreads, there are events to
+                * wait for.  If all subthreads are dead, it's still safe
+                * to clear - this function will be called again in finite
+                * amount time once all the subthreads are released and
+                * will then return without clearing.
+                *
+                * When @ptrace:
+                *
+                * Stopped state is per-task and thus can't change once the
+                * target task dies.  Only continued and exited can happen.
+                * Clear notask_error if WCONTINUED | WEXITED.
+                */
+               if (likely(!ptrace) || (wo->wo_flags & (WCONTINUED | WEXITED)))
+                       wo->notask_error = 0;
+       } else {
+               /*
+                * If @p is ptraced by a task in its real parent's group,
+                * hide group stop/continued state when looking at @p as
+                * the real parent; otherwise, a single stop can be
+                * reported twice as group and ptrace stops.
+                *
+                * If a ptracer wants to distinguish the two events for its
+                * 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))
+                       return 0;
+
+               /*
+                * @p is alive and it's gonna stop, continue or exit, so
+                * there always is something to wait for.
+                */
+               wo->notask_error = 0;
+       }
 
        /*
-        * It's stopped or running now, so it might
-        * later continue, exit, or stop again.
+        * Wait for stopped.  Depending on @ptrace, different stopped state
+        * is used and the two don't interact with each other.
         */
-       wo->notask_error = 0;
-
        if (task_stopped_code(p, ptrace))
                return wait_task_stopped(wo, ptrace, p);
 
+       /*
+        * Wait for continued.  There's only one continued state and the
+        * ptracer can consume it which can confuse the real parent.  Don't
+        * use WCONTINUED from ptracer.  You don't need or want it.
+        */
        return wait_task_continued(wo, p);
 }