15 files changed, 120 insertions, 100 deletions

diff --git a/kernel/audit.c b/kernel/audit.c
index f9889ee778..98106f6078 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -340,7 +340,7 @@ static int kauditd_thread(void *dummy)
 {
         struct sk_buff *skb;
 
-        while (1) {
+        while (!kthread_should_stop()) {
                 skb = skb_dequeue(&audit_skb_queue);
                 wake_up(&audit_backlog_wait);
                 if (skb) {
@@ -369,6 +369,7 @@ static int kauditd_thread(void *dummy)
                         remove_wait_queue(&kauditd_wait, &wait);
                 }
         }
+        return 0;
 }
 
 int audit_send_list(void *_dest)
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 9d850ae13b..6313c38c93 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -2137,7 +2137,7 @@ static int cpuset_handle_cpuhp(struct notifier_block *nb,
  * See also the previous routine cpuset_handle_cpuhp().
  */
 
-void cpuset_track_online_nodes()
+void cpuset_track_online_nodes(void)
 {
         common_cpu_mem_hotplug_unplug();
 }
diff --git a/kernel/futex.c b/kernel/futex.c
index 4aaf91951a..b364e00261 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -1612,10 +1612,10 @@ sys_set_robust_list(struct robust_list_head __user *head,
  * @len_ptr: pointer to a length field, the kernel fills in the header size
  */
 asmlinkage long
-sys_get_robust_list(int pid, struct robust_list_head __user **head_ptr,
+sys_get_robust_list(int pid, struct robust_list_head __user * __user *head_ptr,
                     size_t __user *len_ptr)
 {
-        struct robust_list_head *head;
+        struct robust_list_head __user *head;
         unsigned long ret;
 
         if (!pid)
@@ -1694,14 +1694,15 @@ retry:
  * Fetch a robust-list pointer. Bit 0 signals PI futexes:
  */
 static inline int fetch_robust_entry(struct robust_list __user **entry,
-                                     struct robust_list __user **head, int *pi)
+                                     struct robust_list __user * __user *head,
+                                     int *pi)
 {
         unsigned long uentry;
 
-        if (get_user(uentry, (unsigned long *)head))
+        if (get_user(uentry, (unsigned long __user *)head))
                 return -EFAULT;
 
-        *entry = (void *)(uentry & ~1UL);
+        *entry = (void __user *)(uentry & ~1UL);
         *pi = uentry & 1;
 
         return 0;
@@ -1739,7 +1740,7 @@ void exit_robust_list(struct task_struct *curr)
                 return;
 
         if (pending)
-                handle_futex_death((void *)pending + futex_offset, curr, pip);
+                handle_futex_death((void __user *)pending + futex_offset, curr, pip);
 
         while (entry != &head->list) {
                 /*
@@ -1747,7 +1748,7 @@ void exit_robust_list(struct task_struct *curr)
                  * don't process it twice:
                  */
                 if (entry != pending)
-                        if (handle_futex_death((void *)entry + futex_offset,
+                        if (handle_futex_death((void __user *)entry + futex_offset,
                                                 curr, pi))
                                 return;
                 /*
diff --git a/kernel/futex_compat.c b/kernel/futex_compat.c
index c5cca3f65c..50f24eea6c 100644
--- a/kernel/futex_compat.c
+++ b/kernel/futex_compat.c
@@ -18,7 +18,7 @@
  */
 static inline int
 fetch_robust_entry(compat_uptr_t *uentry, struct robust_list __user **entry,
-                   compat_uptr_t *head, int *pi)
+                   compat_uptr_t __user *head, int *pi)
 {
         if (get_user(*uentry, head))
                 return -EFAULT;
@@ -62,7 +62,7 @@ void compat_exit_robust_list(struct task_struct *curr)
                                &head->list_op_pending, &pip))
                 return;
         if (upending)
-                handle_futex_death((void *)pending + futex_offset, curr, pip);
+                handle_futex_death((void __user *)pending + futex_offset, curr, pip);
 
         while (compat_ptr(uentry) != &head->list) {
                 /*
@@ -70,7 +70,7 @@ void compat_exit_robust_list(struct task_struct *curr)
                  * dont process it twice:
                  */
                 if (entry != pending)
-                        if (handle_futex_death((void *)entry + futex_offset,
+                        if (handle_futex_death((void __user *)entry + futex_offset,
                                                 curr, pi))
                                 return;
 
@@ -78,7 +78,7 @@ void compat_exit_robust_list(struct task_struct *curr)
                  * Fetch the next entry in the list:
                  */
                 if (fetch_robust_entry(&uentry, &entry,
-                                       (compat_uptr_t *)&entry->next, &pi))
+                                       (compat_uptr_t __user *)&entry->next, &pi))
                         return;
                 /*
                  * Avoid excessively long or circular lists:
@@ -103,10 +103,10 @@ compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
 }
 
 asmlinkage long
-compat_sys_get_robust_list(int pid, compat_uptr_t *head_ptr,
+compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
                            compat_size_t __user *len_ptr)
 {
-        struct compat_robust_list_head *head;
+        struct compat_robust_list_head __user *head;
         unsigned long ret;
 
         if (!pid)
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 607c7809ad..9a35266700 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -57,7 +57,7 @@ static int irq_affinity_write_proc(struct file *file, const char __user *buffer,
         if (!irq_desc[irq].chip->set_affinity || no_irq_affinity)
                 return -EIO;
 
-        err = cpumask_parse(buffer, count, new_value);
+        err = cpumask_parse_user(buffer, count, new_value);
         if (err)
                 return err;
 
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
index 35f10f7ff9..5bfeaed7e4 100644
--- a/kernel/irq/resend.c
+++ b/kernel/irq/resend.c
@@ -38,7 +38,7 @@ static void resend_irqs(unsigned long arg)
                 clear_bit(irq, irqs_resend);
                 desc = irq_desc + irq;
                 local_irq_disable();
-                desc->handle_irq(irq, desc, NULL);
+                desc->handle_irq(irq, desc);
                 local_irq_enable();
         }
 }
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 4c05534610..805a322a56 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -1114,8 +1114,6 @@ static int count_matching_names(struct lock_class *new_class)
         return count + 1;
 }
 
-extern void __error_too_big_MAX_LOCKDEP_SUBCLASSES(void);
-
 /*
  * Register a lock's class in the hash-table, if the class is not present
  * yet. Otherwise we look it up. We cache the result in the lock object
@@ -1153,8 +1151,7 @@ look_up_lock_class(struct lockdep_map *lock, unsigned int subclass)
          * (or spin_lock_init()) call - which acts as the key. For static
          * locks we use the lock object itself as the key.
          */
-        if (sizeof(struct lock_class_key) > sizeof(struct lock_class))
-                __error_too_big_MAX_LOCKDEP_SUBCLASSES();
+        BUILD_BUG_ON(sizeof(struct lock_class_key) > sizeof(struct lock_class));
 
         key = lock->key->subkeys + subclass;
 
diff --git a/kernel/module.c b/kernel/module.c
index 7f60e782de..67009bd56c 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -87,6 +87,12 @@ static inline int strong_try_module_get(struct module *mod)
         return try_module_get(mod);
 }
 
+static inline void add_taint_module(struct module *mod, unsigned flag)
+{
+        add_taint(flag);
+        mod->taints |= flag;
+}
+
 /* A thread that wants to hold a reference to a module only while it
  * is running can call ths to safely exit.
  * nfsd and lockd use this.
@@ -847,12 +853,10 @@ static int check_version(Elf_Shdr *sechdrs,
                 return 0;
         }
         /* Not in module's version table.  OK, but that taints the kernel. */
-        if (!(tainted & TAINT_FORCED_MODULE)) {
+        if (!(tainted & TAINT_FORCED_MODULE))
                 printk("%s: no version for \"%s\" found: kernel tainted.\n",
                        mod->name, symname);
-                add_taint(TAINT_FORCED_MODULE);
-                mod->taints |= TAINT_FORCED_MODULE;
-        }
+        add_taint_module(mod, TAINT_FORCED_MODULE);
         return 1;
 }
 
@@ -910,7 +914,8 @@ static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
         unsigned long ret;
         const unsigned long *crc;
 
-        ret = __find_symbol(name, &owner, &crc, mod->license_gplok);
+        ret = __find_symbol(name, &owner, &crc,
+                        !(mod->taints & TAINT_PROPRIETARY_MODULE));
         if (ret) {
                 /* use_module can fail due to OOM, or module unloading */
                 if (!check_version(sechdrs, versindex, name, mod, crc) ||
@@ -1335,12 +1340,11 @@ static void set_license(struct module *mod, const char *license)
         if (!license)
                 license = "unspecified";
 
-        mod->license_gplok = license_is_gpl_compatible(license);
-        if (!mod->license_gplok && !(tainted & TAINT_PROPRIETARY_MODULE)) {
-                printk(KERN_WARNING "%s: module license '%s' taints kernel.\n",
-                       mod->name, license);
-                add_taint(TAINT_PROPRIETARY_MODULE);
-                mod->taints |= TAINT_PROPRIETARY_MODULE;
+        if (!license_is_gpl_compatible(license)) {
+                if (!(tainted & TAINT_PROPRIETARY_MODULE))
+                        printk(KERN_WARNING "%s: module license '%s' taints"
+                                "kernel.\n", mod->name, license);
+                add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
         }
 }
 
@@ -1619,8 +1623,7 @@ static struct module *load_module(void __user *umod,
         modmagic = get_modinfo(sechdrs, infoindex, "vermagic");
         /* This is allowed: modprobe --force will invalidate it. */
         if (!modmagic) {
-                add_taint(TAINT_FORCED_MODULE);
-                mod->taints |= TAINT_FORCED_MODULE;
+                add_taint_module(mod, TAINT_FORCED_MODULE);
                 printk(KERN_WARNING "%s: no version magic, tainting kernel.\n",
                        mod->name);
         } else if (!same_magic(modmagic, vermagic)) {
@@ -1714,14 +1717,10 @@ static struct module *load_module(void __user *umod,
         /* Set up license info based on the info section */
         set_license(mod, get_modinfo(sechdrs, infoindex, "license"));
 
-        if (strcmp(mod->name, "ndiswrapper") == 0) {
-                add_taint(TAINT_PROPRIETARY_MODULE);
-                mod->taints |= TAINT_PROPRIETARY_MODULE;
-        }
-        if (strcmp(mod->name, "driverloader") == 0) {
-                add_taint(TAINT_PROPRIETARY_MODULE);
-                mod->taints |= TAINT_PROPRIETARY_MODULE;
-        }
+        if (strcmp(mod->name, "ndiswrapper") == 0)
+                add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
+        if (strcmp(mod->name, "driverloader") == 0)
+                add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
 
         /* Set up MODINFO_ATTR fields */
         setup_modinfo(mod, sechdrs, infoindex);
@@ -1766,8 +1765,7 @@ static struct module *load_module(void __user *umod,
             (mod->num_unused_gpl_syms && !unusedgplcrcindex)) {
                 printk(KERN_WARNING "%s: No versions for exported symbols."
                        " Tainting kernel.\n", mod->name);
-                add_taint(TAINT_FORCED_MODULE);
-                mod->taints |= TAINT_FORCED_MODULE;
+                add_taint_module(mod, TAINT_FORCED_MODULE);
         }
 #endif
 
@@ -2132,9 +2130,33 @@ static void m_stop(struct seq_file *m, void *p)
         mutex_unlock(&module_mutex);
 }
 
+static char *taint_flags(unsigned int taints, char *buf)
+{
+        int bx = 0;
+
+        if (taints) {
+                buf[bx++] = '(';
+                if (taints & TAINT_PROPRIETARY_MODULE)
+                        buf[bx++] = 'P';
+                if (taints & TAINT_FORCED_MODULE)
+                        buf[bx++] = 'F';
+                /*
+                 * TAINT_FORCED_RMMOD: could be added.
+                 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
+                 * apply to modules.
+                 */
+                buf[bx++] = ')';
+        }
+        buf[bx] = '\0';
+
+        return buf;
+}
+
 static int m_show(struct seq_file *m, void *p)
 {
         struct module *mod = list_entry(p, struct module, list);
+        char buf[8];
+
         seq_printf(m, "%s %lu",
                    mod->name, mod->init_size + mod->core_size);
         print_unload_info(m, mod);
@@ -2147,6 +2169,10 @@ static int m_show(struct seq_file *m, void *p)
         /* Used by oprofile and other similar tools. */
         seq_printf(m, " 0x%p", mod->module_core);
 
+        /* Taints info */
+        if (mod->taints)
+                seq_printf(m, " %s", taint_flags(mod->taints, buf));
+
         seq_printf(m, "\n");
         return 0;
 }
@@ -2235,28 +2261,6 @@ struct module *module_text_address(unsigned long addr)
         return mod;
 }
 
-static char *taint_flags(unsigned int taints, char *buf)
-{
-        *buf = '\0';
-        if (taints) {
-                int bx;
-
-                buf[0] = '(';
-                bx = 1;
-                if (taints & TAINT_PROPRIETARY_MODULE)
-                        buf[bx++] = 'P';
-                if (taints & TAINT_FORCED_MODULE)
-                        buf[bx++] = 'F';
-                /*
-                 * TAINT_FORCED_RMMOD: could be added.
-                 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
-                 * apply to modules.
-                 */
-                buf[bx] = ')';
-        }
-        return buf;
-}
-
 /* Don't grab lock, we're oopsing. */
 void print_modules(void)
 {
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index d722349427..d3a158a603 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -18,6 +18,7 @@
 #include <linux/fs.h>
 #include <linux/mount.h>
 #include <linux/pm.h>
+#include <linux/console.h>
 #include <linux/cpu.h>
 
 #include "power.h"
@@ -119,8 +120,10 @@ int pm_suspend_disk(void)
         if (error)
                 return error;
 
+        suspend_console();
         error = device_suspend(PMSG_FREEZE);
         if (error) {
+                resume_console();
                 printk("Some devices failed to suspend\n");
                 unprepare_processes();
                 return error;
@@ -133,6 +136,7 @@ int pm_suspend_disk(void)
 
         if (in_suspend) {
                 device_resume();
+                resume_console();
                 pr_debug("PM: writing image.\n");
                 error = swsusp_write();
                 if (!error)
@@ -148,6 +152,7 @@ int pm_suspend_disk(void)
         swsusp_free();
  Done:
         device_resume();
+        resume_console();
         unprepare_processes();
         return error;
 }
@@ -212,7 +217,9 @@ static int software_resume(void)
 
         pr_debug("PM: Preparing devices for restore.\n");
 
+        suspend_console();
         if ((error = device_suspend(PMSG_PRETHAW))) {
+                resume_console();
                 printk("Some devices failed to suspend\n");
                 swsusp_free();
                 goto Thaw;
@@ -224,6 +231,7 @@ static int software_resume(void)
         swsusp_resume();
         pr_debug("PM: Restore failed, recovering.n");
         device_resume();
+        resume_console();
  Thaw:
         unprepare_processes();
  Done:
diff --git a/kernel/power/user.c b/kernel/power/user.c
index 72825c853c..d991d3b0e5 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -19,6 +19,7 @@
 #include <linux/swapops.h>
 #include <linux/pm.h>
 #include <linux/fs.h>
+#include <linux/console.h>
 #include <linux/cpu.h>
 
 #include <asm/uaccess.h>
@@ -145,10 +146,10 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                         error = freeze_processes();
                         if (error) {
                                 thaw_processes();
+                                enable_nonboot_cpus();
                                 error = -EBUSY;
                         }
                 }
-                enable_nonboot_cpus();
                 up(&pm_sem);
                 if (!error)
                         data->frozen = 1;
@@ -173,12 +174,14 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 /* Free memory before shutting down devices. */
                 error = swsusp_shrink_memory();
                 if (!error) {
+                        suspend_console();
                         error = device_suspend(PMSG_FREEZE);
                         if (!error) {
                                 in_suspend = 1;
                                 error = swsusp_suspend();
                                 device_resume();
                         }
+                        resume_console();
                 }
                 up(&pm_sem);
                 if (!error)
@@ -196,11 +199,13 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 snapshot_free_unused_memory(&data->handle);
                 down(&pm_sem);
                 pm_prepare_console();
+                suspend_console();
                 error = device_suspend(PMSG_PRETHAW);
                 if (!error) {
                         error = swsusp_resume();
                         device_resume();
                 }
+                resume_console();
                 pm_restore_console();
                 up(&pm_sem);
                 break;
@@ -289,6 +294,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 }
 
                 /* Put devices to sleep */
+                suspend_console();
                 error = device_suspend(PMSG_SUSPEND);
                 if (error) {
                         printk(KERN_ERR "Failed to suspend some devices.\n");
@@ -299,7 +305,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                         /* Wake up devices */
                         device_resume();
                 }
-
+                resume_console();
                 if (pm_ops->finish)
                         pm_ops->finish(PM_SUSPEND_MEM);
 
diff --git a/kernel/printk.c b/kernel/printk.c
index 771f5e861b..f7d427ef50 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -820,15 +820,8 @@ void release_console_sem(void)
         console_locked = 0;
         up(&console_sem);
         spin_unlock_irqrestore(&logbuf_lock, flags);
-        if (wake_klogd && !oops_in_progress && waitqueue_active(&log_wait)) {
-                /*
-                 * If we printk from within the lock dependency code,
-                 * from within the scheduler code, then do not lock
-                 * up due to self-recursion:
-                 */
-                if (!lockdep_internal())
-                        wake_up_interruptible(&log_wait);
-        }
+        if (wake_klogd && !oops_in_progress && waitqueue_active(&log_wait))
+                wake_up_interruptible(&log_wait);
 }
 EXPORT_SYMBOL(release_console_sem);
 
diff --git a/kernel/profile.c b/kernel/profile.c
index 857300a2af..f940b462ee 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -399,7 +399,7 @@ static int prof_cpu_mask_write_proc (struct file *file, const char __user *buffe
         unsigned long full_count = count, err;
         cpumask_t new_value;
 
-        err = cpumask_parse(buffer, count, new_value);
+        err = cpumask_parse_user(buffer, count, new_value);
         if (err)
                 return err;
 
diff --git a/kernel/relay.c b/kernel/relay.c
index 1d63ecddfa..f04bbdb56a 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -887,7 +887,7 @@ static int subbuf_read_actor(size_t read_start,
 
         from = buf->start + read_start;
         ret = avail;
-        if (copy_to_user(desc->arg.data, from, avail)) {
+        if (copy_to_user(desc->arg.buf, from, avail)) {
                 desc->error = -EFAULT;
                 ret = 0;
         }
@@ -946,24 +946,17 @@ typedef int (*subbuf_actor_t) (size_t read_start,
  */
 static inline ssize_t relay_file_read_subbufs(struct file *filp,
                                               loff_t *ppos,
-                                              size_t count,
                                               subbuf_actor_t subbuf_actor,
                                               read_actor_t actor,
-                                              void *target)
+                                              read_descriptor_t *desc)
 {
         struct rchan_buf *buf = filp->private_data;
         size_t read_start, avail;
-        read_descriptor_t desc;
         int ret;
 
-        if (!count)
+        if (!desc->count)
                 return 0;
 
-        desc.written = 0;
-        desc.count = count;
-        desc.arg.data = target;
-        desc.error = 0;
-
         mutex_lock(&filp->f_dentry->d_inode->i_mutex);
         do {
                 if (!relay_file_read_avail(buf, *ppos))
@@ -974,19 +967,19 @@ static inline ssize_t relay_file_read_subbufs(struct file *filp,
                 if (!avail)
                         break;
 
-                avail = min(desc.count, avail);
-                ret = subbuf_actor(read_start, buf, avail, &desc, actor);
-                if (desc.error < 0)
+                avail = min(desc->count, avail);
+                ret = subbuf_actor(read_start, buf, avail, desc, actor);
+                if (desc->error < 0)
                         break;
 
                 if (ret) {
                         relay_file_read_consume(buf, read_start, ret);
                         *ppos = relay_file_read_end_pos(buf, read_start, ret);
                 }
-        } while (desc.count && ret);
+        } while (desc->count && ret);
         mutex_unlock(&filp->f_dentry->d_inode->i_mutex);
 
-        return desc.written;
+        return desc->written;
 }
 
 static ssize_t relay_file_read(struct file *filp,
@@ -994,8 +987,13 @@ static ssize_t relay_file_read(struct file *filp,
                                size_t count,
                                loff_t *ppos)
 {
-        return relay_file_read_subbufs(filp, ppos, count, subbuf_read_actor,
-                                       NULL, buffer);
+        read_descriptor_t desc;
+        desc.written = 0;
+        desc.count = count;
+        desc.arg.buf = buffer;
+        desc.error = 0;
+        return relay_file_read_subbufs(filp, ppos, subbuf_read_actor,
+                                       NULL, &desc);
 }
 
 static ssize_t relay_file_sendfile(struct file *filp,
@@ -1004,8 +1002,13 @@ static ssize_t relay_file_sendfile(struct file *filp,
                                    read_actor_t actor,
                                    void *target)
 {
-        return relay_file_read_subbufs(filp, ppos, count, subbuf_send_actor,
-                                       actor, target);
+        read_descriptor_t desc;
+        desc.written = 0;
+        desc.count = count;
+        desc.arg.data = target;
+        desc.error = 0;
+        return relay_file_read_subbufs(filp, ppos, subbuf_send_actor,
+                                       actor, &desc);
 }
 
 struct file_operations relay_file_operations = {
diff --git a/kernel/sched.c b/kernel/sched.c
index 53608a59d6..094b5687ee 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -1822,14 +1822,14 @@ context_switch(struct rq *rq, struct task_struct *prev,
         struct mm_struct *mm = next->mm;
         struct mm_struct *oldmm = prev->active_mm;
 
-        if (unlikely(!mm)) {
+        if (!mm) {
                 next->active_mm = oldmm;
                 atomic_inc(&oldmm->mm_count);
                 enter_lazy_tlb(oldmm, next);
         } else
                 switch_mm(oldmm, mm, next);
 
-        if (unlikely(!prev->mm)) {
+        if (!prev->mm) {
                 prev->active_mm = NULL;
                 WARN_ON(rq->prev_mm);
                 rq->prev_mm = oldmm;
@@ -3491,7 +3491,7 @@ asmlinkage void __sched preempt_schedule(void)
          * If there is a non-zero preempt_count or interrupts are disabled,
          * we do not want to preempt the current task.  Just return..
          */
-        if (unlikely(ti->preempt_count || irqs_disabled()))
+        if (likely(ti->preempt_count || irqs_disabled()))
                 return;
 
 need_resched:
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index cfc737bffe..3df9bfc7ff 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -28,6 +28,7 @@
 #include <linux/notifier.h>
 #include <linux/kthread.h>
 #include <linux/hardirq.h>
+#include <linux/mempolicy.h>
 
 /*
  * The per-CPU workqueue (if single thread, we always use the first
@@ -245,6 +246,12 @@ static int worker_thread(void *__cwq)
         sigprocmask(SIG_BLOCK, &blocked, NULL);
         flush_signals(current);
 
+        /*
+         * We inherited MPOL_INTERLEAVE from the booting kernel.
+         * Set MPOL_DEFAULT to insure node local allocations.
+         */
+        numa_default_policy();
+
         /* SIG_IGN makes children autoreap: see do_notify_parent(). */
         sa.sa.sa_handler = SIG_IGN;
         sa.sa.sa_flags = 0;