1/* 2 * Copyright (C) 2004-2006 Atmel Corporation 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 */ 8#undef DEBUG 9#include <linux/kernel.h> 10#include <linux/sched.h> 11#include <linux/mm.h> 12#include <linux/ptrace.h> 13#include <linux/errno.h> 14#include <linux/user.h> 15#include <linux/security.h> 16#include <linux/unistd.h> 17#include <linux/notifier.h> 18 19#include <asm/traps.h> 20#include <asm/uaccess.h> 21#include <asm/ocd.h> 22#include <asm/mmu_context.h> 23#include <linux/kdebug.h> 24 25static struct pt_regs *get_user_regs(struct task_struct *tsk) 26{ 27 return (struct pt_regs *)((unsigned long)task_stack_page(tsk) + 28 THREAD_SIZE - sizeof(struct pt_regs)); 29} 30 31static void ptrace_single_step(struct task_struct *tsk) 32{ 33 pr_debug("ptrace_single_step: pid=%u, SR=0x%08lx\n", 34 tsk->pid, tsk->thread.cpu_context.sr); 35 if (!(tsk->thread.cpu_context.sr & SR_D)) { 36 /* 37 * Set a breakpoint at the current pc to force the 38 * process into debug mode. The syscall/exception 39 * exit code will set a breakpoint at the return 40 * address when this flag is set. 41 */ 42 pr_debug("ptrace_single_step: Setting TIF_BREAKPOINT\n"); 43 set_tsk_thread_flag(tsk, TIF_BREAKPOINT); 44 } 45 46 /* The monitor code will do the actual step for us */ 47 set_tsk_thread_flag(tsk, TIF_SINGLE_STEP); 48} 49 50/* 51 * Called by kernel/ptrace.c when detaching 52 * 53 * Make sure any single step bits, etc. are not set 54 */ 55void ptrace_disable(struct task_struct *child) 56{ 57 clear_tsk_thread_flag(child, TIF_SINGLE_STEP); 58} 59 60/* 61 * Handle hitting a breakpoint 62 */ 63static void ptrace_break(struct task_struct *tsk, struct pt_regs *regs) 64{ 65 siginfo_t info; 66 67 info.si_signo = SIGTRAP; 68 info.si_errno = 0; 69 info.si_code = TRAP_BRKPT; 70 info.si_addr = (void __user *)instruction_pointer(regs); 71 72 pr_debug("ptrace_break: Sending SIGTRAP to PID %u (pc = 0x%p)\n", 73 tsk->pid, info.si_addr); 74 force_sig_info(SIGTRAP, &info, tsk); 75} 76 77/* 78 * Read the word at offset "offset" into the task's "struct user". We 79 * actually access the pt_regs struct stored on the kernel stack. 80 */ 81static int ptrace_read_user(struct task_struct *tsk, unsigned long offset, 82 unsigned long __user *data) 83{ 84 unsigned long *regs; 85 unsigned long value; 86 87 pr_debug("ptrace_read_user(%p, %#lx, %p)\n", 88 tsk, offset, data); 89 90 if (offset & 3 || offset >= sizeof(struct user)) { 91 printk("ptrace_read_user: invalid offset 0x%08lx\n", offset); 92 return -EIO; 93 } 94 95 regs = (unsigned long *)get_user_regs(tsk); 96 97 value = 0; 98 if (offset < sizeof(struct pt_regs)) 99 value = regs[offset / sizeof(regs[0])]; 100 101 return put_user(value, data); 102} 103 104/* 105 * Write the word "value" to offset "offset" into the task's "struct 106 * user". We actually access the pt_regs struct stored on the kernel 107 * stack. 108 */ 109static int ptrace_write_user(struct task_struct *tsk, unsigned long offset, 110 unsigned long value) 111{ 112 unsigned long *regs; 113 114 if (offset & 3 || offset >= sizeof(struct user)) { 115 printk("ptrace_write_user: invalid offset 0x%08lx\n", offset); 116 return -EIO; 117 } 118 119 if (offset >= sizeof(struct pt_regs)) 120 return 0; 121 122 regs = (unsigned long *)get_user_regs(tsk); 123 regs[offset / sizeof(regs[0])] = value; 124 125 return 0; 126} 127 128static int ptrace_getregs(struct task_struct *tsk, void __user *uregs) 129{ 130 struct pt_regs *regs = get_user_regs(tsk); 131 132 return copy_to_user(uregs, regs, sizeof(*regs)) ? -EFAULT : 0; 133} 134 135static int ptrace_setregs(struct task_struct *tsk, const void __user *uregs) 136{ 137 struct pt_regs newregs; 138 int ret; 139 140 ret = -EFAULT; 141 if (copy_from_user(&newregs, uregs, sizeof(newregs)) == 0) { 142 struct pt_regs *regs = get_user_regs(tsk); 143 144 ret = -EINVAL; 145 if (valid_user_regs(&newregs)) { 146 *regs = newregs; 147 ret = 0; 148 } 149 } 150 151 return ret; 152} 153 154long arch_ptrace(struct task_struct *child, long request, long addr, long data) 155{ 156 unsigned long tmp; 157 int ret; 158 159 pr_debug("arch_ptrace(%ld, %d, %#lx, %#lx)\n", 160 request, child->pid, addr, data); 161 162 pr_debug("ptrace: Enabling monitor mode...\n"); 163 __mtdr(DBGREG_DC, __mfdr(DBGREG_DC) | DC_MM | DC_DBE); 164 165 switch (request) { 166 /* Read the word at location addr in the child process */ 167 case PTRACE_PEEKTEXT: 168 case PTRACE_PEEKDATA: 169 ret = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); 170 if (ret == sizeof(tmp)) 171 ret = put_user(tmp, (unsigned long __user *)data); 172 else 173 ret = -EIO; 174 break; 175 176 case PTRACE_PEEKUSR: 177 ret = ptrace_read_user(child, addr, 178 (unsigned long __user *)data); 179 break; 180 181 /* Write the word in data at location addr */ 182 case PTRACE_POKETEXT: 183 case PTRACE_POKEDATA: 184 ret = access_process_vm(child, addr, &data, sizeof(data), 1); 185 if (ret == sizeof(data)) 186 ret = 0; 187 else 188 ret = -EIO; 189 break; 190 191 case PTRACE_POKEUSR: 192 ret = ptrace_write_user(child, addr, data); 193 break; 194 195 /* continue and stop at next (return from) syscall */ 196 case PTRACE_SYSCALL: 197 /* restart after signal */ 198 case PTRACE_CONT: 199 ret = -EIO; 200 if (!valid_signal(data)) 201 break; 202 if (request == PTRACE_SYSCALL) 203 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 204 else 205 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 206 child->exit_code = data; 207 wake_up_process(child); 208 ret = 0; 209 break; 210 211 /* 212 * Make the child exit. Best I can do is send it a 213 * SIGKILL. Perhaps it should be put in the status that it 214 * wants to exit. 215 */ 216 case PTRACE_KILL: 217 ret = 0; 218 if (child->exit_state == EXIT_ZOMBIE) 219 break; 220 child->exit_code = SIGKILL; 221 wake_up_process(child); 222 break; 223 224 /* 225 * execute single instruction. 226 */ 227 case PTRACE_SINGLESTEP: 228 ret = -EIO; 229 if (!valid_signal(data)) 230 break; 231 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 232 ptrace_single_step(child); 233 child->exit_code = data; 234 wake_up_process(child); 235 ret = 0; 236 break; 237 238 /* Detach a process that was attached */ 239 case PTRACE_DETACH: 240 ret = ptrace_detach(child, data); 241 break; 242 243 case PTRACE_GETREGS: 244 ret = ptrace_getregs(child, (void __user *)data); 245 break; 246 247 case PTRACE_SETREGS: 248 ret = ptrace_setregs(child, (const void __user *)data); 249 break; 250 251 default: 252 ret = ptrace_request(child, request, addr, data); 253 break; 254 } 255 256 pr_debug("sys_ptrace returning %d (DC = 0x%08lx)\n", ret, __mfdr(DBGREG_DC)); 257 return ret; 258} 259 260asmlinkage void syscall_trace(void) 261{ 262 pr_debug("syscall_trace called\n"); 263 if (!test_thread_flag(TIF_SYSCALL_TRACE)) 264 return; 265 if (!(current->ptrace & PT_PTRACED)) 266 return; 267 268 pr_debug("syscall_trace: notifying parent\n"); 269 /* The 0x80 provides a way for the tracing parent to 270 * distinguish between a syscall stop and SIGTRAP delivery */ 271 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) 272 ? 0x80 : 0)); 273 274 /* 275 * this isn't the same as continuing with a signal, but it 276 * will do for normal use. strace only continues with a 277 * signal if the stopping signal is not SIGTRAP. -brl 278 */ 279 if (current->exit_code) { 280 pr_debug("syscall_trace: sending signal %d to PID %u\n", 281 current->exit_code, current->pid); 282 send_sig(current->exit_code, current, 1); 283 current->exit_code = 0; 284 } 285} 286 287asmlinkage void do_debug_priv(struct pt_regs *regs) 288{ 289 unsigned long dc, ds; 290 unsigned long die_val; 291 292 ds = __mfdr(DBGREG_DS); 293 294 pr_debug("do_debug_priv: pc = %08lx, ds = %08lx\n", regs->pc, ds); 295 296 if (ds & DS_SSS) 297 die_val = DIE_SSTEP; 298 else 299 die_val = DIE_BREAKPOINT; 300 301 if (notify_die(die_val, "ptrace", regs, 0, 0, SIGTRAP) == NOTIFY_STOP) 302 return; 303 304 if (likely(ds & DS_SSS)) { 305 extern void itlb_miss(void); 306 extern void tlb_miss_common(void); 307 struct thread_info *ti; 308 309 dc = __mfdr(DBGREG_DC); 310 dc &= ~DC_SS; 311 __mtdr(DBGREG_DC, dc); 312 313 ti = current_thread_info(); 314 set_ti_thread_flag(ti, TIF_BREAKPOINT); 315 316 /* The TLB miss handlers don't check thread flags */ 317 if ((regs->pc >= (unsigned long)&itlb_miss) 318 && (regs->pc <= (unsigned long)&tlb_miss_common)) { 319 __mtdr(DBGREG_BWA2A, sysreg_read(RAR_EX)); 320 __mtdr(DBGREG_BWC2A, 0x40000001 | (get_asid() << 1)); 321 } 322 323 /* 324 * If we're running in supervisor mode, the breakpoint 325 * will take us where we want directly, no need to 326 * single step. 327 */ 328 if ((regs->sr & MODE_MASK) != MODE_SUPERVISOR) 329 set_ti_thread_flag(ti, TIF_SINGLE_STEP); 330 } else { 331 panic("Unable to handle debug trap at pc = %08lx\n", 332 regs->pc); 333 } 334} 335 336/* 337 * Handle breakpoints, single steps and other debuggy things. To keep 338 * things simple initially, we run with interrupts and exceptions 339 * disabled all the time. 340 */ 341asmlinkage void do_debug(struct pt_regs *regs) 342{ 343 unsigned long dc, ds; 344 345 ds = __mfdr(DBGREG_DS); 346 pr_debug("do_debug: pc = %08lx, ds = %08lx\n", regs->pc, ds); 347 348 if (test_thread_flag(TIF_BREAKPOINT)) { 349 pr_debug("TIF_BREAKPOINT set\n"); 350 /* We're taking care of it */ 351 clear_thread_flag(TIF_BREAKPOINT); 352 __mtdr(DBGREG_BWC2A, 0); 353 } 354 355 if (test_thread_flag(TIF_SINGLE_STEP)) { 356 pr_debug("TIF_SINGLE_STEP set, ds = 0x%08lx\n", ds); 357 if (ds & DS_SSS) { 358 dc = __mfdr(DBGREG_DC); 359 dc &= ~DC_SS; 360 __mtdr(DBGREG_DC, dc); 361 362 clear_thread_flag(TIF_SINGLE_STEP); 363 ptrace_break(current, regs); 364 } 365 } else { 366 /* regular breakpoint */ 367 ptrace_break(current, regs); 368 } 369} 370