1 files changed, 53 insertions, 36 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index 3da04257aeaf..256ce8c2ebc8 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -49,6 +49,7 @@
 #include <linux/init_task.h>
 #include <linux/perf_event.h>
 #include <trace/events/sched.h>
+#include <linux/hw_breakpoint.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -69,10 +70,10 @@ static void __unhash_process(struct task_struct *p)
                 detach_pid(p, PIDTYPE_SID);
 
                 list_del_rcu(&p->tasks);
+                list_del_init(&p->sibling);
                 __get_cpu_var(process_counts)--;
         }
         list_del_rcu(&p->thread_group);
-        list_del_init(&p->sibling);
 }
 
 /*
@@ -86,7 +87,9 @@ static void __exit_signal(struct task_struct *tsk)
         BUG_ON(!sig);
         BUG_ON(!atomic_read(&sig->count));
 
-        sighand = rcu_dereference(tsk->sighand);
+        sighand = rcu_dereference_check(tsk->sighand,
+                                        rcu_read_lock_held() ||
+                                        lockdep_tasklist_lock_is_held());
         spin_lock(&sighand->siglock);
 
         posix_cpu_timers_exit(tsk);
@@ -112,9 +115,9 @@ static void __exit_signal(struct task_struct *tsk)
                  * We won't ever get here for the group leader, since it
                  * will have been the last reference on the signal_struct.
                  */
-                sig->utime = cputime_add(sig->utime, task_utime(tsk));
-                sig->stime = cputime_add(sig->stime, task_stime(tsk));
-                sig->gtime = cputime_add(sig->gtime, task_gtime(tsk));
+                sig->utime = cputime_add(sig->utime, tsk->utime);
+                sig->stime = cputime_add(sig->stime, tsk->stime);
+                sig->gtime = cputime_add(sig->gtime, tsk->gtime);
                 sig->min_flt += tsk->min_flt;
                 sig->maj_flt += tsk->maj_flt;
                 sig->nvcsw += tsk->nvcsw;
@@ -171,8 +174,10 @@ void release_task(struct task_struct * p)
 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 */
+         * can't be modifying its own credentials. But shut RCU-lockdep up */
+        rcu_read_lock();
         atomic_dec(&__task_cred(p)->user->processes);
+        rcu_read_unlock();
 
         proc_flush_task(p);
 
@@ -474,9 +479,11 @@ static void close_files(struct files_struct * files)
         /*
          * It is safe to dereference the fd table without RCU or
          * ->file_lock because this is the last reference to the
-         * files structure.
+         * files structure.  But use RCU to shut RCU-lockdep up.
          */
+        rcu_read_lock();
         fdt = files_fdtable(files);
+        rcu_read_unlock();
         for (;;) {
                 unsigned long set;
                 i = j * __NFDBITS;
@@ -522,10 +529,12 @@ void put_files_struct(struct files_struct *files)
                  * at the end of the RCU grace period. Otherwise,
                  * you can free files immediately.
                  */
+                rcu_read_lock();
                 fdt = files_fdtable(files);
                 if (fdt != &files->fdtab)
                         kmem_cache_free(files_cachep, files);
                 free_fdtable(fdt);
+                rcu_read_unlock();
         }
 }
 
@@ -737,12 +746,9 @@ static struct task_struct *find_new_reaper(struct task_struct *father)
 /*
 * Any that need to be release_task'd are put on the @dead list.
  */
-static void reparent_thread(struct task_struct *father, struct task_struct *p,
+static void reparent_leader(struct task_struct *father, struct task_struct *p,
                                 struct list_head *dead)
 {
-        if (p->pdeath_signal)
-                group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);
-
         list_move_tail(&p->sibling, &p->real_parent->children);
 
         if (task_detached(p))
@@ -781,12 +787,18 @@ static void forget_original_parent(struct task_struct *father)
         reaper = find_new_reaper(father);
 
         list_for_each_entry_safe(p, n, &father->children, sibling) {
-                p->real_parent = reaper;
-                if (p->parent == father) {
-                        BUG_ON(task_ptrace(p));
-                        p->parent = p->real_parent;
-                }
-                reparent_thread(father, p, &dead_children);
+                struct task_struct *t = p;
+                do {
+                        t->real_parent = reaper;
+                        if (t->parent == father) {
+                                BUG_ON(task_ptrace(t));
+                                t->parent = t->real_parent;
+                        }
+                        if (t->pdeath_signal)
+                                group_send_sig_info(t->pdeath_signal,
+                                                    SEND_SIG_NOINFO, t);
+                } while_each_thread(p, t);
+                reparent_leader(father, p, &dead_children);
         }
         write_unlock_irq(&tasklist_lock);
 
@@ -934,7 +946,7 @@ NORET_TYPE void do_exit(long code)
          * an exiting task cleaning up the robust pi futexes.
          */
         smp_mb();
-        spin_unlock_wait(&tsk->pi_lock);
+        raw_spin_unlock_wait(&tsk->pi_lock);
 
         if (unlikely(in_atomic()))
                 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
@@ -942,7 +954,9 @@ NORET_TYPE void do_exit(long code)
                                 preempt_count());
 
         acct_update_integrals(tsk);
-
+        /* sync mm's RSS info before statistics gathering */
+        if (tsk->mm)
+                sync_mm_rss(tsk, tsk->mm);
         group_dead = atomic_dec_and_test(&tsk->signal->live);
         if (group_dead) {
                 hrtimer_cancel(&tsk->signal->real_timer);
@@ -974,7 +988,7 @@ NORET_TYPE void do_exit(long code)
         exit_thread();
         cgroup_exit(tsk, 1);
 
-        if (group_dead && tsk->signal->leader)
+        if (group_dead)
                 disassociate_ctty(1);
 
         module_put(task_thread_info(tsk)->exec_domain->module);
@@ -982,6 +996,10 @@ NORET_TYPE void do_exit(long code)
         proc_exit_connector(tsk);
 
         /*
+         * FIXME: do that only when needed, using sched_exit tracepoint
+         */
+        flush_ptrace_hw_breakpoint(tsk);
+        /*
          * Flush inherited counters to the parent - before the parent
          * gets woken up by child-exit notifications.
          */
@@ -1008,7 +1026,7 @@ NORET_TYPE void do_exit(long code)
         tsk->flags |= PF_EXITPIDONE;
 
         if (tsk->io_context)
-                exit_io_context();
+                exit_io_context(tsk);
 
         if (tsk->splice_pipe)
                 __free_pipe_info(tsk->splice_pipe);
@@ -1176,7 +1194,7 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
 
         if (unlikely(wo->wo_flags & WNOWAIT)) {
                 int exit_code = p->exit_code;
-                int why, status;
+                int why;
 
                 get_task_struct(p);
                 read_unlock(&tasklist_lock);
@@ -1209,6 +1227,7 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
                 struct signal_struct *psig;
                 struct signal_struct *sig;
                 unsigned long maxrss;
+                cputime_t tgutime, tgstime;
 
                 /*
                  * The resource counters for the group leader are in its
@@ -1224,20 +1243,23 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
                  * need to protect the access to parent->signal fields,
                  * as other threads in the parent group can be right
                  * here reaping other children at the same time.
+                 *
+                 * We use thread_group_times() to get times for the thread
+                 * group, which consolidates times for all threads in the
+                 * group including the group leader.
                  */
+                thread_group_times(p, &tgutime, &tgstime);
                 spin_lock_irq(&p->real_parent->sighand->siglock);
                 psig = p->real_parent->signal;
                 sig = p->signal;
                 psig->cutime =
                         cputime_add(psig->cutime,
-                        cputime_add(p->utime,
-                        cputime_add(sig->utime,
-                                    sig->cutime)));
+                        cputime_add(tgutime,
+                                    sig->cutime));
                 psig->cstime =
                         cputime_add(psig->cstime,
-                        cputime_add(p->stime,
-                        cputime_add(sig->stime,
-                                    sig->cstime)));
+                        cputime_add(tgstime,
+                                    sig->cstime));
                 psig->cgtime =
                         cputime_add(psig->cgtime,
                         cputime_add(p->gtime,
@@ -1546,14 +1568,9 @@ static int do_wait_thread(struct wait_opts *wo, struct task_struct *tsk)
         struct task_struct *p;
 
         list_for_each_entry(p, &tsk->children, sibling) {
-                /*
-                 * Do not consider detached threads.
-                 */
-                if (!task_detached(p)) {
-                        int ret = wait_consider_task(wo, 0, p);
-                        if (ret)
-                                return ret;
-                }
+                int ret = wait_consider_task(wo, 0, p);
+                if (ret)
+                        return ret;
         }
 
         return 0;