Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ptrace.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3  * Licensed under the GPL
4  */
5 
6 #include <linux/audit.h>
7 #include <linux/ptrace.h>
8 #include <linux/sched.h>
9 #include <linux/tracehook.h>
10 #include <asm/uaccess.h>
11 #include <skas_ptrace.h>
12 
13 
14 
16 {
17  child->ptrace |= PT_DTRACE;
18  child->thread.singlestep_syscall = 0;
19 
20 #ifdef SUBARCH_SET_SINGLESTEPPING
21  SUBARCH_SET_SINGLESTEPPING(child, 1);
22 #endif
23 }
24 
26 {
27  child->ptrace &= ~PT_DTRACE;
28  child->thread.singlestep_syscall = 0;
29 
30 #ifdef SUBARCH_SET_SINGLESTEPPING
31  SUBARCH_SET_SINGLESTEPPING(child, 0);
32 #endif
33 }
34 
35 /*
36  * Called by kernel/ptrace.c when detaching..
37  */
39 {
41 }
42 
43 extern int peek_user(struct task_struct * child, long addr, long data);
44 extern int poke_user(struct task_struct * child, long addr, long data);
45 
46 long arch_ptrace(struct task_struct *child, long request,
47  unsigned long addr, unsigned long data)
48 {
49  int i, ret;
50  unsigned long __user *p = (void __user *)data;
51  void __user *vp = p;
52 
53  switch (request) {
54  /* read the word at location addr in the USER area. */
55  case PTRACE_PEEKUSR:
56  ret = peek_user(child, addr, data);
57  break;
58 
59  /* write the word at location addr in the USER area */
60  case PTRACE_POKEUSR:
61  ret = poke_user(child, addr, data);
62  break;
63 
64  case PTRACE_SYSEMU:
66  ret = -EIO;
67  break;
68 
69 #ifdef PTRACE_GETREGS
70  case PTRACE_GETREGS: { /* Get all gp regs from the child. */
72  ret = -EIO;
73  break;
74  }
75  for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
76  __put_user(getreg(child, i), p);
77  p++;
78  }
79  ret = 0;
80  break;
81  }
82 #endif
83 #ifdef PTRACE_SETREGS
84  case PTRACE_SETREGS: { /* Set all gp regs in the child. */
85  unsigned long tmp = 0;
87  ret = -EIO;
88  break;
89  }
90  for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
91  __get_user(tmp, p);
92  putreg(child, i, tmp);
93  p++;
94  }
95  ret = 0;
96  break;
97  }
98 #endif
100  ret = ptrace_get_thread_area(child, addr, vp);
101  break;
102 
104  ret = ptrace_set_thread_area(child, addr, vp);
105  break;
106 
107  case PTRACE_FAULTINFO: {
108  /*
109  * Take the info from thread->arch->faultinfo,
110  * but transfer max. sizeof(struct ptrace_faultinfo).
111  * On i386, ptrace_faultinfo is smaller!
112  */
113  ret = copy_to_user(p, &child->thread.arch.faultinfo,
114  sizeof(struct ptrace_faultinfo)) ?
115  -EIO : 0;
116  break;
117  }
118 
119 #ifdef PTRACE_LDT
120  case PTRACE_LDT: {
121  struct ptrace_ldt ldt;
122 
123  if (copy_from_user(&ldt, p, sizeof(ldt))) {
124  ret = -EIO;
125  break;
126  }
127 
128  /*
129  * This one is confusing, so just punt and return -EIO for
130  * now
131  */
132  ret = -EIO;
133  break;
134  }
135 #endif
136  default:
137  ret = ptrace_request(child, request, addr, data);
138  if (ret == -EIO)
139  ret = subarch_ptrace(child, request, addr, data);
140  break;
141  }
142 
143  return ret;
144 }
145 
146 static void send_sigtrap(struct task_struct *tsk, struct uml_pt_regs *regs,
147  int error_code)
148 {
149  struct siginfo info;
150 
151  memset(&info, 0, sizeof(info));
152  info.si_signo = SIGTRAP;
153  info.si_code = TRAP_BRKPT;
154 
155  /* User-mode eip? */
156  info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;
157 
158  /* Send us the fake SIGTRAP */
159  force_sig_info(SIGTRAP, &info, tsk);
160 }
161 
162 /*
163  * XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
164  * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
165  */
166 void syscall_trace_enter(struct pt_regs *regs)
167 {
168  audit_syscall_entry(HOST_AUDIT_ARCH,
169  UPT_SYSCALL_NR(&regs->regs),
170  UPT_SYSCALL_ARG1(&regs->regs),
171  UPT_SYSCALL_ARG2(&regs->regs),
172  UPT_SYSCALL_ARG3(&regs->regs),
173  UPT_SYSCALL_ARG4(&regs->regs));
174 
175  if (!test_thread_flag(TIF_SYSCALL_TRACE))
176  return;
177 
178  tracehook_report_syscall_entry(regs);
179 }
180 
181 void syscall_trace_leave(struct pt_regs *regs)
182 {
183  int ptraced = current->ptrace;
184 
185  audit_syscall_exit(regs);
186 
187  /* Fake a debug trap */
188  if (ptraced & PT_DTRACE)
189  send_sigtrap(current, &regs->regs, 0);
190 
191  if (!test_thread_flag(TIF_SYSCALL_TRACE))
192  return;
193 
194  tracehook_report_syscall_exit(regs, 0);
195  /* force do_signal() --> is_syscall() */
196  if (ptraced & PT_PTRACED)
197  set_thread_flag(TIF_SIGPENDING);
198 }