[PATCH] gdb/strace fix for 2.5.x
[opensuse:kernel.git] / arch / alpha / kernel / ptrace.c
1 /* ptrace.c */
2 /* By Ross Biro 1/23/92 */
3 /* edited by Linus Torvalds */
4 /* mangled further by Bob Manson (manson@santafe.edu) */
5 /* more mutilation by David Mosberger (davidm@azstarnet.com) */
6
7 #include <linux/kernel.h>
8 #include <linux/sched.h>
9 #include <linux/mm.h>
10 #include <linux/smp.h>
11 #include <linux/smp_lock.h>
12 #include <linux/errno.h>
13 #include <linux/ptrace.h>
14 #include <linux/user.h>
15 #include <linux/slab.h>
16
17 #include <asm/uaccess.h>
18 #include <asm/pgtable.h>
19 #include <asm/system.h>
20 #include <asm/fpu.h>
21
22 #include "proto.h"
23
24 #define DEBUG   DBG_MEM
25 #undef DEBUG
26
27 #ifdef DEBUG
28 enum {
29         DBG_MEM         = (1<<0),
30         DBG_BPT         = (1<<1),
31         DBG_MEM_ALL     = (1<<2)
32 };
33 #define DBG(fac,args)   {if ((fac) & DEBUG) printk args;}
34 #else
35 #define DBG(fac,args)
36 #endif
37
38 #define BREAKINST       0x00000080      /* call_pal bpt */
39
40 /*
41  * does not yet catch signals sent when the child dies.
42  * in exit.c or in signal.c.
43  */
44
45 /*
46  * Processes always block with the following stack-layout:
47  *
48  *  +================================+ <---- task + 2*PAGE_SIZE
49  *  | PALcode saved frame (ps, pc,   | ^
50  *  | gp, a0, a1, a2)                | |
51  *  +================================+ | struct pt_regs
52  *  |                                | |
53  *  | frame generated by SAVE_ALL    | |
54  *  |                                | v
55  *  +================================+
56  *  |                                | ^
57  *  | frame saved by do_switch_stack | | struct switch_stack
58  *  |                                | v
59  *  +================================+
60  */
61
62 /* 
63  * The following table maps a register index into the stack offset at
64  * which the register is saved.  Register indices are 0-31 for integer
65  * regs, 32-63 for fp regs, and 64 for the pc.  Notice that sp and
66  * zero have no stack-slot and need to be treated specially (see
67  * get_reg/put_reg below).
68  */
69 enum {
70         REG_R0 = 0, REG_F0 = 32, REG_FPCR = 63, REG_PC = 64
71 };
72
73 static int regoff[] = {
74         PT_REG(    r0), PT_REG(    r1), PT_REG(    r2), PT_REG(   r3),
75         PT_REG(    r4), PT_REG(    r5), PT_REG(    r6), PT_REG(   r7),
76         PT_REG(    r8), SW_REG(    r9), SW_REG(   r10), SW_REG(  r11),
77         SW_REG(   r12), SW_REG(   r13), SW_REG(   r14), SW_REG(  r15),
78         PT_REG(   r16), PT_REG(   r17), PT_REG(   r18), PT_REG(  r19),
79         PT_REG(   r20), PT_REG(   r21), PT_REG(   r22), PT_REG(  r23),
80         PT_REG(   r24), PT_REG(   r25), PT_REG(   r26), PT_REG(  r27),
81         PT_REG(   r28), PT_REG(    gp),            -1,             -1,
82         SW_REG(fp[ 0]), SW_REG(fp[ 1]), SW_REG(fp[ 2]), SW_REG(fp[ 3]),
83         SW_REG(fp[ 4]), SW_REG(fp[ 5]), SW_REG(fp[ 6]), SW_REG(fp[ 7]),
84         SW_REG(fp[ 8]), SW_REG(fp[ 9]), SW_REG(fp[10]), SW_REG(fp[11]),
85         SW_REG(fp[12]), SW_REG(fp[13]), SW_REG(fp[14]), SW_REG(fp[15]),
86         SW_REG(fp[16]), SW_REG(fp[17]), SW_REG(fp[18]), SW_REG(fp[19]),
87         SW_REG(fp[20]), SW_REG(fp[21]), SW_REG(fp[22]), SW_REG(fp[23]),
88         SW_REG(fp[24]), SW_REG(fp[25]), SW_REG(fp[26]), SW_REG(fp[27]),
89         SW_REG(fp[28]), SW_REG(fp[29]), SW_REG(fp[30]), SW_REG(fp[31]),
90         PT_REG(    pc)
91 };
92
93 static long zero;
94
95 /*
96  * Get address of register REGNO in task TASK.
97  */
98 static long *
99 get_reg_addr(struct task_struct * task, unsigned long regno)
100 {
101         long *addr;
102
103         if (regno == 30) {
104                 addr = &task->thread_info->pcb.usp;
105         } else if (regno == 31 || regno > 64) {
106                 zero = 0;
107                 addr = &zero;
108         } else {
109                 addr = (long *)((long)task->thread_info + regoff[regno]);
110         }
111         return addr;
112 }
113
114 /*
115  * Get contents of register REGNO in task TASK.
116  */
117 static long
118 get_reg(struct task_struct * task, unsigned long regno)
119 {
120         /* Special hack for fpcr -- combine hardware and software bits.  */
121         if (regno == 63) {
122                 unsigned long fpcr = *get_reg_addr(task, regno);
123                 unsigned long swcr
124                   = task->thread_info->ieee_state & IEEE_SW_MASK;
125                 swcr = swcr_update_status(swcr, fpcr);
126                 return fpcr | swcr;
127         }
128         return *get_reg_addr(task, regno);
129 }
130
131 /*
132  * Write contents of register REGNO in task TASK.
133  */
134 static int
135 put_reg(struct task_struct *task, unsigned long regno, long data)
136 {
137         if (regno == 63) {
138                 task->thread_info->ieee_state
139                   = ((task->thread_info->ieee_state & ~IEEE_SW_MASK)
140                      | (data & IEEE_SW_MASK));
141                 data = (data & FPCR_DYN_MASK) | ieee_swcr_to_fpcr(data);
142         }
143         *get_reg_addr(task, regno) = data;
144         return 0;
145 }
146
147 static inline int
148 read_int(struct task_struct *task, unsigned long addr, int * data)
149 {
150         int copied = access_process_vm(task, addr, data, sizeof(int), 0);
151         return (copied == sizeof(int)) ? 0 : -EIO;
152 }
153
154 static inline int
155 write_int(struct task_struct *task, unsigned long addr, int data)
156 {
157         int copied = access_process_vm(task, addr, &data, sizeof(int), 1);
158         return (copied == sizeof(int)) ? 0 : -EIO;
159 }
160
161 /*
162  * Set breakpoint.
163  */
164 int
165 ptrace_set_bpt(struct task_struct * child)
166 {
167         int displ, i, res, reg_b, nsaved = 0;
168         u32 insn, op_code;
169         unsigned long pc;
170
171         pc  = get_reg(child, REG_PC);
172         res = read_int(child, pc, &insn);
173         if (res < 0)
174                 return res;
175
176         op_code = insn >> 26;
177         if (op_code >= 0x30) {
178                 /*
179                  * It's a branch: instead of trying to figure out
180                  * whether the branch will be taken or not, we'll put
181                  * a breakpoint at either location.  This is simpler,
182                  * more reliable, and probably not a whole lot slower
183                  * than the alternative approach of emulating the
184                  * branch (emulation can be tricky for fp branches).
185                  */
186                 displ = ((s32)(insn << 11)) >> 9;
187                 child->thread_info->bpt_addr[nsaved++] = pc + 4;
188                 if (displ)              /* guard against unoptimized code */
189                         child->thread_info->bpt_addr[nsaved++]
190                           = pc + 4 + displ;
191                 DBG(DBG_BPT, ("execing branch\n"));
192         } else if (op_code == 0x1a) {
193                 reg_b = (insn >> 16) & 0x1f;
194                 child->thread_info->bpt_addr[nsaved++] = get_reg(child, reg_b);
195                 DBG(DBG_BPT, ("execing jump\n"));
196         } else {
197                 child->thread_info->bpt_addr[nsaved++] = pc + 4;
198                 DBG(DBG_BPT, ("execing normal insn\n"));
199         }
200
201         /* install breakpoints: */
202         for (i = 0; i < nsaved; ++i) {
203                 res = read_int(child, child->thread_info->bpt_addr[i], &insn);
204                 if (res < 0)
205                         return res;
206                 child->thread_info->bpt_insn[i] = insn;
207                 DBG(DBG_BPT, ("    -> next_pc=%lx\n",
208                               child->thread_info->bpt_addr[i]));
209                 res = write_int(child, child->thread_info->bpt_addr[i],
210                                 BREAKINST);
211                 if (res < 0)
212                         return res;
213         }
214         child->thread_info->bpt_nsaved = nsaved;
215         return 0;
216 }
217
218 /*
219  * Ensure no single-step breakpoint is pending.  Returns non-zero
220  * value if child was being single-stepped.
221  */
222 int
223 ptrace_cancel_bpt(struct task_struct * child)
224 {
225         int i, nsaved = child->thread_info->bpt_nsaved;
226
227         child->thread_info->bpt_nsaved = 0;
228
229         if (nsaved > 2) {
230                 printk("ptrace_cancel_bpt: bogus nsaved: %d!\n", nsaved);
231                 nsaved = 2;
232         }
233
234         for (i = 0; i < nsaved; ++i) {
235                 write_int(child, child->thread_info->bpt_addr[i],
236                           child->thread_info->bpt_insn[i]);
237         }
238         return (nsaved != 0);
239 }
240
241 /*
242  * Called by kernel/ptrace.c when detaching..
243  *
244  * Make sure the single step bit is not set.
245  */
246 void ptrace_disable(struct task_struct *child)
247
248         ptrace_cancel_bpt(child);
249 }
250
251 asmlinkage long
252 sys_ptrace(long request, long pid, long addr, long data,
253            int a4, int a5, struct pt_regs regs)
254 {
255         struct task_struct *child;
256         long ret;
257
258         lock_kernel();
259         DBG(DBG_MEM, ("request=%ld pid=%ld addr=0x%lx data=0x%lx\n",
260                       request, pid, addr, data));
261         ret = -EPERM;
262         if (request == PTRACE_TRACEME) {
263                 /* are we already being traced? */
264                 if (current->ptrace & PT_PTRACED)
265                         goto out_notsk;
266                 /* set the ptrace bit in the process ptrace flags. */
267                 current->ptrace |= PT_PTRACED;
268                 ret = 0;
269                 goto out_notsk;
270         }
271         if (pid == 1)           /* you may not mess with init */
272                 goto out_notsk;
273         ret = -ESRCH;
274         read_lock(&tasklist_lock);
275         child = find_task_by_pid(pid);
276         if (child)
277                 get_task_struct(child);
278         read_unlock(&tasklist_lock);
279         if (!child)
280                 goto out_notsk;
281         if (request == PTRACE_ATTACH) {
282                 ret = ptrace_attach(child);
283                 goto out;
284         }
285         ret = -ESRCH;
286         if (!(child->ptrace & PT_PTRACED)) {
287                 DBG(DBG_MEM, ("child not traced\n"));
288                 goto out;
289         }
290         if (child->state != TASK_STOPPED) {
291                 DBG(DBG_MEM, ("child process not stopped\n"));
292                 if (request != PTRACE_KILL)
293                         goto out;
294         }
295         if (child->parent != current) {
296                 DBG(DBG_MEM, ("child not parent of this process\n"));
297                 goto out;
298         }
299
300         switch (request) {
301         /* When I and D space are separate, these will need to be fixed.  */
302         case PTRACE_PEEKTEXT: /* read word at location addr. */
303         case PTRACE_PEEKDATA: {
304                 unsigned long tmp;
305                 int copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
306                 ret = -EIO;
307                 if (copied != sizeof(tmp))
308                         goto out;
309                 
310                 regs.r0 = 0;    /* special return: no errors */
311                 ret = tmp;
312                 goto out;
313         }
314
315         /* Read register number ADDR. */
316         case PTRACE_PEEKUSR:
317                 regs.r0 = 0;    /* special return: no errors */
318                 ret = get_reg(child, addr);
319                 DBG(DBG_MEM, ("peek $%ld->%#lx\n", addr, ret));
320                 goto out;
321
322         /* When I and D space are separate, this will have to be fixed.  */
323         case PTRACE_POKETEXT: /* write the word at location addr. */
324         case PTRACE_POKEDATA: {
325                 unsigned long tmp = data;
326                 int copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 1);
327                 ret = (copied == sizeof(tmp)) ? 0 : -EIO;
328                 goto out;
329         }
330
331         case PTRACE_POKEUSR: /* write the specified register */
332                 DBG(DBG_MEM, ("poke $%ld<-%#lx\n", addr, data));
333                 ret = put_reg(child, addr, data);
334                 goto out;
335
336         case PTRACE_SYSCALL: /* continue and stop at next
337                                 (return from) syscall */
338         case PTRACE_CONT:    /* restart after signal. */
339                 ret = -EIO;
340                 if ((unsigned long) data > _NSIG)
341                         goto out;
342                 if (request == PTRACE_SYSCALL)
343                         set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
344                 else
345                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
346                 child->exit_code = data;
347                 wake_up_process(child);
348                 /* make sure single-step breakpoint is gone. */
349                 ptrace_cancel_bpt(child);
350                 ret = data;
351                 goto out;
352
353         /*
354          * Make the child exit.  Best I can do is send it a sigkill.
355          * perhaps it should be put in the status that it wants to
356          * exit.
357          */
358         case PTRACE_KILL:
359                 if (child->state != TASK_ZOMBIE) {
360                         wake_up_process(child);
361                         child->exit_code = SIGKILL;
362                 }
363                 /* make sure single-step breakpoint is gone. */
364                 ptrace_cancel_bpt(child);
365                 ret = 0;
366                 goto out;
367
368         case PTRACE_SINGLESTEP:  /* execute single instruction. */
369                 ret = -EIO;
370                 if ((unsigned long) data > _NSIG)
371                         goto out;
372                 /* Mark single stepping.  */
373                 child->thread_info->bpt_nsaved = -1;
374                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
375                 wake_up_process(child);
376                 child->exit_code = data;
377                 /* give it a chance to run. */
378                 ret = 0;
379                 goto out;
380
381         case PTRACE_DETACH:      /* detach a process that was attached. */
382                 ret = ptrace_detach(child, data);
383                 goto out;
384
385         default:
386                 ret = -EIO;
387                 goto out;
388         }
389  out:
390         put_task_struct(child);
391  out_notsk:
392         unlock_kernel();
393         return ret;
394 }
395
396 asmlinkage void
397 syscall_trace(void)
398 {
399         if (!test_thread_flag(TIF_SYSCALL_TRACE))
400                 return;
401         if (!(current->ptrace & PT_PTRACED))
402                 return;
403         current->exit_code = SIGTRAP;
404         current->state = TASK_STOPPED;
405         notify_parent(current, SIGCHLD);
406         schedule();
407         /*
408          * This isn't the same as continuing with a signal, but it will do
409          * for normal use.  strace only continues with a signal if the
410          * stopping signal is not SIGTRAP.  -brl
411          */
412         if (current->exit_code) {
413                 send_sig(current->exit_code, current, 1);
414                 current->exit_code = 0;
415         }
416 }