Commit | Line | Data |
---|---|---|
5f97f7f9 HS |
1 | /* |
2 | * Copyright (C) 2004-2006 Atmel Corporation | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | #undef DEBUG | |
9 | #include <linux/kernel.h> | |
10 | #include <linux/sched.h> | |
11 | #include <linux/mm.h> | |
12 | #include <linux/smp_lock.h> | |
13 | #include <linux/ptrace.h> | |
14 | #include <linux/errno.h> | |
15 | #include <linux/user.h> | |
16 | #include <linux/security.h> | |
17 | #include <linux/unistd.h> | |
18 | #include <linux/notifier.h> | |
19 | ||
20 | #include <asm/traps.h> | |
21 | #include <asm/uaccess.h> | |
22 | #include <asm/ocd.h> | |
23 | #include <asm/mmu_context.h> | |
1eeb66a1 | 24 | #include <linux/kdebug.h> |
5f97f7f9 HS |
25 | |
26 | static struct pt_regs *get_user_regs(struct task_struct *tsk) | |
27 | { | |
28 | return (struct pt_regs *)((unsigned long) tsk->thread_info + | |
29 | THREAD_SIZE - sizeof(struct pt_regs)); | |
30 | } | |
31 | ||
32 | static void ptrace_single_step(struct task_struct *tsk) | |
33 | { | |
34 | pr_debug("ptrace_single_step: pid=%u, SR=0x%08lx\n", | |
35 | tsk->pid, tsk->thread.cpu_context.sr); | |
36 | if (!(tsk->thread.cpu_context.sr & SR_D)) { | |
37 | /* | |
38 | * Set a breakpoint at the current pc to force the | |
39 | * process into debug mode. The syscall/exception | |
40 | * exit code will set a breakpoint at the return | |
41 | * address when this flag is set. | |
42 | */ | |
43 | pr_debug("ptrace_single_step: Setting TIF_BREAKPOINT\n"); | |
44 | set_tsk_thread_flag(tsk, TIF_BREAKPOINT); | |
45 | } | |
46 | ||
47 | /* The monitor code will do the actual step for us */ | |
48 | set_tsk_thread_flag(tsk, TIF_SINGLE_STEP); | |
49 | } | |
50 | ||
51 | /* | |
52 | * Called by kernel/ptrace.c when detaching | |
53 | * | |
54 | * Make sure any single step bits, etc. are not set | |
55 | */ | |
56 | void ptrace_disable(struct task_struct *child) | |
57 | { | |
58 | clear_tsk_thread_flag(child, TIF_SINGLE_STEP); | |
59 | } | |
60 | ||
61 | /* | |
62 | * Handle hitting a breakpoint | |
63 | */ | |
64 | static void ptrace_break(struct task_struct *tsk, struct pt_regs *regs) | |
65 | { | |
66 | siginfo_t info; | |
67 | ||
68 | info.si_signo = SIGTRAP; | |
69 | info.si_errno = 0; | |
70 | info.si_code = TRAP_BRKPT; | |
71 | info.si_addr = (void __user *)instruction_pointer(regs); | |
72 | ||
73 | pr_debug("ptrace_break: Sending SIGTRAP to PID %u (pc = 0x%p)\n", | |
74 | tsk->pid, info.si_addr); | |
75 | force_sig_info(SIGTRAP, &info, tsk); | |
76 | } | |
77 | ||
78 | /* | |
79 | * Read the word at offset "offset" into the task's "struct user". We | |
80 | * actually access the pt_regs struct stored on the kernel stack. | |
81 | */ | |
82 | static int ptrace_read_user(struct task_struct *tsk, unsigned long offset, | |
83 | unsigned long __user *data) | |
84 | { | |
85 | unsigned long *regs; | |
86 | unsigned long value; | |
87 | ||
88 | pr_debug("ptrace_read_user(%p, %#lx, %p)\n", | |
89 | tsk, offset, data); | |
90 | ||
91 | if (offset & 3 || offset >= sizeof(struct user)) { | |
92 | printk("ptrace_read_user: invalid offset 0x%08lx\n", offset); | |
93 | return -EIO; | |
94 | } | |
95 | ||
96 | regs = (unsigned long *)get_user_regs(tsk); | |
97 | ||
98 | value = 0; | |
99 | if (offset < sizeof(struct pt_regs)) | |
100 | value = regs[offset / sizeof(regs[0])]; | |
101 | ||
102 | return put_user(value, data); | |
103 | } | |
104 | ||
105 | /* | |
106 | * Write the word "value" to offset "offset" into the task's "struct | |
107 | * user". We actually access the pt_regs struct stored on the kernel | |
108 | * stack. | |
109 | */ | |
110 | static int ptrace_write_user(struct task_struct *tsk, unsigned long offset, | |
111 | unsigned long value) | |
112 | { | |
113 | unsigned long *regs; | |
114 | ||
115 | if (offset & 3 || offset >= sizeof(struct user)) { | |
116 | printk("ptrace_write_user: invalid offset 0x%08lx\n", offset); | |
117 | return -EIO; | |
118 | } | |
119 | ||
120 | if (offset >= sizeof(struct pt_regs)) | |
121 | return 0; | |
122 | ||
123 | regs = (unsigned long *)get_user_regs(tsk); | |
124 | regs[offset / sizeof(regs[0])] = value; | |
125 | ||
126 | return 0; | |
127 | } | |
128 | ||
129 | static int ptrace_getregs(struct task_struct *tsk, void __user *uregs) | |
130 | { | |
131 | struct pt_regs *regs = get_user_regs(tsk); | |
132 | ||
133 | return copy_to_user(uregs, regs, sizeof(*regs)) ? -EFAULT : 0; | |
134 | } | |
135 | ||
136 | static int ptrace_setregs(struct task_struct *tsk, const void __user *uregs) | |
137 | { | |
138 | struct pt_regs newregs; | |
139 | int ret; | |
140 | ||
141 | ret = -EFAULT; | |
142 | if (copy_from_user(&newregs, uregs, sizeof(newregs)) == 0) { | |
143 | struct pt_regs *regs = get_user_regs(tsk); | |
144 | ||
145 | ret = -EINVAL; | |
146 | if (valid_user_regs(&newregs)) { | |
147 | *regs = newregs; | |
148 | ret = 0; | |
149 | } | |
150 | } | |
151 | ||
152 | return ret; | |
153 | } | |
154 | ||
155 | long arch_ptrace(struct task_struct *child, long request, long addr, long data) | |
156 | { | |
157 | unsigned long tmp; | |
158 | int ret; | |
159 | ||
6ea850b5 | 160 | pr_debug("arch_ptrace(%ld, %d, %#lx, %#lx)\n", |
5f97f7f9 HS |
161 | request, child->pid, addr, data); |
162 | ||
163 | pr_debug("ptrace: Enabling monitor mode...\n"); | |
164 | __mtdr(DBGREG_DC, __mfdr(DBGREG_DC) | DC_MM | DC_DBE); | |
165 | ||
166 | switch (request) { | |
167 | /* Read the word at location addr in the child process */ | |
168 | case PTRACE_PEEKTEXT: | |
169 | case PTRACE_PEEKDATA: | |
170 | ret = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); | |
171 | if (ret == sizeof(tmp)) | |
172 | ret = put_user(tmp, (unsigned long __user *)data); | |
173 | else | |
174 | ret = -EIO; | |
175 | break; | |
176 | ||
177 | case PTRACE_PEEKUSR: | |
178 | ret = ptrace_read_user(child, addr, | |
179 | (unsigned long __user *)data); | |
180 | break; | |
181 | ||
182 | /* Write the word in data at location addr */ | |
183 | case PTRACE_POKETEXT: | |
184 | case PTRACE_POKEDATA: | |
185 | ret = access_process_vm(child, addr, &data, sizeof(data), 1); | |
186 | if (ret == sizeof(data)) | |
187 | ret = 0; | |
188 | else | |
189 | ret = -EIO; | |
190 | break; | |
191 | ||
192 | case PTRACE_POKEUSR: | |
193 | ret = ptrace_write_user(child, addr, data); | |
194 | break; | |
195 | ||
196 | /* continue and stop at next (return from) syscall */ | |
197 | case PTRACE_SYSCALL: | |
198 | /* restart after signal */ | |
199 | case PTRACE_CONT: | |
200 | ret = -EIO; | |
201 | if (!valid_signal(data)) | |
202 | break; | |
203 | if (request == PTRACE_SYSCALL) | |
204 | set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | |
205 | else | |
206 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | |
207 | child->exit_code = data; | |
208 | /* XXX: Are we sure no breakpoints are active here? */ | |
209 | wake_up_process(child); | |
210 | ret = 0; | |
211 | break; | |
212 | ||
213 | /* | |
214 | * Make the child exit. Best I can do is send it a | |
215 | * SIGKILL. Perhaps it should be put in the status that it | |
216 | * wants to exit. | |
217 | */ | |
218 | case PTRACE_KILL: | |
219 | ret = 0; | |
220 | if (child->exit_state == EXIT_ZOMBIE) | |
221 | break; | |
222 | child->exit_code = SIGKILL; | |
223 | wake_up_process(child); | |
224 | break; | |
225 | ||
226 | /* | |
227 | * execute single instruction. | |
228 | */ | |
229 | case PTRACE_SINGLESTEP: | |
230 | ret = -EIO; | |
231 | if (!valid_signal(data)) | |
232 | break; | |
233 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | |
234 | ptrace_single_step(child); | |
235 | child->exit_code = data; | |
236 | wake_up_process(child); | |
237 | ret = 0; | |
238 | break; | |
239 | ||
240 | /* Detach a process that was attached */ | |
241 | case PTRACE_DETACH: | |
242 | ret = ptrace_detach(child, data); | |
243 | break; | |
244 | ||
245 | case PTRACE_GETREGS: | |
246 | ret = ptrace_getregs(child, (void __user *)data); | |
247 | break; | |
248 | ||
249 | case PTRACE_SETREGS: | |
250 | ret = ptrace_setregs(child, (const void __user *)data); | |
251 | break; | |
252 | ||
253 | default: | |
254 | ret = ptrace_request(child, request, addr, data); | |
255 | break; | |
256 | } | |
257 | ||
258 | pr_debug("sys_ptrace returning %d (DC = 0x%08lx)\n", ret, __mfdr(DBGREG_DC)); | |
259 | return ret; | |
260 | } | |
261 | ||
262 | asmlinkage void syscall_trace(void) | |
263 | { | |
264 | pr_debug("syscall_trace called\n"); | |
265 | if (!test_thread_flag(TIF_SYSCALL_TRACE)) | |
266 | return; | |
267 | if (!(current->ptrace & PT_PTRACED)) | |
268 | return; | |
269 | ||
270 | pr_debug("syscall_trace: notifying parent\n"); | |
271 | /* The 0x80 provides a way for the tracing parent to | |
272 | * distinguish between a syscall stop and SIGTRAP delivery */ | |
273 | ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) | |
274 | ? 0x80 : 0)); | |
275 | ||
276 | /* | |
277 | * this isn't the same as continuing with a signal, but it | |
278 | * will do for normal use. strace only continues with a | |
279 | * signal if the stopping signal is not SIGTRAP. -brl | |
280 | */ | |
281 | if (current->exit_code) { | |
282 | pr_debug("syscall_trace: sending signal %d to PID %u\n", | |
283 | current->exit_code, current->pid); | |
284 | send_sig(current->exit_code, current, 1); | |
285 | current->exit_code = 0; | |
286 | } | |
287 | } | |
288 | ||
289 | asmlinkage void do_debug_priv(struct pt_regs *regs) | |
290 | { | |
291 | unsigned long dc, ds; | |
292 | unsigned long die_val; | |
293 | ||
294 | ds = __mfdr(DBGREG_DS); | |
295 | ||
296 | pr_debug("do_debug_priv: pc = %08lx, ds = %08lx\n", regs->pc, ds); | |
297 | ||
298 | if (ds & DS_SSS) | |
299 | die_val = DIE_SSTEP; | |
300 | else | |
301 | die_val = DIE_BREAKPOINT; | |
302 | ||
1eeb66a1 | 303 | if (notify_die(die_val, "ptrace", regs, 0, 0, SIGTRAP) == NOTIFY_STOP) |
5f97f7f9 HS |
304 | return; |
305 | ||
306 | if (likely(ds & DS_SSS)) { | |
307 | extern void itlb_miss(void); | |
308 | extern void tlb_miss_common(void); | |
309 | struct thread_info *ti; | |
310 | ||
311 | dc = __mfdr(DBGREG_DC); | |
312 | dc &= ~DC_SS; | |
313 | __mtdr(DBGREG_DC, dc); | |
314 | ||
315 | ti = current_thread_info(); | |
a19b4a14 | 316 | set_ti_thread_flag(ti, TIF_BREAKPOINT); |
5f97f7f9 HS |
317 | |
318 | /* The TLB miss handlers don't check thread flags */ | |
319 | if ((regs->pc >= (unsigned long)&itlb_miss) | |
320 | && (regs->pc <= (unsigned long)&tlb_miss_common)) { | |
321 | __mtdr(DBGREG_BWA2A, sysreg_read(RAR_EX)); | |
322 | __mtdr(DBGREG_BWC2A, 0x40000001 | (get_asid() << 1)); | |
323 | } | |
324 | ||
325 | /* | |
326 | * If we're running in supervisor mode, the breakpoint | |
327 | * will take us where we want directly, no need to | |
328 | * single step. | |
329 | */ | |
330 | if ((regs->sr & MODE_MASK) != MODE_SUPERVISOR) | |
a19b4a14 | 331 | set_ti_thread_flag(ti, TIF_SINGLE_STEP); |
5f97f7f9 HS |
332 | } else { |
333 | panic("Unable to handle debug trap at pc = %08lx\n", | |
334 | regs->pc); | |
335 | } | |
336 | } | |
337 | ||
338 | /* | |
339 | * Handle breakpoints, single steps and other debuggy things. To keep | |
340 | * things simple initially, we run with interrupts and exceptions | |
341 | * disabled all the time. | |
342 | */ | |
343 | asmlinkage void do_debug(struct pt_regs *regs) | |
344 | { | |
345 | unsigned long dc, ds; | |
346 | ||
347 | ds = __mfdr(DBGREG_DS); | |
348 | pr_debug("do_debug: pc = %08lx, ds = %08lx\n", regs->pc, ds); | |
349 | ||
350 | if (test_thread_flag(TIF_BREAKPOINT)) { | |
351 | pr_debug("TIF_BREAKPOINT set\n"); | |
352 | /* We're taking care of it */ | |
353 | clear_thread_flag(TIF_BREAKPOINT); | |
354 | __mtdr(DBGREG_BWC2A, 0); | |
355 | } | |
356 | ||
357 | if (test_thread_flag(TIF_SINGLE_STEP)) { | |
358 | pr_debug("TIF_SINGLE_STEP set, ds = 0x%08lx\n", ds); | |
359 | if (ds & DS_SSS) { | |
360 | dc = __mfdr(DBGREG_DC); | |
361 | dc &= ~DC_SS; | |
362 | __mtdr(DBGREG_DC, dc); | |
363 | ||
364 | clear_thread_flag(TIF_SINGLE_STEP); | |
365 | ptrace_break(current, regs); | |
366 | } | |
367 | } else { | |
368 | /* regular breakpoint */ | |
369 | ptrace_break(current, regs); | |
370 | } | |
371 | } |