kernel/trace/ftrace.c

   1 /*
   2  * Infrastructure for profiling code inserted by 'gcc -pg'.
   3  *
   4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
   5  * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
   6  *
   7  * Originally ported from the -rt patch by:
   8  *   Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
   9  *
  10  * Based on code in the latency_tracer, that is:
  11  *
  12  *  Copyright (C) 2004-2006 Ingo Molnar
  13  *  Copyright (C) 2004 Nadia Yvette Chambers
  14  */
  15
  16 #include <linux/stop_machine.h>
  17 #include <linux/clocksource.h>
  18 #include <linux/kallsyms.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/suspend.h>
  21 #include <linux/debugfs.h>
  22 #include <linux/hardirq.h>
  23 #include <linux/kthread.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/bsearch.h>
  26 #include <linux/module.h>
  27 #include <linux/ftrace.h>
  28 #include <linux/sysctl.h>
  29 #include <linux/slab.h>
  30 #include <linux/ctype.h>
  31 #include <linux/sort.h>
  32 #include <linux/list.h>
  33 #include <linux/hash.h>
  34 #include <linux/rcupdate.h>
  35
  36 #include <trace/events/sched.h>
  37
  38 #include <asm/setup.h>
  39
  40 #include "trace_output.h"
  41 #include "trace_stat.h"
  42
  43 #define FTRACE_WARN_ON(cond)                    \
  44         ({                                      \
  45                 int ___r = cond;                \
  46                 if (WARN_ON(___r))              \
  47                         ftrace_kill();          \
  48                 ___r;                           \
  49         })
  50
  51 #define FTRACE_WARN_ON_ONCE(cond)               \
  52         ({                                      \
  53                 int ___r = cond;                \
  54                 if (WARN_ON_ONCE(___r))         \
  55                         ftrace_kill();          \
  56                 ___r;                           \
  57         })
  58
  59 /* hash bits for specific function selection */
  60 #define FTRACE_HASH_BITS 7
  61 #define FTRACE_FUNC_HASHSIZE (1 << FTRACE_HASH_BITS)
  62 #define FTRACE_HASH_DEFAULT_BITS 10
  63 #define FTRACE_HASH_MAX_BITS 12
  64
  65 #define FL_GLOBAL_CONTROL_MASK (FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_CONTROL)
  66
  67 static struct ftrace_ops ftrace_list_end __read_mostly = {
  68         .func           = ftrace_stub,
  69         .flags          = FTRACE_OPS_FL_RECURSION_SAFE,
  70 };
  71
  72 /* ftrace_enabled is a method to turn ftrace on or off */
  73 int ftrace_enabled __read_mostly;
  74 static int last_ftrace_enabled;
  75
  76 /* Quick disabling of function tracer. */
  77 int function_trace_stop __read_mostly;
  78
  79 /* Current function tracing op */
  80 struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;
  81
  82 /* List for set_ftrace_pid's pids. */
  83 LIST_HEAD(ftrace_pids);
  84 struct ftrace_pid {
  85         struct list_head list;
  86         struct pid *pid;
  87 };
  88
  89 /*
  90  * ftrace_disabled is set when an anomaly is discovered.
  91  * ftrace_disabled is much stronger than ftrace_enabled.
  92  */
  93 static int ftrace_disabled __read_mostly;
  94
  95 static DEFINE_MUTEX(ftrace_lock);
  96
  97 static struct ftrace_ops *ftrace_global_list __read_mostly = &ftrace_list_end;
  98 static struct ftrace_ops *ftrace_control_list __read_mostly = &ftrace_list_end;
  99 static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
 100 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 101 ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 102 static struct ftrace_ops global_ops;
 103 static struct ftrace_ops control_ops;
 104
 105 #if ARCH_SUPPORTS_FTRACE_OPS
 106 static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
 107                                  struct ftrace_ops *op, struct pt_regs *regs);
 108 #else
 109 /* See comment below, where ftrace_ops_list_func is defined */
 110 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip);
 111 #define ftrace_ops_list_func ((ftrace_func_t)ftrace_ops_no_ops)
 112 #endif
 113
 114 /*
 115  * Traverse the ftrace_global_list, invoking all entries.  The reason that we
 116  * can use rcu_dereference_raw() is that elements removed from this list
 117  * are simply leaked, so there is no need to interact with a grace-period
 118  * mechanism.  The rcu_dereference_raw() calls are needed to handle
 119  * concurrent insertions into the ftrace_global_list.
 120  *
 121  * Silly Alpha and silly pointer-speculation compiler optimizations!
 122  */
 123 #define do_for_each_ftrace_op(op, list)                 \
 124         op = rcu_dereference_raw(list);                 \
 125         do
 126
 127 /*
 128  * Optimized for just a single item in the list (as that is the normal case).
 129  */
 130 #define while_for_each_ftrace_op(op)                            \
 131         while (likely(op = rcu_dereference_raw((op)->next)) &&  \
 132                unlikely((op) != &ftrace_list_end))
 133
 134 /**
 135  * ftrace_nr_registered_ops - return number of ops registered
 136  *
 137  * Returns the number of ftrace_ops registered and tracing functions
 138  */
 139 int ftrace_nr_registered_ops(void)
 140 {
 141         struct ftrace_ops *ops;
 142         int cnt = 0;
 143
 144         mutex_lock(&ftrace_lock);
 145
 146         for (ops = ftrace_ops_list;
 147              ops != &ftrace_list_end; ops = ops->next)
 148                 cnt++;
 149
 150         mutex_unlock(&ftrace_lock);
 151
 152         return cnt;
 153 }
 154
 155 static void
 156 ftrace_global_list_func(unsigned long ip, unsigned long parent_ip,
 157                         struct ftrace_ops *op, struct pt_regs *regs)
 158 {
 159         int bit;
 160
 161         bit = trace_test_and_set_recursion(TRACE_GLOBAL_START, TRACE_GLOBAL_MAX);
 162         if (bit < 0)
 163                 return;
 164
 165         do_for_each_ftrace_op(op, ftrace_global_list) {
 166                 op->func(ip, parent_ip, op, regs);
 167         } while_for_each_ftrace_op(op);
 168
 169         trace_clear_recursion(bit);
 170 }
 171
 172 static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
 173                             struct ftrace_ops *op, struct pt_regs *regs)
 174 {
 175         if (!test_tsk_trace_trace(current))
 176                 return;
 177
 178         ftrace_pid_function(ip, parent_ip, op, regs);
 179 }
 180
 181 static void set_ftrace_pid_function(ftrace_func_t func)
 182 {
 183         /* do not set ftrace_pid_function to itself! */
 184         if (func != ftrace_pid_func)
 185                 ftrace_pid_function = func;
 186 }
 187
 188 /**
 189  * clear_ftrace_function - reset the ftrace function
 190  *
 191  * This NULLs the ftrace function and in essence stops
 192  * tracing.  There may be lag
 193  */
 194 void clear_ftrace_function(void)
 195 {
 196         ftrace_trace_function = ftrace_stub;
 197         ftrace_pid_function = ftrace_stub;
 198 }
 199
 200 static void control_ops_disable_all(struct ftrace_ops *ops)
 201 {
 202         int cpu;
 203
 204         for_each_possible_cpu(cpu)
 205                 *per_cpu_ptr(ops->disabled, cpu) = 1;
 206 }
 207
 208 static int control_ops_alloc(struct ftrace_ops *ops)
 209 {
 210         int __percpu *disabled;
 211
 212         disabled = alloc_percpu(int);
 213         if (!disabled)
 214                 return -ENOMEM;
 215
 216         ops->disabled = disabled;
 217         control_ops_disable_all(ops);
 218         return 0;
 219 }
 220
 221 static void control_ops_free(struct ftrace_ops *ops)
 222 {
 223         free_percpu(ops->disabled);
 224 }
 225
 226 static void update_global_ops(void)
 227 {
 228         ftrace_func_t func;
 229
 230         /*
 231          * If there's only one function registered, then call that
 232          * function directly. Otherwise, we need to iterate over the
 233          * registered callers.
 234          */
 235         if (ftrace_global_list == &ftrace_list_end ||
 236             ftrace_global_list->next == &ftrace_list_end) {
 237                 func = ftrace_global_list->func;
 238                 /*
 239                  * As we are calling the function directly.
 240                  * If it does not have recursion protection,
 241                  * the function_trace_op needs to be updated
 242                  * accordingly.
 243                  */
 244                 if (ftrace_global_list->flags & FTRACE_OPS_FL_RECURSION_SAFE)
 245                         global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
 246                 else
 247                         global_ops.flags &= ~FTRACE_OPS_FL_RECURSION_SAFE;
 248         } else {
 249                 func = ftrace_global_list_func;
 250                 /* The list has its own recursion protection. */
 251                 global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
 252         }
 253
 254
 255         /* If we filter on pids, update to use the pid function */
 256         if (!list_empty(&ftrace_pids)) {
 257                 set_ftrace_pid_function(func);
 258                 func = ftrace_pid_func;
 259         }
 260
 261         global_ops.func = func;
 262 }
 263
 264 static void update_ftrace_function(void)
 265 {
 266         ftrace_func_t func;
 267
 268         update_global_ops();
 269
 270         /*
 271          * If we are at the end of the list and this ops is
 272          * recursion safe and not dynamic and the arch supports passing ops,
 273          * then have the mcount trampoline call the function directly.
 274          */
 275         if (ftrace_ops_list == &ftrace_list_end ||
 276             (ftrace_ops_list->next == &ftrace_list_end &&
 277              !(ftrace_ops_list->flags & FTRACE_OPS_FL_DYNAMIC) &&
 278              (ftrace_ops_list->flags & FTRACE_OPS_FL_RECURSION_SAFE) &&
 279              !FTRACE_FORCE_LIST_FUNC)) {
 280                 /* Set the ftrace_ops that the arch callback uses */
 281                 if (ftrace_ops_list == &global_ops)
 282                         function_trace_op = ftrace_global_list;
 283                 else
 284                         function_trace_op = ftrace_ops_list;
 285                 func = ftrace_ops_list->func;
 286         } else {
 287                 /* Just use the default ftrace_ops */
 288                 function_trace_op = &ftrace_list_end;
 289                 func = ftrace_ops_list_func;
 290         }
 291
 292         ftrace_trace_function = func;
 293 }
 294
 295 static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
 296 {
 297         ops->next = *list;
 298         /*
 299          * We are entering ops into the list but another
 300          * CPU might be walking that list. We need to make sure
 301          * the ops->next pointer is valid before another CPU sees
 302          * the ops pointer included into the list.
 303          */
 304         rcu_assign_pointer(*list, ops);
 305 }
 306
 307 static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
 308 {
 309         struct ftrace_ops **p;
 310
 311         /*
 312          * If we are removing the last function, then simply point
 313          * to the ftrace_stub.
 314          */
 315         if (*list == ops && ops->next == &ftrace_list_end) {
 316                 *list = &ftrace_list_end;
 317                 return 0;
 318         }
 319
 320         for (p = list; *p != &ftrace_list_end; p = &(*p)->next)
 321                 if (*p == ops)
 322                         break;
 323
 324         if (*p != ops)
 325                 return -1;
 326
 327         *p = (*p)->next;
 328         return 0;
 329 }
 330
 331 static void add_ftrace_list_ops(struct ftrace_ops **list,
 332                                 struct ftrace_ops *main_ops,
 333                                 struct ftrace_ops *ops)
 334 {
 335         int first = *list == &ftrace_list_end;
 336         add_ftrace_ops(list, ops);
 337         if (first)
 338                 add_ftrace_ops(&ftrace_ops_list, main_ops);
 339 }
 340
 341 static int remove_ftrace_list_ops(struct ftrace_ops **list,
 342                                   struct ftrace_ops *main_ops,
 343                                   struct ftrace_ops *ops)
 344 {
 345         int ret = remove_ftrace_ops(list, ops);
 346         if (!ret && *list == &ftrace_list_end)
 347                 ret = remove_ftrace_ops(&ftrace_ops_list, main_ops);
 348         return ret;
 349 }
 350
 351 static int __register_ftrace_function(struct ftrace_ops *ops)
 352 {
 353         if (unlikely(ftrace_disabled))
 354                 return -ENODEV;
 355
 356         if (FTRACE_WARN_ON(ops == &global_ops))
 357                 return -EINVAL;
 358
 359         if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
 360                 return -EBUSY;
 361
 362         /* We don't support both control and global flags set. */
 363         if ((ops->flags & FL_GLOBAL_CONTROL_MASK) == FL_GLOBAL_CONTROL_MASK)
 364                 return -EINVAL;
 365
 366 #ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS
 367         /*
 368          * If the ftrace_ops specifies SAVE_REGS, then it only can be used
 369          * if the arch supports it, or SAVE_REGS_IF_SUPPORTED is also set.
 370          * Setting SAVE_REGS_IF_SUPPORTED makes SAVE_REGS irrelevant.
 371          */
 372         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS &&
 373             !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED))
 374                 return -EINVAL;
 375
 376         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)
 377                 ops->flags |= FTRACE_OPS_FL_SAVE_REGS;
 378 #endif
 379
 380         if (!core_kernel_data((unsigned long)ops))
 381                 ops->flags |= FTRACE_OPS_FL_DYNAMIC;
 382
 383         if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
 384                 add_ftrace_list_ops(&ftrace_global_list, &global_ops, ops);
 385                 ops->flags |= FTRACE_OPS_FL_ENABLED;
 386         } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
 387                 if (control_ops_alloc(ops))
 388                         return -ENOMEM;
 389                 add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops);
 390         } else
 391                 add_ftrace_ops(&ftrace_ops_list, ops);
 392
 393         if (ftrace_enabled)
 394                 update_ftrace_function();
 395
 396         return 0;
 397 }
 398
 399 static int __unregister_ftrace_function(struct ftrace_ops *ops)
 400 {
 401         int ret;
 402
 403         if (ftrace_disabled)
 404                 return -ENODEV;
 405
 406         if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED)))
 407                 return -EBUSY;
 408
 409         if (FTRACE_WARN_ON(ops == &global_ops))
 410                 return -EINVAL;
 411
 412         if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
 413                 ret = remove_ftrace_list_ops(&ftrace_global_list,
 414                                              &global_ops, ops);
 415                 if (!ret)
 416                         ops->flags &= ~FTRACE_OPS_FL_ENABLED;
 417         } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
 418                 ret = remove_ftrace_list_ops(&ftrace_control_list,
 419                                              &control_ops, ops);
 420                 if (!ret) {
 421                         /*
 422                          * The ftrace_ops is now removed from the list,
 423                          * so there'll be no new users. We must ensure
 424                          * all current users are done before we free
 425                          * the control data.
 426                          */
 427                         synchronize_sched();
 428                         control_ops_free(ops);
 429                 }
 430         } else
 431                 ret = remove_ftrace_ops(&ftrace_ops_list, ops);
 432
 433         if (ret < 0)
 434                 return ret;
 435
 436         if (ftrace_enabled)
 437                 update_ftrace_function();
 438
 439         /*
 440          * Dynamic ops may be freed, we must make sure that all
 441          * callers are done before leaving this function.
 442          */
 443         if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
 444                 synchronize_sched();
 445
 446         return 0;
 447 }
 448
 449 static void ftrace_update_pid_func(void)
 450 {
 451         /* Only do something if we are tracing something */
 452         if (ftrace_trace_function == ftrace_stub)
 453                 return;
 454
 455         update_ftrace_function();
 456 }
 457
 458 #ifdef CONFIG_FUNCTION_PROFILER
 459 struct ftrace_profile {
 460         struct hlist_node               node;
 461         unsigned long                   ip;
 462         unsigned long                   counter;
 463 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 464         unsigned long long              time;
 465         unsigned long long              time_squared;
 466 #endif
 467 };
 468
 469 struct ftrace_profile_page {
 470         struct ftrace_profile_page      *next;
 471         unsigned long                   index;
 472         struct ftrace_profile           records[];
 473 };
 474
 475 struct ftrace_profile_stat {
 476         atomic_t                        disabled;
 477         struct hlist_head               *hash;
 478         struct ftrace_profile_page      *pages;
 479         struct ftrace_profile_page      *start;
 480         struct tracer_stat              stat;
 481 };
 482
 483 #define PROFILE_RECORDS_SIZE                                            \
 484         (PAGE_SIZE - offsetof(struct ftrace_profile_page, records))
 485
 486 #define PROFILES_PER_PAGE                                       \
 487         (PROFILE_RECORDS_SIZE / sizeof(struct ftrace_profile))
 488
 489 static int ftrace_profile_bits __read_mostly;
 490 static int ftrace_profile_enabled __read_mostly;
 491
 492 /* ftrace_profile_lock - synchronize the enable and disable of the profiler */
 493 static DEFINE_MUTEX(ftrace_profile_lock);
 494
 495 static DEFINE_PER_CPU(struct ftrace_profile_stat, ftrace_profile_stats);
 496
 497 #define FTRACE_PROFILE_HASH_SIZE 1024 /* must be power of 2 */
 498
 499 static void *
 500 function_stat_next(void *v, int idx)
 501 {
 502         struct ftrace_profile *rec = v;
 503         struct ftrace_profile_page *pg;
 504
 505         pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
 506
 507  again:
 508         if (idx != 0)
 509                 rec++;
 510
 511         if ((void *)rec >= (void *)&pg->records[pg->index]) {
 512                 pg = pg->next;
 513                 if (!pg)
 514                         return NULL;
 515                 rec = &pg->records[0];
 516                 if (!rec->counter)
 517                         goto again;
 518         }
 519
 520         return rec;
 521 }
 522
 523 static void *function_stat_start(struct tracer_stat *trace)
 524 {
 525         struct ftrace_profile_stat *stat =
 526                 container_of(trace, struct ftrace_profile_stat, stat);
 527
 528         if (!stat || !stat->start)
 529                 return NULL;
 530
 531         return function_stat_next(&stat->start->records[0], 0);
 532 }
 533
 534 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 535 /* function graph compares on total time */
 536 static int function_stat_cmp(void *p1, void *p2)
 537 {
 538         struct ftrace_profile *a = p1;
 539         struct ftrace_profile *b = p2;
 540
 541         if (a->time < b->time)
 542                 return -1;
 543         if (a->time > b->time)
 544                 return 1;
 545         else
 546                 return 0;
 547 }
 548 #else
 549 /* not function graph compares against hits */
 550 static int function_stat_cmp(void *p1, void *p2)
 551 {
 552         struct ftrace_profile *a = p1;
 553         struct ftrace_profile *b = p2;
 554
 555         if (a->counter < b->counter)
 556                 return -1;
 557         if (a->counter > b->counter)
 558                 return 1;
 559         else
 560                 return 0;
 561 }
 562 #endif
 563
 564 static int function_stat_headers(struct seq_file *m)
 565 {
 566 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 567         seq_printf(m, "  Function                               "
 568                    "Hit    Time            Avg             s^2\n"
 569                       "  --------                               "
 570                    "---    ----            ---             ---\n");
 571 #else
 572         seq_printf(m, "  Function                               Hit\n"
 573                       "  --------                               ---\n");
 574 #endif
 575         return 0;
 576 }
 577
 578 static int function_stat_show(struct seq_file *m, void *v)
 579 {
 580         struct ftrace_profile *rec = v;
 581         char str[KSYM_SYMBOL_LEN];
 582         int ret = 0;
 583 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 584         static struct trace_seq s;
 585         unsigned long long avg;
 586         unsigned long long stddev;
 587 #endif
 588         mutex_lock(&ftrace_profile_lock);
 589
 590         /* we raced with function_profile_reset() */
 591         if (unlikely(rec->counter == 0)) {
 592                 ret = -EBUSY;
 593                 goto out;
 594         }
 595
 596         kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
 597         seq_printf(m, "  %-30.30s  %10lu", str, rec->counter);
 598
 599 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 600         seq_printf(m, "    ");
 601         avg = rec->time;
 602         do_div(avg, rec->counter);
 603
 604         /* Sample standard deviation (s^2) */
 605         if (rec->counter <= 1)
 606                 stddev = 0;
 607         else {
 608                 stddev = rec->time_squared - rec->counter * avg * avg;
 609                 /*
 610                  * Divide only 1000 for ns^2 -> us^2 conversion.
 611                  * trace_print_graph_duration will divide 1000 again.
 612                  */
 613                 do_div(stddev, (rec->counter - 1) * 1000);
 614         }
 615
 616         trace_seq_init(&s);
 617         trace_print_graph_duration(rec->time, &s);
 618         trace_seq_puts(&s, "    ");
 619         trace_print_graph_duration(avg, &s);
 620         trace_seq_puts(&s, "    ");
 621         trace_print_graph_duration(stddev, &s);
 622         trace_print_seq(m, &s);
 623 #endif
 624         seq_putc(m, '\n');
 625 out:
 626         mutex_unlock(&ftrace_profile_lock);
 627
 628         return ret;
 629 }
 630
 631 static void ftrace_profile_reset(struct ftrace_profile_stat *stat)
 632 {
 633         struct ftrace_profile_page *pg;
 634
 635         pg = stat->pages = stat->start;
 636
 637         while (pg) {
 638                 memset(pg->records, 0, PROFILE_RECORDS_SIZE);
 639                 pg->index = 0;
 640                 pg = pg->next;
 641         }
 642
 643         memset(stat->hash, 0,
 644                FTRACE_PROFILE_HASH_SIZE * sizeof(struct hlist_head));
 645 }
 646
 647 int ftrace_profile_pages_init(struct ftrace_profile_stat *stat)
 648 {
 649         struct ftrace_profile_page *pg;
 650         int functions;
 651         int pages;
 652         int i;
 653
 654         /* If we already allocated, do nothing */
 655         if (stat->pages)
 656                 return 0;
 657
 658         stat->pages = (void *)get_zeroed_page(GFP_KERNEL);
 659         if (!stat->pages)
 660                 return -ENOMEM;
 661
 662 #ifdef CONFIG_DYNAMIC_FTRACE
 663         functions = ftrace_update_tot_cnt;
 664 #else
 665         /*
 666          * We do not know the number of functions that exist because
 667          * dynamic tracing is what counts them. With past experience
 668          * we have around 20K functions. That should be more than enough.
 669          * It is highly unlikely we will execute every function in
 670          * the kernel.
 671          */
 672         functions = 20000;
 673 #endif
 674
 675         pg = stat->start = stat->pages;
 676
 677         pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);
 678
 679         for (i = 0; i < pages; i++) {
 680                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
 681                 if (!pg->next)
 682                         goto out_free;
 683                 pg = pg->next;
 684         }
 685
 686         return 0;
 687
 688  out_free:
 689         pg = stat->start;
 690         while (pg) {
 691                 unsigned long tmp = (unsigned long)pg;
 692
 693                 pg = pg->next;
 694                 free_page(tmp);
 695         }
 696
 697         free_page((unsigned long)stat->pages);
 698         stat->pages = NULL;
 699         stat->start = NULL;
 700
 701         return -ENOMEM;
 702 }
 703
 704 static int ftrace_profile_init_cpu(int cpu)
 705 {
 706         struct ftrace_profile_stat *stat;
 707         int size;
 708
 709         stat = &per_cpu(ftrace_profile_stats, cpu);
 710
 711         if (stat->hash) {
 712                 /* If the profile is already created, simply reset it */
 713                 ftrace_profile_reset(stat);
 714                 return 0;
 715         }
 716
 717         /*
 718          * We are profiling all functions, but usually only a few thousand
 719          * functions are hit. We'll make a hash of 1024 items.
 720          */
 721         size = FTRACE_PROFILE_HASH_SIZE;
 722
 723         stat->hash = kzalloc(sizeof(struct hlist_head) * size, GFP_KERNEL);
 724
 725         if (!stat->hash)
 726                 return -ENOMEM;
 727
 728         if (!ftrace_profile_bits) {
 729                 size--;
 730
 731                 for (; size; size >>= 1)
 732                         ftrace_profile_bits++;
 733         }
 734
 735         /* Preallocate the function profiling pages */
 736         if (ftrace_profile_pages_init(stat) < 0) {
 737                 kfree(stat->hash);
 738                 stat->hash = NULL;
 739                 return -ENOMEM;
 740         }
 741
 742         return 0;
 743 }
 744
 745 static int ftrace_profile_init(void)
 746 {
 747         int cpu;
 748         int ret = 0;
 749
 750         for_each_online_cpu(cpu) {
 751                 ret = ftrace_profile_init_cpu(cpu);
 752                 if (ret)
 753                         break;
 754         }
 755
 756         return ret;
 757 }
 758
 759 /* interrupts must be disabled */
 760 static struct ftrace_profile *
 761 ftrace_find_profiled_func(struct ftrace_profile_stat *stat, unsigned long ip)
 762 {
 763         struct ftrace_profile *rec;
 764         struct hlist_head *hhd;
 765         struct hlist_node *n;
 766         unsigned long key;
 767
 768         key = hash_long(ip, ftrace_profile_bits);
 769         hhd = &stat->hash[key];
 770
 771         if (hlist_empty(hhd))
 772                 return NULL;
 773
 774         hlist_for_each_entry_rcu(rec, n, hhd, node) {
 775                 if (rec->ip == ip)
 776                         return rec;
 777         }
 778
 779         return NULL;
 780 }
 781
 782 static void ftrace_add_profile(struct ftrace_profile_stat *stat,
 783                                struct ftrace_profile *rec)
 784 {
 785         unsigned long key;
 786
 787         key = hash_long(rec->ip, ftrace_profile_bits);
 788         hlist_add_head_rcu(&rec->node, &stat->hash[key]);
 789 }
 790
 791 /*
 792  * The memory is already allocated, this simply finds a new record to use.
 793  */
 794 static struct ftrace_profile *
 795 ftrace_profile_alloc(struct ftrace_profile_stat *stat, unsigned long ip)
 796 {
 797         struct ftrace_profile *rec = NULL;
 798
 799         /* prevent recursion (from NMIs) */
 800         if (atomic_inc_return(&stat->disabled) != 1)
 801                 goto out;
 802
 803         /*
 804          * Try to find the function again since an NMI
 805          * could have added it
 806          */
 807         rec = ftrace_find_profiled_func(stat, ip);
 808         if (rec)
 809                 goto out;
 810
 811         if (stat->pages->index == PROFILES_PER_PAGE) {
 812                 if (!stat->pages->next)
 813                         goto out;
 814                 stat->pages = stat->pages->next;
 815         }
 816
 817         rec = &stat->pages->records[stat->pages->index++];
 818         rec->ip = ip;
 819         ftrace_add_profile(stat, rec);
 820
 821  out:
 822         atomic_dec(&stat->disabled);
 823
 824         return rec;
 825 }
 826
 827 static void
 828 function_profile_call(unsigned long ip, unsigned long parent_ip,
 829                       struct ftrace_ops *ops, struct pt_regs *regs)
 830 {
 831         struct ftrace_profile_stat *stat;
 832         struct ftrace_profile *rec;
 833         unsigned long flags;
 834
 835         if (!ftrace_profile_enabled)
 836                 return;
 837
 838         local_irq_save(flags);
 839
 840         stat = &__get_cpu_var(ftrace_profile_stats);
 841         if (!stat->hash || !ftrace_profile_enabled)
 842                 goto out;
 843
 844         rec = ftrace_find_profiled_func(stat, ip);
 845         if (!rec) {
 846                 rec = ftrace_profile_alloc(stat, ip);
 847                 if (!rec)
 848                         goto out;
 849         }
 850
 851         rec->counter++;
 852  out:
 853         local_irq_restore(flags);
 854 }
 855
 856 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 857 static int profile_graph_entry(struct ftrace_graph_ent *trace)
 858 {
 859         function_profile_call(trace->func, 0, NULL, NULL);
 860         return 1;
 861 }
 862
 863 static void profile_graph_return(struct ftrace_graph_ret *trace)
 864 {
 865         struct ftrace_profile_stat *stat;
 866         unsigned long long calltime;
 867         struct ftrace_profile *rec;
 868         unsigned long flags;
 869
 870         local_irq_save(flags);
 871         stat = &__get_cpu_var(ftrace_profile_stats);
 872         if (!stat->hash || !ftrace_profile_enabled)
 873                 goto out;
 874
 875         /* If the calltime was zero'd ignore it */
 876         if (!trace->calltime)
 877                 goto out;
 878
 879         calltime = trace->rettime - trace->calltime;
 880
 881         if (!(trace_flags & TRACE_ITER_GRAPH_TIME)) {
 882                 int index;
 883
 884                 index = trace->depth;
 885
 886                 /* Append this call time to the parent time to subtract */
 887                 if (index)
 888                         current->ret_stack[index - 1].subtime += calltime;
 889
 890                 if (current->ret_stack[index].subtime < calltime)
 891                         calltime -= current->ret_stack[index].subtime;
 892                 else
 893                         calltime = 0;
 894         }
 895
 896         rec = ftrace_find_profiled_func(stat, trace->func);
 897         if (rec) {
 898                 rec->time += calltime;
 899                 rec->time_squared += calltime * calltime;
 900         }
 901
 902  out:
 903         local_irq_restore(flags);
 904 }
 905
 906 static int register_ftrace_profiler(void)
 907 {
 908         return register_ftrace_graph(&profile_graph_return,
 909                                      &profile_graph_entry);
 910 }
 911
 912 static void unregister_ftrace_profiler(void)
 913 {
 914         unregister_ftrace_graph();
 915 }
 916 #else
 917 static struct ftrace_ops ftrace_profile_ops __read_mostly = {
 918         .func           = function_profile_call,
 919         .flags          = FTRACE_OPS_FL_RECURSION_SAFE,
 920 };
 921
 922 static int register_ftrace_profiler(void)
 923 {
 924         return register_ftrace_function(&ftrace_profile_ops);
 925 }
 926
 927 static void unregister_ftrace_profiler(void)
 928 {
 929         unregister_ftrace_function(&ftrace_profile_ops);
 930 }
 931 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 932
 933 static ssize_t
 934 ftrace_profile_write(struct file *filp, const char __user *ubuf,
 935                      size_t cnt, loff_t *ppos)
 936 {
 937         unsigned long val;
 938         int ret;
 939
 940         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
 941         if (ret)
 942                 return ret;
 943
 944         val = !!val;
 945
 946         mutex_lock(&ftrace_profile_lock);
 947         if (ftrace_profile_enabled ^ val) {
 948                 if (val) {
 949                         ret = ftrace_profile_init();
 950                         if (ret < 0) {
 951                                 cnt = ret;
 952                                 goto out;
 953                         }
 954
 955                         ret = register_ftrace_profiler();
 956                         if (ret < 0) {
 957                                 cnt = ret;
 958                                 goto out;
 959                         }
 960                         ftrace_profile_enabled = 1;
 961                 } else {
 962                         ftrace_profile_enabled = 0;
 963                         /*
 964                          * unregister_ftrace_profiler calls stop_machine
 965                          * so this acts like an synchronize_sched.
 966                          */
 967                         unregister_ftrace_profiler();
 968                 }
 969         }
 970  out:
 971         mutex_unlock(&ftrace_profile_lock);
 972
 973         *ppos += cnt;
 974
 975         return cnt;
 976 }
 977
 978 static ssize_t
 979 ftrace_profile_read(struct file *filp, char __user *ubuf,
 980                      size_t cnt, loff_t *ppos)
 981 {
 982         char buf[64];           /* big enough to hold a number */
 983         int r;
 984
 985         r = sprintf(buf, "%u\n", ftrace_profile_enabled);
 986         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 987 }
 988
 989 static const struct file_operations ftrace_profile_fops = {
 990         .open           = tracing_open_generic,
 991         .read           = ftrace_profile_read,
 992         .write          = ftrace_profile_write,
 993         .llseek         = default_llseek,
 994 };
 995
 996 /* used to initialize the real stat files */
 997 static struct tracer_stat function_stats __initdata = {
 998         .name           = "functions",
 999         .stat_start     = function_stat_start,
1000         .stat_next      = function_stat_next,
1001         .stat_cmp       = function_stat_cmp,
1002         .stat_headers   = function_stat_headers,
1003         .stat_show      = function_stat_show
1004 };
1005
1006 static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
1007 {
1008         struct ftrace_profile_stat *stat;
1009         struct dentry *entry;
1010         char *name;
1011         int ret;
1012         int cpu;
1013
1014         for_each_possible_cpu(cpu) {
1015                 stat = &per_cpu(ftrace_profile_stats, cpu);
1016
1017                 /* allocate enough for function name + cpu number */
1018                 name = kmalloc(32, GFP_KERNEL);
1019                 if (!name) {
1020                         /*
1021                          * The files created are permanent, if something happens
1022                          * we still do not free memory.
1023                          */
1024                         WARN(1,
1025                              "Could not allocate stat file for cpu %d\n",
1026                              cpu);
1027                         return;
1028                 }
1029                 stat->stat = function_stats;
1030                 snprintf(name, 32, "function%d", cpu);
1031                 stat->stat.name = name;
1032                 ret = register_stat_tracer(&stat->stat);
1033                 if (ret) {
1034                         WARN(1,
1035                              "Could not register function stat for cpu %d\n",
1036                              cpu);
1037                         kfree(name);
1038                         return;
1039                 }
1040         }
1041
1042         entry = debugfs_create_file("function_profile_enabled", 0644,
1043                                     d_tracer, NULL, &ftrace_profile_fops);
1044         if (!entry)
1045                 pr_warning("Could not create debugfs "
1046                            "'function_profile_enabled' entry\n");
1047 }
1048
1049 #else /* CONFIG_FUNCTION_PROFILER */
1050 static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
1051 {
1052 }
1053 #endif /* CONFIG_FUNCTION_PROFILER */
1054
1055 static struct pid * const ftrace_swapper_pid = &init_struct_pid;
1056
1057 #ifdef CONFIG_DYNAMIC_FTRACE
1058
1059 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
1060 # error Dynamic ftrace depends on MCOUNT_RECORD
1061 #endif
1062
1063 static struct hlist_head ftrace_func_hash[FTRACE_FUNC_HASHSIZE] __read_mostly;
1064
1065 struct ftrace_func_probe {
1066         struct hlist_node       node;
1067         struct ftrace_probe_ops *ops;
1068         unsigned long           flags;
1069         unsigned long           ip;
1070         void                    *data;
1071         struct rcu_head         rcu;
1072 };
1073
1074 struct ftrace_func_entry {
1075         struct hlist_node hlist;
1076         unsigned long ip;
1077 };
1078
1079 struct ftrace_hash {
1080         unsigned long           size_bits;
1081         struct hlist_head       *buckets;
1082         unsigned long           count;
1083         struct rcu_head         rcu;
1084 };
1085
1086 /*
1087  * We make these constant because no one should touch them,
1088  * but they are used as the default "empty hash", to avoid allocating
1089  * it all the time. These are in a read only section such that if
1090  * anyone does try to modify it, it will cause an exception.
1091  */
1092 static const struct hlist_head empty_buckets[1];
1093 static const struct ftrace_hash empty_hash = {
1094         .buckets = (struct hlist_head *)empty_buckets,
1095 };
1096 #define EMPTY_HASH      ((struct ftrace_hash *)&empty_hash)
1097
1098 static struct ftrace_ops global_ops = {
1099         .func                   = ftrace_stub,
1100         .notrace_hash           = EMPTY_HASH,
1101         .filter_hash            = EMPTY_HASH,
1102         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
1103 };
1104
1105 static DEFINE_MUTEX(ftrace_regex_lock);
1106
1107 struct ftrace_page {
1108         struct ftrace_page      *next;
1109         struct dyn_ftrace       *records;
1110         int                     index;
1111         int                     size;
1112 };
1113
1114 static struct ftrace_page *ftrace_new_pgs;
1115
1116 #define ENTRY_SIZE sizeof(struct dyn_ftrace)
1117 #define ENTRIES_PER_PAGE (PAGE_SIZE / ENTRY_SIZE)
1118
1119 /* estimate from running different kernels */
1120 #define NR_TO_INIT              10000
1121
1122 static struct ftrace_page       *ftrace_pages_start;
1123 static struct ftrace_page       *ftrace_pages;
1124
1125 static bool ftrace_hash_empty(struct ftrace_hash *hash)
1126 {
1127         return !hash || !hash->count;
1128 }
1129
1130 static struct ftrace_func_entry *
1131 ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1132 {
1133         unsigned long key;
1134         struct ftrace_func_entry *entry;
1135         struct hlist_head *hhd;
1136         struct hlist_node *n;
1137
1138         if (ftrace_hash_empty(hash))
1139                 return NULL;
1140
1141         if (hash->size_bits > 0)
1142                 key = hash_long(ip, hash->size_bits);
1143         else
1144                 key = 0;
1145
1146         hhd = &hash->buckets[key];
1147
1148         hlist_for_each_entry_rcu(entry, n, hhd, hlist) {
1149                 if (entry->ip == ip)
1150                         return entry;
1151         }
1152         return NULL;
1153 }
1154
1155 static void __add_hash_entry(struct ftrace_hash *hash,
1156                              struct ftrace_func_entry *entry)
1157 {
1158         struct hlist_head *hhd;
1159         unsigned long key;
1160
1161         if (hash->size_bits)
1162                 key = hash_long(entry->ip, hash->size_bits);
1163         else
1164                 key = 0;
1165
1166         hhd = &hash->buckets[key];
1167         hlist_add_head(&entry->hlist, hhd);
1168         hash->count++;
1169 }
1170
1171 static int add_hash_entry(struct ftrace_hash *hash, unsigned long ip)
1172 {
1173         struct ftrace_func_entry *entry;
1174
1175         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1176         if (!entry)
1177                 return -ENOMEM;
1178
1179         entry->ip = ip;
1180         __add_hash_entry(hash, entry);
1181
1182         return 0;
1183 }
1184
1185 static void
1186 free_hash_entry(struct ftrace_hash *hash,
1187                   struct ftrace_func_entry *entry)
1188 {
1189         hlist_del(&entry->hlist);
1190         kfree(entry);
1191         hash->count--;
1192 }
1193
1194 static void
1195 remove_hash_entry(struct ftrace_hash *hash,
1196                   struct ftrace_func_entry *entry)
1197 {
1198         hlist_del(&entry->hlist);
1199         hash->count--;
1200 }
1201
1202 static void ftrace_hash_clear(struct ftrace_hash *hash)
1203 {
1204         struct hlist_head *hhd;
1205         struct hlist_node *tp, *tn;
1206         struct ftrace_func_entry *entry;
1207         int size = 1 << hash->size_bits;
1208         int i;
1209
1210         if (!hash->count)
1211                 return;
1212
1213         for (i = 0; i < size; i++) {
1214                 hhd = &hash->buckets[i];
1215                 hlist_for_each_entry_safe(entry, tp, tn, hhd, hlist)
1216                         free_hash_entry(hash, entry);
1217         }
1218         FTRACE_WARN_ON(hash->count);
1219 }
1220
1221 static void free_ftrace_hash(struct ftrace_hash *hash)
1222 {
1223         if (!hash || hash == EMPTY_HASH)
1224                 return;
1225         ftrace_hash_clear(hash);
1226         kfree(hash->buckets);
1227         kfree(hash);
1228 }
1229
1230 static void __free_ftrace_hash_rcu(struct rcu_head *rcu)
1231 {
1232         struct ftrace_hash *hash;
1233
1234         hash = container_of(rcu, struct ftrace_hash, rcu);
1235         free_ftrace_hash(hash);
1236 }
1237
1238 static void free_ftrace_hash_rcu(struct ftrace_hash *hash)
1239 {
1240         if (!hash || hash == EMPTY_HASH)
1241                 return;
1242         call_rcu_sched(&hash->rcu, __free_ftrace_hash_rcu);
1243 }
1244
1245 void ftrace_free_filter(struct ftrace_ops *ops)
1246 {
1247         free_ftrace_hash(ops->filter_hash);
1248         free_ftrace_hash(ops->notrace_hash);
1249 }
1250
1251 static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
1252 {
1253         struct ftrace_hash *hash;
1254         int size;
1255
1256         hash = kzalloc(sizeof(*hash), GFP_KERNEL);
1257         if (!hash)
1258                 return NULL;
1259
1260         size = 1 << size_bits;
1261         hash->buckets = kcalloc(size, sizeof(*hash->buckets), GFP_KERNEL);
1262
1263         if (!hash->buckets) {
1264                 kfree(hash);
1265                 return NULL;
1266         }
1267
1268         hash->size_bits = size_bits;
1269
1270         return hash;
1271 }
1272
1273 static struct ftrace_hash *
1274 alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
1275 {
1276         struct ftrace_func_entry *entry;
1277         struct ftrace_hash *new_hash;
1278         struct hlist_node *tp;
1279         int size;
1280         int ret;
1281         int i;
1282
1283         new_hash = alloc_ftrace_hash(size_bits);
1284         if (!new_hash)
1285                 return NULL;
1286
1287         /* Empty hash? */
1288         if (ftrace_hash_empty(hash))
1289                 return new_hash;
1290
1291         size = 1 << hash->size_bits;
1292         for (i = 0; i < size; i++) {
1293                 hlist_for_each_entry(entry, tp, &hash->buckets[i], hlist) {
1294                         ret = add_hash_entry(new_hash, entry->ip);
1295                         if (ret < 0)
1296                                 goto free_hash;
1297                 }
1298         }
1299
1300         FTRACE_WARN_ON(new_hash->count != hash->count);
1301
1302         return new_hash;
1303
1304  free_hash:
1305         free_ftrace_hash(new_hash);
1306         return NULL;
1307 }
1308
1309 static void
1310 ftrace_hash_rec_disable(struct ftrace_ops *ops, int filter_hash);
1311 static void
1312 ftrace_hash_rec_enable(struct ftrace_ops *ops, int filter_hash);
1313
1314 static int
1315 ftrace_hash_move(struct ftrace_ops *ops, int enable,
1316                  struct ftrace_hash **dst, struct ftrace_hash *src)
1317 {
1318         struct ftrace_func_entry *entry;
1319         struct hlist_node *tp, *tn;
1320         struct hlist_head *hhd;
1321         struct ftrace_hash *old_hash;
1322         struct ftrace_hash *new_hash;
1323         unsigned long key;
1324         int size = src->count;
1325         int bits = 0;
1326         int ret;
1327         int i;
1328
1329         /*
1330          * Remove the current set, update the hash and add
1331          * them back.
1332          */
1333         ftrace_hash_rec_disable(ops, enable);
1334
1335         /*
1336          * If the new source is empty, just free dst and assign it
1337          * the empty_hash.
1338          */
1339         if (!src->count) {
1340                 free_ftrace_hash_rcu(*dst);
1341                 rcu_assign_pointer(*dst, EMPTY_HASH);
1342                 /* still need to update the function records */
1343                 ret = 0;
1344                 goto out;
1345         }
1346
1347         /*
1348          * Make the hash size about 1/2 the # found
1349          */
1350         for (size /= 2; size; size >>= 1)
1351                 bits++;
1352
1353         /* Don't allocate too much */
1354         if (bits > FTRACE_HASH_MAX_BITS)
1355                 bits = FTRACE_HASH_MAX_BITS;
1356
1357         ret = -ENOMEM;
1358         new_hash = alloc_ftrace_hash(bits);
1359         if (!new_hash)
1360                 goto out;
1361
1362         size = 1 << src->size_bits;
1363         for (i = 0; i < size; i++) {
1364                 hhd = &src->buckets[i];
1365                 hlist_for_each_entry_safe(entry, tp, tn, hhd, hlist) {
1366                         if (bits > 0)
1367                                 key = hash_long(entry->ip, bits);
1368                         else
1369                                 key = 0;
1370                         remove_hash_entry(src, entry);
1371                         __add_hash_entry(new_hash, entry);
1372                 }
1373         }
1374
1375         old_hash = *dst;
1376         rcu_assign_pointer(*dst, new_hash);
1377         free_ftrace_hash_rcu(old_hash);
1378
1379         ret = 0;
1380  out:
1381         /*
1382          * Enable regardless of ret:
1383          *  On success, we enable the new hash.
1384          *  On failure, we re-enable the original hash.
1385          */
1386         ftrace_hash_rec_enable(ops, enable);
1387
1388         return ret;
1389 }
1390
1391 /*
1392  * Test the hashes for this ops to see if we want to call
1393  * the ops->func or not.
1394  *
1395  * It's a match if the ip is in the ops->filter_hash or
1396  * the filter_hash does not exist or is empty,
1397  *  AND
1398  * the ip is not in the ops->notrace_hash.
1399  *
1400  * This needs to be called with preemption disabled as
1401  * the hashes are freed with call_rcu_sched().
1402  */
1403 static int
1404 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip)
1405 {
1406         struct ftrace_hash *filter_hash;
1407         struct ftrace_hash *notrace_hash;
1408         int ret;
1409
1410         filter_hash = rcu_dereference_raw(ops->filter_hash);
1411         notrace_hash = rcu_dereference_raw(ops->notrace_hash);
1412
1413         if ((ftrace_hash_empty(filter_hash) ||
1414              ftrace_lookup_ip(filter_hash, ip)) &&
1415             (ftrace_hash_empty(notrace_hash) ||
1416              !ftrace_lookup_ip(notrace_hash, ip)))
1417                 ret = 1;
1418         else
1419                 ret = 0;
1420
1421         return ret;
1422 }
1423
1424 /*
1425  * This is a double for. Do not use 'break' to break out of the loop,
1426  * you must use a goto.
1427  */
1428 #define do_for_each_ftrace_rec(pg, rec)                                 \
1429         for (pg = ftrace_pages_start; pg; pg = pg->next) {              \
1430                 int _____i;                                             \
1431                 for (_____i = 0; _____i < pg->index; _____i++) {        \
1432                         rec = &pg->records[_____i];
1433
1434 #define while_for_each_ftrace_rec()             \
1435                 }                               \
1436         }
1437
1438
1439 static int ftrace_cmp_recs(const void *a, const void *b)
1440 {
1441         const struct dyn_ftrace *key = a;
1442         const struct dyn_ftrace *rec = b;
1443
1444         if (key->flags < rec->ip)
1445                 return -1;
1446         if (key->ip >= rec->ip + MCOUNT_INSN_SIZE)
1447                 return 1;
1448         return 0;
1449 }
1450
1451 static unsigned long ftrace_location_range(unsigned long start, unsigned long end)
1452 {
1453         struct ftrace_page *pg;
1454         struct dyn_ftrace *rec;
1455         struct dyn_ftrace key;
1456
1457         key.ip = start;
1458         key.flags = end;        /* overload flags, as it is unsigned long */
1459
1460         for (pg = ftrace_pages_start; pg; pg = pg->next) {
1461                 if (end < pg->records[0].ip ||
1462                     start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
1463                         continue;
1464                 rec = bsearch(&key, pg->records, pg->index,
1465                               sizeof(struct dyn_ftrace),
1466                               ftrace_cmp_recs);
1467                 if (rec)
1468                         return rec->ip;
1469         }
1470
1471         return 0;
1472 }
1473
1474 /**
1475  * ftrace_location - return true if the ip giving is a traced location
1476  * @ip: the instruction pointer to check
1477  *
1478  * Returns rec->ip if @ip given is a pointer to a ftrace location.
1479  * That is, the instruction that is either a NOP or call to
1480  * the function tracer. It checks the ftrace internal tables to
1481  * determine if the address belongs or not.
1482  */
1483 unsigned long ftrace_location(unsigned long ip)
1484 {
1485         return ftrace_location_range(ip, ip);
1486 }
1487
1488 /**
1489  * ftrace_text_reserved - return true if range contains an ftrace location
1490  * @start: start of range to search
1491  * @end: end of range to search (inclusive). @end points to the last byte to check.
1492  *
1493  * Returns 1 if @start and @end contains a ftrace location.
1494  * That is, the instruction that is either a NOP or call to
1495  * the function tracer. It checks the ftrace internal tables to
1496  * determine if the address belongs or not.
1497  */
1498 int ftrace_text_reserved(void *start, void *end)
1499 {
1500         unsigned long ret;
1501
1502         ret = ftrace_location_range((unsigned long)start,
1503                                     (unsigned long)end);
1504
1505         return (int)!!ret;
1506 }
1507
1508 static void __ftrace_hash_rec_update(struct ftrace_ops *ops,
1509                                      int filter_hash,
1510                                      bool inc)
1511 {
1512         struct ftrace_hash *hash;
1513         struct ftrace_hash *other_hash;
1514         struct ftrace_page *pg;
1515         struct dyn_ftrace *rec;
1516         int count = 0;
1517         int all = 0;
1518
1519         /* Only update if the ops has been registered */
1520         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1521                 return;
1522
1523         /*
1524          * In the filter_hash case:
1525          *   If the count is zero, we update all records.
1526          *   Otherwise we just update the items in the hash.
1527          *
1528          * In the notrace_hash case:
1529          *   We enable the update in the hash.
1530          *   As disabling notrace means enabling the tracing,
1531          *   and enabling notrace means disabling, the inc variable
1532          *   gets inversed.
1533          */
1534         if (filter_hash) {
1535                 hash = ops->filter_hash;
1536                 other_hash = ops->notrace_hash;
1537                 if (ftrace_hash_empty(hash))
1538                         all = 1;
1539         } else {
1540                 inc = !inc;
1541                 hash = ops->notrace_hash;
1542                 other_hash = ops->filter_hash;
1543                 /*
1544                  * If the notrace hash has no items,
1545                  * then there's nothing to do.
1546                  */
1547                 if (ftrace_hash_empty(hash))
1548                         return;
1549         }
1550
1551         do_for_each_ftrace_rec(pg, rec) {
1552                 int in_other_hash = 0;
1553                 int in_hash = 0;
1554                 int match = 0;
1555
1556                 if (all) {
1557                         /*
1558                          * Only the filter_hash affects all records.
1559                          * Update if the record is not in the notrace hash.
1560                          */
1561                         if (!other_hash || !ftrace_lookup_ip(other_hash, rec->ip))
1562                                 match = 1;
1563                 } else {
1564                         in_hash = !!ftrace_lookup_ip(hash, rec->ip);
1565                         in_other_hash = !!ftrace_lookup_ip(other_hash, rec->ip);
1566
1567                         /*
1568                          *
1569                          */
1570                         if (filter_hash && in_hash && !in_other_hash)
1571                                 match = 1;
1572                         else if (!filter_hash && in_hash &&
1573                                  (in_other_hash || ftrace_hash_empty(other_hash)))
1574                                 match = 1;
1575                 }
1576                 if (!match)
1577                         continue;
1578
1579                 if (inc) {
1580                         rec->flags++;
1581                         if (FTRACE_WARN_ON((rec->flags & ~FTRACE_FL_MASK) == FTRACE_REF_MAX))
1582                                 return;
1583                         /*
1584                          * If any ops wants regs saved for this function
1585                          * then all ops will get saved regs.
1586                          */
1587                         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
1588                                 rec->flags |= FTRACE_FL_REGS;
1589                 } else {
1590                         if (FTRACE_WARN_ON((rec->flags & ~FTRACE_FL_MASK) == 0))
1591                                 return;
1592                         rec->flags--;
1593                 }
1594                 count++;
1595                 /* Shortcut, if we handled all records, we are done. */
1596                 if (!all && count == hash->count)
1597                         return;
1598         } while_for_each_ftrace_rec();
1599 }
1600
1601 static void ftrace_hash_rec_disable(struct ftrace_ops *ops,
1602                                     int filter_hash)
1603 {
1604         __ftrace_hash_rec_update(ops, filter_hash, 0);
1605 }
1606
1607 static void ftrace_hash_rec_enable(struct ftrace_ops *ops,
1608                                    int filter_hash)
1609 {
1610         __ftrace_hash_rec_update(ops, filter_hash, 1);
1611 }
1612
1613 static void print_ip_ins(const char *fmt, unsigned char *p)
1614 {
1615         int i;
1616
1617         printk(KERN_CONT "%s", fmt);
1618
1619         for (i = 0; i < MCOUNT_INSN_SIZE; i++)
1620                 printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
1621 }
1622
1623 /**
1624  * ftrace_bug - report and shutdown function tracer
1625  * @failed: The failed type (EFAULT, EINVAL, EPERM)
1626  * @ip: The address that failed
1627  *
1628  * The arch code that enables or disables the function tracing
1629  * can call ftrace_bug() when it has detected a problem in
1630  * modifying the code. @failed should be one of either:
1631  * EFAULT - if the problem happens on reading the @ip address
1632  * EINVAL - if what is read at @ip is not what was expected
1633  * EPERM - if the problem happens on writting to the @ip address
1634  */
1635 void ftrace_bug(int failed, unsigned long ip)
1636 {
1637         switch (failed) {
1638         case -EFAULT:
1639                 FTRACE_WARN_ON_ONCE(1);
1640                 pr_info("ftrace faulted on modifying ");
1641                 print_ip_sym(ip);
1642                 break;
1643         case -EINVAL:
1644                 FTRACE_WARN_ON_ONCE(1);
1645                 pr_info("ftrace failed to modify ");
1646                 print_ip_sym(ip);
1647                 print_ip_ins(" actual: ", (unsigned char *)ip);
1648                 printk(KERN_CONT "\n");
1649                 break;
1650         case -EPERM:
1651                 FTRACE_WARN_ON_ONCE(1);
1652                 pr_info("ftrace faulted on writing ");
1653                 print_ip_sym(ip);
1654                 break;
1655         default:
1656                 FTRACE_WARN_ON_ONCE(1);
1657                 pr_info("ftrace faulted on unknown error ");
1658                 print_ip_sym(ip);
1659         }
1660 }
1661
1662 static int ftrace_check_record(struct dyn_ftrace *rec, int enable, int update)
1663 {
1664         unsigned long flag = 0UL;
1665
1666         /*
1667          * If we are updating calls:
1668          *
1669          *   If the record has a ref count, then we need to enable it
1670          *   because someone is using it.
1671          *
1672          *   Otherwise we make sure its disabled.
1673          *
1674          * If we are disabling calls, then disable all records that
1675          * are enabled.
1676          */
1677         if (enable && (rec->flags & ~FTRACE_FL_MASK))
1678                 flag = FTRACE_FL_ENABLED;
1679
1680         /*
1681          * If enabling and the REGS flag does not match the REGS_EN, then
1682          * do not ignore this record. Set flags to fail the compare against
1683          * ENABLED.
1684          */
1685         if (flag &&
1686             (!(rec->flags & FTRACE_FL_REGS) != !(rec->flags & FTRACE_FL_REGS_EN)))
1687                 flag |= FTRACE_FL_REGS;
1688
1689         /* If the state of this record hasn't changed, then do nothing */
1690         if ((rec->flags & FTRACE_FL_ENABLED) == flag)
1691                 return FTRACE_UPDATE_IGNORE;
1692
1693         if (flag) {
1694                 /* Save off if rec is being enabled (for return value) */
1695                 flag ^= rec->flags & FTRACE_FL_ENABLED;
1696
1697                 if (update) {
1698                         rec->flags |= FTRACE_FL_ENABLED;
1699                         if (flag & FTRACE_FL_REGS) {
1700                                 if (rec->flags & FTRACE_FL_REGS)
1701                                         rec->flags |= FTRACE_FL_REGS_EN;
1702                                 else
1703                                         rec->flags &= ~FTRACE_FL_REGS_EN;
1704                         }
1705                 }
1706
1707                 /*
1708                  * If this record is being updated from a nop, then
1709                  *   return UPDATE_MAKE_CALL.
1710                  * Otherwise, if the EN flag is set, then return
1711                  *   UPDATE_MODIFY_CALL_REGS to tell the caller to convert
1712                  *   from the non-save regs, to a save regs function.
1713                  * Otherwise,
1714                  *   return UPDATE_MODIFY_CALL to tell the caller to convert
1715                  *   from the save regs, to a non-save regs function.
1716                  */
1717                 if (flag & FTRACE_FL_ENABLED)
1718                         return FTRACE_UPDATE_MAKE_CALL;
1719                 else if (rec->flags & FTRACE_FL_REGS_EN)
1720                         return FTRACE_UPDATE_MODIFY_CALL_REGS;
1721                 else
1722                         return FTRACE_UPDATE_MODIFY_CALL;
1723         }
1724
1725         if (update) {
1726                 /* If there's no more users, clear all flags */
1727                 if (!(rec->flags & ~FTRACE_FL_MASK))
1728                         rec->flags = 0;
1729                 else
1730                         /* Just disable the record (keep REGS state) */
1731                         rec->flags &= ~FTRACE_FL_ENABLED;
1732         }
1733
1734         return FTRACE_UPDATE_MAKE_NOP;
1735 }
1736
1737 /**
1738  * ftrace_update_record, set a record that now is tracing or not
1739  * @rec: the record to update
1740  * @enable: set to 1 if the record is tracing, zero to force disable
1741  *
1742  * The records that represent all functions that can be traced need
1743  * to be updated when tracing has been enabled.
1744  */
1745 int ftrace_update_record(struct dyn_ftrace *rec, int enable)
1746 {
1747         return ftrace_check_record(rec, enable, 1);
1748 }
1749
1750 /**
1751  * ftrace_test_record, check if the record has been enabled or not
1752  * @rec: the record to test
1753  * @enable: set to 1 to check if enabled, 0 if it is disabled
1754  *
1755  * The arch code may need to test if a record is already set to
1756  * tracing to determine how to modify the function code that it
1757  * represents.
1758  */
1759 int ftrace_test_record(struct dyn_ftrace *rec, int enable)
1760 {
1761         return ftrace_check_record(rec, enable, 0);
1762 }
1763
1764 static int
1765 __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
1766 {
1767         unsigned long ftrace_old_addr;
1768         unsigned long ftrace_addr;
1769         int ret;
1770
1771         ret = ftrace_update_record(rec, enable);
1772
1773         if (rec->flags & FTRACE_FL_REGS)
1774                 ftrace_addr = (unsigned long)FTRACE_REGS_ADDR;
1775         else
1776                 ftrace_addr = (unsigned long)FTRACE_ADDR;
1777
1778         switch (ret) {
1779         case FTRACE_UPDATE_IGNORE:
1780                 return 0;
1781
1782         case FTRACE_UPDATE_MAKE_CALL:
1783                 return ftrace_make_call(rec, ftrace_addr);
1784
1785         case FTRACE_UPDATE_MAKE_NOP:
1786                 return ftrace_make_nop(NULL, rec, ftrace_addr);
1787
1788         case FTRACE_UPDATE_MODIFY_CALL_REGS:
1789         case FTRACE_UPDATE_MODIFY_CALL:
1790                 if (rec->flags & FTRACE_FL_REGS)
1791                         ftrace_old_addr = (unsigned long)FTRACE_ADDR;
1792                 else
1793                         ftrace_old_addr = (unsigned long)FTRACE_REGS_ADDR;
1794
1795                 return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr);
1796         }
1797
1798         return -1; /* unknow ftrace bug */
1799 }
1800
1801 void __weak ftrace_replace_code(int enable)
1802 {
1803         struct dyn_ftrace *rec;
1804         struct ftrace_page *pg;
1805         int failed;
1806
1807         if (unlikely(ftrace_disabled))
1808                 return;
1809
1810         do_for_each_ftrace_rec(pg, rec) {
1811                 failed = __ftrace_replace_code(rec, enable);
1812                 if (failed) {
1813                         ftrace_bug(failed, rec->ip);
1814                         /* Stop processing */
1815                         return;
1816                 }
1817         } while_for_each_ftrace_rec();
1818 }
1819
1820 struct ftrace_rec_iter {
1821         struct ftrace_page      *pg;
1822         int                     index;
1823 };
1824
1825 /**
1826  * ftrace_rec_iter_start, start up iterating over traced functions
1827  *
1828  * Returns an iterator handle that is used to iterate over all
1829  * the records that represent address locations where functions
1830  * are traced.
1831  *
1832  * May return NULL if no records are available.
1833  */
1834 struct ftrace_rec_iter *ftrace_rec_iter_start(void)
1835 {
1836         /*
1837          * We only use a single iterator.
1838          * Protected by the ftrace_lock mutex.
1839          */
1840         static struct ftrace_rec_iter ftrace_rec_iter;
1841         struct ftrace_rec_iter *iter = &ftrace_rec_iter;
1842
1843         iter->pg = ftrace_pages_start;
1844         iter->index = 0;
1845
1846         /* Could have empty pages */
1847         while (iter->pg && !iter->pg->index)
1848                 iter->pg = iter->pg->next;
1849
1850         if (!iter->pg)
1851                 return NULL;
1852
1853         return iter;
1854 }
1855
1856 /**
1857  * ftrace_rec_iter_next, get the next record to process.
1858  * @iter: The handle to the iterator.
1859  *
1860  * Returns the next iterator after the given iterator @iter.
1861  */
1862 struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter)
1863 {
1864         iter->index++;
1865
1866         if (iter->index >= iter->pg->index) {
1867                 iter->pg = iter->pg->next;
1868                 iter->index = 0;
1869
1870                 /* Could have empty pages */
1871                 while (iter->pg && !iter->pg->index)
1872                         iter->pg = iter->pg->next;
1873         }
1874
1875         if (!iter->pg)
1876                 return NULL;
1877
1878         return iter;
1879 }
1880
1881 /**
1882  * ftrace_rec_iter_record, get the record at the iterator location
1883  * @iter: The current iterator location
1884  *
1885  * Returns the record that the current @iter is at.
1886  */
1887 struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)
1888 {
1889         return &iter->pg->records[iter->index];
1890 }
1891
1892 static int
1893 ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
1894 {
1895         unsigned long ip;
1896         int ret;
1897
1898         ip = rec->ip;
1899
1900         if (unlikely(ftrace_disabled))
1901                 return 0;
1902
1903         ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
1904         if (ret) {
1905                 ftrace_bug(ret, ip);
1906                 return 0;
1907         }
1908         return 1;
1909 }
1910
1911 /*
1912  * archs can override this function if they must do something
1913  * before the modifying code is performed.
1914  */
1915 int __weak ftrace_arch_code_modify_prepare(void)
1916 {
1917         return 0;
1918 }
1919
1920 /*
1921  * archs can override this function if they must do something
1922  * after the modifying code is performed.
1923  */
1924 int __weak ftrace_arch_code_modify_post_process(void)
1925 {
1926         return 0;
1927 }
1928
1929 void ftrace_modify_all_code(int command)
1930 {
1931         if (command & FTRACE_UPDATE_CALLS)
1932                 ftrace_replace_code(1);
1933         else if (command & FTRACE_DISABLE_CALLS)
1934                 ftrace_replace_code(0);
1935
1936         if (command & FTRACE_UPDATE_TRACE_FUNC)
1937                 ftrace_update_ftrace_func(ftrace_trace_function);
1938
1939         if (command & FTRACE_START_FUNC_RET)
1940                 ftrace_enable_ftrace_graph_caller();
1941         else if (command & FTRACE_STOP_FUNC_RET)
1942                 ftrace_disable_ftrace_graph_caller();
1943 }
1944
1945 static int __ftrace_modify_code(void *data)
1946 {
1947         int *command = data;
1948
1949         ftrace_modify_all_code(*command);
1950
1951         return 0;
1952 }
1953
1954 /**
1955  * ftrace_run_stop_machine, go back to the stop machine method
1956  * @command: The command to tell ftrace what to do
1957  *
1958  * If an arch needs to fall back to the stop machine method, the
1959  * it can call this function.
1960  */
1961 void ftrace_run_stop_machine(int command)
1962 {
1963         stop_machine(__ftrace_modify_code, &command, NULL);
1964 }
1965
1966 /**
1967  * arch_ftrace_update_code, modify the code to trace or not trace
1968  * @command: The command that needs to be done
1969  *
1970  * Archs can override this function if it does not need to
1971  * run stop_machine() to modify code.
1972  */
1973 void __weak arch_ftrace_update_code(int command)
1974 {
1975         ftrace_run_stop_machine(command);
1976 }
1977
1978 static void ftrace_run_update_code(int command)
1979 {
1980         int ret;
1981
1982         ret = ftrace_arch_code_modify_prepare();
1983         FTRACE_WARN_ON(ret);
1984         if (ret)
1985                 return;
1986         /*
1987          * Do not call function tracer while we update the code.
1988          * We are in stop machine.
1989          */
1990         function_trace_stop++;
1991
1992         /*
1993          * By default we use stop_machine() to modify the code.
1994          * But archs can do what ever they want as long as it
1995          * is safe. The stop_machine() is the safest, but also
1996          * produces the most overhead.
1997          */
1998         arch_ftrace_update_code(command);
1999
2000         function_trace_stop--;
2001
2002         ret = ftrace_arch_code_modify_post_process();
2003         FTRACE_WARN_ON(ret);
2004 }
2005
2006 static ftrace_func_t saved_ftrace_func;
2007 static int ftrace_start_up;
2008 static int global_start_up;
2009
2010 static void ftrace_startup_enable(int command)
2011 {
2012         if (saved_ftrace_func != ftrace_trace_function) {
2013                 saved_ftrace_func = ftrace_trace_function;
2014                 command |= FTRACE_UPDATE_TRACE_FUNC;
2015         }
2016
2017         if (!command || !ftrace_enabled)
2018                 return;
2019
2020         ftrace_run_update_code(command);
2021 }
2022
2023 static int ftrace_startup(struct ftrace_ops *ops, int command)
2024 {
2025         bool hash_enable = true;
2026
2027         if (unlikely(ftrace_disabled))
2028                 return -ENODEV;
2029
2030         ftrace_start_up++;
2031         command |= FTRACE_UPDATE_CALLS;
2032
2033         /* ops marked global share the filter hashes */
2034         if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
2035                 ops = &global_ops;
2036                 /* Don't update hash if global is already set */
2037                 if (global_start_up)
2038                         hash_enable = false;
2039                 global_start_up++;
2040         }
2041
2042         ops->flags |= FTRACE_OPS_FL_ENABLED;
2043         if (hash_enable)
2044                 ftrace_hash_rec_enable(ops, 1);
2045
2046         ftrace_startup_enable(command);
2047
2048         return 0;
2049 }
2050
2051 static void ftrace_shutdown(struct ftrace_ops *ops, int command)
2052 {
2053         bool hash_disable = true;
2054
2055         if (unlikely(ftrace_disabled))
2056                 return;
2057
2058         ftrace_start_up--;
2059         /*
2060          * Just warn in case of unbalance, no need to kill ftrace, it's not
2061          * critical but the ftrace_call callers may be never nopped again after
2062          * further ftrace uses.
2063          */
2064         WARN_ON_ONCE(ftrace_start_up < 0);
2065
2066         if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
2067                 ops = &global_ops;
2068                 global_start_up--;
2069                 WARN_ON_ONCE(global_start_up < 0);
2070                 /* Don't update hash if global still has users */
2071                 if (global_start_up) {
2072                         WARN_ON_ONCE(!ftrace_start_up);
2073                         hash_disable = false;
2074                 }
2075         }
2076
2077         if (hash_disable)
2078                 ftrace_hash_rec_disable(ops, 1);
2079
2080         if (ops != &global_ops || !global_start_up)
2081                 ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2082
2083         command |= FTRACE_UPDATE_CALLS;
2084
2085         if (saved_ftrace_func != ftrace_trace_function) {
2086                 saved_ftrace_func = ftrace_trace_function;
2087                 command |= FTRACE_UPDATE_TRACE_FUNC;
2088         }
2089
2090         if (!command || !ftrace_enabled)
2091                 return;
2092
2093         ftrace_run_update_code(command);
2094 }
2095
2096 static void ftrace_startup_sysctl(void)
2097 {
2098         if (unlikely(ftrace_disabled))
2099                 return;
2100
2101         /* Force update next time */
2102         saved_ftrace_func = NULL;
2103         /* ftrace_start_up is true if we want ftrace running */
2104         if (ftrace_start_up)
2105                 ftrace_run_update_code(FTRACE_UPDATE_CALLS);
2106 }
2107
2108 static void ftrace_shutdown_sysctl(void)
2109 {
2110         if (unlikely(ftrace_disabled))
2111                 return;
2112
2113         /* ftrace_start_up is true if ftrace is running */
2114         if (ftrace_start_up)
2115                 ftrace_run_update_code(FTRACE_DISABLE_CALLS);
2116 }
2117
2118 static cycle_t          ftrace_update_time;
2119 static unsigned long    ftrace_update_cnt;
2120 unsigned long           ftrace_update_tot_cnt;
2121
2122 static int ops_traces_mod(struct ftrace_ops *ops)
2123 {
2124         struct ftrace_hash *hash;
2125
2126         hash = ops->filter_hash;
2127         return ftrace_hash_empty(hash);
2128 }
2129
2130 static int ftrace_update_code(struct module *mod)
2131 {
2132         struct ftrace_page *pg;
2133         struct dyn_ftrace *p;
2134         cycle_t start, stop;
2135         unsigned long ref = 0;
2136         int i;
2137
2138         /*
2139          * When adding a module, we need to check if tracers are
2140          * currently enabled and if they are set to trace all functions.
2141          * If they are, we need to enable the module functions as well
2142          * as update the reference counts for those function records.
2143          */
2144         if (mod) {
2145                 struct ftrace_ops *ops;
2146
2147                 for (ops = ftrace_ops_list;
2148                      ops != &ftrace_list_end; ops = ops->next) {
2149                         if (ops->flags & FTRACE_OPS_FL_ENABLED &&
2150                             ops_traces_mod(ops))
2151                                 ref++;
2152                 }
2153         }
2154
2155         start = ftrace_now(raw_smp_processor_id());
2156         ftrace_update_cnt = 0;
2157
2158         for (pg = ftrace_new_pgs; pg; pg = pg->next) {
2159
2160                 for (i = 0; i < pg->index; i++) {
2161                         /* If something went wrong, bail without enabling anything */
2162                         if (unlikely(ftrace_disabled))
2163                                 return -1;
2164
2165                         p = &pg->records[i];
2166                         p->flags = ref;
2167
2168                         /*
2169                          * Do the initial record conversion from mcount jump
2170                          * to the NOP instructions.
2171                          */
2172                         if (!ftrace_code_disable(mod, p))
2173                                 break;
2174
2175                         ftrace_update_cnt++;
2176
2177                         /*
2178                          * If the tracing is enabled, go ahead and enable the record.
2179                          *
2180                          * The reason not to enable the record immediatelly is the
2181                          * inherent check of ftrace_make_nop/ftrace_make_call for
2182                          * correct previous instructions.  Making first the NOP
2183                          * conversion puts the module to the correct state, thus
2184                          * passing the ftrace_make_call check.
2185                          */
2186                         if (ftrace_start_up && ref) {
2187                                 int failed = __ftrace_replace_code(p, 1);
2188                                 if (failed)
2189                                         ftrace_bug(failed, p->ip);
2190                         }
2191                 }
2192         }
2193
2194         ftrace_new_pgs = NULL;
2195
2196         stop = ftrace_now(raw_smp_processor_id());
2197         ftrace_update_time = stop - start;
2198         ftrace_update_tot_cnt += ftrace_update_cnt;
2199
2200         return 0;
2201 }
2202
2203 static int ftrace_allocate_records(struct ftrace_page *pg, int count)
2204 {
2205         int order;
2206         int cnt;
2207
2208         if (WARN_ON(!count))
2209                 return -EINVAL;
2210
2211         order = get_count_order(DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
2212
2213         /*
2214          * We want to fill as much as possible. No more than a page
2215          * may be empty.
2216          */
2217         while ((PAGE_SIZE << order) / ENTRY_SIZE >= count + ENTRIES_PER_PAGE)
2218                 order--;
2219
2220  again:
2221         pg->records = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
2222
2223         if (!pg->records) {
2224                 /* if we can't allocate this size, try something smaller */
2225                 if (!order)
2226                         return -ENOMEM;
2227                 order >>= 1;
2228                 goto again;
2229         }
2230
2231         cnt = (PAGE_SIZE << order) / ENTRY_SIZE;
2232         pg->size = cnt;
2233
2234         if (cnt > count)
2235                 cnt = count;
2236
2237         return cnt;
2238 }
2239
2240 static struct ftrace_page *
2241 ftrace_allocate_pages(unsigned long num_to_init)
2242 {
2243         struct ftrace_page *start_pg;
2244         struct ftrace_page *pg;
2245         int order;
2246         int cnt;
2247
2248         if (!num_to_init)
2249                 return 0;
2250
2251         start_pg = pg = kzalloc(sizeof(*pg), GFP_KERNEL);
2252         if (!pg)
2253                 return NULL;
2254
2255         /*
2256          * Try to allocate as much as possible in one continues
2257          * location that fills in all of the space. We want to
2258          * waste as little space as possible.
2259          */
2260         for (;;) {
2261                 cnt = ftrace_allocate_records(pg, num_to_init);
2262                 if (cnt < 0)
2263                         goto free_pages;
2264
2265                 num_to_init -= cnt;
2266                 if (!num_to_init)
2267                         break;
2268
2269                 pg->next = kzalloc(sizeof(*pg), GFP_KERNEL);
2270                 if (!pg->next)
2271                         goto free_pages;
2272
2273                 pg = pg->next;
2274         }
2275
2276         return start_pg;
2277
2278  free_pages:
2279         while (start_pg) {
2280                 order = get_count_order(pg->size / ENTRIES_PER_PAGE);
2281                 free_pages((unsigned long)pg->records, order);
2282                 start_pg = pg->next;
2283                 kfree(pg);
2284                 pg = start_pg;
2285         }
2286         pr_info("ftrace: FAILED to allocate memory for functions\n");
2287         return NULL;
2288 }
2289
2290 static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
2291 {
2292         int cnt;
2293
2294         if (!num_to_init) {
2295                 pr_info("ftrace: No functions to be traced?\n");
2296                 return -1;
2297         }
2298
2299         cnt = num_to_init / ENTRIES_PER_PAGE;
2300         pr_info("ftrace: allocating %ld entries in %d pages\n",
2301                 num_to_init, cnt + 1);
2302
2303         return 0;
2304 }
2305
2306 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
2307
2308 struct ftrace_iterator {
2309         loff_t                          pos;
2310         loff_t                          func_pos;
2311         struct ftrace_page              *pg;
2312         struct dyn_ftrace               *func;
2313         struct ftrace_func_probe        *probe;
2314         struct trace_parser             parser;
2315         struct ftrace_hash              *hash;
2316         struct ftrace_ops               *ops;
2317         int                             hidx;
2318         int                             idx;
2319         unsigned                        flags;
2320 };
2321
2322 static void *
2323 t_hash_next(struct seq_file *m, loff_t *pos)
2324 {
2325         struct ftrace_iterator *iter = m->private;
2326         struct hlist_node *hnd = NULL;
2327         struct hlist_head *hhd;
2328
2329         (*pos)++;
2330         iter->pos = *pos;
2331
2332         if (iter->probe)
2333                 hnd = &iter->probe->node;
2334  retry:
2335         if (iter->hidx >= FTRACE_FUNC_HASHSIZE)
2336                 return NULL;
2337
2338         hhd = &ftrace_func_hash[iter->hidx];
2339
2340         if (hlist_empty(hhd)) {
2341                 iter->hidx++;
2342                 hnd = NULL;
2343                 goto retry;
2344         }
2345
2346         if (!hnd)
2347                 hnd = hhd->first;
2348         else {
2349                 hnd = hnd->next;
2350                 if (!hnd) {
2351                         iter->hidx++;
2352                         goto retry;
2353                 }
2354         }
2355
2356         if (WARN_ON_ONCE(!hnd))
2357                 return NULL;
2358
2359         iter->probe = hlist_entry(hnd, struct ftrace_func_probe, node);
2360
2361         return iter;
2362 }
2363
2364 static void *t_hash_start(struct seq_file *m, loff_t *pos)
2365 {
2366         struct ftrace_iterator *iter = m->private;
2367         void *p = NULL;
2368         loff_t l;
2369
2370         if (!(iter->flags & FTRACE_ITER_DO_HASH))
2371                 return NULL;
2372
2373         if (iter->func_pos > *pos)
2374                 return NULL;
2375
2376         iter->hidx = 0;
2377         for (l = 0; l <= (*pos - iter->func_pos); ) {
2378                 p = t_hash_next(m, &l);
2379                 if (!p)
2380                         break;
2381         }
2382         if (!p)
2383                 return NULL;
2384
2385         /* Only set this if we have an item */
2386         iter->flags |= FTRACE_ITER_HASH;
2387
2388         return iter;
2389 }
2390
2391 static int
2392 t_hash_show(struct seq_file *m, struct ftrace_iterator *iter)
2393 {
2394         struct ftrace_func_probe *rec;
2395
2396         rec = iter->probe;
2397         if (WARN_ON_ONCE(!rec))
2398                 return -EIO;
2399
2400         if (rec->ops->print)
2401                 return rec->ops->print(m, rec->ip, rec->ops, rec->data);
2402
2403         seq_printf(m, "%ps:%ps", (void *)rec->ip, (void *)rec->ops->func);
2404
2405         if (rec->data)
2406                 seq_printf(m, ":%p", rec->data);
2407         seq_putc(m, '\n');
2408
2409         return 0;
2410 }
2411
2412 static void *
2413 t_next(struct seq_file *m, void *v, loff_t *pos)
2414 {
2415         struct ftrace_iterator *iter = m->private;
2416         struct ftrace_ops *ops = iter->ops;
2417         struct dyn_ftrace *rec = NULL;
2418
2419         if (unlikely(ftrace_disabled))
2420                 return NULL;
2421
2422         if (iter->flags & FTRACE_ITER_HASH)
2423                 return t_hash_next(m, pos);
2424
2425         (*pos)++;
2426         iter->pos = iter->func_pos = *pos;
2427
2428         if (iter->flags & FTRACE_ITER_PRINTALL)
2429                 return t_hash_start(m, pos);
2430
2431  retry:
2432         if (iter->idx >= iter->pg->index) {
2433                 if (iter->pg->next) {
2434                         iter->pg = iter->pg->next;
2435                         iter->idx = 0;
2436                         goto retry;
2437                 }
2438         } else {
2439                 rec = &iter->pg->records[iter->idx++];
2440                 if (((iter->flags & FTRACE_ITER_FILTER) &&
2441                      !(ftrace_lookup_ip(ops->filter_hash, rec->ip))) ||
2442
2443                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
2444                      !ftrace_lookup_ip(ops->notrace_hash, rec->ip)) ||
2445
2446                     ((iter->flags & FTRACE_ITER_ENABLED) &&
2447                      !(rec->flags & ~FTRACE_FL_MASK))) {
2448
2449                         rec = NULL;
2450                         goto retry;
2451                 }
2452         }
2453
2454         if (!rec)
2455                 return t_hash_start(m, pos);
2456
2457         iter->func = rec;
2458
2459         return iter;
2460 }
2461
2462 static void reset_iter_read(struct ftrace_iterator *iter)
2463 {
2464         iter->pos = 0;
2465         iter->func_pos = 0;
2466         iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_HASH);
2467 }
2468
2469 static void *t_start(struct seq_file *m, loff_t *pos)
2470 {
2471         struct ftrace_iterator *iter = m->private;
2472         struct ftrace_ops *ops = iter->ops;
2473         void *p = NULL;
2474         loff_t l;
2475
2476         mutex_lock(&ftrace_lock);
2477
2478         if (unlikely(ftrace_disabled))
2479                 return NULL;
2480
2481         /*
2482          * If an lseek was done, then reset and start from beginning.
2483          */
2484         if (*pos < iter->pos)
2485                 reset_iter_read(iter);
2486
2487         /*
2488          * For set_ftrace_filter reading, if we have the filter
2489          * off, we can short cut and just print out that all
2490          * functions are enabled.
2491          */
2492         if (iter->flags & FTRACE_ITER_FILTER &&
2493             ftrace_hash_empty(ops->filter_hash)) {
2494                 if (*pos > 0)
2495                         return t_hash_start(m, pos);
2496                 iter->flags |= FTRACE_ITER_PRINTALL;
2497                 /* reset in case of seek/pread */
2498                 iter->flags &= ~FTRACE_ITER_HASH;
2499                 return iter;
2500         }
2501
2502         if (iter->flags & FTRACE_ITER_HASH)
2503                 return t_hash_start(m, pos);
2504
2505         /*
2506          * Unfortunately, we need to restart at ftrace_pages_start
2507          * every time we let go of the ftrace_mutex. This is because
2508          * those pointers can change without the lock.
2509          */
2510         iter->pg = ftrace_pages_start;
2511         iter->idx = 0;
2512         for (l = 0; l <= *pos; ) {
2513                 p = t_next(m, p, &l);
2514                 if (!p)
2515                         break;
2516         }
2517
2518         if (!p)
2519                 return t_hash_start(m, pos);
2520
2521         return iter;
2522 }
2523
2524 static void t_stop(struct seq_file *m, void *p)
2525 {
2526         mutex_unlock(&ftrace_lock);
2527 }
2528
2529 static int t_show(struct seq_file *m, void *v)
2530 {
2531         struct ftrace_iterator *iter = m->private;
2532         struct dyn_ftrace *rec;
2533
2534         if (iter->flags & FTRACE_ITER_HASH)
2535                 return t_hash_show(m, iter);
2536
2537         if (iter->flags & FTRACE_ITER_PRINTALL) {
2538                 seq_printf(m, "#### all functions enabled ####\n");
2539                 return 0;
2540         }
2541
2542         rec = iter->func;
2543
2544         if (!rec)
2545                 return 0;
2546
2547         seq_printf(m, "%ps", (void *)rec->ip);
2548         if (iter->flags & FTRACE_ITER_ENABLED)
2549                 seq_printf(m, " (%ld)%s",
2550                            rec->flags & ~FTRACE_FL_MASK,
2551                            rec->flags & FTRACE_FL_REGS ? " R" : "");
2552         seq_printf(m, "\n");
2553
2554         return 0;
2555 }
2556
2557 static const struct seq_operations show_ftrace_seq_ops = {
2558         .start = t_start,
2559         .next = t_next,
2560         .stop = t_stop,
2561         .show = t_show,
2562 };
2563
2564 static int
2565 ftrace_avail_open(struct inode *inode, struct file *file)
2566 {
2567         struct ftrace_iterator *iter;
2568
2569         if (unlikely(ftrace_disabled))
2570                 return -ENODEV;
2571
2572         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
2573         if (iter) {
2574                 iter->pg = ftrace_pages_start;
2575                 iter->ops = &global_ops;
2576         }
2577
2578         return iter ? 0 : -ENOMEM;
2579 }
2580
2581 static int
2582 ftrace_enabled_open(struct inode *inode, struct file *file)
2583 {
2584         struct ftrace_iterator *iter;
2585
2586         if (unlikely(ftrace_disabled))
2587                 return -ENODEV;
2588
2589         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
2590         if (iter) {
2591                 iter->pg = ftrace_pages_start;
2592                 iter->flags = FTRACE_ITER_ENABLED;
2593                 iter->ops = &global_ops;
2594         }
2595
2596         return iter ? 0 : -ENOMEM;
2597 }
2598
2599 static void ftrace_filter_reset(struct ftrace_hash *hash)
2600 {
2601         mutex_lock(&ftrace_lock);
2602         ftrace_hash_clear(hash);
2603         mutex_unlock(&ftrace_lock);
2604 }
2605
2606 /**
2607  * ftrace_regex_open - initialize function tracer filter files
2608  * @ops: The ftrace_ops that hold the hash filters
2609  * @flag: The type of filter to process
2610  * @inode: The inode, usually passed in to your open routine
2611  * @file: The file, usually passed in to your open routine
2612  *
2613  * ftrace_regex_open() initializes the filter files for the
2614  * @ops. Depending on @flag it may process the filter hash or
2615  * the notrace hash of @ops. With this called from the open
2616  * routine, you can use ftrace_filter_write() for the write
2617  * routine if @flag has FTRACE_ITER_FILTER set, or
2618  * ftrace_notrace_write() if @flag has FTRACE_ITER_NOTRACE set.
2619  * ftrace_regex_lseek() should be used as the lseek routine, and
2620  * release must call ftrace_regex_release().
2621  */
2622 int
2623 ftrace_regex_open(struct ftrace_ops *ops, int flag,
2624                   struct inode *inode, struct file *file)
2625 {
2626         struct ftrace_iterator *iter;
2627         struct ftrace_hash *hash;
2628         int ret = 0;
2629
2630         if (unlikely(ftrace_disabled))
2631                 return -ENODEV;
2632
2633         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
2634         if (!iter)
2635                 return -ENOMEM;
2636
2637         if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) {
2638                 kfree(iter);
2639                 return -ENOMEM;
2640         }
2641
2642         if (flag & FTRACE_ITER_NOTRACE)
2643                 hash = ops->notrace_hash;
2644         else
2645                 hash = ops->filter_hash;
2646
2647         iter->ops = ops;
2648         iter->flags = flag;
2649
2650         if (file->f_mode & FMODE_WRITE) {
2651                 mutex_lock(&ftrace_lock);
2652                 iter->hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, hash);
2653                 mutex_unlock(&ftrace_lock);
2654
2655                 if (!iter->hash) {
2656                         trace_parser_put(&iter->parser);
2657                         kfree(iter);
2658                         return -ENOMEM;
2659                 }
2660         }
2661
2662         mutex_lock(&ftrace_regex_lock);
2663
2664         if ((file->f_mode & FMODE_WRITE) &&
2665             (file->f_flags & O_TRUNC))
2666                 ftrace_filter_reset(iter->hash);
2667
2668         if (file->f_mode & FMODE_READ) {
2669                 iter->pg = ftrace_pages_start;
2670
2671                 ret = seq_open(file, &show_ftrace_seq_ops);
2672                 if (!ret) {
2673                         struct seq_file *m = file->private_data;
2674                         m->private = iter;
2675                 } else {
2676                         /* Failed */
2677                         free_ftrace_hash(iter->hash);
2678                         trace_parser_put(&iter->parser);
2679                         kfree(iter);
2680                 }
2681         } else
2682                 file->private_data = iter;
2683         mutex_unlock(&ftrace_regex_lock);
2684
2685         return ret;
2686 }
2687
2688 static int
2689 ftrace_filter_open(struct inode *inode, struct file *file)
2690 {
2691         return ftrace_regex_open(&global_ops,
2692                         FTRACE_ITER_FILTER | FTRACE_ITER_DO_HASH,
2693                         inode, file);
2694 }
2695
2696 static int
2697 ftrace_notrace_open(struct inode *inode, struct file *file)
2698 {
2699         return ftrace_regex_open(&global_ops, FTRACE_ITER_NOTRACE,
2700                                  inode, file);
2701 }
2702
2703 loff_t
2704 ftrace_regex_lseek(struct file *file, loff_t offset, int whence)
2705 {
2706         loff_t ret;
2707
2708         if (file->f_mode & FMODE_READ)
2709                 ret = seq_lseek(file, offset, whence);
2710         else
2711                 file->f_pos = ret = 1;
2712
2713         return ret;
2714 }
2715
2716 static int ftrace_match(char *str, char *regex, int len, int type)
2717 {
2718         int matched = 0;
2719         int slen;
2720
2721         switch (type) {
2722         case MATCH_FULL:
2723                 if (strcmp(str, regex) == 0)
2724                         matched = 1;
2725                 break;
2726         case MATCH_FRONT_ONLY:
2727                 if (strncmp(str, regex, len) == 0)
2728                         matched = 1;
2729                 break;
2730         case MATCH_MIDDLE_ONLY:
2731                 if (strstr(str, regex))
2732                         matched = 1;
2733                 break;
2734         case MATCH_END_ONLY:
2735                 slen = strlen(str);
2736                 if (slen >= len && memcmp(str + slen - len, regex, len) == 0)
2737                         matched = 1;
2738                 break;
2739         }
2740
2741         return matched;
2742 }
2743
2744 static int
2745 enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int not)
2746 {
2747         struct ftrace_func_entry *entry;
2748         int ret = 0;
2749
2750         entry = ftrace_lookup_ip(hash, rec->ip);
2751         if (not) {
2752                 /* Do nothing if it doesn't exist */
2753                 if (!entry)
2754                         return 0;
2755
2756                 free_hash_entry(hash, entry);
2757         } else {
2758                 /* Do nothing if it exists */
2759                 if (entry)
2760                         return 0;
2761
2762                 ret = add_hash_entry(hash, rec->ip);
2763         }
2764         return ret;
2765 }
2766
2767 static int
2768 ftrace_match_record(struct dyn_ftrace *rec, char *mod,
2769                     char *regex, int len, int type)
2770 {
2771         char str[KSYM_SYMBOL_LEN];
2772         char *modname;
2773
2774         kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
2775
2776         if (mod) {
2777                 /* module lookup requires matching the module */
2778                 if (!modname || strcmp(modname, mod))
2779                         return 0;
2780
2781                 /* blank search means to match all funcs in the mod */
2782                 if (!len)
2783                         return 1;
2784         }
2785
2786         return ftrace_match(str, regex, len, type);
2787 }
2788
2789 static int
2790 match_records(struct ftrace_hash *hash, char *buff,
2791               int len, char *mod, int not)
2792 {
2793         unsigned search_len = 0;
2794         struct ftrace_page *pg;
2795         struct dyn_ftrace *rec;
2796         int type = MATCH_FULL;
2797         char *search = buff;
2798         int found = 0;
2799         int ret;
2800
2801         if (len) {
2802                 type = filter_parse_regex(buff, len, &search, &not);
2803                 search_len = strlen(search);
2804         }
2805
2806         mutex_lock(&ftrace_lock);
2807
2808         if (unlikely(ftrace_disabled))
2809                 goto out_unlock;
2810
2811         do_for_each_ftrace_rec(pg, rec) {
2812                 if (ftrace_match_record(rec, mod, search, search_len, type)) {
2813                         ret = enter_record(hash, rec, not);
2814                         if (ret < 0) {
2815                                 found = ret;
2816                                 goto out_unlock;
2817                         }
2818                         found = 1;
2819                 }
2820         } while_for_each_ftrace_rec();
2821  out_unlock:
2822         mutex_unlock(&ftrace_lock);
2823
2824         return found;
2825 }
2826
2827 static int
2828 ftrace_match_records(struct ftrace_hash *hash, char *buff, int len)
2829 {
2830         return match_records(hash, buff, len, NULL, 0);
2831 }
2832
2833 static int
2834 ftrace_match_module_records(struct ftrace_hash *hash, char *buff, char *mod)
2835 {
2836         int not = 0;
2837
2838         /* blank or '*' mean the same */
2839         if (strcmp(buff, "*") == 0)
2840                 buff[0] = 0;
2841
2842         /* handle the case of 'dont filter this module' */
2843         if (strcmp(buff, "!") == 0 || strcmp(buff, "!*") == 0) {
2844                 buff[0] = 0;
2845                 not = 1;
2846         }
2847
2848         return match_records(hash, buff, strlen(buff), mod, not);
2849 }
2850
2851 /*
2852  * We register the module command as a template to show others how
2853  * to register the a command as well.
2854  */
2855
2856 static int
2857 ftrace_mod_callback(struct ftrace_hash *hash,
2858                     char *func, char *cmd, char *param, int enable)
2859 {
2860         char *mod;
2861         int ret = -EINVAL;
2862
2863         /*
2864          * cmd == 'mod' because we only registered this func
2865          * for the 'mod' ftrace_func_command.
2866          * But if you register one func with multiple commands,
2867          * you can tell which command was used by the cmd
2868          * parameter.
2869          */
2870
2871         /* we must have a module name */
2872         if (!param)
2873                 return ret;
2874
2875         mod = strsep(&param, ":");
2876         if (!strlen(mod))
2877                 return ret;
2878
2879         ret = ftrace_match_module_records(hash, func, mod);
2880         if (!ret)
2881                 ret = -EINVAL;
2882         if (ret < 0)
2883                 return ret;
2884
2885         return 0;
2886 }
2887
2888 static struct ftrace_func_command ftrace_mod_cmd = {
2889         .name                   = "mod",
2890         .func                   = ftrace_mod_callback,
2891 };
2892
2893 static int __init ftrace_mod_cmd_init(void)
2894 {
2895         return register_ftrace_command(&ftrace_mod_cmd);
2896 }
2897 core_initcall(ftrace_mod_cmd_init);
2898
2899 static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip,
2900                                       struct ftrace_ops *op, struct pt_regs *pt_regs)
2901 {
2902         struct ftrace_func_probe *entry;
2903         struct hlist_head *hhd;
2904         struct hlist_node *n;
2905         unsigned long key;
2906
2907         key = hash_long(ip, FTRACE_HASH_BITS);
2908
2909         hhd = &ftrace_func_hash[key];
2910
2911         if (hlist_empty(hhd))
2912                 return;
2913
2914         /*
2915          * Disable preemption for these calls to prevent a RCU grace
2916          * period. This syncs the hash iteration and freeing of items
2917          * on the hash. rcu_read_lock is too dangerous here.
2918          */
2919         preempt_disable_notrace();
2920         hlist_for_each_entry_rcu(entry, n, hhd, node) {
2921                 if (entry->ip == ip)
2922                         entry->ops->func(ip, parent_ip, &entry->data);
2923         }
2924         preempt_enable_notrace();
2925 }
2926
2927 static struct ftrace_ops trace_probe_ops __read_mostly =
2928 {
2929         .func           = function_trace_probe_call,
2930 };
2931
2932 static int ftrace_probe_registered;
2933
2934 static void __enable_ftrace_function_probe(void)
2935 {
2936         int ret;
2937         int i;
2938
2939         if (ftrace_probe_registered)
2940                 return;
2941
2942         for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
2943                 struct hlist_head *hhd = &ftrace_func_hash[i];
2944                 if (hhd->first)
2945                         break;
2946         }
2947         /* Nothing registered? */
2948         if (i == FTRACE_FUNC_HASHSIZE)
2949                 return;
2950
2951         ret = __register_ftrace_function(&trace_probe_ops);
2952         if (!ret)
2953                 ret = ftrace_startup(&trace_probe_ops, 0);
2954
2955         ftrace_probe_registered = 1;
2956 }
2957
2958 static void __disable_ftrace_function_probe(void)
2959 {
2960         int ret;
2961         int i;
2962
2963         if (!ftrace_probe_registered)
2964                 return;
2965
2966         for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
2967                 struct hlist_head *hhd = &ftrace_func_hash[i];
2968                 if (hhd->first)
2969                         return;
2970         }
2971
2972         /* no more funcs left */
2973         ret = __unregister_ftrace_function(&trace_probe_ops);
2974         if (!ret)
2975                 ftrace_shutdown(&trace_probe_ops, 0);
2976
2977         ftrace_probe_registered = 0;
2978 }
2979
2980
2981 static void ftrace_free_entry_rcu(struct rcu_head *rhp)
2982 {
2983         struct ftrace_func_probe *entry =
2984                 container_of(rhp, struct ftrace_func_probe, rcu);
2985
2986         if (entry->ops->free)
2987                 entry->ops->free(&entry->data);
2988         kfree(entry);
2989 }
2990
2991
2992 int
2993 register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
2994                               void *data)
2995 {
2996         struct ftrace_func_probe *entry;
2997         struct ftrace_page *pg;
2998         struct dyn_ftrace *rec;
2999         int type, len, not;
3000         unsigned long key;
3001         int count = 0;
3002         char *search;
3003
3004         type = filter_parse_regex(glob, strlen(glob), &search, &not);
3005         len = strlen(search);
3006
3007         /* we do not support '!' for function probes */
3008         if (WARN_ON(not))
3009                 return -EINVAL;
3010
3011         mutex_lock(&ftrace_lock);
3012
3013         if (unlikely(ftrace_disabled))
3014                 goto out_unlock;
3015
3016         do_for_each_ftrace_rec(pg, rec) {
3017
3018                 if (!ftrace_match_record(rec, NULL, search, len, type))
3019                         continue;
3020
3021                 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
3022                 if (!entry) {
3023                         /* If we did not process any, then return error */
3024                         if (!count)
3025                                 count = -ENOMEM;
3026                         goto out_unlock;
3027                 }
3028
3029                 count++;
3030
3031                 entry->data = data;
3032
3033                 /*
3034                  * The caller might want to do something special
3035                  * for each function we find. We call the callback
3036                  * to give the caller an opportunity to do so.
3037                  */
3038                 if (ops->callback) {
3039                         if (ops->callback(rec->ip, &entry->data) < 0) {
3040                                 /* caller does not like this func */
3041                                 kfree(entry);
3042                                 continue;
3043                         }
3044                 }
3045
3046                 entry->ops = ops;
3047                 entry->ip = rec->ip;
3048
3049                 key = hash_long(entry->ip, FTRACE_HASH_BITS);
3050                 hlist_add_head_rcu(&entry->node, &ftrace_func_hash[key]);
3051
3052         } while_for_each_ftrace_rec();
3053         __enable_ftrace_function_probe();
3054
3055  out_unlock:
3056         mutex_unlock(&ftrace_lock);
3057
3058         return count;
3059 }
3060
3061 enum {
3062         PROBE_TEST_FUNC         = 1,
3063         PROBE_TEST_DATA         = 2
3064 };
3065
3066 static void
3067 __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
3068                                   void *data, int flags)
3069 {
3070         struct ftrace_func_probe *entry;
3071         struct hlist_node *n, *tmp;
3072         char str[KSYM_SYMBOL_LEN];
3073         int type = MATCH_FULL;
3074         int i, len = 0;
3075         char *search;
3076
3077         if (glob && (strcmp(glob, "*") == 0 || !strlen(glob)))
3078                 glob = NULL;
3079         else if (glob) {
3080                 int not;
3081
3082                 type = filter_parse_regex(glob, strlen(glob), &search, &not);
3083                 len = strlen(search);
3084
3085                 /* we do not support '!' for function probes */
3086                 if (WARN_ON(not))
3087                         return;
3088         }
3089
3090         mutex_lock(&ftrace_lock);
3091         for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
3092                 struct hlist_head *hhd = &ftrace_func_hash[i];
3093
3094                 hlist_for_each_entry_safe(entry, n, tmp, hhd, node) {
3095
3096                         /* break up if statements for readability */
3097                         if ((flags & PROBE_TEST_FUNC) && entry->ops != ops)
3098                                 continue;
3099
3100                         if ((flags & PROBE_TEST_DATA) && entry->data != data)
3101                                 continue;
3102
3103                         /* do this last, since it is the most expensive */
3104                         if (glob) {
3105                                 kallsyms_lookup(entry->ip, NULL, NULL,
3106                                                 NULL, str);
3107                                 if (!ftrace_match(str, glob, len, type))
3108                                         continue;
3109                         }
3110
3111                         hlist_del(&entry->node);
3112                         call_rcu(&entry->rcu, ftrace_free_entry_rcu);
3113                 }
3114         }
3115         __disable_ftrace_function_probe();
3116         mutex_unlock(&ftrace_lock);
3117 }
3118
3119 void
3120 unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
3121                                 void *data)
3122 {
3123         __unregister_ftrace_function_probe(glob, ops, data,
3124                                           PROBE_TEST_FUNC | PROBE_TEST_DATA);
3125 }
3126
3127 void
3128 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops)
3129 {
3130         __unregister_ftrace_function_probe(glob, ops, NULL, PROBE_TEST_FUNC);
3131 }
3132
3133 void unregister_ftrace_function_probe_all(char *glob)
3134 {
3135         __unregister_ftrace_function_probe(glob, NULL, NULL, 0);
3136 }
3137
3138 static LIST_HEAD(ftrace_commands);
3139 static DEFINE_MUTEX(ftrace_cmd_mutex);
3140
3141 int register_ftrace_command(struct ftrace_func_command *cmd)
3142 {
3143         struct ftrace_func_command *p;
3144         int ret = 0;
3145
3146         mutex_lock(&ftrace_cmd_mutex);
3147         list_for_each_entry(p, &ftrace_commands, list) {
3148                 if (strcmp(cmd->name, p->name) == 0) {
3149                         ret = -EBUSY;
3150                         goto out_unlock;
3151                 }
3152         }
3153         list_add(&cmd->list, &ftrace_commands);
3154  out_unlock:
3155         mutex_unlock(&ftrace_cmd_mutex);
3156
3157         return ret;
3158 }
3159
3160 int unregister_ftrace_command(struct ftrace_func_command *cmd)
3161 {
3162         struct ftrace_func_command *p, *n;
3163         int ret = -ENODEV;
3164
3165         mutex_lock(&ftrace_cmd_mutex);
3166         list_for_each_entry_safe(p, n, &ftrace_commands, list) {
3167                 if (strcmp(cmd->name, p->name) == 0) {
3168                         ret = 0;
3169                         list_del_init(&p->list);
3170                         goto out_unlock;
3171                 }
3172         }
3173  out_unlock:
3174         mutex_unlock(&ftrace_cmd_mutex);
3175
3176         return ret;
3177 }
3178
3179 static int ftrace_process_regex(struct ftrace_hash *hash,
3180                                 char *buff, int len, int enable)
3181 {
3182         char *func, *command, *next = buff;
3183         struct ftrace_func_command *p;
3184         int ret = -EINVAL;
3185
3186         func = strsep(&next, ":");
3187
3188         if (!next) {
3189                 ret = ftrace_match_records(hash, func, len);
3190                 if (!ret)
3191                         ret = -EINVAL;
3192                 if (ret < 0)
3193                         return ret;
3194                 return 0;
3195         }
3196
3197         /* command found */
3198
3199         command = strsep(&next, ":");
3200
3201         mutex_lock(&ftrace_cmd_mutex);
3202         list_for_each_entry(p, &ftrace_commands, list) {
3203                 if (strcmp(p->name, command) == 0) {
3204                         ret = p->func(hash, func, command, next, enable);
3205                         goto out_unlock;
3206                 }
3207         }
3208  out_unlock:
3209         mutex_unlock(&ftrace_cmd_mutex);
3210
3211         return ret;
3212 }
3213
3214 static ssize_t
3215 ftrace_regex_write(struct file *file, const char __user *ubuf,
3216                    size_t cnt, loff_t *ppos, int enable)
3217 {
3218         struct ftrace_iterator *iter;
3219         struct trace_parser *parser;
3220         ssize_t ret, read;
3221
3222         if (!cnt)
3223                 return 0;
3224
3225         mutex_lock(&ftrace_regex_lock);
3226
3227         ret = -ENODEV;
3228         if (unlikely(ftrace_disabled))
3229                 goto out_unlock;
3230
3231         if (file->f_mode & FMODE_READ) {
3232                 struct seq_file *m = file->private_data;
3233                 iter = m->private;
3234         } else
3235                 iter = file->private_data;
3236
3237         parser = &iter->parser;
3238         read = trace_get_user(parser, ubuf, cnt, ppos);
3239
3240         if (read >= 0 && trace_parser_loaded(parser) &&
3241             !trace_parser_cont(parser)) {
3242                 ret = ftrace_process_regex(iter->hash, parser->buffer,
3243                                            parser->idx, enable);
3244                 trace_parser_clear(parser);
3245                 if (ret)
3246                         goto out_unlock;
3247         }
3248
3249         ret = read;
3250 out_unlock:
3251         mutex_unlock(&ftrace_regex_lock);
3252
3253         return ret;
3254 }
3255
3256 ssize_t
3257 ftrace_filter_write(struct file *file, const char __user *ubuf,
3258                     size_t cnt, loff_t *ppos)
3259 {
3260         return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
3261 }
3262
3263 ssize_t
3264 ftrace_notrace_write(struct file *file, const char __user *ubuf,
3265                      size_t cnt, loff_t *ppos)
3266 {
3267         return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
3268 }
3269
3270 static int
3271 ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove)
3272 {
3273         struct ftrace_func_entry *entry;
3274
3275         if (!ftrace_location(ip))
3276                 return -EINVAL;
3277
3278         if (remove) {
3279                 entry = ftrace_lookup_ip(hash, ip);
3280                 if (!entry)
3281                         return -ENOENT;
3282                 free_hash_entry(hash, entry);
3283                 return 0;
3284         }
3285
3286         return add_hash_entry(hash, ip);
3287 }
3288
3289 static int
3290 ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
3291                 unsigned long ip, int remove, int reset, int enable)
3292 {
3293         struct ftrace_hash **orig_hash;
3294         struct ftrace_hash *hash;
3295         int ret;
3296
3297         /* All global ops uses the global ops filters */
3298         if (ops->flags & FTRACE_OPS_FL_GLOBAL)
3299                 ops = &global_ops;
3300
3301         if (unlikely(ftrace_disabled))
3302                 return -ENODEV;
3303
3304         if (enable)
3305                 orig_hash = &ops->filter_hash;
3306         else
3307                 orig_hash = &ops->notrace_hash;
3308
3309         hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
3310         if (!hash)
3311                 return -ENOMEM;
3312
3313         mutex_lock(&ftrace_regex_lock);
3314         if (reset)
3315                 ftrace_filter_reset(hash);
3316         if (buf && !ftrace_match_records(hash, buf, len)) {
3317                 ret = -EINVAL;
3318                 goto out_regex_unlock;
3319         }
3320         if (ip) {
3321                 ret = ftrace_match_addr(hash, ip, remove);
3322                 if (ret < 0)
3323                         goto out_regex_unlock;
3324         }
3325
3326         mutex_lock(&ftrace_lock);
3327         ret = ftrace_hash_move(ops, enable, orig_hash, hash);
3328         if (!ret && ops->flags & FTRACE_OPS_FL_ENABLED
3329             && ftrace_enabled)
3330                 ftrace_run_update_code(FTRACE_UPDATE_CALLS);
3331
3332         mutex_unlock(&ftrace_lock);
3333
3334  out_regex_unlock:
3335         mutex_unlock(&ftrace_regex_lock);
3336
3337         free_ftrace_hash(hash);
3338         return ret;
3339 }
3340
3341 static int
3342 ftrace_set_addr(struct ftrace_ops *ops, unsigned long ip, int remove,
3343                 int reset, int enable)
3344 {
3345         return ftrace_set_hash(ops, 0, 0, ip, remove, reset, enable);
3346 }
3347
3348 /**
3349  * ftrace_set_filter_ip - set a function to filter on in ftrace by address
3350  * @ops - the ops to set the filter with
3351  * @ip - the address to add to or remove from the filter.
3352  * @remove - non zero to remove the ip from the filter
3353  * @reset - non zero to reset all filters before applying this filter.
3354  *
3355  * Filters denote which functions should be enabled when tracing is enabled
3356  * If @ip is NULL, it failes to update filter.
3357  */
3358 int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
3359                          int remove, int reset)
3360 {
3361         return ftrace_set_addr(ops, ip, remove, reset, 1);
3362 }
3363 EXPORT_SYMBOL_GPL(ftrace_set_filter_ip);
3364
3365 static int
3366 ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
3367                  int reset, int enable)
3368 {
3369         return ftrace_set_hash(ops, buf, len, 0, 0, reset, enable);
3370 }
3371
3372 /**
3373  * ftrace_set_filter - set a function to filter on in ftrace
3374  * @ops - the ops to set the filter with
3375  * @buf - the string that holds the function filter text.
3376  * @len - the length of the string.
3377  * @reset - non zero to reset all filters before applying this filter.
3378  *
3379  * Filters denote which functions should be enabled when tracing is enabled.
3380  * If @buf is NULL and reset is set, all functions will be enabled for tracing.
3381  */
3382 int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
3383                        int len, int reset)
3384 {
3385         return ftrace_set_regex(ops, buf, len, reset, 1);
3386 }
3387 EXPORT_SYMBOL_GPL(ftrace_set_filter);
3388
3389 /**
3390  * ftrace_set_notrace - set a function to not trace in ftrace
3391  * @ops - the ops to set the notrace filter with
3392  * @buf - the string that holds the function notrace text.
3393  * @len - the length of the string.
3394  * @reset - non zero to reset all filters before applying this filter.
3395  *
3396  * Notrace Filters denote which functions should not be enabled when tracing
3397  * is enabled. If @buf is NULL and reset is set, all functions will be enabled
3398  * for tracing.
3399  */
3400 int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
3401                         int len, int reset)
3402 {
3403         return ftrace_set_regex(ops, buf, len, reset, 0);
3404 }
3405 EXPORT_SYMBOL_GPL(ftrace_set_notrace);
3406 /**
3407  * ftrace_set_filter - set a function to filter on in ftrace
3408  * @ops - the ops to set the filter with
3409  * @buf - the string that holds the function filter text.
3410  * @len - the length of the string.
3411  * @reset - non zero to reset all filters before applying this filter.
3412  *
3413  * Filters denote which functions should be enabled when tracing is enabled.
3414  * If @buf is NULL and reset is set, all functions will be enabled for tracing.
3415  */
3416 void ftrace_set_global_filter(unsigned char *buf, int len, int reset)
3417 {
3418         ftrace_set_regex(&global_ops, buf, len, reset, 1);
3419 }
3420 EXPORT_SYMBOL_GPL(ftrace_set_global_filter);
3421
3422 /**
3423  * ftrace_set_notrace - set a function to not trace in ftrace
3424  * @ops - the ops to set the notrace filter with
3425  * @buf - the string that holds the function notrace text.
3426  * @len - the length of the string.
3427  * @reset - non zero to reset all filters before applying this filter.
3428  *
3429  * Notrace Filters denote which functions should not be enabled when tracing
3430  * is enabled. If @buf is NULL and reset is set, all functions will be enabled
3431  * for tracing.
3432  */
3433 void ftrace_set_global_notrace(unsigned char *buf, int len, int reset)
3434 {
3435         ftrace_set_regex(&global_ops, buf, len, reset, 0);
3436 }
3437 EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
3438
3439 /*
3440  * command line interface to allow users to set filters on boot up.
3441  */
3442 #define FTRACE_FILTER_SIZE              COMMAND_LINE_SIZE
3443 static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
3444 static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
3445
3446 static int __init set_ftrace_notrace(char *str)
3447 {
3448         strncpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
3449         return 1;
3450 }
3451 __setup("ftrace_notrace=", set_ftrace_notrace);
3452
3453 static int __init set_ftrace_filter(char *str)
3454 {
3455         strncpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
3456         return 1;
3457 }
3458 __setup("ftrace_filter=", set_ftrace_filter);
3459
3460 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3461 static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
3462 static int ftrace_set_func(unsigned long *array, int *idx, char *buffer);
3463
3464 static int __init set_graph_function(char *str)
3465 {
3466         strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
3467         return 1;
3468 }
3469 __setup("ftrace_graph_filter=", set_graph_function);
3470
3471 static void __init set_ftrace_early_graph(char *buf)
3472 {
3473         int ret;
3474         char *func;
3475
3476         while (buf) {
3477                 func = strsep(&buf, ",");
3478                 /* we allow only one expression at a time */
3479                 ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
3480                                       func);
3481                 if (ret)
3482                         printk(KERN_DEBUG "ftrace: function %s not "
3483                                           "traceable\n", func);
3484         }
3485 }
3486 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
3487
3488 void __init
3489 ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable)
3490 {
3491         char *func;
3492
3493         while (buf) {
3494                 func = strsep(&buf, ",");
3495                 ftrace_set_regex(ops, func, strlen(func), 0, enable);
3496         }
3497 }
3498
3499 static void __init set_ftrace_early_filters(void)
3500 {
3501         if (ftrace_filter_buf[0])
3502                 ftrace_set_early_filter(&global_ops, ftrace_filter_buf, 1);
3503         if (ftrace_notrace_buf[0])
3504                 ftrace_set_early_filter(&global_ops, ftrace_notrace_buf, 0);
3505 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3506         if (ftrace_graph_buf[0])
3507                 set_ftrace_early_graph(ftrace_graph_buf);
3508 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
3509 }
3510
3511 int ftrace_regex_release(struct inode *inode, struct file *file)
3512 {
3513         struct seq_file *m = (struct seq_file *)file->private_data;
3514         struct ftrace_iterator *iter;
3515         struct ftrace_hash **orig_hash;
3516         struct trace_parser *parser;
3517         int filter_hash;
3518         int ret;
3519
3520         mutex_lock(&ftrace_regex_lock);
3521         if (file->f_mode & FMODE_READ) {
3522                 iter = m->private;
3523
3524                 seq_release(inode, file);
3525         } else
3526                 iter = file->private_data;
3527
3528         parser = &iter->parser;
3529         if (trace_parser_loaded(parser)) {
3530                 parser->buffer[parser->idx] = 0;
3531                 ftrace_match_records(iter->hash, parser->buffer, parser->idx);
3532         }
3533
3534         trace_parser_put(parser);
3535
3536         if (file->f_mode & FMODE_WRITE) {
3537                 filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
3538
3539                 if (filter_hash)
3540                         orig_hash = &iter->ops->filter_hash;
3541                 else
3542                         orig_hash = &iter->ops->notrace_hash;
3543
3544                 mutex_lock(&ftrace_lock);
3545                 ret = ftrace_hash_move(iter->ops, filter_hash,
3546                                        orig_hash, iter->hash);
3547                 if (!ret && (iter->ops->flags & FTRACE_OPS_FL_ENABLED)
3548                     && ftrace_enabled)
3549                         ftrace_run_update_code(FTRACE_UPDATE_CALLS);
3550
3551                 mutex_unlock(&ftrace_lock);
3552         }
3553         free_ftrace_hash(iter->hash);
3554         kfree(iter);
3555
3556         mutex_unlock(&ftrace_regex_lock);
3557         return 0;
3558 }
3559
3560 static const struct file_operations ftrace_avail_fops = {
3561         .open = ftrace_avail_open,
3562         .read = seq_read,
3563         .llseek = seq_lseek,
3564         .release = seq_release_private,
3565 };
3566
3567 static const struct file_operations ftrace_enabled_fops = {
3568         .open = ftrace_enabled_open,
3569         .read = seq_read,
3570         .llseek = seq_lseek,
3571         .release = seq_release_private,
3572 };
3573
3574 static const struct file_operations ftrace_filter_fops = {
3575         .open = ftrace_filter_open,
3576         .read = seq_read,
3577         .write = ftrace_filter_write,
3578         .llseek = ftrace_regex_lseek,
3579         .release = ftrace_regex_release,
3580 };
3581
3582 static const struct file_operations ftrace_notrace_fops = {
3583         .open = ftrace_notrace_open,
3584         .read = seq_read,
3585         .write = ftrace_notrace_write,
3586         .llseek = ftrace_regex_lseek,
3587         .release = ftrace_regex_release,
3588 };
3589
3590 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3591
3592 static DEFINE_MUTEX(graph_lock);
3593
3594 int ftrace_graph_count;
3595 int ftrace_graph_filter_enabled;
3596 unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS] __read_mostly;
3597
3598 static void *
3599 __g_next(struct seq_file *m, loff_t *pos)
3600 {
3601         if (*pos >= ftrace_graph_count)
3602                 return NULL;
3603         return &ftrace_graph_funcs[*pos];
3604 }
3605
3606 static void *
3607 g_next(struct seq_file *m, void *v, loff_t *pos)
3608 {
3609         (*pos)++;
3610         return __g_next(m, pos);
3611 }
3612
3613 static void *g_start(struct seq_file *m, loff_t *pos)
3614 {
3615         mutex_lock(&graph_lock);
3616
3617         /* Nothing, tell g_show to print all functions are enabled */
3618         if (!ftrace_graph_filter_enabled && !*pos)
3619                 return (void *)1;
3620
3621         return __g_next(m, pos);
3622 }
3623
3624 static void g_stop(struct seq_file *m, void *p)
3625 {
3626         mutex_unlock(&graph_lock);
3627 }
3628
3629 static int g_show(struct seq_file *m, void *v)
3630 {
3631         unsigned long *ptr = v;
3632
3633         if (!ptr)
3634                 return 0;
3635
3636         if (ptr == (unsigned long *)1) {
3637                 seq_printf(m, "#### all functions enabled ####\n");
3638                 return 0;
3639         }
3640
3641         seq_printf(m, "%ps\n", (void *)*ptr);
3642
3643         return 0;
3644 }
3645
3646 static const struct seq_operations ftrace_graph_seq_ops = {
3647         .start = g_start,
3648         .next = g_next,
3649         .stop = g_stop,
3650         .show = g_show,
3651 };
3652
3653 static int
3654 ftrace_graph_open(struct inode *inode, struct file *file)
3655 {
3656         int ret = 0;
3657
3658         if (unlikely(ftrace_disabled))
3659                 return -ENODEV;
3660
3661         mutex_lock(&graph_lock);
3662         if ((file->f_mode & FMODE_WRITE) &&
3663             (file->f_flags & O_TRUNC)) {
3664                 ftrace_graph_filter_enabled = 0;
3665                 ftrace_graph_count = 0;
3666                 memset(ftrace_graph_funcs, 0, sizeof(ftrace_graph_funcs));
3667         }
3668         mutex_unlock(&graph_lock);
3669
3670         if (file->f_mode & FMODE_READ)
3671                 ret = seq_open(file, &ftrace_graph_seq_ops);
3672
3673         return ret;
3674 }
3675
3676 static int
3677 ftrace_graph_release(struct inode *inode, struct file *file)
3678 {
3679         if (file->f_mode & FMODE_READ)
3680                 seq_release(inode, file);
3681         return 0;
3682 }
3683
3684 static int
3685 ftrace_set_func(unsigned long *array, int *idx, char *buffer)
3686 {
3687         struct dyn_ftrace *rec;
3688         struct ftrace_page *pg;
3689         int search_len;
3690         int fail = 1;
3691         int type, not;
3692         char *search;
3693         bool exists;
3694         int i;
3695
3696         /* decode regex */
3697         type = filter_parse_regex(buffer, strlen(buffer), &search, &not);
3698         if (!not && *idx >= FTRACE_GRAPH_MAX_FUNCS)
3699                 return -EBUSY;
3700
3701         search_len = strlen(search);
3702
3703         mutex_lock(&ftrace_lock);
3704
3705         if (unlikely(ftrace_disabled)) {
3706                 mutex_unlock(&ftrace_lock);
3707                 return -ENODEV;
3708         }
3709
3710         do_for_each_ftrace_rec(pg, rec) {
3711
3712                 if (ftrace_match_record(rec, NULL, search, search_len, type)) {
3713                         /* if it is in the array */
3714                         exists = false;
3715                         for (i = 0; i < *idx; i++) {
3716                                 if (array[i] == rec->ip) {
3717                                         exists = true;
3718                                         break;
3719                                 }
3720                         }
3721
3722                         if (!not) {
3723                                 fail = 0;
3724                                 if (!exists) {
3725                                         array[(*idx)++] = rec->ip;
3726                                         if (*idx >= FTRACE_GRAPH_MAX_FUNCS)
3727                                                 goto out;
3728                                 }
3729                         } else {
3730                                 if (exists) {
3731                                         array[i] = array[--(*idx)];
3732                                         array[*idx] = 0;
3733                                         fail = 0;
3734                                 }
3735                         }
3736                 }
3737         } while_for_each_ftrace_rec();
3738 out:
3739         mutex_unlock(&ftrace_lock);
3740
3741         if (fail)
3742                 return -EINVAL;
3743
3744         ftrace_graph_filter_enabled = 1;
3745         return 0;
3746 }
3747
3748 static ssize_t
3749 ftrace_graph_write(struct file *file, const char __user *ubuf,
3750                    size_t cnt, loff_t *ppos)
3751 {
3752         struct trace_parser parser;
3753         ssize_t read, ret;
3754
3755         if (!cnt)
3756                 return 0;
3757
3758         mutex_lock(&graph_lock);
3759
3760         if (trace_parser_get_init(&parser, FTRACE_BUFF_MAX)) {
3761                 ret = -ENOMEM;
3762                 goto out_unlock;
3763         }
3764
3765         read = trace_get_user(&parser, ubuf, cnt, ppos);
3766
3767         if (read >= 0 && trace_parser_loaded((&parser))) {
3768                 parser.buffer[parser.idx] = 0;
3769
3770                 /* we allow only one expression at a time */
3771                 ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
3772                                         parser.buffer);
3773                 if (ret)
3774                         goto out_free;
3775         }
3776
3777         ret = read;
3778
3779 out_free:
3780         trace_parser_put(&parser);
3781 out_unlock:
3782         mutex_unlock(&graph_lock);
3783
3784         return ret;
3785 }
3786
3787 static const struct file_operations ftrace_graph_fops = {
3788         .open           = ftrace_graph_open,
3789         .read           = seq_read,
3790         .write          = ftrace_graph_write,
3791         .release        = ftrace_graph_release,
3792         .llseek         = seq_lseek,
3793 };
3794 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
3795
3796 static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
3797 {
3798
3799         trace_create_file("available_filter_functions", 0444,
3800                         d_tracer, NULL, &ftrace_avail_fops);
3801
3802         trace_create_file("enabled_functions", 0444,
3803                         d_tracer, NULL, &ftrace_enabled_fops);
3804
3805         trace_create_file("set_ftrace_filter", 0644, d_tracer,
3806                         NULL, &ftrace_filter_fops);
3807
3808         trace_create_file("set_ftrace_notrace", 0644, d_tracer,
3809                                     NULL, &ftrace_notrace_fops);
3810
3811 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
3812         trace_create_file("set_graph_function", 0444, d_tracer,
3813                                     NULL,
3814                                     &ftrace_graph_fops);
3815 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
3816
3817         return 0;
3818 }
3819
3820 static int ftrace_cmp_ips(const void *a, const void *b)
3821 {
3822         const unsigned long *ipa = a;
3823         const unsigned long *ipb = b;
3824
3825         if (*ipa > *ipb)
3826                 return 1;
3827         if (*ipa < *ipb)
3828                 return -1;
3829         return 0;
3830 }
3831
3832 static void ftrace_swap_ips(void *a, void *b, int size)
3833 {
3834         unsigned long *ipa = a;
3835         unsigned long *ipb = b;
3836         unsigned long t;
3837
3838         t = *ipa;
3839         *ipa = *ipb;
3840         *ipb = t;
3841 }
3842
3843 static int ftrace_process_locs(struct module *mod,
3844                                unsigned long *start,
3845                                unsigned long *end)
3846 {
3847         struct ftrace_page *start_pg;
3848         struct ftrace_page *pg;
3849         struct dyn_ftrace *rec;
3850         unsigned long count;
3851         unsigned long *p;
3852         unsigned long addr;
3853         unsigned long flags = 0; /* Shut up gcc */
3854         int ret = -ENOMEM;
3855
3856         count = end - start;
3857
3858         if (!count)
3859                 return 0;
3860
3861         sort(start, count, sizeof(*start),
3862              ftrace_cmp_ips, ftrace_swap_ips);
3863
3864         start_pg = ftrace_allocate_pages(count);
3865         if (!start_pg)
3866                 return -ENOMEM;
3867
3868         mutex_lock(&ftrace_lock);
3869
3870         /*
3871          * Core and each module needs their own pages, as
3872          * modules will free them when they are removed.
3873          * Force a new page to be allocated for modules.
3874          */
3875         if (!mod) {
3876                 WARN_ON(ftrace_pages || ftrace_pages_start);
3877                 /* First initialization */
3878                 ftrace_pages = ftrace_pages_start = start_pg;
3879         } else {
3880                 if (!ftrace_pages)
3881                         goto out;
3882
3883                 if (WARN_ON(ftrace_pages->next)) {
3884                         /* Hmm, we have free pages? */
3885                         while (ftrace_pages->next)
3886                                 ftrace_pages = ftrace_pages->next;
3887                 }
3888
3889                 ftrace_pages->next = start_pg;
3890         }
3891
3892         p = start;
3893         pg = start_pg;
3894         while (p < end) {
3895                 addr = ftrace_call_adjust(*p++);
3896                 /*
3897                  * Some architecture linkers will pad between
3898                  * the different mcount_loc sections of different
3899                  * object files to satisfy alignments.
3900                  * Skip any NULL pointers.
3901                  */
3902                 if (!addr)
3903                         continue;
3904
3905                 if (pg->index == pg->size) {
3906                         /* We should have allocated enough */
3907                         if (WARN_ON(!pg->next))
3908                                 break;
3909                         pg = pg->next;
3910                 }
3911
3912                 rec = &pg->records[pg->index++];
3913                 rec->ip = addr;
3914         }
3915
3916         /* We should have used all pages */
3917         WARN_ON(pg->next);
3918
3919         /* Assign the last page to ftrace_pages */
3920         ftrace_pages = pg;
3921
3922         /* These new locations need to be initialized */
3923         ftrace_new_pgs = start_pg;
3924
3925         /*
3926          * We only need to disable interrupts on start up
3927          * because we are modifying code that an interrupt
3928          * may execute, and the modification is not atomic.
3929          * But for modules, nothing runs the code we modify
3930          * until we are finished with it, and there's no
3931          * reason to cause large interrupt latencies while we do it.
3932          */
3933         if (!mod)
3934                 local_irq_save(flags);
3935         ftrace_update_code(mod);
3936         if (!mod)
3937                 local_irq_restore(flags);
3938         ret = 0;
3939  out:
3940         mutex_unlock(&ftrace_lock);
3941
3942         return ret;
3943 }
3944
3945 #ifdef CONFIG_MODULES
3946
3947 #define next_to_ftrace_page(p) container_of(p, struct ftrace_page, next)
3948
3949 void ftrace_release_mod(struct module *mod)
3950 {
3951         struct dyn_ftrace *rec;
3952         struct ftrace_page **last_pg;
3953         struct ftrace_page *pg;
3954         int order;
3955
3956         mutex_lock(&ftrace_lock);
3957
3958         if (ftrace_disabled)
3959                 goto out_unlock;
3960
3961         /*
3962          * Each module has its own ftrace_pages, remove
3963          * them from the list.
3964          */
3965         last_pg = &ftrace_pages_start;
3966         for (pg = ftrace_pages_start; pg; pg = *last_pg) {
3967                 rec = &pg->records[0];
3968                 if (within_module_core(rec->ip, mod)) {
3969                         /*
3970                          * As core pages are first, the first
3971                          * page should never be a module page.
3972                          */
3973                         if (WARN_ON(pg == ftrace_pages_start))
3974                                 goto out_unlock;
3975
3976                         /* Check if we are deleting the last page */
3977                         if (pg == ftrace_pages)
3978                                 ftrace_pages = next_to_ftrace_page(last_pg);
3979
3980                         *last_pg = pg->next;
3981                         order = get_count_order(pg->size / ENTRIES_PER_PAGE);
3982                         free_pages((unsigned long)pg->records, order);
3983                         kfree(pg);
3984                 } else
3985                         last_pg = &pg->next;
3986         }
3987  out_unlock:
3988         mutex_unlock(&ftrace_lock);
3989 }
3990
3991 static void ftrace_init_module(struct module *mod,
3992                                unsigned long *start, unsigned long *end)
3993 {
3994         if (ftrace_disabled || start == end)
3995                 return;
3996         ftrace_process_locs(mod, start, end);
3997 }
3998
3999 static int ftrace_module_notify_enter(struct notifier_block *self,
4000                                       unsigned long val, void *data)
4001 {
4002         struct module *mod = data;
4003
4004         if (val == MODULE_STATE_COMING)
4005                 ftrace_init_module(mod, mod->ftrace_callsites,
4006                                    mod->ftrace_callsites +
4007                                    mod->num_ftrace_callsites);
4008         return 0;
4009 }
4010
4011 static int ftrace_module_notify_exit(struct notifier_block *self,
4012                                      unsigned long val, void *data)
4013 {
4014         struct module *mod = data;
4015
4016         if (val == MODULE_STATE_GOING)
4017                 ftrace_release_mod(mod);
4018
4019         return 0;
4020 }
4021 #else
4022 static int ftrace_module_notify_enter(struct notifier_block *self,
4023                                       unsigned long val, void *data)
4024 {
4025         return 0;
4026 }
4027 static int ftrace_module_notify_exit(struct notifier_block *self,
4028                                      unsigned long val, void *data)
4029 {
4030         return 0;
4031 }
4032 #endif /* CONFIG_MODULES */
4033
4034 struct notifier_block ftrace_module_enter_nb = {
4035         .notifier_call = ftrace_module_notify_enter,
4036         .priority = INT_MAX,    /* Run before anything that can use kprobes */
4037 };
4038
4039 struct notifier_block ftrace_module_exit_nb = {
4040         .notifier_call = ftrace_module_notify_exit,
4041         .priority = INT_MIN,    /* Run after anything that can remove kprobes */
4042 };
4043
4044 extern unsigned long __start_mcount_loc[];
4045 extern unsigned long __stop_mcount_loc[];
4046
4047 void __init ftrace_init(void)
4048 {
4049         unsigned long count, addr, flags;
4050         int ret;
4051
4052         /* Keep the ftrace pointer to the stub */
4053         addr = (unsigned long)ftrace_stub;
4054
4055         local_irq_save(flags);
4056         ftrace_dyn_arch_init(&addr);
4057         local_irq_restore(flags);
4058
4059         /* ftrace_dyn_arch_init places the return code in addr */
4060         if (addr)
4061                 goto failed;
4062
4063         count = __stop_mcount_loc - __start_mcount_loc;
4064
4065         ret = ftrace_dyn_table_alloc(count);
4066         if (ret)
4067                 goto failed;
4068
4069         last_ftrace_enabled = ftrace_enabled = 1;
4070
4071         ret = ftrace_process_locs(NULL,
4072                                   __start_mcount_loc,
4073                                   __stop_mcount_loc);
4074
4075         ret = register_module_notifier(&ftrace_module_enter_nb);
4076         if (ret)
4077                 pr_warning("Failed to register trace ftrace module enter notifier\n");
4078
4079         ret = register_module_notifier(&ftrace_module_exit_nb);
4080         if (ret)
4081                 pr_warning("Failed to register trace ftrace module exit notifier\n");
4082
4083         set_ftrace_early_filters();
4084
4085         return;
4086  failed:
4087         ftrace_disabled = 1;
4088 }
4089
4090 #else
4091
4092 static struct ftrace_ops global_ops = {
4093         .func                   = ftrace_stub,
4094         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
4095 };
4096
4097 static int __init ftrace_nodyn_init(void)
4098 {
4099         ftrace_enabled = 1;
4100         return 0;
4101 }
4102 core_initcall(ftrace_nodyn_init);
4103
4104 static inline int ftrace_init_dyn_debugfs(struct dentry *d_tracer) { return 0; }
4105 static inline void ftrace_startup_enable(int command) { }
4106 /* Keep as macros so we do not need to define the commands */
4107 # define ftrace_startup(ops, command)                   \
4108         ({                                              \
4109                 (ops)->flags |= FTRACE_OPS_FL_ENABLED;  \
4110                 0;                                      \
4111         })
4112 # define ftrace_shutdown(ops, command)  do { } while (0)
4113 # define ftrace_startup_sysctl()        do { } while (0)
4114 # define ftrace_shutdown_sysctl()       do { } while (0)
4115
4116 static inline int
4117 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip)
4118 {
4119         return 1;
4120 }
4121
4122 #endif /* CONFIG_DYNAMIC_FTRACE */
4123
4124 static void
4125 ftrace_ops_control_func(unsigned long ip, unsigned long parent_ip,
4126                         struct ftrace_ops *op, struct pt_regs *regs)
4127 {
4128         if (unlikely(trace_recursion_test(TRACE_CONTROL_BIT)))
4129                 return;
4130
4131         /*
4132          * Some of the ops may be dynamically allocated,
4133          * they must be freed after a synchronize_sched().
4134          */
4135         preempt_disable_notrace();
4136         trace_recursion_set(TRACE_CONTROL_BIT);
4137         do_for_each_ftrace_op(op, ftrace_control_list) {
4138                 if (!ftrace_function_local_disabled(op) &&
4139                     ftrace_ops_test(op, ip))
4140                         op->func(ip, parent_ip, op, regs);
4141         } while_for_each_ftrace_op(op);
4142         trace_recursion_clear(TRACE_CONTROL_BIT);
4143         preempt_enable_notrace();
4144 }
4145
4146 static struct ftrace_ops control_ops = {
4147         .func = ftrace_ops_control_func,
4148         .flags = FTRACE_OPS_FL_RECURSION_SAFE,
4149 };
4150
4151 static inline void
4152 __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
4153                        struct ftrace_ops *ignored, struct pt_regs *regs)
4154 {
4155         struct ftrace_ops *op;
4156         int bit;
4157
4158         if (function_trace_stop)
4159                 return;
4160
4161         bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
4162         if (bit < 0)
4163                 return;
4164
4165         /*
4166          * Some of the ops may be dynamically allocated,
4167          * they must be freed after a synchronize_sched().
4168          */
4169         preempt_disable_notrace();
4170         do_for_each_ftrace_op(op, ftrace_ops_list) {
4171                 if (ftrace_ops_test(op, ip))
4172                         op->func(ip, parent_ip, op, regs);
4173         } while_for_each_ftrace_op(op);
4174         preempt_enable_notrace();
4175         trace_clear_recursion(bit);
4176 }
4177
4178 /*
4179  * Some archs only support passing ip and parent_ip. Even though
4180  * the list function ignores the op parameter, we do not want any
4181  * C side effects, where a function is called without the caller
4182  * sending a third parameter.
4183  * Archs are to support both the regs and ftrace_ops at the same time.
4184  * If they support ftrace_ops, it is assumed they support regs.
4185  * If call backs want to use regs, they must either check for regs
4186  * being NULL, or CONFIG_DYNAMIC_FTRACE_WITH_REGS.
4187  * Note, CONFIG_DYNAMIC_FTRACE_WITH_REGS expects a full regs to be saved.
4188  * An architecture can pass partial regs with ftrace_ops and still
4189  * set the ARCH_SUPPORT_FTARCE_OPS.
4190  */
4191 #if ARCH_SUPPORTS_FTRACE_OPS
4192 static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
4193                                  struct ftrace_ops *op, struct pt_regs *regs)
4194 {
4195         __ftrace_ops_list_func(ip, parent_ip, NULL, regs);
4196 }
4197 #else
4198 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
4199 {
4200         __ftrace_ops_list_func(ip, parent_ip, NULL, NULL);
4201 }
4202 #endif
4203
4204 static void clear_ftrace_swapper(void)
4205 {
4206         struct task_struct *p;
4207         int cpu;
4208
4209         get_online_cpus();
4210         for_each_online_cpu(cpu) {
4211                 p = idle_task(cpu);
4212                 clear_tsk_trace_trace(p);
4213         }
4214         put_online_cpus();
4215 }
4216
4217 static void set_ftrace_swapper(void)
4218 {
4219         struct task_struct *p;
4220         int cpu;
4221
4222         get_online_cpus();
4223         for_each_online_cpu(cpu) {
4224                 p = idle_task(cpu);
4225                 set_tsk_trace_trace(p);
4226         }
4227         put_online_cpus();
4228 }
4229
4230 static void clear_ftrace_pid(struct pid *pid)
4231 {
4232         struct task_struct *p;
4233
4234         rcu_read_lock();
4235         do_each_pid_task(pid, PIDTYPE_PID, p) {
4236                 clear_tsk_trace_trace(p);
4237         } while_each_pid_task(pid, PIDTYPE_PID, p);
4238         rcu_read_unlock();
4239
4240         put_pid(pid);
4241 }
4242
4243 static void set_ftrace_pid(struct pid *pid)
4244 {
4245         struct task_struct *p;
4246
4247         rcu_read_lock();
4248         do_each_pid_task(pid, PIDTYPE_PID, p) {
4249                 set_tsk_trace_trace(p);
4250         } while_each_pid_task(pid, PIDTYPE_PID, p);
4251         rcu_read_unlock();
4252 }
4253
4254 static void clear_ftrace_pid_task(struct pid *pid)
4255 {
4256         if (pid == ftrace_swapper_pid)
4257                 clear_ftrace_swapper();
4258         else
4259                 clear_ftrace_pid(pid);
4260 }
4261
4262 static void set_ftrace_pid_task(struct pid *pid)
4263 {
4264         if (pid == ftrace_swapper_pid)
4265                 set_ftrace_swapper();
4266         else
4267                 set_ftrace_pid(pid);
4268 }
4269
4270 static int ftrace_pid_add(int p)
4271 {
4272         struct pid *pid;
4273         struct ftrace_pid *fpid;
4274         int ret = -EINVAL;
4275
4276         mutex_lock(&ftrace_lock);
4277
4278         if (!p)
4279                 pid = ftrace_swapper_pid;
4280         else
4281                 pid = find_get_pid(p);
4282
4283         if (!pid)
4284                 goto out;
4285
4286         ret = 0;
4287
4288         list_for_each_entry(fpid, &ftrace_pids, list)
4289                 if (fpid->pid == pid)
4290                         goto out_put;
4291
4292         ret = -ENOMEM;
4293
4294         fpid = kmalloc(sizeof(*fpid), GFP_KERNEL);
4295         if (!fpid)
4296                 goto out_put;
4297
4298         list_add(&fpid->list, &ftrace_pids);
4299         fpid->pid = pid;
4300
4301         set_ftrace_pid_task(pid);
4302
4303         ftrace_update_pid_func();
4304         ftrace_startup_enable(0);
4305
4306         mutex_unlock(&ftrace_lock);
4307         return 0;
4308
4309 out_put:
4310         if (pid != ftrace_swapper_pid)
4311                 put_pid(pid);
4312
4313 out:
4314         mutex_unlock(&ftrace_lock);
4315         return ret;
4316 }
4317
4318 static void ftrace_pid_reset(void)
4319 {
4320         struct ftrace_pid *fpid, *safe;
4321
4322         mutex_lock(&ftrace_lock);
4323         list_for_each_entry_safe(fpid, safe, &ftrace_pids, list) {
4324                 struct pid *pid = fpid->pid;
4325
4326                 clear_ftrace_pid_task(pid);
4327
4328                 list_del(&fpid->list);
4329                 kfree(fpid);
4330         }
4331
4332         ftrace_update_pid_func();
4333         ftrace_startup_enable(0);
4334
4335         mutex_unlock(&ftrace_lock);
4336 }
4337
4338 static void *fpid_start(struct seq_file *m, loff_t *pos)
4339 {
4340         mutex_lock(&ftrace_lock);
4341
4342         if (list_empty(&ftrace_pids) && (!*pos))
4343                 return (void *) 1;
4344
4345         return seq_list_start(&ftrace_pids, *pos);
4346 }
4347
4348 static void *fpid_next(struct seq_file *m, void *v, loff_t *pos)
4349 {
4350         if (v == (void *)1)
4351                 return NULL;
4352
4353         return seq_list_next(v, &ftrace_pids, pos);
4354 }
4355
4356 static void fpid_stop(struct seq_file *m, void *p)
4357 {
4358         mutex_unlock(&ftrace_lock);
4359 }
4360
4361 static int fpid_show(struct seq_file *m, void *v)
4362 {
4363         const struct ftrace_pid *fpid = list_entry(v, struct ftrace_pid, list);
4364
4365         if (v == (void *)1) {
4366                 seq_printf(m, "no pid\n");
4367                 return 0;
4368         }
4369
4370         if (fpid->pid == ftrace_swapper_pid)
4371                 seq_printf(m, "swapper tasks\n");
4372         else
4373                 seq_printf(m, "%u\n", pid_vnr(fpid->pid));
4374
4375         return 0;
4376 }
4377
4378 static const struct seq_operations ftrace_pid_sops = {
4379         .start = fpid_start,
4380         .next = fpid_next,
4381         .stop = fpid_stop,
4382         .show = fpid_show,
4383 };
4384
4385 static int
4386 ftrace_pid_open(struct inode *inode, struct file *file)
4387 {
4388         int ret = 0;
4389
4390         if ((file->f_mode & FMODE_WRITE) &&
4391             (file->f_flags & O_TRUNC))
4392                 ftrace_pid_reset();
4393
4394         if (file->f_mode & FMODE_READ)
4395                 ret = seq_open(file, &ftrace_pid_sops);
4396
4397         return ret;
4398 }
4399
4400 static ssize_t
4401 ftrace_pid_write(struct file *filp, const char __user *ubuf,
4402                    size_t cnt, loff_t *ppos)
4403 {
4404         char buf[64], *tmp;
4405         long val;
4406         int ret;
4407
4408         if (cnt >= sizeof(buf))
4409                 return -EINVAL;
4410
4411         if (copy_from_user(&buf, ubuf, cnt))
4412                 return -EFAULT;
4413
4414         buf[cnt] = 0;
4415
4416         /*
4417          * Allow "echo > set_ftrace_pid" or "echo -n '' > set_ftrace_pid"
4418          * to clean the filter quietly.
4419          */
4420         tmp = strstrip(buf);
4421         if (strlen(tmp) == 0)
4422                 return 1;
4423
4424         ret = kstrtol(tmp, 10, &val);
4425         if (ret < 0)
4426                 return ret;
4427
4428         ret = ftrace_pid_add(val);
4429
4430         return ret ? ret : cnt;
4431 }
4432
4433 static int
4434 ftrace_pid_release(struct inode *inode, struct file *file)
4435 {
4436         if (file->f_mode & FMODE_READ)
4437                 seq_release(inode, file);
4438
4439         return 0;
4440 }
4441
4442 static const struct file_operations ftrace_pid_fops = {
4443         .open           = ftrace_pid_open,
4444         .write          = ftrace_pid_write,
4445         .read           = seq_read,
4446         .llseek         = seq_lseek,
4447         .release        = ftrace_pid_release,
4448 };
4449
4450 static __init int ftrace_init_debugfs(void)
4451 {
4452         struct dentry *d_tracer;
4453
4454         d_tracer = tracing_init_dentry();
4455         if (!d_tracer)
4456                 return 0;
4457
4458         ftrace_init_dyn_debugfs(d_tracer);
4459
4460         trace_create_file("set_ftrace_pid", 0644, d_tracer,
4461                             NULL, &ftrace_pid_fops);
4462
4463         ftrace_profile_debugfs(d_tracer);
4464
4465         return 0;
4466 }
4467 fs_initcall(ftrace_init_debugfs);
4468
4469 /**
4470  * ftrace_kill - kill ftrace
4471  *
4472  * This function should be used by panic code. It stops ftrace
4473  * but in a not so nice way. If you need to simply kill ftrace
4474  * from a non-atomic section, use ftrace_kill.
4475  */
4476 void ftrace_kill(void)
4477 {
4478         ftrace_disabled = 1;
4479         ftrace_enabled = 0;
4480         clear_ftrace_function();
4481 }
4482
4483 /**
4484  * Test if ftrace is dead or not.
4485  */
4486 int ftrace_is_dead(void)
4487 {
4488         return ftrace_disabled;
4489 }
4490
4491 /**
4492  * register_ftrace_function - register a function for profiling
4493  * @ops - ops structure that holds the function for profiling.
4494  *
4495  * Register a function to be called by all functions in the
4496  * kernel.
4497  *
4498  * Note: @ops->func and all the functions it calls must be labeled
4499  *       with "notrace", otherwise it will go into a
4500  *       recursive loop.
4501  */
4502 int register_ftrace_function(struct ftrace_ops *ops)
4503 {
4504         int ret = -1;
4505
4506         mutex_lock(&ftrace_lock);
4507
4508         ret = __register_ftrace_function(ops);
4509         if (!ret)
4510                 ret = ftrace_startup(ops, 0);
4511
4512         mutex_unlock(&ftrace_lock);
4513
4514         return ret;
4515 }
4516 EXPORT_SYMBOL_GPL(register_ftrace_function);
4517
4518 /**
4519  * unregister_ftrace_function - unregister a function for profiling.
4520  * @ops - ops structure that holds the function to unregister
4521  *
4522  * Unregister a function that was added to be called by ftrace profiling.
4523  */
4524 int unregister_ftrace_function(struct ftrace_ops *ops)
4525 {
4526         int ret;
4527
4528         mutex_lock(&ftrace_lock);
4529         ret = __unregister_ftrace_function(ops);
4530         if (!ret)
4531                 ftrace_shutdown(ops, 0);
4532         mutex_unlock(&ftrace_lock);
4533
4534         return ret;
4535 }
4536 EXPORT_SYMBOL_GPL(unregister_ftrace_function);
4537
4538 int
4539 ftrace_enable_sysctl(struct ctl_table *table, int write,
4540                      void __user *buffer, size_t *lenp,
4541                      loff_t *ppos)
4542 {
4543         int ret = -ENODEV;
4544
4545         mutex_lock(&ftrace_lock);
4546
4547         if (unlikely(ftrace_disabled))
4548                 goto out;
4549
4550         ret = proc_dointvec(table, write, buffer, lenp, ppos);
4551
4552         if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled))
4553                 goto out;
4554
4555         last_ftrace_enabled = !!ftrace_enabled;
4556
4557         if (ftrace_enabled) {
4558
4559                 ftrace_startup_sysctl();
4560
4561                 /* we are starting ftrace again */
4562                 if (ftrace_ops_list != &ftrace_list_end) {
4563                         if (ftrace_ops_list->next == &ftrace_list_end)
4564                                 ftrace_trace_function = ftrace_ops_list->func;
4565                         else
4566                                 ftrace_trace_function = ftrace_ops_list_func;
4567                 }
4568
4569         } else {
4570                 /* stopping ftrace calls (just send to ftrace_stub) */
4571                 ftrace_trace_function = ftrace_stub;
4572
4573                 ftrace_shutdown_sysctl();
4574         }
4575
4576  out:
4577         mutex_unlock(&ftrace_lock);
4578         return ret;
4579 }
4580
4581 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
4582
4583 static int ftrace_graph_active;
4584 static struct notifier_block ftrace_suspend_notifier;
4585
4586 int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace)
4587 {
4588         return 0;
4589 }
4590
4591 /* The callbacks that hook a function */
4592 trace_func_graph_ret_t ftrace_graph_return =
4593                         (trace_func_graph_ret_t)ftrace_stub;
4594 trace_func_graph_ent_t ftrace_graph_entry = ftrace_graph_entry_stub;
4595
4596 /* Try to assign a return stack array on FTRACE_RETSTACK_ALLOC_SIZE tasks. */
4597 static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list)
4598 {
4599         int i;
4600         int ret = 0;
4601         unsigned long flags;
4602         int start = 0, end = FTRACE_RETSTACK_ALLOC_SIZE;
4603         struct task_struct *g, *t;
4604
4605         for (i = 0; i < FTRACE_RETSTACK_ALLOC_SIZE; i++) {
4606                 ret_stack_list[i] = kmalloc(FTRACE_RETFUNC_DEPTH
4607                                         * sizeof(struct ftrace_ret_stack),
4608                                         GFP_KERNEL);
4609                 if (!ret_stack_list[i]) {
4610                         start = 0;
4611                         end = i;
4612                         ret = -ENOMEM;
4613                         goto free;
4614                 }
4615         }
4616
4617         read_lock_irqsave(&tasklist_lock, flags);
4618         do_each_thread(g, t) {
4619                 if (start == end) {
4620                         ret = -EAGAIN;
4621                         goto unlock;
4622                 }
4623
4624                 if (t->ret_stack == NULL) {
4625                         atomic_set(&t->tracing_graph_pause, 0);
4626                         atomic_set(&t->trace_overrun, 0);
4627                         t->curr_ret_stack = -1;
4628                         /* Make sure the tasks see the -1 first: */
4629                         smp_wmb();
4630                         t->ret_stack = ret_stack_list[start++];
4631                 }
4632         } while_each_thread(g, t);
4633
4634 unlock:
4635         read_unlock_irqrestore(&tasklist_lock, flags);
4636 free:
4637         for (i = start; i < end; i++)
4638                 kfree(ret_stack_list[i]);
4639         return ret;
4640 }
4641
4642 static void
4643 ftrace_graph_probe_sched_switch(void *ignore,
4644                         struct task_struct *prev, struct task_struct *next)
4645 {
4646         unsigned long long timestamp;
4647         int index;
4648
4649         /*
4650          * Does the user want to count the time a function was asleep.
4651          * If so, do not update the time stamps.
4652          */
4653         if (trace_flags & TRACE_ITER_SLEEP_TIME)
4654                 return;
4655
4656         timestamp = trace_clock_local();
4657
4658         prev->ftrace_timestamp = timestamp;
4659
4660         /* only process tasks that we timestamped */
4661         if (!next->ftrace_timestamp)
4662                 return;
4663
4664         /*
4665          * Update all the counters in next to make up for the
4666          * time next was sleeping.
4667          */
4668         timestamp -= next->ftrace_timestamp;
4669
4670         for (index = next->curr_ret_stack; index >= 0; index--)
4671                 next->ret_stack[index].calltime += timestamp;
4672 }
4673
4674 /* Allocate a return stack for each task */
4675 static int start_graph_tracing(void)
4676 {
4677         struct ftrace_ret_stack **ret_stack_list;
4678         int ret, cpu;
4679
4680         ret_stack_list = kmalloc(FTRACE_RETSTACK_ALLOC_SIZE *
4681                                 sizeof(struct ftrace_ret_stack *),
4682                                 GFP_KERNEL);
4683
4684         if (!ret_stack_list)
4685                 return -ENOMEM;
4686
4687         /* The cpu_boot init_task->ret_stack will never be freed */
4688         for_each_online_cpu(cpu) {
4689                 if (!idle_task(cpu)->ret_stack)
4690                         ftrace_graph_init_idle_task(idle_task(cpu), cpu);
4691         }
4692
4693         do {
4694                 ret = alloc_retstack_tasklist(ret_stack_list);
4695         } while (ret == -EAGAIN);
4696
4697         if (!ret) {
4698                 ret = register_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
4699                 if (ret)
4700                         pr_info("ftrace_graph: Couldn't activate tracepoint"
4701                                 " probe to kernel_sched_switch\n");
4702         }
4703
4704         kfree(ret_stack_list);
4705         return ret;
4706 }
4707
4708 /*
4709  * Hibernation protection.
4710  * The state of the current task is too much unstable during
4711  * suspend/restore to disk. We want to protect against that.
4712  */
4713 static int
4714 ftrace_suspend_notifier_call(struct notifier_block *bl, unsigned long state,
4715                                                         void *unused)
4716 {
4717         switch (state) {
4718         case PM_HIBERNATION_PREPARE:
4719                 pause_graph_tracing();
4720                 break;
4721
4722         case PM_POST_HIBERNATION:
4723                 unpause_graph_tracing();
4724                 break;
4725         }
4726         return NOTIFY_DONE;
4727 }
4728
4729 int register_ftrace_graph(trace_func_graph_ret_t retfunc,
4730                         trace_func_graph_ent_t entryfunc)
4731 {
4732         int ret = 0;
4733
4734         mutex_lock(&ftrace_lock);
4735
4736         /* we currently allow only one tracer registered at a time */
4737         if (ftrace_graph_active) {
4738                 ret = -EBUSY;
4739                 goto out;
4740         }
4741
4742         ftrace_suspend_notifier.notifier_call = ftrace_suspend_notifier_call;
4743         register_pm_notifier(&ftrace_suspend_notifier);
4744
4745         ftrace_graph_active++;
4746         ret = start_graph_tracing();
4747         if (ret) {
4748                 ftrace_graph_active--;
4749                 goto out;
4750         }
4751
4752         ftrace_graph_return = retfunc;
4753         ftrace_graph_entry = entryfunc;
4754
4755         ret = ftrace_startup(&global_ops, FTRACE_START_FUNC_RET);
4756
4757 out:
4758         mutex_unlock(&ftrace_lock);
4759         return ret;
4760 }
4761
4762 void unregister_ftrace_graph(void)
4763 {
4764         mutex_lock(&ftrace_lock);
4765
4766         if (unlikely(!ftrace_graph_active))
4767                 goto out;
4768
4769         ftrace_graph_active--;
4770         ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
4771         ftrace_graph_entry = ftrace_graph_entry_stub;
4772         ftrace_shutdown(&global_ops, FTRACE_STOP_FUNC_RET);
4773         unregister_pm_notifier(&ftrace_suspend_notifier);
4774         unregister_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
4775
4776  out:
4777         mutex_unlock(&ftrace_lock);
4778 }
4779
4780 static DEFINE_PER_CPU(struct ftrace_ret_stack *, idle_ret_stack);
4781
4782 static void
4783 graph_init_task(struct task_struct *t, struct ftrace_ret_stack *ret_stack)
4784 {
4785         atomic_set(&t->tracing_graph_pause, 0);
4786         atomic_set(&t->trace_overrun, 0);
4787         t->ftrace_timestamp = 0;
4788         /* make curr_ret_stack visible before we add the ret_stack */
4789         smp_wmb();
4790         t->ret_stack = ret_stack;
4791 }
4792
4793 /*
4794  * Allocate a return stack for the idle task. May be the first
4795  * time through, or it may be done by CPU hotplug online.
4796  */
4797 void ftrace_graph_init_idle_task(struct task_struct *t, int cpu)
4798 {
4799         t->curr_ret_stack = -1;
4800         /*
4801          * The idle task has no parent, it either has its own
4802          * stack or no stack at all.
4803          */
4804         if (t->ret_stack)
4805                 WARN_ON(t->ret_stack != per_cpu(idle_ret_stack, cpu));
4806
4807         if (ftrace_graph_active) {
4808                 struct ftrace_ret_stack *ret_stack;
4809
4810                 ret_stack = per_cpu(idle_ret_stack, cpu);
4811                 if (!ret_stack) {
4812                         ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
4813                                             * sizeof(struct ftrace_ret_stack),
4814                                             GFP_KERNEL);
4815                         if (!ret_stack)
4816                                 return;
4817                         per_cpu(idle_ret_stack, cpu) = ret_stack;
4818                 }
4819                 graph_init_task(t, ret_stack);
4820         }
4821 }
4822
4823 /* Allocate a return stack for newly created task */
4824 void ftrace_graph_init_task(struct task_struct *t)
4825 {
4826         /* Make sure we do not use the parent ret_stack */
4827         t->ret_stack = NULL;
4828         t->curr_ret_stack = -1;
4829
4830         if (ftrace_graph_active) {
4831                 struct ftrace_ret_stack *ret_stack;
4832
4833                 ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH
4834                                 * sizeof(struct ftrace_ret_stack),
4835                                 GFP_KERNEL);
4836                 if (!ret_stack)
4837                         return;
4838                 graph_init_task(t, ret_stack);
4839         }
4840 }
4841
4842 void ftrace_graph_exit_task(struct task_struct *t)
4843 {
4844         struct ftrace_ret_stack *ret_stack = t->ret_stack;
4845
4846         t->ret_stack = NULL;
4847         /* NULL must become visible to IRQs before we free it: */
4848         barrier();
4849
4850         kfree(ret_stack);
4851 }
4852
4853 void ftrace_graph_stop(void)
4854 {
4855         ftrace_stop();
4856 }
4857 #endif