diff options
Diffstat (limited to 'arch')
| -rw-r--r-- | arch/x86/ia32/ptrace32.c | 411 | ||||
| -rw-r--r-- | arch/x86/kernel/ptrace_64.c | 470 |
2 files changed, 0 insertions, 881 deletions
diff --git a/arch/x86/ia32/ptrace32.c b/arch/x86/ia32/ptrace32.c deleted file mode 100644 index d5663e29533..00000000000 --- a/arch/x86/ia32/ptrace32.c +++ /dev/null @@ -1,411 +0,0 @@ -/* - * 32bit ptrace for x86-64. - * - * Copyright 2001,2002 Andi Kleen, SuSE Labs. - * Some parts copied from arch/i386/kernel/ptrace.c. See that file for earlier - * copyright. - * - * This allows to access 64bit processes too; but there is no way to - * see the extended register contents. - */ - -#include <linux/kernel.h> -#include <linux/stddef.h> -#include <linux/sched.h> -#include <linux/syscalls.h> -#include <linux/unistd.h> -#include <linux/mm.h> -#include <linux/err.h> -#include <linux/ptrace.h> -#include <asm/ptrace.h> -#include <asm/compat.h> -#include <asm/uaccess.h> -#include <asm/user32.h> -#include <asm/user.h> -#include <asm/errno.h> -#include <asm/debugreg.h> -#include <asm/i387.h> -#include <asm/fpu32.h> -#include <asm/ia32.h> - -/* - * Determines which flags the user has access to [1 = access, 0 = no access]. - * Prohibits changing ID(21), VIP(20), VIF(19), VM(17), IOPL(12-13), IF(9). - * Also masks reserved bits (31-22, 15, 5, 3, 1). - */ -#define FLAG_MASK 0x54dd5UL - -#define R32(l,q) \ - case offsetof(struct user32, regs.l): \ - regs->q = val; break; - -static int putreg32(struct task_struct *child, unsigned regno, u32 val) -{ - struct pt_regs *regs = task_pt_regs(child); - - switch (regno) { - case offsetof(struct user32, regs.fs): - if (val && (val & 3) != 3) - return -EIO; - child->thread.fsindex = val & 0xffff; - if (child == current) - loadsegment(fs, child->thread.fsindex); - break; - case offsetof(struct user32, regs.gs): - if (val && (val & 3) != 3) - return -EIO; - child->thread.gsindex = val & 0xffff; - if (child == current) - load_gs_index(child->thread.gsindex); - break; - case offsetof(struct user32, regs.ds): - if (val && (val & 3) != 3) - return -EIO; - child->thread.ds = val & 0xffff; - if (child == current) - loadsegment(ds, child->thread.ds); - break; - case offsetof(struct user32, regs.es): - child->thread.es = val & 0xffff; - if (child == current) - loadsegment(es, child->thread.ds); - break; - case offsetof(struct user32, regs.ss): - if ((val & 3) != 3) - return -EIO; - regs->ss = val & 0xffff; - break; - case offsetof(struct user32, regs.cs): - if ((val & 3) != 3) - return -EIO; - regs->cs = val & 0xffff; - break; - - R32(ebx, bx); - R32(ecx, cx); - R32(edx, dx); - R32(edi, di); - R32(esi, si); - R32(ebp, bp); - R32(eax, ax); - R32(orig_eax, orig_ax); - R32(eip, ip); - R32(esp, sp); - - case offsetof(struct user32, regs.eflags): - val &= FLAG_MASK; - /* - * If the user value contains TF, mark that - * it was not "us" (the debugger) that set it. - * If not, make sure it stays set if we had. - */ - if (val & X86_EFLAGS_TF) - clear_tsk_thread_flag(child, TIF_FORCED_TF); - else if (test_tsk_thread_flag(child, TIF_FORCED_TF)) - val |= X86_EFLAGS_TF; - regs->flags = val | (regs->flags & ~FLAG_MASK); - break; - - case offsetof(struct user32, u_debugreg[0]) ... - offsetof(struct user32, u_debugreg[7]): - regno -= offsetof(struct user32, u_debugreg[0]); - return ptrace_set_debugreg(child, regno / 4, val); - - default: - if (regno > sizeof(struct user32) || (regno & 3)) - return -EIO; - - /* - * Other dummy fields in the virtual user structure - * are ignored - */ - break; - } - return 0; -} - -#undef R32 - -#define R32(l,q) \ - case offsetof(struct user32, regs.l): \ - *val = regs->q; break - -static int getreg32(struct task_struct *child, unsigned regno, u32 *val) -{ - struct pt_regs *regs = task_pt_regs(child); - - switch (regno) { - case offsetof(struct user32, regs.fs): - *val = child->thread.fsindex; - if (child == current) - asm("movl %%fs,%0" : "=r" (*val)); - break; - case offsetof(struct user32, regs.gs): - *val = child->thread.gsindex; - if (child == current) - asm("movl %%gs,%0" : "=r" (*val)); - break; - case offsetof(struct user32, regs.ds): - *val = child->thread.ds; - if (child == current) - asm("movl %%ds,%0" : "=r" (*val)); - break; - case offsetof(struct user32, regs.es): - *val = child->thread.es; - if (child == current) - asm("movl %%es,%0" : "=r" (*val)); - break; - - R32(cs, cs); - R32(ss, ss); - R32(ebx, bx); - R32(ecx, cx); - R32(edx, dx); - R32(edi, di); - R32(esi, si); - R32(ebp, bp); - R32(eax, ax); - R32(orig_eax, orig_ax); - R32(eip, ip); - R32(esp, sp); - - case offsetof(struct user32, regs.eflags): - /* - * If the debugger set TF, hide it from the readout. - */ - *val = regs->flags; - if (test_tsk_thread_flag(child, TIF_FORCED_TF)) - *val &= ~X86_EFLAGS_TF; - break; - - case offsetof(struct user32, u_debugreg[0]) ... - offsetof(struct user32, u_debugreg[7]): - regno -= offsetof(struct user32, u_debugreg[0]); - *val = ptrace_get_debugreg(child, regno / 4); - break; - - default: - if (regno > sizeof(struct user32) || (regno & 3)) - return -EIO; - - /* - * Other dummy fields in the virtual user structure - * are ignored - */ - *val = 0; - break; - } - return 0; -} - -#undef R32 - -static long ptrace32_siginfo(unsigned request, u32 pid, u32 addr, u32 data) -{ - siginfo_t __user *si = compat_alloc_user_space(sizeof(siginfo_t)); - compat_siginfo_t __user *si32 = compat_ptr(data); - siginfo_t ssi; - int ret; - - if (request == PTRACE_SETSIGINFO) { - memset(&ssi, 0, sizeof(siginfo_t)); - ret = copy_siginfo_from_user32(&ssi, si32); - if (ret) - return ret; - if (copy_to_user(si, &ssi, sizeof(siginfo_t))) - return -EFAULT; - } - ret = sys_ptrace(request, pid, addr, (unsigned long)si); - if (ret) - return ret; - if (request == PTRACE_GETSIGINFO) { - if (copy_from_user(&ssi, si, sizeof(siginfo_t))) - return -EFAULT; - ret = copy_siginfo_to_user32(si32, &ssi); - } - return ret; -} - -asmlinkage long sys32_ptrace(long request, u32 pid, u32 addr, u32 data) -{ - struct task_struct *child; - struct pt_regs *childregs; - void __user *datap = compat_ptr(data); - int ret; - __u32 val; - - switch (request) { - case PTRACE_TRACEME: - case PTRACE_ATTACH: - case PTRACE_KILL: - case PTRACE_CONT: - case PTRACE_SINGLESTEP: - case PTRACE_SINGLEBLOCK: - case PTRACE_DETACH: - case PTRACE_SYSCALL: - case PTRACE_OLDSETOPTIONS: - case PTRACE_SETOPTIONS: - case PTRACE_SET_THREAD_AREA: - case PTRACE_GET_THREAD_AREA: - return sys_ptrace(request, pid, addr, data); - - default: - return -EINVAL; - - case PTRACE_PEEKTEXT: - case PTRACE_PEEKDATA: - case PTRACE_POKEDATA: - case PTRACE_POKETEXT: - case PTRACE_POKEUSR: - case PTRACE_PEEKUSR: - case PTRACE_GETREGS: - case PTRACE_SETREGS: - case PTRACE_SETFPREGS: - case PTRACE_GETFPREGS: - case PTRACE_SETFPXREGS: - case PTRACE_GETFPXREGS: - case PTRACE_GETEVENTMSG: - break; - - case PTRACE_SETSIGINFO: - case PTRACE_GETSIGINFO: - return ptrace32_siginfo(request, pid, addr, data); - } - - child = ptrace_get_task_struct(pid); - if (IS_ERR(child)) - return PTR_ERR(child); - - ret = ptrace_check_attach(child, request == PTRACE_KILL); - if (ret < 0) - goto out; - - childregs = task_pt_regs(child); - - switch (request) { - case PTRACE_PEEKDATA: - case PTRACE_PEEKTEXT: - ret = 0; - if (access_process_vm(child, addr, &val, sizeof(u32), 0) != - sizeof(u32)) - ret = -EIO; - else - ret = put_user(val, (unsigned int __user *)datap); - break; - - case PTRACE_POKEDATA: - case PTRACE_POKETEXT: - ret = 0; - if (access_process_vm(child, addr, &data, sizeof(u32), 1) != - sizeof(u32)) - ret = -EIO; - break; - - case PTRACE_PEEKUSR: - ret = getreg32(child, addr, &val); - if (ret == 0) - ret = put_user(val, (__u32 __user *)datap); - break; - - case PTRACE_POKEUSR: - ret = putreg32(child, addr, data); - break; - - case PTRACE_GETREGS: { /* Get all gp regs from the child. */ - int i; - - if (!access_ok(VERIFY_WRITE, datap, 16*4)) { - ret = -EIO; - break; - } - ret = 0; - for (i = 0; i <= 16*4; i += sizeof(__u32)) { - getreg32(child, i, &val); - ret |= __put_user(val, (u32 __user *)datap); - datap += sizeof(u32); - } - break; - } - - case PTRACE_SETREGS: { /* Set all gp regs in the child. */ - unsigned long tmp; - int i; - - if (!access_ok(VERIFY_READ, datap, 16*4)) { - ret = -EIO; - break; - } - ret = 0; - for (i = 0; i <= 16*4; i += sizeof(u32)) { - ret |= __get_user(tmp, (u32 __user *)datap); - putreg32(child, i, tmp); - datap += sizeof(u32); - } - break; - } - - case PTRACE_GETFPREGS: - ret = -EIO; - if (!access_ok(VERIFY_READ, compat_ptr(data), - sizeof(struct user_i387_struct))) - break; - save_i387_ia32(child, datap, childregs, 1); - ret = 0; - break; - - case PTRACE_SETFPREGS: - ret = -EIO; - if (!access_ok(VERIFY_WRITE, datap, - sizeof(struct user_i387_struct))) - break; - ret = 0; - /* don't check EFAULT to be bug-to-bug compatible to i386 */ - restore_i387_ia32(child, datap, 1); - break; - - case PTRACE_GETFPXREGS: { - struct user32_fxsr_struct __user *u = datap; - - init_fpu(child); - ret = -EIO; - if (!access_ok(VERIFY_WRITE, u, sizeof(*u))) - break; - ret = -EFAULT; - if (__copy_to_user(u, &child->thread.i387.fxsave, sizeof(*u))) - break; - ret = __put_user(childregs->cs, &u->fcs); - ret |= __put_user(child->thread.ds, &u->fos); - break; - } - case PTRACE_SETFPXREGS: { - struct user32_fxsr_struct __user *u = datap; - - unlazy_fpu(child); - ret = -EIO; - if (!access_ok(VERIFY_READ, u, sizeof(*u))) - break; - /* - * no checking to be bug-to-bug compatible with i386. - * but silence warning - */ - if (__copy_from_user(&child->thread.i387.fxsave, u, sizeof(*u))) - ; - set_stopped_child_used_math(child); - child->thread.i387.fxsave.mxcsr &= mxcsr_feature_mask; - ret = 0; - break; - } - - case PTRACE_GETEVENTMSG: - ret = put_user(child->ptrace_message, - (unsigned int __user *)compat_ptr(data)); - break; - - default: - BUG(); - } - - out: - put_task_struct(child); - return ret; -} diff --git a/arch/x86/kernel/ptrace_64.c b/arch/x86/kernel/ptrace_64.c deleted file mode 100644 index 5979dbe8e0a..00000000000 --- a/arch/x86/kernel/ptrace_64.c +++ /dev/null @@ -1,470 +0,0 @@ -/* By Ross Biro 1/23/92 */ -/* - * Pentium III FXSR, SSE support - * Gareth Hughes <gareth@valinux.com>, May 2000 - * - * x86-64 port 2000-2002 Andi Kleen - */ - -#include <linux/kernel.h> -#include <linux/sched.h> -#include <linux/mm.h> -#include <linux/smp.h> -#include <linux/errno.h> -#include <linux/ptrace.h> -#include <linux/user.h> -#include <linux/security.h> -#include <linux/audit.h> -#include <linux/seccomp.h> -#include <linux/signal.h> - -#include <asm/uaccess.h> -#include <asm/pgtable.h> -#include <asm/system.h> -#include <asm/processor.h> -#include <asm/prctl.h> -#include <asm/i387.h> -#include <asm/debugreg.h> -#include <asm/ldt.h> -#include <asm/desc.h> -#include <asm/proto.h> -#include <asm/ia32.h> - -/* - * does not yet catch signals sent when the child dies. - * in exit.c or in signal.c. - */ - -/* - * Determines which flags the user has access to [1 = access, 0 = no access]. - * Prohibits changing ID(21), VIP(20), VIF(19), VM(17), IOPL(12-13), IF(9). - * Also masks reserved bits (63-22, 15, 5, 3, 1). - */ -#define FLAG_MASK 0x54dd5UL - -/* - * Called by kernel/ptrace.c when detaching.. - * - * Make sure the single step bit is not set. - */ -void ptrace_disable(struct task_struct *child) -{ - user_disable_single_step(child); -} - -static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long offset) -{ - BUILD_BUG_ON(offsetof(struct pt_regs, r15) != 0); - return ®s->r15 + (offset / sizeof(regs->r15)); -} - -static int putreg(struct task_struct *child, - unsigned long regno, unsigned long value) -{ - struct pt_regs *regs = task_pt_regs(child); - switch (regno) { - case offsetof(struct user_regs_struct,fs): - if (value && (value & 3) != 3) - return -EIO; - child->thread.fsindex = value & 0xffff; - if (child == current) - loadsegment(fs, child->thread.fsindex); - return 0; - case offsetof(struct user_regs_struct,gs): - if (value && (value & 3) != 3) - return -EIO; - child->thread.gsindex = value & 0xffff; - if (child == current) - load_gs_index(child->thread.gsindex); - return 0; - case offsetof(struct user_regs_struct,ds): - if (value && (value & 3) != 3) - return -EIO; - child->thread.ds = value & 0xffff; - if (child == current) - loadsegment(ds, child->thread.ds); - return 0; - case offsetof(struct user_regs_struct,es): - if (value && (value & 3) != 3) - return -EIO; - child->thread.es = value & 0xffff; - if (child == current) - loadsegment(es, child->thread.es); - return 0; - case offsetof(struct user_regs_struct,ss): - if ((value & 3) != 3) - return -EIO; - value &= 0xffff; - return 0; - case offsetof(struct user_regs_struct,fs_base): - if (value >= TASK_SIZE_OF(child)) - return -EIO; - /* - * When changing the segment base, use do_arch_prctl - * to set either thread.fs or thread.fsindex and the - * corresponding GDT slot. - */ - if (child->thread.fs != value) - return do_arch_prctl(child, ARCH_SET_FS, value); - return 0; - case offsetof(struct user_regs_struct,gs_base): - /* - * Exactly the same here as the %fs handling above. - */ - if (value >= TASK_SIZE_OF(child)) - return -EIO; - if (child->thread.gs != value) - return do_arch_prctl(child, ARCH_SET_GS, value); - return 0; - case offsetof(struct user_regs_struct,flags): - value &= FLAG_MASK; - /* - * If the user value contains TF, mark that - * it was not "us" (the debugger) that set it. - * If not, make sure it stays set if we had. - */ - if (value & X86_EFLAGS_TF) - clear_tsk_thread_flag(child, TIF_FORCED_TF); - else if (test_tsk_thread_flag(child, TIF_FORCED_TF)) - value |= X86_EFLAGS_TF; - value |= regs->flags & ~FLAG_MASK; - break; - case offsetof(struct user_regs_struct,cs): - if ((value & 3) != 3) - return -EIO; - value &= 0xffff; - break; - } - *pt_regs_access(regs, regno) = value; - return 0; -} - -static unsigned long getreg(struct task_struct *child, unsigned long regno) -{ - struct pt_regs *regs = task_pt_regs(child); - unsigned long val; - unsigned int seg; - switch (regno) { - case offsetof(struct user_regs_struct, fs): - if (child == current) { - /* Older gas can't assemble movq %?s,%r?? */ - asm("movl %%fs,%0" : "=r" (seg)); - return seg; - } - return child->thread.fsindex; - case offsetof(struct user_regs_struct, gs): - if (child == current) { - asm("movl %%gs,%0" : "=r" (seg)); - return seg; - } - return child->thread.gsindex; - case offsetof(struct user_regs_struct, ds): - if (child == current) { - asm("movl %%ds,%0" : "=r" (seg)); - return seg; - } - return child->thread.ds; - case offsetof(struct user_regs_struct, es): - if (child == current) { - asm("movl %%es,%0" : "=r" (seg)); - return seg; - } - return child->thread.es; - case offsetof(struct user_regs_struct, fs_base): - /* - * do_arch_prctl may have used a GDT slot instead of - * the MSR. To userland, it appears the same either - * way, except the %fs segment selector might not be 0. - */ - if (child->thread.fs != 0) - return child->thread.fs; - seg = child->thread.fsindex; - if (child == current) - asm("movl %%fs,%0" : "=r" (seg)); - if (seg != FS_TLS_SEL) - return 0; - return get_desc_base(&child->thread.tls_array[FS_TLS]); - case offsetof(struct user_regs_struct, gs_base): - /* - * Exactly the same here as the %fs handling above. - */ - if (child->thread.gs != 0) - return child->thread.gs; - seg = child->thread.gsindex; - if (child == current) - asm("movl %%gs,%0" : "=r" (seg)); - if (seg != GS_TLS_SEL) - return 0; - return get_desc_base(&child->thread.tls_array[GS_TLS]); - case offsetof(struct user_regs_struct, flags): - /* - * If the debugger set TF, hide it from the readout. - */ - val = regs->flags; - if (test_tsk_thread_flag(child, TIF_IA32)) - val &= 0xffffffff; - if (test_tsk_thread_flag(child, TIF_FORCED_TF)) - val &= ~X86_EFLAGS_TF; - return val; - default: - val = *pt_regs_access(regs, regno); - if (test_tsk_thread_flag(child, TIF_IA32)) - val &= 0xffffffff; - return val; - } - -} - -unsigned long ptrace_get_debugreg(struct task_struct *child, int n) -{ - switch (n) { - case 0: return child->thread.debugreg0; - case 1: return child->thread.debugreg1; - case 2: return child->thread.debugreg2; - case 3: return child->thread.debugreg3; - case 6: return child->thread.debugreg6; - case 7: return child->thread.debugreg7; - } - return 0; -} - -int ptrace_set_debugreg(struct task_struct *child, int n, unsigned long data) -{ - int i; - - if (n < 4) { - int dsize = test_tsk_thread_flag(child, TIF_IA32) ? 3 : 7; - if (unlikely(data >= TASK_SIZE_OF(child) - dsize)) - return -EIO; - } - - switch (n) { - case 0: child->thread.debugreg0 = data; break; - case 1: child->thread.debugreg1 = data; break; - case 2: child->thread.debugreg2 = data; break; - case 3: child->thread.debugreg3 = data; break; - - case 6: - if (data >> 32) - return -EIO; - child->thread.debugreg6 = data; - break; - - case 7: - /* - * See ptrace_32.c for an explanation of this awkward check. - */ - data &= ~DR_CONTROL_RESERVED; - for (i = 0; i < 4; i++) - if ((0x5554 >> ((data >> (16 + 4*i)) & 0xf)) & 1) - return -EIO; - child->thread.debugreg7 = data; - if (data) - set_tsk_thread_flag(child, TIF_DEBUG); - else - clear_tsk_thread_flag(child, TIF_DEBUG); - break; - } - - return 0; -} - -long arch_ptrace(struct task_struct *child, long request, long addr, long data) -{ - long ret; - unsigned ui; - - switch (request) { - /* when I and D space are separate, these will need to be fixed. */ - case PTRACE_PEEKTEXT: /* read word at location addr. */ - case PTRACE_PEEKDATA: - ret = generic_ptrace_peekdata(child, addr, data); - break; - - /* read the word at location addr in the USER area. */ - case PTRACE_PEEKUSR: { - unsigned long tmp; - - ret = -EIO; - if ((addr & 7) || - addr > sizeof(struct user) - 7) - break; - - tmp = 0; - if (addr < sizeof(struct user_regs_struct)) - tmp = getreg(child, addr); - else if (addr >= offsetof(struct user, u_debugreg[0])) { - addr -= offsetof(struct user, u_debugreg[0]); - tmp = ptrace_get_debugreg(child, addr / sizeof(long)); - } - - ret = put_user(tmp,(unsigned long __user *) data); - break; - } - - /* when I and D space are separate, this will have to be fixed. */ - case PTRACE_POKETEXT: /* write the word at location addr. */ - case PTRACE_POKEDATA: - ret = generic_ptrace_pokedata(child, addr, data); - break; - - case PTRACE_POKEUSR: /* write the word at location addr in the USER area */ - ret = -EIO; - if ((addr & 7) || - addr > sizeof(struct user) - 7) - break; - - if (addr < sizeof(struct user_regs_struct)) - ret = putreg(child, addr, data); - else if (addr >= offsetof(struct user, u_debugreg[0])) { - addr -= offsetof(struct user, u_debugreg[0]); - ret = ptrace_set_debugreg(child, - addr / sizeof(long), data); - } - break; - -#ifdef CONFIG_IA32_EMULATION - /* This makes only sense with 32bit programs. Allow a - 64bit debugger to fully examine them too. Better - don't use it against 64bit processes, use - PTRACE_ARCH_PRCTL instead. */ - case PTRACE_GET_THREAD_AREA: - if (addr < 0) - return -EIO; - ret = do_get_thread_area(child, addr, - (struct user_desc __user *) data); - - break; - case PTRACE_SET_THREAD_AREA: - if (addr < 0) - return -EIO; - ret = do_set_thread_area(child, addr, - (struct user_desc __user *) data, 0); - break; -#endif - /* normal 64bit interface to access TLS data. - Works just like arch_prctl, except that the arguments - are reversed. */ - case PTRACE_ARCH_PRCTL: - ret = do_arch_prctl(child, data, addr); - break; - - case PTRACE_GETREGS: { /* Get all gp regs from the child. */ - if (!access_ok(VERIFY_WRITE, (unsigned __user *)data, - sizeof(struct user_regs_struct))) { - ret = -EIO; - break; - } - ret = 0; - for (ui = 0; ui < sizeof(struct user_regs_struct); ui += sizeof(long)) { - ret |= __put_user(getreg(child, ui),(unsigned long __user *) data); - data += sizeof(long); - } - break; - } - - case PTRACE_SETREGS: { /* Set all gp regs in the child. */ - unsigned long tmp; - if (!access_ok(VERIFY_READ, (unsigned __user *)data, - sizeof(struct user_regs_struct))) { - ret = -EIO; - break; - } - ret = 0; - for (ui = 0; ui < sizeof(struct user_regs_struct); ui += sizeof(long)) { - ret = __get_user(tmp, (unsigned long __user *) data); - if (ret) - break; - ret = putreg(child, ui, tmp); - if (ret) - break; - data += sizeof(long); - } - break; - } - - case PTRACE_GETFPREGS: { /* Get the child extended FPU state. */ - if (!access_ok(VERIFY_WRITE, (unsigned __user *)data, - sizeof(struct user_i387_struct))) { - ret = -EIO; - break; - } - ret = get_fpregs((struct user_i387_struct __user *)data, child); - break; - } - - case PTRACE_SETFPREGS: { /* Set the child extended FPU state. */ - if (!access_ok(VERIFY_READ, (unsigned __user *)data, - sizeof(struct user_i387_struct))) { - ret = -EIO; - break; - } - set_stopped_child_used_math(child); - ret = set_fpregs(child, (struct user_i387_struct __user *)data); - break; - } - - default: - ret = ptrace_request(child, request, addr, data); - break; - } - return ret; -} - -static void syscall_trace(struct pt_regs *regs) -{ - -#if 0 - printk("trace %s ip %lx sp %lx ax %d origrax %d caller %lx tiflags %x ptrace %x\n", - current->comm, - regs->ip, regs->sp, regs->ax, regs->orig_ax, __builtin_return_address(0), - current_thread_info()->flags, current->ptrace); -#endif - - ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) - ? 0x80 : 0)); - /* - * this isn't the same as continuing with a signal, but it will do - * for normal use. strace only continues with a signal if the - * stopping signal is not SIGTRAP. -brl - */ - if (current->exit_code) { - send_sig(current->exit_code, current, 1); - current->exit_code = 0; - } -} - -asmlinkage void syscall_trace_enter(struct pt_regs *regs) -{ - /* do the secure computing check first */ - secure_computing(regs->orig_ax); - - 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(AUDIT_ARCH_I386, - regs->orig_ax, - regs->bx, regs->cx, - regs->dx, regs->si); - } else { - audit_syscall_entry(AUDIT_ARCH_X86_64, - regs->orig_ax, - regs->di, regs->si, - regs->dx, regs->r10); - } - } -} - -asmlinkage void syscall_trace_leave(struct pt_regs *regs) -{ - if (unlikely(current->audit_context)) - audit_syscall_exit(AUDITSC_RESULT(regs->ax), regs->ax); - - if ((test_thread_flag(TIF_SYSCALL_TRACE) - || test_thread_flag(TIF_SINGLESTEP)) - && (current->ptrace & PT_PTRACED)) - syscall_trace(regs); -} |