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