1 // TODO some minor issues 2 /* 3 * This file is subject to the terms and conditions of the GNU General Public 4 * License. See the file "COPYING" in the main directory of this archive 5 * for more details. 6 * 7 * Copyright (C) 2001 - 2005 Tensilica Inc. 8 * 9 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com> 10 * Chris Zankel <chris@zankel.net> 11 * Scott Foehner<sfoehner@yahoo.com>, 12 * Kevin Chea 13 * Marc Gauthier<marc@tensilica.com> <marc@alumni.uwaterloo.ca> 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/sched.h> 18 #include <linux/mm.h> 19 #include <linux/errno.h> 20 #include <linux/ptrace.h> 21 #include <linux/smp.h> 22 #include <linux/smp_lock.h> 23 #include <linux/security.h> 24 #include <linux/signal.h> 25 26 #include <asm/pgtable.h> 27 #include <asm/page.h> 28 #include <asm/system.h> 29 #include <asm/uaccess.h> 30 #include <asm/ptrace.h> 31 #include <asm/elf.h> 32 33 #define TEST_KERNEL // verify kernel operations FIXME: remove 34 35 36 /* 37 * Called by kernel/ptrace.c when detaching.. 38 * 39 * Make sure single step bits etc are not set. 40 */ 41 42 void ptrace_disable(struct task_struct *child) 43 { 44 /* Nothing to do.. */ 45 } 46 47 long arch_ptrace(struct task_struct *child, long request, long addr, long data) 48 { 49 int ret = -EPERM; 50 51 switch (request) { 52 case PTRACE_PEEKTEXT: /* read word at location addr. */ 53 case PTRACE_PEEKDATA: 54 { 55 unsigned long tmp; 56 int copied; 57 58 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); 59 ret = -EIO; 60 if (copied != sizeof(tmp)) 61 break; 62 ret = put_user(tmp,(unsigned long *) data); 63 64 goto out; 65 } 66 67 /* Read the word at location addr in the USER area. */ 68 69 case PTRACE_PEEKUSR: 70 { 71 struct pt_regs *regs; 72 unsigned long tmp; 73 74 regs = task_pt_regs(child); 75 tmp = 0; /* Default return value. */ 76 77 switch(addr) { 78 79 case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1: 80 { 81 int ar = addr - REG_AR_BASE - regs->windowbase * 4; 82 ar &= (XCHAL_NUM_AREGS - 1); 83 if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0) 84 tmp = regs->areg[ar]; 85 else 86 ret = -EIO; 87 break; 88 } 89 case REG_A_BASE ... REG_A_BASE + 15: 90 tmp = regs->areg[addr - REG_A_BASE]; 91 break; 92 case REG_PC: 93 tmp = regs->pc; 94 break; 95 case REG_PS: 96 /* Note: PS.EXCM is not set while user task is running; 97 * its being set in regs is for exception handling 98 * convenience. */ 99 tmp = (regs->ps & ~XCHAL_PS_EXCM_MASK); 100 break; 101 case REG_WB: 102 tmp = regs->windowbase; 103 break; 104 case REG_WS: 105 tmp = regs->windowstart; 106 break; 107 case REG_LBEG: 108 tmp = regs->lbeg; 109 break; 110 case REG_LEND: 111 tmp = regs->lend; 112 break; 113 case REG_LCOUNT: 114 tmp = regs->lcount; 115 break; 116 case REG_SAR: 117 tmp = regs->sar; 118 break; 119 case REG_DEPC: 120 tmp = regs->depc; 121 break; 122 case REG_EXCCAUSE: 123 tmp = regs->exccause; 124 break; 125 case REG_EXCVADDR: 126 tmp = regs->excvaddr; 127 break; 128 case SYSCALL_NR: 129 tmp = regs->syscall; 130 break; 131 default: 132 tmp = 0; 133 ret = -EIO; 134 goto out; 135 } 136 ret = put_user(tmp, (unsigned long *) data); 137 goto out; 138 } 139 140 case PTRACE_POKETEXT: /* write the word at location addr. */ 141 case PTRACE_POKEDATA: 142 if (access_process_vm(child, addr, &data, sizeof(data), 1) 143 == sizeof(data)) 144 break; 145 ret = -EIO; 146 goto out; 147 148 case PTRACE_POKEUSR: 149 { 150 struct pt_regs *regs; 151 regs = task_pt_regs(child); 152 153 switch (addr) { 154 case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1: 155 { 156 int ar = addr - REG_AR_BASE - regs->windowbase * 4; 157 if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0) 158 regs->areg[ar & (XCHAL_NUM_AREGS - 1)] = data; 159 else 160 ret = -EIO; 161 break; 162 } 163 case REG_A_BASE ... REG_A_BASE + 15: 164 regs->areg[addr - REG_A_BASE] = data; 165 break; 166 case REG_PC: 167 regs->pc = data; 168 break; 169 case SYSCALL_NR: 170 regs->syscall = data; 171 break; 172 #ifdef TEST_KERNEL 173 case REG_WB: 174 regs->windowbase = data; 175 break; 176 case REG_WS: 177 regs->windowstart = data; 178 break; 179 #endif 180 181 default: 182 /* The rest are not allowed. */ 183 ret = -EIO; 184 break; 185 } 186 break; 187 } 188 189 /* continue and stop at next (return from) syscall */ 190 case PTRACE_SYSCALL: 191 case PTRACE_CONT: /* restart after signal. */ 192 { 193 ret = -EIO; 194 if (!valid_signal(data)) 195 break; 196 if (request == PTRACE_SYSCALL) 197 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 198 else 199 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 200 child->exit_code = data; 201 /* Make sure the single step bit is not set. */ 202 child->ptrace &= ~PT_SINGLESTEP; 203 wake_up_process(child); 204 ret = 0; 205 break; 206 } 207 208 /* 209 * make the child exit. Best I can do is send it a sigkill. 210 * perhaps it should be put in the status that it wants to 211 * exit. 212 */ 213 case PTRACE_KILL: 214 ret = 0; 215 if (child->state == EXIT_ZOMBIE) /* already dead */ 216 break; 217 child->exit_code = SIGKILL; 218 child->ptrace &= ~PT_SINGLESTEP; 219 wake_up_process(child); 220 break; 221 222 case PTRACE_SINGLESTEP: 223 ret = -EIO; 224 if (!valid_signal(data)) 225 break; 226 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 227 child->ptrace |= PT_SINGLESTEP; 228 child->exit_code = data; 229 wake_up_process(child); 230 ret = 0; 231 break; 232 233 case PTRACE_GETREGS: 234 { 235 /* 'data' points to user memory in which to write. 236 * Mainly due to the non-live register values, we 237 * reformat the register values into something more 238 * standard. For convenience, we use the handy 239 * elf_gregset_t format. */ 240 241 xtensa_gregset_t format; 242 struct pt_regs *regs = task_pt_regs(child); 243 244 do_copy_regs (&format, regs, child); 245 246 /* Now, copy to user space nice and easy... */ 247 ret = 0; 248 if (copy_to_user((void *)data, &format, sizeof(elf_gregset_t))) 249 ret = -EFAULT; 250 break; 251 } 252 253 case PTRACE_SETREGS: 254 { 255 /* 'data' points to user memory that contains the new 256 * values in the elf_gregset_t format. */ 257 258 xtensa_gregset_t format; 259 struct pt_regs *regs = task_pt_regs(child); 260 261 if (copy_from_user(&format,(void *)data,sizeof(elf_gregset_t))){ 262 ret = -EFAULT; 263 break; 264 } 265 266 /* FIXME: Perhaps we want some sanity checks on 267 * these user-space values? See ARM version. Are 268 * debuggers a security concern? */ 269 270 do_restore_regs (&format, regs, child); 271 272 ret = 0; 273 break; 274 } 275 276 case PTRACE_GETFPREGS: 277 { 278 /* 'data' points to user memory in which to write. 279 * For convenience, we use the handy 280 * elf_fpregset_t format. */ 281 282 elf_fpregset_t fpregs; 283 struct pt_regs *regs = task_pt_regs(child); 284 285 do_save_fpregs (&fpregs, regs, child); 286 287 /* Now, copy to user space nice and easy... */ 288 ret = 0; 289 if (copy_to_user((void *)data, &fpregs, sizeof(elf_fpregset_t))) 290 ret = -EFAULT; 291 292 break; 293 } 294 295 case PTRACE_SETFPREGS: 296 { 297 /* 'data' points to user memory that contains the new 298 * values in the elf_fpregset_t format. 299 */ 300 elf_fpregset_t fpregs; 301 struct pt_regs *regs = task_pt_regs(child); 302 303 ret = 0; 304 if (copy_from_user(&fpregs, (void *)data, sizeof(elf_fpregset_t))) { 305 ret = -EFAULT; 306 break; 307 } 308 309 if (do_restore_fpregs (&fpregs, regs, child)) 310 ret = -EIO; 311 break; 312 } 313 314 case PTRACE_GETFPREGSIZE: 315 /* 'data' points to 'unsigned long' set to the size 316 * of elf_fpregset_t 317 */ 318 ret = put_user(sizeof(elf_fpregset_t), (unsigned long *) data); 319 break; 320 321 case PTRACE_DETACH: /* detach a process that was attached. */ 322 ret = ptrace_detach(child, data); 323 break; 324 325 default: 326 ret = ptrace_request(child, request, addr, data); 327 goto out; 328 } 329 out: 330 return ret; 331 } 332 333 void do_syscall_trace(void) 334 { 335 if (!test_thread_flag(TIF_SYSCALL_TRACE)) 336 return; 337 338 if (!(current->ptrace & PT_PTRACED)) 339 return; 340 341 /* 342 * The 0x80 provides a way for the tracing parent to distinguish 343 * between a syscall stop and SIGTRAP delivery 344 */ 345 ptrace_notify(SIGTRAP|((current->ptrace & PT_TRACESYSGOOD) ? 0x80 : 0)); 346 347 /* 348 * this isn't the same as continuing with a signal, but it will do 349 * for normal use. strace only continues with a signal if the 350 * stopping signal is not SIGTRAP. -brl 351 */ 352 if (current->exit_code) { 353 send_sig(current->exit_code, current, 1); 354 current->exit_code = 0; 355 } 356 } 357