diff options
author | Adrian Bunk <bunk@kernel.org> | 2008-07-24 00:28:50 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2008-07-24 13:47:24 -0400 |
commit | f606ddf42fd4edc558eeb48bfee66d2c591571d2 (patch) | |
tree | 193f00db121201255b2629fce43b99a53c4ec735 /arch/v850/kernel/ptrace.c | |
parent | 99764fa4ceeecba8b9e0a8a5565b418a2e94f83b (diff) |
remove the v850 port
Trying to compile the v850 port brings many compile errors, one of them exists
since at least kernel 2.6.19.
There also seems to be noone willing to bring this port back into a usable
state.
This patch therefore removes the v850 port.
If anyone ever decides to revive the v850 port the code will still be
available from older kernels, and it wouldn't be impossible for the port to
reenter the kernel if it would become actively maintained again.
Signed-off-by: Adrian Bunk <bunk@kernel.org>
Acked-by: Greg Ungerer <gerg@uclinux.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat (limited to 'arch/v850/kernel/ptrace.c')
-rw-r--r-- | arch/v850/kernel/ptrace.c | 235 |
1 files changed, 0 insertions, 235 deletions
diff --git a/arch/v850/kernel/ptrace.c b/arch/v850/kernel/ptrace.c deleted file mode 100644 index a458ac941b25..000000000000 --- a/arch/v850/kernel/ptrace.c +++ /dev/null | |||
@@ -1,235 +0,0 @@ | |||
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> | ||
24 | #include <linux/ptrace.h> | ||
25 | #include <linux/signal.h> | ||
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). */ | ||
60 | regs = task_pt_regs (t); | ||
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 | |||
115 | long arch_ptrace(struct task_struct *child, long request, long addr, long data) | ||
116 | { | ||
117 | int rval; | ||
118 | |||
119 | switch (request) { | ||
120 | unsigned long val; | ||
121 | |||
122 | case PTRACE_PEEKTEXT: /* read word at location addr. */ | ||
123 | case PTRACE_PEEKDATA: | ||
124 | rval = generic_ptrace_peekdata(child, addr, data); | ||
125 | goto out; | ||
126 | |||
127 | case PTRACE_POKETEXT: /* write the word at location addr. */ | ||
128 | case PTRACE_POKEDATA: | ||
129 | rval = generic_ptrace_pokedata(child, addr, data); | ||
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; | ||
168 | if (!valid_signal(data)) | ||
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 | } | ||
207 | out: | ||
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 | } | ||