1 files changed, 64 insertions, 50 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index a3baf92462bd..2e4c13cba95a 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -4,7 +4,6 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
@@ -26,6 +25,8 @@
 #include <linux/mount.h>
 #include <linux/proc_fs.h>
 #include <linux/mempolicy.h>
+#include <linux/taskstats_kern.h>
+#include <linux/delayacct.h>
 #include <linux/cpuset.h>
 #include <linux/syscalls.h>
 #include <linux/signal.h>
@@ -36,6 +37,7 @@
 #include <linux/compat.h>
 #include <linux/pipe_fs_i.h>
 #include <linux/audit.h> /* for audit_free() */
+#include <linux/resource.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -45,8 +47,6 @@
 extern void sem_exit (void);
 extern struct task_struct *child_reaper;
 
-int getrusage(struct task_struct *, int, struct rusage __user *);
-
 static void exit_mm(struct task_struct * tsk);
 
 static void __unhash_process(struct task_struct *p)
@@ -136,14 +136,10 @@ static void delayed_put_task_struct(struct rcu_head *rhp)
 
 void release_task(struct task_struct * p)
 {
+        struct task_struct *leader;
         int zap_leader;
-        task_t *leader;
-        struct dentry *proc_dentry;
-
 repeat:
         atomic_dec(&p->user->processes);
-        spin_lock(&p->proc_lock);
-        proc_dentry = proc_pid_unhash(p);
         write_lock_irq(&tasklist_lock);
         ptrace_unlink(p);
         BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children));
@@ -172,8 +168,7 @@ repeat:
 
         sched_exit(p);
         write_unlock_irq(&tasklist_lock);
-        spin_unlock(&p->proc_lock);
-        proc_pid_flush(proc_dentry);
+        proc_flush_task(p);
         release_thread(p);
         call_rcu(&p->rcu, delayed_put_task_struct);
 
@@ -216,7 +211,7 @@ out:
  *
  * "I ask you, have you ever known what it is to be an orphan?"
  */
-static int will_become_orphaned_pgrp(int pgrp, task_t *ignored_task)
+static int will_become_orphaned_pgrp(int pgrp, struct task_struct *ignored_task)
 {
         struct task_struct *p;
         int ret = 1;
@@ -224,7 +219,7 @@ static int will_become_orphaned_pgrp(int pgrp, task_t *ignored_task)
         do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
                 if (p == ignored_task
                                 || p->exit_state
-                                || p->real_parent->pid == 1)
+                                || is_init(p->real_parent))
                         continue;
                 if (process_group(p->real_parent) != pgrp
                             && p->real_parent->signal->session == p->signal->session) {
@@ -254,17 +249,6 @@ static int has_stopped_jobs(int pgrp)
         do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
                 if (p->state != TASK_STOPPED)
                         continue;
-
-                /* If p is stopped by a debugger on a signal that won't
-                   stop it, then don't count p as stopped.  This isn't
-                   perfect but it's a good approximation.  */
-                if (unlikely (p->ptrace)
-                    && p->exit_code != SIGSTOP
-                    && p->exit_code != SIGTSTP
-                    && p->exit_code != SIGTTOU
-                    && p->exit_code != SIGTTIN)
-                        continue;
-
                 retval = 1;
                 break;
         } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
@@ -297,9 +281,7 @@ static void reparent_to_init(void)
         /* Set the exit signal to SIGCHLD so we signal init on exit */
         current->exit_signal = SIGCHLD;
 
-        if ((current->policy == SCHED_NORMAL ||
-                        current->policy == SCHED_BATCH)
-                                && (task_nice(current) < 0))
+        if (!has_rt_policy(current) && (task_nice(current) < 0))
                 set_user_nice(current, 0);
         /* cpus_allowed? */
         /* rt_priority? */
@@ -492,6 +474,18 @@ void fastcall put_files_struct(struct files_struct *files)
 
 EXPORT_SYMBOL(put_files_struct);
 
+void reset_files_struct(struct task_struct *tsk, struct files_struct *files)
+{
+        struct files_struct *old;
+
+        old = tsk->files;
+        task_lock(tsk);
+        tsk->files = files;
+        task_unlock(tsk);
+        put_files_struct(old);
+}
+EXPORT_SYMBOL(reset_files_struct);
+
 static inline void __exit_files(struct task_struct *tsk)
 {
         struct files_struct * files = tsk->files;
@@ -589,7 +583,8 @@ static void exit_mm(struct task_struct * tsk)
         mmput(mm);
 }
 
-static inline void choose_new_parent(task_t *p, task_t *reaper)
+static inline void
+choose_new_parent(struct task_struct *p, struct task_struct *reaper)
 {
         /*
          * Make sure we're not reparenting to ourselves and that
@@ -599,7 +594,8 @@ static inline void choose_new_parent(task_t *p, task_t *reaper)
         p->real_parent = reaper;
 }
 
-static void reparent_thread(task_t *p, task_t *father, int traced)
+static void
+reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
 {
         /* We don't want people slaying init.  */
         if (p->exit_signal != -1)
@@ -663,8 +659,8 @@ static void reparent_thread(task_t *p, task_t *father, int traced)
  * group, and if no such member exists, give it to
  * the global child reaper process (ie "init")
  */
-static void forget_original_parent(struct task_struct * father,
-                                          struct list_head *to_release)
+static void
+forget_original_parent(struct task_struct *father, struct list_head *to_release)
 {
         struct task_struct *p, *reaper = father;
         struct list_head *_p, *_n;
@@ -687,7 +683,7 @@ static void forget_original_parent(struct task_struct * father,
          */
         list_for_each_safe(_p, _n, &father->children) {
                 int ptrace;
-                p = list_entry(_p,struct task_struct,sibling);
+                p = list_entry(_p, struct task_struct, sibling);
 
                 ptrace = p->ptrace;
 
@@ -716,7 +712,7 @@ static void forget_original_parent(struct task_struct * father,
                         list_add(&p->ptrace_list, to_release);
         }
         list_for_each_safe(_p, _n, &father->ptrace_children) {
-                p = list_entry(_p,struct task_struct,ptrace_list);
+                p = list_entry(_p, struct task_struct, ptrace_list);
                 choose_new_parent(p, reaper);
                 reparent_thread(p, father, 1);
         }
@@ -836,7 +832,7 @@ static void exit_notify(struct task_struct *tsk)
 
         list_for_each_safe(_p, _n, &ptrace_dead) {
                 list_del_init(_p);
-                t = list_entry(_p,struct task_struct,ptrace_list);
+                t = list_entry(_p, struct task_struct, ptrace_list);
                 release_task(t);
         }
 
@@ -848,7 +844,9 @@ static void exit_notify(struct task_struct *tsk)
 fastcall NORET_TYPE void do_exit(long code)
 {
         struct task_struct *tsk = current;
+        struct taskstats *tidstats;
         int group_dead;
+        unsigned int mycpu;
 
         profile_task_exit(tsk);
 
@@ -886,6 +884,8 @@ fastcall NORET_TYPE void do_exit(long code)
                                 current->comm, current->pid,
                                 preempt_count());
 
+        taskstats_exit_alloc(&tidstats, &mycpu);
+
         acct_update_integrals(tsk);
         if (tsk->mm) {
                 update_hiwater_rss(tsk->mm);
@@ -895,18 +895,23 @@ fastcall NORET_TYPE void do_exit(long code)
         if (group_dead) {
                 hrtimer_cancel(&tsk->signal->real_timer);
                 exit_itimers(tsk->signal);
-                acct_process(code);
         }
+        acct_collect(code, group_dead);
         if (unlikely(tsk->robust_list))
                 exit_robust_list(tsk);
-#ifdef CONFIG_COMPAT
+#if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT)
         if (unlikely(tsk->compat_robust_list))
                 compat_exit_robust_list(tsk);
 #endif
         if (unlikely(tsk->audit_context))
                 audit_free(tsk);
+        taskstats_exit_send(tsk, tidstats, group_dead, mycpu);
+        taskstats_exit_free(tidstats);
+
         exit_mm(tsk);
 
+        if (group_dead)
+                acct_process();
         exit_sem(tsk);
         __exit_files(tsk);
         __exit_fs(tsk);
@@ -930,9 +935,17 @@ fastcall NORET_TYPE void do_exit(long code)
         tsk->mempolicy = NULL;
 #endif
         /*
-         * If DEBUG_MUTEXES is on, make sure we are holding no locks:
+         * This must happen late, after the PID is not
+         * hashed anymore:
          */
-        mutex_debug_check_no_locks_held(tsk);
+        if (unlikely(!list_empty(&tsk->pi_state_list)))
+                exit_pi_state_list(tsk);
+        if (unlikely(current->pi_state_cache))
+                kfree(current->pi_state_cache);
+        /*
+         * Make sure we are holding no locks:
+         */
+        debug_check_no_locks_held(tsk);
 
         if (tsk->io_context)
                 exit_io_context();
@@ -940,15 +953,15 @@ fastcall NORET_TYPE void do_exit(long code)
         if (tsk->splice_pipe)
                 __free_pipe_info(tsk->splice_pipe);
 
-        /* PF_DEAD causes final put_task_struct after we schedule. */
         preempt_disable();
-        BUG_ON(tsk->flags & PF_DEAD);
-        tsk->flags |= PF_DEAD;
+        /* causes final put_task_struct in finish_task_switch(). */
+        tsk->state = TASK_DEAD;
 
         schedule();
         BUG();
         /* Avoid "noreturn function does return".  */
-        for (;;) ;
+        for (;;)
+                cpu_relax();    /* For when BUG is null */
 }
 
 EXPORT_SYMBOL_GPL(do_exit);
@@ -957,7 +970,7 @@ NORET_TYPE void complete_and_exit(struct completion *comp, long code)
 {
         if (comp)
                 complete(comp);
-        
+
         do_exit(code);
 }
 
@@ -1007,7 +1020,7 @@ asmlinkage void sys_exit_group(int error_code)
         do_group_exit((error_code & 0xff) << 8);
 }
 
-static int eligible_child(pid_t pid, int options, task_t *p)
+static int eligible_child(pid_t pid, int options, struct task_struct *p)
 {
         if (pid > 0) {
                 if (p->pid != pid)
@@ -1039,7 +1052,7 @@ static int eligible_child(pid_t pid, int options, task_t *p)
          * Do not consider thread group leaders that are
          * in a non-empty thread group:
          */
-        if (current->tgid != p->tgid && delay_group_leader(p))
+        if (delay_group_leader(p))
                 return 2;
 
         if (security_task_wait(p))
@@ -1048,12 +1061,13 @@ static int eligible_child(pid_t pid, int options, task_t *p)
         return 1;
 }
 
-static int wait_noreap_copyout(task_t *p, pid_t pid, uid_t uid,
+static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
                                int why, int status,
                                struct siginfo __user *infop,
                                struct rusage __user *rusagep)
 {
         int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
+
         put_task_struct(p);
         if (!retval)
                 retval = put_user(SIGCHLD, &infop->si_signo);
@@ -1078,7 +1092,7 @@ static int wait_noreap_copyout(task_t *p, pid_t pid, uid_t uid,
  * the lock and this task is uninteresting.  If we return nonzero, we have
  * released the lock and the system call should return.
  */
-static int wait_task_zombie(task_t *p, int noreap,
+static int wait_task_zombie(struct task_struct *p, int noreap,
                             struct siginfo __user *infop,
                             int __user *stat_addr, struct rusage __user *ru)
 {
@@ -1240,8 +1254,8 @@ static int wait_task_zombie(task_t *p, int noreap,
  * the lock and this task is uninteresting.  If we return nonzero, we have
  * released the lock and the system call should return.
  */
-static int wait_task_stopped(task_t *p, int delayed_group_leader, int noreap,
-                             struct siginfo __user *infop,
+static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
+                             int noreap, struct siginfo __user *infop,
                              int __user *stat_addr, struct rusage __user *ru)
 {
         int retval, exit_code;
@@ -1355,7 +1369,7 @@ bail_ref:
  * the lock and this task is uninteresting.  If we return nonzero, we have
  * released the lock and the system call should return.
  */
-static int wait_task_continued(task_t *p, int noreap,
+static int wait_task_continued(struct task_struct *p, int noreap,
                                struct siginfo __user *infop,
                                int __user *stat_addr, struct rusage __user *ru)
 {
@@ -1441,7 +1455,7 @@ repeat:
                 int ret;
 
                 list_for_each(_p,&tsk->children) {
-                        p = list_entry(_p,struct task_struct,sibling);
+                        p = list_entry(_p, struct task_struct, sibling);
 
                         ret = eligible_child(pid, options, p);
                         if (!ret)