Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=60b0d65541b581955279221e060f8a0a221151b4
Commit:     60b0d65541b581955279221e060f8a0a221151b4
Parent:     396a2ae08e5080b140330645743ab2567f6bc426
Author:     Maciej W. Rozycki <[EMAIL PROTECTED]>
AuthorDate: Tue Oct 16 18:43:26 2007 +0100
Committer:  Ralf Baechle <[EMAIL PROTECTED]>
CommitDate: Wed Oct 17 18:28:47 2007 +0100

    [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 <[EMAIL PROTECTED]>
    Signed-off-by: Ralf Baechle <[EMAIL PROTECTED]>
    
    ---
---
 arch/mips/kernel/traps.c |  164 ++++++++++++++++++++++++----------------------
 1 files changed, 86 insertions(+), 78 deletions(-)

diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
index 9c0c478..bbf01b8 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, [EMAIL PROTECTED] and Carsten Langgaard, [EMAIL PROTECTED]
  * 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.  */
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to