1
2
3
4
5
6
7
8#undef DEBUG
9#include <linux/kernel.h>
10#include <linux/sched.h>
11#include <linux/mm.h>
12#include <linux/ptrace.h>
13#include <linux/errno.h>
14#include <linux/user.h>
15#include <linux/security.h>
16#include <linux/unistd.h>
17#include <linux/notifier.h>
18
19#include <asm/traps.h>
20#include <asm/uaccess.h>
21#include <asm/ocd.h>
22#include <asm/mmu_context.h>
23#include <linux/kdebug.h>
24
25static struct pt_regs *get_user_regs(struct task_struct *tsk)
26{
27 return (struct pt_regs *)((unsigned long)task_stack_page(tsk) +
28 THREAD_SIZE - sizeof(struct pt_regs));
29}
30
31static void ptrace_single_step(struct task_struct *tsk)
32{
33 pr_debug("ptrace_single_step: pid=%u, PC=0x%08lx, SR=0x%08lx\n",
34 tsk->pid, task_pt_regs(tsk)->pc, task_pt_regs(tsk)->sr);
35
36
37
38
39
40
41
42
43
44
45
46
47
48 set_tsk_thread_flag(tsk, TIF_BREAKPOINT);
49 set_tsk_thread_flag(tsk, TIF_SINGLE_STEP);
50}
51
52
53
54
55
56
57void ptrace_disable(struct task_struct *child)
58{
59 clear_tsk_thread_flag(child, TIF_SINGLE_STEP);
60 clear_tsk_thread_flag(child, TIF_BREAKPOINT);
61 ocd_disable(child);
62}
63
64
65
66
67
68static int ptrace_read_user(struct task_struct *tsk, unsigned long offset,
69 unsigned long __user *data)
70{
71 unsigned long *regs;
72 unsigned long value;
73
74 if (offset & 3 || offset >= sizeof(struct user)) {
75 printk("ptrace_read_user: invalid offset 0x%08lx\n", offset);
76 return -EIO;
77 }
78
79 regs = (unsigned long *)get_user_regs(tsk);
80
81 value = 0;
82 if (offset < sizeof(struct pt_regs))
83 value = regs[offset / sizeof(regs[0])];
84
85 pr_debug("ptrace_read_user(%s[%u], %#lx, %p) -> %#lx\n",
86 tsk->comm, tsk->pid, offset, data, value);
87
88 return put_user(value, data);
89}
90
91
92
93
94
95
96static int ptrace_write_user(struct task_struct *tsk, unsigned long offset,
97 unsigned long value)
98{
99 unsigned long *regs;
100
101 pr_debug("ptrace_write_user(%s[%u], %#lx, %#lx)\n",
102 tsk->comm, tsk->pid, offset, value);
103
104 if (offset & 3 || offset >= sizeof(struct user)) {
105 pr_debug(" invalid offset 0x%08lx\n", offset);
106 return -EIO;
107 }
108
109 if (offset >= sizeof(struct pt_regs))
110 return 0;
111
112 regs = (unsigned long *)get_user_regs(tsk);
113 regs[offset / sizeof(regs[0])] = value;
114
115 return 0;
116}
117
118static int ptrace_getregs(struct task_struct *tsk, void __user *uregs)
119{
120 struct pt_regs *regs = get_user_regs(tsk);
121
122 return copy_to_user(uregs, regs, sizeof(*regs)) ? -EFAULT : 0;
123}
124
125static int ptrace_setregs(struct task_struct *tsk, const void __user *uregs)
126{
127 struct pt_regs newregs;
128 int ret;
129
130 ret = -EFAULT;
131 if (copy_from_user(&newregs, uregs, sizeof(newregs)) == 0) {
132 struct pt_regs *regs = get_user_regs(tsk);
133
134 ret = -EINVAL;
135 if (valid_user_regs(&newregs)) {
136 *regs = newregs;
137 ret = 0;
138 }
139 }
140
141 return ret;
142}
143
144long arch_ptrace(struct task_struct *child, long request, long addr, long data)
145{
146 int ret;
147
148 switch (request) {
149
150 case PTRACE_PEEKTEXT:
151 case PTRACE_PEEKDATA:
152 ret = generic_ptrace_peekdata(child, addr, data);
153 break;
154
155 case PTRACE_PEEKUSR:
156 ret = ptrace_read_user(child, addr,
157 (unsigned long __user *)data);
158 break;
159
160
161 case PTRACE_POKETEXT:
162 case PTRACE_POKEDATA:
163 ret = generic_ptrace_pokedata(child, addr, data);
164 break;
165
166 case PTRACE_POKEUSR:
167 ret = ptrace_write_user(child, addr, data);
168 break;
169
170
171 case PTRACE_SYSCALL:
172
173 case PTRACE_CONT:
174 ret = -EIO;
175 if (!valid_signal(data))
176 break;
177 if (request == PTRACE_SYSCALL)
178 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
179 else
180 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
181 child->exit_code = data;
182
183 wake_up_process(child);
184 ret = 0;
185 break;
186
187
188
189
190
191
192 case PTRACE_KILL:
193 ret = 0;
194 if (child->exit_state == EXIT_ZOMBIE)
195 break;
196 child->exit_code = SIGKILL;
197 wake_up_process(child);
198 break;
199
200
201
202
203 case PTRACE_SINGLESTEP:
204 ret = -EIO;
205 if (!valid_signal(data))
206 break;
207 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
208 ptrace_single_step(child);
209 child->exit_code = data;
210 wake_up_process(child);
211 ret = 0;
212 break;
213
214 case PTRACE_GETREGS:
215 ret = ptrace_getregs(child, (void __user *)data);
216 break;
217
218 case PTRACE_SETREGS:
219 ret = ptrace_setregs(child, (const void __user *)data);
220 break;
221
222 default:
223 ret = ptrace_request(child, request, addr, data);
224 break;
225 }
226
227 return ret;
228}
229
230asmlinkage void syscall_trace(void)
231{
232 if (!test_thread_flag(TIF_SYSCALL_TRACE))
233 return;
234 if (!(current->ptrace & PT_PTRACED))
235 return;
236
237
238
239 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
240 ? 0x80 : 0));
241
242
243
244
245
246
247 if (current->exit_code) {
248 pr_debug("syscall_trace: sending signal %d to PID %u\n",
249 current->exit_code, current->pid);
250 send_sig(current->exit_code, current, 1);
251 current->exit_code = 0;
252 }
253}
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270extern void debug_trampoline(void);
271
272asmlinkage struct pt_regs *do_debug(struct pt_regs *regs)
273{
274 struct thread_info *ti;
275 unsigned long trampoline_addr;
276 u32 status;
277 u32 ctrl;
278 int code;
279
280 status = ocd_read(DS);
281 ti = current_thread_info();
282 code = TRAP_BRKPT;
283
284 pr_debug("do_debug: status=0x%08x PC=0x%08lx SR=0x%08lx tif=0x%08lx\n",
285 status, regs->pc, regs->sr, ti->flags);
286
287 if (!user_mode(regs)) {
288 unsigned long die_val = DIE_BREAKPOINT;
289
290 if (status & (1 << OCD_DS_SSS_BIT))
291 die_val = DIE_SSTEP;
292
293 if (notify_die(die_val, "ptrace", regs, 0, 0, SIGTRAP)
294 == NOTIFY_STOP)
295 return regs;
296
297 if ((status & (1 << OCD_DS_SWB_BIT))
298 && test_and_clear_ti_thread_flag(
299 ti, TIF_BREAKPOINT)) {
300
301
302
303
304
305
306
307 regs++;
308 pr_debug(" -> TIF_BREAKPOINT done, adjusted regs:"
309 "PC=0x%08lx SR=0x%08lx\n",
310 regs->pc, regs->sr);
311 BUG_ON(!user_mode(regs));
312
313 if (test_thread_flag(TIF_SINGLE_STEP)) {
314 pr_debug("Going to do single step...\n");
315 return regs;
316 }
317
318
319
320
321
322 code = TRAP_TRACE;
323 } else if ((status & (1 << OCD_DS_SSS_BIT))
324 && test_ti_thread_flag(ti, TIF_SINGLE_STEP)) {
325
326 pr_debug("Stepped into something, "
327 "setting TIF_BREAKPOINT...\n");
328 set_ti_thread_flag(ti, TIF_BREAKPOINT);
329
330
331
332
333
334
335
336
337
338
339
340
341 if ((regs->sr & MODE_MASK) == MODE_EXCEPTION) {
342 trampoline_addr
343 = (unsigned long)&debug_trampoline;
344
345 pr_debug("Setting up trampoline...\n");
346 ti->rar_saved = sysreg_read(RAR_EX);
347 ti->rsr_saved = sysreg_read(RSR_EX);
348 sysreg_write(RAR_EX, trampoline_addr);
349 sysreg_write(RSR_EX, (MODE_EXCEPTION
350 | SR_EM | SR_GM));
351 BUG_ON(ti->rsr_saved & MODE_MASK);
352 }
353
354
355
356
357
358
359
360
361 if ((regs->sr & MODE_MASK) == MODE_SUPERVISOR) {
362 pr_debug("Supervisor; no single step\n");
363 clear_ti_thread_flag(ti, TIF_SINGLE_STEP);
364 }
365
366 ctrl = ocd_read(DC);
367 ctrl &= ~(1 << OCD_DC_SS_BIT);
368 ocd_write(DC, ctrl);
369
370 return regs;
371 } else {
372 printk(KERN_ERR "Unexpected OCD_DS value: 0x%08x\n",
373 status);
374 printk(KERN_ERR "Thread flags: 0x%08lx\n", ti->flags);
375 die("Unhandled debug trap in kernel mode",
376 regs, SIGTRAP);
377 }
378 } else if (status & (1 << OCD_DS_SSS_BIT)) {
379
380 code = TRAP_TRACE;
381
382 ctrl = ocd_read(DC);
383 ctrl &= ~(1 << OCD_DC_SS_BIT);
384 ocd_write(DC, ctrl);
385 }
386
387 pr_debug("Sending SIGTRAP: code=%d PC=0x%08lx SR=0x%08lx\n",
388 code, regs->pc, regs->sr);
389
390 clear_thread_flag(TIF_SINGLE_STEP);
391 _exception(SIGTRAP, regs, code, instruction_pointer(regs));
392
393 return regs;
394}
395