Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * arch/v850/kernel/ptrace.c -- `ptrace' system call | |
3 | * | |
4 | * Copyright (C) 2002,03,04 NEC Electronics Corporation | |
5 | * Copyright (C) 2002,03,04 Miles Bader <miles@gnu.org> | |
6 | * | |
7 | * Derived from arch/mips/kernel/ptrace.c: | |
8 | * | |
9 | * Copyright (C) 1992 Ross Biro | |
10 | * Copyright (C) Linus Torvalds | |
11 | * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle | |
12 | * Copyright (C) 1996 David S. Miller | |
13 | * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com | |
14 | * Copyright (C) 1999 MIPS Technologies, Inc. | |
15 | * | |
16 | * This file is subject to the terms and conditions of the GNU General | |
17 | * Public License. See the file COPYING in the main directory of this | |
18 | * archive for more details. | |
19 | */ | |
20 | ||
21 | #include <linux/kernel.h> | |
22 | #include <linux/mm.h> | |
23 | #include <linux/sched.h> | |
1da177e4 | 24 | #include <linux/ptrace.h> |
7ed20e1a | 25 | #include <linux/signal.h> |
1da177e4 LT |
26 | |
27 | #include <asm/errno.h> | |
28 | #include <asm/ptrace.h> | |
29 | #include <asm/processor.h> | |
30 | #include <asm/uaccess.h> | |
31 | ||
32 | /* Returns the address where the register at REG_OFFS in P is stashed away. */ | |
33 | static v850_reg_t *reg_save_addr (unsigned reg_offs, struct task_struct *t) | |
34 | { | |
35 | struct pt_regs *regs; | |
36 | ||
37 | /* Three basic cases: | |
38 | ||
39 | (1) A register normally saved before calling the scheduler, is | |
40 | available in the kernel entry pt_regs structure at the top | |
41 | of the kernel stack. The kernel trap/irq exit path takes | |
42 | care to save/restore almost all registers for ptrace'd | |
43 | processes. | |
44 | ||
45 | (2) A call-clobbered register, where the process P entered the | |
46 | kernel via [syscall] trap, is not stored anywhere; that's | |
47 | OK, because such registers are not expected to be preserved | |
48 | when the trap returns anyway (so we don't actually bother to | |
49 | test for this case). | |
50 | ||
51 | (3) A few registers not used at all by the kernel, and so | |
52 | normally never saved except by context-switches, are in the | |
53 | context switch state. */ | |
54 | ||
55 | if (reg_offs == PT_CTPC || reg_offs == PT_CTPSW || reg_offs == PT_CTBP) | |
56 | /* Register saved during context switch. */ | |
57 | regs = thread_saved_regs (t); | |
58 | else | |
59 | /* Register saved during kernel entry (or not available). */ | |
b7f6961d | 60 | regs = task_pt_regs (t); |
1da177e4 LT |
61 | |
62 | return (v850_reg_t *)((char *)regs + reg_offs); | |
63 | } | |
64 | ||
65 | /* Set the bits SET and clear the bits CLEAR in the v850e DIR | |
66 | (`debug information register'). Returns the new value of DIR. */ | |
67 | static inline v850_reg_t set_dir (v850_reg_t set, v850_reg_t clear) | |
68 | { | |
69 | register v850_reg_t rval asm ("r10"); | |
70 | register v850_reg_t arg0 asm ("r6") = set; | |
71 | register v850_reg_t arg1 asm ("r7") = clear; | |
72 | ||
73 | /* The dbtrap handler has exactly this functionality when called | |
74 | from kernel mode. 0xf840 is a `dbtrap' insn. */ | |
75 | asm (".short 0xf840" : "=r" (rval) : "r" (arg0), "r" (arg1)); | |
76 | ||
77 | return rval; | |
78 | } | |
79 | ||
80 | /* Makes sure hardware single-stepping is (globally) enabled. | |
81 | Returns true if successful. */ | |
82 | static inline int enable_single_stepping (void) | |
83 | { | |
84 | static int enabled = 0; /* Remember whether we already did it. */ | |
85 | if (! enabled) { | |
86 | /* Turn on the SE (`single-step enable') bit, 0x100, in the | |
87 | DIR (`debug information register'). This may fail if a | |
88 | processor doesn't support it or something. We also try | |
89 | to clear bit 0x40 (`INI'), which is necessary to use the | |
90 | debug stuff on the v850e2; on the v850e, clearing 0x40 | |
91 | shouldn't cause any problem. */ | |
92 | v850_reg_t dir = set_dir (0x100, 0x40); | |
93 | /* Make sure it really got set. */ | |
94 | if (dir & 0x100) | |
95 | enabled = 1; | |
96 | } | |
97 | return enabled; | |
98 | } | |
99 | ||
100 | /* Try to set CHILD's single-step flag to VAL. Returns true if successful. */ | |
101 | static int set_single_step (struct task_struct *t, int val) | |
102 | { | |
103 | v850_reg_t *psw_addr = reg_save_addr(PT_PSW, t); | |
104 | if (val) { | |
105 | /* Make sure single-stepping is enabled. */ | |
106 | if (! enable_single_stepping ()) | |
107 | return 0; | |
108 | /* Set T's single-step flag. */ | |
109 | *psw_addr |= 0x800; | |
110 | } else | |
111 | *psw_addr &= ~0x800; | |
112 | return 1; | |
113 | } | |
114 | ||
481bed45 | 115 | long arch_ptrace(struct task_struct *child, long request, long addr, long data) |
1da177e4 | 116 | { |
1da177e4 LT |
117 | int rval; |
118 | ||
1da177e4 | 119 | switch (request) { |
76647323 | 120 | unsigned long val; |
1da177e4 LT |
121 | |
122 | case PTRACE_PEEKTEXT: /* read word at location addr. */ | |
123 | case PTRACE_PEEKDATA: | |
76647323 | 124 | rval = generic_ptrace_peekdata(child, addr, data); |
1da177e4 LT |
125 | goto out; |
126 | ||
127 | case PTRACE_POKETEXT: /* write the word at location addr. */ | |
128 | case PTRACE_POKEDATA: | |
f284ce72 | 129 | rval = generic_ptrace_pokedata(child, addr, data); |
1da177e4 LT |
130 | goto out; |
131 | ||
132 | /* Read/write the word at location ADDR in the registers. */ | |
133 | case PTRACE_PEEKUSR: | |
134 | case PTRACE_POKEUSR: | |
135 | rval = 0; | |
136 | if (addr >= PT_SIZE && request == PTRACE_PEEKUSR) { | |
137 | /* Special requests that don't actually correspond | |
138 | to offsets in struct pt_regs. */ | |
139 | if (addr == PT_TEXT_ADDR) | |
140 | val = child->mm->start_code; | |
141 | else if (addr == PT_DATA_ADDR) | |
142 | val = child->mm->start_data; | |
143 | else if (addr == PT_TEXT_LEN) | |
144 | val = child->mm->end_code | |
145 | - child->mm->start_code; | |
146 | else | |
147 | rval = -EIO; | |
148 | } else if (addr >= 0 && addr < PT_SIZE && (addr & 0x3) == 0) { | |
149 | v850_reg_t *reg_addr = reg_save_addr(addr, child); | |
150 | if (request == PTRACE_PEEKUSR) | |
151 | val = *reg_addr; | |
152 | else | |
153 | *reg_addr = data; | |
154 | } else | |
155 | rval = -EIO; | |
156 | ||
157 | if (rval == 0 && request == PTRACE_PEEKUSR) | |
158 | rval = put_user (val, (unsigned long *)data); | |
159 | goto out; | |
160 | ||
161 | /* Continue and stop at next (return from) syscall */ | |
162 | case PTRACE_SYSCALL: | |
163 | /* Restart after a signal. */ | |
164 | case PTRACE_CONT: | |
165 | /* Execute a single instruction. */ | |
166 | case PTRACE_SINGLESTEP: | |
167 | rval = -EIO; | |
7ed20e1a | 168 | if (!valid_signal(data)) |
1da177e4 LT |
169 | break; |
170 | ||
171 | /* Turn CHILD's single-step flag on or off. */ | |
172 | if (! set_single_step (child, request == PTRACE_SINGLESTEP)) | |
173 | break; | |
174 | ||
175 | if (request == PTRACE_SYSCALL) | |
176 | set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | |
177 | else | |
178 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | |
179 | ||
180 | child->exit_code = data; | |
181 | wake_up_process(child); | |
182 | rval = 0; | |
183 | break; | |
184 | ||
185 | /* | |
186 | * make the child exit. Best I can do is send it a sigkill. | |
187 | * perhaps it should be put in the status that it wants to | |
188 | * exit. | |
189 | */ | |
190 | case PTRACE_KILL: | |
191 | rval = 0; | |
192 | if (child->exit_state == EXIT_ZOMBIE) /* already dead */ | |
193 | break; | |
194 | child->exit_code = SIGKILL; | |
195 | wake_up_process(child); | |
196 | break; | |
197 | ||
198 | case PTRACE_DETACH: /* detach a process that was attached. */ | |
199 | set_single_step (child, 0); /* Clear single-step flag */ | |
200 | rval = ptrace_detach(child, data); | |
201 | break; | |
202 | ||
203 | default: | |
204 | rval = -EIO; | |
205 | goto out; | |
206 | } | |
481bed45 | 207 | out: |
1da177e4 LT |
208 | return rval; |
209 | } | |
210 | ||
211 | asmlinkage void syscall_trace(void) | |
212 | { | |
213 | if (!test_thread_flag(TIF_SYSCALL_TRACE)) | |
214 | return; | |
215 | if (!(current->ptrace & PT_PTRACED)) | |
216 | return; | |
217 | /* The 0x80 provides a way for the tracing parent to distinguish | |
218 | between a syscall stop and SIGTRAP delivery */ | |
219 | ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) | |
220 | ? 0x80 : 0)); | |
221 | /* | |
222 | * this isn't the same as continuing with a signal, but it will do | |
223 | * for normal use. strace only continues with a signal if the | |
224 | * stopping signal is not SIGTRAP. -brl | |
225 | */ | |
226 | if (current->exit_code) { | |
227 | send_sig(current->exit_code, current, 1); | |
228 | current->exit_code = 0; | |
229 | } | |
230 | } | |
231 | ||
232 | void ptrace_disable (struct task_struct *child) | |
233 | { | |
234 | /* nothing to do */ | |
235 | } |