1 files changed, 145 insertions, 5 deletions

diff --git a/arch/mips/kernel/ptrace32.c b/arch/mips/kernel/ptrace32.c
index eee207969c21..9a9b04972132 100644
--- a/arch/mips/kernel/ptrace32.c
+++ b/arch/mips/kernel/ptrace32.c
@@ -24,17 +24,24 @@
 #include <linux/smp_lock.h>
 #include <linux/user.h>
 #include <linux/security.h>
-#include <linux/signal.h>
 
 #include <asm/cpu.h>
+#include <asm/dsp.h>
 #include <asm/fpu.h>
 #include <asm/mipsregs.h>
+#include <asm/mipsmtregs.h>
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/bootinfo.h>
 
+int ptrace_getregs (struct task_struct *child, __s64 __user *data);
+int ptrace_setregs (struct task_struct *child, __s64 __user *data);
+
+int ptrace_getfpregs (struct task_struct *child, __u32 __user *data);
+int ptrace_setfpregs (struct task_struct *child, __u32 __user *data);
+
 /*
  * Tracing a 32-bit process with a 64-bit strace and vice versa will not
  * work.  I don't know how to fix this.
@@ -99,6 +106,35 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                 break;
         }
 
+        /*
+         * Read 4 bytes of the other process' storage
+         *  data is a pointer specifying where the user wants the
+         *      4 bytes copied into
+         *  addr is a pointer in the user's storage that contains an 8 byte
+         *      address in the other process of the 4 bytes that is to be read
+         * (this is run in a 32-bit process looking at a 64-bit process)
+         * when I and D space are separate, these will need to be fixed.
+         */
+        case PTRACE_PEEKTEXT_3264:
+        case PTRACE_PEEKDATA_3264: {
+                u32 tmp;
+                int copied;
+                u32 __user * addrOthers;
+
+                ret = -EIO;
+
+                /* Get the addr in the other process that we want to read */
+                if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
+                        break;
+
+                copied = access_process_vm(child, (u64)addrOthers, &tmp,
+                                sizeof(tmp), 0);
+                if (copied != sizeof(tmp))
+                        break;
+                ret = put_user(tmp, (u32 __user *) (unsigned long) data);
+                break;
+        }
+
         /* Read the word at location addr in the USER area. */
         case PTRACE_PEEKUSR: {
                 struct pt_regs *regs;
@@ -156,12 +192,44 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                         if (!cpu_has_fpu)
                                 break;
 
-                        flags = read_c0_status();
-                        __enable_fpu();
-                        __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
-                        write_c0_status(flags);
+                        preempt_disable();
+                        if (cpu_has_mipsmt) {
+                                unsigned int vpflags = dvpe();
+                                flags = read_c0_status();
+                                __enable_fpu();
+                                __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
+                                write_c0_status(flags);
+                                evpe(vpflags);
+                        } else {
+                                flags = read_c0_status();
+                                __enable_fpu();
+                                __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
+                                write_c0_status(flags);
+                        }
+                        preempt_enable();
                         break;
                 }
+                case DSP_BASE ... DSP_BASE + 5:
+                        if (!cpu_has_dsp) {
+                                tmp = 0;
+                                ret = -EIO;
+                                goto out_tsk;
+                        }
+                        if (child->thread.dsp.used_dsp) {
+                                dspreg_t *dregs = __get_dsp_regs(child);
+                                tmp = (unsigned long) (dregs[addr - DSP_BASE]);
+                        } else {
+                                tmp = -1;       /* DSP registers yet used  */
+                        }
+                        break;
+                case DSP_CONTROL:
+                        if (!cpu_has_dsp) {
+                                tmp = 0;
+                                ret = -EIO;
+                                goto out_tsk;
+                        }
+                        tmp = child->thread.dsp.dspcontrol;
+                        break;
                 default:
                         tmp = 0;
                         ret = -EIO;
@@ -181,6 +249,31 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                 ret = -EIO;
                 break;
 
+        /*
+         * Write 4 bytes into the other process' storage
+         *  data is the 4 bytes that the user wants written
+         *  addr is a pointer in the user's storage that contains an
+         *      8 byte address in the other process where the 4 bytes
+         *      that is to be written
+         * (this is run in a 32-bit process looking at a 64-bit process)
+         * when I and D space are separate, these will need to be fixed.
+         */
+        case PTRACE_POKETEXT_3264:
+        case PTRACE_POKEDATA_3264: {
+                u32 __user * addrOthers;
+
+                /* Get the addr in the other process that we want to write into */
+                ret = -EIO;
+                if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
+                        break;
+                ret = 0;
+                if (access_process_vm(child, (u64)addrOthers, &data,
+                                        sizeof(data), 1) == sizeof(data))
+                        break;
+                ret = -EIO;
+                break;
+        }
+
         case PTRACE_POKEUSR: {
                 struct pt_regs *regs;
                 ret = 0;
@@ -231,6 +324,22 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                         else
                                 child->thread.fpu.soft.fcr31 = data;
                         break;
+                case DSP_BASE ... DSP_BASE + 5:
+                        if (!cpu_has_dsp) {
+                                ret = -EIO;
+                                break;
+                        }
+
+                        dspreg_t *dregs = __get_dsp_regs(child);
+                        dregs[addr - DSP_BASE] = data;
+                        break;
+                case DSP_CONTROL:
+                        if (!cpu_has_dsp) {
+                                ret = -EIO;
+                                break;
+                        }
+                        child->thread.dsp.dspcontrol = data;
+                        break;
                 default:
                         /* The rest are not allowed. */
                         ret = -EIO;
@@ -239,6 +348,22 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                 break;
                 }
 
+        case PTRACE_GETREGS:
+                ret = ptrace_getregs (child, (__u64 __user *) (__u64) data);
+                break;
+
+        case PTRACE_SETREGS:
+                ret = ptrace_setregs (child, (__u64 __user *) (__u64) data);
+                break;
+
+        case PTRACE_GETFPREGS:
+                ret = ptrace_getfpregs (child, (__u32 __user *) (__u64) data);
+                break;
+
+        case PTRACE_SETFPREGS:
+                ret = ptrace_setfpregs (child, (__u32 __user *) (__u64) data);
+                break;
+
         case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
         case PTRACE_CONT: { /* restart after signal. */
                 ret = -EIO;
@@ -269,10 +394,25 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                 wake_up_process(child);
                 break;
 
+        case PTRACE_GET_THREAD_AREA:
+                ret = put_user(child->thread_info->tp_value,
+                                (unsigned int __user *) (unsigned long) data);
+                break;
+
         case PTRACE_DETACH: /* detach a process that was attached. */
                 ret = ptrace_detach(child, data);
                 break;
 
+        case PTRACE_GETEVENTMSG:
+                ret = put_user(child->ptrace_message,
+                               (unsigned int __user *) (unsigned long) data);
+                break;
+
+        case PTRACE_GET_THREAD_AREA_3264:
+                ret = put_user(child->thread_info->tp_value,
+                                (unsigned long __user *) (unsigned long) data);
+                break;
+
         default:
                 ret = ptrace_request(child, request, addr, data);
                 break;