arch/m32r/kernel/ptrace.c

   1 /*
   2  * linux/arch/m32r/kernel/ptrace.c
   3  *
   4  * Copyright (C) 2002  Hirokazu Takata, Takeo Takahashi
   5  * Copyright (C) 2004  Hirokazu Takata, Kei Sakamoto
   6  *
   7  * Original x86 implementation:
   8  *      By Ross Biro 1/23/92
   9  *      edited by Linus Torvalds
  10  *
  11  * Some code taken from sh version:
  12  *   Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
  13  * Some code taken from arm version:
  14  *   Copyright (C) 2000 Russell King
  15  */
  16
  17 #include <linux/config.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sched.h>
  20 #include <linux/mm.h>
  21 #include <linux/smp.h>
  22 #include <linux/smp_lock.h>
  23 #include <linux/errno.h>
  24 #include <linux/ptrace.h>
  25 #include <linux/user.h>
  26 #include <linux/string.h>
  27 #include <linux/signal.h>
  28
  29 #include <asm/cacheflush.h>
  30 #include <asm/io.h>
  31 #include <asm/uaccess.h>
  32 #include <asm/pgtable.h>
  33 #include <asm/system.h>
  34 #include <asm/processor.h>
  35 #include <asm/mmu_context.h>
  36
  37 /*
  38  * Get the address of the live pt_regs for the specified task.
  39  * These are saved onto the top kernel stack when the process
  40  * is not running.
  41  *
  42  * Note: if a user thread is execve'd from kernel space, the
  43  * kernel stack will not be empty on entry to the kernel, so
  44  * ptracing these tasks will fail.
  45  */
  46 static inline struct pt_regs *
  47 get_user_regs(struct task_struct *task)
  48 {
  49         return (struct pt_regs *)
  50                 ((unsigned long)task->thread_info + THREAD_SIZE
  51                  - sizeof(struct pt_regs));
  52 }
  53
  54 /*
  55  * This routine will get a word off of the process kernel stack.
  56  */
  57 static inline unsigned long int
  58 get_stack_long(struct task_struct *task, int offset)
  59 {
  60         unsigned long *stack;
  61
  62         stack = (unsigned long *)get_user_regs(task);
  63
  64         return stack[offset];
  65 }
  66
  67 /*
  68  * This routine will put a word on the process kernel stack.
  69  */
  70 static inline int
  71 put_stack_long(struct task_struct *task, int offset, unsigned long data)
  72 {
  73         unsigned long *stack;
  74
  75         stack = (unsigned long *)get_user_regs(task);
  76         stack[offset] = data;
  77
  78         return 0;
  79 }
  80
  81 static int reg_offset[] = {
  82         PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
  83         PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_FP, PT_LR, PT_SPU,
  84 };
  85
  86 /*
  87  * Read the word at offset "off" into the "struct user".  We
  88  * actually access the pt_regs stored on the kernel stack.
  89  */
  90 static int ptrace_read_user(struct task_struct *tsk, unsigned long off,
  91                             unsigned long __user *data)
  92 {
  93         unsigned long tmp;
  94 #ifndef NO_FPU
  95         struct user * dummy = NULL;
  96 #endif
  97
  98         if ((off & 3) || (off < 0) || (off > sizeof(struct user) - 3))
  99                 return -EIO;
 100
 101         off >>= 2;
 102         switch (off) {
 103         case PT_EVB:
 104                 __asm__ __volatile__ (
 105                         "mvfc   %0, cr5 \n\t"
 106                         : "=r" (tmp)
 107                 );
 108                 break;
 109         case PT_CBR: {
 110                         unsigned long psw;
 111                         psw = get_stack_long(tsk, PT_PSW);
 112                         tmp = ((psw >> 8) & 1);
 113                 }
 114                 break;
 115         case PT_PSW: {
 116                         unsigned long psw, bbpsw;
 117                         psw = get_stack_long(tsk, PT_PSW);
 118                         bbpsw = get_stack_long(tsk, PT_BBPSW);
 119                         tmp = ((psw >> 8) & 0xff) | ((bbpsw & 0xff) << 8);
 120                 }
 121                 break;
 122         case PT_PC:
 123                 tmp = get_stack_long(tsk, PT_BPC);
 124                 break;
 125         case PT_BPC:
 126                 off = PT_BBPC;
 127                 /* fall through */
 128         default:
 129                 if (off < (sizeof(struct pt_regs) >> 2))
 130                         tmp = get_stack_long(tsk, off);
 131 #ifndef NO_FPU
 132                 else if (off >= (long)(&dummy->fpu >> 2) &&
 133                          off < (long)(&dummy->u_fpvalid >> 2)) {
 134                         if (!tsk_used_math(tsk)) {
 135                                 if (off == (long)(&dummy->fpu.fpscr >> 2))
 136                                         tmp = FPSCR_INIT;
 137                                 else
 138                                         tmp = 0;
 139                         } else
 140                                 tmp = ((long *)(&tsk->thread.fpu >> 2))
 141                                         [off - (long)&dummy->fpu];
 142                 } else if (off == (long)(&dummy->u_fpvalid >> 2))
 143                         tmp = !!tsk_used_math(tsk);
 144 #endif /* not NO_FPU */
 145                 else
 146                         tmp = 0;
 147         }
 148
 149         return put_user(tmp, data);
 150 }
 151
 152 static int ptrace_write_user(struct task_struct *tsk, unsigned long off,
 153                              unsigned long data)
 154 {
 155         int ret = -EIO;
 156 #ifndef NO_FPU
 157         struct user * dummy = NULL;
 158 #endif
 159
 160         if ((off & 3) || off < 0 ||
 161             off > sizeof(struct user) - 3)
 162                 return -EIO;
 163
 164         off >>= 2;
 165         switch (off) {
 166         case PT_EVB:
 167         case PT_BPC:
 168         case PT_SPI:
 169                 /* We don't allow to modify evb. */
 170                 ret = 0;
 171                 break;
 172         case PT_PSW:
 173         case PT_CBR: {
 174                         /* We allow to modify only cbr in psw */
 175                         unsigned long psw;
 176                         psw = get_stack_long(tsk, PT_PSW);
 177                         psw = (psw & ~0x100) | ((data & 1) << 8);
 178                         ret = put_stack_long(tsk, PT_PSW, psw);
 179                 }
 180                 break;
 181         case PT_PC:
 182                 off = PT_BPC;
 183                 data &= ~1;
 184                 /* fall through */
 185         default:
 186                 if (off < (sizeof(struct pt_regs) >> 2))
 187                         ret = put_stack_long(tsk, off, data);
 188 #ifndef NO_FPU
 189                 else if (off >= (long)(&dummy->fpu >> 2) &&
 190                          off < (long)(&dummy->u_fpvalid >> 2)) {
 191                         set_stopped_child_used_math(tsk);
 192                         ((long *)&tsk->thread.fpu)
 193                                 [off - (long)&dummy->fpu] = data;
 194                         ret = 0;
 195                 } else if (off == (long)(&dummy->u_fpvalid >> 2)) {
 196                         conditional_stopped_child_used_math(data, tsk);
 197                         ret = 0;
 198                 }
 199 #endif /* not NO_FPU */
 200                 break;
 201         }
 202
 203         return ret;
 204 }
 205
 206 /*
 207  * Get all user integer registers.
 208  */
 209 static int ptrace_getregs(struct task_struct *tsk, void __user *uregs)
 210 {
 211         struct pt_regs *regs = get_user_regs(tsk);
 212
 213         return copy_to_user(uregs, regs, sizeof(struct pt_regs)) ? -EFAULT : 0;
 214 }
 215
 216 /*
 217  * Set all user integer registers.
 218  */
 219 static int ptrace_setregs(struct task_struct *tsk, void __user *uregs)
 220 {
 221         struct pt_regs newregs;
 222         int ret;
 223
 224         ret = -EFAULT;
 225         if (copy_from_user(&newregs, uregs, sizeof(struct pt_regs)) == 0) {
 226                 struct pt_regs *regs = get_user_regs(tsk);
 227                 *regs = newregs;
 228                 ret = 0;
 229         }
 230
 231         return ret;
 232 }
 233
 234
 235 static inline int
 236 check_condition_bit(struct task_struct *child)
 237 {
 238         return (int)((get_stack_long(child, PT_PSW) >> 8) & 1);
 239 }
 240
 241 static int
 242 check_condition_src(unsigned long op, unsigned long regno1,
 243                     unsigned long regno2, struct task_struct *child)
 244 {
 245         unsigned long reg1, reg2;
 246
 247         reg2 = get_stack_long(child, reg_offset[regno2]);
 248
 249         switch (op) {
 250         case 0x0: /* BEQ */
 251                 reg1 = get_stack_long(child, reg_offset[regno1]);
 252                 return reg1 == reg2;
 253         case 0x1: /* BNE */
 254                 reg1 = get_stack_long(child, reg_offset[regno1]);
 255                 return reg1 != reg2;
 256         case 0x8: /* BEQZ */
 257                 return reg2 == 0;
 258         case 0x9: /* BNEZ */
 259                 return reg2 != 0;
 260         case 0xa: /* BLTZ */
 261                 return (int)reg2 < 0;
 262         case 0xb: /* BGEZ */
 263                 return (int)reg2 >= 0;
 264         case 0xc: /* BLEZ */
 265                 return (int)reg2 <= 0;
 266         case 0xd: /* BGTZ */
 267                 return (int)reg2 > 0;
 268         default:
 269                 /* never reached */
 270                 return 0;
 271         }
 272 }
 273
 274 static void
 275 compute_next_pc_for_16bit_insn(unsigned long insn, unsigned long pc,
 276                                unsigned long *next_pc,
 277                                struct task_struct *child)
 278 {
 279         unsigned long op, op2, op3;
 280         unsigned long disp;
 281         unsigned long regno;
 282         int parallel = 0;
 283
 284         if (insn & 0x00008000)
 285                 parallel = 1;
 286         if (pc & 3)
 287                 insn &= 0x7fff; /* right slot */
 288         else
 289                 insn >>= 16;    /* left slot */
 290
 291         op = (insn >> 12) & 0xf;
 292         op2 = (insn >> 8) & 0xf;
 293         op3 = (insn >> 4) & 0xf;
 294
 295         if (op == 0x7) {
 296                 switch (op2) {
 297                 case 0xd: /* BNC */
 298                 case 0x9: /* BNCL */
 299                         if (!check_condition_bit(child)) {
 300                                 disp = (long)(insn << 24) >> 22;
 301                                 *next_pc = (pc & ~0x3) + disp;
 302                                 return;
 303                         }
 304                         break;
 305                 case 0x8: /* BCL */
 306                 case 0xc: /* BC */
 307                         if (check_condition_bit(child)) {
 308                                 disp = (long)(insn << 24) >> 22;
 309                                 *next_pc = (pc & ~0x3) + disp;
 310                                 return;
 311                         }
 312                         break;
 313                 case 0xe: /* BL */
 314                 case 0xf: /* BRA */
 315                         disp = (long)(insn << 24) >> 22;
 316                         *next_pc = (pc & ~0x3) + disp;
 317                         return;
 318                         break;
 319                 }
 320         } else if (op == 0x1) {
 321                 switch (op2) {
 322                 case 0x0:
 323                         if (op3 == 0xf) { /* TRAP */
 324 #if 1
 325                                 /* pass through */
 326 #else
 327                                 /* kernel space is not allowed as next_pc */
 328                                 unsigned long evb;
 329                                 unsigned long trapno;
 330                                 trapno = insn & 0xf;
 331                                 __asm__ __volatile__ (
 332                                         "mvfc %0, cr5\n"
 333                                         :"=r"(evb)
 334                                         :
 335                                 );
 336                                 *next_pc = evb + (trapno << 2);
 337                                 return;
 338 #endif
 339                         } else if (op3 == 0xd) { /* RTE */
 340                                 *next_pc = get_stack_long(child, PT_BPC);
 341                                 return;
 342                         }
 343                         break;
 344                 case 0xc: /* JC */
 345                         if (op3 == 0xc && check_condition_bit(child)) {
 346                                 regno = insn & 0xf;
 347                                 *next_pc = get_stack_long(child,
 348                                                           reg_offset[regno]);
 349                                 return;
 350                         }
 351                         break;
 352                 case 0xd: /* JNC */
 353                         if (op3 == 0xc && !check_condition_bit(child)) {
 354                                 regno = insn & 0xf;
 355                                 *next_pc = get_stack_long(child,
 356                                                           reg_offset[regno]);
 357                                 return;
 358                         }
 359                         break;
 360                 case 0xe: /* JL */
 361                 case 0xf: /* JMP */
 362                         if (op3 == 0xc) { /* JMP */
 363                                 regno = insn & 0xf;
 364                                 *next_pc = get_stack_long(child,
 365                                                           reg_offset[regno]);
 366                                 return;
 367                         }
 368                         break;
 369                 }
 370         }
 371         if (parallel)
 372                 *next_pc = pc + 4;
 373         else
 374                 *next_pc = pc + 2;
 375 }
 376
 377 static void
 378 compute_next_pc_for_32bit_insn(unsigned long insn, unsigned long pc,
 379                                unsigned long *next_pc,
 380                                struct task_struct *child)
 381 {
 382         unsigned long op;
 383         unsigned long op2;
 384         unsigned long disp;
 385         unsigned long regno1, regno2;
 386
 387         op = (insn >> 28) & 0xf;
 388         if (op == 0xf) {        /* branch 24-bit relative */
 389                 op2 = (insn >> 24) & 0xf;
 390                 switch (op2) {
 391                 case 0xd:       /* BNC */
 392                 case 0x9:       /* BNCL */
 393                         if (!check_condition_bit(child)) {
 394                                 disp = (long)(insn << 8) >> 6;
 395                                 *next_pc = (pc & ~0x3) + disp;
 396                                 return;
 397                         }
 398                         break;
 399                 case 0x8:       /* BCL */
 400                 case 0xc:       /* BC */
 401                         if (check_condition_bit(child)) {
 402                                 disp = (long)(insn << 8) >> 6;
 403                                 *next_pc = (pc & ~0x3) + disp;
 404                                 return;
 405                         }
 406                         break;
 407                 case 0xe:       /* BL */
 408                 case 0xf:       /* BRA */
 409                         disp = (long)(insn << 8) >> 6;
 410                         *next_pc = (pc & ~0x3) + disp;
 411                         return;
 412                 }
 413         } else if (op == 0xb) { /* branch 16-bit relative */
 414                 op2 = (insn >> 20) & 0xf;
 415                 switch (op2) {
 416                 case 0x0: /* BEQ */
 417                 case 0x1: /* BNE */
 418                 case 0x8: /* BEQZ */
 419                 case 0x9: /* BNEZ */
 420                 case 0xa: /* BLTZ */
 421                 case 0xb: /* BGEZ */
 422                 case 0xc: /* BLEZ */
 423                 case 0xd: /* BGTZ */
 424                         regno1 = ((insn >> 24) & 0xf);
 425                         regno2 = ((insn >> 16) & 0xf);
 426                         if (check_condition_src(op2, regno1, regno2, child)) {
 427                                 disp = (long)(insn << 16) >> 14;
 428                                 *next_pc = (pc & ~0x3) + disp;
 429                                 return;
 430                         }
 431                         break;
 432                 }
 433         }
 434         *next_pc = pc + 4;
 435 }
 436
 437 static inline void
 438 compute_next_pc(unsigned long insn, unsigned long pc,
 439                 unsigned long *next_pc, struct task_struct *child)
 440 {
 441         if (insn & 0x80000000)
 442                 compute_next_pc_for_32bit_insn(insn, pc, next_pc, child);
 443         else
 444                 compute_next_pc_for_16bit_insn(insn, pc, next_pc, child);
 445 }
 446
 447 static int
 448 register_debug_trap(struct task_struct *child, unsigned long next_pc,
 449         unsigned long next_insn, unsigned long *code)
 450 {
 451         struct debug_trap *p = &child->thread.debug_trap;
 452         unsigned long addr = next_pc & ~3;
 453
 454         if (p->nr_trap == MAX_TRAPS) {
 455                 printk("kernel BUG at %s %d: p->nr_trap = %d\n",
 456                                         __FILE__, __LINE__, p->nr_trap);
 457                 return -1;
 458         }
 459         p->addr[p->nr_trap] = addr;
 460         p->insn[p->nr_trap] = next_insn;
 461         p->nr_trap++;
 462         if (next_pc & 3) {
 463                 *code = (next_insn & 0xffff0000) | 0x10f1;
 464                 /* xxx --> TRAP1 */
 465         } else {
 466                 if ((next_insn & 0x80000000) || (next_insn & 0x8000)) {
 467                         *code = 0x10f17000;
 468                         /* TRAP1 --> NOP */
 469                 } else {
 470                         *code = (next_insn & 0xffff) | 0x10f10000;
 471                         /* TRAP1 --> xxx */
 472                 }
 473         }
 474         return 0;
 475 }
 476
 477 static int
 478 unregister_debug_trap(struct task_struct *child, unsigned long addr,
 479                       unsigned long *code)
 480 {
 481         struct debug_trap *p = &child->thread.debug_trap;
 482         int i;
 483
 484         /* Search debug trap entry. */
 485         for (i = 0; i < p->nr_trap; i++) {
 486                 if (p->addr[i] == addr)
 487                         break;
 488         }
 489         if (i >= p->nr_trap) {
 490                 /* The trap may be requested from debugger.
 491                  * ptrace should do nothing in this case.
 492                  */
 493                 return 0;
 494         }
 495
 496         /* Recover orignal instruction code. */
 497         *code = p->insn[i];
 498
 499         /* Shift debug trap entries. */
 500         while (i < p->nr_trap - 1) {
 501                 p->insn[i] = p->insn[i + 1];
 502                 p->addr[i] = p->addr[i + 1];
 503                 i++;
 504         }
 505         p->nr_trap--;
 506         return 1;
 507 }
 508
 509 static void
 510 unregister_all_debug_traps(struct task_struct *child)
 511 {
 512         struct debug_trap *p = &child->thread.debug_trap;
 513         int i;
 514
 515         for (i = 0; i < p->nr_trap; i++)
 516                 access_process_vm(child, p->addr[i], &p->insn[i], sizeof(p->insn[i]), 1);
 517         p->nr_trap = 0;
 518 }
 519
 520 static inline void
 521 invalidate_cache(void)
 522 {
 523 #if defined(CONFIG_CHIP_M32700) || defined(CONFIG_CHIP_OPSP)
 524
 525         _flush_cache_copyback_all();
 526
 527 #else   /* ! CONFIG_CHIP_M32700 */
 528
 529         /* Invalidate cache */
 530         __asm__ __volatile__ (
 531                 "ldi    r0, #-1                                 \n\t"
 532                 "ldi    r1, #0                                  \n\t"
 533                 "stb    r1, @r0         ; cache off             \n\t"
 534                 ";                                              \n\t"
 535                 "ldi    r0, #-2                                 \n\t"
 536                 "ldi    r1, #1                                  \n\t"
 537                 "stb    r1, @r0         ; cache invalidate      \n\t"
 538                 ".fillinsn                                      \n"
 539                 "0:                                             \n\t"
 540                 "ldb    r1, @r0         ; invalidate check      \n\t"
 541                 "bnez   r1, 0b                                  \n\t"
 542                 ";                                              \n\t"
 543                 "ldi    r0, #-1                                 \n\t"
 544                 "ldi    r1, #1                                  \n\t"
 545                 "stb    r1, @r0         ; cache on              \n\t"
 546                 : : : "r0", "r1", "memory"
 547         );
 548         /* FIXME: copying-back d-cache and invalidating i-cache are needed.
 549          */
 550 #endif  /* CONFIG_CHIP_M32700 */
 551 }
 552
 553 /* Embed a debug trap (TRAP1) code */
 554 static int
 555 embed_debug_trap(struct task_struct *child, unsigned long next_pc)
 556 {
 557         unsigned long next_insn, code;
 558         unsigned long addr = next_pc & ~3;
 559
 560         if (access_process_vm(child, addr, &next_insn, sizeof(next_insn), 0)
 561             != sizeof(next_insn)) {
 562                 return -1; /* error */
 563         }
 564
 565         /* Set a trap code. */
 566         if (register_debug_trap(child, next_pc, next_insn, &code)) {
 567                 return -1; /* error */
 568         }
 569         if (access_process_vm(child, addr, &code, sizeof(code), 1)
 570             != sizeof(code)) {
 571                 return -1; /* error */
 572         }
 573         return 0; /* success */
 574 }
 575
 576 void
 577 withdraw_debug_trap(struct pt_regs *regs)
 578 {
 579         unsigned long addr;
 580         unsigned long code;
 581
 582         addr = (regs->bpc - 2) & ~3;
 583         regs->bpc -= 2;
 584         if (unregister_debug_trap(current, addr, &code)) {
 585             access_process_vm(current, addr, &code, sizeof(code), 1);
 586             invalidate_cache();
 587         }
 588 }
 589
 590 static void
 591 init_debug_traps(struct task_struct *child)
 592 {
 593         struct debug_trap *p = &child->thread.debug_trap;
 594         int i;
 595         p->nr_trap = 0;
 596         for (i = 0; i < MAX_TRAPS; i++) {
 597                 p->addr[i] = 0;
 598                 p->insn[i] = 0;
 599         }
 600 }
 601
 602
 603 /*
 604  * Called by kernel/ptrace.c when detaching..
 605  *
 606  * Make sure single step bits etc are not set.
 607  */
 608 void ptrace_disable(struct task_struct *child)
 609 {
 610         /* nothing to do.. */
 611 }
 612
 613 static int
 614 do_ptrace(long request, struct task_struct *child, long addr, long data)
 615 {
 616         unsigned long tmp;
 617         int ret;
 618
 619         switch (request) {
 620         /*
 621          * read word at location "addr" in the child process.
 622          */
 623         case PTRACE_PEEKTEXT:
 624         case PTRACE_PEEKDATA:
 625                 ret = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
 626                 if (ret == sizeof(tmp))
 627                         ret = put_user(tmp,(unsigned long __user *) data);
 628                 else
 629                         ret = -EIO;
 630                 break;
 631
 632         /*
 633          * read the word at location addr in the USER area.
 634          */
 635         case PTRACE_PEEKUSR:
 636                 ret = ptrace_read_user(child, addr,
 637                                        (unsigned long __user *)data);
 638                 break;
 639
 640         /*
 641          * write the word at location addr.
 642          */
 643         case PTRACE_POKETEXT:
 644         case PTRACE_POKEDATA:
 645                 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
 646                 if (ret == sizeof(data)) {
 647                         ret = 0;
 648                         if (request == PTRACE_POKETEXT) {
 649                                 invalidate_cache();
 650                         }
 651                 } else {
 652                         ret = -EIO;
 653                 }
 654                 break;
 655
 656         /*
 657          * write the word at location addr in the USER area.
 658          */
 659         case PTRACE_POKEUSR:
 660                 ret = ptrace_write_user(child, addr, data);
 661                 break;
 662
 663         /*
 664          * continue/restart and stop at next (return from) syscall
 665          */
 666         case PTRACE_SYSCALL:
 667         case PTRACE_CONT:
 668                 ret = -EIO;
 669                 if (!valid_signal(data))
 670                         break;
 671                 if (request == PTRACE_SYSCALL)
 672                         set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 673                 else
 674                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 675                 child->exit_code = data;
 676                 wake_up_process(child);
 677                 ret = 0;
 678                 break;
 679
 680         /*
 681          * make the child exit.  Best I can do is send it a sigkill.
 682          * perhaps it should be put in the status that it wants to
 683          * exit.
 684          */
 685         case PTRACE_KILL: {
 686                 ret = 0;
 687                 unregister_all_debug_traps(child);
 688                 invalidate_cache();
 689                 if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
 690                         break;
 691                 child->exit_code = SIGKILL;
 692                 wake_up_process(child);
 693                 break;
 694         }
 695
 696         /*
 697          * execute single instruction.
 698          */
 699         case PTRACE_SINGLESTEP: {
 700                 unsigned long next_pc;
 701                 unsigned long pc, insn;
 702
 703                 ret = -EIO;
 704                 if (!valid_signal(data))
 705                         break;
 706                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 707                 if ((child->ptrace & PT_DTRACE) == 0) {
 708                         /* Spurious delayed TF traps may occur */
 709                         child->ptrace |= PT_DTRACE;
 710                 }
 711
 712                 /* Compute next pc.  */
 713                 pc = get_stack_long(child, PT_BPC);
 714
 715                 if (access_process_vm(child, pc&~3, &insn, sizeof(insn), 0)
 716                     != sizeof(insn))
 717                         break;
 718
 719                 compute_next_pc(insn, pc, &next_pc, child);
 720                 if (next_pc & 0x80000000)
 721                         break;
 722
 723                 if (embed_debug_trap(child, next_pc))
 724                         break;
 725
 726                 invalidate_cache();
 727                 child->exit_code = data;
 728
 729                 /* give it a chance to run. */
 730                 wake_up_process(child);
 731                 ret = 0;
 732                 break;
 733         }
 734
 735         /*
 736          * detach a process that was attached.
 737          */
 738         case PTRACE_DETACH:
 739                 ret = 0;
 740                 ret = ptrace_detach(child, data);
 741                 break;
 742
 743         case PTRACE_GETREGS:
 744                 ret = ptrace_getregs(child, (void __user *)data);
 745                 break;
 746
 747         case PTRACE_SETREGS:
 748                 ret = ptrace_setregs(child, (void __user *)data);
 749                 break;
 750
 751         default:
 752                 ret = ptrace_request(child, request, addr, data);
 753                 break;
 754         }
 755
 756         return ret;
 757 }
 758
 759 asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
 760 {
 761         struct task_struct *child;
 762         int ret;
 763
 764         lock_kernel();
 765         ret = -EPERM;
 766         if (request == PTRACE_TRACEME) {
 767                 /* are we already being traced? */
 768                 if (current->ptrace & PT_PTRACED)
 769                         goto out;
 770                 /* set the ptrace bit in the process flags. */
 771                 current->ptrace |= PT_PTRACED;
 772                 ret = 0;
 773                 goto out;
 774         }
 775         ret = -ESRCH;
 776         read_lock(&tasklist_lock);
 777         child = find_task_by_pid(pid);
 778         if (child)
 779                 get_task_struct(child);
 780         read_unlock(&tasklist_lock);
 781         if (!child)
 782                 goto out;
 783
 784         ret = -EPERM;
 785         if (pid == 1)           /* you may not mess with init */
 786                 goto out;
 787
 788         if (request == PTRACE_ATTACH) {
 789                 ret = ptrace_attach(child);
 790                 if (ret == 0)
 791                         init_debug_traps(child);
 792                 goto out_tsk;
 793         }
 794
 795         ret = ptrace_check_attach(child, request == PTRACE_KILL);
 796         if (ret == 0)
 797                 ret = do_ptrace(request, child, addr, data);
 798
 799 out_tsk:
 800         put_task_struct(child);
 801 out:
 802         unlock_kernel();
 803
 804         return ret;
 805 }
 806
 807 /* notification of system call entry/exit
 808  * - triggered by current->work.syscall_trace
 809  */
 810 void do_syscall_trace(void)
 811 {
 812         if (!test_thread_flag(TIF_SYSCALL_TRACE))
 813                 return;
 814         if (!(current->ptrace & PT_PTRACED))
 815                 return;
 816         /* the 0x80 provides a way for the tracing parent to distinguish
 817            between a syscall stop and SIGTRAP delivery */
 818         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
 819                                  ? 0x80 : 0));
 820
 821         /*
 822          * this isn't the same as continuing with a signal, but it will do
 823          * for normal use.  strace only continues with a signal if the
 824          * stopping signal is not SIGTRAP.  -brl
 825          */
 826         if (current->exit_code) {
 827                 send_sig(current->exit_code, current, 1);
 828                 current->exit_code = 0;
 829         }
 830 }