Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[linux-3.10.git] / arch / arm / kernel / ptrace.c
1 /*
2  *  linux/arch/arm/kernel/ptrace.c
3  *
4  *  By Ross Biro 1/23/92
5  * edited by Linus Torvalds
6  * ARM modifications Copyright (C) 2000 Russell King
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/mm.h>
15 #include <linux/elf.h>
16 #include <linux/smp.h>
17 #include <linux/ptrace.h>
18 #include <linux/user.h>
19 #include <linux/security.h>
20 #include <linux/init.h>
21 #include <linux/signal.h>
22 #include <linux/uaccess.h>
23 #include <linux/perf_event.h>
24 #include <linux/hw_breakpoint.h>
25 #include <linux/regset.h>
26 #include <linux/audit.h>
27 #include <linux/tracehook.h>
28 #include <linux/unistd.h>
29
30 #include <asm/pgtable.h>
31 #include <asm/traps.h>
32
33 #define CREATE_TRACE_POINTS
34 #include <trace/events/syscalls.h>
35
36 #define REG_PC  15
37 #define REG_PSR 16
38 /*
39  * does not yet catch signals sent when the child dies.
40  * in exit.c or in signal.c.
41  */
42
43 #if 0
44 /*
45  * Breakpoint SWI instruction: SWI &9F0001
46  */
47 #define BREAKINST_ARM   0xef9f0001
48 #define BREAKINST_THUMB 0xdf00          /* fill this in later */
49 #else
50 /*
51  * New breakpoints - use an undefined instruction.  The ARM architecture
52  * reference manual guarantees that the following instruction space
53  * will produce an undefined instruction exception on all CPUs:
54  *
55  *  ARM:   xxxx 0111 1111 xxxx xxxx xxxx 1111 xxxx
56  *  Thumb: 1101 1110 xxxx xxxx
57  */
58 #define BREAKINST_ARM   0xe7f001f0
59 #define BREAKINST_THUMB 0xde01
60 #endif
61
62 struct pt_regs_offset {
63         const char *name;
64         int offset;
65 };
66
67 #define REG_OFFSET_NAME(r) \
68         {.name = #r, .offset = offsetof(struct pt_regs, ARM_##r)}
69 #define REG_OFFSET_END {.name = NULL, .offset = 0}
70
71 static const struct pt_regs_offset regoffset_table[] = {
72         REG_OFFSET_NAME(r0),
73         REG_OFFSET_NAME(r1),
74         REG_OFFSET_NAME(r2),
75         REG_OFFSET_NAME(r3),
76         REG_OFFSET_NAME(r4),
77         REG_OFFSET_NAME(r5),
78         REG_OFFSET_NAME(r6),
79         REG_OFFSET_NAME(r7),
80         REG_OFFSET_NAME(r8),
81         REG_OFFSET_NAME(r9),
82         REG_OFFSET_NAME(r10),
83         REG_OFFSET_NAME(fp),
84         REG_OFFSET_NAME(ip),
85         REG_OFFSET_NAME(sp),
86         REG_OFFSET_NAME(lr),
87         REG_OFFSET_NAME(pc),
88         REG_OFFSET_NAME(cpsr),
89         REG_OFFSET_NAME(ORIG_r0),
90         REG_OFFSET_END,
91 };
92
93 /**
94  * regs_query_register_offset() - query register offset from its name
95  * @name:       the name of a register
96  *
97  * regs_query_register_offset() returns the offset of a register in struct
98  * pt_regs from its name. If the name is invalid, this returns -EINVAL;
99  */
100 int regs_query_register_offset(const char *name)
101 {
102         const struct pt_regs_offset *roff;
103         for (roff = regoffset_table; roff->name != NULL; roff++)
104                 if (!strcmp(roff->name, name))
105                         return roff->offset;
106         return -EINVAL;
107 }
108
109 /**
110  * regs_query_register_name() - query register name from its offset
111  * @offset:     the offset of a register in struct pt_regs.
112  *
113  * regs_query_register_name() returns the name of a register from its
114  * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
115  */
116 const char *regs_query_register_name(unsigned int offset)
117 {
118         const struct pt_regs_offset *roff;
119         for (roff = regoffset_table; roff->name != NULL; roff++)
120                 if (roff->offset == offset)
121                         return roff->name;
122         return NULL;
123 }
124
125 /**
126  * regs_within_kernel_stack() - check the address in the stack
127  * @regs:      pt_regs which contains kernel stack pointer.
128  * @addr:      address which is checked.
129  *
130  * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
131  * If @addr is within the kernel stack, it returns true. If not, returns false.
132  */
133 bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
134 {
135         return ((addr & ~(THREAD_SIZE - 1))  ==
136                 (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
137 }
138
139 /**
140  * regs_get_kernel_stack_nth() - get Nth entry of the stack
141  * @regs:       pt_regs which contains kernel stack pointer.
142  * @n:          stack entry number.
143  *
144  * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
145  * is specified by @regs. If the @n th entry is NOT in the kernel stack,
146  * this returns 0.
147  */
148 unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
149 {
150         unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
151         addr += n;
152         if (regs_within_kernel_stack(regs, (unsigned long)addr))
153                 return *addr;
154         else
155                 return 0;
156 }
157
158 /*
159  * this routine will get a word off of the processes privileged stack.
160  * the offset is how far from the base addr as stored in the THREAD.
161  * this routine assumes that all the privileged stacks are in our
162  * data space.
163  */
164 static inline long get_user_reg(struct task_struct *task, int offset)
165 {
166         return task_pt_regs(task)->uregs[offset];
167 }
168
169 /*
170  * this routine will put a word on the processes privileged stack.
171  * the offset is how far from the base addr as stored in the THREAD.
172  * this routine assumes that all the privileged stacks are in our
173  * data space.
174  */
175 static inline int
176 put_user_reg(struct task_struct *task, int offset, long data)
177 {
178         struct pt_regs newregs, *regs = task_pt_regs(task);
179         int ret = -EINVAL;
180
181         newregs = *regs;
182         newregs.uregs[offset] = data;
183
184         if (valid_user_regs(&newregs)) {
185                 regs->uregs[offset] = data;
186                 ret = 0;
187         }
188
189         return ret;
190 }
191
192 /*
193  * Called by kernel/ptrace.c when detaching..
194  */
195 void ptrace_disable(struct task_struct *child)
196 {
197         /* Nothing to do. */
198 }
199
200 /*
201  * Handle hitting a breakpoint.
202  */
203 void ptrace_break(struct task_struct *tsk, struct pt_regs *regs)
204 {
205         siginfo_t info;
206
207         info.si_signo = SIGTRAP;
208         info.si_errno = 0;
209         info.si_code  = TRAP_BRKPT;
210         info.si_addr  = (void __user *)instruction_pointer(regs);
211
212         force_sig_info(SIGTRAP, &info, tsk);
213 }
214
215 static int break_trap(struct pt_regs *regs, unsigned int instr)
216 {
217         ptrace_break(current, regs);
218         return 0;
219 }
220
221 static struct undef_hook arm_break_hook = {
222         .instr_mask     = 0x0fffffff,
223         .instr_val      = 0x07f001f0,
224         .cpsr_mask      = PSR_T_BIT,
225         .cpsr_val       = 0,
226         .fn             = break_trap,
227 };
228
229 static struct undef_hook thumb_break_hook = {
230         .instr_mask     = 0xffff,
231         .instr_val      = 0xde01,
232         .cpsr_mask      = PSR_T_BIT,
233         .cpsr_val       = PSR_T_BIT,
234         .fn             = break_trap,
235 };
236
237 static struct undef_hook thumb2_break_hook = {
238         .instr_mask     = 0xffffffff,
239         .instr_val      = 0xf7f0a000,
240         .cpsr_mask      = PSR_T_BIT,
241         .cpsr_val       = PSR_T_BIT,
242         .fn             = break_trap,
243 };
244
245 static int __init ptrace_break_init(void)
246 {
247         register_undef_hook(&arm_break_hook);
248         register_undef_hook(&thumb_break_hook);
249         register_undef_hook(&thumb2_break_hook);
250         return 0;
251 }
252
253 core_initcall(ptrace_break_init);
254
255 /*
256  * Read the word at offset "off" into the "struct user".  We
257  * actually access the pt_regs stored on the kernel stack.
258  */
259 static int ptrace_read_user(struct task_struct *tsk, unsigned long off,
260                             unsigned long __user *ret)
261 {
262         unsigned long tmp;
263
264         if (off & 3)
265                 return -EIO;
266
267         tmp = 0;
268         if (off == PT_TEXT_ADDR)
269                 tmp = tsk->mm->start_code;
270         else if (off == PT_DATA_ADDR)
271                 tmp = tsk->mm->start_data;
272         else if (off == PT_TEXT_END_ADDR)
273                 tmp = tsk->mm->end_code;
274         else if (off < sizeof(struct pt_regs))
275                 tmp = get_user_reg(tsk, off >> 2);
276         else if (off >= sizeof(struct user))
277                 return -EIO;
278
279         return put_user(tmp, ret);
280 }
281
282 /*
283  * Write the word at offset "off" into "struct user".  We
284  * actually access the pt_regs stored on the kernel stack.
285  */
286 static int ptrace_write_user(struct task_struct *tsk, unsigned long off,
287                              unsigned long val)
288 {
289         if (off & 3 || off >= sizeof(struct user))
290                 return -EIO;
291
292         if (off >= sizeof(struct pt_regs))
293                 return 0;
294
295         return put_user_reg(tsk, off >> 2, val);
296 }
297
298 #ifdef CONFIG_IWMMXT
299
300 /*
301  * Get the child iWMMXt state.
302  */
303 static int ptrace_getwmmxregs(struct task_struct *tsk, void __user *ufp)
304 {
305         struct thread_info *thread = task_thread_info(tsk);
306
307         if (!test_ti_thread_flag(thread, TIF_USING_IWMMXT))
308                 return -ENODATA;
309         iwmmxt_task_disable(thread);  /* force it to ram */
310         return copy_to_user(ufp, &thread->fpstate.iwmmxt, IWMMXT_SIZE)
311                 ? -EFAULT : 0;
312 }
313
314 /*
315  * Set the child iWMMXt state.
316  */
317 static int ptrace_setwmmxregs(struct task_struct *tsk, void __user *ufp)
318 {
319         struct thread_info *thread = task_thread_info(tsk);
320
321         if (!test_ti_thread_flag(thread, TIF_USING_IWMMXT))
322                 return -EACCES;
323         iwmmxt_task_release(thread);  /* force a reload */
324         return copy_from_user(&thread->fpstate.iwmmxt, ufp, IWMMXT_SIZE)
325                 ? -EFAULT : 0;
326 }
327
328 #endif
329
330 #ifdef CONFIG_CRUNCH
331 /*
332  * Get the child Crunch state.
333  */
334 static int ptrace_getcrunchregs(struct task_struct *tsk, void __user *ufp)
335 {
336         struct thread_info *thread = task_thread_info(tsk);
337
338         crunch_task_disable(thread);  /* force it to ram */
339         return copy_to_user(ufp, &thread->crunchstate, CRUNCH_SIZE)
340                 ? -EFAULT : 0;
341 }
342
343 /*
344  * Set the child Crunch state.
345  */
346 static int ptrace_setcrunchregs(struct task_struct *tsk, void __user *ufp)
347 {
348         struct thread_info *thread = task_thread_info(tsk);
349
350         crunch_task_release(thread);  /* force a reload */
351         return copy_from_user(&thread->crunchstate, ufp, CRUNCH_SIZE)
352                 ? -EFAULT : 0;
353 }
354 #endif
355
356 #ifdef CONFIG_HAVE_HW_BREAKPOINT
357 /*
358  * Convert a virtual register number into an index for a thread_info
359  * breakpoint array. Breakpoints are identified using positive numbers
360  * whilst watchpoints are negative. The registers are laid out as pairs
361  * of (address, control), each pair mapping to a unique hw_breakpoint struct.
362  * Register 0 is reserved for describing resource information.
363  */
364 static int ptrace_hbp_num_to_idx(long num)
365 {
366         if (num < 0)
367                 num = (ARM_MAX_BRP << 1) - num;
368         return (num - 1) >> 1;
369 }
370
371 /*
372  * Returns the virtual register number for the address of the
373  * breakpoint at index idx.
374  */
375 static long ptrace_hbp_idx_to_num(int idx)
376 {
377         long mid = ARM_MAX_BRP << 1;
378         long num = (idx << 1) + 1;
379         return num > mid ? mid - num : num;
380 }
381
382 /*
383  * Handle hitting a HW-breakpoint.
384  */
385 static void ptrace_hbptriggered(struct perf_event *bp,
386                                      struct perf_sample_data *data,
387                                      struct pt_regs *regs)
388 {
389         struct arch_hw_breakpoint *bkpt = counter_arch_bp(bp);
390         long num;
391         int i;
392         siginfo_t info;
393
394         for (i = 0; i < ARM_MAX_HBP_SLOTS; ++i)
395                 if (current->thread.debug.hbp[i] == bp)
396                         break;
397
398         num = (i == ARM_MAX_HBP_SLOTS) ? 0 : ptrace_hbp_idx_to_num(i);
399
400         info.si_signo   = SIGTRAP;
401         info.si_errno   = (int)num;
402         info.si_code    = TRAP_HWBKPT;
403         info.si_addr    = (void __user *)(bkpt->trigger);
404
405         force_sig_info(SIGTRAP, &info, current);
406 }
407
408 /*
409  * Set ptrace breakpoint pointers to zero for this task.
410  * This is required in order to prevent child processes from unregistering
411  * breakpoints held by their parent.
412  */
413 void clear_ptrace_hw_breakpoint(struct task_struct *tsk)
414 {
415         memset(tsk->thread.debug.hbp, 0, sizeof(tsk->thread.debug.hbp));
416 }
417
418 /*
419  * Unregister breakpoints from this task and reset the pointers in
420  * the thread_struct.
421  */
422 void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
423 {
424         int i;
425         struct thread_struct *t = &tsk->thread;
426
427         for (i = 0; i < ARM_MAX_HBP_SLOTS; i++) {
428                 if (t->debug.hbp[i]) {
429                         unregister_hw_breakpoint(t->debug.hbp[i]);
430                         t->debug.hbp[i] = NULL;
431                 }
432         }
433 }
434
435 static u32 ptrace_get_hbp_resource_info(void)
436 {
437         u8 num_brps, num_wrps, debug_arch, wp_len;
438         u32 reg = 0;
439
440         num_brps        = hw_breakpoint_slots(TYPE_INST);
441         num_wrps        = hw_breakpoint_slots(TYPE_DATA);
442         debug_arch      = arch_get_debug_arch();
443         wp_len          = arch_get_max_wp_len();
444
445         reg             |= debug_arch;
446         reg             <<= 8;
447         reg             |= wp_len;
448         reg             <<= 8;
449         reg             |= num_wrps;
450         reg             <<= 8;
451         reg             |= num_brps;
452
453         return reg;
454 }
455
456 static struct perf_event *ptrace_hbp_create(struct task_struct *tsk, int type)
457 {
458         struct perf_event_attr attr;
459
460         ptrace_breakpoint_init(&attr);
461
462         /* Initialise fields to sane defaults. */
463         attr.bp_addr    = 0;
464         attr.bp_len     = HW_BREAKPOINT_LEN_4;
465         attr.bp_type    = type;
466         attr.disabled   = 1;
467
468         return register_user_hw_breakpoint(&attr, ptrace_hbptriggered, NULL,
469                                            tsk);
470 }
471
472 static int ptrace_gethbpregs(struct task_struct *tsk, long num,
473                              unsigned long  __user *data)
474 {
475         u32 reg;
476         int idx, ret = 0;
477         struct perf_event *bp;
478         struct arch_hw_breakpoint_ctrl arch_ctrl;
479
480         if (num == 0) {
481                 reg = ptrace_get_hbp_resource_info();
482         } else {
483                 idx = ptrace_hbp_num_to_idx(num);
484                 if (idx < 0 || idx >= ARM_MAX_HBP_SLOTS) {
485                         ret = -EINVAL;
486                         goto out;
487                 }
488
489                 bp = tsk->thread.debug.hbp[idx];
490                 if (!bp) {
491                         reg = 0;
492                         goto put;
493                 }
494
495                 arch_ctrl = counter_arch_bp(bp)->ctrl;
496
497                 /*
498                  * Fix up the len because we may have adjusted it
499                  * to compensate for an unaligned address.
500                  */
501                 while (!(arch_ctrl.len & 0x1))
502                         arch_ctrl.len >>= 1;
503
504                 if (num & 0x1)
505                         reg = bp->attr.bp_addr;
506                 else
507                         reg = encode_ctrl_reg(arch_ctrl);
508         }
509
510 put:
511         if (put_user(reg, data))
512                 ret = -EFAULT;
513
514 out:
515         return ret;
516 }
517
518 static int ptrace_sethbpregs(struct task_struct *tsk, long num,
519                              unsigned long __user *data)
520 {
521         int idx, gen_len, gen_type, implied_type, ret = 0;
522         u32 user_val;
523         struct perf_event *bp;
524         struct arch_hw_breakpoint_ctrl ctrl;
525         struct perf_event_attr attr;
526
527         if (num == 0)
528                 goto out;
529         else if (num < 0)
530                 implied_type = HW_BREAKPOINT_RW;
531         else
532                 implied_type = HW_BREAKPOINT_X;
533
534         idx = ptrace_hbp_num_to_idx(num);
535         if (idx < 0 || idx >= ARM_MAX_HBP_SLOTS) {
536                 ret = -EINVAL;
537                 goto out;
538         }
539
540         if (get_user(user_val, data)) {
541                 ret = -EFAULT;
542                 goto out;
543         }
544
545         bp = tsk->thread.debug.hbp[idx];
546         if (!bp) {
547                 bp = ptrace_hbp_create(tsk, implied_type);
548                 if (IS_ERR(bp)) {
549                         ret = PTR_ERR(bp);
550                         goto out;
551                 }
552                 tsk->thread.debug.hbp[idx] = bp;
553         }
554
555         attr = bp->attr;
556
557         if (num & 0x1) {
558                 /* Address */
559                 attr.bp_addr    = user_val;
560         } else {
561                 /* Control */
562                 decode_ctrl_reg(user_val, &ctrl);
563                 ret = arch_bp_generic_fields(ctrl, &gen_len, &gen_type);
564                 if (ret)
565                         goto out;
566
567                 if ((gen_type & implied_type) != gen_type) {
568                         ret = -EINVAL;
569                         goto out;
570                 }
571
572                 attr.bp_len     = gen_len;
573                 attr.bp_type    = gen_type;
574                 attr.disabled   = !ctrl.enabled;
575         }
576
577         ret = modify_user_hw_breakpoint(bp, &attr);
578 out:
579         return ret;
580 }
581 #endif
582
583 /* regset get/set implementations */
584
585 static int gpr_get(struct task_struct *target,
586                    const struct user_regset *regset,
587                    unsigned int pos, unsigned int count,
588                    void *kbuf, void __user *ubuf)
589 {
590         struct pt_regs *regs = task_pt_regs(target);
591
592         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
593                                    regs,
594                                    0, sizeof(*regs));
595 }
596
597 static int gpr_set(struct task_struct *target,
598                    const struct user_regset *regset,
599                    unsigned int pos, unsigned int count,
600                    const void *kbuf, const void __user *ubuf)
601 {
602         int ret;
603         struct pt_regs newregs;
604
605         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
606                                  &newregs,
607                                  0, sizeof(newregs));
608         if (ret)
609                 return ret;
610
611         if (!valid_user_regs(&newregs))
612                 return -EINVAL;
613
614         *task_pt_regs(target) = newregs;
615         return 0;
616 }
617
618 static int fpa_get(struct task_struct *target,
619                    const struct user_regset *regset,
620                    unsigned int pos, unsigned int count,
621                    void *kbuf, void __user *ubuf)
622 {
623         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
624                                    &task_thread_info(target)->fpstate,
625                                    0, sizeof(struct user_fp));
626 }
627
628 static int fpa_set(struct task_struct *target,
629                    const struct user_regset *regset,
630                    unsigned int pos, unsigned int count,
631                    const void *kbuf, const void __user *ubuf)
632 {
633         struct thread_info *thread = task_thread_info(target);
634
635         thread->used_cp[1] = thread->used_cp[2] = 1;
636
637         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
638                 &thread->fpstate,
639                 0, sizeof(struct user_fp));
640 }
641
642 #ifdef CONFIG_VFP
643 /*
644  * VFP register get/set implementations.
645  *
646  * With respect to the kernel, struct user_fp is divided into three chunks:
647  * 16 or 32 real VFP registers (d0-d15 or d0-31)
648  *      These are transferred to/from the real registers in the task's
649  *      vfp_hard_struct.  The number of registers depends on the kernel
650  *      configuration.
651  *
652  * 16 or 0 fake VFP registers (d16-d31 or empty)
653  *      i.e., the user_vfp structure has space for 32 registers even if
654  *      the kernel doesn't have them all.
655  *
656  *      vfp_get() reads this chunk as zero where applicable
657  *      vfp_set() ignores this chunk
658  *
659  * 1 word for the FPSCR
660  *
661  * The bounds-checking logic built into user_regset_copyout and friends
662  * means that we can make a simple sequence of calls to map the relevant data
663  * to/from the specified slice of the user regset structure.
664  */
665 static int vfp_get(struct task_struct *target,
666                    const struct user_regset *regset,
667                    unsigned int pos, unsigned int count,
668                    void *kbuf, void __user *ubuf)
669 {
670         int ret;
671         struct thread_info *thread = task_thread_info(target);
672         struct vfp_hard_struct const *vfp = &thread->vfpstate.hard;
673         const size_t user_fpregs_offset = offsetof(struct user_vfp, fpregs);
674         const size_t user_fpscr_offset = offsetof(struct user_vfp, fpscr);
675
676         vfp_sync_hwstate(thread);
677
678         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
679                                   &vfp->fpregs,
680                                   user_fpregs_offset,
681                                   user_fpregs_offset + sizeof(vfp->fpregs));
682         if (ret)
683                 return ret;
684
685         ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
686                                        user_fpregs_offset + sizeof(vfp->fpregs),
687                                        user_fpscr_offset);
688         if (ret)
689                 return ret;
690
691         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
692                                    &vfp->fpscr,
693                                    user_fpscr_offset,
694                                    user_fpscr_offset + sizeof(vfp->fpscr));
695 }
696
697 /*
698  * For vfp_set() a read-modify-write is done on the VFP registers,
699  * in order to avoid writing back a half-modified set of registers on
700  * failure.
701  */
702 static int vfp_set(struct task_struct *target,
703                           const struct user_regset *regset,
704                           unsigned int pos, unsigned int count,
705                           const void *kbuf, const void __user *ubuf)
706 {
707         int ret;
708         struct thread_info *thread = task_thread_info(target);
709         struct vfp_hard_struct new_vfp;
710         const size_t user_fpregs_offset = offsetof(struct user_vfp, fpregs);
711         const size_t user_fpscr_offset = offsetof(struct user_vfp, fpscr);
712
713         vfp_sync_hwstate(thread);
714         new_vfp = thread->vfpstate.hard;
715
716         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
717                                   &new_vfp.fpregs,
718                                   user_fpregs_offset,
719                                   user_fpregs_offset + sizeof(new_vfp.fpregs));
720         if (ret)
721                 return ret;
722
723         ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
724                                 user_fpregs_offset + sizeof(new_vfp.fpregs),
725                                 user_fpscr_offset);
726         if (ret)
727                 return ret;
728
729         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
730                                  &new_vfp.fpscr,
731                                  user_fpscr_offset,
732                                  user_fpscr_offset + sizeof(new_vfp.fpscr));
733         if (ret)
734                 return ret;
735
736         vfp_flush_hwstate(thread);
737         thread->vfpstate.hard = new_vfp;
738
739         return 0;
740 }
741 #endif /* CONFIG_VFP */
742
743 enum arm_regset {
744         REGSET_GPR,
745         REGSET_FPR,
746 #ifdef CONFIG_VFP
747         REGSET_VFP,
748 #endif
749 };
750
751 static const struct user_regset arm_regsets[] = {
752         [REGSET_GPR] = {
753                 .core_note_type = NT_PRSTATUS,
754                 .n = ELF_NGREG,
755                 .size = sizeof(u32),
756                 .align = sizeof(u32),
757                 .get = gpr_get,
758                 .set = gpr_set
759         },
760         [REGSET_FPR] = {
761                 /*
762                  * For the FPA regs in fpstate, the real fields are a mixture
763                  * of sizes, so pretend that the registers are word-sized:
764                  */
765                 .core_note_type = NT_PRFPREG,
766                 .n = sizeof(struct user_fp) / sizeof(u32),
767                 .size = sizeof(u32),
768                 .align = sizeof(u32),
769                 .get = fpa_get,
770                 .set = fpa_set
771         },
772 #ifdef CONFIG_VFP
773         [REGSET_VFP] = {
774                 /*
775                  * Pretend that the VFP regs are word-sized, since the FPSCR is
776                  * a single word dangling at the end of struct user_vfp:
777                  */
778                 .core_note_type = NT_ARM_VFP,
779                 .n = ARM_VFPREGS_SIZE / sizeof(u32),
780                 .size = sizeof(u32),
781                 .align = sizeof(u32),
782                 .get = vfp_get,
783                 .set = vfp_set
784         },
785 #endif /* CONFIG_VFP */
786 };
787
788 static const struct user_regset_view user_arm_view = {
789         .name = "arm", .e_machine = ELF_ARCH, .ei_osabi = ELF_OSABI,
790         .regsets = arm_regsets, .n = ARRAY_SIZE(arm_regsets)
791 };
792
793 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
794 {
795         return &user_arm_view;
796 }
797
798 long arch_ptrace(struct task_struct *child, long request,
799                  unsigned long addr, unsigned long data)
800 {
801         int ret;
802         unsigned long __user *datap = (unsigned long __user *) data;
803
804         switch (request) {
805                 case PTRACE_PEEKUSR:
806                         ret = ptrace_read_user(child, addr, datap);
807                         break;
808
809                 case PTRACE_POKEUSR:
810                         ret = ptrace_write_user(child, addr, data);
811                         break;
812
813                 case PTRACE_GETREGS:
814                         ret = copy_regset_to_user(child,
815                                                   &user_arm_view, REGSET_GPR,
816                                                   0, sizeof(struct pt_regs),
817                                                   datap);
818                         break;
819
820                 case PTRACE_SETREGS:
821                         ret = copy_regset_from_user(child,
822                                                     &user_arm_view, REGSET_GPR,
823                                                     0, sizeof(struct pt_regs),
824                                                     datap);
825                         break;
826
827                 case PTRACE_GETFPREGS:
828                         ret = copy_regset_to_user(child,
829                                                   &user_arm_view, REGSET_FPR,
830                                                   0, sizeof(union fp_state),
831                                                   datap);
832                         break;
833
834                 case PTRACE_SETFPREGS:
835                         ret = copy_regset_from_user(child,
836                                                     &user_arm_view, REGSET_FPR,
837                                                     0, sizeof(union fp_state),
838                                                     datap);
839                         break;
840
841 #ifdef CONFIG_IWMMXT
842                 case PTRACE_GETWMMXREGS:
843                         ret = ptrace_getwmmxregs(child, datap);
844                         break;
845
846                 case PTRACE_SETWMMXREGS:
847                         ret = ptrace_setwmmxregs(child, datap);
848                         break;
849 #endif
850
851                 case PTRACE_GET_THREAD_AREA:
852                         ret = put_user(task_thread_info(child)->tp_value,
853                                        datap);
854                         break;
855
856                 case PTRACE_SET_SYSCALL:
857                         task_thread_info(child)->syscall = data;
858                         ret = 0;
859                         break;
860
861 #ifdef CONFIG_CRUNCH
862                 case PTRACE_GETCRUNCHREGS:
863                         ret = ptrace_getcrunchregs(child, datap);
864                         break;
865
866                 case PTRACE_SETCRUNCHREGS:
867                         ret = ptrace_setcrunchregs(child, datap);
868                         break;
869 #endif
870
871 #ifdef CONFIG_VFP
872                 case PTRACE_GETVFPREGS:
873                         ret = copy_regset_to_user(child,
874                                                   &user_arm_view, REGSET_VFP,
875                                                   0, ARM_VFPREGS_SIZE,
876                                                   datap);
877                         break;
878
879                 case PTRACE_SETVFPREGS:
880                         ret = copy_regset_from_user(child,
881                                                     &user_arm_view, REGSET_VFP,
882                                                     0, ARM_VFPREGS_SIZE,
883                                                     datap);
884                         break;
885 #endif
886
887 #ifdef CONFIG_HAVE_HW_BREAKPOINT
888                 case PTRACE_GETHBPREGS:
889                         if (ptrace_get_breakpoints(child) < 0)
890                                 return -ESRCH;
891
892                         ret = ptrace_gethbpregs(child, addr,
893                                                 (unsigned long __user *)data);
894                         ptrace_put_breakpoints(child);
895                         break;
896                 case PTRACE_SETHBPREGS:
897                         if (ptrace_get_breakpoints(child) < 0)
898                                 return -ESRCH;
899
900                         ret = ptrace_sethbpregs(child, addr,
901                                                 (unsigned long __user *)data);
902                         ptrace_put_breakpoints(child);
903                         break;
904 #endif
905
906                 default:
907                         ret = ptrace_request(child, request, addr, data);
908                         break;
909         }
910
911         return ret;
912 }
913
914 enum ptrace_syscall_dir {
915         PTRACE_SYSCALL_ENTER = 0,
916         PTRACE_SYSCALL_EXIT,
917 };
918
919 static int tracehook_report_syscall(struct pt_regs *regs,
920                                     enum ptrace_syscall_dir dir)
921 {
922         unsigned long ip;
923
924         /*
925          * IP is used to denote syscall entry/exit:
926          * IP = 0 -> entry, =1 -> exit
927          */
928         ip = regs->ARM_ip;
929         regs->ARM_ip = dir;
930
931         if (dir == PTRACE_SYSCALL_EXIT)
932                 tracehook_report_syscall_exit(regs, 0);
933         else if (tracehook_report_syscall_entry(regs))
934                 current_thread_info()->syscall = -1;
935
936         regs->ARM_ip = ip;
937         return current_thread_info()->syscall;
938 }
939
940 asmlinkage int syscall_trace_enter(struct pt_regs *regs, int scno)
941 {
942         current_thread_info()->syscall = scno;
943
944         /* Do the secure computing check first; failures should be fast. */
945         if (secure_computing(scno) == -1)
946                 return -1;
947
948         if (test_thread_flag(TIF_SYSCALL_TRACE))
949                 scno = tracehook_report_syscall(regs, PTRACE_SYSCALL_ENTER);
950
951         if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
952                 trace_sys_enter(regs, scno);
953
954         audit_syscall_entry(AUDIT_ARCH_ARM, scno, regs->ARM_r0, regs->ARM_r1,
955                             regs->ARM_r2, regs->ARM_r3);
956
957         return scno;
958 }
959
960 asmlinkage void syscall_trace_exit(struct pt_regs *regs)
961 {
962         /*
963          * Audit the syscall before anything else, as a debugger may
964          * come in and change the current registers.
965          */
966         audit_syscall_exit(regs);
967
968         /*
969          * Note that we haven't updated the ->syscall field for the
970          * current thread. This isn't a problem because it will have
971          * been set on syscall entry and there hasn't been an opportunity
972          * for a PTRACE_SET_SYSCALL since then.
973          */
974         if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
975                 trace_sys_exit(regs, regs_return_value(regs));
976
977         if (test_thread_flag(TIF_SYSCALL_TRACE))
978                 tracehook_report_syscall(regs, PTRACE_SYSCALL_EXIT);
979 }