[MIPS] SYNC emulation for MIPS I processors

Userland, including the C library and the dynamic linker, is keen to use
the SYNC instruction, even for "generic" MIPS I binaries these days.
Which makes it less than useful on MIPS I processors.

This change adds the emulation, but as our do_ri() infrastructure was not
really prepared to take yet another instruction, I have rewritten it and
its callees slightly as follows.

Now there is only a single place a possible signal is thrown from.  The
place is at the end of do_ri().  The instruction word is fetched in
do_ri() and passed down to handlers.  The handlers are called in sequence
and return a result that lets the caller decide upon further processing.
If the result is positive, then the handler has picked the instruction,
but a signal should be thrown and the result is the signal number.  If the
result is zero, then the handler has successfully simulated the
instruction.  If the result is negative, then the handler did not handle
the instruction; to make it more obvious the calls do not follow the usual
0/-Exxx result convention they now return -1 instead of -EFAULT.

The calculation of the return EPC is now at the beginning.  The reason is
it is easier to handle it there as emulation callees may modify a register
and an instruction may be located in delay slot of a branch whose result
depends on the register.  It has to be undone if a signal is to be raised,
but it is not a problem as this is the slow-path case, and both actions
are done in single places now rather than the former being scattered
through emulation handlers.

The part of do_cpu() being covered follows the changes to do_ri().

Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

---

1 files changed, 86 insertions, 78 deletions

diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
index 9c0c478d71ac..bbf01b81a4ff 100644
--- a/arch/mips/kernel/traps.c
+++ b/arch/mips/kernel/traps.c
@@ -9,9 +9,10 @@
  * Copyright (C) 1999 Silicon Graphics, Inc.
  * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
  * Copyright (C) 2000, 01 MIPS Technologies, Inc.
- * Copyright (C) 2002, 2003, 2004, 2005  Maciej W. Rozycki
+ * Copyright (C) 2002, 2003, 2004, 2005, 2007  Maciej W. Rozycki
  */
 #include <linux/bug.h>
+#include <linux/compiler.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/module.h>
@@ -410,7 +411,7 @@ asmlinkage void do_be(struct pt_regs *regs)
 }
 
 /*
- * ll/sc emulation
+ * ll/sc, rdhwr, sync emulation
  */
 
 #define OPCODE 0xfc000000
@@ -419,9 +420,11 @@ asmlinkage void do_be(struct pt_regs *regs)
 #define OFFSET 0x0000ffff
 #define LL     0xc0000000
 #define SC     0xe0000000
+#define SPEC0  0x00000000
 #define SPEC3  0x7c000000
 #define RD     0x0000f800
 #define FUNC   0x0000003f
+#define SYNC   0x0000000f
 #define RDHWR  0x0000003b
 
 /*
@@ -432,11 +435,10 @@ unsigned long ll_bit;
 
 static struct task_struct *ll_task = NULL;
 
-static inline void simulate_ll(struct pt_regs *regs, unsigned int opcode)
+static inline int simulate_ll(struct pt_regs *regs, unsigned int opcode)
 {
         unsigned long value, __user *vaddr;
         long offset;
-        int signal = 0;
 
         /*
          * analyse the ll instruction that just caused a ri exception
@@ -451,14 +453,10 @@ static inline void simulate_ll(struct pt_regs *regs, unsigned int opcode)
         vaddr = (unsigned long __user *)
                 ((unsigned long)(regs->regs[(opcode & BASE) >> 21]) + offset);
 
-        if ((unsigned long)vaddr & 3) {
-                signal = SIGBUS;
-                goto sig;
-        }
-        if (get_user(value, vaddr)) {
-                signal = SIGSEGV;
-                goto sig;
-        }
+        if ((unsigned long)vaddr & 3)
+                return SIGBUS;
+        if (get_user(value, vaddr))
+                return SIGSEGV;
 
         preempt_disable();
 
@@ -471,22 +469,16 @@ static inline void simulate_ll(struct pt_regs *regs, unsigned int opcode)
 
         preempt_enable();
 
-        compute_return_epc(regs);
-
         regs->regs[(opcode & RT) >> 16] = value;
 
-        return;
-
-sig:
-        force_sig(signal, current);
+        return 0;
 }
 
-static inline void simulate_sc(struct pt_regs *regs, unsigned int opcode)
+static inline int simulate_sc(struct pt_regs *regs, unsigned int opcode)
 {
         unsigned long __user *vaddr;
         unsigned long reg;
         long offset;
-        int signal = 0;
 
         /*
          * analyse the sc instruction that just caused a ri exception
@@ -502,34 +494,25 @@ static inline void simulate_sc(struct pt_regs *regs, unsigned int opcode)
                 ((unsigned long)(regs->regs[(opcode & BASE) >> 21]) + offset);
         reg = (opcode & RT) >> 16;
 
-        if ((unsigned long)vaddr & 3) {
-                signal = SIGBUS;
-                goto sig;
-        }
+        if ((unsigned long)vaddr & 3)
+                return SIGBUS;
 
         preempt_disable();
 
         if (ll_bit == 0 || ll_task != current) {
-                compute_return_epc(regs);
                 regs->regs[reg] = 0;
                 preempt_enable();
-                return;
+                return 0;
         }
 
         preempt_enable();
 
-        if (put_user(regs->regs[reg], vaddr)) {
-                signal = SIGSEGV;
-                goto sig;
-        }
+        if (put_user(regs->regs[reg], vaddr))
+                return SIGSEGV;
 
-        compute_return_epc(regs);
         regs->regs[reg] = 1;
 
-        return;
-
-sig:
-        force_sig(signal, current);
+        return 0;
 }
 
 /*
@@ -539,27 +522,14 @@ sig:
  * few processors such as NEC's VR4100 throw reserved instruction exceptions
  * instead, so we're doing the emulation thing in both exception handlers.
  */
-static inline int simulate_llsc(struct pt_regs *regs)
+static int simulate_llsc(struct pt_regs *regs, unsigned int opcode)
 {
-        unsigned int opcode;
-
-        if (get_user(opcode, (unsigned int __user *) exception_epc(regs)))
-                goto out_sigsegv;
-
-        if ((opcode & OPCODE) == LL) {
-                simulate_ll(regs, opcode);
-                return 0;
-        }
-        if ((opcode & OPCODE) == SC) {
-                simulate_sc(regs, opcode);
-                return 0;
-        }
-
-        return -EFAULT;                 /* Strange things going on ... */
+        if ((opcode & OPCODE) == LL)
+                return simulate_ll(regs, opcode);
+        if ((opcode & OPCODE) == SC)
+                return simulate_sc(regs, opcode);
 
-out_sigsegv:
-        force_sig(SIGSEGV, current);
-        return -EFAULT;
+        return -1;                      /* Must be something else ... */
 }
 
 /*
@@ -567,16 +537,9 @@ out_sigsegv:
  * registers not implemented in hardware.  The only current use of this
  * is the thread area pointer.
  */
-static inline int simulate_rdhwr(struct pt_regs *regs)
+static int simulate_rdhwr(struct pt_regs *regs, unsigned int opcode)
 {
         struct thread_info *ti = task_thread_info(current);
-        unsigned int opcode;
-
-        if (get_user(opcode, (unsigned int __user *) exception_epc(regs)))
-                goto out_sigsegv;
-
-        if (unlikely(compute_return_epc(regs)))
-                return -EFAULT;
 
         if ((opcode & OPCODE) == SPEC3 && (opcode & FUNC) == RDHWR) {
                 int rd = (opcode & RD) >> 11;
@@ -586,16 +549,20 @@ static inline int simulate_rdhwr(struct pt_regs *regs)
                                 regs->regs[rt] = ti->tp_value;
                                 return 0;
                         default:
-                                return -EFAULT;
+                                return -1;
                 }
         }
 
         /* Not ours.  */
-        return -EFAULT;
+        return -1;
+}
 
-out_sigsegv:
-        force_sig(SIGSEGV, current);
-        return -EFAULT;
+static int simulate_sync(struct pt_regs *regs, unsigned int opcode)
+{
+        if ((opcode & OPCODE) == SPEC0 && (opcode & FUNC) == SYNC)
+                return 0;
+
+        return -1;                      /* Must be something else ... */
 }
 
 asmlinkage void do_ov(struct pt_regs *regs)
@@ -767,16 +734,35 @@ out_sigsegv:
 
 asmlinkage void do_ri(struct pt_regs *regs)
 {
-        die_if_kernel("Reserved instruction in kernel code", regs);
+        unsigned int __user *epc = (unsigned int __user *)exception_epc(regs);
+        unsigned long old_epc = regs->cp0_epc;
+        unsigned int opcode = 0;
+        int status = -1;
 
-        if (!cpu_has_llsc)
-                if (!simulate_llsc(regs))
-                        return;
+        die_if_kernel("Reserved instruction in kernel code", regs);
 
-        if (!simulate_rdhwr(regs))
+        if (unlikely(compute_return_epc(regs) < 0))
                 return;
 
-        force_sig(SIGILL, current);
+        if (unlikely(get_user(opcode, epc) < 0))
+                status = SIGSEGV;
+
+        if (!cpu_has_llsc && status < 0)
+                status = simulate_llsc(regs, opcode);
+
+        if (status < 0)
+                status = simulate_rdhwr(regs, opcode);
+
+        if (status < 0)
+                status = simulate_sync(regs, opcode);
+
+        if (status < 0)
+                status = SIGILL;
+
+        if (unlikely(status > 0)) {
+                regs->cp0_epc = old_epc;                /* Undo skip-over.  */
+                force_sig(status, current);
+        }
 }
 
 /*
@@ -808,7 +794,11 @@ static void mt_ase_fp_affinity(void)
 
 asmlinkage void do_cpu(struct pt_regs *regs)
 {
+        unsigned int __user *epc;
+        unsigned long old_epc;
+        unsigned int opcode;
         unsigned int cpid;
+        int status;
 
         die_if_kernel("do_cpu invoked from kernel context!", regs);
 
@@ -816,14 +806,32 @@ asmlinkage void do_cpu(struct pt_regs *regs)
 
         switch (cpid) {
         case 0:
-                if (!cpu_has_llsc)
-                        if (!simulate_llsc(regs))
-                                return;
+                epc = (unsigned int __user *)exception_epc(regs);
+                old_epc = regs->cp0_epc;
+                opcode = 0;
+                status = -1;
 
-                if (!simulate_rdhwr(regs))
+                if (unlikely(compute_return_epc(regs) < 0))
                         return;
 
-                break;
+                if (unlikely(get_user(opcode, epc) < 0))
+                        status = SIGSEGV;
+
+                if (!cpu_has_llsc && status < 0)
+                        status = simulate_llsc(regs, opcode);
+
+                if (status < 0)
+                        status = simulate_rdhwr(regs, opcode);
+
+                if (status < 0)
+                        status = SIGILL;
+
+                if (unlikely(status > 0)) {
+                        regs->cp0_epc = old_epc;        /* Undo skip-over.  */
+                        force_sig(status, current);
+                }
+
+                return;
 
         case 1:
                 if (used_math())        /* Using the FPU again.  */