1/* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * arch/sh64/kernel/ptrace.c 7 * 8 * Copyright (C) 2000, 2001 Paolo Alberelli 9 * Copyright (C) 2003 Paul Mundt 10 * 11 * Started from SH3/4 version: 12 * SuperH version: Copyright (C) 1999, 2000 Kaz Kojima & Niibe Yutaka 13 * 14 * Original x86 implementation: 15 * By Ross Biro 1/23/92 16 * edited by Linus Torvalds 17 * 18 */ 19 20#include <linux/kernel.h> 21#include <linux/rwsem.h> 22#include <linux/sched.h> 23#include <linux/mm.h> 24#include <linux/smp.h> 25#include <linux/smp_lock.h> 26#include <linux/errno.h> 27#include <linux/ptrace.h> 28#include <linux/user.h> 29#include <linux/signal.h> 30#include <linux/syscalls.h> 31 32#include <asm/io.h> 33#include <asm/uaccess.h> 34#include <asm/pgtable.h> 35#include <asm/system.h> 36#include <asm/processor.h> 37#include <asm/mmu_context.h> 38 39/* This mask defines the bits of the SR which the user is not allowed to 40 change, which are everything except S, Q, M, PR, SZ, FR. */ 41#define SR_MASK (0xffff8cfd) 42 43/* 44 * does not yet catch signals sent when the child dies. 45 * in exit.c or in signal.c. 46 */ 47 48/* 49 * This routine will get a word from the user area in the process kernel stack. 50 */ 51static inline int get_stack_long(struct task_struct *task, int offset) 52{ 53 unsigned char *stack; 54 55 stack = (unsigned char *)(task->thread.uregs); 56 stack += offset; 57 return (*((int *)stack)); 58} 59 60static inline unsigned long 61get_fpu_long(struct task_struct *task, unsigned long addr) 62{ 63 unsigned long tmp; 64 struct pt_regs *regs; 65 regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1; 66 67 if (!tsk_used_math(task)) { 68 if (addr == offsetof(struct user_fpu_struct, fpscr)) { 69 tmp = FPSCR_INIT; 70 } else { 71 tmp = 0xffffffffUL; /* matches initial value in fpu.c */ 72 } 73 return tmp; 74 } 75 76 if (last_task_used_math == task) { 77 grab_fpu(); 78 fpsave(&task->thread.fpu.hard); 79 release_fpu(); 80 last_task_used_math = 0; 81 regs->sr |= SR_FD; 82 } 83 84 tmp = ((long *)&task->thread.fpu)[addr / sizeof(unsigned long)]; 85 return tmp; 86} 87 88/* 89 * This routine will put a word into the user area in the process kernel stack. 90 */ 91static inline int put_stack_long(struct task_struct *task, int offset, 92 unsigned long data) 93{ 94 unsigned char *stack; 95 96 stack = (unsigned char *)(task->thread.uregs); 97 stack += offset; 98 *(unsigned long *) stack = data; 99 return 0; 100} 101 102static inline int 103put_fpu_long(struct task_struct *task, unsigned long addr, unsigned long data) 104{ 105 struct pt_regs *regs; 106 107 regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1; 108 109 if (!tsk_used_math(task)) { 110 fpinit(&task->thread.fpu.hard); 111 set_stopped_child_used_math(task); 112 } else if (last_task_used_math == task) { 113 grab_fpu(); 114 fpsave(&task->thread.fpu.hard); 115 release_fpu(); 116 last_task_used_math = 0; 117 regs->sr |= SR_FD; 118 } 119 120 ((long *)&task->thread.fpu)[addr / sizeof(unsigned long)] = data; 121 return 0; 122} 123 124 125long arch_ptrace(struct task_struct *child, long request, long addr, long data) 126{ 127 int ret; 128 129 switch (request) { 130 /* when I and D space are separate, these will need to be fixed. */ 131 case PTRACE_PEEKTEXT: /* read word at location addr. */ 132 case PTRACE_PEEKDATA: { 133 unsigned long tmp; 134 int copied; 135 136 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); 137 ret = -EIO; 138 if (copied != sizeof(tmp)) 139 break; 140 ret = put_user(tmp,(unsigned long *) data); 141 break; 142 } 143 144 /* read the word at location addr in the USER area. */ 145 case PTRACE_PEEKUSR: { 146 unsigned long tmp; 147 148 ret = -EIO; 149 if ((addr & 3) || addr < 0) 150 break; 151 152 if (addr < sizeof(struct pt_regs)) 153 tmp = get_stack_long(child, addr); 154 else if ((addr >= offsetof(struct user, fpu)) && 155 (addr < offsetof(struct user, u_fpvalid))) { 156 tmp = get_fpu_long(child, addr - offsetof(struct user, fpu)); 157 } else if (addr == offsetof(struct user, u_fpvalid)) { 158 tmp = !!tsk_used_math(child); 159 } else { 160 break; 161 } 162 ret = put_user(tmp, (unsigned long *)data); 163 break; 164 } 165 166 /* when I and D space are separate, this will have to be fixed. */ 167 case PTRACE_POKETEXT: /* write the word at location addr. */ 168 case PTRACE_POKEDATA: 169 ret = 0; 170 if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data)) 171 break; 172 ret = -EIO; 173 break; 174 175 case PTRACE_POKEUSR: 176 /* write the word at location addr in the USER area. We must 177 disallow any changes to certain SR bits or u_fpvalid, since 178 this could crash the kernel or result in a security 179 loophole. */ 180 ret = -EIO; 181 if ((addr & 3) || addr < 0) 182 break; 183 184 if (addr < sizeof(struct pt_regs)) { 185 /* Ignore change of top 32 bits of SR */ 186 if (addr == offsetof (struct pt_regs, sr)+4) 187 { 188 ret = 0; 189 break; 190 } 191 /* If lower 32 bits of SR, ignore non-user bits */ 192 if (addr == offsetof (struct pt_regs, sr)) 193 { 194 long cursr = get_stack_long(child, addr); 195 data &= ~(SR_MASK); 196 data |= (cursr & SR_MASK); 197 } 198 ret = put_stack_long(child, addr, data); 199 } 200 else if ((addr >= offsetof(struct user, fpu)) && 201 (addr < offsetof(struct user, u_fpvalid))) { 202 ret = put_fpu_long(child, addr - offsetof(struct user, fpu), data); 203 } 204 break; 205 206 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 207 case PTRACE_CONT: { /* restart after signal. */ 208 ret = -EIO; 209 if (!valid_signal(data)) 210 break; 211 if (request == PTRACE_SYSCALL) 212 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 213 else 214 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 215 child->exit_code = data; 216 wake_up_process(child); 217 ret = 0; 218 break; 219 } 220 221/* 222 * make the child exit. Best I can do is send it a sigkill. 223 * perhaps it should be put in the status that it wants to 224 * exit. 225 */ 226 case PTRACE_KILL: { 227 ret = 0; 228 if (child->exit_state == EXIT_ZOMBIE) /* already dead */ 229 break; 230 child->exit_code = SIGKILL; 231 wake_up_process(child); 232 break; 233 } 234 235 case PTRACE_SINGLESTEP: { /* set the trap flag. */ 236 struct pt_regs *regs; 237 238 ret = -EIO; 239 if (!valid_signal(data)) 240 break; 241 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 242 if ((child->ptrace & PT_DTRACE) == 0) { 243 /* Spurious delayed TF traps may occur */ 244 child->ptrace |= PT_DTRACE; 245 } 246 247 regs = child->thread.uregs; 248 249 regs->sr |= SR_SSTEP; /* auto-resetting upon exception */ 250 251 child->exit_code = data; 252 /* give it a chance to run. */ 253 wake_up_process(child); 254 ret = 0; 255 break; 256 } 257 258 case PTRACE_DETACH: /* detach a process that was attached. */ 259 ret = ptrace_detach(child, data); 260 break; 261 262 default: 263 ret = ptrace_request(child, request, addr, data); 264 break; 265 } 266 return ret; 267} 268 269asmlinkage int sh64_ptrace(long request, long pid, long addr, long data) 270{ 271 extern void poke_real_address_q(unsigned long long addr, unsigned long long data); 272#define WPC_DBRMODE 0x0d104008 273 static int first_call = 1; 274 275 lock_kernel(); 276 if (first_call) { 277 /* Set WPC.DBRMODE to 0. This makes all debug events get 278 * delivered through RESVEC, i.e. into the handlers in entry.S. 279 * (If the kernel was downloaded using a remote gdb, WPC.DBRMODE 280 * would normally be left set to 1, which makes debug events get 281 * delivered through DBRVEC, i.e. into the remote gdb's 282 * handlers. This prevents ptrace getting them, and confuses 283 * the remote gdb.) */ 284 printk("DBRMODE set to 0 to permit native debugging\n"); 285 poke_real_address_q(WPC_DBRMODE, 0); 286 first_call = 0; 287 } 288 unlock_kernel(); 289 290 return sys_ptrace(request, pid, addr, data); 291} 292 293asmlinkage void syscall_trace(void) 294{ 295 struct task_struct *tsk = current; 296 297 if (!test_thread_flag(TIF_SYSCALL_TRACE)) 298 return; 299 if (!(tsk->ptrace & PT_PTRACED)) 300 return; 301 302 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) 303 ? 0x80 : 0)); 304 /* 305 * this isn't the same as continuing with a signal, but it will do 306 * for normal use. strace only continues with a signal if the 307 * stopping signal is not SIGTRAP. -brl 308 */ 309 if (tsk->exit_code) { 310 send_sig(tsk->exit_code, tsk, 1); 311 tsk->exit_code = 0; 312 } 313} 314 315/* Called with interrupts disabled */ 316asmlinkage void do_single_step(unsigned long long vec, struct pt_regs *regs) 317{ 318 /* This is called after a single step exception (DEBUGSS). 319 There is no need to change the PC, as it is a post-execution 320 exception, as entry.S does not do anything to the PC for DEBUGSS. 321 We need to clear the Single Step setting in SR to avoid 322 continually stepping. */ 323 local_irq_enable(); 324 regs->sr &= ~SR_SSTEP; 325 force_sig(SIGTRAP, current); 326} 327 328/* Called with interrupts disabled */ 329asmlinkage void do_software_break_point(unsigned long long vec, 330 struct pt_regs *regs) 331{ 332 /* We need to forward step the PC, to counteract the backstep done 333 in signal.c. */ 334 local_irq_enable(); 335 force_sig(SIGTRAP, current); 336 regs->pc += 4; 337} 338 339/* 340 * Called by kernel/ptrace.c when detaching.. 341 * 342 * Make sure single step bits etc are not set. 343 */ 344void ptrace_disable(struct task_struct *child) 345{ 346 /* nothing to do.. */ 347} 348