sh: Add kprobe-based event tracer.
[linux-3.10.git] / arch / sh / kernel / ptrace_32.c
1 /*
2  * SuperH process tracing
3  *
4  * Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
5  * Copyright (C) 2002 - 2009  Paul Mundt
6  *
7  * Audit support by Yuichi Nakamura <ynakam@hitachisoft.jp>
8  *
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
11  * for more details.
12  */
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/mm.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>
22 #include <linux/io.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>
35 #include <asm/fpu.h>
36
37 #define CREATE_TRACE_POINTS
38 #include <trace/events/syscalls.h>
39
40 /*
41  * This routine will get a word off of the process kernel stack.
42  */
43 static inline int get_stack_long(struct task_struct *task, int offset)
44 {
45         unsigned char *stack;
46
47         stack = (unsigned char *)task_pt_regs(task);
48         stack += offset;
49         return (*((int *)stack));
50 }
51
52 /*
53  * This routine will put a word on the process kernel stack.
54  */
55 static inline int put_stack_long(struct task_struct *task, int offset,
56                                  unsigned long data)
57 {
58         unsigned char *stack;
59
60         stack = (unsigned char *)task_pt_regs(task);
61         stack += offset;
62         *(unsigned long *) stack = data;
63         return 0;
64 }
65
66 void ptrace_triggered(struct perf_event *bp, int nmi,
67                       struct perf_sample_data *data, struct pt_regs *regs)
68 {
69         struct perf_event_attr attr;
70
71         /*
72          * Disable the breakpoint request here since ptrace has defined a
73          * one-shot behaviour for breakpoint exceptions.
74          */
75         attr = bp->attr;
76         attr.disabled = true;
77         modify_user_hw_breakpoint(bp, &attr);
78 }
79
80 static int set_single_step(struct task_struct *tsk, unsigned long addr)
81 {
82         struct thread_struct *thread = &tsk->thread;
83         struct perf_event *bp;
84         struct perf_event_attr attr;
85
86         bp = thread->ptrace_bps[0];
87         if (!bp) {
88                 ptrace_breakpoint_init(&attr);
89
90                 attr.bp_addr = addr;
91                 attr.bp_len = HW_BREAKPOINT_LEN_2;
92                 attr.bp_type = HW_BREAKPOINT_R;
93
94                 bp = register_user_hw_breakpoint(&attr, ptrace_triggered, tsk);
95                 if (IS_ERR(bp))
96                         return PTR_ERR(bp);
97
98                 thread->ptrace_bps[0] = bp;
99         } else {
100                 int err;
101
102                 attr = bp->attr;
103                 attr.bp_addr = addr;
104                 err = modify_user_hw_breakpoint(bp, &attr);
105                 if (unlikely(err))
106                         return err;
107         }
108
109         return 0;
110 }
111
112 void user_enable_single_step(struct task_struct *child)
113 {
114         unsigned long pc = get_stack_long(child, offsetof(struct pt_regs, pc));
115
116         set_tsk_thread_flag(child, TIF_SINGLESTEP);
117
118         set_single_step(child, pc);
119 }
120
121 void user_disable_single_step(struct task_struct *child)
122 {
123         clear_tsk_thread_flag(child, TIF_SINGLESTEP);
124 }
125
126 /*
127  * Called by kernel/ptrace.c when detaching..
128  *
129  * Make sure single step bits etc are not set.
130  */
131 void ptrace_disable(struct task_struct *child)
132 {
133         user_disable_single_step(child);
134 }
135
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)
140 {
141         const struct pt_regs *regs = task_pt_regs(target);
142         int ret;
143
144         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
145                                   regs->regs,
146                                   0, 16 * sizeof(unsigned long));
147         if (!ret)
148                 /* PC, PR, SR, GBR, MACH, MACL, TRA */
149                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
150                                           &regs->pc,
151                                           offsetof(struct pt_regs, pc),
152                                           sizeof(struct pt_regs));
153         if (!ret)
154                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
155                                                sizeof(struct pt_regs), -1);
156
157         return ret;
158 }
159
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)
164 {
165         struct pt_regs *regs = task_pt_regs(target);
166         int ret;
167
168         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
169                                  regs->regs,
170                                  0, 16 * sizeof(unsigned long));
171         if (!ret && count > 0)
172                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
173                                          &regs->pc,
174                                          offsetof(struct pt_regs, pc),
175                                          sizeof(struct pt_regs));
176         if (!ret)
177                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
178                                                 sizeof(struct pt_regs), -1);
179
180         return ret;
181 }
182
183 #ifdef CONFIG_SH_FPU
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)
188 {
189         int ret;
190
191         ret = init_fpu(target);
192         if (ret)
193                 return ret;
194
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);
198
199         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
200                                    &target->thread.xstate->softfpu, 0, -1);
201 }
202
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)
207 {
208         int ret;
209
210         ret = init_fpu(target);
211         if (ret)
212                 return ret;
213
214         set_stopped_child_used_math(target);
215
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);
219
220         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
221                                   &target->thread.xstate->softfpu, 0, -1);
222 }
223
224 static int fpregs_active(struct task_struct *target,
225                          const struct user_regset *regset)
226 {
227         return tsk_used_math(target) ? regset->n : 0;
228 }
229 #endif
230
231 #ifdef CONFIG_SH_DSP
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)
236 {
237         const struct pt_dspregs *regs =
238                 (struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
239         int ret;
240
241         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs,
242                                   0, sizeof(struct pt_dspregs));
243         if (!ret)
244                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
245                                                sizeof(struct pt_dspregs), -1);
246
247         return ret;
248 }
249
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)
254 {
255         struct pt_dspregs *regs =
256                 (struct pt_dspregs *)&target->thread.dsp_status.dsp_regs;
257         int ret;
258
259         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs,
260                                  0, sizeof(struct pt_dspregs));
261         if (!ret)
262                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
263                                                 sizeof(struct pt_dspregs), -1);
264
265         return ret;
266 }
267
268 static int dspregs_active(struct task_struct *target,
269                           const struct user_regset *regset)
270 {
271         struct pt_regs *regs = task_pt_regs(target);
272
273         return regs->sr & SR_DSP ? regset->n : 0;
274 }
275 #endif
276
277 const struct pt_regs_offset regoffset_table[] = {
278         REGS_OFFSET_NAME(0),
279         REGS_OFFSET_NAME(1),
280         REGS_OFFSET_NAME(2),
281         REGS_OFFSET_NAME(3),
282         REGS_OFFSET_NAME(4),
283         REGS_OFFSET_NAME(5),
284         REGS_OFFSET_NAME(6),
285         REGS_OFFSET_NAME(7),
286         REGS_OFFSET_NAME(8),
287         REGS_OFFSET_NAME(9),
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),
294         REG_OFFSET_NAME(pc),
295         REG_OFFSET_NAME(pr),
296         REG_OFFSET_NAME(sr),
297         REG_OFFSET_NAME(gbr),
298         REG_OFFSET_NAME(mach),
299         REG_OFFSET_NAME(macl),
300         REG_OFFSET_NAME(tra),
301         REG_OFFSET_END,
302 };
303
304 /*
305  * These are our native regset flavours.
306  */
307 enum sh_regset {
308         REGSET_GENERAL,
309 #ifdef CONFIG_SH_FPU
310         REGSET_FPU,
311 #endif
312 #ifdef CONFIG_SH_DSP
313         REGSET_DSP,
314 #endif
315 };
316
317 static const struct user_regset sh_regsets[] = {
318         /*
319          * Format is:
320          *      R0 --> R15
321          *      PC, PR, SR, GBR, MACH, MACL, TRA
322          */
323         [REGSET_GENERAL] = {
324                 .core_note_type = NT_PRSTATUS,
325                 .n              = ELF_NGREG,
326                 .size           = sizeof(long),
327                 .align          = sizeof(long),
328                 .get            = genregs_get,
329                 .set            = genregs_set,
330         },
331
332 #ifdef CONFIG_SH_FPU
333         [REGSET_FPU] = {
334                 .core_note_type = NT_PRFPREG,
335                 .n              = sizeof(struct user_fpu_struct) / sizeof(long),
336                 .size           = sizeof(long),
337                 .align          = sizeof(long),
338                 .get            = fpregs_get,
339                 .set            = fpregs_set,
340                 .active         = fpregs_active,
341         },
342 #endif
343
344 #ifdef CONFIG_SH_DSP
345         [REGSET_DSP] = {
346                 .n              = sizeof(struct pt_dspregs) / sizeof(long),
347                 .size           = sizeof(long),
348                 .align          = sizeof(long),
349                 .get            = dspregs_get,
350                 .set            = dspregs_set,
351                 .active         = dspregs_active,
352         },
353 #endif
354 };
355
356 static const struct user_regset_view user_sh_native_view = {
357         .name           = "sh",
358         .e_machine      = EM_SH,
359         .regsets        = sh_regsets,
360         .n              = ARRAY_SIZE(sh_regsets),
361 };
362
363 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
364 {
365         return &user_sh_native_view;
366 }
367
368 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
369 {
370         struct user * dummy = NULL;
371         unsigned long __user *datap = (unsigned long __user *)data;
372         int ret;
373
374         switch (request) {
375         /* read the word at location addr in the USER area. */
376         case PTRACE_PEEKUSR: {
377                 unsigned long tmp;
378
379                 ret = -EIO;
380                 if ((addr & 3) || addr < 0 ||
381                     addr > sizeof(struct user) - 3)
382                         break;
383
384                 if (addr < sizeof(struct pt_regs))
385                         tmp = get_stack_long(child, addr);
386                 else if (addr >= (long) &dummy->fpu &&
387                          addr < (long) &dummy->u_fpvalid) {
388                         if (!tsk_used_math(child)) {
389                                 if (addr == (long)&dummy->fpu.fpscr)
390                                         tmp = FPSCR_INIT;
391                                 else
392                                         tmp = 0;
393                         } else
394                                 tmp = ((long *)child->thread.xstate)
395                                         [(addr - (long)&dummy->fpu) >> 2];
396                 } else if (addr == (long) &dummy->u_fpvalid)
397                         tmp = !!tsk_used_math(child);
398                 else if (addr == PT_TEXT_ADDR)
399                         tmp = child->mm->start_code;
400                 else if (addr == PT_DATA_ADDR)
401                         tmp = child->mm->start_data;
402                 else if (addr == PT_TEXT_END_ADDR)
403                         tmp = child->mm->end_code;
404                 else if (addr == PT_TEXT_LEN)
405                         tmp = child->mm->end_code - child->mm->start_code;
406                 else
407                         tmp = 0;
408                 ret = put_user(tmp, datap);
409                 break;
410         }
411
412         case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
413                 ret = -EIO;
414                 if ((addr & 3) || addr < 0 ||
415                     addr > sizeof(struct user) - 3)
416                         break;
417
418                 if (addr < sizeof(struct pt_regs))
419                         ret = put_stack_long(child, addr, data);
420                 else if (addr >= (long) &dummy->fpu &&
421                          addr < (long) &dummy->u_fpvalid) {
422                         set_stopped_child_used_math(child);
423                         ((long *)child->thread.xstate)
424                                 [(addr - (long)&dummy->fpu) >> 2] = data;
425                         ret = 0;
426                 } else if (addr == (long) &dummy->u_fpvalid) {
427                         conditional_stopped_child_used_math(data, child);
428                         ret = 0;
429                 }
430                 break;
431
432         case PTRACE_GETREGS:
433                 return copy_regset_to_user(child, &user_sh_native_view,
434                                            REGSET_GENERAL,
435                                            0, sizeof(struct pt_regs),
436                                            (void __user *)data);
437         case PTRACE_SETREGS:
438                 return copy_regset_from_user(child, &user_sh_native_view,
439                                              REGSET_GENERAL,
440                                              0, sizeof(struct pt_regs),
441                                              (const void __user *)data);
442 #ifdef CONFIG_SH_FPU
443         case PTRACE_GETFPREGS:
444                 return copy_regset_to_user(child, &user_sh_native_view,
445                                            REGSET_FPU,
446                                            0, sizeof(struct user_fpu_struct),
447                                            (void __user *)data);
448         case PTRACE_SETFPREGS:
449                 return copy_regset_from_user(child, &user_sh_native_view,
450                                              REGSET_FPU,
451                                              0, sizeof(struct user_fpu_struct),
452                                              (const void __user *)data);
453 #endif
454 #ifdef CONFIG_SH_DSP
455         case PTRACE_GETDSPREGS:
456                 return copy_regset_to_user(child, &user_sh_native_view,
457                                            REGSET_DSP,
458                                            0, sizeof(struct pt_dspregs),
459                                            (void __user *)data);
460         case PTRACE_SETDSPREGS:
461                 return copy_regset_from_user(child, &user_sh_native_view,
462                                              REGSET_DSP,
463                                              0, sizeof(struct pt_dspregs),
464                                              (const void __user *)data);
465 #endif
466         default:
467                 ret = ptrace_request(child, request, addr, data);
468                 break;
469         }
470
471         return ret;
472 }
473
474 static inline int audit_arch(void)
475 {
476         int arch = EM_SH;
477
478 #ifdef CONFIG_CPU_LITTLE_ENDIAN
479         arch |= __AUDIT_ARCH_LE;
480 #endif
481
482         return arch;
483 }
484
485 asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
486 {
487         long ret = 0;
488
489         secure_computing(regs->regs[0]);
490
491         if (test_thread_flag(TIF_SYSCALL_TRACE) &&
492             tracehook_report_syscall_entry(regs))
493                 /*
494                  * Tracing decided this syscall should not happen.
495                  * We'll return a bogus call number to get an ENOSYS
496                  * error, but leave the original number in regs->regs[0].
497                  */
498                 ret = -1L;
499
500         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
501                 trace_sys_enter(regs, regs->regs[0]);
502
503         if (unlikely(current->audit_context))
504                 audit_syscall_entry(audit_arch(), regs->regs[3],
505                                     regs->regs[4], regs->regs[5],
506                                     regs->regs[6], regs->regs[7]);
507
508         return ret ?: regs->regs[0];
509 }
510
511 asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
512 {
513         int step;
514
515         if (unlikely(current->audit_context))
516                 audit_syscall_exit(AUDITSC_RESULT(regs->regs[0]),
517                                    regs->regs[0]);
518
519         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
520                 trace_sys_exit(regs, regs->regs[0]);
521
522         step = test_thread_flag(TIF_SINGLESTEP);
523         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
524                 tracehook_report_syscall_exit(regs, step);
525 }