exit: Use task_is_*

Also restructure the loop in do_wait()

Signed-off-by: Matthew Wilcox <willy@linux.intel.com>

diff --git a/kernel/exit.c b/kernel/exit.c
index 549c0558ba68273c7586b26f6579d12c27d0f79d..bfb1c0e940e814f7e64a3c707c65a6f5608c0388 100644 (file)
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -249,7 +249,7 @@ static int has_stopped_jobs(struct pid *pgrp)
        struct task_struct *p;
 
        do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-               if (p->state != TASK_STOPPED)
+               if (!task_is_stopped(p))
                        continue;
                retval = 1;
                break;
@@ -614,7 +614,7 @@ reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
                p->parent = p->real_parent;
                add_parent(p);
 
-               if (p->state == TASK_TRACED) {
+               if (task_is_traced(p)) {
                        /*
                         * If it was at a trace stop, turn it into
                         * a normal stop since it's no longer being
@@ -1563,60 +1563,51 @@ repeat:
                        }
                        allowed = 1;
 
-                       switch (p->state) {
-                       case TASK_TRACED:
-                               /*
-                                * When we hit the race with PTRACE_ATTACH,
-                                * we will not report this child.  But the
-                                * race means it has not yet been moved to
-                                * our ptrace_children list, so we need to
-                                * set the flag here to avoid a spurious ECHILD
-                                * when the race happens with the only child.
-                                */
-                               flag = 1;
-                               if (!my_ptrace_child(p))
-                                       continue;
-                               /*FALLTHROUGH*/
-                       case TASK_STOPPED:
+                       if (task_is_stopped_or_traced(p)) {
                                /*
                                 * It's stopped now, so it might later
                                 * continue, exit, or stop again.
+                                *
+                                * When we hit the race with PTRACE_ATTACH, we
+                                * will not report this child.  But the race
+                                * means it has not yet been moved to our
+                                * ptrace_children list, so we need to set the
+                                * flag here to avoid a spurious ECHILD when
+                                * the race happens with the only child.
                                 */
                                flag = 1;
-                               if (!(options & WUNTRACED) &&
-                                   !my_ptrace_child(p))
-                                       continue;
+
+                               if (!my_ptrace_child(p)) {
+                                       if (task_is_traced(p))
+                                               continue;
+                                       if (!(options & WUNTRACED))
+                                               continue;
+                               }
+
                                retval = wait_task_stopped(p, ret == 2,
-                                                          (options & WNOWAIT),
-                                                          infop,
-                                                          stat_addr, ru);
+                                               (options & WNOWAIT), infop,
+                                               stat_addr, ru);
                                if (retval == -EAGAIN)
                                        goto repeat;
                                if (retval != 0) /* He released the lock.  */
                                        goto end;
-                               break;
-                       default:
-                       // case EXIT_DEAD:
-                               if (p->exit_state == EXIT_DEAD)
+                       } else if (p->exit_state == EXIT_DEAD) {
+                               continue;
+                       } else if (p->exit_state == EXIT_ZOMBIE) {
+                               /*
+                                * Eligible but we cannot release it yet:
+                                */
+                               if (ret == 2)
+                                       goto check_continued;
+                               if (!likely(options & WEXITED))
                                        continue;
-                       // case EXIT_ZOMBIE:
-                               if (p->exit_state == EXIT_ZOMBIE) {
-                                       /*
-                                        * Eligible but we cannot release
-                                        * it yet:
-                                        */
-                                       if (ret == 2)
-                                               goto check_continued;
-                                       if (!likely(options & WEXITED))
-                                               continue;
-                                       retval = wait_task_zombie(
-                                               p, (options & WNOWAIT),
-                                               infop, stat_addr, ru);
-                                       /* He released the lock.  */
-                                       if (retval != 0)
-                                               goto end;
-                                       break;
-                               }
+                               retval = wait_task_zombie(p,
+                                               (options & WNOWAIT), infop,
+                                               stat_addr, ru);
+                               /* He released the lock.  */
+                               if (retval != 0)
+                                       goto end;
+                       } else {
 check_continued:
                                /*
                                 * It's running now, so it might later
@@ -1625,12 +1616,11 @@ check_continued:
                                flag = 1;
                                if (!unlikely(options & WCONTINUED))
                                        continue;
-                               retval = wait_task_continued(
-                                       p, (options & WNOWAIT),
-                                       infop, stat_addr, ru);
+                               retval = wait_task_continued(p,
+                                               (options & WNOWAIT), infop,
+                                               stat_addr, ru);
                                if (retval != 0) /* He released the lock.  */
                                        goto end;
-                               break;
                        }
                }
                if (!flag) {