[PATCH] kdump: Use real pt_regs from exception

[powerpc.git] / arch / x86_64 / kernel / ptrace.c

diff --git a/arch/x86_64/kernel/ptrace.c b/arch/x86_64/kernel/ptrace.c
index c701167..bbf64b5 100644 (file)
--- a/arch/x86_64/kernel/ptrace.c
+++ b/arch/x86_64/kernel/ptrace.c
@@ -18,6 +18,7 @@
 #include <linux/security.h>
 #include <linux/audit.h>
 #include <linux/seccomp.h>
+#include <linux/signal.h>
 
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
@@ -256,13 +257,13 @@ static int putreg(struct task_struct *child,
                        value &= 0xffff;
                        return 0;
                case offsetof(struct user_regs_struct,fs_base):
-                       if (!((value >> 48) == 0 || (value >> 48) == 0xffff))
-                               return -EIO; 
+                       if (value >= TASK_SIZE_OF(child))
+                               return -EIO;
                        child->thread.fs = value;
                        return 0;
                case offsetof(struct user_regs_struct,gs_base):
-                       if (!((value >> 48) == 0 || (value >> 48) == 0xffff))
-                               return -EIO; 
+                       if (value >= TASK_SIZE_OF(child))
+                               return -EIO;
                        child->thread.gs = value;
                        return 0;
                case offsetof(struct user_regs_struct, eflags):
@@ -276,6 +277,11 @@ static int putreg(struct task_struct *child,
                                return -EIO;
                        value &= 0xffff;
                        break;
+               case offsetof(struct user_regs_struct, rip):
+                       /* Check if the new RIP address is canonical */
+                       if (value >= TASK_SIZE_OF(child))
+                               return -EIO;
+                       break;
        }
        put_stack_long(child, regno - sizeof(struct pt_regs), value);
        return 0;
@@ -374,7 +380,7 @@ asmlinkage long sys_ptrace(long request, long pid, unsigned long addr, long data
                        break;
 
                switch (addr) { 
-               case 0 ... sizeof(struct user_regs_struct):
+               case 0 ... sizeof(struct user_regs_struct) - sizeof(long):
                        tmp = getreg(child, addr);
                        break;
                case offsetof(struct user, u_debugreg[0]):
@@ -413,33 +419,35 @@ asmlinkage long sys_ptrace(long request, long pid, unsigned long addr, long data
                break;
 
        case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
+       {
+               int dsize = test_tsk_thread_flag(child, TIF_IA32) ? 3 : 7;
                ret = -EIO;
                if ((addr & 7) ||
                    addr > sizeof(struct user) - 7)
                        break;
 
                switch (addr) { 
-               case 0 ... sizeof(struct user_regs_struct): 
+               case 0 ... sizeof(struct user_regs_struct) - sizeof(long):
                        ret = putreg(child, addr, data);
                        break;
                /* Disallows to set a breakpoint into the vsyscall */
                case offsetof(struct user, u_debugreg[0]):
-                       if (data >= TASK_SIZE-7) break;
+                       if (data >= TASK_SIZE_OF(child) - dsize) break;
                        child->thread.debugreg0 = data;
                        ret = 0;
                        break;
                case offsetof(struct user, u_debugreg[1]):
-                       if (data >= TASK_SIZE-7) break;
+                       if (data >= TASK_SIZE_OF(child) - dsize) break;
                        child->thread.debugreg1 = data;
                        ret = 0;
                        break;
                case offsetof(struct user, u_debugreg[2]):
-                       if (data >= TASK_SIZE-7) break;
+                       if (data >= TASK_SIZE_OF(child) - dsize) break;
                        child->thread.debugreg2 = data;
                        ret = 0;
                        break;
                case offsetof(struct user, u_debugreg[3]):
-                       if (data >= TASK_SIZE-7) break;
+                       if (data >= TASK_SIZE_OF(child) - dsize) break;
                        child->thread.debugreg3 = data;
                        ret = 0;
                        break;
@@ -463,11 +471,12 @@ asmlinkage long sys_ptrace(long request, long pid, unsigned long addr, long data
                  break;
                }
                break;
+       }
        case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
        case PTRACE_CONT:    /* restart after signal. */
 
                ret = -EIO;
-               if ((unsigned long) data > _NSIG)
+               if (!valid_signal(data))
                        break;
                if (request == PTRACE_SYSCALL)
                        set_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
@@ -529,7 +538,7 @@ asmlinkage long sys_ptrace(long request, long pid, unsigned long addr, long data
 
        case PTRACE_SINGLESTEP:    /* set the trap flag. */
                ret = -EIO;
-               if ((unsigned long) data > _NSIG)
+               if (!valid_signal(data))
                        break;
                clear_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
                set_singlestep(child);
@@ -634,20 +643,29 @@ asmlinkage void syscall_trace_enter(struct pt_regs *regs)
        /* do the secure computing check first */
        secure_computing(regs->orig_rax);
 
-       if (unlikely(current->audit_context))
-               audit_syscall_entry(current, regs->orig_rax,
-                                   regs->rdi, regs->rsi,
-                                   regs->rdx, regs->r10);
-
        if (test_thread_flag(TIF_SYSCALL_TRACE)
            && (current->ptrace & PT_PTRACED))
                syscall_trace(regs);
+
+       if (unlikely(current->audit_context)) {
+               if (test_thread_flag(TIF_IA32)) {
+                       audit_syscall_entry(current, AUDIT_ARCH_I386,
+                                           regs->orig_rax,
+                                           regs->rbx, regs->rcx,
+                                           regs->rdx, regs->rsi);
+               } else {
+                       audit_syscall_entry(current, AUDIT_ARCH_X86_64,
+                                           regs->orig_rax,
+                                           regs->rdi, regs->rsi,
+                                           regs->rdx, regs->r10);
+               }
+       }
 }
 
 asmlinkage void syscall_trace_leave(struct pt_regs *regs)
 {
        if (unlikely(current->audit_context))
-               audit_syscall_exit(current, regs->rax);
+               audit_syscall_exit(current, AUDITSC_RESULT(regs->rax), regs->rax);
 
        if ((test_thread_flag(TIF_SYSCALL_TRACE)
             || test_thread_flag(TIF_SINGLESTEP))