ptrace: change signature of arch_ptrace()
[linux-3.10.git] / arch / frv / kernel / ptrace.c
1 /* ptrace.c: FRV specific parts of process tracing
2  *
3  * Copyright (C) 2003-5 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  * - Derived from arch/m68k/kernel/ptrace.c
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version
10  * 2 of the License, or (at your option) any later version.
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/mm.h>
16 #include <linux/smp.h>
17 #include <linux/errno.h>
18 #include <linux/ptrace.h>
19 #include <linux/user.h>
20 #include <linux/security.h>
21 #include <linux/signal.h>
22 #include <linux/regset.h>
23 #include <linux/elf.h>
24 #include <linux/tracehook.h>
25
26 #include <asm/uaccess.h>
27 #include <asm/page.h>
28 #include <asm/pgtable.h>
29 #include <asm/system.h>
30 #include <asm/processor.h>
31 #include <asm/unistd.h>
32
33 /*
34  * does not yet catch signals sent when the child dies.
35  * in exit.c or in signal.c.
36  */
37
38 /*
39  * retrieve the contents of FRV userspace general registers
40  */
41 static int genregs_get(struct task_struct *target,
42                        const struct user_regset *regset,
43                        unsigned int pos, unsigned int count,
44                        void *kbuf, void __user *ubuf)
45 {
46         const struct user_int_regs *iregs = &target->thread.user->i;
47         int ret;
48
49         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
50                                   iregs, 0, sizeof(*iregs));
51         if (ret < 0)
52                 return ret;
53
54         return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
55                                         sizeof(*iregs), -1);
56 }
57
58 /*
59  * update the contents of the FRV userspace general registers
60  */
61 static int genregs_set(struct task_struct *target,
62                        const struct user_regset *regset,
63                        unsigned int pos, unsigned int count,
64                        const void *kbuf, const void __user *ubuf)
65 {
66         struct user_int_regs *iregs = &target->thread.user->i;
67         unsigned int offs_gr0, offs_gr1;
68         int ret;
69
70         /* not allowed to set PSR or __status */
71         if (pos < offsetof(struct user_int_regs, psr) + sizeof(long) &&
72             pos + count > offsetof(struct user_int_regs, psr))
73                 return -EIO;
74
75         if (pos < offsetof(struct user_int_regs, __status) + sizeof(long) &&
76             pos + count > offsetof(struct user_int_regs, __status))
77                 return -EIO;
78
79         /* set the control regs */
80         offs_gr0 = offsetof(struct user_int_regs, gr[0]);
81         offs_gr1 = offsetof(struct user_int_regs, gr[1]);
82         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
83                                  iregs, 0, offs_gr0);
84         if (ret < 0)
85                 return ret;
86
87         /* skip GR0/TBR */
88         ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
89                                         offs_gr0, offs_gr1);
90         if (ret < 0)
91                 return ret;
92
93         /* set the general regs */
94         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
95                                  &iregs->gr[1], offs_gr1, sizeof(*iregs));
96         if (ret < 0)
97                 return ret;
98
99         return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
100                                         sizeof(*iregs), -1);
101 }
102
103 /*
104  * retrieve the contents of FRV userspace FP/Media registers
105  */
106 static int fpmregs_get(struct task_struct *target,
107                        const struct user_regset *regset,
108                        unsigned int pos, unsigned int count,
109                        void *kbuf, void __user *ubuf)
110 {
111         const struct user_fpmedia_regs *fpregs = &target->thread.user->f;
112         int ret;
113
114         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
115                                   fpregs, 0, sizeof(*fpregs));
116         if (ret < 0)
117                 return ret;
118
119         return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
120                                         sizeof(*fpregs), -1);
121 }
122
123 /*
124  * update the contents of the FRV userspace FP/Media registers
125  */
126 static int fpmregs_set(struct task_struct *target,
127                        const struct user_regset *regset,
128                        unsigned int pos, unsigned int count,
129                        const void *kbuf, const void __user *ubuf)
130 {
131         struct user_fpmedia_regs *fpregs = &target->thread.user->f;
132         int ret;
133
134         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
135                                  fpregs, 0, sizeof(*fpregs));
136         if (ret < 0)
137                 return ret;
138
139         return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
140                                         sizeof(*fpregs), -1);
141 }
142
143 /*
144  * determine if the FP/Media registers have actually been used
145  */
146 static int fpmregs_active(struct task_struct *target,
147                           const struct user_regset *regset)
148 {
149         return tsk_used_math(target) ? regset->n : 0;
150 }
151
152 /*
153  * Define the register sets available on the FRV under Linux
154  */
155 enum frv_regset {
156         REGSET_GENERAL,
157         REGSET_FPMEDIA,
158 };
159
160 static const struct user_regset frv_regsets[] = {
161         /*
162          * General register format is:
163          *      PSR, ISR, CCR, CCCR, LR, LCR, PC, (STATUS), SYSCALLNO, ORIG_G8
164          *      GNER0-1, IACC0, TBR, GR1-63
165          */
166         [REGSET_GENERAL] = {
167                 .core_note_type = NT_PRSTATUS,
168                 .n              = ELF_NGREG,
169                 .size           = sizeof(long),
170                 .align          = sizeof(long),
171                 .get            = genregs_get,
172                 .set            = genregs_set,
173         },
174         /*
175          * FPU/Media register format is:
176          *      FR0-63, FNER0-1, MSR0-1, ACC0-7, ACCG0-8, FSR
177          */
178         [REGSET_FPMEDIA] = {
179                 .core_note_type = NT_PRFPREG,
180                 .n              = sizeof(struct user_fpmedia_regs) / sizeof(long),
181                 .size           = sizeof(long),
182                 .align          = sizeof(long),
183                 .get            = fpmregs_get,
184                 .set            = fpmregs_set,
185                 .active         = fpmregs_active,
186         },
187 };
188
189 static const struct user_regset_view user_frv_native_view = {
190         .name           = "frv",
191         .e_machine      = EM_FRV,
192         .regsets        = frv_regsets,
193         .n              = ARRAY_SIZE(frv_regsets),
194 };
195
196 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
197 {
198         return &user_frv_native_view;
199 }
200
201 /*
202  * Get contents of register REGNO in task TASK.
203  */
204 static inline long get_reg(struct task_struct *task, int regno)
205 {
206         struct user_context *user = task->thread.user;
207
208         if (regno < 0 || regno >= PT__END)
209                 return 0;
210
211         return ((unsigned long *) user)[regno];
212 }
213
214 /*
215  * Write contents of register REGNO in task TASK.
216  */
217 static inline int put_reg(struct task_struct *task, int regno,
218                           unsigned long data)
219 {
220         struct user_context *user = task->thread.user;
221
222         if (regno < 0 || regno >= PT__END)
223                 return -EIO;
224
225         switch (regno) {
226         case PT_GR(0):
227                 return 0;
228         case PT_PSR:
229         case PT__STATUS:
230                 return -EIO;
231         default:
232                 ((unsigned long *) user)[regno] = data;
233                 return 0;
234         }
235 }
236
237 /*
238  * Called by kernel/ptrace.c when detaching..
239  *
240  * Control h/w single stepping
241  */
242 void user_enable_single_step(struct task_struct *child)
243 {
244         child->thread.frame0->__status |= REG__STATUS_STEP;
245 }
246
247 void user_disable_single_step(struct task_struct *child)
248 {
249         child->thread.frame0->__status &= ~REG__STATUS_STEP;
250 }
251
252 void ptrace_disable(struct task_struct *child)
253 {
254         user_disable_single_step(child);
255 }
256
257 long arch_ptrace(struct task_struct *child, long request,
258                  unsigned long addr, unsigned long data)
259 {
260         unsigned long tmp;
261         int ret;
262
263         switch (request) {
264                 /* read the word at location addr in the USER area. */
265         case PTRACE_PEEKUSR: {
266                 tmp = 0;
267                 ret = -EIO;
268                 if ((addr & 3) || addr < 0)
269                         break;
270
271                 ret = 0;
272                 switch (addr >> 2) {
273                 case 0 ... PT__END - 1:
274                         tmp = get_reg(child, addr >> 2);
275                         break;
276
277                 case PT__END + 0:
278                         tmp = child->mm->end_code - child->mm->start_code;
279                         break;
280
281                 case PT__END + 1:
282                         tmp = child->mm->end_data - child->mm->start_data;
283                         break;
284
285                 case PT__END + 2:
286                         tmp = child->mm->start_stack - child->mm->start_brk;
287                         break;
288
289                 case PT__END + 3:
290                         tmp = child->mm->start_code;
291                         break;
292
293                 case PT__END + 4:
294                         tmp = child->mm->start_stack;
295                         break;
296
297                 default:
298                         ret = -EIO;
299                         break;
300                 }
301
302                 if (ret == 0)
303                         ret = put_user(tmp, (unsigned long *) data);
304                 break;
305         }
306
307         case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
308                 ret = -EIO;
309                 if ((addr & 3) || addr < 0)
310                         break;
311
312                 ret = 0;
313                 switch (addr >> 2) {
314                 case 0 ... PT__END - 1:
315                         ret = put_reg(child, addr >> 2, data);
316                         break;
317
318                 default:
319                         ret = -EIO;
320                         break;
321                 }
322                 break;
323
324         case PTRACE_GETREGS:    /* Get all integer regs from the child. */
325                 return copy_regset_to_user(child, &user_frv_native_view,
326                                            REGSET_GENERAL,
327                                            0, sizeof(child->thread.user->i),
328                                            (void __user *)data);
329
330         case PTRACE_SETREGS:    /* Set all integer regs in the child. */
331                 return copy_regset_from_user(child, &user_frv_native_view,
332                                              REGSET_GENERAL,
333                                              0, sizeof(child->thread.user->i),
334                                              (const void __user *)data);
335
336         case PTRACE_GETFPREGS:  /* Get the child FP/Media state. */
337                 return copy_regset_to_user(child, &user_frv_native_view,
338                                            REGSET_FPMEDIA,
339                                            0, sizeof(child->thread.user->f),
340                                            (void __user *)data);
341
342         case PTRACE_SETFPREGS:  /* Set the child FP/Media state. */
343                 return copy_regset_from_user(child, &user_frv_native_view,
344                                              REGSET_FPMEDIA,
345                                              0, sizeof(child->thread.user->f),
346                                              (const void __user *)data);
347
348         default:
349                 ret = ptrace_request(child, request, addr, data);
350                 break;
351         }
352         return ret;
353 }
354
355 /*
356  * handle tracing of system call entry
357  * - return the revised system call number or ULONG_MAX to cause ENOSYS
358  */
359 asmlinkage unsigned long syscall_trace_entry(void)
360 {
361         __frame->__status |= REG__STATUS_SYSC_ENTRY;
362         if (tracehook_report_syscall_entry(__frame)) {
363                 /* tracing decided this syscall should not happen, so
364                  * We'll return a bogus call number to get an ENOSYS
365                  * error, but leave the original number in
366                  * __frame->syscallno
367                  */
368                 return ULONG_MAX;
369         }
370
371         return __frame->syscallno;
372 }
373
374 /*
375  * handle tracing of system call exit
376  */
377 asmlinkage void syscall_trace_exit(void)
378 {
379         __frame->__status |= REG__STATUS_SYSC_EXIT;
380         tracehook_report_syscall_exit(__frame, 0);
381 }