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