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/config.h>
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/mm.h>
  16 #include <linux/smp.h>
  17 #include <linux/smp_lock.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
  24 #include <asm/uaccess.h>
  25 #include <asm/pgtable.h>
  26 #include <asm/system.h>
  27 #include <asm/traps.h>
  28
  29 #include "ptrace.h"
  30
  31 #define REG_PC  15
  32 #define REG_PSR 16
  33 /*
  34  * does not yet catch signals sent when the child dies.
  35  * in exit.c or in signal.c.
  36  */
  37
  38 #if 0
  39 /*
  40  * Breakpoint SWI instruction: SWI &9F0001
  41  */
  42 #define BREAKINST_ARM   0xef9f0001
  43 #define BREAKINST_THUMB 0xdf00          /* fill this in later */
  44 #else
  45 /*
  46  * New breakpoints - use an undefined instruction.  The ARM architecture
  47  * reference manual guarantees that the following instruction space
  48  * will produce an undefined instruction exception on all CPUs:
  49  *
  50  *  ARM:   xxxx 0111 1111 xxxx xxxx xxxx 1111 xxxx
  51  *  Thumb: 1101 1110 xxxx xxxx
  52  */
  53 #define BREAKINST_ARM   0xe7f001f0
  54 #define BREAKINST_THUMB 0xde01
  55 #endif
  56
  57 /*
  58  * Get the address of the live pt_regs for the specified task.
  59  * These are saved onto the top kernel stack when the process
  60  * is not running.
  61  *
  62  * Note: if a user thread is execve'd from kernel space, the
  63  * kernel stack will not be empty on entry to the kernel, so
  64  * ptracing these tasks will fail.
  65  */
  66 static inline struct pt_regs *
  67 get_user_regs(struct task_struct *task)
  68 {
  69         return (struct pt_regs *)
  70                 ((unsigned long)task->thread_info + THREAD_SIZE -
  71                                  8 - sizeof(struct pt_regs));
  72 }
  73
  74 /*
  75  * this routine will get a word off of the processes privileged stack.
  76  * the offset is how far from the base addr as stored in the THREAD.
  77  * this routine assumes that all the privileged stacks are in our
  78  * data space.
  79  */
  80 static inline long get_user_reg(struct task_struct *task, int offset)
  81 {
  82         return get_user_regs(task)->uregs[offset];
  83 }
  84
  85 /*
  86  * this routine will put a word on the processes privileged stack.
  87  * the offset is how far from the base addr as stored in the THREAD.
  88  * this routine assumes that all the privileged stacks are in our
  89  * data space.
  90  */
  91 static inline int
  92 put_user_reg(struct task_struct *task, int offset, long data)
  93 {
  94         struct pt_regs newregs, *regs = get_user_regs(task);
  95         int ret = -EINVAL;
  96
  97         newregs = *regs;
  98         newregs.uregs[offset] = data;
  99
 100         if (valid_user_regs(&newregs)) {
 101                 regs->uregs[offset] = data;
 102                 ret = 0;
 103         }
 104
 105         return ret;
 106 }
 107
 108 static inline int
 109 read_u32(struct task_struct *task, unsigned long addr, u32 *res)
 110 {
 111         int ret;
 112
 113         ret = access_process_vm(task, addr, res, sizeof(*res), 0);
 114
 115         return ret == sizeof(*res) ? 0 : -EIO;
 116 }
 117
 118 static inline int
 119 read_instr(struct task_struct *task, unsigned long addr, u32 *res)
 120 {
 121         int ret;
 122
 123         if (addr & 1) {
 124                 u16 val;
 125                 ret = access_process_vm(task, addr & ~1, &val, sizeof(val), 0);
 126                 ret = ret == sizeof(val) ? 0 : -EIO;
 127                 *res = val;
 128         } else {
 129                 u32 val;
 130                 ret = access_process_vm(task, addr & ~3, &val, sizeof(val), 0);
 131                 ret = ret == sizeof(val) ? 0 : -EIO;
 132                 *res = val;
 133         }
 134         return ret;
 135 }
 136
 137 /*
 138  * Get value of register `rn' (in the instruction)
 139  */
 140 static unsigned long
 141 ptrace_getrn(struct task_struct *child, unsigned long insn)
 142 {
 143         unsigned int reg = (insn >> 16) & 15;
 144         unsigned long val;
 145
 146         val = get_user_reg(child, reg);
 147         if (reg == 15)
 148                 val = pc_pointer(val + 8);
 149
 150         return val;
 151 }
 152
 153 /*
 154  * Get value of operand 2 (in an ALU instruction)
 155  */
 156 static unsigned long
 157 ptrace_getaluop2(struct task_struct *child, unsigned long insn)
 158 {
 159         unsigned long val;
 160         int shift;
 161         int type;
 162
 163         if (insn & 1 << 25) {
 164                 val = insn & 255;
 165                 shift = (insn >> 8) & 15;
 166                 type = 3;
 167         } else {
 168                 val = get_user_reg (child, insn & 15);
 169
 170                 if (insn & (1 << 4))
 171                         shift = (int)get_user_reg (child, (insn >> 8) & 15);
 172                 else
 173                         shift = (insn >> 7) & 31;
 174
 175                 type = (insn >> 5) & 3;
 176         }
 177
 178         switch (type) {
 179         case 0: val <<= shift;  break;
 180         case 1: val >>= shift;  break;
 181         case 2:
 182                 val = (((signed long)val) >> shift);
 183                 break;
 184         case 3:
 185                 val = (val >> shift) | (val << (32 - shift));
 186                 break;
 187         }
 188         return val;
 189 }
 190
 191 /*
 192  * Get value of operand 2 (in a LDR instruction)
 193  */
 194 static unsigned long
 195 ptrace_getldrop2(struct task_struct *child, unsigned long insn)
 196 {
 197         unsigned long val;
 198         int shift;
 199         int type;
 200
 201         val = get_user_reg(child, insn & 15);
 202         shift = (insn >> 7) & 31;
 203         type = (insn >> 5) & 3;
 204
 205         switch (type) {
 206         case 0: val <<= shift;  break;
 207         case 1: val >>= shift;  break;
 208         case 2:
 209                 val = (((signed long)val) >> shift);
 210                 break;
 211         case 3:
 212                 val = (val >> shift) | (val << (32 - shift));
 213                 break;
 214         }
 215         return val;
 216 }
 217
 218 #define OP_MASK 0x01e00000
 219 #define OP_AND  0x00000000
 220 #define OP_EOR  0x00200000
 221 #define OP_SUB  0x00400000
 222 #define OP_RSB  0x00600000
 223 #define OP_ADD  0x00800000
 224 #define OP_ADC  0x00a00000
 225 #define OP_SBC  0x00c00000
 226 #define OP_RSC  0x00e00000
 227 #define OP_ORR  0x01800000
 228 #define OP_MOV  0x01a00000
 229 #define OP_BIC  0x01c00000
 230 #define OP_MVN  0x01e00000
 231
 232 static unsigned long
 233 get_branch_address(struct task_struct *child, unsigned long pc, unsigned long insn)
 234 {
 235         u32 alt = 0;
 236
 237         switch (insn & 0x0e000000) {
 238         case 0x00000000:
 239         case 0x02000000: {
 240                 /*
 241                  * data processing
 242                  */
 243                 long aluop1, aluop2, ccbit;
 244
 245                 if ((insn & 0xf000) != 0xf000)
 246                         break;
 247
 248                 aluop1 = ptrace_getrn(child, insn);
 249                 aluop2 = ptrace_getaluop2(child, insn);
 250                 ccbit  = get_user_reg(child, REG_PSR) & PSR_C_BIT ? 1 : 0;
 251
 252                 switch (insn & OP_MASK) {
 253                 case OP_AND: alt = aluop1 & aluop2;             break;
 254                 case OP_EOR: alt = aluop1 ^ aluop2;             break;
 255                 case OP_SUB: alt = aluop1 - aluop2;             break;
 256                 case OP_RSB: alt = aluop2 - aluop1;             break;
 257                 case OP_ADD: alt = aluop1 + aluop2;             break;
 258                 case OP_ADC: alt = aluop1 + aluop2 + ccbit;     break;
 259                 case OP_SBC: alt = aluop1 - aluop2 + ccbit;     break;
 260                 case OP_RSC: alt = aluop2 - aluop1 + ccbit;     break;
 261                 case OP_ORR: alt = aluop1 | aluop2;             break;
 262                 case OP_MOV: alt = aluop2;                      break;
 263                 case OP_BIC: alt = aluop1 & ~aluop2;            break;
 264                 case OP_MVN: alt = ~aluop2;                     break;
 265                 }
 266                 break;
 267         }
 268
 269         case 0x04000000:
 270         case 0x06000000:
 271                 /*
 272                  * ldr
 273                  */
 274                 if ((insn & 0x0010f000) == 0x0010f000) {
 275                         unsigned long base;
 276
 277                         base = ptrace_getrn(child, insn);
 278                         if (insn & 1 << 24) {
 279                                 long aluop2;
 280
 281                                 if (insn & 0x02000000)
 282                                         aluop2 = ptrace_getldrop2(child, insn);
 283                                 else
 284                                         aluop2 = insn & 0xfff;
 285
 286                                 if (insn & 1 << 23)
 287                                         base += aluop2;
 288                                 else
 289                                         base -= aluop2;
 290                         }
 291                         if (read_u32(child, base, &alt) == 0)
 292                                 alt = pc_pointer(alt);
 293                 }
 294                 break;
 295
 296         case 0x08000000:
 297                 /*
 298                  * ldm
 299                  */
 300                 if ((insn & 0x00108000) == 0x00108000) {
 301                         unsigned long base;
 302                         unsigned int nr_regs;
 303
 304                         if (insn & (1 << 23)) {
 305                                 nr_regs = hweight16(insn & 65535) << 2;
 306
 307                                 if (!(insn & (1 << 24)))
 308                                         nr_regs -= 4;
 309                         } else {
 310                                 if (insn & (1 << 24))
 311                                         nr_regs = -4;
 312                                 else
 313                                         nr_regs = 0;
 314                         }
 315
 316                         base = ptrace_getrn(child, insn);
 317
 318                         if (read_u32(child, base + nr_regs, &alt) == 0)
 319                                 alt = pc_pointer(alt);
 320                         break;
 321                 }
 322                 break;
 323
 324         case 0x0a000000: {
 325                 /*
 326                  * bl or b
 327                  */
 328                 signed long displ;
 329                 /* It's a branch/branch link: instead of trying to
 330                  * figure out whether the branch will be taken or not,
 331                  * we'll put a breakpoint at both locations.  This is
 332                  * simpler, more reliable, and probably not a whole lot
 333                  * slower than the alternative approach of emulating the
 334                  * branch.
 335                  */
 336                 displ = (insn & 0x00ffffff) << 8;
 337                 displ = (displ >> 6) + 8;
 338                 if (displ != 0 && displ != 4)
 339                         alt = pc + displ;
 340             }
 341             break;
 342         }
 343
 344         return alt;
 345 }
 346
 347 static int
 348 swap_insn(struct task_struct *task, unsigned long addr,
 349           void *old_insn, void *new_insn, int size)
 350 {
 351         int ret;
 352
 353         ret = access_process_vm(task, addr, old_insn, size, 0);
 354         if (ret == size)
 355                 ret = access_process_vm(task, addr, new_insn, size, 1);
 356         return ret;
 357 }
 358
 359 static void
 360 add_breakpoint(struct task_struct *task, struct debug_info *dbg, unsigned long addr)
 361 {
 362         int nr = dbg->nsaved;
 363
 364         if (nr < 2) {
 365                 u32 new_insn = BREAKINST_ARM;
 366                 int res;
 367
 368                 res = swap_insn(task, addr, &dbg->bp[nr].insn, &new_insn, 4);
 369
 370                 if (res == 4) {
 371                         dbg->bp[nr].address = addr;
 372                         dbg->nsaved += 1;
 373                 }
 374         } else
 375                 printk(KERN_ERR "ptrace: too many breakpoints\n");
 376 }
 377
 378 /*
 379  * Clear one breakpoint in the user program.  We copy what the hardware
 380  * does and use bit 0 of the address to indicate whether this is a Thumb
 381  * breakpoint or an ARM breakpoint.
 382  */
 383 static void clear_breakpoint(struct task_struct *task, struct debug_entry *bp)
 384 {
 385         unsigned long addr = bp->address;
 386         union debug_insn old_insn;
 387         int ret;
 388
 389         if (addr & 1) {
 390                 ret = swap_insn(task, addr & ~1, &old_insn.thumb,
 391                                 &bp->insn.thumb, 2);
 392
 393                 if (ret != 2 || old_insn.thumb != BREAKINST_THUMB)
 394                         printk(KERN_ERR "%s:%d: corrupted Thumb breakpoint at "
 395                                 "0x%08lx (0x%04x)\n", task->comm, task->pid,
 396                                 addr, old_insn.thumb);
 397         } else {
 398                 ret = swap_insn(task, addr & ~3, &old_insn.arm,
 399                                 &bp->insn.arm, 4);
 400
 401                 if (ret != 4 || old_insn.arm != BREAKINST_ARM)
 402                         printk(KERN_ERR "%s:%d: corrupted ARM breakpoint at "
 403                                 "0x%08lx (0x%08x)\n", task->comm, task->pid,
 404                                 addr, old_insn.arm);
 405         }
 406 }
 407
 408 void ptrace_set_bpt(struct task_struct *child)
 409 {
 410         struct pt_regs *regs;
 411         unsigned long pc;
 412         u32 insn;
 413         int res;
 414
 415         regs = get_user_regs(child);
 416         pc = instruction_pointer(regs);
 417
 418         if (thumb_mode(regs)) {
 419                 printk(KERN_WARNING "ptrace: can't handle thumb mode\n");
 420                 return;
 421         }
 422
 423         res = read_instr(child, pc, &insn);
 424         if (!res) {
 425                 struct debug_info *dbg = &child->thread.debug;
 426                 unsigned long alt;
 427
 428                 dbg->nsaved = 0;
 429
 430                 alt = get_branch_address(child, pc, insn);
 431                 if (alt)
 432                         add_breakpoint(child, dbg, alt);
 433
 434                 /*
 435                  * Note that we ignore the result of setting the above
 436                  * breakpoint since it may fail.  When it does, this is
 437                  * not so much an error, but a forewarning that we may
 438                  * be receiving a prefetch abort shortly.
 439                  *
 440                  * If we don't set this breakpoint here, then we can
 441                  * lose control of the thread during single stepping.
 442                  */
 443                 if (!alt || predicate(insn) != PREDICATE_ALWAYS)
 444                         add_breakpoint(child, dbg, pc + 4);
 445         }
 446 }
 447
 448 /*
 449  * Ensure no single-step breakpoint is pending.  Returns non-zero
 450  * value if child was being single-stepped.
 451  */
 452 void ptrace_cancel_bpt(struct task_struct *child)
 453 {
 454         int i, nsaved = child->thread.debug.nsaved;
 455
 456         child->thread.debug.nsaved = 0;
 457
 458         if (nsaved > 2) {
 459                 printk("ptrace_cancel_bpt: bogus nsaved: %d!\n", nsaved);
 460                 nsaved = 2;
 461         }
 462
 463         for (i = 0; i < nsaved; i++)
 464                 clear_breakpoint(child, &child->thread.debug.bp[i]);
 465 }
 466
 467 /*
 468  * Called by kernel/ptrace.c when detaching..
 469  *
 470  * Make sure the single step bit is not set.
 471  */
 472 void ptrace_disable(struct task_struct *child)
 473 {
 474         child->ptrace &= ~PT_SINGLESTEP;
 475         ptrace_cancel_bpt(child);
 476 }
 477
 478 /*
 479  * Handle hitting a breakpoint.
 480  */
 481 void ptrace_break(struct task_struct *tsk, struct pt_regs *regs)
 482 {
 483         siginfo_t info;
 484
 485         ptrace_cancel_bpt(tsk);
 486
 487         info.si_signo = SIGTRAP;
 488         info.si_errno = 0;
 489         info.si_code  = TRAP_BRKPT;
 490         info.si_addr  = (void __user *)instruction_pointer(regs);
 491
 492         force_sig_info(SIGTRAP, &info, tsk);
 493 }
 494
 495 static int break_trap(struct pt_regs *regs, unsigned int instr)
 496 {
 497         ptrace_break(current, regs);
 498         return 0;
 499 }
 500
 501 static struct undef_hook arm_break_hook = {
 502         .instr_mask     = 0x0fffffff,
 503         .instr_val      = 0x07f001f0,
 504         .cpsr_mask      = PSR_T_BIT,
 505         .cpsr_val       = 0,
 506         .fn             = break_trap,
 507 };
 508
 509 static struct undef_hook thumb_break_hook = {
 510         .instr_mask     = 0xffff,
 511         .instr_val      = 0xde01,
 512         .cpsr_mask      = PSR_T_BIT,
 513         .cpsr_val       = PSR_T_BIT,
 514         .fn             = break_trap,
 515 };
 516
 517 static int __init ptrace_break_init(void)
 518 {
 519         register_undef_hook(&arm_break_hook);
 520         register_undef_hook(&thumb_break_hook);
 521         return 0;
 522 }
 523
 524 core_initcall(ptrace_break_init);
 525
 526 /*
 527  * Read the word at offset "off" into the "struct user".  We
 528  * actually access the pt_regs stored on the kernel stack.
 529  */
 530 static int ptrace_read_user(struct task_struct *tsk, unsigned long off,
 531                             unsigned long __user *ret)
 532 {
 533         unsigned long tmp;
 534
 535         if (off & 3 || off >= sizeof(struct user))
 536                 return -EIO;
 537
 538         tmp = 0;
 539         if (off < sizeof(struct pt_regs))
 540                 tmp = get_user_reg(tsk, off >> 2);
 541
 542         return put_user(tmp, ret);
 543 }
 544
 545 /*
 546  * Write the word at offset "off" into "struct user".  We
 547  * actually access the pt_regs stored on the kernel stack.
 548  */
 549 static int ptrace_write_user(struct task_struct *tsk, unsigned long off,
 550                              unsigned long val)
 551 {
 552         if (off & 3 || off >= sizeof(struct user))
 553                 return -EIO;
 554
 555         if (off >= sizeof(struct pt_regs))
 556                 return 0;
 557
 558         return put_user_reg(tsk, off >> 2, val);
 559 }
 560
 561 /*
 562  * Get all user integer registers.
 563  */
 564 static int ptrace_getregs(struct task_struct *tsk, void __user *uregs)
 565 {
 566         struct pt_regs *regs = get_user_regs(tsk);
 567
 568         return copy_to_user(uregs, regs, sizeof(struct pt_regs)) ? -EFAULT : 0;
 569 }
 570
 571 /*
 572  * Set all user integer registers.
 573  */
 574 static int ptrace_setregs(struct task_struct *tsk, void __user *uregs)
 575 {
 576         struct pt_regs newregs;
 577         int ret;
 578
 579         ret = -EFAULT;
 580         if (copy_from_user(&newregs, uregs, sizeof(struct pt_regs)) == 0) {
 581                 struct pt_regs *regs = get_user_regs(tsk);
 582
 583                 ret = -EINVAL;
 584                 if (valid_user_regs(&newregs)) {
 585                         *regs = newregs;
 586                         ret = 0;
 587                 }
 588         }
 589
 590         return ret;
 591 }
 592
 593 /*
 594  * Get the child FPU state.
 595  */
 596 static int ptrace_getfpregs(struct task_struct *tsk, void __user *ufp)
 597 {
 598         return copy_to_user(ufp, &tsk->thread_info->fpstate,
 599                             sizeof(struct user_fp)) ? -EFAULT : 0;
 600 }
 601
 602 /*
 603  * Set the child FPU state.
 604  */
 605 static int ptrace_setfpregs(struct task_struct *tsk, void __user *ufp)
 606 {
 607         struct thread_info *thread = tsk->thread_info;
 608         thread->used_cp[1] = thread->used_cp[2] = 1;
 609         return copy_from_user(&thread->fpstate, ufp,
 610                               sizeof(struct user_fp)) ? -EFAULT : 0;
 611 }
 612
 613 #ifdef CONFIG_IWMMXT
 614
 615 /*
 616  * Get the child iWMMXt state.
 617  */
 618 static int ptrace_getwmmxregs(struct task_struct *tsk, void __user *ufp)
 619 {
 620         struct thread_info *thread = tsk->thread_info;
 621         void *ptr = &thread->fpstate;
 622
 623         if (!test_ti_thread_flag(thread, TIF_USING_IWMMXT))
 624                 return -ENODATA;
 625         iwmmxt_task_disable(thread);  /* force it to ram */
 626         /* The iWMMXt state is stored doubleword-aligned.  */
 627         if (((long) ptr) & 4)
 628                 ptr += 4;
 629         return copy_to_user(ufp, ptr, 0x98) ? -EFAULT : 0;
 630 }
 631
 632 /*
 633  * Set the child iWMMXt state.
 634  */
 635 static int ptrace_setwmmxregs(struct task_struct *tsk, void __user *ufp)
 636 {
 637         struct thread_info *thread = tsk->thread_info;
 638         void *ptr = &thread->fpstate;
 639
 640         if (!test_ti_thread_flag(thread, TIF_USING_IWMMXT))
 641                 return -EACCES;
 642         iwmmxt_task_release(thread);  /* force a reload */
 643         /* The iWMMXt state is stored doubleword-aligned.  */
 644         if (((long) ptr) & 4)
 645                 ptr += 4;
 646         return copy_from_user(ptr, ufp, 0x98) ? -EFAULT : 0;
 647 }
 648
 649 #endif
 650
 651 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 652 {
 653         unsigned long tmp;
 654         int ret;
 655
 656         switch (request) {
 657                 /*
 658                  * read word at location "addr" in the child process.
 659                  */
 660                 case PTRACE_PEEKTEXT:
 661                 case PTRACE_PEEKDATA:
 662                         ret = access_process_vm(child, addr, &tmp,
 663                                                 sizeof(unsigned long), 0);
 664                         if (ret == sizeof(unsigned long))
 665                                 ret = put_user(tmp, (unsigned long __user *) data);
 666                         else
 667                                 ret = -EIO;
 668                         break;
 669
 670                 case PTRACE_PEEKUSR:
 671                         ret = ptrace_read_user(child, addr, (unsigned long __user *)data);
 672                         break;
 673
 674                 /*
 675                  * write the word at location addr.
 676                  */
 677                 case PTRACE_POKETEXT:
 678                 case PTRACE_POKEDATA:
 679                         ret = access_process_vm(child, addr, &data,
 680                                                 sizeof(unsigned long), 1);
 681                         if (ret == sizeof(unsigned long))
 682                                 ret = 0;
 683                         else
 684                                 ret = -EIO;
 685                         break;
 686
 687                 case PTRACE_POKEUSR:
 688                         ret = ptrace_write_user(child, addr, data);
 689                         break;
 690
 691                 /*
 692                  * continue/restart and stop at next (return from) syscall
 693                  */
 694                 case PTRACE_SYSCALL:
 695                 case PTRACE_CONT:
 696                         ret = -EIO;
 697                         if (!valid_signal(data))
 698                                 break;
 699                         if (request == PTRACE_SYSCALL)
 700                                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 701                         else
 702                                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 703                         child->exit_code = data;
 704                         /* make sure single-step breakpoint is gone. */
 705                         child->ptrace &= ~PT_SINGLESTEP;
 706                         ptrace_cancel_bpt(child);
 707                         wake_up_process(child);
 708                         ret = 0;
 709                         break;
 710
 711                 /*
 712                  * make the child exit.  Best I can do is send it a sigkill.
 713                  * perhaps it should be put in the status that it wants to
 714                  * exit.
 715                  */
 716                 case PTRACE_KILL:
 717                         /* make sure single-step breakpoint is gone. */
 718                         child->ptrace &= ~PT_SINGLESTEP;
 719                         ptrace_cancel_bpt(child);
 720                         if (child->exit_state != EXIT_ZOMBIE) {
 721                                 child->exit_code = SIGKILL;
 722                                 wake_up_process(child);
 723                         }
 724                         ret = 0;
 725                         break;
 726
 727                 /*
 728                  * execute single instruction.
 729                  */
 730                 case PTRACE_SINGLESTEP:
 731                         ret = -EIO;
 732                         if (!valid_signal(data))
 733                                 break;
 734                         child->ptrace |= PT_SINGLESTEP;
 735                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 736                         child->exit_code = data;
 737                         /* give it a chance to run. */
 738                         wake_up_process(child);
 739                         ret = 0;
 740                         break;
 741
 742                 case PTRACE_DETACH:
 743                         ret = ptrace_detach(child, data);
 744                         break;
 745
 746                 case PTRACE_GETREGS:
 747                         ret = ptrace_getregs(child, (void __user *)data);
 748                         break;
 749
 750                 case PTRACE_SETREGS:
 751                         ret = ptrace_setregs(child, (void __user *)data);
 752                         break;
 753
 754                 case PTRACE_GETFPREGS:
 755                         ret = ptrace_getfpregs(child, (void __user *)data);
 756                         break;
 757
 758                 case PTRACE_SETFPREGS:
 759                         ret = ptrace_setfpregs(child, (void __user *)data);
 760                         break;
 761
 762 #ifdef CONFIG_IWMMXT
 763                 case PTRACE_GETWMMXREGS:
 764                         ret = ptrace_getwmmxregs(child, (void __user *)data);
 765                         break;
 766
 767                 case PTRACE_SETWMMXREGS:
 768                         ret = ptrace_setwmmxregs(child, (void __user *)data);
 769                         break;
 770 #endif
 771
 772                 case PTRACE_GET_THREAD_AREA:
 773                         ret = put_user(child->thread_info->tp_value,
 774                                        (unsigned long __user *) data);
 775                         break;
 776
 777                 default:
 778                         ret = ptrace_request(child, request, addr, data);
 779                         break;
 780         }
 781
 782         return ret;
 783 }
 784
 785 asmlinkage void syscall_trace(int why, struct pt_regs *regs)
 786 {
 787         unsigned long ip;
 788
 789         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 790                 return;
 791         if (!(current->ptrace & PT_PTRACED))
 792                 return;
 793
 794         /*
 795          * Save IP.  IP is used to denote syscall entry/exit:
 796          *  IP = 0 -> entry, = 1 -> exit
 797          */
 798         ip = regs->ARM_ip;
 799         regs->ARM_ip = why;
 800
 801         /* the 0x80 provides a way for the tracing parent to distinguish
 802            between a syscall stop and SIGTRAP delivery */
 803         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
 804                                  ? 0x80 : 0));
 805         /*
 806          * this isn't the same as continuing with a signal, but it will do
 807          * for normal use.  strace only continues with a signal if the
 808          * stopping signal is not SIGTRAP.  -brl
 809          */
 810         if (current->exit_code) {
 811                 send_sig(current->exit_code, current, 1);
 812                 current->exit_code = 0;
 813         }
 814         regs->ARM_ip = ip;
 815 }