| /* ptrace.c */ |
| /* By Ross Biro 1/23/92 */ |
| /* |
| * Pentium III FXSR, SSE support |
| * Gareth Hughes <gareth@valinux.com>, May 2000 |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/sched.h> |
| #include <linux/mm.h> |
| #include <linux/smp.h> |
| #include <linux/smp_lock.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/i387.h> |
| #include <asm/debugreg.h> |
| #include <asm/ldt.h> |
| #include <asm/desc.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 */ |
| #define FLAG_MASK 0x00044dd5 |
| |
| /* set's the trap flag. */ |
| #define TRAP_FLAG 0x100 |
| |
| /* |
| * Offset of eflags on child stack.. |
| */ |
| #define EFL_OFFSET ((EFL-2)*4-sizeof(struct pt_regs)) |
| |
| static inline struct pt_regs *get_child_regs(struct task_struct *task) |
| { |
| void *stack_top = (void *)task->thread.esp0; |
| return stack_top - sizeof(struct pt_regs); |
| } |
| |
| /* |
| * this routine will get a word off of the processes privileged stack. |
| * the offset is how far from the base addr as stored in the TSS. |
| * this routine assumes that all the privileged stacks are in our |
| * data space. |
| */ |
| static inline int get_stack_long(struct task_struct *task, int offset) |
| { |
| unsigned char *stack; |
| |
| stack = (unsigned char *)task->thread.esp0; |
| stack += offset; |
| return (*((int *)stack)); |
| } |
| |
| /* |
| * this routine will put a word on the processes privileged stack. |
| * the offset is how far from the base addr as stored in the TSS. |
| * this routine assumes that all the privileged stacks are in our |
| * data space. |
| */ |
| static inline int put_stack_long(struct task_struct *task, int offset, |
| unsigned long data) |
| { |
| unsigned char * stack; |
| |
| stack = (unsigned char *) task->thread.esp0; |
| stack += offset; |
| *(unsigned long *) stack = data; |
| return 0; |
| } |
| |
| static int putreg(struct task_struct *child, |
| unsigned long regno, unsigned long value) |
| { |
| switch (regno >> 2) { |
| case FS: |
| if (value && (value & 3) != 3) |
| return -EIO; |
| child->thread.fs = value; |
| return 0; |
| case GS: |
| if (value && (value & 3) != 3) |
| return -EIO; |
| child->thread.gs = value; |
| return 0; |
| case DS: |
| case ES: |
| if (value && (value & 3) != 3) |
| return -EIO; |
| value &= 0xffff; |
| break; |
| case SS: |
| case CS: |
| if ((value & 3) != 3) |
| return -EIO; |
| value &= 0xffff; |
| break; |
| case EFL: |
| value &= FLAG_MASK; |
| value |= get_stack_long(child, EFL_OFFSET) & ~FLAG_MASK; |
| break; |
| } |
| if (regno > GS*4) |
| regno -= 2*4; |
| put_stack_long(child, regno - sizeof(struct pt_regs), value); |
| return 0; |
| } |
| |
| static unsigned long getreg(struct task_struct *child, |
| unsigned long regno) |
| { |
| unsigned long retval = ~0UL; |
| |
| switch (regno >> 2) { |
| case FS: |
| retval = child->thread.fs; |
| break; |
| case GS: |
| retval = child->thread.gs; |
| break; |
| case DS: |
| case ES: |
| case SS: |
| case CS: |
| retval = 0xffff; |
| /* fall through */ |
| default: |
| if (regno > GS*4) |
| regno -= 2*4; |
| regno = regno - sizeof(struct pt_regs); |
| retval &= get_stack_long(child, regno); |
| } |
| return retval; |
| } |
| |
| #define LDT_SEGMENT 4 |
| |
| static unsigned long convert_eip_to_linear(struct task_struct *child, struct pt_regs *regs) |
| { |
| unsigned long addr, seg; |
| |
| addr = regs->eip; |
| seg = regs->xcs & 0xffff; |
| if (regs->eflags & VM_MASK) { |
| addr = (addr & 0xffff) + (seg << 4); |
| return addr; |
| } |
| |
| /* |
| * We'll assume that the code segments in the GDT |
| * are all zero-based. That is largely true: the |
| * TLS segments are used for data, and the PNPBIOS |
| * and APM bios ones we just ignore here. |
| */ |
| if (seg & LDT_SEGMENT) { |
| u32 *desc; |
| unsigned long base; |
| |
| down(&child->mm->context.sem); |
| desc = child->mm->context.ldt + (seg & ~7); |
| base = (desc[0] >> 16) | ((desc[1] & 0xff) << 16) | (desc[1] & 0xff000000); |
| |
| /* 16-bit code segment? */ |
| if (!((desc[1] >> 22) & 1)) |
| addr &= 0xffff; |
| addr += base; |
| up(&child->mm->context.sem); |
| } |
| return addr; |
| } |
| |
| static inline int is_at_popf(struct task_struct *child, struct pt_regs *regs) |
| { |
| int i, copied; |
| unsigned char opcode[16]; |
| unsigned long addr = convert_eip_to_linear(child, regs); |
| |
| copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0); |
| for (i = 0; i < copied; i++) { |
| switch (opcode[i]) { |
| /* popf */ |
| case 0x9d: |
| return 1; |
| /* opcode and address size prefixes */ |
| case 0x66: case 0x67: |
| continue; |
| /* irrelevant prefixes (segment overrides and repeats) */ |
| case 0x26: case 0x2e: |
| case 0x36: case 0x3e: |
| case 0x64: case 0x65: |
| case 0xf0: case 0xf2: case 0xf3: |
| continue; |
| |
| /* |
| * pushf: NOTE! We should probably not let |
| * the user see the TF bit being set. But |
| * it's more pain than it's worth to avoid |
| * it, and a debugger could emulate this |
| * all in user space if it _really_ cares. |
| */ |
| case 0x9c: |
| default: |
| return 0; |
| } |
| } |
| return 0; |
| } |
| |
| static void set_singlestep(struct task_struct *child) |
| { |
| struct pt_regs *regs = get_child_regs(child); |
| |
| /* |
| * Always set TIF_SINGLESTEP - this guarantees that |
| * we single-step system calls etc.. This will also |
| * cause us to set TF when returning to user mode. |
| */ |
| set_tsk_thread_flag(child, TIF_SINGLESTEP); |
| |
| /* |
| * If TF was already set, don't do anything else |
| */ |
| if (regs->eflags & TRAP_FLAG) |
| return; |
| |
| /* Set TF on the kernel stack.. */ |
| regs->eflags |= TRAP_FLAG; |
| |
| /* |
| * ..but if TF is changed by the instruction we will trace, |
| * don't mark it as being "us" that set it, so that we |
| * won't clear it by hand later. |
| */ |
| if (is_at_popf(child, regs)) |
| return; |
| |
| child->ptrace |= PT_DTRACE; |
| } |
| |
| static void clear_singlestep(struct task_struct *child) |
| { |
| /* Always clear TIF_SINGLESTEP... */ |
| clear_tsk_thread_flag(child, TIF_SINGLESTEP); |
| |
| /* But touch TF only if it was set by us.. */ |
| if (child->ptrace & PT_DTRACE) { |
| struct pt_regs *regs = get_child_regs(child); |
| regs->eflags &= ~TRAP_FLAG; |
| child->ptrace &= ~PT_DTRACE; |
| } |
| } |
| |
| /* |
| * Called by kernel/ptrace.c when detaching.. |
| * |
| * Make sure the single step bit is not set. |
| */ |
| void ptrace_disable(struct task_struct *child) |
| { |
| clear_singlestep(child); |
| clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
| clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
| } |
| |
| /* |
| * Perform get_thread_area on behalf of the traced child. |
| */ |
| static int |
| ptrace_get_thread_area(struct task_struct *child, |
| int idx, struct user_desc __user *user_desc) |
| { |
| struct user_desc info; |
| struct desc_struct *desc; |
| |
| /* |
| * Get the current Thread-Local Storage area: |
| */ |
| |
| #define GET_BASE(desc) ( \ |
| (((desc)->a >> 16) & 0x0000ffff) | \ |
| (((desc)->b << 16) & 0x00ff0000) | \ |
| ( (desc)->b & 0xff000000) ) |
| |
| #define GET_LIMIT(desc) ( \ |
| ((desc)->a & 0x0ffff) | \ |
| ((desc)->b & 0xf0000) ) |
| |
| #define GET_32BIT(desc) (((desc)->b >> 22) & 1) |
| #define GET_CONTENTS(desc) (((desc)->b >> 10) & 3) |
| #define GET_WRITABLE(desc) (((desc)->b >> 9) & 1) |
| #define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1) |
| #define GET_PRESENT(desc) (((desc)->b >> 15) & 1) |
| #define GET_USEABLE(desc) (((desc)->b >> 20) & 1) |
| |
| if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) |
| return -EINVAL; |
| |
| desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN; |
| |
| info.entry_number = idx; |
| info.base_addr = GET_BASE(desc); |
| info.limit = GET_LIMIT(desc); |
| info.seg_32bit = GET_32BIT(desc); |
| info.contents = GET_CONTENTS(desc); |
| info.read_exec_only = !GET_WRITABLE(desc); |
| info.limit_in_pages = GET_LIMIT_PAGES(desc); |
| info.seg_not_present = !GET_PRESENT(desc); |
| info.useable = GET_USEABLE(desc); |
| |
| if (copy_to_user(user_desc, &info, sizeof(info))) |
| return -EFAULT; |
| |
| return 0; |
| } |
| |
| /* |
| * Perform set_thread_area on behalf of the traced child. |
| */ |
| static int |
| ptrace_set_thread_area(struct task_struct *child, |
| int idx, struct user_desc __user *user_desc) |
| { |
| struct user_desc info; |
| struct desc_struct *desc; |
| |
| if (copy_from_user(&info, user_desc, sizeof(info))) |
| return -EFAULT; |
| |
| if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) |
| return -EINVAL; |
| |
| desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN; |
| if (LDT_empty(&info)) { |
| desc->a = 0; |
| desc->b = 0; |
| } else { |
| desc->a = LDT_entry_a(&info); |
| desc->b = LDT_entry_b(&info); |
| } |
| |
| return 0; |
| } |
| |
| asmlinkage int sys_ptrace(long request, long pid, long addr, long data) |
| { |
| struct task_struct *child; |
| struct user * dummy = NULL; |
| int i, ret; |
| unsigned long __user *datap = (unsigned long __user *)data; |
| |
| lock_kernel(); |
| ret = -EPERM; |
| if (request == PTRACE_TRACEME) { |
| /* are we already being traced? */ |
| if (current->ptrace & PT_PTRACED) |
| goto out; |
| ret = security_ptrace(current->parent, current); |
| if (ret) |
| goto out; |
| /* set the ptrace bit in the process flags. */ |
| current->ptrace |= PT_PTRACED; |
| ret = 0; |
| goto out; |
| } |
| ret = -ESRCH; |
| read_lock(&tasklist_lock); |
| child = find_task_by_pid(pid); |
| if (child) |
| get_task_struct(child); |
| read_unlock(&tasklist_lock); |
| if (!child) |
| goto out; |
| |
| ret = -EPERM; |
| if (pid == 1) /* you may not mess with init */ |
| goto out_tsk; |
| |
| if (request == PTRACE_ATTACH) { |
| ret = ptrace_attach(child); |
| goto out_tsk; |
| } |
| |
| ret = ptrace_check_attach(child, request == PTRACE_KILL); |
| if (ret < 0) |
| goto out_tsk; |
| |
| 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: { |
| unsigned long tmp; |
| int copied; |
| |
| copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); |
| ret = -EIO; |
| if (copied != sizeof(tmp)) |
| break; |
| ret = put_user(tmp, datap); |
| break; |
| } |
| |
| /* read the word at location addr in the USER area. */ |
| case PTRACE_PEEKUSR: { |
| unsigned long tmp; |
| |
| ret = -EIO; |
| if ((addr & 3) || addr < 0 || |
| addr > sizeof(struct user) - 3) |
| break; |
| |
| tmp = 0; /* Default return condition */ |
| if(addr < FRAME_SIZE*sizeof(long)) |
| tmp = getreg(child, addr); |
| if(addr >= (long) &dummy->u_debugreg[0] && |
| addr <= (long) &dummy->u_debugreg[7]){ |
| addr -= (long) &dummy->u_debugreg[0]; |
| addr = addr >> 2; |
| tmp = child->thread.debugreg[addr]; |
| } |
| ret = put_user(tmp, datap); |
| 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 = 0; |
| if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data)) |
| break; |
| ret = -EIO; |
| break; |
| |
| case PTRACE_POKEUSR: /* write the word at location addr in the USER area */ |
| ret = -EIO; |
| if ((addr & 3) || addr < 0 || |
| addr > sizeof(struct user) - 3) |
| break; |
| |
| if (addr < FRAME_SIZE*sizeof(long)) { |
| ret = putreg(child, addr, data); |
| break; |
| } |
| /* We need to be very careful here. We implicitly |
| want to modify a portion of the task_struct, and we |
| have to be selective about what portions we allow someone |
| to modify. */ |
| |
| ret = -EIO; |
| if(addr >= (long) &dummy->u_debugreg[0] && |
| addr <= (long) &dummy->u_debugreg[7]){ |
| |
| if(addr == (long) &dummy->u_debugreg[4]) break; |
| if(addr == (long) &dummy->u_debugreg[5]) break; |
| if(addr < (long) &dummy->u_debugreg[4] && |
| ((unsigned long) data) >= TASK_SIZE-3) break; |
| |
| /* Sanity-check data. Take one half-byte at once with |
| * check = (val >> (16 + 4*i)) & 0xf. It contains the |
| * R/Wi and LENi bits; bits 0 and 1 are R/Wi, and bits |
| * 2 and 3 are LENi. Given a list of invalid values, |
| * we do mask |= 1 << invalid_value, so that |
| * (mask >> check) & 1 is a correct test for invalid |
| * values. |
| * |
| * R/Wi contains the type of the breakpoint / |
| * watchpoint, LENi contains the length of the watched |
| * data in the watchpoint case. |
| * |
| * The invalid values are: |
| * - LENi == 0x10 (undefined), so mask |= 0x0f00. |
| * - R/Wi == 0x10 (break on I/O reads or writes), so |
| * mask |= 0x4444. |
| * - R/Wi == 0x00 && LENi != 0x00, so we have mask |= |
| * 0x1110. |
| * |
| * Finally, mask = 0x0f00 | 0x4444 | 0x1110 == 0x5f54. |
| * |
| * See the Intel Manual "System Programming Guide", |
| * 15.2.4 |
| * |
| * Note that LENi == 0x10 is defined on x86_64 in long |
| * mode (i.e. even for 32-bit userspace software, but |
| * 64-bit kernel), so the x86_64 mask value is 0x5454. |
| * See the AMD manual no. 24593 (AMD64 System |
| * Programming)*/ |
| |
| if(addr == (long) &dummy->u_debugreg[7]) { |
| data &= ~DR_CONTROL_RESERVED; |
| for(i=0; i<4; i++) |
| if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1) |
| goto out_tsk; |
| } |
| |
| addr -= (long) &dummy->u_debugreg; |
| addr = addr >> 2; |
| child->thread.debugreg[addr] = data; |
| ret = 0; |
| } |
| break; |
| |
| case PTRACE_SYSEMU: /* continue and stop at next syscall, which will not be executed */ |
| case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ |
| case PTRACE_CONT: /* restart after signal. */ |
| ret = -EIO; |
| if (!valid_signal(data)) |
| break; |
| if (request == PTRACE_SYSEMU) { |
| set_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
| clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
| } else if (request == PTRACE_SYSCALL) { |
| set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
| clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
| } else { |
| clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
| clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
| } |
| child->exit_code = data; |
| /* make sure the single step bit is not set. */ |
| clear_singlestep(child); |
| wake_up_process(child); |
| ret = 0; |
| break; |
| |
| /* |
| * make the child exit. Best I can do is send it a sigkill. |
| * perhaps it should be put in the status that it wants to |
| * exit. |
| */ |
| case PTRACE_KILL: |
| ret = 0; |
| if (child->exit_state == EXIT_ZOMBIE) /* already dead */ |
| break; |
| child->exit_code = SIGKILL; |
| /* make sure the single step bit is not set. */ |
| clear_singlestep(child); |
| wake_up_process(child); |
| break; |
| |
| case PTRACE_SYSEMU_SINGLESTEP: /* Same as SYSEMU, but singlestep if not syscall */ |
| case PTRACE_SINGLESTEP: /* set the trap flag. */ |
| ret = -EIO; |
| if (!valid_signal(data)) |
| break; |
| |
| if (request == PTRACE_SYSEMU_SINGLESTEP) |
| set_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
| else |
| clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
| |
| clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
| set_singlestep(child); |
| child->exit_code = data; |
| /* give it a chance to run. */ |
| wake_up_process(child); |
| ret = 0; |
| break; |
| |
| case PTRACE_DETACH: |
| /* detach a process that was attached. */ |
| ret = ptrace_detach(child, data); |
| break; |
| |
| case PTRACE_GETREGS: { /* Get all gp regs from the child. */ |
| if (!access_ok(VERIFY_WRITE, datap, FRAME_SIZE*sizeof(long))) { |
| ret = -EIO; |
| break; |
| } |
| for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) { |
| __put_user(getreg(child, i), datap); |
| datap++; |
| } |
| ret = 0; |
| break; |
| } |
| |
| case PTRACE_SETREGS: { /* Set all gp regs in the child. */ |
| unsigned long tmp; |
| if (!access_ok(VERIFY_READ, datap, FRAME_SIZE*sizeof(long))) { |
| ret = -EIO; |
| break; |
| } |
| for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) { |
| __get_user(tmp, datap); |
| putreg(child, i, tmp); |
| datap++; |
| } |
| ret = 0; |
| break; |
| } |
| |
| case PTRACE_GETFPREGS: { /* Get the child FPU state. */ |
| if (!access_ok(VERIFY_WRITE, datap, |
| sizeof(struct user_i387_struct))) { |
| ret = -EIO; |
| break; |
| } |
| ret = 0; |
| if (!tsk_used_math(child)) |
| init_fpu(child); |
| get_fpregs((struct user_i387_struct __user *)data, child); |
| break; |
| } |
| |
| case PTRACE_SETFPREGS: { /* Set the child FPU state. */ |
| if (!access_ok(VERIFY_READ, datap, |
| sizeof(struct user_i387_struct))) { |
| ret = -EIO; |
| break; |
| } |
| set_stopped_child_used_math(child); |
| set_fpregs(child, (struct user_i387_struct __user *)data); |
| ret = 0; |
| break; |
| } |
| |
| case PTRACE_GETFPXREGS: { /* Get the child extended FPU state. */ |
| if (!access_ok(VERIFY_WRITE, datap, |
| sizeof(struct user_fxsr_struct))) { |
| ret = -EIO; |
| break; |
| } |
| if (!tsk_used_math(child)) |
| init_fpu(child); |
| ret = get_fpxregs((struct user_fxsr_struct __user *)data, child); |
| break; |
| } |
| |
| case PTRACE_SETFPXREGS: { /* Set the child extended FPU state. */ |
| if (!access_ok(VERIFY_READ, datap, |
| sizeof(struct user_fxsr_struct))) { |
| ret = -EIO; |
| break; |
| } |
| set_stopped_child_used_math(child); |
| ret = set_fpxregs(child, (struct user_fxsr_struct __user *)data); |
| break; |
| } |
| |
| case PTRACE_GET_THREAD_AREA: |
| ret = ptrace_get_thread_area(child, addr, |
| (struct user_desc __user *) data); |
| break; |
| |
| case PTRACE_SET_THREAD_AREA: |
| ret = ptrace_set_thread_area(child, addr, |
| (struct user_desc __user *) data); |
| break; |
| |
| default: |
| ret = ptrace_request(child, request, addr, data); |
| break; |
| } |
| out_tsk: |
| put_task_struct(child); |
| out: |
| unlock_kernel(); |
| return ret; |
| } |
| |
| void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code) |
| { |
| struct siginfo info; |
| |
| tsk->thread.trap_no = 1; |
| tsk->thread.error_code = error_code; |
| |
| memset(&info, 0, sizeof(info)); |
| info.si_signo = SIGTRAP; |
| info.si_code = TRAP_BRKPT; |
| |
| /* User-mode eip? */ |
| info.si_addr = user_mode_vm(regs) ? (void __user *) regs->eip : NULL; |
| |
| /* Send us the fakey SIGTRAP */ |
| force_sig_info(SIGTRAP, &info, tsk); |
| } |
| |
| /* notification of system call entry/exit |
| * - triggered by current->work.syscall_trace |
| */ |
| __attribute__((regparm(3))) |
| int do_syscall_trace(struct pt_regs *regs, int entryexit) |
| { |
| int is_sysemu = test_thread_flag(TIF_SYSCALL_EMU), ret = 0; |
| /* With TIF_SYSCALL_EMU set we want to ignore TIF_SINGLESTEP for syscall |
| * interception. */ |
| int is_singlestep = !is_sysemu && test_thread_flag(TIF_SINGLESTEP); |
| |
| /* do the secure computing check first */ |
| secure_computing(regs->orig_eax); |
| |
| if (unlikely(current->audit_context)) { |
| if (entryexit) |
| audit_syscall_exit(current, AUDITSC_RESULT(regs->eax), regs->eax); |
| /* Debug traps, when using PTRACE_SINGLESTEP, must be sent only |
| * on the syscall exit path. Normally, when TIF_SYSCALL_AUDIT is |
| * not used, entry.S will call us only on syscall exit, not |
| * entry; so when TIF_SYSCALL_AUDIT is used we must avoid |
| * calling send_sigtrap() on syscall entry. |
| * |
| * Note that when PTRACE_SYSEMU_SINGLESTEP is used, |
| * is_singlestep is false, despite his name, so we will still do |
| * the correct thing. |
| */ |
| else if (is_singlestep) |
| goto out; |
| } |
| |
| if (!(current->ptrace & PT_PTRACED)) |
| goto out; |
| |
| /* If a process stops on the 1st tracepoint with SYSCALL_TRACE |
| * and then is resumed with SYSEMU_SINGLESTEP, it will come in |
| * here. We have to check this and return */ |
| if (is_sysemu && entryexit) |
| return 0; |
| |
| /* Fake a debug trap */ |
| if (is_singlestep) |
| send_sigtrap(current, regs, 0); |
| |
| if (!test_thread_flag(TIF_SYSCALL_TRACE) && !is_sysemu) |
| goto out; |
| |
| /* the 0x80 provides a way for the tracing parent to distinguish |
| between a syscall stop and SIGTRAP delivery */ |
| /* Note that the debugger could change the result of test_thread_flag!*/ |
| 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; |
| } |
| ret = is_sysemu; |
| out: |
| if (unlikely(current->audit_context) && !entryexit) |
| audit_syscall_entry(current, AUDIT_ARCH_I386, regs->orig_eax, |
| regs->ebx, regs->ecx, regs->edx, regs->esi); |
| if (ret == 0) |
| return 0; |
| |
| regs->orig_eax = -1; /* force skip of syscall restarting */ |
| if (unlikely(current->audit_context)) |
| audit_syscall_exit(current, AUDITSC_RESULT(regs->eax), regs->eax); |
| return 1; |
| } |