[PATCH] fallout from ptrace consolidation patch: cris/arch-v10
[linux-2.6] / arch / cris / arch-v10 / kernel / ptrace.c
1 /*
2  * Copyright (C) 2000-2003, Axis Communications AB.
3  */
4
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>
15
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>
21
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 */
27
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          */
36
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 }
44
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 }
59
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 }
70
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;
83
84         switch (request) {
85                 /* Read word at location address. */ 
86                 case PTRACE_PEEKTEXT:
87                 case PTRACE_PEEKDATA: {
88                         unsigned long tmp;
89                         int copied;
90
91                         copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
92                         ret = -EIO;
93                         
94                         if (copied != sizeof(tmp))
95                                 break;
96                         
97                         ret = put_user(tmp,datap);
98                         break;
99                 }
100
101                 /* Read the word at location address in the USER area. */
102                 case PTRACE_PEEKUSR: {
103                         unsigned long tmp;
104
105                         ret = -EIO;
106                         if ((addr & 3) || addr < 0 || addr > PT_MAX << 2)
107                                 break;
108
109                         tmp = get_reg(child, addr >> 2);
110                         ret = put_user(tmp, datap);
111                         break;
112                 }
113                 
114                 /* Write the word at location address. */
115                 case PTRACE_POKETEXT:
116                 case PTRACE_POKEDATA:
117                         ret = 0;
118                         
119                         if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
120                                 break;
121                         
122                         ret = -EIO;
123                         break;
124  
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;
130
131                         addr >>= 2;
132
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;
144
145                 case PTRACE_SYSCALL:
146                 case PTRACE_CONT:
147                         ret = -EIO;
148                         
149                         if (!valid_signal(data))
150                                 break;
151                         
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                         }
158                         
159                         child->exit_code = data;
160                         
161                         /* TODO: make sure any pending breakpoint is killed */
162                         wake_up_process(child);
163                         ret = 0;
164                         
165                         break;
166                 
167                 /* Make the child exit by sending it a sigkill. */
168                 case PTRACE_KILL:
169                         ret = 0;
170                         
171                         if (child->exit_state == EXIT_ZOMBIE)
172                                 break;
173                         
174                         child->exit_code = SIGKILL;
175                         
176                         /* TODO: make sure any pending breakpoint is killed */
177                         wake_up_process(child);
178                         break;
179
180                 /* Set the trap flag. */
181                 case PTRACE_SINGLESTEP:
182                         ret = -EIO;
183                         
184                         if (!valid_signal(data))
185                                 break;
186                         
187                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
188
189                         /* TODO: set some clever breakpoint mechanism... */
190
191                         child->exit_code = data;
192                         wake_up_process(child);
193                         ret = 0;
194                         break;
195
196                 case PTRACE_DETACH:
197                         ret = ptrace_detach(child, data);
198                         break;
199
200                 /* Get all GP registers from the child. */
201                 case PTRACE_GETREGS: {
202                         int i;
203                         unsigned long tmp;
204                         
205                         ret = 0;
206                         for (i = 0; i <= PT_MAX; i++) {
207                                 tmp = get_reg(child, i);
208                                 
209                                 if (put_user(tmp, datap)) {
210                                         ret = -EFAULT;
211                                         break;
212                                 }
213                                 
214                                 data += sizeof(long);
215                         }
216
217                         break;
218                 }
219
220                 /* Set all GP registers in the child. */
221                 case PTRACE_SETREGS: {
222                         int i;
223                         unsigned long tmp;
224                         
225                         ret = 0;
226                         for (i = 0; i <= PT_MAX; i++) {
227                                 if (get_user(tmp, datap)) {
228                                         ret = -EFAULT;
229                                         break;
230                                 }
231                                 
232                                 if (i == PT_DCCR) {
233                                         tmp &= DCCR_MASK;
234                                         tmp |= get_reg(child, PT_DCCR) & ~DCCR_MASK;
235                                 }
236                                 
237                                 put_reg(child, i, tmp);
238                                 data += sizeof(long);
239                         }
240                         
241                         break;
242                 }
243
244                 default:
245                         ret = ptrace_request(child, request, addr, data);
246                         break;
247         }
248
249         return ret;
250 }
251
252 void do_syscall_trace(void)
253 {
254         if (!test_thread_flag(TIF_SYSCALL_TRACE))
255                 return;
256         
257         if (!(current->ptrace & PT_PTRACED))
258                 return;
259         
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));
264         
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 }