2 * SuperH process tracing
4 * Copyright (C) 1999, 2000 Kaz Kojima & Niibe Yutaka
5 * Copyright (C) 2002 - 2009 Paul Mundt
7 * Audit support by Yuichi Nakamura <ynakam@hitachisoft.jp>
9 * This file is subject to the terms and conditions of the GNU General Public
10 * License. See the file "COPYING" in the main directory of this archive
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
16 #include <linux/smp.h>
17 #include <linux/errno.h>
18 #include <linux/ptrace.h>
19 #include <linux/user.h>
20 #include <linux/security.h>
21 #include <linux/signal.h>
23 #include <linux/audit.h>
24 #include <linux/seccomp.h>
25 #include <linux/tracehook.h>
26 #include <linux/elf.h>
27 #include <linux/regset.h>
28 #include <linux/hw_breakpoint.h>
29 #include <asm/uaccess.h>
30 #include <asm/pgtable.h>
31 #include <asm/system.h>
32 #include <asm/processor.h>
33 #include <asm/mmu_context.h>
34 #include <asm/syscalls.h>
37 #define CREATE_TRACE_POINTS
38 #include <trace/events/syscalls.h>
41 * This routine will get a word off of the process kernel stack.
43 static inline int get_stack_long(struct task_struct
*task
, int offset
)
47 stack
= (unsigned char *)task_pt_regs(task
);
49 return (*((int *)stack
));
53 * This routine will put a word on the process kernel stack.
55 static inline int put_stack_long(struct task_struct
*task
, int offset
,
60 stack
= (unsigned char *)task_pt_regs(task
);
62 *(unsigned long *) stack
= data
;
66 void ptrace_triggered(struct perf_event
*bp
, int nmi
,
67 struct perf_sample_data
*data
, struct pt_regs
*regs
)
69 struct perf_event_attr attr
;
72 * Disable the breakpoint request here since ptrace has defined a
73 * one-shot behaviour for breakpoint exceptions.
77 modify_user_hw_breakpoint(bp
, &attr
);
80 static int set_single_step(struct task_struct
*tsk
, unsigned long addr
)
82 struct thread_struct
*thread
= &tsk
->thread
;
83 struct perf_event
*bp
;
84 struct perf_event_attr attr
;
86 bp
= thread
->ptrace_bps
[0];
88 ptrace_breakpoint_init(&attr
);
91 attr
.bp_len
= HW_BREAKPOINT_LEN_2
;
92 attr
.bp_type
= HW_BREAKPOINT_R
;
94 bp
= register_user_hw_breakpoint(&attr
, ptrace_triggered
, tsk
);
98 thread
->ptrace_bps
[0] = bp
;
104 err
= modify_user_hw_breakpoint(bp
, &attr
);
112 void user_enable_single_step(struct task_struct
*child
)
114 unsigned long pc
= get_stack_long(child
, offsetof(struct pt_regs
, pc
));
116 set_tsk_thread_flag(child
, TIF_SINGLESTEP
);
118 set_single_step(child
, pc
);
121 void user_disable_single_step(struct task_struct
*child
)
123 clear_tsk_thread_flag(child
, TIF_SINGLESTEP
);
127 * Called by kernel/ptrace.c when detaching..
129 * Make sure single step bits etc are not set.
131 void ptrace_disable(struct task_struct
*child
)
133 user_disable_single_step(child
);
136 static int genregs_get(struct task_struct
*target
,
137 const struct user_regset
*regset
,
138 unsigned int pos
, unsigned int count
,
139 void *kbuf
, void __user
*ubuf
)
141 const struct pt_regs
*regs
= task_pt_regs(target
);
144 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
146 0, 16 * sizeof(unsigned long));
148 /* PC, PR, SR, GBR, MACH, MACL, TRA */
149 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
151 offsetof(struct pt_regs
, pc
),
152 sizeof(struct pt_regs
));
154 ret
= user_regset_copyout_zero(&pos
, &count
, &kbuf
, &ubuf
,
155 sizeof(struct pt_regs
), -1);
160 static int genregs_set(struct task_struct
*target
,
161 const struct user_regset
*regset
,
162 unsigned int pos
, unsigned int count
,
163 const void *kbuf
, const void __user
*ubuf
)
165 struct pt_regs
*regs
= task_pt_regs(target
);
168 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
170 0, 16 * sizeof(unsigned long));
171 if (!ret
&& count
> 0)
172 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
174 offsetof(struct pt_regs
, pc
),
175 sizeof(struct pt_regs
));
177 ret
= user_regset_copyin_ignore(&pos
, &count
, &kbuf
, &ubuf
,
178 sizeof(struct pt_regs
), -1);
184 int fpregs_get(struct task_struct
*target
,
185 const struct user_regset
*regset
,
186 unsigned int pos
, unsigned int count
,
187 void *kbuf
, void __user
*ubuf
)
191 ret
= init_fpu(target
);
195 if ((boot_cpu_data
.flags
& CPU_HAS_FPU
))
196 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
197 &target
->thread
.xstate
->hardfpu
, 0, -1);
199 return user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
,
200 &target
->thread
.xstate
->softfpu
, 0, -1);
203 static int fpregs_set(struct task_struct
*target
,
204 const struct user_regset
*regset
,
205 unsigned int pos
, unsigned int count
,
206 const void *kbuf
, const void __user
*ubuf
)
210 ret
= init_fpu(target
);
214 set_stopped_child_used_math(target
);
216 if ((boot_cpu_data
.flags
& CPU_HAS_FPU
))
217 return user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
218 &target
->thread
.xstate
->hardfpu
, 0, -1);
220 return user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
,
221 &target
->thread
.xstate
->softfpu
, 0, -1);
224 static int fpregs_active(struct task_struct
*target
,
225 const struct user_regset
*regset
)
227 return tsk_used_math(target
) ? regset
->n
: 0;
232 static int dspregs_get(struct task_struct
*target
,
233 const struct user_regset
*regset
,
234 unsigned int pos
, unsigned int count
,
235 void *kbuf
, void __user
*ubuf
)
237 const struct pt_dspregs
*regs
=
238 (struct pt_dspregs
*)&target
->thread
.dsp_status
.dsp_regs
;
241 ret
= user_regset_copyout(&pos
, &count
, &kbuf
, &ubuf
, regs
,
242 0, sizeof(struct pt_dspregs
));
244 ret
= user_regset_copyout_zero(&pos
, &count
, &kbuf
, &ubuf
,
245 sizeof(struct pt_dspregs
), -1);
250 static int dspregs_set(struct task_struct
*target
,
251 const struct user_regset
*regset
,
252 unsigned int pos
, unsigned int count
,
253 const void *kbuf
, const void __user
*ubuf
)
255 struct pt_dspregs
*regs
=
256 (struct pt_dspregs
*)&target
->thread
.dsp_status
.dsp_regs
;
259 ret
= user_regset_copyin(&pos
, &count
, &kbuf
, &ubuf
, regs
,
260 0, sizeof(struct pt_dspregs
));
262 ret
= user_regset_copyin_ignore(&pos
, &count
, &kbuf
, &ubuf
,
263 sizeof(struct pt_dspregs
), -1);
268 static int dspregs_active(struct task_struct
*target
,
269 const struct user_regset
*regset
)
271 struct pt_regs
*regs
= task_pt_regs(target
);
273 return regs
->sr
& SR_DSP
? regset
->n
: 0;
277 const struct pt_regs_offset regoffset_table
[] = {
288 REGS_OFFSET_NAME(10),
289 REGS_OFFSET_NAME(11),
290 REGS_OFFSET_NAME(12),
291 REGS_OFFSET_NAME(13),
292 REGS_OFFSET_NAME(14),
293 REGS_OFFSET_NAME(15),
297 REG_OFFSET_NAME(gbr
),
298 REG_OFFSET_NAME(mach
),
299 REG_OFFSET_NAME(macl
),
300 REG_OFFSET_NAME(tra
),
305 * These are our native regset flavours.
317 static const struct user_regset sh_regsets
[] = {
321 * PC, PR, SR, GBR, MACH, MACL, TRA
324 .core_note_type
= NT_PRSTATUS
,
326 .size
= sizeof(long),
327 .align
= sizeof(long),
334 .core_note_type
= NT_PRFPREG
,
335 .n
= sizeof(struct user_fpu_struct
) / sizeof(long),
336 .size
= sizeof(long),
337 .align
= sizeof(long),
340 .active
= fpregs_active
,
346 .n
= sizeof(struct pt_dspregs
) / sizeof(long),
347 .size
= sizeof(long),
348 .align
= sizeof(long),
351 .active
= dspregs_active
,
356 static const struct user_regset_view user_sh_native_view
= {
359 .regsets
= sh_regsets
,
360 .n
= ARRAY_SIZE(sh_regsets
),
363 const struct user_regset_view
*task_user_regset_view(struct task_struct
*task
)
365 return &user_sh_native_view
;
368 long arch_ptrace(struct task_struct
*child
, long request
,
369 unsigned long addr
, unsigned long data
)
371 unsigned long __user
*datap
= (unsigned long __user
*)data
;
375 /* read the word at location addr in the USER area. */
376 case PTRACE_PEEKUSR
: {
380 if ((addr
& 3) || addr
< 0 ||
381 addr
> sizeof(struct user
) - 3)
384 if (addr
< sizeof(struct pt_regs
))
385 tmp
= get_stack_long(child
, addr
);
386 else if (addr
>= offsetof(struct user
, fpu
) &&
387 addr
< offsetof(struct user
, u_fpvalid
)) {
388 if (!tsk_used_math(child
)) {
389 if (addr
== offsetof(struct user
, fpu
.fpscr
))
395 index
= addr
- offsetof(struct user
, fpu
);
396 tmp
= ((unsigned long *)child
->thread
.xstate
)
399 } else if (addr
== offsetof(struct user
, u_fpvalid
))
400 tmp
= !!tsk_used_math(child
);
401 else if (addr
== PT_TEXT_ADDR
)
402 tmp
= child
->mm
->start_code
;
403 else if (addr
== PT_DATA_ADDR
)
404 tmp
= child
->mm
->start_data
;
405 else if (addr
== PT_TEXT_END_ADDR
)
406 tmp
= child
->mm
->end_code
;
407 else if (addr
== PT_TEXT_LEN
)
408 tmp
= child
->mm
->end_code
- child
->mm
->start_code
;
411 ret
= put_user(tmp
, datap
);
415 case PTRACE_POKEUSR
: /* write the word at location addr in the USER area */
417 if ((addr
& 3) || addr
< 0 ||
418 addr
> sizeof(struct user
) - 3)
421 if (addr
< sizeof(struct pt_regs
))
422 ret
= put_stack_long(child
, addr
, data
);
423 else if (addr
>= offsetof(struct user
, fpu
) &&
424 addr
< offsetof(struct user
, u_fpvalid
)) {
426 index
= addr
- offsetof(struct user
, fpu
);
427 set_stopped_child_used_math(child
);
428 ((unsigned long *)child
->thread
.xstate
)
431 } else if (addr
== offsetof(struct user
, u_fpvalid
)) {
432 conditional_stopped_child_used_math(data
, child
);
438 return copy_regset_to_user(child
, &user_sh_native_view
,
440 0, sizeof(struct pt_regs
),
443 return copy_regset_from_user(child
, &user_sh_native_view
,
445 0, sizeof(struct pt_regs
),
448 case PTRACE_GETFPREGS
:
449 return copy_regset_to_user(child
, &user_sh_native_view
,
451 0, sizeof(struct user_fpu_struct
),
453 case PTRACE_SETFPREGS
:
454 return copy_regset_from_user(child
, &user_sh_native_view
,
456 0, sizeof(struct user_fpu_struct
),
460 case PTRACE_GETDSPREGS
:
461 return copy_regset_to_user(child
, &user_sh_native_view
,
463 0, sizeof(struct pt_dspregs
),
465 case PTRACE_SETDSPREGS
:
466 return copy_regset_from_user(child
, &user_sh_native_view
,
468 0, sizeof(struct pt_dspregs
),
472 ret
= ptrace_request(child
, request
, addr
, data
);
479 static inline int audit_arch(void)
483 #ifdef CONFIG_CPU_LITTLE_ENDIAN
484 arch
|= __AUDIT_ARCH_LE
;
490 asmlinkage
long do_syscall_trace_enter(struct pt_regs
*regs
)
494 secure_computing(regs
->regs
[0]);
496 if (test_thread_flag(TIF_SYSCALL_TRACE
) &&
497 tracehook_report_syscall_entry(regs
))
499 * Tracing decided this syscall should not happen.
500 * We'll return a bogus call number to get an ENOSYS
501 * error, but leave the original number in regs->regs[0].
505 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
506 trace_sys_enter(regs
, regs
->regs
[0]);
508 if (unlikely(current
->audit_context
))
509 audit_syscall_entry(audit_arch(), regs
->regs
[3],
510 regs
->regs
[4], regs
->regs
[5],
511 regs
->regs
[6], regs
->regs
[7]);
513 return ret
?: regs
->regs
[0];
516 asmlinkage
void do_syscall_trace_leave(struct pt_regs
*regs
)
520 if (unlikely(current
->audit_context
))
521 audit_syscall_exit(AUDITSC_RESULT(regs
->regs
[0]),
524 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT
)))
525 trace_sys_exit(regs
, regs
->regs
[0]);
527 step
= test_thread_flag(TIF_SINGLESTEP
);
528 if (step
|| test_thread_flag(TIF_SYSCALL_TRACE
))
529 tracehook_report_syscall_exit(regs
, step
);