5 files changed, 39 insertions, 111 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index 073005b1cfb2..97f609f574b1 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -507,10 +507,9 @@ void put_files_struct(struct files_struct *files)
         }
 }
 
-EXPORT_SYMBOL(put_files_struct);
-
-void reset_files_struct(struct task_struct *tsk, struct files_struct *files)
+void reset_files_struct(struct files_struct *files)
 {
+        struct task_struct *tsk = current;
         struct files_struct *old;
 
         old = tsk->files;
@@ -519,9 +518,8 @@ void reset_files_struct(struct task_struct *tsk, struct files_struct *files)
         task_unlock(tsk);
         put_files_struct(old);
 }
-EXPORT_SYMBOL(reset_files_struct);
 
-static void __exit_files(struct task_struct *tsk)
+void exit_files(struct task_struct *tsk)
 {
         struct files_struct * files = tsk->files;
 
@@ -533,12 +531,7 @@ static void __exit_files(struct task_struct *tsk)
         }
 }
 
-void exit_files(struct task_struct *tsk)
-{
-        __exit_files(tsk);
-}
-
-static void __put_fs_struct(struct fs_struct *fs)
+void put_fs_struct(struct fs_struct *fs)
 {
         /* No need to hold fs->lock if we are killing it */
         if (atomic_dec_and_test(&fs->count)) {
@@ -550,12 +543,7 @@ static void __put_fs_struct(struct fs_struct *fs)
         }
 }
 
-void put_fs_struct(struct fs_struct *fs)
-{
-        __put_fs_struct(fs);
-}
-
-static void __exit_fs(struct task_struct *tsk)
+void exit_fs(struct task_struct *tsk)
 {
         struct fs_struct * fs = tsk->fs;
 
@@ -563,15 +551,10 @@ static void __exit_fs(struct task_struct *tsk)
                 task_lock(tsk);
                 tsk->fs = NULL;
                 task_unlock(tsk);
-                __put_fs_struct(fs);
+                put_fs_struct(fs);
         }
 }
 
-void exit_fs(struct task_struct *tsk)
-{
-        __exit_fs(tsk);
-}
-
 EXPORT_SYMBOL_GPL(exit_fs);
 
 /*
@@ -967,8 +950,8 @@ NORET_TYPE void do_exit(long code)
         if (group_dead)
                 acct_process();
         exit_sem(tsk);
-        __exit_files(tsk);
-        __exit_fs(tsk);
+        exit_files(tsk);
+        exit_fs(tsk);
         check_stack_usage();
         exit_thread();
         cgroup_exit(tsk, 1);
diff --git a/kernel/fork.c b/kernel/fork.c
index 89fe414645e9..c674aa8d3c31 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -521,7 +521,7 @@ void mm_release(struct task_struct *tsk, struct mm_struct *mm)
  * Allocate a new mm structure and copy contents from the
  * mm structure of the passed in task structure.
  */
-static struct mm_struct *dup_mm(struct task_struct *tsk)
+struct mm_struct *dup_mm(struct task_struct *tsk)
 {
         struct mm_struct *mm, *oldmm = current->mm;
         int err;
@@ -805,12 +805,6 @@ static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
                 goto out;
         }
 
-        /*
-         * Note: we may be using current for both targets (See exec.c)
-         * This works because we cache current->files (old) as oldf. Don't
-         * break this.
-         */
-        tsk->files = NULL;
         newf = dup_fd(oldf, &error);
         if (!newf)
                 goto out;
@@ -846,34 +840,6 @@ static int copy_io(unsigned long clone_flags, struct task_struct *tsk)
         return 0;
 }
 
-/*
- *      Helper to unshare the files of the current task.
- *      We don't want to expose copy_files internals to
- *      the exec layer of the kernel.
- */
-
-int unshare_files(void)
-{
-        struct files_struct *files  = current->files;
-        int rc;
-
-        BUG_ON(!files);
-
-        /* This can race but the race causes us to copy when we don't
-           need to and drop the copy */
-        if(atomic_read(&files->count) == 1)
-        {
-                atomic_inc(&files->count);
-                return 0;
-        }
-        rc = copy_files(0, current);
-        if(rc)
-                current->files = files;
-        return rc;
-}
-
-EXPORT_SYMBOL(unshare_files);
-
 static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
 {
         struct sighand_struct *sig;
@@ -1811,3 +1777,27 @@ bad_unshare_cleanup_thread:
 bad_unshare_out:
         return err;
 }
+
+/*
+ *      Helper to unshare the files of the current task.
+ *      We don't want to expose copy_files internals to
+ *      the exec layer of the kernel.
+ */
+
+int unshare_files(struct files_struct **displaced)
+{
+        struct task_struct *task = current;
+        struct files_struct *copy = NULL;
+        int error;
+
+        error = unshare_fd(CLONE_FILES, &copy);
+        if (error || !copy) {
+                *displaced = NULL;
+                return error;
+        }
+        *displaced = task->files;
+        task_lock(task);
+        task->files = copy;
+        task_unlock(task);
+        return 0;
+}
diff --git a/kernel/sched.c b/kernel/sched.c
index 57ba7ea9b744..740fb409e5bb 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -1657,42 +1657,6 @@ void aggregate_group_weight(struct task_group *tg, struct sched_domain *sd)
 }
 
 /*
- * Redistribute tg->shares amongst all tg->cfs_rq[]s.
- */
-static void __aggregate_redistribute_shares(struct task_group *tg)
-{
-        int i, max_cpu = smp_processor_id();
-        unsigned long rq_weight = 0;
-        unsigned long shares, max_shares = 0, shares_rem = tg->shares;
-
-        for_each_possible_cpu(i)
-                rq_weight += tg->cfs_rq[i]->load.weight;
-
-        for_each_possible_cpu(i) {
-                /*
-                 * divide shares proportional to the rq_weights.
-                 */
-                shares = tg->shares * tg->cfs_rq[i]->load.weight;
-                shares /= rq_weight + 1;
-
-                tg->cfs_rq[i]->shares = shares;
-
-                if (shares > max_shares) {
-                        max_shares = shares;
-                        max_cpu = i;
-                }
-                shares_rem -= shares;
-        }
-
-        /*
-         * Ensure it all adds up to tg->shares; we can loose a few
-         * due to rounding down when computing the per-cpu shares.
-         */
-        if (shares_rem)
-                tg->cfs_rq[max_cpu]->shares += shares_rem;
-}
-
-/*
  * Compute the weight of this group on the given cpus.
  */
 static
@@ -1701,18 +1665,11 @@ void aggregate_group_shares(struct task_group *tg, struct sched_domain *sd)
         unsigned long shares = 0;
         int i;
 
-again:
         for_each_cpu_mask(i, sd->span)
                 shares += tg->cfs_rq[i]->shares;
 
-        /*
-         * When the span doesn't have any shares assigned, but does have
-         * tasks to run do a machine wide rebalance (should be rare).
-         */
-        if (unlikely(!shares && aggregate(tg, sd)->rq_weight)) {
-                __aggregate_redistribute_shares(tg);
-                goto again;
-        }
+        if ((!shares && aggregate(tg, sd)->rq_weight) || shares > tg->shares)
+                shares = tg->shares;
 
         aggregate(tg, sd)->shares = shares;
 }
@@ -7035,6 +6992,7 @@ static int find_next_best_node(int node, nodemask_t *used_nodes)
 /**
  * sched_domain_node_span - get a cpumask for a node's sched_domain
  * @node: node whose cpumask we're constructing
+ * @span: resulting cpumask
  *
  * Given a node, construct a good cpumask for its sched_domain to span. It
  * should be one that prevents unnecessary balancing, but also spreads tasks
@@ -7990,11 +7948,6 @@ void __init sched_init_smp(void)
 #else
 void __init sched_init_smp(void)
 {
-#if defined(CONFIG_NUMA)
-        sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
-                                                                GFP_KERNEL);
-        BUG_ON(sched_group_nodes_bycpu == NULL);
-#endif
         sched_init_granularity();
 }
 #endif /* CONFIG_SMP */
@@ -8127,7 +8080,7 @@ void __init sched_init(void)
          * we use alloc_bootmem().
          */
         if (alloc_size) {
-                ptr = (unsigned long)alloc_bootmem_low(alloc_size);
+                ptr = (unsigned long)alloc_bootmem(alloc_size);
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
                 init_task_group.se = (struct sched_entity **)ptr;
diff --git a/kernel/time.c b/kernel/time.c
index a5ec013b6c80..35d373a98782 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -379,6 +379,7 @@ void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
         ts->tv_sec = sec;
         ts->tv_nsec = nsec;
 }
+EXPORT_SYMBOL(set_normalized_timespec);
 
 /**
  * ns_to_timespec - Convert nanoseconds to timespec
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index d358d4e3a958..b854a895591e 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -393,6 +393,7 @@ void tick_nohz_restart_sched_tick(void)
                 sub_preempt_count(HARDIRQ_OFFSET);
         }
 
+        touch_softlockup_watchdog();
         /*
          * Cancel the scheduled timer and restore the tick
          */