blob: ede6443c34d964670560f155aaf200ed6bf0949e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/kernel.h>
13#include <linux/sched.h>
14#include <linux/mm.h>
Paul Gortmakerce8b9d22011-07-18 12:03:53 -040015#include <linux/elf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/smp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/ptrace.h>
18#include <linux/user.h>
19#include <linux/security.h>
20#include <linux/init.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070021#include <linux/signal.h>
Russell King33fa9b12008-09-06 11:35:55 +010022#include <linux/uaccess.h>
Will Deacon864232f2010-09-03 10:42:55 +010023#include <linux/perf_event.h>
24#include <linux/hw_breakpoint.h>
Dave Martin5be6f622011-04-18 14:48:23 +010025#include <linux/regset.h>
Eric Paris5180bb32012-02-21 11:26:55 -050026#include <linux/audit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <asm/pgtable.h>
29#include <asm/system.h>
30#include <asm/traps.h>
31
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#define REG_PC 15
33#define REG_PSR 16
34/*
35 * does not yet catch signals sent when the child dies.
36 * in exit.c or in signal.c.
37 */
38
39#if 0
40/*
41 * Breakpoint SWI instruction: SWI &9F0001
42 */
43#define BREAKINST_ARM 0xef9f0001
44#define BREAKINST_THUMB 0xdf00 /* fill this in later */
45#else
46/*
47 * New breakpoints - use an undefined instruction. The ARM architecture
48 * reference manual guarantees that the following instruction space
49 * will produce an undefined instruction exception on all CPUs:
50 *
51 * ARM: xxxx 0111 1111 xxxx xxxx xxxx 1111 xxxx
52 * Thumb: 1101 1110 xxxx xxxx
53 */
54#define BREAKINST_ARM 0xe7f001f0
55#define BREAKINST_THUMB 0xde01
56#endif
57
Will Deacone513f8b2010-06-25 12:24:53 +010058struct pt_regs_offset {
59 const char *name;
60 int offset;
61};
62
63#define REG_OFFSET_NAME(r) \
64 {.name = #r, .offset = offsetof(struct pt_regs, ARM_##r)}
65#define REG_OFFSET_END {.name = NULL, .offset = 0}
66
67static const struct pt_regs_offset regoffset_table[] = {
68 REG_OFFSET_NAME(r0),
69 REG_OFFSET_NAME(r1),
70 REG_OFFSET_NAME(r2),
71 REG_OFFSET_NAME(r3),
72 REG_OFFSET_NAME(r4),
73 REG_OFFSET_NAME(r5),
74 REG_OFFSET_NAME(r6),
75 REG_OFFSET_NAME(r7),
76 REG_OFFSET_NAME(r8),
77 REG_OFFSET_NAME(r9),
78 REG_OFFSET_NAME(r10),
79 REG_OFFSET_NAME(fp),
80 REG_OFFSET_NAME(ip),
81 REG_OFFSET_NAME(sp),
82 REG_OFFSET_NAME(lr),
83 REG_OFFSET_NAME(pc),
84 REG_OFFSET_NAME(cpsr),
85 REG_OFFSET_NAME(ORIG_r0),
86 REG_OFFSET_END,
87};
88
89/**
90 * regs_query_register_offset() - query register offset from its name
91 * @name: the name of a register
92 *
93 * regs_query_register_offset() returns the offset of a register in struct
94 * pt_regs from its name. If the name is invalid, this returns -EINVAL;
95 */
96int regs_query_register_offset(const char *name)
97{
98 const struct pt_regs_offset *roff;
99 for (roff = regoffset_table; roff->name != NULL; roff++)
100 if (!strcmp(roff->name, name))
101 return roff->offset;
102 return -EINVAL;
103}
104
105/**
106 * regs_query_register_name() - query register name from its offset
107 * @offset: the offset of a register in struct pt_regs.
108 *
109 * regs_query_register_name() returns the name of a register from its
110 * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
111 */
112const char *regs_query_register_name(unsigned int offset)
113{
114 const struct pt_regs_offset *roff;
115 for (roff = regoffset_table; roff->name != NULL; roff++)
116 if (roff->offset == offset)
117 return roff->name;
118 return NULL;
119}
120
121/**
122 * regs_within_kernel_stack() - check the address in the stack
123 * @regs: pt_regs which contains kernel stack pointer.
124 * @addr: address which is checked.
125 *
126 * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
127 * If @addr is within the kernel stack, it returns true. If not, returns false.
128 */
129bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
130{
131 return ((addr & ~(THREAD_SIZE - 1)) ==
132 (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
133}
134
135/**
136 * regs_get_kernel_stack_nth() - get Nth entry of the stack
137 * @regs: pt_regs which contains kernel stack pointer.
138 * @n: stack entry number.
139 *
140 * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
141 * is specified by @regs. If the @n th entry is NOT in the kernel stack,
142 * this returns 0.
143 */
144unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
145{
146 unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
147 addr += n;
148 if (regs_within_kernel_stack(regs, (unsigned long)addr))
149 return *addr;
150 else
151 return 0;
152}
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 * this routine will get a word off of the processes privileged stack.
156 * the offset is how far from the base addr as stored in the THREAD.
157 * this routine assumes that all the privileged stacks are in our
158 * data space.
159 */
160static inline long get_user_reg(struct task_struct *task, int offset)
161{
Al Viro815d5ec2006-01-12 01:05:57 -0800162 return task_pt_regs(task)->uregs[offset];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
165/*
166 * this routine will put a word on the processes privileged stack.
167 * the offset is how far from the base addr as stored in the THREAD.
168 * this routine assumes that all the privileged stacks are in our
169 * data space.
170 */
171static inline int
172put_user_reg(struct task_struct *task, int offset, long data)
173{
Al Viro815d5ec2006-01-12 01:05:57 -0800174 struct pt_regs newregs, *regs = task_pt_regs(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 int ret = -EINVAL;
176
177 newregs = *regs;
178 newregs.uregs[offset] = data;
179
180 if (valid_user_regs(&newregs)) {
181 regs->uregs[offset] = data;
182 ret = 0;
183 }
184
185 return ret;
186}
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/*
189 * Called by kernel/ptrace.c when detaching..
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 */
191void ptrace_disable(struct task_struct *child)
192{
Will Deacon425fc472011-02-14 14:31:09 +0100193 /* Nothing to do. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
196/*
197 * Handle hitting a breakpoint.
198 */
199void ptrace_break(struct task_struct *tsk, struct pt_regs *regs)
200{
201 siginfo_t info;
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 info.si_signo = SIGTRAP;
204 info.si_errno = 0;
205 info.si_code = TRAP_BRKPT;
206 info.si_addr = (void __user *)instruction_pointer(regs);
207
208 force_sig_info(SIGTRAP, &info, tsk);
209}
210
211static int break_trap(struct pt_regs *regs, unsigned int instr)
212{
213 ptrace_break(current, regs);
214 return 0;
215}
216
217static struct undef_hook arm_break_hook = {
218 .instr_mask = 0x0fffffff,
219 .instr_val = 0x07f001f0,
220 .cpsr_mask = PSR_T_BIT,
221 .cpsr_val = 0,
222 .fn = break_trap,
223};
224
225static struct undef_hook thumb_break_hook = {
226 .instr_mask = 0xffff,
227 .instr_val = 0xde01,
228 .cpsr_mask = PSR_T_BIT,
229 .cpsr_val = PSR_T_BIT,
230 .fn = break_trap,
231};
232
Daniel Jacobowitzd23bc1b2010-02-02 18:22:16 +0100233static struct undef_hook thumb2_break_hook = {
Jon Medhurst592201a2011-03-26 19:19:07 +0000234 .instr_mask = 0xffffffff,
235 .instr_val = 0xf7f0a000,
Daniel Jacobowitzd23bc1b2010-02-02 18:22:16 +0100236 .cpsr_mask = PSR_T_BIT,
237 .cpsr_val = PSR_T_BIT,
Jon Medhurst592201a2011-03-26 19:19:07 +0000238 .fn = break_trap,
Daniel Jacobowitzd23bc1b2010-02-02 18:22:16 +0100239};
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241static int __init ptrace_break_init(void)
242{
243 register_undef_hook(&arm_break_hook);
244 register_undef_hook(&thumb_break_hook);
Daniel Jacobowitzd23bc1b2010-02-02 18:22:16 +0100245 register_undef_hook(&thumb2_break_hook);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 return 0;
247}
248
249core_initcall(ptrace_break_init);
250
251/*
252 * Read the word at offset "off" into the "struct user". We
253 * actually access the pt_regs stored on the kernel stack.
254 */
255static int ptrace_read_user(struct task_struct *tsk, unsigned long off,
256 unsigned long __user *ret)
257{
258 unsigned long tmp;
259
260 if (off & 3 || off >= sizeof(struct user))
261 return -EIO;
262
263 tmp = 0;
Paul Brook68b7f7152009-07-24 12:34:58 +0100264 if (off == PT_TEXT_ADDR)
265 tmp = tsk->mm->start_code;
266 else if (off == PT_DATA_ADDR)
267 tmp = tsk->mm->start_data;
268 else if (off == PT_TEXT_END_ADDR)
269 tmp = tsk->mm->end_code;
270 else if (off < sizeof(struct pt_regs))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 tmp = get_user_reg(tsk, off >> 2);
272
273 return put_user(tmp, ret);
274}
275
276/*
277 * Write the word at offset "off" into "struct user". We
278 * actually access the pt_regs stored on the kernel stack.
279 */
280static int ptrace_write_user(struct task_struct *tsk, unsigned long off,
281 unsigned long val)
282{
283 if (off & 3 || off >= sizeof(struct user))
284 return -EIO;
285
286 if (off >= sizeof(struct pt_regs))
287 return 0;
288
289 return put_user_reg(tsk, off >> 2, val);
290}
291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292#ifdef CONFIG_IWMMXT
293
294/*
295 * Get the child iWMMXt state.
296 */
297static int ptrace_getwmmxregs(struct task_struct *tsk, void __user *ufp)
298{
Al Viroe7c1b322006-01-12 01:05:56 -0800299 struct thread_info *thread = task_thread_info(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301 if (!test_ti_thread_flag(thread, TIF_USING_IWMMXT))
302 return -ENODATA;
303 iwmmxt_task_disable(thread); /* force it to ram */
Russell Kingcdaabbd2006-03-12 22:36:06 +0000304 return copy_to_user(ufp, &thread->fpstate.iwmmxt, IWMMXT_SIZE)
305 ? -EFAULT : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306}
307
308/*
309 * Set the child iWMMXt state.
310 */
311static int ptrace_setwmmxregs(struct task_struct *tsk, void __user *ufp)
312{
Al Viroe7c1b322006-01-12 01:05:56 -0800313 struct thread_info *thread = task_thread_info(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315 if (!test_ti_thread_flag(thread, TIF_USING_IWMMXT))
316 return -EACCES;
317 iwmmxt_task_release(thread); /* force a reload */
Russell King17320a92006-03-15 14:57:13 +0000318 return copy_from_user(&thread->fpstate.iwmmxt, ufp, IWMMXT_SIZE)
Russell Kingcdaabbd2006-03-12 22:36:06 +0000319 ? -EFAULT : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320}
321
322#endif
323
Lennert Buytenhek5429b062006-06-27 22:56:19 +0100324#ifdef CONFIG_CRUNCH
325/*
326 * Get the child Crunch state.
327 */
328static int ptrace_getcrunchregs(struct task_struct *tsk, void __user *ufp)
329{
330 struct thread_info *thread = task_thread_info(tsk);
331
332 crunch_task_disable(thread); /* force it to ram */
333 return copy_to_user(ufp, &thread->crunchstate, CRUNCH_SIZE)
334 ? -EFAULT : 0;
335}
336
337/*
338 * Set the child Crunch state.
339 */
340static int ptrace_setcrunchregs(struct task_struct *tsk, void __user *ufp)
341{
342 struct thread_info *thread = task_thread_info(tsk);
343
344 crunch_task_release(thread); /* force a reload */
345 return copy_from_user(&thread->crunchstate, ufp, CRUNCH_SIZE)
346 ? -EFAULT : 0;
347}
348#endif
349
Will Deacon864232f2010-09-03 10:42:55 +0100350#ifdef CONFIG_HAVE_HW_BREAKPOINT
351/*
352 * Convert a virtual register number into an index for a thread_info
353 * breakpoint array. Breakpoints are identified using positive numbers
354 * whilst watchpoints are negative. The registers are laid out as pairs
355 * of (address, control), each pair mapping to a unique hw_breakpoint struct.
356 * Register 0 is reserved for describing resource information.
357 */
358static int ptrace_hbp_num_to_idx(long num)
359{
360 if (num < 0)
361 num = (ARM_MAX_BRP << 1) - num;
362 return (num - 1) >> 1;
363}
364
365/*
366 * Returns the virtual register number for the address of the
367 * breakpoint at index idx.
368 */
369static long ptrace_hbp_idx_to_num(int idx)
370{
371 long mid = ARM_MAX_BRP << 1;
372 long num = (idx << 1) + 1;
373 return num > mid ? mid - num : num;
374}
375
376/*
377 * Handle hitting a HW-breakpoint.
378 */
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +0200379static void ptrace_hbptriggered(struct perf_event *bp,
Will Deacon864232f2010-09-03 10:42:55 +0100380 struct perf_sample_data *data,
381 struct pt_regs *regs)
382{
383 struct arch_hw_breakpoint *bkpt = counter_arch_bp(bp);
384 long num;
385 int i;
386 siginfo_t info;
387
388 for (i = 0; i < ARM_MAX_HBP_SLOTS; ++i)
389 if (current->thread.debug.hbp[i] == bp)
390 break;
391
392 num = (i == ARM_MAX_HBP_SLOTS) ? 0 : ptrace_hbp_idx_to_num(i);
393
394 info.si_signo = SIGTRAP;
395 info.si_errno = (int)num;
396 info.si_code = TRAP_HWBKPT;
397 info.si_addr = (void __user *)(bkpt->trigger);
398
399 force_sig_info(SIGTRAP, &info, current);
400}
401
402/*
403 * Set ptrace breakpoint pointers to zero for this task.
404 * This is required in order to prevent child processes from unregistering
405 * breakpoints held by their parent.
406 */
407void clear_ptrace_hw_breakpoint(struct task_struct *tsk)
408{
409 memset(tsk->thread.debug.hbp, 0, sizeof(tsk->thread.debug.hbp));
410}
411
412/*
413 * Unregister breakpoints from this task and reset the pointers in
414 * the thread_struct.
415 */
416void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
417{
418 int i;
419 struct thread_struct *t = &tsk->thread;
420
421 for (i = 0; i < ARM_MAX_HBP_SLOTS; i++) {
422 if (t->debug.hbp[i]) {
423 unregister_hw_breakpoint(t->debug.hbp[i]);
424 t->debug.hbp[i] = NULL;
425 }
426 }
427}
428
429static u32 ptrace_get_hbp_resource_info(void)
430{
431 u8 num_brps, num_wrps, debug_arch, wp_len;
432 u32 reg = 0;
433
434 num_brps = hw_breakpoint_slots(TYPE_INST);
435 num_wrps = hw_breakpoint_slots(TYPE_DATA);
436 debug_arch = arch_get_debug_arch();
437 wp_len = arch_get_max_wp_len();
438
439 reg |= debug_arch;
440 reg <<= 8;
441 reg |= wp_len;
442 reg <<= 8;
443 reg |= num_wrps;
444 reg <<= 8;
445 reg |= num_brps;
446
447 return reg;
448}
449
450static struct perf_event *ptrace_hbp_create(struct task_struct *tsk, int type)
451{
452 struct perf_event_attr attr;
453
454 ptrace_breakpoint_init(&attr);
455
456 /* Initialise fields to sane defaults. */
457 attr.bp_addr = 0;
458 attr.bp_len = HW_BREAKPOINT_LEN_4;
459 attr.bp_type = type;
460 attr.disabled = 1;
461
Avi Kivity4dc0da82011-06-29 18:42:35 +0300462 return register_user_hw_breakpoint(&attr, ptrace_hbptriggered, NULL,
463 tsk);
Will Deacon864232f2010-09-03 10:42:55 +0100464}
465
466static int ptrace_gethbpregs(struct task_struct *tsk, long num,
467 unsigned long __user *data)
468{
469 u32 reg;
470 int idx, ret = 0;
471 struct perf_event *bp;
472 struct arch_hw_breakpoint_ctrl arch_ctrl;
473
474 if (num == 0) {
475 reg = ptrace_get_hbp_resource_info();
476 } else {
477 idx = ptrace_hbp_num_to_idx(num);
478 if (idx < 0 || idx >= ARM_MAX_HBP_SLOTS) {
479 ret = -EINVAL;
480 goto out;
481 }
482
483 bp = tsk->thread.debug.hbp[idx];
484 if (!bp) {
485 reg = 0;
486 goto put;
487 }
488
489 arch_ctrl = counter_arch_bp(bp)->ctrl;
490
491 /*
492 * Fix up the len because we may have adjusted it
493 * to compensate for an unaligned address.
494 */
495 while (!(arch_ctrl.len & 0x1))
496 arch_ctrl.len >>= 1;
497
Will Deaconba55d3d2011-02-25 20:19:32 +0100498 if (num & 0x1)
Will Deacon864232f2010-09-03 10:42:55 +0100499 reg = bp->attr.bp_addr;
Will Deaconba55d3d2011-02-25 20:19:32 +0100500 else
501 reg = encode_ctrl_reg(arch_ctrl);
Will Deacon864232f2010-09-03 10:42:55 +0100502 }
503
504put:
505 if (put_user(reg, data))
506 ret = -EFAULT;
507
508out:
509 return ret;
510}
511
512static int ptrace_sethbpregs(struct task_struct *tsk, long num,
513 unsigned long __user *data)
514{
515 int idx, gen_len, gen_type, implied_type, ret = 0;
516 u32 user_val;
517 struct perf_event *bp;
518 struct arch_hw_breakpoint_ctrl ctrl;
519 struct perf_event_attr attr;
520
521 if (num == 0)
522 goto out;
523 else if (num < 0)
524 implied_type = HW_BREAKPOINT_RW;
525 else
526 implied_type = HW_BREAKPOINT_X;
527
528 idx = ptrace_hbp_num_to_idx(num);
529 if (idx < 0 || idx >= ARM_MAX_HBP_SLOTS) {
530 ret = -EINVAL;
531 goto out;
532 }
533
534 if (get_user(user_val, data)) {
535 ret = -EFAULT;
536 goto out;
537 }
538
539 bp = tsk->thread.debug.hbp[idx];
540 if (!bp) {
541 bp = ptrace_hbp_create(tsk, implied_type);
542 if (IS_ERR(bp)) {
543 ret = PTR_ERR(bp);
544 goto out;
545 }
546 tsk->thread.debug.hbp[idx] = bp;
547 }
548
549 attr = bp->attr;
550
551 if (num & 0x1) {
552 /* Address */
553 attr.bp_addr = user_val;
554 } else {
555 /* Control */
556 decode_ctrl_reg(user_val, &ctrl);
557 ret = arch_bp_generic_fields(ctrl, &gen_len, &gen_type);
558 if (ret)
559 goto out;
560
561 if ((gen_type & implied_type) != gen_type) {
Will Deaconce9b1b02010-11-25 12:59:31 +0000562 ret = -EINVAL;
563 goto out;
Will Deacon864232f2010-09-03 10:42:55 +0100564 }
565
566 attr.bp_len = gen_len;
567 attr.bp_type = gen_type;
568 attr.disabled = !ctrl.enabled;
569 }
570
571 ret = modify_user_hw_breakpoint(bp, &attr);
572out:
573 return ret;
574}
575#endif
576
Dave Martin5be6f622011-04-18 14:48:23 +0100577/* regset get/set implementations */
578
579static int gpr_get(struct task_struct *target,
580 const struct user_regset *regset,
581 unsigned int pos, unsigned int count,
582 void *kbuf, void __user *ubuf)
583{
584 struct pt_regs *regs = task_pt_regs(target);
585
586 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
587 regs,
588 0, sizeof(*regs));
589}
590
591static int gpr_set(struct task_struct *target,
592 const struct user_regset *regset,
593 unsigned int pos, unsigned int count,
594 const void *kbuf, const void __user *ubuf)
595{
596 int ret;
597 struct pt_regs newregs;
598
599 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
600 &newregs,
601 0, sizeof(newregs));
602 if (ret)
603 return ret;
604
605 if (!valid_user_regs(&newregs))
606 return -EINVAL;
607
608 *task_pt_regs(target) = newregs;
609 return 0;
610}
611
612static int fpa_get(struct task_struct *target,
613 const struct user_regset *regset,
614 unsigned int pos, unsigned int count,
615 void *kbuf, void __user *ubuf)
616{
617 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
618 &task_thread_info(target)->fpstate,
619 0, sizeof(struct user_fp));
620}
621
622static int fpa_set(struct task_struct *target,
623 const struct user_regset *regset,
624 unsigned int pos, unsigned int count,
625 const void *kbuf, const void __user *ubuf)
626{
627 struct thread_info *thread = task_thread_info(target);
628
629 thread->used_cp[1] = thread->used_cp[2] = 1;
630
631 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
632 &thread->fpstate,
633 0, sizeof(struct user_fp));
634}
635
636#ifdef CONFIG_VFP
637/*
638 * VFP register get/set implementations.
639 *
640 * With respect to the kernel, struct user_fp is divided into three chunks:
641 * 16 or 32 real VFP registers (d0-d15 or d0-31)
642 * These are transferred to/from the real registers in the task's
643 * vfp_hard_struct. The number of registers depends on the kernel
644 * configuration.
645 *
646 * 16 or 0 fake VFP registers (d16-d31 or empty)
647 * i.e., the user_vfp structure has space for 32 registers even if
648 * the kernel doesn't have them all.
649 *
650 * vfp_get() reads this chunk as zero where applicable
651 * vfp_set() ignores this chunk
652 *
653 * 1 word for the FPSCR
654 *
655 * The bounds-checking logic built into user_regset_copyout and friends
656 * means that we can make a simple sequence of calls to map the relevant data
657 * to/from the specified slice of the user regset structure.
658 */
659static int vfp_get(struct task_struct *target,
660 const struct user_regset *regset,
661 unsigned int pos, unsigned int count,
662 void *kbuf, void __user *ubuf)
663{
664 int ret;
665 struct thread_info *thread = task_thread_info(target);
666 struct vfp_hard_struct const *vfp = &thread->vfpstate.hard;
667 const size_t user_fpregs_offset = offsetof(struct user_vfp, fpregs);
668 const size_t user_fpscr_offset = offsetof(struct user_vfp, fpscr);
669
670 vfp_sync_hwstate(thread);
671
672 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
673 &vfp->fpregs,
674 user_fpregs_offset,
675 user_fpregs_offset + sizeof(vfp->fpregs));
676 if (ret)
677 return ret;
678
679 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
680 user_fpregs_offset + sizeof(vfp->fpregs),
681 user_fpscr_offset);
682 if (ret)
683 return ret;
684
685 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
686 &vfp->fpscr,
687 user_fpscr_offset,
688 user_fpscr_offset + sizeof(vfp->fpscr));
689}
690
691/*
692 * For vfp_set() a read-modify-write is done on the VFP registers,
693 * in order to avoid writing back a half-modified set of registers on
694 * failure.
695 */
696static int vfp_set(struct task_struct *target,
697 const struct user_regset *regset,
698 unsigned int pos, unsigned int count,
699 const void *kbuf, const void __user *ubuf)
700{
701 int ret;
702 struct thread_info *thread = task_thread_info(target);
Dave Martin247f4992012-01-30 20:22:28 +0100703 struct vfp_hard_struct new_vfp;
Dave Martin5be6f622011-04-18 14:48:23 +0100704 const size_t user_fpregs_offset = offsetof(struct user_vfp, fpregs);
705 const size_t user_fpscr_offset = offsetof(struct user_vfp, fpscr);
706
Dave Martin247f4992012-01-30 20:22:28 +0100707 vfp_sync_hwstate(thread);
708 new_vfp = thread->vfpstate.hard;
709
Dave Martin5be6f622011-04-18 14:48:23 +0100710 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
711 &new_vfp.fpregs,
712 user_fpregs_offset,
713 user_fpregs_offset + sizeof(new_vfp.fpregs));
714 if (ret)
715 return ret;
716
717 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
718 user_fpregs_offset + sizeof(new_vfp.fpregs),
719 user_fpscr_offset);
720 if (ret)
721 return ret;
722
723 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
724 &new_vfp.fpscr,
725 user_fpscr_offset,
726 user_fpscr_offset + sizeof(new_vfp.fpscr));
727 if (ret)
728 return ret;
729
Dave Martin5be6f622011-04-18 14:48:23 +0100730 vfp_flush_hwstate(thread);
Will Deacon8130b9d2012-01-30 20:23:29 +0100731 thread->vfpstate.hard = new_vfp;
Dave Martin5be6f622011-04-18 14:48:23 +0100732
733 return 0;
734}
735#endif /* CONFIG_VFP */
736
737enum arm_regset {
738 REGSET_GPR,
739 REGSET_FPR,
740#ifdef CONFIG_VFP
741 REGSET_VFP,
742#endif
743};
744
745static const struct user_regset arm_regsets[] = {
746 [REGSET_GPR] = {
747 .core_note_type = NT_PRSTATUS,
748 .n = ELF_NGREG,
749 .size = sizeof(u32),
750 .align = sizeof(u32),
751 .get = gpr_get,
752 .set = gpr_set
753 },
754 [REGSET_FPR] = {
755 /*
756 * For the FPA regs in fpstate, the real fields are a mixture
757 * of sizes, so pretend that the registers are word-sized:
758 */
759 .core_note_type = NT_PRFPREG,
760 .n = sizeof(struct user_fp) / sizeof(u32),
761 .size = sizeof(u32),
762 .align = sizeof(u32),
763 .get = fpa_get,
764 .set = fpa_set
765 },
766#ifdef CONFIG_VFP
767 [REGSET_VFP] = {
768 /*
769 * Pretend that the VFP regs are word-sized, since the FPSCR is
770 * a single word dangling at the end of struct user_vfp:
771 */
772 .core_note_type = NT_ARM_VFP,
773 .n = ARM_VFPREGS_SIZE / sizeof(u32),
774 .size = sizeof(u32),
775 .align = sizeof(u32),
776 .get = vfp_get,
777 .set = vfp_set
778 },
779#endif /* CONFIG_VFP */
780};
781
782static const struct user_regset_view user_arm_view = {
783 .name = "arm", .e_machine = ELF_ARCH, .ei_osabi = ELF_OSABI,
784 .regsets = arm_regsets, .n = ARRAY_SIZE(arm_regsets)
785};
786
787const struct user_regset_view *task_user_regset_view(struct task_struct *task)
788{
789 return &user_arm_view;
790}
791
Namhyung Kim9b05a692010-10-27 15:33:47 -0700792long arch_ptrace(struct task_struct *child, long request,
793 unsigned long addr, unsigned long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 int ret;
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700796 unsigned long __user *datap = (unsigned long __user *) data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798 switch (request) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 case PTRACE_PEEKUSR:
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700800 ret = ptrace_read_user(child, addr, datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 break;
802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 case PTRACE_POKEUSR:
804 ret = ptrace_write_user(child, addr, data);
805 break;
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 case PTRACE_GETREGS:
Dave Martin5be6f622011-04-18 14:48:23 +0100808 ret = copy_regset_to_user(child,
809 &user_arm_view, REGSET_GPR,
810 0, sizeof(struct pt_regs),
811 datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 break;
813
814 case PTRACE_SETREGS:
Dave Martin5be6f622011-04-18 14:48:23 +0100815 ret = copy_regset_from_user(child,
816 &user_arm_view, REGSET_GPR,
817 0, sizeof(struct pt_regs),
818 datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 break;
820
821 case PTRACE_GETFPREGS:
Dave Martin5be6f622011-04-18 14:48:23 +0100822 ret = copy_regset_to_user(child,
823 &user_arm_view, REGSET_FPR,
824 0, sizeof(union fp_state),
825 datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 break;
Dave Martin5be6f622011-04-18 14:48:23 +0100827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 case PTRACE_SETFPREGS:
Dave Martin5be6f622011-04-18 14:48:23 +0100829 ret = copy_regset_from_user(child,
830 &user_arm_view, REGSET_FPR,
831 0, sizeof(union fp_state),
832 datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 break;
834
835#ifdef CONFIG_IWMMXT
836 case PTRACE_GETWMMXREGS:
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700837 ret = ptrace_getwmmxregs(child, datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 break;
839
840 case PTRACE_SETWMMXREGS:
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700841 ret = ptrace_setwmmxregs(child, datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 break;
843#endif
844
845 case PTRACE_GET_THREAD_AREA:
Al Viroe7c1b322006-01-12 01:05:56 -0800846 ret = put_user(task_thread_info(child)->tp_value,
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700847 datap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 break;
849
Nicolas Pitre3f471122006-01-14 19:30:04 +0000850 case PTRACE_SET_SYSCALL:
Russell King5ba6d3f2007-05-06 13:56:26 +0100851 task_thread_info(child)->syscall = data;
Nicolas Pitre3f471122006-01-14 19:30:04 +0000852 ret = 0;
Nicolas Pitre3f471122006-01-14 19:30:04 +0000853 break;
854
Lennert Buytenhek5429b062006-06-27 22:56:19 +0100855#ifdef CONFIG_CRUNCH
856 case PTRACE_GETCRUNCHREGS:
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700857 ret = ptrace_getcrunchregs(child, datap);
Lennert Buytenhek5429b062006-06-27 22:56:19 +0100858 break;
859
860 case PTRACE_SETCRUNCHREGS:
Namhyung Kimb640a0d2010-10-27 15:33:48 -0700861 ret = ptrace_setcrunchregs(child, datap);
Lennert Buytenhek5429b062006-06-27 22:56:19 +0100862 break;
863#endif
864
Catalin Marinas3d1228e2009-02-11 13:12:56 +0100865#ifdef CONFIG_VFP
866 case PTRACE_GETVFPREGS:
Dave Martin5be6f622011-04-18 14:48:23 +0100867 ret = copy_regset_to_user(child,
868 &user_arm_view, REGSET_VFP,
869 0, ARM_VFPREGS_SIZE,
870 datap);
Catalin Marinas3d1228e2009-02-11 13:12:56 +0100871 break;
872
873 case PTRACE_SETVFPREGS:
Dave Martin5be6f622011-04-18 14:48:23 +0100874 ret = copy_regset_from_user(child,
875 &user_arm_view, REGSET_VFP,
876 0, ARM_VFPREGS_SIZE,
877 datap);
Catalin Marinas3d1228e2009-02-11 13:12:56 +0100878 break;
879#endif
880
Will Deacon864232f2010-09-03 10:42:55 +0100881#ifdef CONFIG_HAVE_HW_BREAKPOINT
882 case PTRACE_GETHBPREGS:
Frederic Weisbeckerbf0b8f42011-04-08 17:29:36 +0200883 if (ptrace_get_breakpoints(child) < 0)
884 return -ESRCH;
885
Will Deacon864232f2010-09-03 10:42:55 +0100886 ret = ptrace_gethbpregs(child, addr,
887 (unsigned long __user *)data);
Frederic Weisbeckerbf0b8f42011-04-08 17:29:36 +0200888 ptrace_put_breakpoints(child);
Will Deacon864232f2010-09-03 10:42:55 +0100889 break;
890 case PTRACE_SETHBPREGS:
Frederic Weisbeckerbf0b8f42011-04-08 17:29:36 +0200891 if (ptrace_get_breakpoints(child) < 0)
892 return -ESRCH;
893
Will Deacon864232f2010-09-03 10:42:55 +0100894 ret = ptrace_sethbpregs(child, addr,
895 (unsigned long __user *)data);
Frederic Weisbeckerbf0b8f42011-04-08 17:29:36 +0200896 ptrace_put_breakpoints(child);
Will Deacon864232f2010-09-03 10:42:55 +0100897 break;
898#endif
899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 default:
901 ret = ptrace_request(child, request, addr, data);
902 break;
903 }
904
905 return ret;
906}
907
Eric Paris5180bb32012-02-21 11:26:55 -0500908#ifdef __ARMEB__
909#define AUDIT_ARCH_NR AUDIT_ARCH_ARMEB
910#else
911#define AUDIT_ARCH_NR AUDIT_ARCH_ARM
912#endif
913
Nicolas Pitre3f471122006-01-14 19:30:04 +0000914asmlinkage int syscall_trace(int why, struct pt_regs *regs, int scno)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
916 unsigned long ip;
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 /*
919 * Save IP. IP is used to denote syscall entry/exit:
920 * IP = 0 -> entry, = 1 -> exit
921 */
922 ip = regs->ARM_ip;
923 regs->ARM_ip = why;
924
Nathaniel Husted29ef73b2012-01-03 14:23:09 -0500925 if (!ip)
926 audit_syscall_exit(regs);
927 else
Eric Paris5180bb32012-02-21 11:26:55 -0500928 audit_syscall_entry(AUDIT_ARCH_NR, scno, regs->ARM_r0,
Nathaniel Husted29ef73b2012-01-03 14:23:09 -0500929 regs->ARM_r1, regs->ARM_r2, regs->ARM_r3);
930
931 if (!test_thread_flag(TIF_SYSCALL_TRACE))
932 return scno;
933 if (!(current->ptrace & PT_PTRACED))
934 return scno;
935
Russell King5ba6d3f2007-05-06 13:56:26 +0100936 current_thread_info()->syscall = scno;
Nicolas Pitre3f471122006-01-14 19:30:04 +0000937
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 /* the 0x80 provides a way for the tracing parent to distinguish
939 between a syscall stop and SIGTRAP delivery */
940 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
941 ? 0x80 : 0));
942 /*
943 * this isn't the same as continuing with a signal, but it will do
944 * for normal use. strace only continues with a signal if the
945 * stopping signal is not SIGTRAP. -brl
946 */
947 if (current->exit_code) {
948 send_sig(current->exit_code, current, 1);
949 current->exit_code = 0;
950 }
951 regs->ARM_ip = ip;
Nicolas Pitre3f471122006-01-14 19:30:04 +0000952
Russell King5ba6d3f2007-05-06 13:56:26 +0100953 return current_thread_info()->syscall;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}