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 62struct 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 71static 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 */ 100int 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 */ 116const 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 */ 133bool 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 */ 148unsigned 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 */ 164static 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 */ 175static inline int 176put_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 */ 195void ptrace_disable(struct task_struct *child) 196{ 197 /* Nothing to do. */ 198} 199 200/* 201 * Handle hitting a breakpoint. 202 */ 203void 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 215static int break_trap(struct pt_regs *regs, unsigned int instr) 216{ 217 ptrace_break(current, regs); 218 return 0; 219} 220 221static 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 229static 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 237static 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 245static 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 253core_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 */ 259static 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 */ 286static 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 */ 303static 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 */ 317static 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 */ 334static 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 */ 346static 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 */ 364static 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 */ 375static 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 */ 385static 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 */ 413void 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 */ 422void 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 435static 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 456static 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 472static 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 510put: 511 if (put_user(reg, data)) 512 ret = -EFAULT; 513 514out: 515 return ret; 516} 517 518static 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); 578out: 579 return ret; 580} 581#endif 582 583/* regset get/set implementations */ 584 585static 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 597static 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 618static 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 628static 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 */ 665static 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 */ 702static 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 thread->vfpstate.hard = new_vfp; 737 vfp_flush_hwstate(thread); 738 739 return 0; 740} 741#endif /* CONFIG_VFP */ 742 743enum arm_regset { 744 REGSET_GPR, 745 REGSET_FPR, 746#ifdef CONFIG_VFP 747 REGSET_VFP, 748#endif 749}; 750 751static 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 788static 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 793const struct user_regset_view *task_user_regset_view(struct task_struct *task) 794{ 795 return &user_arm_view; 796} 797 798long 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[0], 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 ret = ptrace_gethbpregs(child, addr, 890 (unsigned long __user *)data); 891 break; 892 case PTRACE_SETHBPREGS: 893 ret = ptrace_sethbpregs(child, addr, 894 (unsigned long __user *)data); 895 break; 896#endif 897 898 default: 899 ret = ptrace_request(child, request, addr, data); 900 break; 901 } 902 903 return ret; 904} 905 906enum ptrace_syscall_dir { 907 PTRACE_SYSCALL_ENTER = 0, 908 PTRACE_SYSCALL_EXIT, 909}; 910 911static void tracehook_report_syscall(struct pt_regs *regs, 912 enum ptrace_syscall_dir dir) 913{ 914 unsigned long ip; 915 916 /* 917 * IP is used to denote syscall entry/exit: 918 * IP = 0 -> entry, =1 -> exit 919 */ 920 ip = regs->ARM_ip; 921 regs->ARM_ip = dir; 922 923 if (dir == PTRACE_SYSCALL_EXIT) 924 tracehook_report_syscall_exit(regs, 0); 925 else if (tracehook_report_syscall_entry(regs)) 926 current_thread_info()->syscall = -1; 927 928 regs->ARM_ip = ip; 929} 930 931asmlinkage int syscall_trace_enter(struct pt_regs *regs, int scno) 932{ 933 current_thread_info()->syscall = scno; 934 935 /* Do the secure computing check first; failures should be fast. */ 936#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER 937 if (secure_computing() == -1) 938 return -1; 939#else 940 /* XXX: remove this once OABI gets fixed */ 941 secure_computing_strict(scno); 942#endif 943 944 if (test_thread_flag(TIF_SYSCALL_TRACE)) 945 tracehook_report_syscall(regs, PTRACE_SYSCALL_ENTER); 946 947 scno = current_thread_info()->syscall; 948 949 if (test_thread_flag(TIF_SYSCALL_TRACEPOINT)) 950 trace_sys_enter(regs, scno); 951 952 audit_syscall_entry(scno, regs->ARM_r0, regs->ARM_r1, regs->ARM_r2, 953 regs->ARM_r3); 954 955 return scno; 956} 957 958asmlinkage void syscall_trace_exit(struct pt_regs *regs) 959{ 960 /* 961 * Audit the syscall before anything else, as a debugger may 962 * come in and change the current registers. 963 */ 964 audit_syscall_exit(regs); 965 966 /* 967 * Note that we haven't updated the ->syscall field for the 968 * current thread. This isn't a problem because it will have 969 * been set on syscall entry and there hasn't been an opportunity 970 * for a PTRACE_SET_SYSCALL since then. 971 */ 972 if (test_thread_flag(TIF_SYSCALL_TRACEPOINT)) 973 trace_sys_exit(regs, regs_return_value(regs)); 974 975 if (test_thread_flag(TIF_SYSCALL_TRACE)) 976 tracehook_report_syscall(regs, PTRACE_SYSCALL_EXIT); 977} 978