Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc

Pull Sparc updates from David Miller:

 1) Updated syscall tracing fix from Al Viro.

 2) SUN4V error reporting was deficient in several areas.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc:
  sparc64: fix ptrace interaction with force_successful_syscall_return()
  sparc64: Fix deficiencies in sun4v error reporting.

4 files changed, 221 insertions, 81 deletions

diff --git a/arch/sparc/include/asm/uaccess_64.h b/arch/sparc/include/asm/uaccess_64.h
index 7c831d848b4e..73083e1d38d9 100644
--- a/arch/sparc/include/asm/uaccess_64.h
+++ b/arch/sparc/include/asm/uaccess_64.h
@@ -265,6 +265,11 @@ extern __must_check long strnlen_user(const char __user *str, long n);
 #define __copy_to_user_inatomic ___copy_to_user
 #define __copy_from_user_inatomic ___copy_from_user
 
+struct pt_regs;
+extern unsigned long compute_effective_address(struct pt_regs *,
+                                               unsigned int insn,
+                                               unsigned int rd);
+
 #endif  /* __ASSEMBLY__ */
 
 #endif /* _ASM_UACCESS_H */
diff --git a/arch/sparc/kernel/syscalls.S b/arch/sparc/kernel/syscalls.S
index 1d7e274f3f2b..7f5f65d0b3fd 100644
--- a/arch/sparc/kernel/syscalls.S
+++ b/arch/sparc/kernel/syscalls.S
@@ -212,24 +212,20 @@ linux_sparc_syscall:
 3:      stx     %o0, [%sp + PTREGS_OFF + PT_V9_I0]
 ret_sys_call:
         ldx     [%sp + PTREGS_OFF + PT_V9_TSTATE], %g3
-        ldx     [%sp + PTREGS_OFF + PT_V9_TNPC], %l1 ! pc = npc
         sra     %o0, 0, %o0
         mov     %ulo(TSTATE_XCARRY | TSTATE_ICARRY), %g2
         sllx    %g2, 32, %g2
 
-        /* Check if force_successful_syscall_return()
-         * was invoked.
-         */
-        ldub    [%g6 + TI_SYS_NOERROR], %l2
-        brnz,a,pn %l2, 80f
-         stb    %g0, [%g6 + TI_SYS_NOERROR]
-
         cmp     %o0, -ERESTART_RESTARTBLOCK
         bgeu,pn %xcc, 1f
-         andcc  %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %l6
-80:
+         andcc  %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %g0
+        ldx     [%sp + PTREGS_OFF + PT_V9_TNPC], %l1 ! pc = npc
+
+2:
+        stb     %g0, [%g6 + TI_SYS_NOERROR]
         /* System call success, clear Carry condition code. */
         andn    %g3, %g2, %g3
+3:
         stx     %g3, [%sp + PTREGS_OFF + PT_V9_TSTATE]  
         bne,pn  %icc, linux_syscall_trace2
          add    %l1, 0x4, %l2                   ! npc = npc+4
@@ -238,20 +234,20 @@ ret_sys_call:
          stx    %l2, [%sp + PTREGS_OFF + PT_V9_TNPC]
 
 1:
+        /* Check if force_successful_syscall_return()
+         * was invoked.
+         */
+        ldub    [%g6 + TI_SYS_NOERROR], %l2
+        brnz,pn %l2, 2b
+         ldx    [%sp + PTREGS_OFF + PT_V9_TNPC], %l1 ! pc = npc
         /* System call failure, set Carry condition code.
          * Also, get abs(errno) to return to the process.
          */
-        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %l6  
         sub     %g0, %o0, %o0
-        or      %g3, %g2, %g3
         stx     %o0, [%sp + PTREGS_OFF + PT_V9_I0]
-        stx     %g3, [%sp + PTREGS_OFF + PT_V9_TSTATE]
-        bne,pn  %icc, linux_syscall_trace2
-         add    %l1, 0x4, %l2                   ! npc = npc+4
-        stx     %l1, [%sp + PTREGS_OFF + PT_V9_TPC]
+        ba,pt   %xcc, 3b
+         or     %g3, %g2, %g3
 
-        b,pt    %xcc, rtrap
-         stx    %l2, [%sp + PTREGS_OFF + PT_V9_TNPC]
 linux_syscall_trace2:
         call    syscall_trace_leave
          add    %sp, PTREGS_OFF, %o0
diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
index fa1f1d375ffc..b66a77968f35 100644
--- a/arch/sparc/kernel/traps_64.c
+++ b/arch/sparc/kernel/traps_64.c
@@ -1,6 +1,6 @@
 /* arch/sparc64/kernel/traps.c
  *
- * Copyright (C) 1995,1997,2008,2009 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 1995,1997,2008,2009,2012 David S. Miller (davem@davemloft.net)
  * Copyright (C) 1997,1999,2000 Jakub Jelinek (jakub@redhat.com)
  */
 
@@ -18,6 +18,7 @@
 #include <linux/init.h>
 #include <linux/kdebug.h>
 #include <linux/ftrace.h>
+#include <linux/reboot.h>
 #include <linux/gfp.h>
 
 #include <asm/smp.h>
@@ -1760,85 +1761,223 @@ void cheetah_plus_parity_error(int type, struct pt_regs *regs)
 }
 
 struct sun4v_error_entry {
-        u64             err_handle;
-        u64             err_stick;
+        /* Unique error handle */
+/*0x00*/u64             err_handle;
 
-        u32             err_type;
+        /* %stick value at the time of the error */
+/*0x08*/u64             err_stick;
+
+/*0x10*/u8              reserved_1[3];
+
+        /* Error type */
+/*0x13*/u8              err_type;
 #define SUN4V_ERR_TYPE_UNDEFINED        0
 #define SUN4V_ERR_TYPE_UNCORRECTED_RES  1
 #define SUN4V_ERR_TYPE_PRECISE_NONRES   2
 #define SUN4V_ERR_TYPE_DEFERRED_NONRES  3
-#define SUN4V_ERR_TYPE_WARNING_RES      4
+#define SUN4V_ERR_TYPE_SHUTDOWN_RQST    4
+#define SUN4V_ERR_TYPE_DUMP_CORE        5
+#define SUN4V_ERR_TYPE_SP_STATE_CHANGE  6
+#define SUN4V_ERR_TYPE_NUM              7
 
-        u32             err_attrs;
+        /* Error attributes */
+/*0x14*/u32             err_attrs;
 #define SUN4V_ERR_ATTRS_PROCESSOR       0x00000001
 #define SUN4V_ERR_ATTRS_MEMORY          0x00000002
 #define SUN4V_ERR_ATTRS_PIO             0x00000004
 #define SUN4V_ERR_ATTRS_INT_REGISTERS   0x00000008
 #define SUN4V_ERR_ATTRS_FPU_REGISTERS   0x00000010
-#define SUN4V_ERR_ATTRS_USER_MODE       0x01000000
-#define SUN4V_ERR_ATTRS_PRIV_MODE       0x02000000
+#define SUN4V_ERR_ATTRS_SHUTDOWN_RQST   0x00000020
+#define SUN4V_ERR_ATTRS_ASR             0x00000040
+#define SUN4V_ERR_ATTRS_ASI             0x00000080
+#define SUN4V_ERR_ATTRS_PRIV_REG        0x00000100
+#define SUN4V_ERR_ATTRS_SPSTATE_MSK     0x00000600
+#define SUN4V_ERR_ATTRS_SPSTATE_SHFT    9
+#define SUN4V_ERR_ATTRS_MODE_MSK        0x03000000
+#define SUN4V_ERR_ATTRS_MODE_SHFT       24
 #define SUN4V_ERR_ATTRS_RES_QUEUE_FULL  0x80000000
 
-        u64             err_raddr;
-        u32             err_size;
-        u16             err_cpu;
-        u16             err_pad;
+#define SUN4V_ERR_SPSTATE_FAULTED       0
+#define SUN4V_ERR_SPSTATE_AVAILABLE     1
+#define SUN4V_ERR_SPSTATE_NOT_PRESENT   2
+
+#define SUN4V_ERR_MODE_USER             1
+#define SUN4V_ERR_MODE_PRIV             2
+
+        /* Real address of the memory region or PIO transaction */
+/*0x18*/u64             err_raddr;
+
+        /* Size of the operation triggering the error, in bytes */
+/*0x20*/u32             err_size;
+
+        /* ID of the CPU */
+/*0x24*/u16             err_cpu;
+
+        /* Grace periof for shutdown, in seconds */
+/*0x26*/u16             err_secs;
+
+        /* Value of the %asi register */
+/*0x28*/u8              err_asi;
+
+/*0x29*/u8              reserved_2;
+
+        /* Value of the ASR register number */
+/*0x2a*/u16             err_asr;
+#define SUN4V_ERR_ASR_VALID             0x8000
+
+/*0x2c*/u32             reserved_3;
+/*0x30*/u64             reserved_4;
+/*0x38*/u64             reserved_5;
 };
 
 static atomic_t sun4v_resum_oflow_cnt = ATOMIC_INIT(0);
 static atomic_t sun4v_nonresum_oflow_cnt = ATOMIC_INIT(0);
 
-static const char *sun4v_err_type_to_str(u32 type)
-{
-        switch (type) {
-        case SUN4V_ERR_TYPE_UNDEFINED:
-                return "undefined";
-        case SUN4V_ERR_TYPE_UNCORRECTED_RES:
-                return "uncorrected resumable";
-        case SUN4V_ERR_TYPE_PRECISE_NONRES:
-                return "precise nonresumable";
-        case SUN4V_ERR_TYPE_DEFERRED_NONRES:
-                return "deferred nonresumable";
-        case SUN4V_ERR_TYPE_WARNING_RES:
-                return "warning resumable";
-        default:
-                return "unknown";
+static const char *sun4v_err_type_to_str(u8 type)
+{
+        static const char *types[SUN4V_ERR_TYPE_NUM] = {
+                "undefined",
+                "uncorrected resumable",
+                "precise nonresumable",
+                "deferred nonresumable",
+                "shutdown request",
+                "dump core",
+                "SP state change",
+        };
+
+        if (type < SUN4V_ERR_TYPE_NUM)
+                return types[type];
+
+        return "unknown";
+}
+
+static void sun4v_emit_err_attr_strings(u32 attrs)
+{
+        static const char *attr_names[] = {
+                "processor",
+                "memory",
+                "PIO",
+                "int-registers",
+                "fpu-registers",
+                "shutdown-request",
+                "ASR",
+                "ASI",
+                "priv-reg",
+        };
+        static const char *sp_states[] = {
+                "sp-faulted",
+                "sp-available",
+                "sp-not-present",
+                "sp-state-reserved",
+        };
+        static const char *modes[] = {
+                "mode-reserved0",
+                "user",
+                "priv",
+                "mode-reserved1",
+        };
+        u32 sp_state, mode;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(attr_names); i++) {
+                if (attrs & (1U << i)) {
+                        const char *s = attr_names[i];
+
+                        pr_cont("%s ", s);
+                }
         }
+
+        sp_state = ((attrs & SUN4V_ERR_ATTRS_SPSTATE_MSK) >>
+                    SUN4V_ERR_ATTRS_SPSTATE_SHFT);
+        pr_cont("%s ", sp_states[sp_state]);
+
+        mode = ((attrs & SUN4V_ERR_ATTRS_MODE_MSK) >>
+                SUN4V_ERR_ATTRS_MODE_SHFT);
+        pr_cont("%s ", modes[mode]);
+
+        if (attrs & SUN4V_ERR_ATTRS_RES_QUEUE_FULL)
+                pr_cont("res-queue-full ");
 }
 
-static void sun4v_log_error(struct pt_regs *regs, struct sun4v_error_entry *ent, int cpu, const char *pfx, atomic_t *ocnt)
+/* When the report contains a real-address of "-1" it means that the
+ * hardware did not provide the address.  So we compute the effective
+ * address of the load or store instruction at regs->tpc and report
+ * that.  Usually when this happens it's a PIO and in such a case we
+ * are using physical addresses with bypass ASIs anyways, so what we
+ * report here is exactly what we want.
+ */
+static void sun4v_report_real_raddr(const char *pfx, struct pt_regs *regs)
 {
+        unsigned int insn;
+        u64 addr;
+
+        if (!(regs->tstate & TSTATE_PRIV))
+                return;
+
+        insn = *(unsigned int *) regs->tpc;
+
+        addr = compute_effective_address(regs, insn, 0);
+
+        printk("%s: insn effective address [0x%016llx]\n",
+               pfx, addr);
+}
+
+static void sun4v_log_error(struct pt_regs *regs, struct sun4v_error_entry *ent,
+                            int cpu, const char *pfx, atomic_t *ocnt)
+{
+        u64 *raw_ptr = (u64 *) ent;
+        u32 attrs;
         int cnt;
 
         printk("%s: Reporting on cpu %d\n", pfx, cpu);
-        printk("%s: err_handle[%llx] err_stick[%llx] err_type[%08x:%s]\n",
-               pfx,
-               ent->err_handle, ent->err_stick,
-               ent->err_type,
-               sun4v_err_type_to_str(ent->err_type));
-        printk("%s: err_attrs[%08x:%s %s %s %s %s %s %s %s]\n",
-               pfx,
-               ent->err_attrs,
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_PROCESSOR) ?
-                "processor" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_MEMORY) ?
-                "memory" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_PIO) ?
-                "pio" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_INT_REGISTERS) ?
-                "integer-regs" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_FPU_REGISTERS) ?
-                "fpu-regs" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_USER_MODE) ?
-                "user" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_PRIV_MODE) ?
-                "privileged" : ""),
-               ((ent->err_attrs & SUN4V_ERR_ATTRS_RES_QUEUE_FULL) ?
-                "queue-full" : ""));
-        printk("%s: err_raddr[%016llx] err_size[%u] err_cpu[%u]\n",
-               pfx,
-               ent->err_raddr, ent->err_size, ent->err_cpu);
+        printk("%s: TPC [0x%016lx] <%pS>\n",
+               pfx, regs->tpc, (void *) regs->tpc);
+
+        printk("%s: RAW [%016llx:%016llx:%016llx:%016llx\n",
+               pfx, raw_ptr[0], raw_ptr[1], raw_ptr[2], raw_ptr[3]);
+        printk("%s:      %016llx:%016llx:%016llx:%016llx]\n",
+               pfx, raw_ptr[4], raw_ptr[5], raw_ptr[6], raw_ptr[7]);
+
+        printk("%s: handle [0x%016llx] stick [0x%016llx]\n",
+               pfx, ent->err_handle, ent->err_stick);
+
+        printk("%s: type [%s]\n", pfx, sun4v_err_type_to_str(ent->err_type));
+
+        attrs = ent->err_attrs;
+        printk("%s: attrs [0x%08x] < ", pfx, attrs);
+        sun4v_emit_err_attr_strings(attrs);
+        pr_cont(">\n");
+
+        /* Various fields in the error report are only valid if
+         * certain attribute bits are set.
+         */
+        if (attrs & (SUN4V_ERR_ATTRS_MEMORY |
+                     SUN4V_ERR_ATTRS_PIO |
+                     SUN4V_ERR_ATTRS_ASI)) {
+                printk("%s: raddr [0x%016llx]\n", pfx, ent->err_raddr);
+
+                if (ent->err_raddr == ~(u64)0)
+                        sun4v_report_real_raddr(pfx, regs);
+        }
+
+        if (attrs & (SUN4V_ERR_ATTRS_MEMORY | SUN4V_ERR_ATTRS_ASI))
+                printk("%s: size [0x%x]\n", pfx, ent->err_size);
+
+        if (attrs & (SUN4V_ERR_ATTRS_PROCESSOR |
+                     SUN4V_ERR_ATTRS_INT_REGISTERS |
+                     SUN4V_ERR_ATTRS_FPU_REGISTERS |
+                     SUN4V_ERR_ATTRS_PRIV_REG))
+                printk("%s: cpu[%u]\n", pfx, ent->err_cpu);
+
+        if (attrs & SUN4V_ERR_ATTRS_ASI)
+                printk("%s: asi [0x%02x]\n", pfx, ent->err_asi);
+
+        if ((attrs & (SUN4V_ERR_ATTRS_INT_REGISTERS |
+                      SUN4V_ERR_ATTRS_FPU_REGISTERS |
+                      SUN4V_ERR_ATTRS_PRIV_REG)) &&
+            (ent->err_asr & SUN4V_ERR_ASR_VALID) != 0)
+                printk("%s: reg [0x%04x]\n",
+                       pfx, ent->err_asr & ~SUN4V_ERR_ASR_VALID);
 
         show_regs(regs);
 
@@ -1874,13 +2013,15 @@ void sun4v_resum_error(struct pt_regs *regs, unsigned long offset)
 
         put_cpu();
 
-        if (ent->err_type == SUN4V_ERR_TYPE_WARNING_RES) {
-                /* If err_type is 0x4, it's a powerdown request.  Do
-                 * not do the usual resumable error log because that
-                 * makes it look like some abnormal error.
+        if (local_copy.err_type == SUN4V_ERR_TYPE_SHUTDOWN_RQST) {
+                /* We should really take the seconds field of
+                 * the error report and use it for the shutdown
+                 * invocation, but for now do the same thing we
+                 * do for a DS shutdown request.
                  */
-                printk(KERN_INFO "Power down request...\n");
-                kill_cad_pid(SIGINT, 1);
+                pr_info("Shutdown request, %u seconds...\n",
+                        local_copy.err_secs);
+                orderly_poweroff(true);
                 return;
         }
 
diff --git a/arch/sparc/mm/fault_64.c b/arch/sparc/mm/fault_64.c
index 2976dba1ebaf..097aee763af3 100644
--- a/arch/sparc/mm/fault_64.c
+++ b/arch/sparc/mm/fault_64.c
@@ -151,8 +151,6 @@ show_signal_msg(struct pt_regs *regs, int sig, int code,
         printk(KERN_CONT "\n");
 }
 
-extern unsigned long compute_effective_address(struct pt_regs *, unsigned int, unsigned int);
-
 static void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
                              unsigned int insn, int fault_code)
 {