Patched in Tegra support.

1 files changed, 253 insertions, 76 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index b4df2193721..9e316ae4984 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -51,8 +51,6 @@
 #include <trace/events/sched.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/oom.h>
-#include <linux/writeback.h>
-#include <linux/shm.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -123,9 +121,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 += tsk->utime;
-                sig->stime += tsk->stime;
-                sig->gtime += tsk->gtime;
+                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;
@@ -310,6 +308,43 @@ kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
         }
 }
 
+/**
+ * reparent_to_kthreadd - Reparent the calling kernel thread to kthreadd
+ *
+ * If a kernel thread is launched as a result of a system call, or if
+ * it ever exits, it should generally reparent itself to kthreadd so it
+ * isn't in the way of other processes and is correctly cleaned up on exit.
+ *
+ * The various task state such as scheduling policy and priority may have
+ * been inherited from a user process, so we reset them to sane values here.
+ *
+ * NOTE that reparent_to_kthreadd() gives the caller full capabilities.
+ */
+static void reparent_to_kthreadd(void)
+{
+        write_lock_irq(&tasklist_lock);
+
+        ptrace_unlink(current);
+        /* Reparent to init */
+        current->real_parent = current->parent = kthreadd_task;
+        list_move_tail(&current->sibling, &current->real_parent->children);
+
+        /* Set the exit signal to SIGCHLD so we signal init on exit */
+        current->exit_signal = SIGCHLD;
+
+        if (task_nice(current) < 0)
+                set_user_nice(current, 0);
+        /* cpus_allowed? */
+        /* rt_priority? */
+        /* signals? */
+        memcpy(current->signal->rlim, init_task.signal->rlim,
+               sizeof(current->signal->rlim));
+
+        atomic_inc(&init_cred.usage);
+        commit_creds(&init_cred);
+        write_unlock_irq(&tasklist_lock);
+}
+
 void __set_special_pids(struct pid *pid)
 {
         struct task_struct *curr = current->group_leader;
@@ -321,6 +356,13 @@ void __set_special_pids(struct pid *pid)
                 change_pid(curr, PIDTYPE_PGID, pid);
 }
 
+static void set_special_pids(struct pid *pid)
+{
+        write_lock_irq(&tasklist_lock);
+        __set_special_pids(pid);
+        write_unlock_irq(&tasklist_lock);
+}
+
 /*
  * Let kernel threads use this to say that they allow a certain signal.
  * Must not be used if kthread was cloned with CLONE_SIGHAND.
@@ -360,6 +402,149 @@ int disallow_signal(int sig)
 
 EXPORT_SYMBOL(disallow_signal);
 
+/*
+ *      Put all the gunge required to become a kernel thread without
+ *      attached user resources in one place where it belongs.
+ */
+
+void daemonize(const char *name, ...)
+{
+        va_list args;
+        sigset_t blocked;
+
+        va_start(args, name);
+        vsnprintf(current->comm, sizeof(current->comm), name, args);
+        va_end(args);
+
+        /*
+         * If we were started as result of loading a module, close all of the
+         * user space pages.  We don't need them, and if we didn't close them
+         * they would be locked into memory.
+         */
+        exit_mm(current);
+        /*
+         * We don't want to have TIF_FREEZE set if the system-wide hibernation
+         * or suspend transition begins right now.
+         */
+        current->flags |= (PF_NOFREEZE | PF_KTHREAD);
+
+        if (current->nsproxy != &init_nsproxy) {
+                get_nsproxy(&init_nsproxy);
+                switch_task_namespaces(current, &init_nsproxy);
+        }
+        set_special_pids(&init_struct_pid);
+        proc_clear_tty(current);
+
+        /* Block and flush all signals */
+        sigfillset(&blocked);
+        sigprocmask(SIG_BLOCK, &blocked, NULL);
+        flush_signals(current);
+
+        /* Become as one with the init task */
+
+        daemonize_fs_struct();
+        exit_files(current);
+        current->files = init_task.files;
+        atomic_inc(&current->files->count);
+
+        reparent_to_kthreadd();
+}
+
+EXPORT_SYMBOL(daemonize);
+
+static void close_files(struct files_struct * files)
+{
+        int i, j;
+        struct fdtable *fdt;
+
+        j = 0;
+
+        /*
+         * It is safe to dereference the fd table without RCU or
+         * ->file_lock because this is the last reference to the
+         * 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;
+                if (i >= fdt->max_fds)
+                        break;
+                set = fdt->open_fds->fds_bits[j++];
+                while (set) {
+                        if (set & 1) {
+                                struct file * file = xchg(&fdt->fd[i], NULL);
+                                if (file) {
+                                        filp_close(file, files);
+                                        cond_resched();
+                                }
+                        }
+                        i++;
+                        set >>= 1;
+                }
+        }
+}
+
+struct files_struct *get_files_struct(struct task_struct *task)
+{
+        struct files_struct *files;
+
+        task_lock(task);
+        files = task->files;
+        if (files)
+                atomic_inc(&files->count);
+        task_unlock(task);
+
+        return files;
+}
+
+void put_files_struct(struct files_struct *files)
+{
+        struct fdtable *fdt;
+
+        if (atomic_dec_and_test(&files->count)) {
+                close_files(files);
+                /*
+                 * Free the fd and fdset arrays if we expanded them.
+                 * If the fdtable was embedded, pass files for freeing
+                 * 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();
+        }
+}
+
+void reset_files_struct(struct files_struct *files)
+{
+        struct task_struct *tsk = current;
+        struct files_struct *old;
+
+        old = tsk->files;
+        task_lock(tsk);
+        tsk->files = files;
+        task_unlock(tsk);
+        put_files_struct(old);
+}
+
+void exit_files(struct task_struct *tsk)
+{
+        struct files_struct * files = tsk->files;
+
+        if (files) {
+                task_lock(tsk);
+                tsk->files = NULL;
+                task_unlock(tsk);
+                put_files_struct(files);
+        }
+}
+
 #ifdef CONFIG_MM_OWNER
 /*
  * A task is exiting.   If it owned this mm, find a new owner for the mm.
@@ -456,7 +641,6 @@ static void exit_mm(struct task_struct * tsk)
         mm_release(tsk, mm);
         if (!mm)
                 return;
-        sync_mm_rss(mm);
         /*
          * Serialize with any possible pending coredump.
          * We must hold mmap_sem around checking core_state
@@ -495,17 +679,21 @@ static void exit_mm(struct task_struct * tsk)
         tsk->mm = NULL;
         up_read(&mm->mmap_sem);
         enter_lazy_tlb(mm, current);
+        /* We don't want this task to be frozen prematurely */
+        clear_freeze_flag(tsk);
+        if (tsk->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
+                atomic_dec(&mm->oom_disable_count);
         task_unlock(tsk);
         mm_update_next_owner(mm);
         mmput(mm);
 }
 
 /*
- * When we die, we re-parent all our children, and try to:
- * 1. give them to another thread in our thread group, if such a member exists
- * 2. give it to the first ancestor process which prctl'd itself as a
- *    child_subreaper for its children (like a service manager)
- * 3. give it to the init process (PID 1) in our pid namespace
+ * When we die, we re-parent all our children.
+ * Try to give them to another thread in our thread
+ * group, and if no such member exists, give it to
+ * the child reaper process (ie "init") in our pid
+ * space.
  */
 static struct task_struct *find_new_reaper(struct task_struct *father)
         __releases(&tasklist_lock)
@@ -525,37 +713,17 @@ static struct task_struct *find_new_reaper(struct task_struct *father)
 
         if (unlikely(pid_ns->child_reaper == father)) {
                 write_unlock_irq(&tasklist_lock);
-                if (unlikely(pid_ns == &init_pid_ns)) {
-                        panic("Attempted to kill init! exitcode=0x%08x\n",
-                                father->signal->group_exit_code ?:
-                                        father->exit_code);
-                }
+                if (unlikely(pid_ns == &init_pid_ns))
+                        panic("Attempted to kill init!");
 
                 zap_pid_ns_processes(pid_ns);
                 write_lock_irq(&tasklist_lock);
-        } else if (father->signal->has_child_subreaper) {
-                struct task_struct *reaper;
-
                 /*
-                 * Find the first ancestor marked as child_subreaper.
-                 * Note that the code below checks same_thread_group(reaper,
-                 * pid_ns->child_reaper).  This is what we need to DTRT in a
-                 * PID namespace. However we still need the check above, see
-                 * http://marc.info/?l=linux-kernel&m=131385460420380
+                 * We can not clear ->child_reaper or leave it alone.
+                 * There may by stealth EXIT_DEAD tasks on ->children,
+                 * forget_original_parent() must move them somewhere.
                  */
-                for (reaper = father->real_parent;
-                     reaper != &init_task;
-                     reaper = reaper->real_parent) {
-                        if (same_thread_group(reaper, pid_ns->child_reaper))
-                                break;
-                        if (!reaper->signal->is_child_subreaper)
-                                continue;
-                        thread = reaper;
-                        do {
-                                if (!(thread->flags & PF_EXITING))
-                                        return reaper;
-                        } while_each_thread(reaper, thread);
-                }
+                pid_ns->child_reaper = init_pid_ns.child_reaper;
         }
 
         return pid_ns->child_reaper;
@@ -653,6 +821,25 @@ static void exit_notify(struct task_struct *tsk, int group_dead)
         if (group_dead)
                 kill_orphaned_pgrp(tsk->group_leader, NULL);
 
+        /* Let father know we died
+         *
+         * Thread signals are configurable, but you aren't going to use
+         * that to send signals to arbitrary processes.
+         * That stops right now.
+         *
+         * If the parent exec id doesn't match the exec id we saved
+         * when we started then we know the parent has changed security
+         * domain.
+         *
+         * If our self_exec id doesn't match our parent_exec_id then
+         * we have changed execution domain as these two values started
+         * the same after a fork.
+         */
+        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;
+
         if (unlikely(tsk->ptrace)) {
                 int sig = thread_group_leader(tsk) &&
                                 thread_group_empty(tsk) &&
@@ -692,9 +879,9 @@ static void check_stack_usage(void)
 
         spin_lock(&low_water_lock);
         if (free < lowest_to_date) {
-                printk(KERN_WARNING "%s (%d) used greatest stack depth: "
-                                "%lu bytes left\n",
-                                current->comm, task_pid_nr(current), free);
+                printk(KERN_WARNING "%s used greatest stack depth: %lu bytes "
+                                "left\n",
+                                current->comm, free);
                 lowest_to_date = free;
         }
         spin_unlock(&low_water_lock);
@@ -703,7 +890,7 @@ static void check_stack_usage(void)
 static inline void check_stack_usage(void) {}
 #endif
 
-void do_exit(long code)
+NORET_TYPE void do_exit(long code)
 {
         struct task_struct *tsk = current;
         int group_dead;
@@ -751,6 +938,8 @@ void do_exit(long code)
                 schedule();
         }
 
+        exit_irq_thread();
+
         exit_signals(tsk);  /* sets PF_EXITING */
         /*
          * tsk->flags are checked in the futex code to protect against
@@ -767,7 +956,7 @@ void do_exit(long code)
         acct_update_integrals(tsk);
         /* sync mm's RSS info before statistics gathering */
         if (tsk->mm)
-                sync_mm_rss(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);
@@ -778,7 +967,8 @@ void do_exit(long code)
         acct_collect(code, group_dead);
         if (group_dead)
                 tty_audit_exit();
-        audit_free(tsk);
+        if (unlikely(tsk->audit_context))
+                audit_free(tsk);
 
         tsk->exit_code = code;
         taskstats_exit(tsk, group_dead);
@@ -793,7 +983,6 @@ void do_exit(long code)
         exit_shm(tsk);
         exit_files(tsk);
         exit_fs(tsk);
-        exit_task_work(tsk);
         check_stack_usage();
         exit_thread();
 
@@ -847,34 +1036,12 @@ void do_exit(long code)
         if (tsk->splice_pipe)
                 __free_pipe_info(tsk->splice_pipe);
 
-        if (tsk->task_frag.page)
-                put_page(tsk->task_frag.page);
-
         validate_creds_for_do_exit(tsk);
 
         preempt_disable();
-        if (tsk->nr_dirtied)
-                __this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);
         exit_rcu();
-
-        /*
-         * The setting of TASK_RUNNING by try_to_wake_up() may be delayed
-         * when the following two conditions become true.
-         *   - There is race condition of mmap_sem (It is acquired by
-         *     exit_mm()), and
-         *   - SMI occurs before setting TASK_RUNINNG.
-         *     (or hypervisor of virtual machine switches to other guest)
-         *  As a result, we may become TASK_RUNNING after becoming TASK_DEAD
-         *
-         * To avoid it, we have to wait for releasing tsk->pi_lock which
-         * is held by try_to_wake_up()
-         */
-        smp_mb();
-        raw_spin_unlock_wait(&tsk->pi_lock);
-
         /* causes final put_task_struct in finish_task_switch(). */
         tsk->state = TASK_DEAD;
-        tsk->flags |= PF_NOFREEZE;      /* tell freezer to ignore us */
         schedule();
         BUG();
         /* Avoid "noreturn function does return".  */
@@ -884,7 +1051,7 @@ void do_exit(long code)
 
 EXPORT_SYMBOL_GPL(do_exit);
 
-void complete_and_exit(struct completion *comp, long code)
+NORET_TYPE void complete_and_exit(struct completion *comp, long code)
 {
         if (comp)
                 complete(comp);
@@ -903,7 +1070,7 @@ SYSCALL_DEFINE1(exit, int, error_code)
  * Take down every thread in the group.  This is called by fatal signals
  * as well as by sys_exit_group (below).
  */
-void
+NORET_TYPE void
 do_group_exit(int exit_code)
 {
         struct signal_struct *sig = current->signal;
@@ -1024,7 +1191,7 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
         unsigned long state;
         int retval, status, traced;
         pid_t pid = task_pid_vnr(p);
-        uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p));
+        uid_t uid = __task_cred(p)->uid;
         struct siginfo __user *infop;
 
         if (!likely(wo->wo_flags & WEXITED))
@@ -1082,17 +1249,27 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
                  * as other threads in the parent group can be right
                  * here reaping other children at the same time.
                  *
-                 * We use thread_group_cputime_adjusted() to get times for the thread
+                 * 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_cputime_adjusted(p, &tgutime, &tgstime);
+                thread_group_times(p, &tgutime, &tgstime);
                 spin_lock_irq(&p->real_parent->sighand->siglock);
                 psig = p->real_parent->signal;
                 sig = p->signal;
-                psig->cutime += tgutime + sig->cutime;
-                psig->cstime += tgstime + sig->cstime;
-                psig->cgtime += p->gtime + sig->gtime + sig->cgtime;
+                psig->cutime =
+                        cputime_add(psig->cutime,
+                        cputime_add(tgutime,
+                                    sig->cutime));
+                psig->cstime =
+                        cputime_add(psig->cstime,
+                        cputime_add(tgstime,
+                                    sig->cstime));
+                psig->cgtime =
+                        cputime_add(psig->cgtime,
+                        cputime_add(p->gtime,
+                        cputime_add(sig->gtime,
+                                    sig->cgtime)));
                 psig->cmin_flt +=
                         p->min_flt + sig->min_flt + sig->cmin_flt;
                 psig->cmaj_flt +=
@@ -1237,7 +1414,7 @@ static int wait_task_stopped(struct wait_opts *wo,
         if (!unlikely(wo->wo_flags & WNOWAIT))
                 *p_code = 0;
 
-        uid = from_kuid_munged(current_user_ns(), task_uid(p));
+        uid = task_uid(p);
 unlock_sig:
         spin_unlock_irq(&p->sighand->siglock);
         if (!exit_code)
@@ -1310,7 +1487,7 @@ static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
         }
         if (!unlikely(wo->wo_flags & WNOWAIT))
                 p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
-        uid = from_kuid_munged(current_user_ns(), task_uid(p));
+        uid = task_uid(p);
         spin_unlock_irq(&p->sighand->siglock);
 
         pid = task_pid_vnr(p);