Merge 3.10-rc3 into usb-next

We want these fixes.

Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

19 files changed, 297 insertions, 45 deletions

diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index b51a97cfedf8..6f16ffafa6f0 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -127,6 +127,12 @@ int main(void)
         DEFINE(THREAD_BESCR, offsetof(struct thread_struct, bescr));
         DEFINE(THREAD_EBBHR, offsetof(struct thread_struct, ebbhr));
         DEFINE(THREAD_EBBRR, offsetof(struct thread_struct, ebbrr));
+        DEFINE(THREAD_SIAR, offsetof(struct thread_struct, siar));
+        DEFINE(THREAD_SDAR, offsetof(struct thread_struct, sdar));
+        DEFINE(THREAD_SIER, offsetof(struct thread_struct, sier));
+        DEFINE(THREAD_MMCR0, offsetof(struct thread_struct, mmcr0));
+        DEFINE(THREAD_MMCR2, offsetof(struct thread_struct, mmcr2));
+        DEFINE(THREAD_MMCRA, offsetof(struct thread_struct, mmcra));
 #endif
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
         DEFINE(PACATMSCRATCH, offsetof(struct paca_struct, tm_scratch));
diff --git a/arch/powerpc/kernel/cpu_setup_power.S b/arch/powerpc/kernel/cpu_setup_power.S
index a283b6442b26..18b5b9cf8e37 100644
--- a/arch/powerpc/kernel/cpu_setup_power.S
+++ b/arch/powerpc/kernel/cpu_setup_power.S
@@ -135,8 +135,12 @@ __init_HFSCR:
         blr
 
 __init_TLB:
-        /* Clear the TLB */
-        li      r6,128
+        /*
+         * Clear the TLB using the "IS 3" form of tlbiel instruction
+         * (invalidate by congruence class). P7 has 128 CCs, P8 has 512
+         * so we just always do 512
+         */
+        li      r6,512
         mtctr   r6
         li      r7,0xc00        /* IS field = 0b11 */
         ptesync
diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
index e514de57a125..d22e73e4618b 100644
--- a/arch/powerpc/kernel/entry_32.S
+++ b/arch/powerpc/kernel/entry_32.S
@@ -439,8 +439,6 @@ ret_from_fork:
 ret_from_kernel_thread:
         REST_NVGPRS(r1)
         bl      schedule_tail
-        li      r3,0
-        stw     r3,0(r1)
         mtlr    r14
         mr      r3,r15
         PPC440EP_ERR42
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index 915fbb4fc2fe..0e9095e47b5b 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -33,6 +33,7 @@
 #include <asm/irqflags.h>
 #include <asm/ftrace.h>
 #include <asm/hw_irq.h>
+#include <asm/context_tracking.h>
 
 /*
  * System calls.
@@ -376,8 +377,6 @@ _GLOBAL(ret_from_fork)
 _GLOBAL(ret_from_kernel_thread)
         bl      .schedule_tail
         REST_NVGPRS(r1)
-        li      r3,0
-        std     r3,0(r1)
         ld      r14, 0(r14)
         mtlr    r14
         mr      r3,r15
@@ -466,6 +465,20 @@ BEGIN_FTR_SECTION
         std     r0, THREAD_EBBHR(r3)
         mfspr   r0, SPRN_EBBRR
         std     r0, THREAD_EBBRR(r3)
+
+        /* PMU registers made user read/(write) by EBB */
+        mfspr   r0, SPRN_SIAR
+        std     r0, THREAD_SIAR(r3)
+        mfspr   r0, SPRN_SDAR
+        std     r0, THREAD_SDAR(r3)
+        mfspr   r0, SPRN_SIER
+        std     r0, THREAD_SIER(r3)
+        mfspr   r0, SPRN_MMCR0
+        std     r0, THREAD_MMCR0(r3)
+        mfspr   r0, SPRN_MMCR2
+        std     r0, THREAD_MMCR2(r3)
+        mfspr   r0, SPRN_MMCRA
+        std     r0, THREAD_MMCRA(r3)
 END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S)
 #endif
 
@@ -561,6 +574,20 @@ BEGIN_FTR_SECTION
         ld      r0, THREAD_EBBRR(r4)
         mtspr   SPRN_EBBRR, r0
 
+        /* PMU registers made user read/(write) by EBB */
+        ld      r0, THREAD_SIAR(r4)
+        mtspr   SPRN_SIAR, r0
+        ld      r0, THREAD_SDAR(r4)
+        mtspr   SPRN_SDAR, r0
+        ld      r0, THREAD_SIER(r4)
+        mtspr   SPRN_SIER, r0
+        ld      r0, THREAD_MMCR0(r4)
+        mtspr   SPRN_MMCR0, r0
+        ld      r0, THREAD_MMCR2(r4)
+        mtspr   SPRN_MMCR2, r0
+        ld      r0, THREAD_MMCRA(r4)
+        mtspr   SPRN_MMCRA, r0
+
         ld      r0,THREAD_TAR(r4)
         mtspr   SPRN_TAR,r0
 END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S)
@@ -634,7 +661,7 @@ _GLOBAL(ret_from_except_lite)
         andi.   r0,r4,_TIF_NEED_RESCHED
         beq     1f
         bl      .restore_interrupts
-        bl      .schedule
+        SCHEDULE_USER
         b       .ret_from_except_lite
 
 1:      bl      .save_nvgprs
diff --git a/arch/powerpc/kernel/exceptions-64e.S b/arch/powerpc/kernel/exceptions-64e.S
index 42a756eec9ff..645170a07ada 100644
--- a/arch/powerpc/kernel/exceptions-64e.S
+++ b/arch/powerpc/kernel/exceptions-64e.S
@@ -489,7 +489,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC)
          */
 
         mfspr   r14,SPRN_DBSR           /* check single-step/branch taken */
-        andis.  r15,r14,DBSR_IC@h
+        andis.  r15,r14,(DBSR_IC|DBSR_BT)@h
         beq+    1f
 
         LOAD_REG_IMMEDIATE(r14,interrupt_base_book3e)
@@ -500,7 +500,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC)
         bge+    cr1,1f
 
         /* here it looks like we got an inappropriate debug exception. */
-        lis     r14,DBSR_IC@h           /* clear the IC event */
+        lis     r14,(DBSR_IC|DBSR_BT)@h         /* clear the event */
         rlwinm  r11,r11,0,~MSR_DE       /* clear DE in the CSRR1 value */
         mtspr   SPRN_DBSR,r14
         mtspr   SPRN_CSRR1,r11
@@ -555,7 +555,7 @@ kernel_dbg_exc:
          */
 
         mfspr   r14,SPRN_DBSR           /* check single-step/branch taken */
-        andis.  r15,r14,DBSR_IC@h
+        andis.  r15,r14,(DBSR_IC|DBSR_BT)@h
         beq+    1f
 
         LOAD_REG_IMMEDIATE(r14,interrupt_base_book3e)
@@ -566,7 +566,7 @@ kernel_dbg_exc:
         bge+    cr1,1f
 
         /* here it looks like we got an inappropriate debug exception. */
-        lis     r14,DBSR_IC@h           /* clear the IC event */
+        lis     r14,(DBSR_IC|DBSR_BT)@h         /* clear the event */
         rlwinm  r11,r11,0,~MSR_DE       /* clear DE in the DSRR1 value */
         mtspr   SPRN_DBSR,r14
         mtspr   SPRN_DSRR1,r11
diff --git a/arch/powerpc/kernel/machine_kexec_64.c b/arch/powerpc/kernel/machine_kexec_64.c
index 466a2908bb63..611acdf30096 100644
--- a/arch/powerpc/kernel/machine_kexec_64.c
+++ b/arch/powerpc/kernel/machine_kexec_64.c
@@ -17,6 +17,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/cpu.h>
+#include <linux/hardirq.h>
 
 #include <asm/page.h>
 #include <asm/current.h>
@@ -335,10 +336,13 @@ void default_machine_kexec(struct kimage *image)
         pr_debug("kexec: Starting switchover sequence.\n");
 
         /* switch to a staticly allocated stack.  Based on irq stack code.
+         * We setup preempt_count to avoid using VMX in memcpy.
          * XXX: the task struct will likely be invalid once we do the copy!
          */
         kexec_stack.thread_info.task = current_thread_info()->task;
         kexec_stack.thread_info.flags = 0;
+        kexec_stack.thread_info.preempt_count = HARDIRQ_OFFSET;
+        kexec_stack.thread_info.cpu = current_thread_info()->cpu;
 
         /* We need a static PACA, too; copy this CPU's PACA over and switch to
          * it.  Also poison per_cpu_offset to catch anyone using non-static
diff --git a/arch/powerpc/kernel/misc_32.S b/arch/powerpc/kernel/misc_32.S
index 19e096bd0e73..e469f30e6eeb 100644
--- a/arch/powerpc/kernel/misc_32.S
+++ b/arch/powerpc/kernel/misc_32.S
@@ -657,6 +657,17 @@ _GLOBAL(__ucmpdi2)
         li      r3,2
         blr
 
+_GLOBAL(__bswapdi2)
+        rotlwi  r9,r4,8
+        rotlwi  r10,r3,8
+        rlwimi  r9,r4,24,0,7
+        rlwimi  r10,r3,24,0,7
+        rlwimi  r9,r4,24,16,23
+        rlwimi  r10,r3,24,16,23
+        mr      r3,r9
+        mr      r4,r10
+        blr
+
 _GLOBAL(abs)
         srawi   r4,r3,31
         xor     r3,r3,r4
diff --git a/arch/powerpc/kernel/misc_64.S b/arch/powerpc/kernel/misc_64.S
index 5cfa8008693b..6820e45f557b 100644
--- a/arch/powerpc/kernel/misc_64.S
+++ b/arch/powerpc/kernel/misc_64.S
@@ -234,6 +234,17 @@ _GLOBAL(__flush_dcache_icache)
         isync
         blr
 
+_GLOBAL(__bswapdi2)
+        srdi    r8,r3,32
+        rlwinm  r7,r3,8,0xffffffff
+        rlwimi  r7,r3,24,0,7
+        rlwinm  r9,r8,8,0xffffffff
+        rlwimi  r7,r3,24,16,23
+        rlwimi  r9,r8,24,0,7
+        rlwimi  r9,r8,24,16,23
+        sldi    r7,r7,32
+        or      r3,r7,r9
+        blr
 
 #if defined(CONFIG_PPC_PMAC) || defined(CONFIG_PPC_MAPLE)
 /*
diff --git a/arch/powerpc/kernel/pci-common.c b/arch/powerpc/kernel/pci-common.c
index f5c5c90799a7..e9acf50dd5b2 100644
--- a/arch/powerpc/kernel/pci-common.c
+++ b/arch/powerpc/kernel/pci-common.c
@@ -359,7 +359,6 @@ static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
                                       enum pci_mmap_state mmap_state,
                                       int write_combine)
 {
-        unsigned long prot = pgprot_val(protection);
 
         /* Write combine is always 0 on non-memory space mappings. On
          * memory space, if the user didn't pass 1, we check for a
@@ -376,9 +375,9 @@ static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
 
         /* XXX would be nice to have a way to ask for write-through */
         if (write_combine)
-                return pgprot_noncached_wc(prot);
+                return pgprot_noncached_wc(protection);
         else
-                return pgprot_noncached(prot);
+                return pgprot_noncached(protection);
 }
 
 /*
@@ -1521,9 +1520,10 @@ static void pcibios_setup_phb_resources(struct pci_controller *hose,
         for (i = 0; i < 3; ++i) {
                 res = &hose->mem_resources[i];
                 if (!res->flags) {
-                        printk(KERN_ERR "PCI: Memory resource 0 not set for "
-                               "host bridge %s (domain %d)\n",
-                               hose->dn->full_name, hose->global_number);
+                        if (i == 0)
+                                printk(KERN_ERR "PCI: Memory resource 0 not set for "
+                                       "host bridge %s (domain %d)\n",
+                                       hose->dn->full_name, hose->global_number);
                         continue;
                 }
                 offset = hose->mem_offset[i];
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 873050d26840..2e8629654ca8 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -266,3 +266,13 @@ int pcibus_to_node(struct pci_bus *bus)
 }
 EXPORT_SYMBOL(pcibus_to_node);
 #endif
+
+static void quirk_radeon_32bit_msi(struct pci_dev *dev)
+{
+        struct pci_dn *pdn = pci_get_pdn(dev);
+
+        if (pdn)
+                pdn->force_32bit_msi = 1;
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x68f2, quirk_radeon_32bit_msi);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0xaa68, quirk_radeon_32bit_msi);
diff --git a/arch/powerpc/kernel/pci_dn.c b/arch/powerpc/kernel/pci_dn.c
index e7af165f8b9d..df038442548a 100644
--- a/arch/powerpc/kernel/pci_dn.c
+++ b/arch/powerpc/kernel/pci_dn.c
@@ -32,6 +32,14 @@
 #include <asm/ppc-pci.h>
 #include <asm/firmware.h>
 
+struct pci_dn *pci_get_pdn(struct pci_dev *pdev)
+{
+        struct device_node *dn = pci_device_to_OF_node(pdev);
+        if (!dn)
+                return NULL;
+        return PCI_DN(dn);
+}
+
 /*
  * Traverse_func that inits the PCI fields of the device node.
  * NOTE: this *must* be done before read/write config to the device.
diff --git a/arch/powerpc/kernel/ppc_ksyms.c b/arch/powerpc/kernel/ppc_ksyms.c
index 78b8766fd79e..c29666586998 100644
--- a/arch/powerpc/kernel/ppc_ksyms.c
+++ b/arch/powerpc/kernel/ppc_ksyms.c
@@ -143,7 +143,8 @@ EXPORT_SYMBOL(__lshrdi3);
 int __ucmpdi2(unsigned long long, unsigned long long);
 EXPORT_SYMBOL(__ucmpdi2);
 #endif
-
+long long __bswapdi2(long long);
+EXPORT_SYMBOL(__bswapdi2);
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memmove);
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index ceb4e7b62cf4..a902723fdc69 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -339,6 +339,13 @@ static void set_debug_reg_defaults(struct thread_struct *thread)
 
 static void prime_debug_regs(struct thread_struct *thread)
 {
+        /*
+         * We could have inherited MSR_DE from userspace, since
+         * it doesn't get cleared on exception entry.  Make sure
+         * MSR_DE is clear before we enable any debug events.
+         */
+        mtmsr(mfmsr() & ~MSR_DE);
+
         mtspr(SPRN_IAC1, thread->iac1);
         mtspr(SPRN_IAC2, thread->iac2);
 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
@@ -971,6 +978,7 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
          * do some house keeping and then return from the fork or clone
          * system call, using the stack frame created above.
          */
+        ((unsigned long *)sp)[0] = 0;
         sp -= sizeof(struct pt_regs);
         kregs = (struct pt_regs *) sp;
         sp -= STACK_FRAME_OVERHEAD;
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 3b14d320e69f..98c2fc198712 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -32,6 +32,7 @@
 #include <trace/syscall.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/perf_event.h>
+#include <linux/context_tracking.h>
 
 #include <asm/uaccess.h>
 #include <asm/page.h>
@@ -1788,6 +1789,8 @@ long do_syscall_trace_enter(struct pt_regs *regs)
 {
         long ret = 0;
 
+        user_exit();
+
         secure_computing_strict(regs->gpr[0]);
 
         if (test_thread_flag(TIF_SYSCALL_TRACE) &&
@@ -1832,4 +1835,6 @@ void do_syscall_trace_leave(struct pt_regs *regs)
         step = test_thread_flag(TIF_SINGLESTEP);
         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
                 tracehook_report_syscall_exit(regs, step);
+
+        user_enter();
 }
diff --git a/arch/powerpc/kernel/rtas.c b/arch/powerpc/kernel/rtas.c
index 1fd6e7b2f390..52add6f3e201 100644
--- a/arch/powerpc/kernel/rtas.c
+++ b/arch/powerpc/kernel/rtas.c
@@ -19,6 +19,7 @@
 #include <linux/init.h>
 #include <linux/capability.h>
 #include <linux/delay.h>
+#include <linux/cpu.h>
 #include <linux/smp.h>
 #include <linux/completion.h>
 #include <linux/cpumask.h>
@@ -807,6 +808,95 @@ static void rtas_percpu_suspend_me(void *info)
         __rtas_suspend_cpu((struct rtas_suspend_me_data *)info, 1);
 }
 
+enum rtas_cpu_state {
+        DOWN,
+        UP,
+};
+
+#ifndef CONFIG_SMP
+static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,
+                                cpumask_var_t cpus)
+{
+        if (!cpumask_empty(cpus)) {
+                cpumask_clear(cpus);
+                return -EINVAL;
+        } else
+                return 0;
+}
+#else
+/* On return cpumask will be altered to indicate CPUs changed.
+ * CPUs with states changed will be set in the mask,
+ * CPUs with status unchanged will be unset in the mask. */
+static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,
+                                cpumask_var_t cpus)
+{
+        int cpu;
+        int cpuret = 0;
+        int ret = 0;
+
+        if (cpumask_empty(cpus))
+                return 0;
+
+        for_each_cpu(cpu, cpus) {
+                switch (state) {
+                case DOWN:
+                        cpuret = cpu_down(cpu);
+                        break;
+                case UP:
+                        cpuret = cpu_up(cpu);
+                        break;
+                }
+                if (cpuret) {
+                        pr_debug("%s: cpu_%s for cpu#%d returned %d.\n",
+                                        __func__,
+                                        ((state == UP) ? "up" : "down"),
+                                        cpu, cpuret);
+                        if (!ret)
+                                ret = cpuret;
+                        if (state == UP) {
+                                /* clear bits for unchanged cpus, return */
+                                cpumask_shift_right(cpus, cpus, cpu);
+                                cpumask_shift_left(cpus, cpus, cpu);
+                                break;
+                        } else {
+                                /* clear bit for unchanged cpu, continue */
+                                cpumask_clear_cpu(cpu, cpus);
+                        }
+                }
+        }
+
+        return ret;
+}
+#endif
+
+int rtas_online_cpus_mask(cpumask_var_t cpus)
+{
+        int ret;
+
+        ret = rtas_cpu_state_change_mask(UP, cpus);
+
+        if (ret) {
+                cpumask_var_t tmp_mask;
+
+                if (!alloc_cpumask_var(&tmp_mask, GFP_TEMPORARY))
+                        return ret;
+
+                /* Use tmp_mask to preserve cpus mask from first failure */
+                cpumask_copy(tmp_mask, cpus);
+                rtas_offline_cpus_mask(tmp_mask);
+                free_cpumask_var(tmp_mask);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(rtas_online_cpus_mask);
+
+int rtas_offline_cpus_mask(cpumask_var_t cpus)
+{
+        return rtas_cpu_state_change_mask(DOWN, cpus);
+}
+EXPORT_SYMBOL(rtas_offline_cpus_mask);
+
 int rtas_ibm_suspend_me(struct rtas_args *args)
 {
         long state;
@@ -814,6 +904,8 @@ int rtas_ibm_suspend_me(struct rtas_args *args)
         unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
         struct rtas_suspend_me_data data;
         DECLARE_COMPLETION_ONSTACK(done);
+        cpumask_var_t offline_mask;
+        int cpuret;
 
         if (!rtas_service_present("ibm,suspend-me"))
                 return -ENOSYS;
@@ -837,11 +929,24 @@ int rtas_ibm_suspend_me(struct rtas_args *args)
                 return 0;
         }
 
+        if (!alloc_cpumask_var(&offline_mask, GFP_TEMPORARY))
+                return -ENOMEM;
+
         atomic_set(&data.working, 0);
         atomic_set(&data.done, 0);
         atomic_set(&data.error, 0);
         data.token = rtas_token("ibm,suspend-me");
         data.complete = &done;
+
+        /* All present CPUs must be online */
+        cpumask_andnot(offline_mask, cpu_present_mask, cpu_online_mask);
+        cpuret = rtas_online_cpus_mask(offline_mask);
+        if (cpuret) {
+                pr_err("%s: Could not bring present CPUs online.\n", __func__);
+                atomic_set(&data.error, cpuret);
+                goto out;
+        }
+
         stop_topology_update();
 
         /* Call function on all CPUs.  One of us will make the
@@ -857,6 +962,14 @@ int rtas_ibm_suspend_me(struct rtas_args *args)
 
         start_topology_update();
 
+        /* Take down CPUs not online prior to suspend */
+        cpuret = rtas_offline_cpus_mask(offline_mask);
+        if (cpuret)
+                pr_warn("%s: Could not restore CPUs to offline state.\n",
+                                __func__);
+
+out:
+        free_cpumask_var(offline_mask);
         return atomic_read(&data.error);
 }
 #else /* CONFIG_PPC_PSERIES */
diff --git a/arch/powerpc/kernel/rtas_flash.c b/arch/powerpc/kernel/rtas_flash.c
index 5b3022470126..2f3cdb01506d 100644
--- a/arch/powerpc/kernel/rtas_flash.c
+++ b/arch/powerpc/kernel/rtas_flash.c
@@ -89,6 +89,7 @@
 
 /* Array sizes */
 #define VALIDATE_BUF_SIZE 4096    
+#define VALIDATE_MSG_LEN  256
 #define RTAS_MSG_MAXLEN   64
 
 /* Quirk - RTAS requires 4k list length and block size */
@@ -466,7 +467,7 @@ static void validate_flash(struct rtas_validate_flash_t *args_buf)
 }
 
 static int get_validate_flash_msg(struct rtas_validate_flash_t *args_buf, 
-                                   char *msg)
+                                   char *msg, int msglen)
 {
         int n;
 
@@ -474,7 +475,8 @@ static int get_validate_flash_msg(struct rtas_validate_flash_t *args_buf,
                 n = sprintf(msg, "%d\n", args_buf->update_results);
                 if ((args_buf->update_results >= VALIDATE_CUR_UNKNOWN) ||
                     (args_buf->update_results == VALIDATE_TMP_UPDATE))
-                        n += sprintf(msg + n, "%s\n", args_buf->buf);
+                        n += snprintf(msg + n, msglen - n, "%s\n",
+                                        args_buf->buf);
         } else {
                 n = sprintf(msg, "%d\n", args_buf->status);
         }
@@ -486,11 +488,11 @@ static ssize_t validate_flash_read(struct file *file, char __user *buf,
 {
         struct rtas_validate_flash_t *const args_buf =
                 &rtas_validate_flash_data;
-        char msg[RTAS_MSG_MAXLEN];
+        char msg[VALIDATE_MSG_LEN];
         int msglen;
 
         mutex_lock(&rtas_validate_flash_mutex);
-        msglen = get_validate_flash_msg(args_buf, msg);
+        msglen = get_validate_flash_msg(args_buf, msg, VALIDATE_MSG_LEN);
         mutex_unlock(&rtas_validate_flash_mutex);
 
         return simple_read_from_buffer(buf, count, ppos, msg, msglen);
diff --git a/arch/powerpc/kernel/signal.c b/arch/powerpc/kernel/signal.c
index cf12eae02de5..577a8aa69c6e 100644
--- a/arch/powerpc/kernel/signal.c
+++ b/arch/powerpc/kernel/signal.c
@@ -13,6 +13,7 @@
 #include <linux/signal.h>
 #include <linux/uprobes.h>
 #include <linux/key.h>
+#include <linux/context_tracking.h>
 #include <asm/hw_breakpoint.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -24,7 +25,7 @@
  * through debug.exception-trace sysctl.
  */
 
-int show_unhandled_signals = 0;
+int show_unhandled_signals = 1;
 
 /*
  * Allocate space for the signal frame
@@ -159,6 +160,8 @@ static int do_signal(struct pt_regs *regs)
 
 void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 {
+        user_exit();
+
         if (thread_info_flags & _TIF_UPROBE)
                 uprobe_notify_resume(regs);
 
@@ -169,4 +172,6 @@ void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
                 clear_thread_flag(TIF_NOTIFY_RESUME);
                 tracehook_notify_resume(regs);
         }
+
+        user_enter();
 }
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 83efa2f7d926..a7a648f6b750 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -35,6 +35,7 @@
 #include <linux/kdebug.h>
 #include <linux/debugfs.h>
 #include <linux/ratelimit.h>
+#include <linux/context_tracking.h>
 
 #include <asm/emulated_ops.h>
 #include <asm/pgtable.h>
@@ -667,6 +668,7 @@ int machine_check_generic(struct pt_regs *regs)
 
 void machine_check_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
         int recover = 0;
 
         __get_cpu_var(irq_stat).mce_exceptions++;
@@ -683,7 +685,7 @@ void machine_check_exception(struct pt_regs *regs)
                 recover = cur_cpu_spec->machine_check(regs);
 
         if (recover > 0)
-                return;
+                goto bail;
 
 #if defined(CONFIG_8xx) && defined(CONFIG_PCI)
         /* the qspan pci read routines can cause machine checks -- Cort
@@ -693,20 +695,23 @@ void machine_check_exception(struct pt_regs *regs)
          * -- BenH
          */
         bad_page_fault(regs, regs->dar, SIGBUS);
-        return;
+        goto bail;
 #endif
 
         if (debugger_fault_handler(regs))
-                return;
+                goto bail;
 
         if (check_io_access(regs))
-                return;
+                goto bail;
 
         die("Machine check", regs, SIGBUS);
 
         /* Must die if the interrupt is not recoverable */
         if (!(regs->msr & MSR_RI))
                 panic("Unrecoverable Machine check");
+
+bail:
+        exception_exit(prev_state);
 }
 
 void SMIException(struct pt_regs *regs)
@@ -716,20 +721,29 @@ void SMIException(struct pt_regs *regs)
 
 void unknown_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
+
         printk("Bad trap at PC: %lx, SR: %lx, vector=%lx\n",
                regs->nip, regs->msr, regs->trap);
 
         _exception(SIGTRAP, regs, 0, 0);
+
+        exception_exit(prev_state);
 }
 
 void instruction_breakpoint_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
+
         if (notify_die(DIE_IABR_MATCH, "iabr_match", regs, 5,
                                         5, SIGTRAP) == NOTIFY_STOP)
-                return;
+                goto bail;
         if (debugger_iabr_match(regs))
-                return;
+                goto bail;
         _exception(SIGTRAP, regs, TRAP_BRKPT, regs->nip);
+
+bail:
+        exception_exit(prev_state);
 }
 
 void RunModeException(struct pt_regs *regs)
@@ -739,15 +753,20 @@ void RunModeException(struct pt_regs *regs)
 
 void __kprobes single_step_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
+
         clear_single_step(regs);
 
         if (notify_die(DIE_SSTEP, "single_step", regs, 5,
                                         5, SIGTRAP) == NOTIFY_STOP)
-                return;
+                goto bail;
         if (debugger_sstep(regs))
-                return;
+                goto bail;
 
         _exception(SIGTRAP, regs, TRAP_TRACE, regs->nip);
+
+bail:
+        exception_exit(prev_state);
 }
 
 /*
@@ -1005,6 +1024,7 @@ int is_valid_bugaddr(unsigned long addr)
 
 void __kprobes program_check_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
         unsigned int reason = get_reason(regs);
         extern int do_mathemu(struct pt_regs *regs);
 
@@ -1014,26 +1034,26 @@ void __kprobes program_check_exception(struct pt_regs *regs)
         if (reason & REASON_FP) {
                 /* IEEE FP exception */
                 parse_fpe(regs);
-                return;
+                goto bail;
         }
         if (reason & REASON_TRAP) {
                 /* Debugger is first in line to stop recursive faults in
                  * rcu_lock, notify_die, or atomic_notifier_call_chain */
                 if (debugger_bpt(regs))
-                        return;
+                        goto bail;
 
                 /* trap exception */
                 if (notify_die(DIE_BPT, "breakpoint", regs, 5, 5, SIGTRAP)
                                 == NOTIFY_STOP)
-                        return;
+                        goto bail;
 
                 if (!(regs->msr & MSR_PR) &&  /* not user-mode */
                     report_bug(regs->nip, regs) == BUG_TRAP_TYPE_WARN) {
                         regs->nip += 4;
-                        return;
+                        goto bail;
                 }
                 _exception(SIGTRAP, regs, TRAP_BRKPT, regs->nip);
-                return;
+                goto bail;
         }
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
         if (reason & REASON_TM) {
@@ -1049,7 +1069,7 @@ void __kprobes program_check_exception(struct pt_regs *regs)
                 if (!user_mode(regs) &&
                     report_bug(regs->nip, regs) == BUG_TRAP_TYPE_WARN) {
                         regs->nip += 4;
-                        return;
+                        goto bail;
                 }
                 /* If usermode caused this, it's done something illegal and
                  * gets a SIGILL slap on the wrist.  We call it an illegal
@@ -1059,7 +1079,7 @@ void __kprobes program_check_exception(struct pt_regs *regs)
                  */
                 if (user_mode(regs)) {
                         _exception(SIGILL, regs, ILL_ILLOPN, regs->nip);
-                        return;
+                        goto bail;
                 } else {
                         printk(KERN_EMERG "Unexpected TM Bad Thing exception "
                                "at %lx (msr 0x%x)\n", regs->nip, reason);
@@ -1083,16 +1103,16 @@ void __kprobes program_check_exception(struct pt_regs *regs)
         switch (do_mathemu(regs)) {
         case 0:
                 emulate_single_step(regs);
-                return;
+                goto bail;
         case 1: {
                         int code = 0;
                         code = __parse_fpscr(current->thread.fpscr.val);
                         _exception(SIGFPE, regs, code, regs->nip);
-                        return;
+                        goto bail;
                 }
         case -EFAULT:
                 _exception(SIGSEGV, regs, SEGV_MAPERR, regs->nip);
-                return;
+                goto bail;
         }
         /* fall through on any other errors */
 #endif /* CONFIG_MATH_EMULATION */
@@ -1103,10 +1123,10 @@ void __kprobes program_check_exception(struct pt_regs *regs)
                 case 0:
                         regs->nip += 4;
                         emulate_single_step(regs);
-                        return;
+                        goto bail;
                 case -EFAULT:
                         _exception(SIGSEGV, regs, SEGV_MAPERR, regs->nip);
-                        return;
+                        goto bail;
                 }
         }
 
@@ -1114,10 +1134,14 @@ void __kprobes program_check_exception(struct pt_regs *regs)
                 _exception(SIGILL, regs, ILL_PRVOPC, regs->nip);
         else
                 _exception(SIGILL, regs, ILL_ILLOPC, regs->nip);
+
+bail:
+        exception_exit(prev_state);
 }
 
 void alignment_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
         int sig, code, fixed = 0;
 
         /* We restore the interrupt state now */
@@ -1131,7 +1155,7 @@ void alignment_exception(struct pt_regs *regs)
         if (fixed == 1) {
                 regs->nip += 4; /* skip over emulated instruction */
                 emulate_single_step(regs);
-                return;
+                goto bail;
         }
 
         /* Operand address was bad */
@@ -1146,6 +1170,9 @@ void alignment_exception(struct pt_regs *regs)
                 _exception(sig, regs, code, regs->dar);
         else
                 bad_page_fault(regs, regs->dar, sig);
+
+bail:
+        exception_exit(prev_state);
 }
 
 void StackOverflow(struct pt_regs *regs)
@@ -1174,23 +1201,32 @@ void trace_syscall(struct pt_regs *regs)
 
 void kernel_fp_unavailable_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
+
         printk(KERN_EMERG "Unrecoverable FP Unavailable Exception "
                           "%lx at %lx\n", regs->trap, regs->nip);
         die("Unrecoverable FP Unavailable Exception", regs, SIGABRT);
+
+        exception_exit(prev_state);
 }
 
 void altivec_unavailable_exception(struct pt_regs *regs)
 {
+        enum ctx_state prev_state = exception_enter();
+
         if (user_mode(regs)) {
                 /* A user program has executed an altivec instruction,
                    but this kernel doesn't support altivec. */
                 _exception(SIGILL, regs, ILL_ILLOPC, regs->nip);
-                return;
+                goto bail;
         }
 
         printk(KERN_EMERG "Unrecoverable VMX/Altivec Unavailable Exception "
                         "%lx at %lx\n", regs->trap, regs->nip);
         die("Unrecoverable VMX/Altivec Unavailable Exception", regs, SIGABRT);
+
+bail:
+        exception_exit(prev_state);
 }
 
 void vsx_unavailable_exception(struct pt_regs *regs)
diff --git a/arch/powerpc/kernel/udbg.c b/arch/powerpc/kernel/udbg.c
index 13b867093499..9d3fdcd66290 100644
--- a/arch/powerpc/kernel/udbg.c
+++ b/arch/powerpc/kernel/udbg.c
@@ -64,6 +64,9 @@ void __init udbg_early_init(void)
         udbg_init_usbgecko();
 #elif defined(CONFIG_PPC_EARLY_DEBUG_WSP)
         udbg_init_wsp();
+#elif defined(CONFIG_PPC_EARLY_DEBUG_MEMCONS)
+        /* In memory console */
+        udbg_init_memcons();
 #elif defined(CONFIG_PPC_EARLY_DEBUG_EHV_BC)
         udbg_init_ehv_bc();
 #elif defined(CONFIG_PPC_EARLY_DEBUG_PS3GELIC)