1 /* 2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) 3 * Licensed under the GPL 4 */ 5 6 #include "linux/audit.h" 7 #include "linux/ptrace.h" 8 #include "linux/sched.h" 9 #include "asm/uaccess.h" 10 #include "skas_ptrace.h" 11 12 13 14 void user_enable_single_step(struct task_struct *child) 15 { 16 child->ptrace |= PT_DTRACE; 17 child->thread.singlestep_syscall = 0; 18 19 #ifdef SUBARCH_SET_SINGLESTEPPING 20 SUBARCH_SET_SINGLESTEPPING(child, 1); 21 #endif 22 } 23 24 void user_disable_single_step(struct task_struct *child) 25 { 26 child->ptrace &= ~PT_DTRACE; 27 child->thread.singlestep_syscall = 0; 28 29 #ifdef SUBARCH_SET_SINGLESTEPPING 30 SUBARCH_SET_SINGLESTEPPING(child, 0); 31 #endif 32 } 33 34 /* 35 * Called by kernel/ptrace.c when detaching.. 36 */ 37 void ptrace_disable(struct task_struct *child) 38 { 39 user_disable_single_step(child); 40 } 41 42 extern int peek_user(struct task_struct * child, long addr, long data); 43 extern int poke_user(struct task_struct * child, long addr, long data); 44 45 long arch_ptrace(struct task_struct *child, long request, long addr, long data) 46 { 47 int i, ret; 48 unsigned long __user *p = (void __user *)(unsigned long)data; 49 50 switch (request) { 51 /* read word at location addr. */ 52 case PTRACE_PEEKTEXT: 53 case PTRACE_PEEKDATA: 54 ret = generic_ptrace_peekdata(child, addr, data); 55 break; 56 57 /* read the word at location addr in the USER area. */ 58 case PTRACE_PEEKUSR: 59 ret = peek_user(child, addr, data); 60 break; 61 62 /* write the word at location addr. */ 63 case PTRACE_POKETEXT: 64 case PTRACE_POKEDATA: 65 ret = generic_ptrace_pokedata(child, addr, data); 66 break; 67 68 /* write the word at location addr in the USER area */ 69 case PTRACE_POKEUSR: 70 ret = poke_user(child, addr, data); 71 break; 72 73 case PTRACE_SYSEMU: 74 case PTRACE_SYSEMU_SINGLESTEP: 75 ret = -EIO; 76 break; 77 78 #ifdef PTRACE_GETREGS 79 case PTRACE_GETREGS: { /* Get all gp regs from the child. */ 80 if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) { 81 ret = -EIO; 82 break; 83 } 84 for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { 85 __put_user(getreg(child, i), p); 86 p++; 87 } 88 ret = 0; 89 break; 90 } 91 #endif 92 #ifdef PTRACE_SETREGS 93 case PTRACE_SETREGS: { /* Set all gp regs in the child. */ 94 unsigned long tmp = 0; 95 if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) { 96 ret = -EIO; 97 break; 98 } 99 for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { 100 __get_user(tmp, p); 101 putreg(child, i, tmp); 102 p++; 103 } 104 ret = 0; 105 break; 106 } 107 #endif 108 #ifdef PTRACE_GETFPREGS 109 case PTRACE_GETFPREGS: /* Get the child FPU state. */ 110 ret = get_fpregs((struct user_i387_struct __user *) data, 111 child); 112 break; 113 #endif 114 #ifdef PTRACE_SETFPREGS 115 case PTRACE_SETFPREGS: /* Set the child FPU state. */ 116 ret = set_fpregs((struct user_i387_struct __user *) data, 117 child); 118 break; 119 #endif 120 case PTRACE_GET_THREAD_AREA: 121 ret = ptrace_get_thread_area(child, addr, 122 (struct user_desc __user *) data); 123 break; 124 125 case PTRACE_SET_THREAD_AREA: 126 ret = ptrace_set_thread_area(child, addr, 127 (struct user_desc __user *) data); 128 break; 129 130 case PTRACE_FAULTINFO: { 131 /* 132 * Take the info from thread->arch->faultinfo, 133 * but transfer max. sizeof(struct ptrace_faultinfo). 134 * On i386, ptrace_faultinfo is smaller! 135 */ 136 ret = copy_to_user(p, &child->thread.arch.faultinfo, 137 sizeof(struct ptrace_faultinfo)); 138 break; 139 } 140 141 #ifdef PTRACE_LDT 142 case PTRACE_LDT: { 143 struct ptrace_ldt ldt; 144 145 if (copy_from_user(&ldt, p, sizeof(ldt))) { 146 ret = -EIO; 147 break; 148 } 149 150 /* 151 * This one is confusing, so just punt and return -EIO for 152 * now 153 */ 154 ret = -EIO; 155 break; 156 } 157 #endif 158 #ifdef PTRACE_ARCH_PRCTL 159 case PTRACE_ARCH_PRCTL: 160 /* XXX Calls ptrace on the host - needs some SMP thinking */ 161 ret = arch_prctl(child, data, (void *) addr); 162 break; 163 #endif 164 default: 165 ret = ptrace_request(child, request, addr, data); 166 if (ret == -EIO) 167 ret = subarch_ptrace(child, request, addr, data); 168 break; 169 } 170 171 return ret; 172 } 173 174 static void send_sigtrap(struct task_struct *tsk, struct uml_pt_regs *regs, 175 int error_code) 176 { 177 struct siginfo info; 178 179 memset(&info, 0, sizeof(info)); 180 info.si_signo = SIGTRAP; 181 info.si_code = TRAP_BRKPT; 182 183 /* User-mode eip? */ 184 info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL; 185 186 /* Send us the fake SIGTRAP */ 187 force_sig_info(SIGTRAP, &info, tsk); 188 } 189 190 /* 191 * XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and 192 * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check 193 */ 194 void syscall_trace(struct uml_pt_regs *regs, int entryexit) 195 { 196 int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit; 197 int tracesysgood; 198 199 if (unlikely(current->audit_context)) { 200 if (!entryexit) 201 audit_syscall_entry(HOST_AUDIT_ARCH, 202 UPT_SYSCALL_NR(regs), 203 UPT_SYSCALL_ARG1(regs), 204 UPT_SYSCALL_ARG2(regs), 205 UPT_SYSCALL_ARG3(regs), 206 UPT_SYSCALL_ARG4(regs)); 207 else audit_syscall_exit(AUDITSC_RESULT(UPT_SYSCALL_RET(regs)), 208 UPT_SYSCALL_RET(regs)); 209 } 210 211 /* Fake a debug trap */ 212 if (is_singlestep) 213 send_sigtrap(current, regs, 0); 214 215 if (!test_thread_flag(TIF_SYSCALL_TRACE)) 216 return; 217 218 if (!(current->ptrace & PT_PTRACED)) 219 return; 220 221 /* 222 * the 0x80 provides a way for the tracing parent to distinguish 223 * between a syscall stop and SIGTRAP delivery 224 */ 225 tracesysgood = (current->ptrace & PT_TRACESYSGOOD); 226 ptrace_notify(SIGTRAP | (tracesysgood ? 0x80 : 0)); 227 228 if (entryexit) /* force do_signal() --> is_syscall() */ 229 set_thread_flag(TIF_SIGPENDING); 230 231 /* 232 * this isn't the same as continuing with a signal, but it will do 233 * for normal use. strace only continues with a signal if the 234 * stopping signal is not SIGTRAP. -brl 235 */ 236 if (current->exit_code) { 237 send_sig(current->exit_code, current, 1); 238 current->exit_code = 0; 239 } 240 } 241