2 * arch/sh/kernel/ptrace_64.c
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 - 2008 Paul Mundt
7 * Started from SH3/4 version:
8 * SuperH version: Copyright (C) 1999, 2000 Kaz Kojima & Niibe Yutaka
10 * Original x86 implementation:
11 * By Ross Biro 1/23/92
12 * edited by Linus Torvalds
14 * This file is subject to the terms and conditions of the GNU General Public
15 * License. See the file "COPYING" in the main directory of this archive
18 #include <linux/kernel.h>
19 #include <linux/rwsem.h>
20 #include <linux/sched.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/errno.h>
25 #include <linux/ptrace.h>
26 #include <linux/user.h>
27 #include <linux/signal.h>
28 #include <linux/syscalls.h>
29 #include <linux/audit.h>
30 #include <linux/seccomp.h>
31 #include <linux/tracehook.h>
32 #include <linux/elf.h>
33 #include <linux/regset.h>
35 #include <asm/uaccess.h>
36 #include <asm/pgtable.h>
37 #include <asm/system.h>
38 #include <asm/processor.h>
39 #include <asm/mmu_context.h>
40 #include <asm/syscalls.h>
43 #define CREATE_TRACE_POINTS
44 #include <trace/events/syscalls.h>
46 /* This mask defines the bits of the SR which the user is not allowed to
47 change, which are everything except S, Q, M, PR, SZ, FR. */
48 #define SR_MASK (0xffff8cfd)
51 * does not yet catch signals sent when the child dies.
52 * in exit.c or in signal.c.
56 * This routine will get a word from the user area in the process kernel stack.
58 static inline int get_stack_long(struct task_struct
*task
, int offset
)
62 stack
= (unsigned char *)(task
->thread
.uregs
);
64 return (*((int *)stack
));
67 static inline unsigned long
68 get_fpu_long(struct task_struct
*task
, unsigned long addr
)
72 regs
= (struct pt_regs
*)((unsigned char *)task
+ THREAD_SIZE
) - 1;
74 if (!tsk_used_math(task
)) {
75 if (addr
== offsetof(struct user_fpu_struct
, fpscr
)) {
78 tmp
= 0xffffffffUL
; /* matches initial value in fpu.c */
83 if (last_task_used_math
== task
) {
87 last_task_used_math
= 0;
91 tmp
= ((long *)task
->thread
.xstate
)[addr
/ sizeof(unsigned long)];
96 * This routine will put a word into the user area in the process kernel stack.
98 static inline int put_stack_long(struct task_struct
*task
, int offset
,
101 unsigned char *stack
;
103 stack
= (unsigned char *)(task
->thread
.uregs
);
105 *(unsigned long *) stack
= data
;
110 put_fpu_long(struct task_struct
*task
, unsigned long addr
, unsigned long data
)
112 struct pt_regs
*regs
;
114 regs
= (struct pt_regs
*)((unsigned char *)task
+ THREAD_SIZE
) - 1;
116 if (!tsk_used_math(task
)) {
118 } else if (last_task_used_math
== task
) {
122 last_task_used_math
= 0;
126 ((long *)task
->thread
.xstate
)[addr
/ sizeof(unsigned long)] = data
;
130 void user_enable_single_step(struct task_struct
*child
)
132 struct pt_regs
*regs
= child
->thread
.uregs
;
134 regs
->sr
|= SR_SSTEP
; /* auto-resetting upon exception */
137 void user_disable_single_step(struct task_struct
*child
)
139 struct pt_regs
*regs
= child
->thread
.uregs
;
141 regs
->sr
&= ~SR_SSTEP
;
144 static int genregs_get(struct task_struct
*target
,
145 const struct user_regset
*regset
,
146 unsigned int pos
, unsigned int count
,
147 void *kbuf
, void __user
*ubuf
)
149 const struct pt_regs
*regs
= task_pt_regs(target
);
152 /* PC, SR, SYSCALL */
153 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
155 0, 3 * sizeof(unsigned long long));
159 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
161 offsetof(struct pt_regs
, regs
[0]),
162 63 * sizeof(unsigned long long));
165 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
167 offsetof(struct pt_regs
, tregs
[0]),
168 8 * sizeof(unsigned long long));
171 ret
= user_regset_copyout_zero(&pos
, &count
, &kbuf
, &ubuf
,
172 sizeof(struct pt_regs
), -1);
177 static int genregs_set(struct task_struct
*target
,
178 const struct user_regset
*regset
,
179 unsigned int pos
, unsigned int count
,
180 const void *kbuf
, const void __user
*ubuf
)
182 struct pt_regs
*regs
= task_pt_regs(target
);
185 /* PC, SR, SYSCALL */
186 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
188 0, 3 * sizeof(unsigned long long));
191 if (!ret
&& count
> 0)
192 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
194 offsetof(struct pt_regs
, regs
[0]),
195 63 * sizeof(unsigned long long));
198 if (!ret
&& count
> 0)
199 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
201 offsetof(struct pt_regs
, tregs
[0]),
202 8 * sizeof(unsigned long long));
205 ret
= user_regset_copyin_ignore(&pos
, &count
, &kbuf
, &ubuf
,
206 sizeof(struct pt_regs
), -1);
212 int fpregs_get(struct task_struct
*target
,
213 const struct user_regset
*regset
,
214 unsigned int pos
, unsigned int count
,
215 void *kbuf
, void __user
*ubuf
)
219 ret
= init_fpu(target
);
223 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
224 &target
->thread
.xstate
->hardfpu
, 0, -1);
227 static int fpregs_set(struct task_struct
*target
,
228 const struct user_regset
*regset
,
229 unsigned int pos
, unsigned int count
,
230 const void *kbuf
, const void __user
*ubuf
)
234 ret
= init_fpu(target
);
238 set_stopped_child_used_math(target
);
240 return user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
241 &target
->thread
.xstate
->hardfpu
, 0, -1);
244 static int fpregs_active(struct task_struct
*target
,
245 const struct user_regset
*regset
)
247 return tsk_used_math(target
) ? regset
->n
: 0;
252 * These are our native regset flavours.
261 static const struct user_regset sh_regsets
[] = {
269 .core_note_type
= NT_PRSTATUS
,
271 .size
= sizeof(long long),
272 .align
= sizeof(long long),
279 .core_note_type
= NT_PRFPREG
,
280 .n
= sizeof(struct user_fpu_struct
) /
282 .size
= sizeof(long long),
283 .align
= sizeof(long long),
286 .active
= fpregs_active
,
291 static const struct user_regset_view user_sh64_native_view
= {
294 .regsets
= sh_regsets
,
295 .n
= ARRAY_SIZE(sh_regsets
),
298 const struct user_regset_view
*task_user_regset_view(struct task_struct
*task
)
300 return &user_sh64_native_view
;
303 long arch_ptrace(struct task_struct
*child
, long request
, long addr
, long data
)
308 /* read the word at location addr in the USER area. */
309 case PTRACE_PEEKUSR
: {
313 if ((addr
& 3) || addr
< 0)
316 if (addr
< sizeof(struct pt_regs
))
317 tmp
= get_stack_long(child
, addr
);
318 else if ((addr
>= offsetof(struct user
, fpu
)) &&
319 (addr
< offsetof(struct user
, u_fpvalid
))) {
320 tmp
= get_fpu_long(child
, addr
- offsetof(struct user
, fpu
));
321 } else if (addr
== offsetof(struct user
, u_fpvalid
)) {
322 tmp
= !!tsk_used_math(child
);
326 ret
= put_user(tmp
, (unsigned long *)data
);
331 /* write the word at location addr in the USER area. We must
332 disallow any changes to certain SR bits or u_fpvalid, since
333 this could crash the kernel or result in a security
336 if ((addr
& 3) || addr
< 0)
339 if (addr
< sizeof(struct pt_regs
)) {
340 /* Ignore change of top 32 bits of SR */
341 if (addr
== offsetof (struct pt_regs
, sr
)+4)
346 /* If lower 32 bits of SR, ignore non-user bits */
347 if (addr
== offsetof (struct pt_regs
, sr
))
349 long cursr
= get_stack_long(child
, addr
);
351 data
|= (cursr
& SR_MASK
);
353 ret
= put_stack_long(child
, addr
, data
);
355 else if ((addr
>= offsetof(struct user
, fpu
)) &&
356 (addr
< offsetof(struct user
, u_fpvalid
))) {
357 ret
= put_fpu_long(child
, addr
- offsetof(struct user
, fpu
), data
);
362 return copy_regset_to_user(child
, &user_sh64_native_view
,
364 0, sizeof(struct pt_regs
),
365 (void __user
*)data
);
367 return copy_regset_from_user(child
, &user_sh64_native_view
,
369 0, sizeof(struct pt_regs
),
370 (const void __user
*)data
);
372 case PTRACE_GETFPREGS
:
373 return copy_regset_to_user(child
, &user_sh64_native_view
,
375 0, sizeof(struct user_fpu_struct
),
376 (void __user
*)data
);
377 case PTRACE_SETFPREGS
:
378 return copy_regset_from_user(child
, &user_sh64_native_view
,
380 0, sizeof(struct user_fpu_struct
),
381 (const void __user
*)data
);
384 ret
= ptrace_request(child
, request
, addr
, data
);
391 asmlinkage
int sh64_ptrace(long request
, long pid
, long addr
, long data
)
393 #define WPC_DBRMODE 0x0d104008
394 static int first_call
= 1;
398 /* Set WPC.DBRMODE to 0. This makes all debug events get
399 * delivered through RESVEC, i.e. into the handlers in entry.S.
400 * (If the kernel was downloaded using a remote gdb, WPC.DBRMODE
401 * would normally be left set to 1, which makes debug events get
402 * delivered through DBRVEC, i.e. into the remote gdb's
403 * handlers. This prevents ptrace getting them, and confuses
404 * the remote gdb.) */
405 printk("DBRMODE set to 0 to permit native debugging\n");
406 poke_real_address_q(WPC_DBRMODE
, 0);
411 return sys_ptrace(request
, pid
, addr
, data
);
414 static inline int audit_arch(void)
419 arch
|= __AUDIT_ARCH_64BIT
;
421 #ifdef CONFIG_CPU_LITTLE_ENDIAN
422 arch
|= __AUDIT_ARCH_LE
;
428 asmlinkage
long long do_syscall_trace_enter(struct pt_regs
*regs
)
432 secure_computing(regs
->regs
[9]);
434 if (test_thread_flag(TIF_SYSCALL_TRACE
) &&
435 tracehook_report_syscall_entry(regs
))
437 * Tracing decided this syscall should not happen.
438 * We'll return a bogus call number to get an ENOSYS
439 * error, but leave the original number in regs->regs[0].
443 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
444 trace_sys_enter(regs
, regs
->regs
[9]);
446 if (unlikely(current
->audit_context
))
447 audit_syscall_entry(audit_arch(), regs
->regs
[1],
448 regs
->regs
[2], regs
->regs
[3],
449 regs
->regs
[4], regs
->regs
[5]);
451 return ret
?: regs
->regs
[9];
454 asmlinkage
void do_syscall_trace_leave(struct pt_regs
*regs
)
456 if (unlikely(current
->audit_context
))
457 audit_syscall_exit(AUDITSC_RESULT(regs
->regs
[9]),
460 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
461 trace_sys_exit(regs
, regs
->regs
[9]);
463 if (test_thread_flag(TIF_SYSCALL_TRACE
))
464 tracehook_report_syscall_exit(regs
, 0);
467 /* Called with interrupts disabled */
468 asmlinkage
void do_single_step(unsigned long long vec
, struct pt_regs
*regs
)
470 /* This is called after a single step exception (DEBUGSS).
471 There is no need to change the PC, as it is a post-execution
472 exception, as entry.S does not do anything to the PC for DEBUGSS.
473 We need to clear the Single Step setting in SR to avoid
474 continually stepping. */
476 regs
->sr
&= ~SR_SSTEP
;
477 force_sig(SIGTRAP
, current
);
480 /* Called with interrupts disabled */
481 BUILD_TRAP_HANDLER(breakpoint
)
485 /* We need to forward step the PC, to counteract the backstep done
488 force_sig(SIGTRAP
, current
);
493 * Called by kernel/ptrace.c when detaching..
495 * Make sure single step bits etc are not set.
497 void ptrace_disable(struct task_struct
*child
)
499 user_disable_single_step(child
);