arch/x86/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 to Ingo Molnar, for suggesting the idea.
   7  * Mathieu Desnoyers, for suggesting postponing the modifications.
   8  * Arjan van de Ven, for keeping me straight, and explaining to me
   9  * the dangers of modifying code on the run.
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/spinlock.h>
  15 #include <linux/hardirq.h>
  16 #include <linux/uaccess.h>
  17 #include <linux/ftrace.h>
  18 #include <linux/percpu.h>
  19 #include <linux/sched.h>
  20 #include <linux/init.h>
  21 #include <linux/list.h>
  22 #include <linux/module.h>
  23
  24 #include <trace/syscall.h>
  25
  26 #include <asm/cacheflush.h>
  27 #include <asm/kprobes.h>
  28 #include <asm/ftrace.h>
  29 #include <asm/nops.h>
  30
  31 #ifdef CONFIG_DYNAMIC_FTRACE
  32
  33 int ftrace_arch_code_modify_prepare(void)
  34 {
  35         set_kernel_text_rw();
  36         set_all_modules_text_rw();
  37         return 0;
  38 }
  39
  40 int ftrace_arch_code_modify_post_process(void)
  41 {
  42         set_all_modules_text_ro();
  43         set_kernel_text_ro();
  44         return 0;
  45 }
  46
  47 union ftrace_code_union {
  48         char code[MCOUNT_INSN_SIZE];
  49         struct {
  50                 char e8;
  51                 int offset;
  52         } __attribute__((packed));
  53 };
  54
  55 static int ftrace_calc_offset(long ip, long addr)
  56 {
  57         return (int)(addr - ip);
  58 }
  59
  60 static unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
  61 {
  62         static union ftrace_code_union calc;
  63
  64         calc.e8         = 0xe8;
  65         calc.offset     = ftrace_calc_offset(ip + MCOUNT_INSN_SIZE, addr);
  66
  67         /*
  68          * No locking needed, this must be called via kstop_machine
  69          * which in essence is like running on a uniprocessor machine.
  70          */
  71         return calc.code;
  72 }
  73
  74 static inline int
  75 within(unsigned long addr, unsigned long start, unsigned long end)
  76 {
  77         return addr >= start && addr < end;
  78 }
  79
  80 static int
  81 do_ftrace_mod_code(unsigned long ip, const void *new_code)
  82 {
  83         /*
  84          * On x86_64, kernel text mappings are mapped read-only with
  85          * CONFIG_DEBUG_RODATA. So we use the kernel identity mapping instead
  86          * of the kernel text mapping to modify the kernel text.
  87          *
  88          * For 32bit kernels, these mappings are same and we can use
  89          * kernel identity mapping to modify code.
  90          */
  91         if (within(ip, (unsigned long)_text, (unsigned long)_etext))
  92                 ip = (unsigned long)__va(__pa(ip));
  93
  94         return probe_kernel_write((void *)ip, new_code, MCOUNT_INSN_SIZE);
  95 }
  96
  97 static const unsigned char *ftrace_nop_replace(void)
  98 {
  99         return ideal_nops[NOP_ATOMIC5];
 100 }
 101
 102 static int
 103 ftrace_modify_code_direct(unsigned long ip, unsigned const char *old_code,
 104                    unsigned const char *new_code)
 105 {
 106         unsigned char replaced[MCOUNT_INSN_SIZE];
 107
 108         /*
 109          * Note: Due to modules and __init, code can
 110          *  disappear and change, we need to protect against faulting
 111          *  as well as code changing. We do this by using the
 112          *  probe_kernel_* functions.
 113          *
 114          * No real locking needed, this code is run through
 115          * kstop_machine, or before SMP starts.
 116          */
 117
 118         /* read the text we want to modify */
 119         if (probe_kernel_read(replaced, (void *)ip, MCOUNT_INSN_SIZE))
 120                 return -EFAULT;
 121
 122         /* Make sure it is what we expect it to be */
 123         if (memcmp(replaced, old_code, MCOUNT_INSN_SIZE) != 0)
 124                 return -EINVAL;
 125
 126         /* replace the text with the new text */
 127         if (do_ftrace_mod_code(ip, new_code))
 128                 return -EPERM;
 129
 130         sync_core();
 131
 132         return 0;
 133 }
 134
 135 int ftrace_make_nop(struct module *mod,
 136                     struct dyn_ftrace *rec, unsigned long addr)
 137 {
 138         unsigned const char *new, *old;
 139         unsigned long ip = rec->ip;
 140
 141         old = ftrace_call_replace(ip, addr);
 142         new = ftrace_nop_replace();
 143
 144         /*
 145          * On boot up, and when modules are loaded, the MCOUNT_ADDR
 146          * is converted to a nop, and will never become MCOUNT_ADDR
 147          * again. This code is either running before SMP (on boot up)
 148          * or before the code will ever be executed (module load).
 149          * We do not want to use the breakpoint version in this case,
 150          * just modify the code directly.
 151          */
 152         if (addr == MCOUNT_ADDR)
 153                 return ftrace_modify_code_direct(rec->ip, old, new);
 154
 155         /* Normal cases use add_brk_on_nop */
 156         WARN_ONCE(1, "invalid use of ftrace_make_nop");
 157         return -EINVAL;
 158 }
 159
 160 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 161 {
 162         unsigned const char *new, *old;
 163         unsigned long ip = rec->ip;
 164
 165         old = ftrace_nop_replace();
 166         new = ftrace_call_replace(ip, addr);
 167
 168         /* Should only be called when module is loaded */
 169         return ftrace_modify_code_direct(rec->ip, old, new);
 170 }
 171
 172 /*
 173  * The modifying_ftrace_code is used to tell the breakpoint
 174  * handler to call ftrace_int3_handler(). If it fails to
 175  * call this handler for a breakpoint added by ftrace, then
 176  * the kernel may crash.
 177  *
 178  * As atomic_writes on x86 do not need a barrier, we do not
 179  * need to add smp_mb()s for this to work. It is also considered
 180  * that we can not read the modifying_ftrace_code before
 181  * executing the breakpoint. That would be quite remarkable if
 182  * it could do that. Here's the flow that is required:
 183  *
 184  *   CPU-0                          CPU-1
 185  *
 186  * atomic_inc(mfc);
 187  * write int3s
 188  *                              <trap-int3> // implicit (r)mb
 189  *                              if (atomic_read(mfc))
 190  *                                      call ftrace_int3_handler()
 191  *
 192  * Then when we are finished:
 193  *
 194  * atomic_dec(mfc);
 195  *
 196  * If we hit a breakpoint that was not set by ftrace, it does not
 197  * matter if ftrace_int3_handler() is called or not. It will
 198  * simply be ignored. But it is crucial that a ftrace nop/caller
 199  * breakpoint is handled. No other user should ever place a
 200  * breakpoint on an ftrace nop/caller location. It must only
 201  * be done by this code.
 202  */
 203 atomic_t modifying_ftrace_code __read_mostly;
 204
 205 static int
 206 ftrace_modify_code(unsigned long ip, unsigned const char *old_code,
 207                    unsigned const char *new_code);
 208
 209 #ifdef ARCH_SUPPORTS_FTRACE_SAVE_REGS
 210 /*
 211  * Should never be called:
 212  *  As it is only called by __ftrace_replace_code() which is called by
 213  *  ftrace_replace_code() that x86 overrides, and by ftrace_update_code()
 214  *  which is called to turn mcount into nops or nops into function calls
 215  *  but not to convert a function from not using regs to one that uses
 216  *  regs, which ftrace_modify_call() is for.
 217  */
 218 int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
 219                                  unsigned long addr)
 220 {
 221         WARN_ON(1);
 222         return -EINVAL;
 223 }
 224 #endif
 225
 226 int ftrace_update_ftrace_func(ftrace_func_t func)
 227 {
 228         unsigned long ip = (unsigned long)(&ftrace_call);
 229         unsigned char old[MCOUNT_INSN_SIZE], *new;
 230         int ret;
 231
 232         memcpy(old, &ftrace_call, MCOUNT_INSN_SIZE);
 233         new = ftrace_call_replace(ip, (unsigned long)func);
 234
 235         /* See comment above by declaration of modifying_ftrace_code */
 236         atomic_inc(&modifying_ftrace_code);
 237
 238         ret = ftrace_modify_code(ip, old, new);
 239
 240 #ifdef ARCH_SUPPORTS_FTRACE_SAVE_REGS
 241         /* Also update the regs callback function */
 242         if (!ret) {
 243                 ip = (unsigned long)(&ftrace_regs_call);
 244                 memcpy(old, &ftrace_regs_call, MCOUNT_INSN_SIZE);
 245                 new = ftrace_call_replace(ip, (unsigned long)func);
 246                 ret = ftrace_modify_code(ip, old, new);
 247         }
 248 #endif
 249
 250         atomic_dec(&modifying_ftrace_code);
 251
 252         return ret;
 253 }
 254
 255 /*
 256  * A breakpoint was added to the code address we are about to
 257  * modify, and this is the handle that will just skip over it.
 258  * We are either changing a nop into a trace call, or a trace
 259  * call to a nop. While the change is taking place, we treat
 260  * it just like it was a nop.
 261  */
 262 int ftrace_int3_handler(struct pt_regs *regs)
 263 {
 264         if (WARN_ON_ONCE(!regs))
 265                 return 0;
 266
 267         if (!ftrace_location(regs->ip - 1))
 268                 return 0;
 269
 270         regs->ip += MCOUNT_INSN_SIZE - 1;
 271
 272         return 1;
 273 }
 274
 275 static int ftrace_write(unsigned long ip, const char *val, int size)
 276 {
 277         /*
 278          * On x86_64, kernel text mappings are mapped read-only with
 279          * CONFIG_DEBUG_RODATA. So we use the kernel identity mapping instead
 280          * of the kernel text mapping to modify the kernel text.
 281          *
 282          * For 32bit kernels, these mappings are same and we can use
 283          * kernel identity mapping to modify code.
 284          */
 285         if (within(ip, (unsigned long)_text, (unsigned long)_etext))
 286                 ip = (unsigned long)__va(__pa(ip));
 287
 288         return probe_kernel_write((void *)ip, val, size);
 289 }
 290
 291 static int add_break(unsigned long ip, const char *old)
 292 {
 293         unsigned char replaced[MCOUNT_INSN_SIZE];
 294         unsigned char brk = BREAKPOINT_INSTRUCTION;
 295
 296         if (probe_kernel_read(replaced, (void *)ip, MCOUNT_INSN_SIZE))
 297                 return -EFAULT;
 298
 299         /* Make sure it is what we expect it to be */
 300         if (memcmp(replaced, old, MCOUNT_INSN_SIZE) != 0)
 301                 return -EINVAL;
 302
 303         if (ftrace_write(ip, &brk, 1))
 304                 return -EPERM;
 305
 306         return 0;
 307 }
 308
 309 static int add_brk_on_call(struct dyn_ftrace *rec, unsigned long addr)
 310 {
 311         unsigned const char *old;
 312         unsigned long ip = rec->ip;
 313
 314         old = ftrace_call_replace(ip, addr);
 315
 316         return add_break(rec->ip, old);
 317 }
 318
 319
 320 static int add_brk_on_nop(struct dyn_ftrace *rec)
 321 {
 322         unsigned const char *old;
 323
 324         old = ftrace_nop_replace();
 325
 326         return add_break(rec->ip, old);
 327 }
 328
 329 /*
 330  * If the record has the FTRACE_FL_REGS set, that means that it
 331  * wants to convert to a callback that saves all regs. If FTRACE_FL_REGS
 332  * is not not set, then it wants to convert to the normal callback.
 333  */
 334 static unsigned long get_ftrace_addr(struct dyn_ftrace *rec)
 335 {
 336         if (rec->flags & FTRACE_FL_REGS)
 337                 return (unsigned long)FTRACE_REGS_ADDR;
 338         else
 339                 return (unsigned long)FTRACE_ADDR;
 340 }
 341
 342 /*
 343  * The FTRACE_FL_REGS_EN is set when the record already points to
 344  * a function that saves all the regs. Basically the '_EN' version
 345  * represents the current state of the function.
 346  */
 347 static unsigned long get_ftrace_old_addr(struct dyn_ftrace *rec)
 348 {
 349         if (rec->flags & FTRACE_FL_REGS_EN)
 350                 return (unsigned long)FTRACE_REGS_ADDR;
 351         else
 352                 return (unsigned long)FTRACE_ADDR;
 353 }
 354
 355 static int add_breakpoints(struct dyn_ftrace *rec, int enable)
 356 {
 357         unsigned long ftrace_addr;
 358         int ret;
 359
 360         ret = ftrace_test_record(rec, enable);
 361
 362         ftrace_addr = get_ftrace_addr(rec);
 363
 364         switch (ret) {
 365         case FTRACE_UPDATE_IGNORE:
 366                 return 0;
 367
 368         case FTRACE_UPDATE_MAKE_CALL:
 369                 /* converting nop to call */
 370                 return add_brk_on_nop(rec);
 371
 372         case FTRACE_UPDATE_MODIFY_CALL_REGS:
 373         case FTRACE_UPDATE_MODIFY_CALL:
 374                 ftrace_addr = get_ftrace_old_addr(rec);
 375                 /* fall through */
 376         case FTRACE_UPDATE_MAKE_NOP:
 377                 /* converting a call to a nop */
 378                 return add_brk_on_call(rec, ftrace_addr);
 379         }
 380         return 0;
 381 }
 382
 383 /*
 384  * On error, we need to remove breakpoints. This needs to
 385  * be done caefully. If the address does not currently have a
 386  * breakpoint, we know we are done. Otherwise, we look at the
 387  * remaining 4 bytes of the instruction. If it matches a nop
 388  * we replace the breakpoint with the nop. Otherwise we replace
 389  * it with the call instruction.
 390  */
 391 static int remove_breakpoint(struct dyn_ftrace *rec)
 392 {
 393         unsigned char ins[MCOUNT_INSN_SIZE];
 394         unsigned char brk = BREAKPOINT_INSTRUCTION;
 395         const unsigned char *nop;
 396         unsigned long ftrace_addr;
 397         unsigned long ip = rec->ip;
 398
 399         /* If we fail the read, just give up */
 400         if (probe_kernel_read(ins, (void *)ip, MCOUNT_INSN_SIZE))
 401                 return -EFAULT;
 402
 403         /* If this does not have a breakpoint, we are done */
 404         if (ins[0] != brk)
 405                 return -1;
 406
 407         nop = ftrace_nop_replace();
 408
 409         /*
 410          * If the last 4 bytes of the instruction do not match
 411          * a nop, then we assume that this is a call to ftrace_addr.
 412          */
 413         if (memcmp(&ins[1], &nop[1], MCOUNT_INSN_SIZE - 1) != 0) {
 414                 /*
 415                  * For extra paranoidism, we check if the breakpoint is on
 416                  * a call that would actually jump to the ftrace_addr.
 417                  * If not, don't touch the breakpoint, we make just create
 418                  * a disaster.
 419                  */
 420                 ftrace_addr = get_ftrace_addr(rec);
 421                 nop = ftrace_call_replace(ip, ftrace_addr);
 422
 423                 if (memcmp(&ins[1], &nop[1], MCOUNT_INSN_SIZE - 1) == 0)
 424                         goto update;
 425
 426                 /* Check both ftrace_addr and ftrace_old_addr */
 427                 ftrace_addr = get_ftrace_old_addr(rec);
 428                 nop = ftrace_call_replace(ip, ftrace_addr);
 429
 430                 if (memcmp(&ins[1], &nop[1], MCOUNT_INSN_SIZE - 1) != 0)
 431                         return -EINVAL;
 432         }
 433
 434  update:
 435         return probe_kernel_write((void *)ip, &nop[0], 1);
 436 }
 437
 438 static int add_update_code(unsigned long ip, unsigned const char *new)
 439 {
 440         /* skip breakpoint */
 441         ip++;
 442         new++;
 443         if (ftrace_write(ip, new, MCOUNT_INSN_SIZE - 1))
 444                 return -EPERM;
 445         return 0;
 446 }
 447
 448 static int add_update_call(struct dyn_ftrace *rec, unsigned long addr)
 449 {
 450         unsigned long ip = rec->ip;
 451         unsigned const char *new;
 452
 453         new = ftrace_call_replace(ip, addr);
 454         return add_update_code(ip, new);
 455 }
 456
 457 static int add_update_nop(struct dyn_ftrace *rec)
 458 {
 459         unsigned long ip = rec->ip;
 460         unsigned const char *new;
 461
 462         new = ftrace_nop_replace();
 463         return add_update_code(ip, new);
 464 }
 465
 466 static int add_update(struct dyn_ftrace *rec, int enable)
 467 {
 468         unsigned long ftrace_addr;
 469         int ret;
 470
 471         ret = ftrace_test_record(rec, enable);
 472
 473         ftrace_addr  = get_ftrace_addr(rec);
 474
 475         switch (ret) {
 476         case FTRACE_UPDATE_IGNORE:
 477                 return 0;
 478
 479         case FTRACE_UPDATE_MODIFY_CALL_REGS:
 480         case FTRACE_UPDATE_MODIFY_CALL:
 481         case FTRACE_UPDATE_MAKE_CALL:
 482                 /* converting nop to call */
 483                 return add_update_call(rec, ftrace_addr);
 484
 485         case FTRACE_UPDATE_MAKE_NOP:
 486                 /* converting a call to a nop */
 487                 return add_update_nop(rec);
 488         }
 489
 490         return 0;
 491 }
 492
 493 static int finish_update_call(struct dyn_ftrace *rec, unsigned long addr)
 494 {
 495         unsigned long ip = rec->ip;
 496         unsigned const char *new;
 497
 498         new = ftrace_call_replace(ip, addr);
 499
 500         if (ftrace_write(ip, new, 1))
 501                 return -EPERM;
 502
 503         return 0;
 504 }
 505
 506 static int finish_update_nop(struct dyn_ftrace *rec)
 507 {
 508         unsigned long ip = rec->ip;
 509         unsigned const char *new;
 510
 511         new = ftrace_nop_replace();
 512
 513         if (ftrace_write(ip, new, 1))
 514                 return -EPERM;
 515         return 0;
 516 }
 517
 518 static int finish_update(struct dyn_ftrace *rec, int enable)
 519 {
 520         unsigned long ftrace_addr;
 521         int ret;
 522
 523         ret = ftrace_update_record(rec, enable);
 524
 525         ftrace_addr = get_ftrace_addr(rec);
 526
 527         switch (ret) {
 528         case FTRACE_UPDATE_IGNORE:
 529                 return 0;
 530
 531         case FTRACE_UPDATE_MODIFY_CALL_REGS:
 532         case FTRACE_UPDATE_MODIFY_CALL:
 533         case FTRACE_UPDATE_MAKE_CALL:
 534                 /* converting nop to call */
 535                 return finish_update_call(rec, ftrace_addr);
 536
 537         case FTRACE_UPDATE_MAKE_NOP:
 538                 /* converting a call to a nop */
 539                 return finish_update_nop(rec);
 540         }
 541
 542         return 0;
 543 }
 544
 545 static void do_sync_core(void *data)
 546 {
 547         sync_core();
 548 }
 549
 550 static void run_sync(void)
 551 {
 552         int enable_irqs = irqs_disabled();
 553
 554         /* We may be called with interrupts disbled (on bootup). */
 555         if (enable_irqs)
 556                 local_irq_enable();
 557         on_each_cpu(do_sync_core, NULL, 1);
 558         if (enable_irqs)
 559                 local_irq_disable();
 560 }
 561
 562 void ftrace_replace_code(int enable)
 563 {
 564         struct ftrace_rec_iter *iter;
 565         struct dyn_ftrace *rec;
 566         const char *report = "adding breakpoints";
 567         int count = 0;
 568         int ret;
 569
 570         for_ftrace_rec_iter(iter) {
 571                 rec = ftrace_rec_iter_record(iter);
 572
 573                 ret = add_breakpoints(rec, enable);
 574                 if (ret)
 575                         goto remove_breakpoints;
 576                 count++;
 577         }
 578
 579         run_sync();
 580
 581         report = "updating code";
 582
 583         for_ftrace_rec_iter(iter) {
 584                 rec = ftrace_rec_iter_record(iter);
 585
 586                 ret = add_update(rec, enable);
 587                 if (ret)
 588                         goto remove_breakpoints;
 589         }
 590
 591         run_sync();
 592
 593         report = "removing breakpoints";
 594
 595         for_ftrace_rec_iter(iter) {
 596                 rec = ftrace_rec_iter_record(iter);
 597
 598                 ret = finish_update(rec, enable);
 599                 if (ret)
 600                         goto remove_breakpoints;
 601         }
 602
 603         run_sync();
 604
 605         return;
 606
 607  remove_breakpoints:
 608         ftrace_bug(ret, rec ? rec->ip : 0);
 609         printk(KERN_WARNING "Failed on %s (%d):\n", report, count);
 610         for_ftrace_rec_iter(iter) {
 611                 rec = ftrace_rec_iter_record(iter);
 612                 remove_breakpoint(rec);
 613         }
 614 }
 615
 616 static int
 617 ftrace_modify_code(unsigned long ip, unsigned const char *old_code,
 618                    unsigned const char *new_code)
 619 {
 620         int ret;
 621
 622         ret = add_break(ip, old_code);
 623         if (ret)
 624                 goto out;
 625
 626         run_sync();
 627
 628         ret = add_update_code(ip, new_code);
 629         if (ret)
 630                 goto fail_update;
 631
 632         run_sync();
 633
 634         ret = ftrace_write(ip, new_code, 1);
 635         if (ret) {
 636                 ret = -EPERM;
 637                 goto out;
 638         }
 639         run_sync();
 640  out:
 641         return ret;
 642
 643  fail_update:
 644         probe_kernel_write((void *)ip, &old_code[0], 1);
 645         goto out;
 646 }
 647
 648 void arch_ftrace_update_code(int command)
 649 {
 650         /* See comment above by declaration of modifying_ftrace_code */
 651         atomic_inc(&modifying_ftrace_code);
 652
 653         ftrace_modify_all_code(command);
 654
 655         atomic_dec(&modifying_ftrace_code);
 656 }
 657
 658 int __init ftrace_dyn_arch_init(void *data)
 659 {
 660         /* The return code is retured via data */
 661         *(unsigned long *)data = 0;
 662
 663         return 0;
 664 }
 665 #endif
 666
 667 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 668
 669 #ifdef CONFIG_DYNAMIC_FTRACE
 670 extern void ftrace_graph_call(void);
 671
 672 static int ftrace_mod_jmp(unsigned long ip,
 673                           int old_offset, int new_offset)
 674 {
 675         unsigned char code[MCOUNT_INSN_SIZE];
 676
 677         if (probe_kernel_read(code, (void *)ip, MCOUNT_INSN_SIZE))
 678                 return -EFAULT;
 679
 680         if (code[0] != 0xe9 || old_offset != *(int *)(&code[1]))
 681                 return -EINVAL;
 682
 683         *(int *)(&code[1]) = new_offset;
 684
 685         if (do_ftrace_mod_code(ip, &code))
 686                 return -EPERM;
 687
 688         return 0;
 689 }
 690
 691 int ftrace_enable_ftrace_graph_caller(void)
 692 {
 693         unsigned long ip = (unsigned long)(&ftrace_graph_call);
 694         int old_offset, new_offset;
 695
 696         old_offset = (unsigned long)(&ftrace_stub) - (ip + MCOUNT_INSN_SIZE);
 697         new_offset = (unsigned long)(&ftrace_graph_caller) - (ip + MCOUNT_INSN_SIZE);
 698
 699         return ftrace_mod_jmp(ip, old_offset, new_offset);
 700 }
 701
 702 int ftrace_disable_ftrace_graph_caller(void)
 703 {
 704         unsigned long ip = (unsigned long)(&ftrace_graph_call);
 705         int old_offset, new_offset;
 706
 707         old_offset = (unsigned long)(&ftrace_graph_caller) - (ip + MCOUNT_INSN_SIZE);
 708         new_offset = (unsigned long)(&ftrace_stub) - (ip + MCOUNT_INSN_SIZE);
 709
 710         return ftrace_mod_jmp(ip, old_offset, new_offset);
 711 }
 712
 713 #endif /* !CONFIG_DYNAMIC_FTRACE */
 714
 715 /*
 716  * Hook the return address and push it in the stack of return addrs
 717  * in current thread info.
 718  */
 719 void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
 720                            unsigned long frame_pointer)
 721 {
 722         unsigned long old;
 723         int faulted;
 724         struct ftrace_graph_ent trace;
 725         unsigned long return_hooker = (unsigned long)
 726                                 &return_to_handler;
 727
 728         if (unlikely(atomic_read(&current->tracing_graph_pause)))
 729                 return;
 730
 731         /*
 732          * Protect against fault, even if it shouldn't
 733          * happen. This tool is too much intrusive to
 734          * ignore such a protection.
 735          */
 736         asm volatile(
 737                 "1: " _ASM_MOV " (%[parent]), %[old]\n"
 738                 "2: " _ASM_MOV " %[return_hooker], (%[parent])\n"
 739                 "   movl $0, %[faulted]\n"
 740                 "3:\n"
 741
 742                 ".section .fixup, \"ax\"\n"
 743                 "4: movl $1, %[faulted]\n"
 744                 "   jmp 3b\n"
 745                 ".previous\n"
 746
 747                 _ASM_EXTABLE(1b, 4b)
 748                 _ASM_EXTABLE(2b, 4b)
 749
 750                 : [old] "=&r" (old), [faulted] "=r" (faulted)
 751                 : [parent] "r" (parent), [return_hooker] "r" (return_hooker)
 752                 : "memory"
 753         );
 754
 755         if (unlikely(faulted)) {
 756                 ftrace_graph_stop();
 757                 WARN_ON(1);
 758                 return;
 759         }
 760
 761         trace.func = self_addr;
 762         trace.depth = current->curr_ret_stack + 1;
 763
 764         /* Only trace if the calling function expects to */
 765         if (!ftrace_graph_entry(&trace)) {
 766                 *parent = old;
 767                 return;
 768         }
 769
 770         if (ftrace_push_return_trace(old, self_addr, &trace.depth,
 771                     frame_pointer) == -EBUSY) {
 772                 *parent = old;
 773                 return;
 774         }
 775 }
 776 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */