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