arch/powerpc/kernel/ftrace.c

   1 /*
   2  * Code for replacing ftrace calls with jumps.
   3  *
   4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
   5  *
   6  * Thanks goes out to P.A. Semi, Inc for supplying me with a PPC64 box.
   7  *
   8  * Added function graph tracer code, taken from x86 that was written
   9  * by Frederic Weisbecker, and ported to PPC by Steven Rostedt.
  10  *
  11  */
  12
  13 #include <linux/spinlock.h>
  14 #include <linux/hardirq.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/module.h>
  17 #include <linux/ftrace.h>
  18 #include <linux/percpu.h>
  19 #include <linux/init.h>
  20 #include <linux/list.h>
  21
  22 #include <asm/cacheflush.h>
  23 #include <asm/code-patching.h>
  24 #include <asm/ftrace.h>
  25 #include <asm/syscall.h>
  26
  27
  28 #ifdef CONFIG_DYNAMIC_FTRACE
  29 static unsigned int
  30 ftrace_call_replace(unsigned long ip, unsigned long addr, int link)
  31 {
  32         unsigned int op;
  33
  34         addr = ppc_function_entry((void *)addr);
  35
  36         /* if (link) set op to 'bl' else 'b' */
  37         op = create_branch((unsigned int *)ip, addr, link ? 1 : 0);
  38
  39         return op;
  40 }
  41
  42 static int
  43 ftrace_modify_code(unsigned long ip, unsigned int old, unsigned int new)
  44 {
  45         unsigned int replaced;
  46
  47         /*
  48          * Note: Due to modules and __init, code can
  49          *  disappear and change, we need to protect against faulting
  50          *  as well as code changing. We do this by using the
  51          *  probe_kernel_* functions.
  52          *
  53          * No real locking needed, this code is run through
  54          * kstop_machine, or before SMP starts.
  55          */
  56
  57         /* read the text we want to modify */
  58         if (probe_kernel_read(&replaced, (void *)ip, MCOUNT_INSN_SIZE))
  59                 return -EFAULT;
  60
  61         /* Make sure it is what we expect it to be */
  62         if (replaced != old)
  63                 return -EINVAL;
  64
  65         /* replace the text with the new text */
  66         if (patch_instruction((unsigned int *)ip, new))
  67                 return -EPERM;
  68
  69         return 0;
  70 }
  71
  72 /*
  73  * Helper functions that are the same for both PPC64 and PPC32.
  74  */
  75 static int test_24bit_addr(unsigned long ip, unsigned long addr)
  76 {
  77
  78         /* use the create_branch to verify that this offset can be branched */
  79         return create_branch((unsigned int *)ip, addr, 0);
  80 }
  81
  82 #ifdef CONFIG_MODULES
  83
  84 static int is_bl_op(unsigned int op)
  85 {
  86         return (op & 0xfc000003) == 0x48000001;
  87 }
  88
  89 static unsigned long find_bl_target(unsigned long ip, unsigned int op)
  90 {
  91         static int offset;
  92
  93         offset = (op & 0x03fffffc);
  94         /* make it signed */
  95         if (offset & 0x02000000)
  96                 offset |= 0xfe000000;
  97
  98         return ip + (long)offset;
  99 }
 100
 101 #ifdef CONFIG_PPC64
 102 static int
 103 __ftrace_make_nop(struct module *mod,
 104                   struct dyn_ftrace *rec, unsigned long addr)
 105 {
 106         unsigned int op;
 107         unsigned int jmp[5];
 108         unsigned long ptr;
 109         unsigned long ip = rec->ip;
 110         unsigned long tramp;
 111         int offset;
 112
 113         /* read where this goes */
 114         if (probe_kernel_read(&op, (void *)ip, sizeof(int)))
 115                 return -EFAULT;
 116
 117         /* Make sure that that this is still a 24bit jump */
 118         if (!is_bl_op(op)) {
 119                 printk(KERN_ERR "Not expected bl: opcode is %x\n", op);
 120                 return -EINVAL;
 121         }
 122
 123         /* lets find where the pointer goes */
 124         tramp = find_bl_target(ip, op);
 125
 126         /*
 127          * On PPC64 the trampoline looks like:
 128          * 0x3d, 0x82, 0x00, 0x00,    addis   r12,r2, <high>
 129          * 0x39, 0x8c, 0x00, 0x00,    addi    r12,r12, <low>
 130          *   Where the bytes 2,3,6 and 7 make up the 32bit offset
 131          *   to the TOC that holds the pointer.
 132          *   to jump to.
 133          * 0xf8, 0x41, 0x00, 0x28,    std     r2,40(r1)
 134          * 0xe9, 0x6c, 0x00, 0x20,    ld      r11,32(r12)
 135          *   The actually address is 32 bytes from the offset
 136          *   into the TOC.
 137          * 0xe8, 0x4c, 0x00, 0x28,    ld      r2,40(r12)
 138          */
 139
 140         pr_devel("ip:%lx jumps to %lx r2: %lx", ip, tramp, mod->arch.toc);
 141
 142         /* Find where the trampoline jumps to */
 143         if (probe_kernel_read(jmp, (void *)tramp, sizeof(jmp))) {
 144                 printk(KERN_ERR "Failed to read %lx\n", tramp);
 145                 return -EFAULT;
 146         }
 147
 148         pr_devel(" %08x %08x", jmp[0], jmp[1]);
 149
 150         /* verify that this is what we expect it to be */
 151         if (((jmp[0] & 0xffff0000) != 0x3d820000) ||
 152             ((jmp[1] & 0xffff0000) != 0x398c0000) ||
 153             (jmp[2] != 0xf8410028) ||
 154             (jmp[3] != 0xe96c0020) ||
 155             (jmp[4] != 0xe84c0028)) {
 156                 printk(KERN_ERR "Not a trampoline\n");
 157                 return -EINVAL;
 158         }
 159
 160         /* The bottom half is signed extended */
 161         offset = ((unsigned)((unsigned short)jmp[0]) << 16) +
 162                 (int)((short)jmp[1]);
 163
 164         pr_devel(" %x ", offset);
 165
 166         /* get the address this jumps too */
 167         tramp = mod->arch.toc + offset + 32;
 168         pr_devel("toc: %lx", tramp);
 169
 170         if (probe_kernel_read(jmp, (void *)tramp, 8)) {
 171                 printk(KERN_ERR "Failed to read %lx\n", tramp);
 172                 return -EFAULT;
 173         }
 174
 175         pr_devel(" %08x %08x\n", jmp[0], jmp[1]);
 176
 177 #ifdef __LITTLE_ENDIAN__
 178         ptr = ((unsigned long)jmp[1] << 32) + jmp[0];
 179 #else
 180         ptr = ((unsigned long)jmp[0] << 32) + jmp[1];
 181 #endif
 182
 183         /* This should match what was called */
 184         if (ptr != ppc_function_entry((void *)addr)) {
 185                 printk(KERN_ERR "addr does not match %lx\n", ptr);
 186                 return -EINVAL;
 187         }
 188
 189         /*
 190          * We want to nop the line, but the next line is
 191          *  0xe8, 0x41, 0x00, 0x28   ld r2,40(r1)
 192          * This needs to be turned to a nop too.
 193          */
 194         if (probe_kernel_read(&op, (void *)(ip+4), MCOUNT_INSN_SIZE))
 195                 return -EFAULT;
 196
 197         if (op != 0xe8410028) {
 198                 printk(KERN_ERR "Next line is not ld! (%08x)\n", op);
 199                 return -EINVAL;
 200         }
 201
 202         /*
 203          * Milton Miller pointed out that we can not blindly do nops.
 204          * If a task was preempted when calling a trace function,
 205          * the nops will remove the way to restore the TOC in r2
 206          * and the r2 TOC will get corrupted.
 207          */
 208
 209         /*
 210          * Replace:
 211          *   bl <tramp>  <==== will be replaced with "b 1f"
 212          *   ld r2,40(r1)
 213          *  1:
 214          */
 215         op = 0x48000008;        /* b +8 */
 216
 217         if (patch_instruction((unsigned int *)ip, op))
 218                 return -EPERM;
 219
 220         return 0;
 221 }
 222
 223 #else /* !PPC64 */
 224 static int
 225 __ftrace_make_nop(struct module *mod,
 226                   struct dyn_ftrace *rec, unsigned long addr)
 227 {
 228         unsigned int op;
 229         unsigned int jmp[4];
 230         unsigned long ip = rec->ip;
 231         unsigned long tramp;
 232
 233         if (probe_kernel_read(&op, (void *)ip, MCOUNT_INSN_SIZE))
 234                 return -EFAULT;
 235
 236         /* Make sure that that this is still a 24bit jump */
 237         if (!is_bl_op(op)) {
 238                 printk(KERN_ERR "Not expected bl: opcode is %x\n", op);
 239                 return -EINVAL;
 240         }
 241
 242         /* lets find where the pointer goes */
 243         tramp = find_bl_target(ip, op);
 244
 245         /*
 246          * On PPC32 the trampoline looks like:
 247          *  0x3d, 0x80, 0x00, 0x00  lis r12,sym@ha
 248          *  0x39, 0x8c, 0x00, 0x00  addi r12,r12,sym@l
 249          *  0x7d, 0x89, 0x03, 0xa6  mtctr r12
 250          *  0x4e, 0x80, 0x04, 0x20  bctr
 251          */
 252
 253         pr_devel("ip:%lx jumps to %lx", ip, tramp);
 254
 255         /* Find where the trampoline jumps to */
 256         if (probe_kernel_read(jmp, (void *)tramp, sizeof(jmp))) {
 257                 printk(KERN_ERR "Failed to read %lx\n", tramp);
 258                 return -EFAULT;
 259         }
 260
 261         pr_devel(" %08x %08x ", jmp[0], jmp[1]);
 262
 263         /* verify that this is what we expect it to be */
 264         if (((jmp[0] & 0xffff0000) != 0x3d800000) ||
 265             ((jmp[1] & 0xffff0000) != 0x398c0000) ||
 266             (jmp[2] != 0x7d8903a6) ||
 267             (jmp[3] != 0x4e800420)) {
 268                 printk(KERN_ERR "Not a trampoline\n");
 269                 return -EINVAL;
 270         }
 271
 272         tramp = (jmp[1] & 0xffff) |
 273                 ((jmp[0] & 0xffff) << 16);
 274         if (tramp & 0x8000)
 275                 tramp -= 0x10000;
 276
 277         pr_devel(" %lx ", tramp);
 278
 279         if (tramp != addr) {
 280                 printk(KERN_ERR
 281                        "Trampoline location %08lx does not match addr\n",
 282                        tramp);
 283                 return -EINVAL;
 284         }
 285
 286         op = PPC_INST_NOP;
 287
 288         if (patch_instruction((unsigned int *)ip, op))
 289                 return -EPERM;
 290
 291         return 0;
 292 }
 293 #endif /* PPC64 */
 294 #endif /* CONFIG_MODULES */
 295
 296 int ftrace_make_nop(struct module *mod,
 297                     struct dyn_ftrace *rec, unsigned long addr)
 298 {
 299         unsigned long ip = rec->ip;
 300         unsigned int old, new;
 301
 302         /*
 303          * If the calling address is more that 24 bits away,
 304          * then we had to use a trampoline to make the call.
 305          * Otherwise just update the call site.
 306          */
 307         if (test_24bit_addr(ip, addr)) {
 308                 /* within range */
 309                 old = ftrace_call_replace(ip, addr, 1);
 310                 new = PPC_INST_NOP;
 311                 return ftrace_modify_code(ip, old, new);
 312         }
 313
 314 #ifdef CONFIG_MODULES
 315         /*
 316          * Out of range jumps are called from modules.
 317          * We should either already have a pointer to the module
 318          * or it has been passed in.
 319          */
 320         if (!rec->arch.mod) {
 321                 if (!mod) {
 322                         printk(KERN_ERR "No module loaded addr=%lx\n",
 323                                addr);
 324                         return -EFAULT;
 325                 }
 326                 rec->arch.mod = mod;
 327         } else if (mod) {
 328                 if (mod != rec->arch.mod) {
 329                         printk(KERN_ERR
 330                                "Record mod %p not equal to passed in mod %p\n",
 331                                rec->arch.mod, mod);
 332                         return -EINVAL;
 333                 }
 334                 /* nothing to do if mod == rec->arch.mod */
 335         } else
 336                 mod = rec->arch.mod;
 337
 338         return __ftrace_make_nop(mod, rec, addr);
 339 #else
 340         /* We should not get here without modules */
 341         return -EINVAL;
 342 #endif /* CONFIG_MODULES */
 343 }
 344
 345 #ifdef CONFIG_MODULES
 346 #ifdef CONFIG_PPC64
 347 static int
 348 __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 349 {
 350         unsigned int op[2];
 351         unsigned long ip = rec->ip;
 352
 353         /* read where this goes */
 354         if (probe_kernel_read(op, (void *)ip, MCOUNT_INSN_SIZE * 2))
 355                 return -EFAULT;
 356
 357         /*
 358          * It should be pointing to two nops or
 359          *  b +8; ld r2,40(r1)
 360          */
 361         if (((op[0] != 0x48000008) || (op[1] != 0xe8410028)) &&
 362             ((op[0] != PPC_INST_NOP) || (op[1] != PPC_INST_NOP))) {
 363                 printk(KERN_ERR "Expected NOPs but have %x %x\n", op[0], op[1]);
 364                 return -EINVAL;
 365         }
 366
 367         /* If we never set up a trampoline to ftrace_caller, then bail */
 368         if (!rec->arch.mod->arch.tramp) {
 369                 printk(KERN_ERR "No ftrace trampoline\n");
 370                 return -EINVAL;
 371         }
 372
 373         /* create the branch to the trampoline */
 374         op[0] = create_branch((unsigned int *)ip,
 375                               rec->arch.mod->arch.tramp, BRANCH_SET_LINK);
 376         if (!op[0]) {
 377                 printk(KERN_ERR "REL24 out of range!\n");
 378                 return -EINVAL;
 379         }
 380
 381         /* ld r2,40(r1) */
 382         op[1] = 0xe8410028;
 383
 384         pr_devel("write to %lx\n", rec->ip);
 385
 386         if (probe_kernel_write((void *)ip, op, MCOUNT_INSN_SIZE * 2))
 387                 return -EPERM;
 388
 389         flush_icache_range(ip, ip + 8);
 390
 391         return 0;
 392 }
 393 #else
 394 static int
 395 __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 396 {
 397         unsigned int op;
 398         unsigned long ip = rec->ip;
 399
 400         /* read where this goes */
 401         if (probe_kernel_read(&op, (void *)ip, MCOUNT_INSN_SIZE))
 402                 return -EFAULT;
 403
 404         /* It should be pointing to a nop */
 405         if (op != PPC_INST_NOP) {
 406                 printk(KERN_ERR "Expected NOP but have %x\n", op);
 407                 return -EINVAL;
 408         }
 409
 410         /* If we never set up a trampoline to ftrace_caller, then bail */
 411         if (!rec->arch.mod->arch.tramp) {
 412                 printk(KERN_ERR "No ftrace trampoline\n");
 413                 return -EINVAL;
 414         }
 415
 416         /* create the branch to the trampoline */
 417         op = create_branch((unsigned int *)ip,
 418                            rec->arch.mod->arch.tramp, BRANCH_SET_LINK);
 419         if (!op) {
 420                 printk(KERN_ERR "REL24 out of range!\n");
 421                 return -EINVAL;
 422         }
 423
 424         pr_devel("write to %lx\n", rec->ip);
 425
 426         if (patch_instruction((unsigned int *)ip, op))
 427                 return -EPERM;
 428
 429         return 0;
 430 }
 431 #endif /* CONFIG_PPC64 */
 432 #endif /* CONFIG_MODULES */
 433
 434 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 435 {
 436         unsigned long ip = rec->ip;
 437         unsigned int old, new;
 438
 439         /*
 440          * If the calling address is more that 24 bits away,
 441          * then we had to use a trampoline to make the call.
 442          * Otherwise just update the call site.
 443          */
 444         if (test_24bit_addr(ip, addr)) {
 445                 /* within range */
 446                 old = PPC_INST_NOP;
 447                 new = ftrace_call_replace(ip, addr, 1);
 448                 return ftrace_modify_code(ip, old, new);
 449         }
 450
 451 #ifdef CONFIG_MODULES
 452         /*
 453          * Out of range jumps are called from modules.
 454          * Being that we are converting from nop, it had better
 455          * already have a module defined.
 456          */
 457         if (!rec->arch.mod) {
 458                 printk(KERN_ERR "No module loaded\n");
 459                 return -EINVAL;
 460         }
 461
 462         return __ftrace_make_call(rec, addr);
 463 #else
 464         /* We should not get here without modules */
 465         return -EINVAL;
 466 #endif /* CONFIG_MODULES */
 467 }
 468
 469 int ftrace_update_ftrace_func(ftrace_func_t func)
 470 {
 471         unsigned long ip = (unsigned long)(&ftrace_call);
 472         unsigned int old, new;
 473         int ret;
 474
 475         old = *(unsigned int *)&ftrace_call;
 476         new = ftrace_call_replace(ip, (unsigned long)func, 1);
 477         ret = ftrace_modify_code(ip, old, new);
 478
 479         return ret;
 480 }
 481
 482 static int __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 483 {
 484         unsigned long ftrace_addr = (unsigned long)FTRACE_ADDR;
 485         int ret;
 486
 487         ret = ftrace_update_record(rec, enable);
 488
 489         switch (ret) {
 490         case FTRACE_UPDATE_IGNORE:
 491                 return 0;
 492         case FTRACE_UPDATE_MAKE_CALL:
 493                 return ftrace_make_call(rec, ftrace_addr);
 494         case FTRACE_UPDATE_MAKE_NOP:
 495                 return ftrace_make_nop(NULL, rec, ftrace_addr);
 496         }
 497
 498         return 0;
 499 }
 500
 501 void ftrace_replace_code(int enable)
 502 {
 503         struct ftrace_rec_iter *iter;
 504         struct dyn_ftrace *rec;
 505         int ret;
 506
 507         for (iter = ftrace_rec_iter_start(); iter;
 508              iter = ftrace_rec_iter_next(iter)) {
 509                 rec = ftrace_rec_iter_record(iter);
 510                 ret = __ftrace_replace_code(rec, enable);
 511                 if (ret) {
 512                         ftrace_bug(ret, rec->ip);
 513                         return;
 514                 }
 515         }
 516 }
 517
 518 void arch_ftrace_update_code(int command)
 519 {
 520         if (command & FTRACE_UPDATE_CALLS)
 521                 ftrace_replace_code(1);
 522         else if (command & FTRACE_DISABLE_CALLS)
 523                 ftrace_replace_code(0);
 524
 525         if (command & FTRACE_UPDATE_TRACE_FUNC)
 526                 ftrace_update_ftrace_func(ftrace_trace_function);
 527
 528         if (command & FTRACE_START_FUNC_RET)
 529                 ftrace_enable_ftrace_graph_caller();
 530         else if (command & FTRACE_STOP_FUNC_RET)
 531                 ftrace_disable_ftrace_graph_caller();
 532 }
 533
 534 int __init ftrace_dyn_arch_init(void *data)
 535 {
 536         /* caller expects data to be zero */
 537         unsigned long *p = data;
 538
 539         *p = 0;
 540
 541         return 0;
 542 }
 543 #endif /* CONFIG_DYNAMIC_FTRACE */
 544
 545 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 546
 547 #ifdef CONFIG_DYNAMIC_FTRACE
 548 extern void ftrace_graph_call(void);
 549 extern void ftrace_graph_stub(void);
 550
 551 int ftrace_enable_ftrace_graph_caller(void)
 552 {
 553         unsigned long ip = (unsigned long)(&ftrace_graph_call);
 554         unsigned long addr = (unsigned long)(&ftrace_graph_caller);
 555         unsigned long stub = (unsigned long)(&ftrace_graph_stub);
 556         unsigned int old, new;
 557
 558         old = ftrace_call_replace(ip, stub, 0);
 559         new = ftrace_call_replace(ip, addr, 0);
 560
 561         return ftrace_modify_code(ip, old, new);
 562 }
 563
 564 int ftrace_disable_ftrace_graph_caller(void)
 565 {
 566         unsigned long ip = (unsigned long)(&ftrace_graph_call);
 567         unsigned long addr = (unsigned long)(&ftrace_graph_caller);
 568         unsigned long stub = (unsigned long)(&ftrace_graph_stub);
 569         unsigned int old, new;
 570
 571         old = ftrace_call_replace(ip, addr, 0);
 572         new = ftrace_call_replace(ip, stub, 0);
 573
 574         return ftrace_modify_code(ip, old, new);
 575 }
 576 #endif /* CONFIG_DYNAMIC_FTRACE */
 577
 578 #ifdef CONFIG_PPC64
 579 extern void mod_return_to_handler(void);
 580 #endif
 581
 582 /*
 583  * Hook the return address and push it in the stack of return addrs
 584  * in current thread info.
 585  */
 586 void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr)
 587 {
 588         unsigned long old;
 589         int faulted;
 590         struct ftrace_graph_ent trace;
 591         unsigned long return_hooker = (unsigned long)&return_to_handler;
 592
 593         if (unlikely(atomic_read(&current->tracing_graph_pause)))
 594                 return;
 595
 596 #ifdef CONFIG_PPC64
 597         /* non core kernel code needs to save and restore the TOC */
 598         if (REGION_ID(self_addr) != KERNEL_REGION_ID)
 599                 return_hooker = (unsigned long)&mod_return_to_handler;
 600 #endif
 601
 602         return_hooker = ppc_function_entry((void *)return_hooker);
 603
 604         /*
 605          * Protect against fault, even if it shouldn't
 606          * happen. This tool is too much intrusive to
 607          * ignore such a protection.
 608          */
 609         asm volatile(
 610                 "1: " PPC_LL "%[old], 0(%[parent])\n"
 611                 "2: " PPC_STL "%[return_hooker], 0(%[parent])\n"
 612                 "   li %[faulted], 0\n"
 613                 "3:\n"
 614
 615                 ".section .fixup, \"ax\"\n"
 616                 "4: li %[faulted], 1\n"
 617                 "   b 3b\n"
 618                 ".previous\n"
 619
 620                 ".section __ex_table,\"a\"\n"
 621                         PPC_LONG_ALIGN "\n"
 622                         PPC_LONG "1b,4b\n"
 623                         PPC_LONG "2b,4b\n"
 624                 ".previous"
 625
 626                 : [old] "=&r" (old), [faulted] "=r" (faulted)
 627                 : [parent] "r" (parent), [return_hooker] "r" (return_hooker)
 628                 : "memory"
 629         );
 630
 631         if (unlikely(faulted)) {
 632                 ftrace_graph_stop();
 633                 WARN_ON(1);
 634                 return;
 635         }
 636
 637         trace.func = self_addr;
 638         trace.depth = current->curr_ret_stack + 1;
 639
 640         /* Only trace if the calling function expects to */
 641         if (!ftrace_graph_entry(&trace)) {
 642                 *parent = old;
 643                 return;
 644         }
 645
 646         if (ftrace_push_return_trace(old, self_addr, &trace.depth, 0) == -EBUSY)
 647                 *parent = old;
 648 }
 649 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 650
 651 #if defined(CONFIG_FTRACE_SYSCALLS) && defined(CONFIG_PPC64)
 652 unsigned long __init arch_syscall_addr(int nr)
 653 {
 654         return sys_call_table[nr*2];
 655 }
 656 #endif /* CONFIG_FTRACE_SYSCALLS && CONFIG_PPC64 */