ia64/linux-2.6.18-xen.hg

view arch/cris/arch-v10/kernel/ptrace.c @ 647:a5bb490065f6

Fix the build after public header sync.
Signed-off-by: Keir Fraser <keir.fraser@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Wed Aug 13 14:01:49 2008 +0100 (2008-08-13)
parents 831230e53067
children
line source
1 /*
2 * Copyright (C) 2000-2003, Axis Communications AB.
3 */
5 #include <linux/kernel.h>
6 #include <linux/sched.h>
7 #include <linux/mm.h>
8 #include <linux/smp.h>
9 #include <linux/smp_lock.h>
10 #include <linux/errno.h>
11 #include <linux/ptrace.h>
12 #include <linux/user.h>
13 #include <linux/signal.h>
14 #include <linux/security.h>
16 #include <asm/uaccess.h>
17 #include <asm/page.h>
18 #include <asm/pgtable.h>
19 #include <asm/system.h>
20 #include <asm/processor.h>
22 /*
23 * Determines which bits in DCCR the user has access to.
24 * 1 = access, 0 = no access.
25 */
26 #define DCCR_MASK 0x0000001f /* XNZVC */
28 /*
29 * Get contents of register REGNO in task TASK.
30 */
31 inline long get_reg(struct task_struct *task, unsigned int regno)
32 {
33 /* USP is a special case, it's not in the pt_regs struct but
34 * in the tasks thread struct
35 */
37 if (regno == PT_USP)
38 return task->thread.usp;
39 else if (regno < PT_MAX)
40 return ((unsigned long *)task_pt_regs(task))[regno];
41 else
42 return 0;
43 }
45 /*
46 * Write contents of register REGNO in task TASK.
47 */
48 inline int put_reg(struct task_struct *task, unsigned int regno,
49 unsigned long data)
50 {
51 if (regno == PT_USP)
52 task->thread.usp = data;
53 else if (regno < PT_MAX)
54 ((unsigned long *)task_pt_regs(task))[regno] = data;
55 else
56 return -1;
57 return 0;
58 }
60 /*
61 * Called by kernel/ptrace.c when detaching.
62 *
63 * Make sure the single step bit is not set.
64 */
65 void
66 ptrace_disable(struct task_struct *child)
67 {
68 /* Todo - pending singlesteps? */
69 }
71 /*
72 * Note that this implementation of ptrace behaves differently from vanilla
73 * ptrace. Contrary to what the man page says, in the PTRACE_PEEKTEXT,
74 * PTRACE_PEEKDATA, and PTRACE_PEEKUSER requests the data variable is not
75 * ignored. Instead, the data variable is expected to point at a location
76 * (in user space) where the result of the ptrace call is written (instead of
77 * being returned).
78 */
79 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
80 {
81 int ret;
82 unsigned long __user *datap = (unsigned long __user *)data;
84 switch (request) {
85 /* Read word at location address. */
86 case PTRACE_PEEKTEXT:
87 case PTRACE_PEEKDATA: {
88 unsigned long tmp;
89 int copied;
91 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
92 ret = -EIO;
94 if (copied != sizeof(tmp))
95 break;
97 ret = put_user(tmp,datap);
98 break;
99 }
101 /* Read the word at location address in the USER area. */
102 case PTRACE_PEEKUSR: {
103 unsigned long tmp;
105 ret = -EIO;
106 if ((addr & 3) || addr < 0 || addr > PT_MAX << 2)
107 break;
109 tmp = get_reg(child, addr >> 2);
110 ret = put_user(tmp, datap);
111 break;
112 }
114 /* Write the word at location address. */
115 case PTRACE_POKETEXT:
116 case PTRACE_POKEDATA:
117 ret = 0;
119 if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
120 break;
122 ret = -EIO;
123 break;
125 /* Write the word at location address in the USER area. */
126 case PTRACE_POKEUSR:
127 ret = -EIO;
128 if ((addr & 3) || addr < 0 || addr > PT_MAX << 2)
129 break;
131 addr >>= 2;
133 if (addr == PT_DCCR) {
134 /* don't allow the tracing process to change stuff like
135 * interrupt enable, kernel/user bit, dma enables etc.
136 */
137 data &= DCCR_MASK;
138 data |= get_reg(child, PT_DCCR) & ~DCCR_MASK;
139 }
140 if (put_reg(child, addr, data))
141 break;
142 ret = 0;
143 break;
145 case PTRACE_SYSCALL:
146 case PTRACE_CONT:
147 ret = -EIO;
149 if (!valid_signal(data))
150 break;
152 if (request == PTRACE_SYSCALL) {
153 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
154 }
155 else {
156 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
157 }
159 child->exit_code = data;
161 /* TODO: make sure any pending breakpoint is killed */
162 wake_up_process(child);
163 ret = 0;
165 break;
167 /* Make the child exit by sending it a sigkill. */
168 case PTRACE_KILL:
169 ret = 0;
171 if (child->exit_state == EXIT_ZOMBIE)
172 break;
174 child->exit_code = SIGKILL;
176 /* TODO: make sure any pending breakpoint is killed */
177 wake_up_process(child);
178 break;
180 /* Set the trap flag. */
181 case PTRACE_SINGLESTEP:
182 ret = -EIO;
184 if (!valid_signal(data))
185 break;
187 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
189 /* TODO: set some clever breakpoint mechanism... */
191 child->exit_code = data;
192 wake_up_process(child);
193 ret = 0;
194 break;
196 case PTRACE_DETACH:
197 ret = ptrace_detach(child, data);
198 break;
200 /* Get all GP registers from the child. */
201 case PTRACE_GETREGS: {
202 int i;
203 unsigned long tmp;
205 ret = 0;
206 for (i = 0; i <= PT_MAX; i++) {
207 tmp = get_reg(child, i);
209 if (put_user(tmp, datap)) {
210 ret = -EFAULT;
211 break;
212 }
214 data += sizeof(long);
215 }
217 break;
218 }
220 /* Set all GP registers in the child. */
221 case PTRACE_SETREGS: {
222 int i;
223 unsigned long tmp;
225 ret = 0;
226 for (i = 0; i <= PT_MAX; i++) {
227 if (get_user(tmp, datap)) {
228 ret = -EFAULT;
229 break;
230 }
232 if (i == PT_DCCR) {
233 tmp &= DCCR_MASK;
234 tmp |= get_reg(child, PT_DCCR) & ~DCCR_MASK;
235 }
237 put_reg(child, i, tmp);
238 data += sizeof(long);
239 }
241 break;
242 }
244 default:
245 ret = ptrace_request(child, request, addr, data);
246 break;
247 }
249 return ret;
250 }
252 void do_syscall_trace(void)
253 {
254 if (!test_thread_flag(TIF_SYSCALL_TRACE))
255 return;
257 if (!(current->ptrace & PT_PTRACED))
258 return;
260 /* the 0x80 provides a way for the tracing parent to distinguish
261 between a syscall stop and SIGTRAP delivery */
262 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
263 ? 0x80 : 0));
265 /*
266 * This isn't the same as continuing with a signal, but it will do for
267 * normal use.
268 */
269 if (current->exit_code) {
270 send_sig(current->exit_code, current, 1);
271 current->exit_code = 0;
272 }
273 }