4 files changed, 109 insertions, 46 deletions

diff --git a/arch/powerpc/platforms/pseries/Kconfig b/arch/powerpc/platforms/pseries/Kconfig
index 5d1b743dbe7e..5b3da4b4ea79 100644
--- a/arch/powerpc/platforms/pseries/Kconfig
+++ b/arch/powerpc/platforms/pseries/Kconfig
@@ -10,7 +10,7 @@ config PPC_PSERIES
         select RTAS_ERROR_LOGGING
         select PPC_UDBG_16550
         select PPC_NATIVE
-        select PPC_PCI_CHOICE if EMBEDDED
+        select PPC_PCI_CHOICE if EXPERT
         default y
 
 config PPC_SPLPAR
@@ -24,9 +24,9 @@ config PPC_SPLPAR
           two or more partitions.
 
 config EEH
-        bool "PCI Extended Error Handling (EEH)" if EMBEDDED
+        bool "PCI Extended Error Handling (EEH)" if EXPERT
         depends on PPC_PSERIES && PCI
-        default y if !EMBEDDED
+        default y if !EXPERT
 
 config PSERIES_MSI
        bool
diff --git a/arch/powerpc/platforms/pseries/kexec.c b/arch/powerpc/platforms/pseries/kexec.c
index 53cbd53d8740..77d38a5e2ff9 100644
--- a/arch/powerpc/platforms/pseries/kexec.c
+++ b/arch/powerpc/platforms/pseries/kexec.c
@@ -61,13 +61,3 @@ void __init setup_kexec_cpu_down_xics(void)
 {
         ppc_md.kexec_cpu_down = pseries_kexec_cpu_down_xics;
 }
-
-static int __init pseries_kexec_setup(void)
-{
-        ppc_md.machine_kexec = default_machine_kexec;
-        ppc_md.machine_kexec_prepare = default_machine_kexec_prepare;
-        ppc_md.machine_crash_shutdown = default_machine_crash_shutdown;
-
-        return 0;
-}
-machine_device_initcall(pseries, pseries_kexec_setup);
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 5d3ea9f60dd7..ca5d5898d320 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -713,6 +713,13 @@ EXPORT_SYMBOL(arch_free_page);
 /* NB: reg/unreg are called while guarded with the tracepoints_mutex */
 extern long hcall_tracepoint_refcount;
 
+/* 
+ * Since the tracing code might execute hcalls we need to guard against
+ * recursion. One example of this are spinlocks calling H_YIELD on
+ * shared processor partitions.
+ */
+static DEFINE_PER_CPU(unsigned int, hcall_trace_depth);
+
 void hcall_tracepoint_regfunc(void)
 {
         hcall_tracepoint_refcount++;
@@ -725,12 +732,42 @@ void hcall_tracepoint_unregfunc(void)
 
 void __trace_hcall_entry(unsigned long opcode, unsigned long *args)
 {
+        unsigned long flags;
+        unsigned int *depth;
+
+        local_irq_save(flags);
+
+        depth = &__get_cpu_var(hcall_trace_depth);
+
+        if (*depth)
+                goto out;
+
+        (*depth)++;
         trace_hcall_entry(opcode, args);
+        (*depth)--;
+
+out:
+        local_irq_restore(flags);
 }
 
 void __trace_hcall_exit(long opcode, unsigned long retval,
                         unsigned long *retbuf)
 {
+        unsigned long flags;
+        unsigned int *depth;
+
+        local_irq_save(flags);
+
+        depth = &__get_cpu_var(hcall_trace_depth);
+
+        if (*depth)
+                goto out;
+
+        (*depth)++;
         trace_hcall_exit(opcode, retval, retbuf);
+        (*depth)--;
+
+out:
+        local_irq_restore(flags);
 }
 #endif
diff --git a/arch/powerpc/platforms/pseries/ras.c b/arch/powerpc/platforms/pseries/ras.c
index a4fc6da87c2e..c55d7ad9c648 100644
--- a/arch/powerpc/platforms/pseries/ras.c
+++ b/arch/powerpc/platforms/pseries/ras.c
@@ -54,7 +54,8 @@
 static unsigned char ras_log_buf[RTAS_ERROR_LOG_MAX];
 static DEFINE_SPINLOCK(ras_log_buf_lock);
 
-static char mce_data_buf[RTAS_ERROR_LOG_MAX];
+static char global_mce_data_buf[RTAS_ERROR_LOG_MAX];
+static DEFINE_PER_CPU(__u64, mce_data_buf);
 
 static int ras_get_sensor_state_token;
 static int ras_check_exception_token;
@@ -196,12 +197,24 @@ static irqreturn_t ras_error_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-/* Get the error information for errors coming through the
+/*
+ * Some versions of FWNMI place the buffer inside the 4kB page starting at
+ * 0x7000. Other versions place it inside the rtas buffer. We check both.
+ */
+#define VALID_FWNMI_BUFFER(A) \
+        ((((A) >= 0x7000) && ((A) < 0x7ff0)) || \
+        (((A) >= rtas.base) && ((A) < (rtas.base + rtas.size - 16))))
+
+/*
+ * Get the error information for errors coming through the
  * FWNMI vectors.  The pt_regs' r3 will be updated to reflect
  * the actual r3 if possible, and a ptr to the error log entry
  * will be returned if found.
  *
- * The mce_data_buf does not have any locks or protection around it,
+ * If the RTAS error is not of the extended type, then we put it in a per
+ * cpu 64bit buffer. If it is the extended type we use global_mce_data_buf.
+ *
+ * The global_mce_data_buf does not have any locks or protection around it,
  * if a second machine check comes in, or a system reset is done
  * before we have logged the error, then we will get corruption in the
  * error log.  This is preferable over holding off on calling
@@ -210,20 +223,31 @@ static irqreturn_t ras_error_interrupt(int irq, void *dev_id)
  */
 static struct rtas_error_log *fwnmi_get_errinfo(struct pt_regs *regs)
 {
-        unsigned long errdata = regs->gpr[3];
-        struct rtas_error_log *errhdr = NULL;
         unsigned long *savep;
+        struct rtas_error_log *h, *errhdr = NULL;
+
+        if (!VALID_FWNMI_BUFFER(regs->gpr[3])) {
+                printk(KERN_ERR "FWNMI: corrupt r3\n");
+                return NULL;
+        }
 
-        if ((errdata >= 0x7000 && errdata < 0x7fff0) ||
-            (errdata >= rtas.base && errdata < rtas.base + rtas.size - 16)) {
-                savep = __va(errdata);
-                regs->gpr[3] = savep[0];        /* restore original r3 */
-                memset(mce_data_buf, 0, RTAS_ERROR_LOG_MAX);
-                memcpy(mce_data_buf, (char *)(savep + 1), RTAS_ERROR_LOG_MAX);
-                errhdr = (struct rtas_error_log *)mce_data_buf;
+        savep = __va(regs->gpr[3]);
+        regs->gpr[3] = savep[0];        /* restore original r3 */
+
+        /* If it isn't an extended log we can use the per cpu 64bit buffer */
+        h = (struct rtas_error_log *)&savep[1];
+        if (!h->extended) {
+                memcpy(&__get_cpu_var(mce_data_buf), h, sizeof(__u64));
+                errhdr = (struct rtas_error_log *)&__get_cpu_var(mce_data_buf);
         } else {
-                printk("FWNMI: corrupt r3\n");
+                int len;
+
+                len = max_t(int, 8+h->extended_log_length, RTAS_ERROR_LOG_MAX);
+                memset(global_mce_data_buf, 0, RTAS_ERROR_LOG_MAX);
+                memcpy(global_mce_data_buf, h, len);
+                errhdr = (struct rtas_error_log *)global_mce_data_buf;
         }
+
         return errhdr;
 }
 
@@ -235,7 +259,7 @@ static void fwnmi_release_errinfo(void)
 {
         int ret = rtas_call(rtas_token("ibm,nmi-interlock"), 0, 1, NULL);
         if (ret != 0)
-                printk("FWNMI: nmi-interlock failed: %d\n", ret);
+                printk(KERN_ERR "FWNMI: nmi-interlock failed: %d\n", ret);
 }
 
 int pSeries_system_reset_exception(struct pt_regs *regs)
@@ -259,31 +283,43 @@ int pSeries_system_reset_exception(struct pt_regs *regs)
  * Return 1 if corrected (or delivered a signal).
  * Return 0 if there is nothing we can do.
  */
-static int recover_mce(struct pt_regs *regs, struct rtas_error_log * err)
+static int recover_mce(struct pt_regs *regs, struct rtas_error_log *err)
 {
-        int nonfatal = 0;
+        int recovered = 0;
 
-        if (err->disposition == RTAS_DISP_FULLY_RECOVERED) {
+        if (!(regs->msr & MSR_RI)) {
+                /* If MSR_RI isn't set, we cannot recover */
+                recovered = 0;
+
+        } else if (err->disposition == RTAS_DISP_FULLY_RECOVERED) {
                 /* Platform corrected itself */
-                nonfatal = 1;
-        } else if ((regs->msr & MSR_RI) &&
-                   user_mode(regs) &&
-                   err->severity == RTAS_SEVERITY_ERROR_SYNC &&
-                   err->disposition == RTAS_DISP_NOT_RECOVERED &&
-                   err->target == RTAS_TARGET_MEMORY &&
-                   err->type == RTAS_TYPE_ECC_UNCORR &&
-                   !(current->pid == 0 || is_global_init(current))) {
-                /* Kill off a user process with an ECC error */
-                printk(KERN_ERR "MCE: uncorrectable ecc error for pid %d\n",
-                       current->pid);
-                /* XXX something better for ECC error? */
-                _exception(SIGBUS, regs, BUS_ADRERR, regs->nip);
-                nonfatal = 1;
+                recovered = 1;
+
+        } else if (err->disposition == RTAS_DISP_LIMITED_RECOVERY) {
+                /* Platform corrected itself but could be degraded */
+                printk(KERN_ERR "MCE: limited recovery, system may "
+                       "be degraded\n");
+                recovered = 1;
+
+        } else if (user_mode(regs) && !is_global_init(current) &&
+                   err->severity == RTAS_SEVERITY_ERROR_SYNC) {
+
+                /*
+                 * If we received a synchronous error when in userspace
+                 * kill the task. Firmware may report details of the fail
+                 * asynchronously, so we can't rely on the target and type
+                 * fields being valid here.
+                 */
+                printk(KERN_ERR "MCE: uncorrectable error, killing task "
+                       "%s:%d\n", current->comm, current->pid);
+
+                _exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
+                recovered = 1;
         }
 
-        log_error((char *)err, ERR_TYPE_RTAS_LOG, !nonfatal);
+        log_error((char *)err, ERR_TYPE_RTAS_LOG, 0);
 
-        return nonfatal;
+        return recovered;
 }
 
 /*