10 files changed, 179 insertions, 185 deletions

diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 57e6448b171e..0864f4097930 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -581,26 +581,28 @@ static void guarantee_online_cpus(const struct cpuset *cs, cpumask_t *pmask)
 
 /*
  * Return in *pmask the portion of a cpusets's mems_allowed that
- * are online.  If none are online, walk up the cpuset hierarchy
- * until we find one that does have some online mems.  If we get
- * all the way to the top and still haven't found any online mems,
- * return node_online_map.
+ * are online, with memory.  If none are online with memory, walk
+ * up the cpuset hierarchy until we find one that does have some
+ * online mems.  If we get all the way to the top and still haven't
+ * found any online mems, return node_states[N_HIGH_MEMORY].
  *
  * One way or another, we guarantee to return some non-empty subset
- * of node_online_map.
+ * of node_states[N_HIGH_MEMORY].
  *
  * Call with callback_mutex held.
  */
 
 static void guarantee_online_mems(const struct cpuset *cs, nodemask_t *pmask)
 {
-        while (cs && !nodes_intersects(cs->mems_allowed, node_online_map))
+        while (cs && !nodes_intersects(cs->mems_allowed,
+                                        node_states[N_HIGH_MEMORY]))
                 cs = cs->parent;
         if (cs)
-                nodes_and(*pmask, cs->mems_allowed, node_online_map);
+                nodes_and(*pmask, cs->mems_allowed,
+                                        node_states[N_HIGH_MEMORY]);
         else
-                *pmask = node_online_map;
-        BUG_ON(!nodes_intersects(*pmask, node_online_map));
+                *pmask = node_states[N_HIGH_MEMORY];
+        BUG_ON(!nodes_intersects(*pmask, node_states[N_HIGH_MEMORY]));
 }
 
 /**
@@ -753,68 +755,13 @@ static int validate_change(const struct cpuset *cur, const struct cpuset *trial)
 }
 
 /*
- * For a given cpuset cur, partition the system as follows
- * a. All cpus in the parent cpuset's cpus_allowed that are not part of any
- *    exclusive child cpusets
- * b. All cpus in the current cpuset's cpus_allowed that are not part of any
- *    exclusive child cpusets
- * Build these two partitions by calling partition_sched_domains
- *
- * Call with manage_mutex held.  May nest a call to the
- * lock_cpu_hotplug()/unlock_cpu_hotplug() pair.
- * Must not be called holding callback_mutex, because we must
- * not call lock_cpu_hotplug() while holding callback_mutex.
- */
-
-static void update_cpu_domains(struct cpuset *cur)
-{
-        struct cpuset *c, *par = cur->parent;
-        cpumask_t pspan, cspan;
-
-        if (par == NULL || cpus_empty(cur->cpus_allowed))
-                return;
-
-        /*
-         * Get all cpus from parent's cpus_allowed not part of exclusive
-         * children
-         */
-        pspan = par->cpus_allowed;
-        list_for_each_entry(c, &par->children, sibling) {
-                if (is_cpu_exclusive(c))
-                        cpus_andnot(pspan, pspan, c->cpus_allowed);
-        }
-        if (!is_cpu_exclusive(cur)) {
-                cpus_or(pspan, pspan, cur->cpus_allowed);
-                if (cpus_equal(pspan, cur->cpus_allowed))
-                        return;
-                cspan = CPU_MASK_NONE;
-        } else {
-                if (cpus_empty(pspan))
-                        return;
-                cspan = cur->cpus_allowed;
-                /*
-                 * Get all cpus from current cpuset's cpus_allowed not part
-                 * of exclusive children
-                 */
-                list_for_each_entry(c, &cur->children, sibling) {
-                        if (is_cpu_exclusive(c))
-                                cpus_andnot(cspan, cspan, c->cpus_allowed);
-                }
-        }
-
-        lock_cpu_hotplug();
-        partition_sched_domains(&pspan, &cspan);
-        unlock_cpu_hotplug();
-}
-
-/*
  * Call with manage_mutex held.  May take callback_mutex during call.
  */
 
 static int update_cpumask(struct cpuset *cs, char *buf)
 {
         struct cpuset trialcs;
-        int retval, cpus_unchanged;
+        int retval;
 
         /* top_cpuset.cpus_allowed tracks cpu_online_map; it's read-only */
         if (cs == &top_cpuset)
@@ -841,12 +788,9 @@ static int update_cpumask(struct cpuset *cs, char *buf)
         retval = validate_change(cs, &trialcs);
         if (retval < 0)
                 return retval;
-        cpus_unchanged = cpus_equal(cs->cpus_allowed, trialcs.cpus_allowed);
         mutex_lock(&callback_mutex);
         cs->cpus_allowed = trialcs.cpus_allowed;
         mutex_unlock(&callback_mutex);
-        if (is_cpu_exclusive(cs) && !cpus_unchanged)
-                update_cpu_domains(cs);
         return 0;
 }
 
@@ -924,7 +868,10 @@ static int update_nodemask(struct cpuset *cs, char *buf)
         int fudge;
         int retval;
 
-        /* top_cpuset.mems_allowed tracks node_online_map; it's read-only */
+        /*
+         * top_cpuset.mems_allowed tracks node_stats[N_HIGH_MEMORY];
+         * it's read-only
+         */
         if (cs == &top_cpuset)
                 return -EACCES;
 
@@ -941,8 +888,21 @@ static int update_nodemask(struct cpuset *cs, char *buf)
                 retval = nodelist_parse(buf, trialcs.mems_allowed);
                 if (retval < 0)
                         goto done;
+                if (!nodes_intersects(trialcs.mems_allowed,
+                                                node_states[N_HIGH_MEMORY])) {
+                        /*
+                         * error if only memoryless nodes specified.
+                         */
+                        retval = -ENOSPC;
+                        goto done;
+                }
         }
-        nodes_and(trialcs.mems_allowed, trialcs.mems_allowed, node_online_map);
+        /*
+         * Exclude memoryless nodes.  We know that trialcs.mems_allowed
+         * contains at least one node with memory.
+         */
+        nodes_and(trialcs.mems_allowed, trialcs.mems_allowed,
+                                                node_states[N_HIGH_MEMORY]);
         oldmem = cs->mems_allowed;
         if (nodes_equal(oldmem, trialcs.mems_allowed)) {
                 retval = 0;             /* Too easy - nothing to do */
@@ -1067,7 +1027,7 @@ static int update_flag(cpuset_flagbits_t bit, struct cpuset *cs, char *buf)
 {
         int turning_on;
         struct cpuset trialcs;
-        int err, cpu_exclusive_changed;
+        int err;
 
         turning_on = (simple_strtoul(buf, NULL, 10) != 0);
 
@@ -1080,14 +1040,10 @@ static int update_flag(cpuset_flagbits_t bit, struct cpuset *cs, char *buf)
         err = validate_change(cs, &trialcs);
         if (err < 0)
                 return err;
-        cpu_exclusive_changed =
-                (is_cpu_exclusive(cs) != is_cpu_exclusive(&trialcs));
         mutex_lock(&callback_mutex);
         cs->flags = trialcs.flags;
         mutex_unlock(&callback_mutex);
 
-        if (cpu_exclusive_changed)
-                update_cpu_domains(cs);
         return 0;
 }
 
@@ -1445,7 +1401,7 @@ static ssize_t cpuset_common_file_read(struct file *file, char __user *buf,
         ssize_t retval = 0;
         char *s;
 
-        if (!(page = (char *)__get_free_page(GFP_KERNEL)))
+        if (!(page = (char *)__get_free_page(GFP_TEMPORARY)))
                 return -ENOMEM;
 
         s = page;
@@ -1947,17 +1903,6 @@ static int cpuset_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         return cpuset_create(c_parent, dentry->d_name.name, mode | S_IFDIR);
 }
 
-/*
- * Locking note on the strange update_flag() call below:
- *
- * If the cpuset being removed is marked cpu_exclusive, then simulate
- * turning cpu_exclusive off, which will call update_cpu_domains().
- * The lock_cpu_hotplug() call in update_cpu_domains() must not be
- * made while holding callback_mutex.  Elsewhere the kernel nests
- * callback_mutex inside lock_cpu_hotplug() calls.  So the reverse
- * nesting would risk an ABBA deadlock.
- */
-
 static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
 {
         struct cpuset *cs = dentry->d_fsdata;
@@ -1977,13 +1922,6 @@ static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
                 mutex_unlock(&manage_mutex);
                 return -EBUSY;
         }
-        if (is_cpu_exclusive(cs)) {
-                int retval = update_flag(CS_CPU_EXCLUSIVE, cs, "0");
-                if (retval < 0) {
-                        mutex_unlock(&manage_mutex);
-                        return retval;
-                }
-        }
         parent = cs->parent;
         mutex_lock(&callback_mutex);
         set_bit(CS_REMOVED, &cs->flags);
@@ -2098,8 +2036,9 @@ static void guarantee_online_cpus_mems_in_subtree(const struct cpuset *cur)
 
 /*
  * The cpus_allowed and mems_allowed nodemasks in the top_cpuset track
- * cpu_online_map and node_online_map.  Force the top cpuset to track
- * whats online after any CPU or memory node hotplug or unplug event.
+ * cpu_online_map and node_states[N_HIGH_MEMORY].  Force the top cpuset to
+ * track what's online after any CPU or memory node hotplug or unplug
+ * event.
  *
  * To ensure that we don't remove a CPU or node from the top cpuset
  * that is currently in use by a child cpuset (which would violate
@@ -2119,7 +2058,7 @@ static void common_cpu_mem_hotplug_unplug(void)
 
         guarantee_online_cpus_mems_in_subtree(&top_cpuset);
         top_cpuset.cpus_allowed = cpu_online_map;
-        top_cpuset.mems_allowed = node_online_map;
+        top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
 
         mutex_unlock(&callback_mutex);
         mutex_unlock(&manage_mutex);
@@ -2147,8 +2086,9 @@ static int cpuset_handle_cpuhp(struct notifier_block *nb,
 
 #ifdef CONFIG_MEMORY_HOTPLUG
 /*
- * Keep top_cpuset.mems_allowed tracking node_online_map.
- * Call this routine anytime after you change node_online_map.
+ * Keep top_cpuset.mems_allowed tracking node_states[N_HIGH_MEMORY].
+ * Call this routine anytime after you change
+ * node_states[N_HIGH_MEMORY].
  * See also the previous routine cpuset_handle_cpuhp().
  */
 
@@ -2167,7 +2107,7 @@ void cpuset_track_online_nodes(void)
 void __init cpuset_init_smp(void)
 {
         top_cpuset.cpus_allowed = cpu_online_map;
-        top_cpuset.mems_allowed = node_online_map;
+        top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
 
         hotcpu_notifier(cpuset_handle_cpuhp, 0);
 }
@@ -2309,7 +2249,7 @@ void cpuset_init_current_mems_allowed(void)
  *
  * Description: Returns the nodemask_t mems_allowed of the cpuset
  * attached to the specified @tsk.  Guaranteed to return some non-empty
- * subset of node_online_map, even if this means going outside the
+ * subset of node_states[N_HIGH_MEMORY], even if this means going outside the
  * tasks cpuset.
  **/
 
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 4b8a4493c541..e3a5d817ac9b 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -64,7 +64,6 @@
 
 static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
 static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
-static atomic_t kprobe_count;
 
 /* NOTE: change this value only with kprobe_mutex held */
 static bool kprobe_enabled;
@@ -73,11 +72,6 @@ DEFINE_MUTEX(kprobe_mutex);		/* Protects kprobe_table */
 DEFINE_SPINLOCK(kretprobe_lock);        /* Protects kretprobe_inst_table */
 static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
 
-static struct notifier_block kprobe_page_fault_nb = {
-        .notifier_call = kprobe_exceptions_notify,
-        .priority = 0x7fffffff /* we need to notified first */
-};
-
 #ifdef __ARCH_WANT_KPROBES_INSN_SLOT
 /*
  * kprobe->ainsn.insn points to the copy of the instruction to be
@@ -556,8 +550,6 @@ static int __kprobes __register_kprobe(struct kprobe *p,
         old_p = get_kprobe(p->addr);
         if (old_p) {
                 ret = register_aggr_kprobe(old_p, p);
-                if (!ret)
-                        atomic_inc(&kprobe_count);
                 goto out;
         }
 
@@ -569,13 +561,9 @@ static int __kprobes __register_kprobe(struct kprobe *p,
         hlist_add_head_rcu(&p->hlist,
                        &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
 
-        if (kprobe_enabled) {
-                if (atomic_add_return(1, &kprobe_count) == \
-                                (ARCH_INACTIVE_KPROBE_COUNT + 1))
-                        register_page_fault_notifier(&kprobe_page_fault_nb);
-
+        if (kprobe_enabled)
                 arch_arm_kprobe(p);
-        }
+
 out:
         mutex_unlock(&kprobe_mutex);
 
@@ -658,16 +646,6 @@ valid_p:
                 }
                 mutex_unlock(&kprobe_mutex);
         }
-
-        /* Call unregister_page_fault_notifier()
-         * if no probes are active
-         */
-        mutex_lock(&kprobe_mutex);
-        if (atomic_add_return(-1, &kprobe_count) == \
-                                ARCH_INACTIVE_KPROBE_COUNT)
-                unregister_page_fault_notifier(&kprobe_page_fault_nb);
-        mutex_unlock(&kprobe_mutex);
-        return;
 }
 
 static struct notifier_block kprobe_exceptions_nb = {
@@ -738,6 +716,18 @@ int __kprobes register_kretprobe(struct kretprobe *rp)
         int ret = 0;
         struct kretprobe_instance *inst;
         int i;
+        void *addr = rp->kp.addr;
+
+        if (kretprobe_blacklist_size) {
+                if (addr == NULL)
+                        kprobe_lookup_name(rp->kp.symbol_name, addr);
+                addr += rp->kp.offset;
+
+                for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
+                        if (kretprobe_blacklist[i].addr == addr)
+                                return -EINVAL;
+                }
+        }
 
         rp->kp.pre_handler = pre_handler_kretprobe;
         rp->kp.post_handler = NULL;
@@ -815,7 +805,17 @@ static int __init init_kprobes(void)
                 INIT_HLIST_HEAD(&kprobe_table[i]);
                 INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
         }
-        atomic_set(&kprobe_count, 0);
+
+        if (kretprobe_blacklist_size) {
+                /* lookup the function address from its name */
+                for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
+                        kprobe_lookup_name(kretprobe_blacklist[i].name,
+                                           kretprobe_blacklist[i].addr);
+                        if (!kretprobe_blacklist[i].addr)
+                                printk("kretprobe: lookup failed: %s\n",
+                                       kretprobe_blacklist[i].name);
+                }
+        }
 
         /* By default, kprobes are enabled */
         kprobe_enabled = true;
@@ -921,13 +921,6 @@ static void __kprobes enable_all_kprobes(void)
         if (kprobe_enabled)
                 goto already_enabled;
 
-        /*
-         * Re-register the page fault notifier only if there are any
-         * active probes at the time of enabling kprobes globally
-         */
-        if (atomic_read(&kprobe_count) > ARCH_INACTIVE_KPROBE_COUNT)
-                register_page_fault_notifier(&kprobe_page_fault_nb);
-
         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
                 head = &kprobe_table[i];
                 hlist_for_each_entry_rcu(p, node, head, hlist)
@@ -968,10 +961,7 @@ static void __kprobes disable_all_kprobes(void)
         mutex_unlock(&kprobe_mutex);
         /* Allow all currently running kprobes to complete */
         synchronize_sched();
-
-        mutex_lock(&kprobe_mutex);
-        /* Unconditionally unregister the page_fault notifier */
-        unregister_page_fault_notifier(&kprobe_page_fault_nb);
+        return;
 
 already_disabled:
         mutex_unlock(&kprobe_mutex);
diff --git a/kernel/printk.c b/kernel/printk.c
index 8451dfc31d25..b2b5c3a22a36 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -22,6 +22,8 @@
 #include <linux/tty_driver.h>
 #include <linux/console.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/nmi.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>                    /* For in_interrupt() */
@@ -162,6 +164,61 @@ out:
 
 __setup("log_buf_len=", log_buf_len_setup);
 
+#ifdef CONFIG_BOOT_PRINTK_DELAY
+
+static unsigned int boot_delay; /* msecs delay after each printk during bootup */
+static unsigned long long printk_delay_msec; /* per msec, based on boot_delay */
+
+static int __init boot_delay_setup(char *str)
+{
+        unsigned long lpj;
+        unsigned long long loops_per_msec;
+
+        lpj = preset_lpj ? preset_lpj : 1000000;        /* some guess */
+        loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
+
+        get_option(&str, &boot_delay);
+        if (boot_delay > 10 * 1000)
+                boot_delay = 0;
+
+        printk_delay_msec = loops_per_msec;
+        printk(KERN_DEBUG "boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
+                "HZ: %d, printk_delay_msec: %llu\n",
+                boot_delay, preset_lpj, lpj, HZ, printk_delay_msec);
+        return 1;
+}
+__setup("boot_delay=", boot_delay_setup);
+
+static void boot_delay_msec(void)
+{
+        unsigned long long k;
+        unsigned long timeout;
+
+        if (boot_delay == 0 || system_state != SYSTEM_BOOTING)
+                return;
+
+        k = (unsigned long long)printk_delay_msec * boot_delay;
+
+        timeout = jiffies + msecs_to_jiffies(boot_delay);
+        while (k) {
+                k--;
+                cpu_relax();
+                /*
+                 * use (volatile) jiffies to prevent
+                 * compiler reduction; loop termination via jiffies
+                 * is secondary and may or may not happen.
+                 */
+                if (time_after(jiffies, timeout))
+                        break;
+                touch_nmi_watchdog();
+        }
+}
+#else
+static inline void boot_delay_msec(void)
+{
+}
+#endif
+
 /*
  * Commands to do_syslog:
  *
@@ -527,6 +584,8 @@ asmlinkage int vprintk(const char *fmt, va_list args)
         static char printk_buf[1024];
         static int log_level_unknown = 1;
 
+        boot_delay_msec();
+
         preempt_disable();
         if (unlikely(oops_in_progress) && printk_cpu == smp_processor_id())
                 /* If a crash is occurring during printk() on this CPU,
diff --git a/kernel/profile.c b/kernel/profile.c
index cb1e37d2dac3..6f69bf792d96 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -346,7 +346,7 @@ static int __devinit profile_cpu_callback(struct notifier_block *info,
                 per_cpu(cpu_profile_flip, cpu) = 0;
                 if (!per_cpu(cpu_profile_hits, cpu)[1]) {
                         page = alloc_pages_node(node,
-                                        GFP_KERNEL | __GFP_ZERO | GFP_THISNODE,
+                                        GFP_KERNEL | __GFP_ZERO,
                                         0);
                         if (!page)
                                 return NOTIFY_BAD;
@@ -354,7 +354,7 @@ static int __devinit profile_cpu_callback(struct notifier_block *info,
                 }
                 if (!per_cpu(cpu_profile_hits, cpu)[0]) {
                         page = alloc_pages_node(node,
-                                        GFP_KERNEL | __GFP_ZERO | GFP_THISNODE,
+                                        GFP_KERNEL | __GFP_ZERO,
                                         0);
                         if (!page)
                                 goto out_free;
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 3eca7a55f2ee..a73ebd3b9d4c 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -386,6 +386,9 @@ int ptrace_request(struct task_struct *child, long request,
         case PTRACE_SETSIGINFO:
                 ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);
                 break;
+        case PTRACE_DETACH:      /* detach a process that was attached. */
+                ret = ptrace_detach(child, data);
+                break;
         default:
                 break;
         }
@@ -450,6 +453,10 @@ struct task_struct *ptrace_get_task_struct(pid_t pid)
         return child;
 }
 
+#ifndef arch_ptrace_attach
+#define arch_ptrace_attach(child)       do { } while (0)
+#endif
+
 #ifndef __ARCH_SYS_PTRACE
 asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
 {
@@ -473,6 +480,12 @@ asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
 
         if (request == PTRACE_ATTACH) {
                 ret = ptrace_attach(child);
+                /*
+                 * Some architectures need to do book-keeping after
+                 * a ptrace attach.
+                 */
+                if (!ret)
+                        arch_ptrace_attach(child);
                 goto out_put_task_struct;
         }
 
diff --git a/kernel/resource.c b/kernel/resource.c
index 9bd14fd3e6de..a358142ff48f 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -234,7 +234,7 @@ EXPORT_SYMBOL(release_resource);
  * the caller must specify res->start, res->end, res->flags.
  * If found, returns 0, res is overwritten, if not found, returns -1.
  */
-int find_next_system_ram(struct resource *res)
+static int find_next_system_ram(struct resource *res)
 {
         resource_size_t start, end;
         struct resource *p;
@@ -267,6 +267,30 @@ int find_next_system_ram(struct resource *res)
                 res->end = p->end;
         return 0;
 }
+int
+walk_memory_resource(unsigned long start_pfn, unsigned long nr_pages, void *arg,
+                        int (*func)(unsigned long, unsigned long, void *))
+{
+        struct resource res;
+        unsigned long pfn, len;
+        u64 orig_end;
+        int ret = -1;
+        res.start = (u64) start_pfn << PAGE_SHIFT;
+        res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
+        res.flags = IORESOURCE_MEM;
+        orig_end = res.end;
+        while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {
+                pfn = (unsigned long)(res.start >> PAGE_SHIFT);
+                len = (unsigned long)((res.end + 1 - res.start) >> PAGE_SHIFT);
+                ret = (*func)(pfn, len, arg);
+                if (ret)
+                        break;
+                res.start = res.end + 1;
+                res.end = orig_end;
+        }
+        return ret;
+}
+
 #endif
 
 /*
diff --git a/kernel/sched.c b/kernel/sched.c
index bba57adb9504..0da2b2635c54 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -5869,7 +5869,7 @@ static int cpu_to_core_group(int cpu, const cpumask_t *cpu_map,
                              struct sched_group **sg)
 {
         int group;
-        cpumask_t mask = cpu_sibling_map[cpu];
+        cpumask_t mask = per_cpu(cpu_sibling_map, cpu);
         cpus_and(mask, mask, *cpu_map);
         group = first_cpu(mask);
         if (sg)
@@ -5898,7 +5898,7 @@ static int cpu_to_phys_group(int cpu, const cpumask_t *cpu_map,
         cpus_and(mask, mask, *cpu_map);
         group = first_cpu(mask);
 #elif defined(CONFIG_SCHED_SMT)
-        cpumask_t mask = cpu_sibling_map[cpu];
+        cpumask_t mask = per_cpu(cpu_sibling_map, cpu);
         cpus_and(mask, mask, *cpu_map);
         group = first_cpu(mask);
 #else
@@ -6132,7 +6132,7 @@ static int build_sched_domains(const cpumask_t *cpu_map)
                 p = sd;
                 sd = &per_cpu(cpu_domains, i);
                 *sd = SD_SIBLING_INIT;
-                sd->span = cpu_sibling_map[i];
+                sd->span = per_cpu(cpu_sibling_map, i);
                 cpus_and(sd->span, sd->span, *cpu_map);
                 sd->parent = p;
                 p->child = sd;
@@ -6143,7 +6143,7 @@ static int build_sched_domains(const cpumask_t *cpu_map)
 #ifdef CONFIG_SCHED_SMT
         /* Set up CPU (sibling) groups */
         for_each_cpu_mask(i, *cpu_map) {
-                cpumask_t this_sibling_map = cpu_sibling_map[i];
+                cpumask_t this_sibling_map = per_cpu(cpu_sibling_map, i);
                 cpus_and(this_sibling_map, this_sibling_map, *cpu_map);
                 if (i != first_cpu(this_sibling_map))
                         continue;
@@ -6348,35 +6348,6 @@ static void detach_destroy_domains(const cpumask_t *cpu_map)
         arch_destroy_sched_domains(cpu_map);
 }
 
-/*
- * Partition sched domains as specified by the cpumasks below.
- * This attaches all cpus from the cpumasks to the NULL domain,
- * waits for a RCU quiescent period, recalculates sched
- * domain information and then attaches them back to the
- * correct sched domains
- * Call with hotplug lock held
- */
-int partition_sched_domains(cpumask_t *partition1, cpumask_t *partition2)
-{
-        cpumask_t change_map;
-        int err = 0;
-
-        cpus_and(*partition1, *partition1, cpu_online_map);
-        cpus_and(*partition2, *partition2, cpu_online_map);
-        cpus_or(change_map, *partition1, *partition2);
-
-        /* Detach sched domains from all of the affected cpus */
-        detach_destroy_domains(&change_map);
-        if (!cpus_empty(*partition1))
-                err = build_sched_domains(partition1);
-        if (!err && !cpus_empty(*partition2))
-                err = build_sched_domains(partition2);
-
-        register_sched_domain_sysctl();
-
-        return err;
-}
-
 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
 static int arch_reinit_sched_domains(void)
 {
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index ec14aa8ac51f..96efbb859997 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -880,6 +880,14 @@ static ctl_table vm_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &hugetlb_treat_movable_handler,
         },
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "hugetlb_dynamic_pool",
+                .data           = &hugetlb_dynamic_pool,
+                .maxlen         = sizeof(hugetlb_dynamic_pool),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
 #endif
         {
                 .ctl_name       = VM_LOWMEM_RESERVE_RATIO,
diff --git a/kernel/time.c b/kernel/time.c
index 2289a8d68314..1afcc78dc3b1 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -57,11 +57,7 @@ EXPORT_SYMBOL(sys_tz);
  */
 asmlinkage long sys_time(time_t __user * tloc)
 {
-        time_t i;
-        struct timespec tv;
-
-        getnstimeofday(&tv);
-        i = tv.tv_sec;
+        time_t i = get_seconds();
 
         if (tloc) {
                 if (put_user(i,tloc))
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 4ad79f6bdec6..7e8983aecf83 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -49,19 +49,12 @@ struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
 static unsigned long total_sleep_time;          /* seconds */
 EXPORT_SYMBOL(xtime);
 
-
-#ifdef CONFIG_NO_HZ
 static struct timespec xtime_cache __attribute__ ((aligned (16)));
 static inline void update_xtime_cache(u64 nsec)
 {
         xtime_cache = xtime;
         timespec_add_ns(&xtime_cache, nsec);
 }
-#else
-#define xtime_cache xtime
-/* We do *not* want to evaluate the argument for this case */
-#define update_xtime_cache(n) do { } while (0)
-#endif
 
 static struct clocksource *clock; /* pointer to current clocksource */