kernel/trace/ftrace.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Infrastructure for profiling code inserted by 'gcc -pg'.
   4  *
   5  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
   6  * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
   7  *
   8  * Originally ported from the -rt patch by:
   9  *   Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
  10  *
  11  * Based on code in the latency_tracer, that is:
  12  *
  13  *  Copyright (C) 2004-2006 Ingo Molnar
  14  *  Copyright (C) 2004 Nadia Yvette Chambers
  15  */
  16
  17 #include <linux/stop_machine.h>
  18 #include <linux/clocksource.h>
  19 #include <linux/sched/task.h>
  20 #include <linux/kallsyms.h>
  21 #include <linux/security.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/tracefs.h>
  24 #include <linux/hardirq.h>
  25 #include <linux/kthread.h>
  26 #include <linux/uaccess.h>
  27 #include <linux/bsearch.h>
  28 #include <linux/module.h>
  29 #include <linux/ftrace.h>
  30 #include <linux/sysctl.h>
  31 #include <linux/slab.h>
  32 #include <linux/ctype.h>
  33 #include <linux/sort.h>
  34 #include <linux/list.h>
  35 #include <linux/hash.h>
  36 #include <linux/rcupdate.h>
  37 #include <linux/kprobes.h>
  38
  39 #include <trace/events/sched.h>
  40
  41 #include <asm/sections.h>
  42 #include <asm/setup.h>
  43
  44 #include "ftrace_internal.h"
  45 #include "trace_output.h"
  46 #include "trace_stat.h"
  47
  48 #define FTRACE_WARN_ON(cond)                    \
  49         ({                                      \
  50                 int ___r = cond;                \
  51                 if (WARN_ON(___r))              \
  52                         ftrace_kill();          \
  53                 ___r;                           \
  54         })
  55
  56 #define FTRACE_WARN_ON_ONCE(cond)               \
  57         ({                                      \
  58                 int ___r = cond;                \
  59                 if (WARN_ON_ONCE(___r))         \
  60                         ftrace_kill();          \
  61                 ___r;                           \
  62         })
  63
  64 /* hash bits for specific function selection */
  65 #define FTRACE_HASH_DEFAULT_BITS 10
  66 #define FTRACE_HASH_MAX_BITS 12
  67
  68 #ifdef CONFIG_DYNAMIC_FTRACE
  69 #define INIT_OPS_HASH(opsname)  \
  70         .func_hash              = &opsname.local_hash,                  \
  71         .local_hash.regex_lock  = __MUTEX_INITIALIZER(opsname.local_hash.regex_lock),
  72 #else
  73 #define INIT_OPS_HASH(opsname)
  74 #endif
  75
  76 enum {
  77         FTRACE_MODIFY_ENABLE_FL         = (1 << 0),
  78         FTRACE_MODIFY_MAY_SLEEP_FL      = (1 << 1),
  79 };
  80
  81 struct ftrace_ops ftrace_list_end __read_mostly = {
  82         .func           = ftrace_stub,
  83         .flags          = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_STUB,
  84         INIT_OPS_HASH(ftrace_list_end)
  85 };
  86
  87 /* ftrace_enabled is a method to turn ftrace on or off */
  88 int ftrace_enabled __read_mostly;
  89 static int last_ftrace_enabled;
  90
  91 /* Current function tracing op */
  92 struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;
  93 /* What to set function_trace_op to */
  94 static struct ftrace_ops *set_function_trace_op;
  95
  96 static bool ftrace_pids_enabled(struct ftrace_ops *ops)
  97 {
  98         struct trace_array *tr;
  99
 100         if (!(ops->flags & FTRACE_OPS_FL_PID) || !ops->private)
 101                 return false;
 102
 103         tr = ops->private;
 104
 105         return tr->function_pids != NULL;
 106 }
 107
 108 static void ftrace_update_trampoline(struct ftrace_ops *ops);
 109
 110 /*
 111  * ftrace_disabled is set when an anomaly is discovered.
 112  * ftrace_disabled is much stronger than ftrace_enabled.
 113  */
 114 static int ftrace_disabled __read_mostly;
 115
 116 DEFINE_MUTEX(ftrace_lock);
 117
 118 struct ftrace_ops __rcu *ftrace_ops_list __read_mostly = &ftrace_list_end;
 119 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 120 struct ftrace_ops global_ops;
 121
 122 #if ARCH_SUPPORTS_FTRACE_OPS
 123 static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
 124                                  struct ftrace_ops *op, struct pt_regs *regs);
 125 #else
 126 /* See comment below, where ftrace_ops_list_func is defined */
 127 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip);
 128 #define ftrace_ops_list_func ((ftrace_func_t)ftrace_ops_no_ops)
 129 #endif
 130
 131 static inline void ftrace_ops_init(struct ftrace_ops *ops)
 132 {
 133 #ifdef CONFIG_DYNAMIC_FTRACE
 134         if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) {
 135                 mutex_init(&ops->local_hash.regex_lock);
 136                 ops->func_hash = &ops->local_hash;
 137                 ops->flags |= FTRACE_OPS_FL_INITIALIZED;
 138         }
 139 #endif
 140 }
 141
 142 static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
 143                             struct ftrace_ops *op, struct pt_regs *regs)
 144 {
 145         struct trace_array *tr = op->private;
 146
 147         if (tr && this_cpu_read(tr->array_buffer.data->ftrace_ignore_pid))
 148                 return;
 149
 150         op->saved_func(ip, parent_ip, op, regs);
 151 }
 152
 153 static void ftrace_sync(struct work_struct *work)
 154 {
 155         /*
 156          * This function is just a stub to implement a hard force
 157          * of synchronize_rcu(). This requires synchronizing
 158          * tasks even in userspace and idle.
 159          *
 160          * Yes, function tracing is rude.
 161          */
 162 }
 163
 164 static void ftrace_sync_ipi(void *data)
 165 {
 166         /* Probably not needed, but do it anyway */
 167         smp_rmb();
 168 }
 169
 170 static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops)
 171 {
 172         /*
 173          * If this is a dynamic, RCU, or per CPU ops, or we force list func,
 174          * then it needs to call the list anyway.
 175          */
 176         if (ops->flags & (FTRACE_OPS_FL_DYNAMIC | FTRACE_OPS_FL_RCU) ||
 177             FTRACE_FORCE_LIST_FUNC)
 178                 return ftrace_ops_list_func;
 179
 180         return ftrace_ops_get_func(ops);
 181 }
 182
 183 static void update_ftrace_function(void)
 184 {
 185         ftrace_func_t func;
 186
 187         /*
 188          * Prepare the ftrace_ops that the arch callback will use.
 189          * If there's only one ftrace_ops registered, the ftrace_ops_list
 190          * will point to the ops we want.
 191          */
 192         set_function_trace_op = rcu_dereference_protected(ftrace_ops_list,
 193                                                 lockdep_is_held(&ftrace_lock));
 194
 195         /* If there's no ftrace_ops registered, just call the stub function */
 196         if (set_function_trace_op == &ftrace_list_end) {
 197                 func = ftrace_stub;
 198
 199         /*
 200          * If we are at the end of the list and this ops is
 201          * recursion safe and not dynamic and the arch supports passing ops,
 202          * then have the mcount trampoline call the function directly.
 203          */
 204         } else if (rcu_dereference_protected(ftrace_ops_list->next,
 205                         lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
 206                 func = ftrace_ops_get_list_func(ftrace_ops_list);
 207
 208         } else {
 209                 /* Just use the default ftrace_ops */
 210                 set_function_trace_op = &ftrace_list_end;
 211                 func = ftrace_ops_list_func;
 212         }
 213
 214         update_function_graph_func();
 215
 216         /* If there's no change, then do nothing more here */
 217         if (ftrace_trace_function == func)
 218                 return;
 219
 220         /*
 221          * If we are using the list function, it doesn't care
 222          * about the function_trace_ops.
 223          */
 224         if (func == ftrace_ops_list_func) {
 225                 ftrace_trace_function = func;
 226                 /*
 227                  * Don't even bother setting function_trace_ops,
 228                  * it would be racy to do so anyway.
 229                  */
 230                 return;
 231         }
 232
 233 #ifndef CONFIG_DYNAMIC_FTRACE
 234         /*
 235          * For static tracing, we need to be a bit more careful.
 236          * The function change takes affect immediately. Thus,
 237          * we need to coorditate the setting of the function_trace_ops
 238          * with the setting of the ftrace_trace_function.
 239          *
 240          * Set the function to the list ops, which will call the
 241          * function we want, albeit indirectly, but it handles the
 242          * ftrace_ops and doesn't depend on function_trace_op.
 243          */
 244         ftrace_trace_function = ftrace_ops_list_func;
 245         /*
 246          * Make sure all CPUs see this. Yes this is slow, but static
 247          * tracing is slow and nasty to have enabled.
 248          */
 249         schedule_on_each_cpu(ftrace_sync);
 250         /* Now all cpus are using the list ops. */
 251         function_trace_op = set_function_trace_op;
 252         /* Make sure the function_trace_op is visible on all CPUs */
 253         smp_wmb();
 254         /* Nasty way to force a rmb on all cpus */
 255         smp_call_function(ftrace_sync_ipi, NULL, 1);
 256         /* OK, we are all set to update the ftrace_trace_function now! */
 257 #endif /* !CONFIG_DYNAMIC_FTRACE */
 258
 259         ftrace_trace_function = func;
 260 }
 261
 262 static void add_ftrace_ops(struct ftrace_ops __rcu **list,
 263                            struct ftrace_ops *ops)
 264 {
 265         rcu_assign_pointer(ops->next, *list);
 266
 267         /*
 268          * We are entering ops into the list but another
 269          * CPU might be walking that list. We need to make sure
 270          * the ops->next pointer is valid before another CPU sees
 271          * the ops pointer included into the list.
 272          */
 273         rcu_assign_pointer(*list, ops);
 274 }
 275
 276 static int remove_ftrace_ops(struct ftrace_ops __rcu **list,
 277                              struct ftrace_ops *ops)
 278 {
 279         struct ftrace_ops **p;
 280
 281         /*
 282          * If we are removing the last function, then simply point
 283          * to the ftrace_stub.
 284          */
 285         if (rcu_dereference_protected(*list,
 286                         lockdep_is_held(&ftrace_lock)) == ops &&
 287             rcu_dereference_protected(ops->next,
 288                         lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
 289                 *list = &ftrace_list_end;
 290                 return 0;
 291         }
 292
 293         for (p = list; *p != &ftrace_list_end; p = &(*p)->next)
 294                 if (*p == ops)
 295                         break;
 296
 297         if (*p != ops)
 298                 return -1;
 299
 300         *p = (*p)->next;
 301         return 0;
 302 }
 303
 304 static void ftrace_update_trampoline(struct ftrace_ops *ops);
 305
 306 int __register_ftrace_function(struct ftrace_ops *ops)
 307 {
 308         if (ops->flags & FTRACE_OPS_FL_DELETED)
 309                 return -EINVAL;
 310
 311         if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
 312                 return -EBUSY;
 313
 314 #ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS
 315         /*
 316          * If the ftrace_ops specifies SAVE_REGS, then it only can be used
 317          * if the arch supports it, or SAVE_REGS_IF_SUPPORTED is also set.
 318          * Setting SAVE_REGS_IF_SUPPORTED makes SAVE_REGS irrelevant.
 319          */
 320         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS &&
 321             !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED))
 322                 return -EINVAL;
 323
 324         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)
 325                 ops->flags |= FTRACE_OPS_FL_SAVE_REGS;
 326 #endif
 327         if (!ftrace_enabled && (ops->flags & FTRACE_OPS_FL_PERMANENT))
 328                 return -EBUSY;
 329
 330         if (!core_kernel_data((unsigned long)ops))
 331                 ops->flags |= FTRACE_OPS_FL_DYNAMIC;
 332
 333         add_ftrace_ops(&ftrace_ops_list, ops);
 334
 335         /* Always save the function, and reset at unregistering */
 336         ops->saved_func = ops->func;
 337
 338         if (ftrace_pids_enabled(ops))
 339                 ops->func = ftrace_pid_func;
 340
 341         ftrace_update_trampoline(ops);
 342
 343         if (ftrace_enabled)
 344                 update_ftrace_function();
 345
 346         return 0;
 347 }
 348
 349 int __unregister_ftrace_function(struct ftrace_ops *ops)
 350 {
 351         int ret;
 352
 353         if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED)))
 354                 return -EBUSY;
 355
 356         ret = remove_ftrace_ops(&ftrace_ops_list, ops);
 357
 358         if (ret < 0)
 359                 return ret;
 360
 361         if (ftrace_enabled)
 362                 update_ftrace_function();
 363
 364         ops->func = ops->saved_func;
 365
 366         return 0;
 367 }
 368
 369 static void ftrace_update_pid_func(void)
 370 {
 371         struct ftrace_ops *op;
 372
 373         /* Only do something if we are tracing something */
 374         if (ftrace_trace_function == ftrace_stub)
 375                 return;
 376
 377         do_for_each_ftrace_op(op, ftrace_ops_list) {
 378                 if (op->flags & FTRACE_OPS_FL_PID) {
 379                         op->func = ftrace_pids_enabled(op) ?
 380                                 ftrace_pid_func : op->saved_func;
 381                         ftrace_update_trampoline(op);
 382                 }
 383         } while_for_each_ftrace_op(op);
 384
 385         update_ftrace_function();
 386 }
 387
 388 #ifdef CONFIG_FUNCTION_PROFILER
 389 struct ftrace_profile {
 390         struct hlist_node               node;
 391         unsigned long                   ip;
 392         unsigned long                   counter;
 393 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 394         unsigned long long              time;
 395         unsigned long long              time_squared;
 396 #endif
 397 };
 398
 399 struct ftrace_profile_page {
 400         struct ftrace_profile_page      *next;
 401         unsigned long                   index;
 402         struct ftrace_profile           records[];
 403 };
 404
 405 struct ftrace_profile_stat {
 406         atomic_t                        disabled;
 407         struct hlist_head               *hash;
 408         struct ftrace_profile_page      *pages;
 409         struct ftrace_profile_page      *start;
 410         struct tracer_stat              stat;
 411 };
 412
 413 #define PROFILE_RECORDS_SIZE                                            \
 414         (PAGE_SIZE - offsetof(struct ftrace_profile_page, records))
 415
 416 #define PROFILES_PER_PAGE                                       \
 417         (PROFILE_RECORDS_SIZE / sizeof(struct ftrace_profile))
 418
 419 static int ftrace_profile_enabled __read_mostly;
 420
 421 /* ftrace_profile_lock - synchronize the enable and disable of the profiler */
 422 static DEFINE_MUTEX(ftrace_profile_lock);
 423
 424 static DEFINE_PER_CPU(struct ftrace_profile_stat, ftrace_profile_stats);
 425
 426 #define FTRACE_PROFILE_HASH_BITS 10
 427 #define FTRACE_PROFILE_HASH_SIZE (1 << FTRACE_PROFILE_HASH_BITS)
 428
 429 static void *
 430 function_stat_next(void *v, int idx)
 431 {
 432         struct ftrace_profile *rec = v;
 433         struct ftrace_profile_page *pg;
 434
 435         pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
 436
 437  again:
 438         if (idx != 0)
 439                 rec++;
 440
 441         if ((void *)rec >= (void *)&pg->records[pg->index]) {
 442                 pg = pg->next;
 443                 if (!pg)
 444                         return NULL;
 445                 rec = &pg->records[0];
 446                 if (!rec->counter)
 447                         goto again;
 448         }
 449
 450         return rec;
 451 }
 452
 453 static void *function_stat_start(struct tracer_stat *trace)
 454 {
 455         struct ftrace_profile_stat *stat =
 456                 container_of(trace, struct ftrace_profile_stat, stat);
 457
 458         if (!stat || !stat->start)
 459                 return NULL;
 460
 461         return function_stat_next(&stat->start->records[0], 0);
 462 }
 463
 464 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 465 /* function graph compares on total time */
 466 static int function_stat_cmp(const void *p1, const void *p2)
 467 {
 468         const struct ftrace_profile *a = p1;
 469         const struct ftrace_profile *b = p2;
 470
 471         if (a->time < b->time)
 472                 return -1;
 473         if (a->time > b->time)
 474                 return 1;
 475         else
 476                 return 0;
 477 }
 478 #else
 479 /* not function graph compares against hits */
 480 static int function_stat_cmp(const void *p1, const void *p2)
 481 {
 482         const struct ftrace_profile *a = p1;
 483         const struct ftrace_profile *b = p2;
 484
 485         if (a->counter < b->counter)
 486                 return -1;
 487         if (a->counter > b->counter)
 488                 return 1;
 489         else
 490                 return 0;
 491 }
 492 #endif
 493
 494 static int function_stat_headers(struct seq_file *m)
 495 {
 496 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 497         seq_puts(m, "  Function                               "
 498                  "Hit    Time            Avg             s^2\n"
 499                     "  --------                               "
 500                  "---    ----            ---             ---\n");
 501 #else
 502         seq_puts(m, "  Function                               Hit\n"
 503                     "  --------                               ---\n");
 504 #endif
 505         return 0;
 506 }
 507
 508 static int function_stat_show(struct seq_file *m, void *v)
 509 {
 510         struct ftrace_profile *rec = v;
 511         char str[KSYM_SYMBOL_LEN];
 512         int ret = 0;
 513 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 514         static struct trace_seq s;
 515         unsigned long long avg;
 516         unsigned long long stddev;
 517 #endif
 518         mutex_lock(&ftrace_profile_lock);
 519
 520         /* we raced with function_profile_reset() */
 521         if (unlikely(rec->counter == 0)) {
 522                 ret = -EBUSY;
 523                 goto out;
 524         }
 525
 526 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 527         avg = div64_ul(rec->time, rec->counter);
 528         if (tracing_thresh && (avg < tracing_thresh))
 529                 goto out;
 530 #endif
 531
 532         kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
 533         seq_printf(m, "  %-30.30s  %10lu", str, rec->counter);
 534
 535 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 536         seq_puts(m, "    ");
 537
 538         /* Sample standard deviation (s^2) */
 539         if (rec->counter <= 1)
 540                 stddev = 0;
 541         else {
 542                 /*
 543                  * Apply Welford's method:
 544                  * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
 545                  */
 546                 stddev = rec->counter * rec->time_squared -
 547                          rec->time * rec->time;
 548
 549                 /*
 550                  * Divide only 1000 for ns^2 -> us^2 conversion.
 551                  * trace_print_graph_duration will divide 1000 again.
 552                  */
 553                 stddev = div64_ul(stddev,
 554                                   rec->counter * (rec->counter - 1) * 1000);
 555         }
 556
 557         trace_seq_init(&s);
 558         trace_print_graph_duration(rec->time, &s);
 559         trace_seq_puts(&s, "    ");
 560         trace_print_graph_duration(avg, &s);
 561         trace_seq_puts(&s, "    ");
 562         trace_print_graph_duration(stddev, &s);
 563         trace_print_seq(m, &s);
 564 #endif
 565         seq_putc(m, '\n');
 566 out:
 567         mutex_unlock(&ftrace_profile_lock);
 568
 569         return ret;
 570 }
 571
 572 static void ftrace_profile_reset(struct ftrace_profile_stat *stat)
 573 {
 574         struct ftrace_profile_page *pg;
 575
 576         pg = stat->pages = stat->start;
 577
 578         while (pg) {
 579                 memset(pg->records, 0, PROFILE_RECORDS_SIZE);
 580                 pg->index = 0;
 581                 pg = pg->next;
 582         }
 583
 584         memset(stat->hash, 0,
 585                FTRACE_PROFILE_HASH_SIZE * sizeof(struct hlist_head));
 586 }
 587
 588 int ftrace_profile_pages_init(struct ftrace_profile_stat *stat)
 589 {
 590         struct ftrace_profile_page *pg;
 591         int functions;
 592         int pages;
 593         int i;
 594
 595         /* If we already allocated, do nothing */
 596         if (stat->pages)
 597                 return 0;
 598
 599         stat->pages = (void *)get_zeroed_page(GFP_KERNEL);
 600         if (!stat->pages)
 601                 return -ENOMEM;
 602
 603 #ifdef CONFIG_DYNAMIC_FTRACE
 604         functions = ftrace_update_tot_cnt;
 605 #else
 606         /*
 607          * We do not know the number of functions that exist because
 608          * dynamic tracing is what counts them. With past experience
 609          * we have around 20K functions. That should be more than enough.
 610          * It is highly unlikely we will execute every function in
 611          * the kernel.
 612          */
 613         functions = 20000;
 614 #endif
 615
 616         pg = stat->start = stat->pages;
 617
 618         pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);
 619
 620         for (i = 1; i < pages; i++) {
 621                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
 622                 if (!pg->next)
 623                         goto out_free;
 624                 pg = pg->next;
 625         }
 626
 627         return 0;
 628
 629  out_free:
 630         pg = stat->start;
 631         while (pg) {
 632                 unsigned long tmp = (unsigned long)pg;
 633
 634                 pg = pg->next;
 635                 free_page(tmp);
 636         }
 637
 638         stat->pages = NULL;
 639         stat->start = NULL;
 640
 641         return -ENOMEM;
 642 }
 643
 644 static int ftrace_profile_init_cpu(int cpu)
 645 {
 646         struct ftrace_profile_stat *stat;
 647         int size;
 648
 649         stat = &per_cpu(ftrace_profile_stats, cpu);
 650
 651         if (stat->hash) {
 652                 /* If the profile is already created, simply reset it */
 653                 ftrace_profile_reset(stat);
 654                 return 0;
 655         }
 656
 657         /*
 658          * We are profiling all functions, but usually only a few thousand
 659          * functions are hit. We'll make a hash of 1024 items.
 660          */
 661         size = FTRACE_PROFILE_HASH_SIZE;
 662
 663         stat->hash = kcalloc(size, sizeof(struct hlist_head), GFP_KERNEL);
 664
 665         if (!stat->hash)
 666                 return -ENOMEM;
 667
 668         /* Preallocate the function profiling pages */
 669         if (ftrace_profile_pages_init(stat) < 0) {
 670                 kfree(stat->hash);
 671                 stat->hash = NULL;
 672                 return -ENOMEM;
 673         }
 674
 675         return 0;
 676 }
 677
 678 static int ftrace_profile_init(void)
 679 {
 680         int cpu;
 681         int ret = 0;
 682
 683         for_each_possible_cpu(cpu) {
 684                 ret = ftrace_profile_init_cpu(cpu);
 685                 if (ret)
 686                         break;
 687         }
 688
 689         return ret;
 690 }
 691
 692 /* interrupts must be disabled */
 693 static struct ftrace_profile *
 694 ftrace_find_profiled_func(struct ftrace_profile_stat *stat, unsigned long ip)
 695 {
 696         struct ftrace_profile *rec;
 697         struct hlist_head *hhd;
 698         unsigned long key;
 699
 700         key = hash_long(ip, FTRACE_PROFILE_HASH_BITS);
 701         hhd = &stat->hash[key];
 702
 703         if (hlist_empty(hhd))
 704                 return NULL;
 705
 706         hlist_for_each_entry_rcu_notrace(rec, hhd, node) {
 707                 if (rec->ip == ip)
 708                         return rec;
 709         }
 710
 711         return NULL;
 712 }
 713
 714 static void ftrace_add_profile(struct ftrace_profile_stat *stat,
 715                                struct ftrace_profile *rec)
 716 {
 717         unsigned long key;
 718
 719         key = hash_long(rec->ip, FTRACE_PROFILE_HASH_BITS);
 720         hlist_add_head_rcu(&rec->node, &stat->hash[key]);
 721 }
 722
 723 /*
 724  * The memory is already allocated, this simply finds a new record to use.
 725  */
 726 static struct ftrace_profile *
 727 ftrace_profile_alloc(struct ftrace_profile_stat *stat, unsigned long ip)
 728 {
 729         struct ftrace_profile *rec = NULL;
 730
 731         /* prevent recursion (from NMIs) */
 732         if (atomic_inc_return(&stat->disabled) != 1)
 733                 goto out;
 734
 735         /*
 736          * Try to find the function again since an NMI
 737          * could have added it
 738          */
 739         rec = ftrace_find_profiled_func(stat, ip);
 740         if (rec)
 741                 goto out;
 742
 743         if (stat->pages->index == PROFILES_PER_PAGE) {
 744                 if (!stat->pages->next)
 745                         goto out;
 746                 stat->pages = stat->pages->next;
 747         }
 748
 749         rec = &stat->pages->records[stat->pages->index++];
 750         rec->ip = ip;
 751         ftrace_add_profile(stat, rec);
 752
 753  out:
 754         atomic_dec(&stat->disabled);
 755
 756         return rec;
 757 }
 758
 759 static void
 760 function_profile_call(unsigned long ip, unsigned long parent_ip,
 761                       struct ftrace_ops *ops, struct pt_regs *regs)
 762 {
 763         struct ftrace_profile_stat *stat;
 764         struct ftrace_profile *rec;
 765         unsigned long flags;
 766
 767         if (!ftrace_profile_enabled)
 768                 return;
 769
 770         local_irq_save(flags);
 771
 772         stat = this_cpu_ptr(&ftrace_profile_stats);
 773         if (!stat->hash || !ftrace_profile_enabled)
 774                 goto out;
 775
 776         rec = ftrace_find_profiled_func(stat, ip);
 777         if (!rec) {
 778                 rec = ftrace_profile_alloc(stat, ip);
 779                 if (!rec)
 780                         goto out;
 781         }
 782
 783         rec->counter++;
 784  out:
 785         local_irq_restore(flags);
 786 }
 787
 788 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 789 static bool fgraph_graph_time = true;
 790
 791 void ftrace_graph_graph_time_control(bool enable)
 792 {
 793         fgraph_graph_time = enable;
 794 }
 795
 796 static int profile_graph_entry(struct ftrace_graph_ent *trace)
 797 {
 798         struct ftrace_ret_stack *ret_stack;
 799
 800         function_profile_call(trace->func, 0, NULL, NULL);
 801
 802         /* If function graph is shutting down, ret_stack can be NULL */
 803         if (!current->ret_stack)
 804                 return 0;
 805
 806         ret_stack = ftrace_graph_get_ret_stack(current, 0);
 807         if (ret_stack)
 808                 ret_stack->subtime = 0;
 809
 810         return 1;
 811 }
 812
 813 static void profile_graph_return(struct ftrace_graph_ret *trace)
 814 {
 815         struct ftrace_ret_stack *ret_stack;
 816         struct ftrace_profile_stat *stat;
 817         unsigned long long calltime;
 818         struct ftrace_profile *rec;
 819         unsigned long flags;
 820
 821         local_irq_save(flags);
 822         stat = this_cpu_ptr(&ftrace_profile_stats);
 823         if (!stat->hash || !ftrace_profile_enabled)
 824                 goto out;
 825
 826         /* If the calltime was zero'd ignore it */
 827         if (!trace->calltime)
 828                 goto out;
 829
 830         calltime = trace->rettime - trace->calltime;
 831
 832         if (!fgraph_graph_time) {
 833
 834                 /* Append this call time to the parent time to subtract */
 835                 ret_stack = ftrace_graph_get_ret_stack(current, 1);
 836                 if (ret_stack)
 837                         ret_stack->subtime += calltime;
 838
 839                 ret_stack = ftrace_graph_get_ret_stack(current, 0);
 840                 if (ret_stack && ret_stack->subtime < calltime)
 841                         calltime -= ret_stack->subtime;
 842                 else
 843                         calltime = 0;
 844         }
 845
 846         rec = ftrace_find_profiled_func(stat, trace->func);
 847         if (rec) {
 848                 rec->time += calltime;
 849                 rec->time_squared += calltime * calltime;
 850         }
 851
 852  out:
 853         local_irq_restore(flags);
 854 }
 855
 856 static struct fgraph_ops fprofiler_ops = {
 857         .entryfunc = &profile_graph_entry,
 858         .retfunc = &profile_graph_return,
 859 };
 860
 861 static int register_ftrace_profiler(void)
 862 {
 863         return register_ftrace_graph(&fprofiler_ops);
 864 }
 865
 866 static void unregister_ftrace_profiler(void)
 867 {
 868         unregister_ftrace_graph(&fprofiler_ops);
 869 }
 870 #else
 871 static struct ftrace_ops ftrace_profile_ops __read_mostly = {
 872         .func           = function_profile_call,
 873         .flags          = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
 874         INIT_OPS_HASH(ftrace_profile_ops)
 875 };
 876
 877 static int register_ftrace_profiler(void)
 878 {
 879         return register_ftrace_function(&ftrace_profile_ops);
 880 }
 881
 882 static void unregister_ftrace_profiler(void)
 883 {
 884         unregister_ftrace_function(&ftrace_profile_ops);
 885 }
 886 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 887
 888 static ssize_t
 889 ftrace_profile_write(struct file *filp, const char __user *ubuf,
 890                      size_t cnt, loff_t *ppos)
 891 {
 892         unsigned long val;
 893         int ret;
 894
 895         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
 896         if (ret)
 897                 return ret;
 898
 899         val = !!val;
 900
 901         mutex_lock(&ftrace_profile_lock);
 902         if (ftrace_profile_enabled ^ val) {
 903                 if (val) {
 904                         ret = ftrace_profile_init();
 905                         if (ret < 0) {
 906                                 cnt = ret;
 907                                 goto out;
 908                         }
 909
 910                         ret = register_ftrace_profiler();
 911                         if (ret < 0) {
 912                                 cnt = ret;
 913                                 goto out;
 914                         }
 915                         ftrace_profile_enabled = 1;
 916                 } else {
 917                         ftrace_profile_enabled = 0;
 918                         /*
 919                          * unregister_ftrace_profiler calls stop_machine
 920                          * so this acts like an synchronize_rcu.
 921                          */
 922                         unregister_ftrace_profiler();
 923                 }
 924         }
 925  out:
 926         mutex_unlock(&ftrace_profile_lock);
 927
 928         *ppos += cnt;
 929
 930         return cnt;
 931 }
 932
 933 static ssize_t
 934 ftrace_profile_read(struct file *filp, char __user *ubuf,
 935                      size_t cnt, loff_t *ppos)
 936 {
 937         char buf[64];           /* big enough to hold a number */
 938         int r;
 939
 940         r = sprintf(buf, "%u\n", ftrace_profile_enabled);
 941         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 942 }
 943
 944 static const struct file_operations ftrace_profile_fops = {
 945         .open           = tracing_open_generic,
 946         .read           = ftrace_profile_read,
 947         .write          = ftrace_profile_write,
 948         .llseek         = default_llseek,
 949 };
 950
 951 /* used to initialize the real stat files */
 952 static struct tracer_stat function_stats __initdata = {
 953         .name           = "functions",
 954         .stat_start     = function_stat_start,
 955         .stat_next      = function_stat_next,
 956         .stat_cmp       = function_stat_cmp,
 957         .stat_headers   = function_stat_headers,
 958         .stat_show      = function_stat_show
 959 };
 960
 961 static __init void ftrace_profile_tracefs(struct dentry *d_tracer)
 962 {
 963         struct ftrace_profile_stat *stat;
 964         struct dentry *entry;
 965         char *name;
 966         int ret;
 967         int cpu;
 968
 969         for_each_possible_cpu(cpu) {
 970                 stat = &per_cpu(ftrace_profile_stats, cpu);
 971
 972                 name = kasprintf(GFP_KERNEL, "function%d", cpu);
 973                 if (!name) {
 974                         /*
 975                          * The files created are permanent, if something happens
 976                          * we still do not free memory.
 977                          */
 978                         WARN(1,
 979                              "Could not allocate stat file for cpu %d\n",
 980                              cpu);
 981                         return;
 982                 }
 983                 stat->stat = function_stats;
 984                 stat->stat.name = name;
 985                 ret = register_stat_tracer(&stat->stat);
 986                 if (ret) {
 987                         WARN(1,
 988                              "Could not register function stat for cpu %d\n",
 989                              cpu);
 990                         kfree(name);
 991                         return;
 992                 }
 993         }
 994
 995         entry = tracefs_create_file("function_profile_enabled", 0644,
 996                                     d_tracer, NULL, &ftrace_profile_fops);
 997         if (!entry)
 998                 pr_warn("Could not create tracefs 'function_profile_enabled' entry\n");
 999 }
1000
1001 #else /* CONFIG_FUNCTION_PROFILER */
1002 static __init void ftrace_profile_tracefs(struct dentry *d_tracer)
1003 {
1004 }
1005 #endif /* CONFIG_FUNCTION_PROFILER */
1006
1007 #ifdef CONFIG_DYNAMIC_FTRACE
1008
1009 static struct ftrace_ops *removed_ops;
1010
1011 /*
1012  * Set when doing a global update, like enabling all recs or disabling them.
1013  * It is not set when just updating a single ftrace_ops.
1014  */
1015 static bool update_all_ops;
1016
1017 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
1018 # error Dynamic ftrace depends on MCOUNT_RECORD
1019 #endif
1020
1021 struct ftrace_func_probe {
1022         struct ftrace_probe_ops *probe_ops;
1023         struct ftrace_ops       ops;
1024         struct trace_array      *tr;
1025         struct list_head        list;
1026         void                    *data;
1027         int                     ref;
1028 };
1029
1030 /*
1031  * We make these constant because no one should touch them,
1032  * but they are used as the default "empty hash", to avoid allocating
1033  * it all the time. These are in a read only section such that if
1034  * anyone does try to modify it, it will cause an exception.
1035  */
1036 static const struct hlist_head empty_buckets[1];
1037 static const struct ftrace_hash empty_hash = {
1038         .buckets = (struct hlist_head *)empty_buckets,
1039 };
1040 #define EMPTY_HASH      ((struct ftrace_hash *)&empty_hash)
1041
1042 struct ftrace_ops global_ops = {
1043         .func                           = ftrace_stub,
1044         .local_hash.notrace_hash        = EMPTY_HASH,
1045         .local_hash.filter_hash         = EMPTY_HASH,
1046         INIT_OPS_HASH(global_ops)
1047         .flags                          = FTRACE_OPS_FL_RECURSION_SAFE |
1048                                           FTRACE_OPS_FL_INITIALIZED |
1049                                           FTRACE_OPS_FL_PID,
1050 };
1051
1052 /*
1053  * Used by the stack undwinder to know about dynamic ftrace trampolines.
1054  */
1055 struct ftrace_ops *ftrace_ops_trampoline(unsigned long addr)
1056 {
1057         struct ftrace_ops *op = NULL;
1058
1059         /*
1060          * Some of the ops may be dynamically allocated,
1061          * they are freed after a synchronize_rcu().
1062          */
1063         preempt_disable_notrace();
1064
1065         do_for_each_ftrace_op(op, ftrace_ops_list) {
1066                 /*
1067                  * This is to check for dynamically allocated trampolines.
1068                  * Trampolines that are in kernel text will have
1069                  * core_kernel_text() return true.
1070                  */
1071                 if (op->trampoline && op->trampoline_size)
1072                         if (addr >= op->trampoline &&
1073                             addr < op->trampoline + op->trampoline_size) {
1074                                 preempt_enable_notrace();
1075                                 return op;
1076                         }
1077         } while_for_each_ftrace_op(op);
1078         preempt_enable_notrace();
1079
1080         return NULL;
1081 }
1082
1083 /*
1084  * This is used by __kernel_text_address() to return true if the
1085  * address is on a dynamically allocated trampoline that would
1086  * not return true for either core_kernel_text() or
1087  * is_module_text_address().
1088  */
1089 bool is_ftrace_trampoline(unsigned long addr)
1090 {
1091         return ftrace_ops_trampoline(addr) != NULL;
1092 }
1093
1094 struct ftrace_page {
1095         struct ftrace_page      *next;
1096         struct dyn_ftrace       *records;
1097         int                     index;
1098         int                     size;
1099 };
1100
1101 #define ENTRY_SIZE sizeof(struct dyn_ftrace)
1102 #define ENTRIES_PER_PAGE (PAGE_SIZE / ENTRY_SIZE)
1103
1104 static struct ftrace_page       *ftrace_pages_start;
1105 static struct ftrace_page       *ftrace_pages;
1106
1107 static __always_inline unsigned long
1108 ftrace_hash_key(struct ftrace_hash *hash, unsigned long ip)
1109 {
1110         if (hash->size_bits > 0)
1111                 return hash_long(ip, hash->size_bits);
1112
1113         return 0;
1114 }
1115
1116 /* Only use this function if ftrace_hash_empty() has already been tested */
1117 static __always_inline struct ftrace_func_entry *
1118 __ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1119 {
1120         unsigned long key;
1121         struct ftrace_func_entry *entry;
1122         struct hlist_head *hhd;
1123
1124         key = ftrace_hash_key(hash, ip);
1125         hhd = &hash->buckets[key];
1126
1127         hlist_for_each_entry_rcu_notrace(entry, hhd, hlist) {
1128                 if (entry->ip == ip)
1129                         return entry;
1130         }
1131         return NULL;
1132 }
1133
1134 /**
1135  * ftrace_lookup_ip - Test to see if an ip exists in an ftrace_hash
1136  * @hash: The hash to look at
1137  * @ip: The instruction pointer to test
1138  *
1139  * Search a given @hash to see if a given instruction pointer (@ip)
1140  * exists in it.
1141  *
1142  * Returns the entry that holds the @ip if found. NULL otherwise.
1143  */
1144 struct ftrace_func_entry *
1145 ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip)
1146 {
1147         if (ftrace_hash_empty(hash))
1148                 return NULL;
1149
1150         return __ftrace_lookup_ip(hash, ip);
1151 }
1152
1153 static void __add_hash_entry(struct ftrace_hash *hash,
1154                              struct ftrace_func_entry *entry)
1155 {
1156         struct hlist_head *hhd;
1157         unsigned long key;
1158
1159         key = ftrace_hash_key(hash, entry->ip);
1160         hhd = &hash->buckets[key];
1161         hlist_add_head(&entry->hlist, hhd);
1162         hash->count++;
1163 }
1164
1165 static int add_hash_entry(struct ftrace_hash *hash, unsigned long ip)
1166 {
1167         struct ftrace_func_entry *entry;
1168
1169         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
1170         if (!entry)
1171                 return -ENOMEM;
1172
1173         entry->ip = ip;
1174         __add_hash_entry(hash, entry);
1175
1176         return 0;
1177 }
1178
1179 static void
1180 free_hash_entry(struct ftrace_hash *hash,
1181                   struct ftrace_func_entry *entry)
1182 {
1183         hlist_del(&entry->hlist);
1184         kfree(entry);
1185         hash->count--;
1186 }
1187
1188 static void
1189 remove_hash_entry(struct ftrace_hash *hash,
1190                   struct ftrace_func_entry *entry)
1191 {
1192         hlist_del_rcu(&entry->hlist);
1193         hash->count--;
1194 }
1195
1196 static void ftrace_hash_clear(struct ftrace_hash *hash)
1197 {
1198         struct hlist_head *hhd;
1199         struct hlist_node *tn;
1200         struct ftrace_func_entry *entry;
1201         int size = 1 << hash->size_bits;
1202         int i;
1203
1204         if (!hash->count)
1205                 return;
1206
1207         for (i = 0; i < size; i++) {
1208                 hhd = &hash->buckets[i];
1209                 hlist_for_each_entry_safe(entry, tn, hhd, hlist)
1210                         free_hash_entry(hash, entry);
1211         }
1212         FTRACE_WARN_ON(hash->count);
1213 }
1214
1215 static void free_ftrace_mod(struct ftrace_mod_load *ftrace_mod)
1216 {
1217         list_del(&ftrace_mod->list);
1218         kfree(ftrace_mod->module);
1219         kfree(ftrace_mod->func);
1220         kfree(ftrace_mod);
1221 }
1222
1223 static void clear_ftrace_mod_list(struct list_head *head)
1224 {
1225         struct ftrace_mod_load *p, *n;
1226
1227         /* stack tracer isn't supported yet */
1228         if (!head)
1229                 return;
1230
1231         mutex_lock(&ftrace_lock);
1232         list_for_each_entry_safe(p, n, head, list)
1233                 free_ftrace_mod(p);
1234         mutex_unlock(&ftrace_lock);
1235 }
1236
1237 static void free_ftrace_hash(struct ftrace_hash *hash)
1238 {
1239         if (!hash || hash == EMPTY_HASH)
1240                 return;
1241         ftrace_hash_clear(hash);
1242         kfree(hash->buckets);
1243         kfree(hash);
1244 }
1245
1246 static void __free_ftrace_hash_rcu(struct rcu_head *rcu)
1247 {
1248         struct ftrace_hash *hash;
1249
1250         hash = container_of(rcu, struct ftrace_hash, rcu);
1251         free_ftrace_hash(hash);
1252 }
1253
1254 static void free_ftrace_hash_rcu(struct ftrace_hash *hash)
1255 {
1256         if (!hash || hash == EMPTY_HASH)
1257                 return;
1258         call_rcu(&hash->rcu, __free_ftrace_hash_rcu);
1259 }
1260
1261 void ftrace_free_filter(struct ftrace_ops *ops)
1262 {
1263         ftrace_ops_init(ops);
1264         free_ftrace_hash(ops->func_hash->filter_hash);
1265         free_ftrace_hash(ops->func_hash->notrace_hash);
1266 }
1267
1268 static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
1269 {
1270         struct ftrace_hash *hash;
1271         int size;
1272
1273         hash = kzalloc(sizeof(*hash), GFP_KERNEL);
1274         if (!hash)
1275                 return NULL;
1276
1277         size = 1 << size_bits;
1278         hash->buckets = kcalloc(size, sizeof(*hash->buckets), GFP_KERNEL);
1279
1280         if (!hash->buckets) {
1281                 kfree(hash);
1282                 return NULL;
1283         }
1284
1285         hash->size_bits = size_bits;
1286
1287         return hash;
1288 }
1289
1290
1291 static int ftrace_add_mod(struct trace_array *tr,
1292                           const char *func, const char *module,
1293                           int enable)
1294 {
1295         struct ftrace_mod_load *ftrace_mod;
1296         struct list_head *mod_head = enable ? &tr->mod_trace : &tr->mod_notrace;
1297
1298         ftrace_mod = kzalloc(sizeof(*ftrace_mod), GFP_KERNEL);
1299         if (!ftrace_mod)
1300                 return -ENOMEM;
1301
1302         ftrace_mod->func = kstrdup(func, GFP_KERNEL);
1303         ftrace_mod->module = kstrdup(module, GFP_KERNEL);
1304         ftrace_mod->enable = enable;
1305
1306         if (!ftrace_mod->func || !ftrace_mod->module)
1307                 goto out_free;
1308
1309         list_add(&ftrace_mod->list, mod_head);
1310
1311         return 0;
1312
1313  out_free:
1314         free_ftrace_mod(ftrace_mod);
1315
1316         return -ENOMEM;
1317 }
1318
1319 static struct ftrace_hash *
1320 alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
1321 {
1322         struct ftrace_func_entry *entry;
1323         struct ftrace_hash *new_hash;
1324         int size;
1325         int ret;
1326         int i;
1327
1328         new_hash = alloc_ftrace_hash(size_bits);
1329         if (!new_hash)
1330                 return NULL;
1331
1332         if (hash)
1333                 new_hash->flags = hash->flags;
1334
1335         /* Empty hash? */
1336         if (ftrace_hash_empty(hash))
1337                 return new_hash;
1338
1339         size = 1 << hash->size_bits;
1340         for (i = 0; i < size; i++) {
1341                 hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
1342                         ret = add_hash_entry(new_hash, entry->ip);
1343                         if (ret < 0)
1344                                 goto free_hash;
1345                 }
1346         }
1347
1348         FTRACE_WARN_ON(new_hash->count != hash->count);
1349
1350         return new_hash;
1351
1352  free_hash:
1353         free_ftrace_hash(new_hash);
1354         return NULL;
1355 }
1356
1357 static void
1358 ftrace_hash_rec_disable_modify(struct ftrace_ops *ops, int filter_hash);
1359 static void
1360 ftrace_hash_rec_enable_modify(struct ftrace_ops *ops, int filter_hash);
1361
1362 static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
1363                                        struct ftrace_hash *new_hash);
1364
1365 static struct ftrace_hash *dup_hash(struct ftrace_hash *src, int size)
1366 {
1367         struct ftrace_func_entry *entry;
1368         struct ftrace_hash *new_hash;
1369         struct hlist_head *hhd;
1370         struct hlist_node *tn;
1371         int bits = 0;
1372         int i;
1373
1374         /*
1375          * Make the hash size about 1/2 the # found
1376          */
1377         for (size /= 2; size; size >>= 1)
1378                 bits++;
1379
1380         /* Don't allocate too much */
1381         if (bits > FTRACE_HASH_MAX_BITS)
1382                 bits = FTRACE_HASH_MAX_BITS;
1383
1384         new_hash = alloc_ftrace_hash(bits);
1385         if (!new_hash)
1386                 return NULL;
1387
1388         new_hash->flags = src->flags;
1389
1390         size = 1 << src->size_bits;
1391         for (i = 0; i < size; i++) {
1392                 hhd = &src->buckets[i];
1393                 hlist_for_each_entry_safe(entry, tn, hhd, hlist) {
1394                         remove_hash_entry(src, entry);
1395                         __add_hash_entry(new_hash, entry);
1396                 }
1397         }
1398         return new_hash;
1399 }
1400
1401 static struct ftrace_hash *
1402 __ftrace_hash_move(struct ftrace_hash *src)
1403 {
1404         int size = src->count;
1405
1406         /*
1407          * If the new source is empty, just return the empty_hash.
1408          */
1409         if (ftrace_hash_empty(src))
1410                 return EMPTY_HASH;
1411
1412         return dup_hash(src, size);
1413 }
1414
1415 static int
1416 ftrace_hash_move(struct ftrace_ops *ops, int enable,
1417                  struct ftrace_hash **dst, struct ftrace_hash *src)
1418 {
1419         struct ftrace_hash *new_hash;
1420         int ret;
1421
1422         /* Reject setting notrace hash on IPMODIFY ftrace_ops */
1423         if (ops->flags & FTRACE_OPS_FL_IPMODIFY && !enable)
1424                 return -EINVAL;
1425
1426         new_hash = __ftrace_hash_move(src);
1427         if (!new_hash)
1428                 return -ENOMEM;
1429
1430         /* Make sure this can be applied if it is IPMODIFY ftrace_ops */
1431         if (enable) {
1432                 /* IPMODIFY should be updated only when filter_hash updating */
1433                 ret = ftrace_hash_ipmodify_update(ops, new_hash);
1434                 if (ret < 0) {
1435                         free_ftrace_hash(new_hash);
1436                         return ret;
1437                 }
1438         }
1439
1440         /*
1441          * Remove the current set, update the hash and add
1442          * them back.
1443          */
1444         ftrace_hash_rec_disable_modify(ops, enable);
1445
1446         rcu_assign_pointer(*dst, new_hash);
1447
1448         ftrace_hash_rec_enable_modify(ops, enable);
1449
1450         return 0;
1451 }
1452
1453 static bool hash_contains_ip(unsigned long ip,
1454                              struct ftrace_ops_hash *hash)
1455 {
1456         /*
1457          * The function record is a match if it exists in the filter
1458          * hash and not in the notrace hash. Note, an emty hash is
1459          * considered a match for the filter hash, but an empty
1460          * notrace hash is considered not in the notrace hash.
1461          */
1462         return (ftrace_hash_empty(hash->filter_hash) ||
1463                 __ftrace_lookup_ip(hash->filter_hash, ip)) &&
1464                 (ftrace_hash_empty(hash->notrace_hash) ||
1465                  !__ftrace_lookup_ip(hash->notrace_hash, ip));
1466 }
1467
1468 /*
1469  * Test the hashes for this ops to see if we want to call
1470  * the ops->func or not.
1471  *
1472  * It's a match if the ip is in the ops->filter_hash or
1473  * the filter_hash does not exist or is empty,
1474  *  AND
1475  * the ip is not in the ops->notrace_hash.
1476  *
1477  * This needs to be called with preemption disabled as
1478  * the hashes are freed with call_rcu().
1479  */
1480 int
1481 ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
1482 {
1483         struct ftrace_ops_hash hash;
1484         int ret;
1485
1486 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
1487         /*
1488          * There's a small race when adding ops that the ftrace handler
1489          * that wants regs, may be called without them. We can not
1490          * allow that handler to be called if regs is NULL.
1491          */
1492         if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS))
1493                 return 0;
1494 #endif
1495
1496         rcu_assign_pointer(hash.filter_hash, ops->func_hash->filter_hash);
1497         rcu_assign_pointer(hash.notrace_hash, ops->func_hash->notrace_hash);
1498
1499         if (hash_contains_ip(ip, &hash))
1500                 ret = 1;
1501         else
1502                 ret = 0;
1503
1504         return ret;
1505 }
1506
1507 /*
1508  * This is a double for. Do not use 'break' to break out of the loop,
1509  * you must use a goto.
1510  */
1511 #define do_for_each_ftrace_rec(pg, rec)                                 \
1512         for (pg = ftrace_pages_start; pg; pg = pg->next) {              \
1513                 int _____i;                                             \
1514                 for (_____i = 0; _____i < pg->index; _____i++) {        \
1515                         rec = &pg->records[_____i];
1516
1517 #define while_for_each_ftrace_rec()             \
1518                 }                               \
1519         }
1520
1521
1522 static int ftrace_cmp_recs(const void *a, const void *b)
1523 {
1524         const struct dyn_ftrace *key = a;
1525         const struct dyn_ftrace *rec = b;
1526
1527         if (key->flags < rec->ip)
1528                 return -1;
1529         if (key->ip >= rec->ip + MCOUNT_INSN_SIZE)
1530                 return 1;
1531         return 0;
1532 }
1533
1534 static struct dyn_ftrace *lookup_rec(unsigned long start, unsigned long end)
1535 {
1536         struct ftrace_page *pg;
1537         struct dyn_ftrace *rec = NULL;
1538         struct dyn_ftrace key;
1539
1540         key.ip = start;
1541         key.flags = end;        /* overload flags, as it is unsigned long */
1542
1543         for (pg = ftrace_pages_start; pg; pg = pg->next) {
1544                 if (end < pg->records[0].ip ||
1545                     start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
1546                         continue;
1547                 rec = bsearch(&key, pg->records, pg->index,
1548                               sizeof(struct dyn_ftrace),
1549                               ftrace_cmp_recs);
1550                 if (rec)
1551                         break;
1552         }
1553         return rec;
1554 }
1555
1556 /**
1557  * ftrace_location_range - return the first address of a traced location
1558  *      if it touches the given ip range
1559  * @start: start of range to search.
1560  * @end: end of range to search (inclusive). @end points to the last byte
1561  *      to check.
1562  *
1563  * Returns rec->ip if the related ftrace location is a least partly within
1564  * the given address range. That is, the first address of the instruction
1565  * that is either a NOP or call to the function tracer. It checks the ftrace
1566  * internal tables to determine if the address belongs or not.
1567  */
1568 unsigned long ftrace_location_range(unsigned long start, unsigned long end)
1569 {
1570         struct dyn_ftrace *rec;
1571
1572         rec = lookup_rec(start, end);
1573         if (rec)
1574                 return rec->ip;
1575
1576         return 0;
1577 }
1578
1579 /**
1580  * ftrace_location - return true if the ip giving is a traced location
1581  * @ip: the instruction pointer to check
1582  *
1583  * Returns rec->ip if @ip given is a pointer to a ftrace location.
1584  * That is, the instruction that is either a NOP or call to
1585  * the function tracer. It checks the ftrace internal tables to
1586  * determine if the address belongs or not.
1587  */
1588 unsigned long ftrace_location(unsigned long ip)
1589 {
1590         return ftrace_location_range(ip, ip);
1591 }
1592
1593 /**
1594  * ftrace_text_reserved - return true if range contains an ftrace location
1595  * @start: start of range to search
1596  * @end: end of range to search (inclusive). @end points to the last byte to check.
1597  *
1598  * Returns 1 if @start and @end contains a ftrace location.
1599  * That is, the instruction that is either a NOP or call to
1600  * the function tracer. It checks the ftrace internal tables to
1601  * determine if the address belongs or not.
1602  */
1603 int ftrace_text_reserved(const void *start, const void *end)
1604 {
1605         unsigned long ret;
1606
1607         ret = ftrace_location_range((unsigned long)start,
1608                                     (unsigned long)end);
1609
1610         return (int)!!ret;
1611 }
1612
1613 /* Test if ops registered to this rec needs regs */
1614 static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec)
1615 {
1616         struct ftrace_ops *ops;
1617         bool keep_regs = false;
1618
1619         for (ops = ftrace_ops_list;
1620              ops != &ftrace_list_end; ops = ops->next) {
1621                 /* pass rec in as regs to have non-NULL val */
1622                 if (ftrace_ops_test(ops, rec->ip, rec)) {
1623                         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
1624                                 keep_regs = true;
1625                                 break;
1626                         }
1627                 }
1628         }
1629
1630         return  keep_regs;
1631 }
1632
1633 static struct ftrace_ops *
1634 ftrace_find_tramp_ops_any(struct dyn_ftrace *rec);
1635 static struct ftrace_ops *
1636 ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, struct ftrace_ops *ops);
1637
1638 static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
1639                                      int filter_hash,
1640                                      bool inc)
1641 {
1642         struct ftrace_hash *hash;
1643         struct ftrace_hash *other_hash;
1644         struct ftrace_page *pg;
1645         struct dyn_ftrace *rec;
1646         bool update = false;
1647         int count = 0;
1648         int all = false;
1649
1650         /* Only update if the ops has been registered */
1651         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1652                 return false;
1653
1654         /*
1655          * In the filter_hash case:
1656          *   If the count is zero, we update all records.
1657          *   Otherwise we just update the items in the hash.
1658          *
1659          * In the notrace_hash case:
1660          *   We enable the update in the hash.
1661          *   As disabling notrace means enabling the tracing,
1662          *   and enabling notrace means disabling, the inc variable
1663          *   gets inversed.
1664          */
1665         if (filter_hash) {
1666                 hash = ops->func_hash->filter_hash;
1667                 other_hash = ops->func_hash->notrace_hash;
1668                 if (ftrace_hash_empty(hash))
1669                         all = true;
1670         } else {
1671                 inc = !inc;
1672                 hash = ops->func_hash->notrace_hash;
1673                 other_hash = ops->func_hash->filter_hash;
1674                 /*
1675                  * If the notrace hash has no items,
1676                  * then there's nothing to do.
1677                  */
1678                 if (ftrace_hash_empty(hash))
1679                         return false;
1680         }
1681
1682         do_for_each_ftrace_rec(pg, rec) {
1683                 int in_other_hash = 0;
1684                 int in_hash = 0;
1685                 int match = 0;
1686
1687                 if (rec->flags & FTRACE_FL_DISABLED)
1688                         continue;
1689
1690                 if (all) {
1691                         /*
1692                          * Only the filter_hash affects all records.
1693                          * Update if the record is not in the notrace hash.
1694                          */
1695                         if (!other_hash || !ftrace_lookup_ip(other_hash, rec->ip))
1696                                 match = 1;
1697                 } else {
1698                         in_hash = !!ftrace_lookup_ip(hash, rec->ip);
1699                         in_other_hash = !!ftrace_lookup_ip(other_hash, rec->ip);
1700
1701                         /*
1702                          * If filter_hash is set, we want to match all functions
1703                          * that are in the hash but not in the other hash.
1704                          *
1705                          * If filter_hash is not set, then we are decrementing.
1706                          * That means we match anything that is in the hash
1707                          * and also in the other_hash. That is, we need to turn
1708                          * off functions in the other hash because they are disabled
1709                          * by this hash.
1710                          */
1711                         if (filter_hash && in_hash && !in_other_hash)
1712                                 match = 1;
1713                         else if (!filter_hash && in_hash &&
1714                                  (in_other_hash || ftrace_hash_empty(other_hash)))
1715                                 match = 1;
1716                 }
1717                 if (!match)
1718                         continue;
1719
1720                 if (inc) {
1721                         rec->flags++;
1722                         if (FTRACE_WARN_ON(ftrace_rec_count(rec) == FTRACE_REF_MAX))
1723                                 return false;
1724
1725                         if (ops->flags & FTRACE_OPS_FL_DIRECT)
1726                                 rec->flags |= FTRACE_FL_DIRECT;
1727
1728                         /*
1729                          * If there's only a single callback registered to a
1730                          * function, and the ops has a trampoline registered
1731                          * for it, then we can call it directly.
1732                          */
1733                         if (ftrace_rec_count(rec) == 1 && ops->trampoline)
1734                                 rec->flags |= FTRACE_FL_TRAMP;
1735                         else
1736                                 /*
1737                                  * If we are adding another function callback
1738                                  * to this function, and the previous had a
1739                                  * custom trampoline in use, then we need to go
1740                                  * back to the default trampoline.
1741                                  */
1742                                 rec->flags &= ~FTRACE_FL_TRAMP;
1743
1744                         /*
1745                          * If any ops wants regs saved for this function
1746                          * then all ops will get saved regs.
1747                          */
1748                         if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
1749                                 rec->flags |= FTRACE_FL_REGS;
1750                 } else {
1751                         if (FTRACE_WARN_ON(ftrace_rec_count(rec) == 0))
1752                                 return false;
1753                         rec->flags--;
1754
1755                         /*
1756                          * Only the internal direct_ops should have the
1757                          * DIRECT flag set. Thus, if it is removing a
1758                          * function, then that function should no longer
1759                          * be direct.
1760                          */
1761                         if (ops->flags & FTRACE_OPS_FL_DIRECT)
1762                                 rec->flags &= ~FTRACE_FL_DIRECT;
1763
1764                         /*
1765                          * If the rec had REGS enabled and the ops that is
1766                          * being removed had REGS set, then see if there is
1767                          * still any ops for this record that wants regs.
1768                          * If not, we can stop recording them.
1769                          */
1770                         if (ftrace_rec_count(rec) > 0 &&
1771                             rec->flags & FTRACE_FL_REGS &&
1772                             ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
1773                                 if (!test_rec_ops_needs_regs(rec))
1774                                         rec->flags &= ~FTRACE_FL_REGS;
1775                         }
1776
1777                         /*
1778                          * The TRAMP needs to be set only if rec count
1779                          * is decremented to one, and the ops that is
1780                          * left has a trampoline. As TRAMP can only be
1781                          * enabled if there is only a single ops attached
1782                          * to it.
1783                          */
1784                         if (ftrace_rec_count(rec) == 1 &&
1785                             ftrace_find_tramp_ops_any(rec))
1786                                 rec->flags |= FTRACE_FL_TRAMP;
1787                         else
1788                                 rec->flags &= ~FTRACE_FL_TRAMP;
1789
1790                         /*
1791                          * flags will be cleared in ftrace_check_record()
1792                          * if rec count is zero.
1793                          */
1794                 }
1795                 count++;
1796
1797                 /* Must match FTRACE_UPDATE_CALLS in ftrace_modify_all_code() */
1798                 update |= ftrace_test_record(rec, true) != FTRACE_UPDATE_IGNORE;
1799
1800                 /* Shortcut, if we handled all records, we are done. */
1801                 if (!all && count == hash->count)
1802                         return update;
1803         } while_for_each_ftrace_rec();
1804
1805         return update;
1806 }
1807
1808 static bool ftrace_hash_rec_disable(struct ftrace_ops *ops,
1809                                     int filter_hash)
1810 {
1811         return __ftrace_hash_rec_update(ops, filter_hash, 0);
1812 }
1813
1814 static bool ftrace_hash_rec_enable(struct ftrace_ops *ops,
1815                                    int filter_hash)
1816 {
1817         return __ftrace_hash_rec_update(ops, filter_hash, 1);
1818 }
1819
1820 static void ftrace_hash_rec_update_modify(struct ftrace_ops *ops,
1821                                           int filter_hash, int inc)
1822 {
1823         struct ftrace_ops *op;
1824
1825         __ftrace_hash_rec_update(ops, filter_hash, inc);
1826
1827         if (ops->func_hash != &global_ops.local_hash)
1828                 return;
1829
1830         /*
1831          * If the ops shares the global_ops hash, then we need to update
1832          * all ops that are enabled and use this hash.
1833          */
1834         do_for_each_ftrace_op(op, ftrace_ops_list) {
1835                 /* Already done */
1836                 if (op == ops)
1837                         continue;
1838                 if (op->func_hash == &global_ops.local_hash)
1839                         __ftrace_hash_rec_update(op, filter_hash, inc);
1840         } while_for_each_ftrace_op(op);
1841 }
1842
1843 static void ftrace_hash_rec_disable_modify(struct ftrace_ops *ops,
1844                                            int filter_hash)
1845 {
1846         ftrace_hash_rec_update_modify(ops, filter_hash, 0);
1847 }
1848
1849 static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops,
1850                                           int filter_hash)
1851 {
1852         ftrace_hash_rec_update_modify(ops, filter_hash, 1);
1853 }
1854
1855 /*
1856  * Try to update IPMODIFY flag on each ftrace_rec. Return 0 if it is OK
1857  * or no-needed to update, -EBUSY if it detects a conflict of the flag
1858  * on a ftrace_rec, and -EINVAL if the new_hash tries to trace all recs.
1859  * Note that old_hash and new_hash has below meanings
1860  *  - If the hash is NULL, it hits all recs (if IPMODIFY is set, this is rejected)
1861  *  - If the hash is EMPTY_HASH, it hits nothing
1862  *  - Anything else hits the recs which match the hash entries.
1863  */
1864 static int __ftrace_hash_update_ipmodify(struct ftrace_ops *ops,
1865                                          struct ftrace_hash *old_hash,
1866                                          struct ftrace_hash *new_hash)
1867 {
1868         struct ftrace_page *pg;
1869         struct dyn_ftrace *rec, *end = NULL;
1870         int in_old, in_new;
1871
1872         /* Only update if the ops has been registered */
1873         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
1874                 return 0;
1875
1876         if (!(ops->flags & FTRACE_OPS_FL_IPMODIFY))
1877                 return 0;
1878
1879         /*
1880          * Since the IPMODIFY is a very address sensitive action, we do not
1881          * allow ftrace_ops to set all functions to new hash.
1882          */
1883         if (!new_hash || !old_hash)
1884                 return -EINVAL;
1885
1886         /* Update rec->flags */
1887         do_for_each_ftrace_rec(pg, rec) {
1888
1889                 if (rec->flags & FTRACE_FL_DISABLED)
1890                         continue;
1891
1892                 /* We need to update only differences of filter_hash */
1893                 in_old = !!ftrace_lookup_ip(old_hash, rec->ip);
1894                 in_new = !!ftrace_lookup_ip(new_hash, rec->ip);
1895                 if (in_old == in_new)
1896                         continue;
1897
1898                 if (in_new) {
1899                         /* New entries must ensure no others are using it */
1900                         if (rec->flags & FTRACE_FL_IPMODIFY)
1901                                 goto rollback;
1902                         rec->flags |= FTRACE_FL_IPMODIFY;
1903                 } else /* Removed entry */
1904                         rec->flags &= ~FTRACE_FL_IPMODIFY;
1905         } while_for_each_ftrace_rec();
1906
1907         return 0;
1908
1909 rollback:
1910         end = rec;
1911
1912         /* Roll back what we did above */
1913         do_for_each_ftrace_rec(pg, rec) {
1914
1915                 if (rec->flags & FTRACE_FL_DISABLED)
1916                         continue;
1917
1918                 if (rec == end)
1919                         goto err_out;
1920
1921                 in_old = !!ftrace_lookup_ip(old_hash, rec->ip);
1922                 in_new = !!ftrace_lookup_ip(new_hash, rec->ip);
1923                 if (in_old == in_new)
1924                         continue;
1925
1926                 if (in_new)
1927                         rec->flags &= ~FTRACE_FL_IPMODIFY;
1928                 else
1929                         rec->flags |= FTRACE_FL_IPMODIFY;
1930         } while_for_each_ftrace_rec();
1931
1932 err_out:
1933         return -EBUSY;
1934 }
1935
1936 static int ftrace_hash_ipmodify_enable(struct ftrace_ops *ops)
1937 {
1938         struct ftrace_hash *hash = ops->func_hash->filter_hash;
1939
1940         if (ftrace_hash_empty(hash))
1941                 hash = NULL;
1942
1943         return __ftrace_hash_update_ipmodify(ops, EMPTY_HASH, hash);
1944 }
1945
1946 /* Disabling always succeeds */
1947 static void ftrace_hash_ipmodify_disable(struct ftrace_ops *ops)
1948 {
1949         struct ftrace_hash *hash = ops->func_hash->filter_hash;
1950
1951         if (ftrace_hash_empty(hash))
1952                 hash = NULL;
1953
1954         __ftrace_hash_update_ipmodify(ops, hash, EMPTY_HASH);
1955 }
1956
1957 static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops,
1958                                        struct ftrace_hash *new_hash)
1959 {
1960         struct ftrace_hash *old_hash = ops->func_hash->filter_hash;
1961
1962         if (ftrace_hash_empty(old_hash))
1963                 old_hash = NULL;
1964
1965         if (ftrace_hash_empty(new_hash))
1966                 new_hash = NULL;
1967
1968         return __ftrace_hash_update_ipmodify(ops, old_hash, new_hash);
1969 }
1970
1971 static void print_ip_ins(const char *fmt, const unsigned char *p)
1972 {
1973         int i;
1974
1975         printk(KERN_CONT "%s", fmt);
1976
1977         for (i = 0; i < MCOUNT_INSN_SIZE; i++)
1978                 printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
1979 }
1980
1981 enum ftrace_bug_type ftrace_bug_type;
1982 const void *ftrace_expected;
1983
1984 static void print_bug_type(void)
1985 {
1986         switch (ftrace_bug_type) {
1987         case FTRACE_BUG_UNKNOWN:
1988                 break;
1989         case FTRACE_BUG_INIT:
1990                 pr_info("Initializing ftrace call sites\n");
1991                 break;
1992         case FTRACE_BUG_NOP:
1993                 pr_info("Setting ftrace call site to NOP\n");
1994                 break;
1995         case FTRACE_BUG_CALL:
1996                 pr_info("Setting ftrace call site to call ftrace function\n");
1997                 break;
1998         case FTRACE_BUG_UPDATE:
1999                 pr_info("Updating ftrace call site to call a different ftrace function\n");
2000                 break;
2001         }
2002 }
2003
2004 /**
2005  * ftrace_bug - report and shutdown function tracer
2006  * @failed: The failed type (EFAULT, EINVAL, EPERM)
2007  * @rec: The record that failed
2008  *
2009  * The arch code that enables or disables the function tracing
2010  * can call ftrace_bug() when it has detected a problem in
2011  * modifying the code. @failed should be one of either:
2012  * EFAULT - if the problem happens on reading the @ip address
2013  * EINVAL - if what is read at @ip is not what was expected
2014  * EPERM - if the problem happens on writing to the @ip address
2015  */
2016 void ftrace_bug(int failed, struct dyn_ftrace *rec)
2017 {
2018         unsigned long ip = rec ? rec->ip : 0;
2019
2020         switch (failed) {
2021         case -EFAULT:
2022                 FTRACE_WARN_ON_ONCE(1);
2023                 pr_info("ftrace faulted on modifying ");
2024                 print_ip_sym(ip);
2025                 break;
2026         case -EINVAL:
2027                 FTRACE_WARN_ON_ONCE(1);
2028                 pr_info("ftrace failed to modify ");
2029                 print_ip_sym(ip);
2030                 print_ip_ins(" actual:   ", (unsigned char *)ip);
2031                 pr_cont("\n");
2032                 if (ftrace_expected) {
2033                         print_ip_ins(" expected: ", ftrace_expected);
2034                         pr_cont("\n");
2035                 }
2036                 break;
2037         case -EPERM:
2038                 FTRACE_WARN_ON_ONCE(1);
2039                 pr_info("ftrace faulted on writing ");
2040                 print_ip_sym(ip);
2041                 break;
2042         default:
2043                 FTRACE_WARN_ON_ONCE(1);
2044                 pr_info("ftrace faulted on unknown error ");
2045                 print_ip_sym(ip);
2046         }
2047         print_bug_type();
2048         if (rec) {
2049                 struct ftrace_ops *ops = NULL;
2050
2051                 pr_info("ftrace record flags: %lx\n", rec->flags);
2052                 pr_cont(" (%ld)%s", ftrace_rec_count(rec),
2053                         rec->flags & FTRACE_FL_REGS ? " R" : "  ");
2054                 if (rec->flags & FTRACE_FL_TRAMP_EN) {
2055                         ops = ftrace_find_tramp_ops_any(rec);
2056                         if (ops) {
2057                                 do {
2058                                         pr_cont("\ttramp: %pS (%pS)",
2059                                                 (void *)ops->trampoline,
2060                                                 (void *)ops->func);
2061                                         ops = ftrace_find_tramp_ops_next(rec, ops);
2062                                 } while (ops);
2063                         } else
2064                                 pr_cont("\ttramp: ERROR!");
2065
2066                 }
2067                 ip = ftrace_get_addr_curr(rec);
2068                 pr_cont("\n expected tramp: %lx\n", ip);
2069         }
2070 }
2071
2072 static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update)
2073 {
2074         unsigned long flag = 0UL;
2075
2076         ftrace_bug_type = FTRACE_BUG_UNKNOWN;
2077
2078         if (rec->flags & FTRACE_FL_DISABLED)
2079                 return FTRACE_UPDATE_IGNORE;
2080
2081         /*
2082          * If we are updating calls:
2083          *
2084          *   If the record has a ref count, then we need to enable it
2085          *   because someone is using it.
2086          *
2087          *   Otherwise we make sure its disabled.
2088          *
2089          * If we are disabling calls, then disable all records that
2090          * are enabled.
2091          */
2092         if (enable && ftrace_rec_count(rec))
2093                 flag = FTRACE_FL_ENABLED;
2094
2095         /*
2096          * If enabling and the REGS flag does not match the REGS_EN, or
2097          * the TRAMP flag doesn't match the TRAMP_EN, then do not ignore
2098          * this record. Set flags to fail the compare against ENABLED.
2099          * Same for direct calls.
2100          */
2101         if (flag) {
2102                 if (!(rec->flags & FTRACE_FL_REGS) !=
2103                     !(rec->flags & FTRACE_FL_REGS_EN))
2104                         flag |= FTRACE_FL_REGS;
2105
2106                 if (!(rec->flags & FTRACE_FL_TRAMP) !=
2107                     !(rec->flags & FTRACE_FL_TRAMP_EN))
2108                         flag |= FTRACE_FL_TRAMP;
2109
2110                 /*
2111                  * Direct calls are special, as count matters.
2112                  * We must test the record for direct, if the
2113                  * DIRECT and DIRECT_EN do not match, but only
2114                  * if the count is 1. That's because, if the
2115                  * count is something other than one, we do not
2116                  * want the direct enabled (it will be done via the
2117                  * direct helper). But if DIRECT_EN is set, and
2118                  * the count is not one, we need to clear it.
2119                  */
2120                 if (ftrace_rec_count(rec) == 1) {
2121                         if (!(rec->flags & FTRACE_FL_DIRECT) !=
2122                             !(rec->flags & FTRACE_FL_DIRECT_EN))
2123                                 flag |= FTRACE_FL_DIRECT;
2124                 } else if (rec->flags & FTRACE_FL_DIRECT_EN) {
2125                         flag |= FTRACE_FL_DIRECT;
2126                 }
2127         }
2128
2129         /* If the state of this record hasn't changed, then do nothing */
2130         if ((rec->flags & FTRACE_FL_ENABLED) == flag)
2131                 return FTRACE_UPDATE_IGNORE;
2132
2133         if (flag) {
2134                 /* Save off if rec is being enabled (for return value) */
2135                 flag ^= rec->flags & FTRACE_FL_ENABLED;
2136
2137                 if (update) {
2138                         rec->flags |= FTRACE_FL_ENABLED;
2139                         if (flag & FTRACE_FL_REGS) {
2140                                 if (rec->flags & FTRACE_FL_REGS)
2141                                         rec->flags |= FTRACE_FL_REGS_EN;
2142                                 else
2143                                         rec->flags &= ~FTRACE_FL_REGS_EN;
2144                         }
2145                         if (flag & FTRACE_FL_TRAMP) {
2146                                 if (rec->flags & FTRACE_FL_TRAMP)
2147                                         rec->flags |= FTRACE_FL_TRAMP_EN;
2148                                 else
2149                                         rec->flags &= ~FTRACE_FL_TRAMP_EN;
2150                         }
2151                         if (flag & FTRACE_FL_DIRECT) {
2152                                 /*
2153                                  * If there's only one user (direct_ops helper)
2154                                  * then we can call the direct function
2155                                  * directly (no ftrace trampoline).
2156                                  */
2157                                 if (ftrace_rec_count(rec) == 1) {
2158                                         if (rec->flags & FTRACE_FL_DIRECT)
2159                                                 rec->flags |= FTRACE_FL_DIRECT_EN;
2160                                         else
2161                                                 rec->flags &= ~FTRACE_FL_DIRECT_EN;
2162                                 } else {
2163                                         /*
2164                                          * Can only call directly if there's
2165                                          * only one callback to the function.
2166                                          */
2167                                         rec->flags &= ~FTRACE_FL_DIRECT_EN;
2168                                 }
2169                         }
2170                 }
2171
2172                 /*
2173                  * If this record is being updated from a nop, then
2174                  *   return UPDATE_MAKE_CALL.
2175                  * Otherwise,
2176                  *   return UPDATE_MODIFY_CALL to tell the caller to convert
2177                  *   from the save regs, to a non-save regs function or
2178                  *   vice versa, or from a trampoline call.
2179                  */
2180                 if (flag & FTRACE_FL_ENABLED) {
2181                         ftrace_bug_type = FTRACE_BUG_CALL;
2182                         return FTRACE_UPDATE_MAKE_CALL;
2183                 }
2184
2185                 ftrace_bug_type = FTRACE_BUG_UPDATE;
2186                 return FTRACE_UPDATE_MODIFY_CALL;
2187         }
2188
2189         if (update) {
2190                 /* If there's no more users, clear all flags */
2191                 if (!ftrace_rec_count(rec))
2192                         rec->flags = 0;
2193                 else
2194                         /*
2195                          * Just disable the record, but keep the ops TRAMP
2196                          * and REGS states. The _EN flags must be disabled though.
2197                          */
2198                         rec->flags &= ~(FTRACE_FL_ENABLED | FTRACE_FL_TRAMP_EN |
2199                                         FTRACE_FL_REGS_EN | FTRACE_FL_DIRECT_EN);
2200         }
2201
2202         ftrace_bug_type = FTRACE_BUG_NOP;
2203         return FTRACE_UPDATE_MAKE_NOP;
2204 }
2205
2206 /**
2207  * ftrace_update_record, set a record that now is tracing or not
2208  * @rec: the record to update
2209  * @enable: set to true if the record is tracing, false to force disable
2210  *
2211  * The records that represent all functions that can be traced need
2212  * to be updated when tracing has been enabled.
2213  */
2214 int ftrace_update_record(struct dyn_ftrace *rec, bool enable)
2215 {
2216         return ftrace_check_record(rec, enable, true);
2217 }
2218
2219 /**
2220  * ftrace_test_record, check if the record has been enabled or not
2221  * @rec: the record to test
2222  * @enable: set to true to check if enabled, false if it is disabled
2223  *
2224  * The arch code may need to test if a record is already set to
2225  * tracing to determine how to modify the function code that it
2226  * represents.
2227  */
2228 int ftrace_test_record(struct dyn_ftrace *rec, bool enable)
2229 {
2230         return ftrace_check_record(rec, enable, false);
2231 }
2232
2233 static struct ftrace_ops *
2234 ftrace_find_tramp_ops_any(struct dyn_ftrace *rec)
2235 {
2236         struct ftrace_ops *op;
2237         unsigned long ip = rec->ip;
2238
2239         do_for_each_ftrace_op(op, ftrace_ops_list) {
2240
2241                 if (!op->trampoline)
2242                         continue;
2243
2244                 if (hash_contains_ip(ip, op->func_hash))
2245                         return op;
2246         } while_for_each_ftrace_op(op);
2247
2248         return NULL;
2249 }
2250
2251 static struct ftrace_ops *
2252 ftrace_find_tramp_ops_next(struct dyn_ftrace *rec,
2253                            struct ftrace_ops *op)
2254 {
2255         unsigned long ip = rec->ip;
2256
2257         while_for_each_ftrace_op(op) {
2258
2259                 if (!op->trampoline)
2260                         continue;
2261
2262                 if (hash_contains_ip(ip, op->func_hash))
2263                         return op;
2264         }
2265
2266         return NULL;
2267 }
2268
2269 static struct ftrace_ops *
2270 ftrace_find_tramp_ops_curr(struct dyn_ftrace *rec)
2271 {
2272         struct ftrace_ops *op;
2273         unsigned long ip = rec->ip;
2274
2275         /*
2276          * Need to check removed ops first.
2277          * If they are being removed, and this rec has a tramp,
2278          * and this rec is in the ops list, then it would be the
2279          * one with the tramp.
2280          */
2281         if (removed_ops) {
2282                 if (hash_contains_ip(ip, &removed_ops->old_hash))
2283                         return removed_ops;
2284         }
2285
2286         /*
2287          * Need to find the current trampoline for a rec.
2288          * Now, a trampoline is only attached to a rec if there
2289          * was a single 'ops' attached to it. But this can be called
2290          * when we are adding another op to the rec or removing the
2291          * current one. Thus, if the op is being added, we can
2292          * ignore it because it hasn't attached itself to the rec
2293          * yet.
2294          *
2295          * If an ops is being modified (hooking to different functions)
2296          * then we don't care about the new functions that are being
2297          * added, just the old ones (that are probably being removed).
2298          *
2299          * If we are adding an ops to a function that already is using
2300          * a trampoline, it needs to be removed (trampolines are only
2301          * for single ops connected), then an ops that is not being
2302          * modified also needs to be checked.
2303          */
2304         do_for_each_ftrace_op(op, ftrace_ops_list) {
2305
2306                 if (!op->trampoline)
2307                         continue;
2308
2309                 /*
2310                  * If the ops is being added, it hasn't gotten to
2311                  * the point to be removed from this tree yet.
2312                  */
2313                 if (op->flags & FTRACE_OPS_FL_ADDING)
2314                         continue;
2315
2316
2317                 /*
2318                  * If the ops is being modified and is in the old
2319                  * hash, then it is probably being removed from this
2320                  * function.
2321                  */
2322                 if ((op->flags & FTRACE_OPS_FL_MODIFYING) &&
2323                     hash_contains_ip(ip, &op->old_hash))
2324                         return op;
2325                 /*
2326                  * If the ops is not being added or modified, and it's
2327                  * in its normal filter hash, then this must be the one
2328                  * we want!
2329                  */
2330                 if (!(op->flags & FTRACE_OPS_FL_MODIFYING) &&
2331                     hash_contains_ip(ip, op->func_hash))
2332                         return op;
2333
2334         } while_for_each_ftrace_op(op);
2335
2336         return NULL;
2337 }
2338
2339 static struct ftrace_ops *
2340 ftrace_find_tramp_ops_new(struct dyn_ftrace *rec)
2341 {
2342         struct ftrace_ops *op;
2343         unsigned long ip = rec->ip;
2344
2345         do_for_each_ftrace_op(op, ftrace_ops_list) {
2346                 /* pass rec in as regs to have non-NULL val */
2347                 if (hash_contains_ip(ip, op->func_hash))
2348                         return op;
2349         } while_for_each_ftrace_op(op);
2350
2351         return NULL;
2352 }
2353
2354 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
2355 /* Protected by rcu_tasks for reading, and direct_mutex for writing */
2356 static struct ftrace_hash *direct_functions = EMPTY_HASH;
2357 static DEFINE_MUTEX(direct_mutex);
2358 int ftrace_direct_func_count;
2359
2360 /*
2361  * Search the direct_functions hash to see if the given instruction pointer
2362  * has a direct caller attached to it.
2363  */
2364 unsigned long ftrace_find_rec_direct(unsigned long ip)
2365 {
2366         struct ftrace_func_entry *entry;
2367
2368         entry = __ftrace_lookup_ip(direct_functions, ip);
2369         if (!entry)
2370                 return 0;
2371
2372         return entry->direct;
2373 }
2374
2375 static void call_direct_funcs(unsigned long ip, unsigned long pip,
2376                               struct ftrace_ops *ops, struct pt_regs *regs)
2377 {
2378         unsigned long addr;
2379
2380         addr = ftrace_find_rec_direct(ip);
2381         if (!addr)
2382                 return;
2383
2384         arch_ftrace_set_direct_caller(regs, addr);
2385 }
2386
2387 struct ftrace_ops direct_ops = {
2388         .func           = call_direct_funcs,
2389         .flags          = FTRACE_OPS_FL_IPMODIFY | FTRACE_OPS_FL_RECURSION_SAFE
2390                           | FTRACE_OPS_FL_DIRECT | FTRACE_OPS_FL_SAVE_REGS
2391                           | FTRACE_OPS_FL_PERMANENT,
2392 };
2393 #endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
2394
2395 /**
2396  * ftrace_get_addr_new - Get the call address to set to
2397  * @rec:  The ftrace record descriptor
2398  *
2399  * If the record has the FTRACE_FL_REGS set, that means that it
2400  * wants to convert to a callback that saves all regs. If FTRACE_FL_REGS
2401  * is not not set, then it wants to convert to the normal callback.
2402  *
2403  * Returns the address of the trampoline to set to
2404  */
2405 unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec)
2406 {
2407         struct ftrace_ops *ops;
2408         unsigned long addr;
2409
2410         if ((rec->flags & FTRACE_FL_DIRECT) &&
2411             (ftrace_rec_count(rec) == 1)) {
2412                 addr = ftrace_find_rec_direct(rec->ip);
2413                 if (addr)
2414                         return addr;
2415                 WARN_ON_ONCE(1);
2416         }
2417
2418         /* Trampolines take precedence over regs */
2419         if (rec->flags & FTRACE_FL_TRAMP) {
2420                 ops = ftrace_find_tramp_ops_new(rec);
2421                 if (FTRACE_WARN_ON(!ops || !ops->trampoline)) {
2422                         pr_warn("Bad trampoline accounting at: %p (%pS) (%lx)\n",
2423                                 (void *)rec->ip, (void *)rec->ip, rec->flags);
2424                         /* Ftrace is shutting down, return anything */
2425                         return (unsigned long)FTRACE_ADDR;
2426                 }
2427                 return ops->trampoline;
2428         }
2429
2430         if (rec->flags & FTRACE_FL_REGS)
2431                 return (unsigned long)FTRACE_REGS_ADDR;
2432         else
2433                 return (unsigned long)FTRACE_ADDR;
2434 }
2435
2436 /**
2437  * ftrace_get_addr_curr - Get the call address that is already there
2438  * @rec:  The ftrace record descriptor
2439  *
2440  * The FTRACE_FL_REGS_EN is set when the record already points to
2441  * a function that saves all the regs. Basically the '_EN' version
2442  * represents the current state of the function.
2443  *
2444  * Returns the address of the trampoline that is currently being called
2445  */
2446 unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec)
2447 {
2448         struct ftrace_ops *ops;
2449         unsigned long addr;
2450
2451         /* Direct calls take precedence over trampolines */
2452         if (rec->flags & FTRACE_FL_DIRECT_EN) {
2453                 addr = ftrace_find_rec_direct(rec->ip);
2454                 if (addr)
2455                         return addr;
2456                 WARN_ON_ONCE(1);
2457         }
2458
2459         /* Trampolines take precedence over regs */
2460         if (rec->flags & FTRACE_FL_TRAMP_EN) {
2461                 ops = ftrace_find_tramp_ops_curr(rec);
2462                 if (FTRACE_WARN_ON(!ops)) {
2463                         pr_warn("Bad trampoline accounting at: %p (%pS)\n",
2464                                 (void *)rec->ip, (void *)rec->ip);
2465                         /* Ftrace is shutting down, return anything */
2466                         return (unsigned long)FTRACE_ADDR;
2467                 }
2468                 return ops->trampoline;
2469         }
2470
2471         if (rec->flags & FTRACE_FL_REGS_EN)
2472                 return (unsigned long)FTRACE_REGS_ADDR;
2473         else
2474                 return (unsigned long)FTRACE_ADDR;
2475 }
2476
2477 static int
2478 __ftrace_replace_code(struct dyn_ftrace *rec, bool enable)
2479 {
2480         unsigned long ftrace_old_addr;
2481         unsigned long ftrace_addr;
2482         int ret;
2483
2484         ftrace_addr = ftrace_get_addr_new(rec);
2485
2486         /* This needs to be done before we call ftrace_update_record */
2487         ftrace_old_addr = ftrace_get_addr_curr(rec);
2488
2489         ret = ftrace_update_record(rec, enable);
2490
2491         ftrace_bug_type = FTRACE_BUG_UNKNOWN;
2492
2493         switch (ret) {
2494         case FTRACE_UPDATE_IGNORE:
2495                 return 0;
2496
2497         case FTRACE_UPDATE_MAKE_CALL:
2498                 ftrace_bug_type = FTRACE_BUG_CALL;
2499                 return ftrace_make_call(rec, ftrace_addr);
2500
2501         case FTRACE_UPDATE_MAKE_NOP:
2502                 ftrace_bug_type = FTRACE_BUG_NOP;
2503                 return ftrace_make_nop(NULL, rec, ftrace_old_addr);
2504
2505         case FTRACE_UPDATE_MODIFY_CALL:
2506                 ftrace_bug_type = FTRACE_BUG_UPDATE;
2507                 return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr);
2508         }
2509
2510         return -1; /* unknown ftrace bug */
2511 }
2512
2513 void __weak ftrace_replace_code(int mod_flags)
2514 {
2515         struct dyn_ftrace *rec;
2516         struct ftrace_page *pg;
2517         bool enable = mod_flags & FTRACE_MODIFY_ENABLE_FL;
2518         int schedulable = mod_flags & FTRACE_MODIFY_MAY_SLEEP_FL;
2519         int failed;
2520
2521         if (unlikely(ftrace_disabled))
2522                 return;
2523
2524         do_for_each_ftrace_rec(pg, rec) {
2525
2526                 if (rec->flags & FTRACE_FL_DISABLED)
2527                         continue;
2528
2529                 failed = __ftrace_replace_code(rec, enable);
2530                 if (failed) {
2531                         ftrace_bug(failed, rec);
2532                         /* Stop processing */
2533                         return;
2534                 }
2535                 if (schedulable)
2536                         cond_resched();
2537         } while_for_each_ftrace_rec();
2538 }
2539
2540 struct ftrace_rec_iter {
2541         struct ftrace_page      *pg;
2542         int                     index;
2543 };
2544
2545 /**
2546  * ftrace_rec_iter_start, start up iterating over traced functions
2547  *
2548  * Returns an iterator handle that is used to iterate over all
2549  * the records that represent address locations where functions
2550  * are traced.
2551  *
2552  * May return NULL if no records are available.
2553  */
2554 struct ftrace_rec_iter *ftrace_rec_iter_start(void)
2555 {
2556         /*
2557          * We only use a single iterator.
2558          * Protected by the ftrace_lock mutex.
2559          */
2560         static struct ftrace_rec_iter ftrace_rec_iter;
2561         struct ftrace_rec_iter *iter = &ftrace_rec_iter;
2562
2563         iter->pg = ftrace_pages_start;
2564         iter->index = 0;
2565
2566         /* Could have empty pages */
2567         while (iter->pg && !iter->pg->index)
2568                 iter->pg = iter->pg->next;
2569
2570         if (!iter->pg)
2571                 return NULL;
2572
2573         return iter;
2574 }
2575
2576 /**
2577  * ftrace_rec_iter_next, get the next record to process.
2578  * @iter: The handle to the iterator.
2579  *
2580  * Returns the next iterator after the given iterator @iter.
2581  */
2582 struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter)
2583 {
2584         iter->index++;
2585
2586         if (iter->index >= iter->pg->index) {
2587                 iter->pg = iter->pg->next;
2588                 iter->index = 0;
2589
2590                 /* Could have empty pages */
2591                 while (iter->pg && !iter->pg->index)
2592                         iter->pg = iter->pg->next;
2593         }
2594
2595         if (!iter->pg)
2596                 return NULL;
2597
2598         return iter;
2599 }
2600
2601 /**
2602  * ftrace_rec_iter_record, get the record at the iterator location
2603  * @iter: The current iterator location
2604  *
2605  * Returns the record that the current @iter is at.
2606  */
2607 struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)
2608 {
2609         return &iter->pg->records[iter->index];
2610 }
2611
2612 static int
2613 ftrace_nop_initialize(struct module *mod, struct dyn_ftrace *rec)
2614 {
2615         int ret;
2616
2617         if (unlikely(ftrace_disabled))
2618                 return 0;
2619
2620         ret = ftrace_init_nop(mod, rec);
2621         if (ret) {
2622                 ftrace_bug_type = FTRACE_BUG_INIT;
2623                 ftrace_bug(ret, rec);
2624                 return 0;
2625         }
2626         return 1;
2627 }
2628
2629 /*
2630  * archs can override this function if they must do something
2631  * before the modifying code is performed.
2632  */
2633 int __weak ftrace_arch_code_modify_prepare(void)
2634 {
2635         return 0;
2636 }
2637
2638 /*
2639  * archs can override this function if they must do something
2640  * after the modifying code is performed.
2641  */
2642 int __weak ftrace_arch_code_modify_post_process(void)
2643 {
2644         return 0;
2645 }
2646
2647 void ftrace_modify_all_code(int command)
2648 {
2649         int update = command & FTRACE_UPDATE_TRACE_FUNC;
2650         int mod_flags = 0;
2651         int err = 0;
2652
2653         if (command & FTRACE_MAY_SLEEP)
2654                 mod_flags = FTRACE_MODIFY_MAY_SLEEP_FL;
2655
2656         /*
2657          * If the ftrace_caller calls a ftrace_ops func directly,
2658          * we need to make sure that it only traces functions it
2659          * expects to trace. When doing the switch of functions,
2660          * we need to update to the ftrace_ops_list_func first
2661          * before the transition between old and new calls are set,
2662          * as the ftrace_ops_list_func will check the ops hashes
2663          * to make sure the ops are having the right functions
2664          * traced.
2665          */
2666         if (update) {
2667                 err = ftrace_update_ftrace_func(ftrace_ops_list_func);
2668                 if (FTRACE_WARN_ON(err))
2669                         return;
2670         }
2671
2672         if (command & FTRACE_UPDATE_CALLS)
2673                 ftrace_replace_code(mod_flags | FTRACE_MODIFY_ENABLE_FL);
2674         else if (command & FTRACE_DISABLE_CALLS)
2675                 ftrace_replace_code(mod_flags);
2676
2677         if (update && ftrace_trace_function != ftrace_ops_list_func) {
2678                 function_trace_op = set_function_trace_op;
2679                 smp_wmb();
2680                 /* If irqs are disabled, we are in stop machine */
2681                 if (!irqs_disabled())
2682                         smp_call_function(ftrace_sync_ipi, NULL, 1);
2683                 err = ftrace_update_ftrace_func(ftrace_trace_function);
2684                 if (FTRACE_WARN_ON(err))
2685                         return;
2686         }
2687
2688         if (command & FTRACE_START_FUNC_RET)
2689                 err = ftrace_enable_ftrace_graph_caller();
2690         else if (command & FTRACE_STOP_FUNC_RET)
2691                 err = ftrace_disable_ftrace_graph_caller();
2692         FTRACE_WARN_ON(err);
2693 }
2694
2695 static int __ftrace_modify_code(void *data)
2696 {
2697         int *command = data;
2698
2699         ftrace_modify_all_code(*command);
2700
2701         return 0;
2702 }
2703
2704 /**
2705  * ftrace_run_stop_machine, go back to the stop machine method
2706  * @command: The command to tell ftrace what to do
2707  *
2708  * If an arch needs to fall back to the stop machine method, the
2709  * it can call this function.
2710  */
2711 void ftrace_run_stop_machine(int command)
2712 {
2713         stop_machine(__ftrace_modify_code, &command, NULL);
2714 }
2715
2716 /**
2717  * arch_ftrace_update_code, modify the code to trace or not trace
2718  * @command: The command that needs to be done
2719  *
2720  * Archs can override this function if it does not need to
2721  * run stop_machine() to modify code.
2722  */
2723 void __weak arch_ftrace_update_code(int command)
2724 {
2725         ftrace_run_stop_machine(command);
2726 }
2727
2728 static void ftrace_run_update_code(int command)
2729 {
2730         int ret;
2731
2732         ret = ftrace_arch_code_modify_prepare();
2733         FTRACE_WARN_ON(ret);
2734         if (ret)
2735                 return;
2736
2737         /*
2738          * By default we use stop_machine() to modify the code.
2739          * But archs can do what ever they want as long as it
2740          * is safe. The stop_machine() is the safest, but also
2741          * produces the most overhead.
2742          */
2743         arch_ftrace_update_code(command);
2744
2745         ret = ftrace_arch_code_modify_post_process();
2746         FTRACE_WARN_ON(ret);
2747 }
2748
2749 static void ftrace_run_modify_code(struct ftrace_ops *ops, int command,
2750                                    struct ftrace_ops_hash *old_hash)
2751 {
2752         ops->flags |= FTRACE_OPS_FL_MODIFYING;
2753         ops->old_hash.filter_hash = old_hash->filter_hash;
2754         ops->old_hash.notrace_hash = old_hash->notrace_hash;
2755         ftrace_run_update_code(command);
2756         ops->old_hash.filter_hash = NULL;
2757         ops->old_hash.notrace_hash = NULL;
2758         ops->flags &= ~FTRACE_OPS_FL_MODIFYING;
2759 }
2760
2761 static ftrace_func_t saved_ftrace_func;
2762 static int ftrace_start_up;
2763
2764 void __weak arch_ftrace_trampoline_free(struct ftrace_ops *ops)
2765 {
2766 }
2767
2768 static void ftrace_startup_enable(int command)
2769 {
2770         if (saved_ftrace_func != ftrace_trace_function) {
2771                 saved_ftrace_func = ftrace_trace_function;
2772                 command |= FTRACE_UPDATE_TRACE_FUNC;
2773         }
2774
2775         if (!command || !ftrace_enabled)
2776                 return;
2777
2778         ftrace_run_update_code(command);
2779 }
2780
2781 static void ftrace_startup_all(int command)
2782 {
2783         update_all_ops = true;
2784         ftrace_startup_enable(command);
2785         update_all_ops = false;
2786 }
2787
2788 int ftrace_startup(struct ftrace_ops *ops, int command)
2789 {
2790         int ret;
2791
2792         if (unlikely(ftrace_disabled))
2793                 return -ENODEV;
2794
2795         ret = __register_ftrace_function(ops);
2796         if (ret)
2797                 return ret;
2798
2799         ftrace_start_up++;
2800
2801         /*
2802          * Note that ftrace probes uses this to start up
2803          * and modify functions it will probe. But we still
2804          * set the ADDING flag for modification, as probes
2805          * do not have trampolines. If they add them in the
2806          * future, then the probes will need to distinguish
2807          * between adding and updating probes.
2808          */
2809         ops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_ADDING;
2810
2811         ret = ftrace_hash_ipmodify_enable(ops);
2812         if (ret < 0) {
2813                 /* Rollback registration process */
2814                 __unregister_ftrace_function(ops);
2815                 ftrace_start_up--;
2816                 ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2817                 return ret;
2818         }
2819
2820         if (ftrace_hash_rec_enable(ops, 1))
2821                 command |= FTRACE_UPDATE_CALLS;
2822
2823         ftrace_startup_enable(command);
2824
2825         ops->flags &= ~FTRACE_OPS_FL_ADDING;
2826
2827         return 0;
2828 }
2829
2830 int ftrace_shutdown(struct ftrace_ops *ops, int command)
2831 {
2832         int ret;
2833
2834         if (unlikely(ftrace_disabled))
2835                 return -ENODEV;
2836
2837         ret = __unregister_ftrace_function(ops);
2838         if (ret)
2839                 return ret;
2840
2841         ftrace_start_up--;
2842         /*
2843          * Just warn in case of unbalance, no need to kill ftrace, it's not
2844          * critical but the ftrace_call callers may be never nopped again after
2845          * further ftrace uses.
2846          */
2847         WARN_ON_ONCE(ftrace_start_up < 0);
2848
2849         /* Disabling ipmodify never fails */
2850         ftrace_hash_ipmodify_disable(ops);
2851
2852         if (ftrace_hash_rec_disable(ops, 1))
2853                 command |= FTRACE_UPDATE_CALLS;
2854
2855         ops->flags &= ~FTRACE_OPS_FL_ENABLED;
2856
2857         if (saved_ftrace_func != ftrace_trace_function) {
2858                 saved_ftrace_func = ftrace_trace_function;
2859                 command |= FTRACE_UPDATE_TRACE_FUNC;
2860         }
2861
2862         if (!command || !ftrace_enabled) {
2863                 /*
2864                  * If these are dynamic or per_cpu ops, they still
2865                  * need their data freed. Since, function tracing is
2866                  * not currently active, we can just free them
2867                  * without synchronizing all CPUs.
2868                  */
2869                 if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
2870                         goto free_ops;
2871
2872                 return 0;
2873         }
2874
2875         /*
2876          * If the ops uses a trampoline, then it needs to be
2877          * tested first on update.
2878          */
2879         ops->flags |= FTRACE_OPS_FL_REMOVING;
2880         removed_ops = ops;
2881
2882         /* The trampoline logic checks the old hashes */
2883         ops->old_hash.filter_hash = ops->func_hash->filter_hash;
2884         ops->old_hash.notrace_hash = ops->func_hash->notrace_hash;
2885
2886         ftrace_run_update_code(command);
2887
2888         /*
2889          * If there's no more ops registered with ftrace, run a
2890          * sanity check to make sure all rec flags are cleared.
2891          */
2892         if (rcu_dereference_protected(ftrace_ops_list,
2893                         lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
2894                 struct ftrace_page *pg;
2895                 struct dyn_ftrace *rec;
2896
2897                 do_for_each_ftrace_rec(pg, rec) {
2898                         if (FTRACE_WARN_ON_ONCE(rec->flags & ~FTRACE_FL_DISABLED))
2899                                 pr_warn("  %pS flags:%lx\n",
2900                                         (void *)rec->ip, rec->flags);
2901                 } while_for_each_ftrace_rec();
2902         }
2903
2904         ops->old_hash.filter_hash = NULL;
2905         ops->old_hash.notrace_hash = NULL;
2906
2907         removed_ops = NULL;
2908         ops->flags &= ~FTRACE_OPS_FL_REMOVING;
2909
2910         /*
2911          * Dynamic ops may be freed, we must make sure that all
2912          * callers are done before leaving this function.
2913          * The same goes for freeing the per_cpu data of the per_cpu
2914          * ops.
2915          */
2916         if (ops->flags & FTRACE_OPS_FL_DYNAMIC) {
2917                 /*
2918                  * We need to do a hard force of sched synchronization.
2919                  * This is because we use preempt_disable() to do RCU, but
2920                  * the function tracers can be called where RCU is not watching
2921                  * (like before user_exit()). We can not rely on the RCU
2922                  * infrastructure to do the synchronization, thus we must do it
2923                  * ourselves.
2924                  */
2925                 schedule_on_each_cpu(ftrace_sync);
2926
2927                 /*
2928                  * When the kernel is preeptive, tasks can be preempted
2929                  * while on a ftrace trampoline. Just scheduling a task on
2930                  * a CPU is not good enough to flush them. Calling
2931                  * synchornize_rcu_tasks() will wait for those tasks to
2932                  * execute and either schedule voluntarily or enter user space.
2933                  */
2934                 if (IS_ENABLED(CONFIG_PREEMPTION))
2935                         synchronize_rcu_tasks();
2936
2937  free_ops:
2938                 arch_ftrace_trampoline_free(ops);
2939         }
2940
2941         return 0;
2942 }
2943
2944 static void ftrace_startup_sysctl(void)
2945 {
2946         int command;
2947
2948         if (unlikely(ftrace_disabled))
2949                 return;
2950
2951         /* Force update next time */
2952         saved_ftrace_func = NULL;
2953         /* ftrace_start_up is true if we want ftrace running */
2954         if (ftrace_start_up) {
2955                 command = FTRACE_UPDATE_CALLS;
2956                 if (ftrace_graph_active)
2957                         command |= FTRACE_START_FUNC_RET;
2958                 ftrace_startup_enable(command);
2959         }
2960 }
2961
2962 static void ftrace_shutdown_sysctl(void)
2963 {
2964         int command;
2965
2966         if (unlikely(ftrace_disabled))
2967                 return;
2968
2969         /* ftrace_start_up is true if ftrace is running */
2970         if (ftrace_start_up) {
2971                 command = FTRACE_DISABLE_CALLS;
2972                 if (ftrace_graph_active)
2973                         command |= FTRACE_STOP_FUNC_RET;
2974                 ftrace_run_update_code(command);
2975         }
2976 }
2977
2978 static u64              ftrace_update_time;
2979 unsigned long           ftrace_update_tot_cnt;
2980 unsigned long           ftrace_number_of_pages;
2981 unsigned long           ftrace_number_of_groups;
2982
2983 static inline int ops_traces_mod(struct ftrace_ops *ops)
2984 {
2985         /*
2986          * Filter_hash being empty will default to trace module.
2987          * But notrace hash requires a test of individual module functions.
2988          */
2989         return ftrace_hash_empty(ops->func_hash->filter_hash) &&
2990                 ftrace_hash_empty(ops->func_hash->notrace_hash);
2991 }
2992
2993 /*
2994  * Check if the current ops references the record.
2995  *
2996  * If the ops traces all functions, then it was already accounted for.
2997  * If the ops does not trace the current record function, skip it.
2998  * If the ops ignores the function via notrace filter, skip it.
2999  */
3000 static inline bool
3001 ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec)
3002 {
3003         /* If ops isn't enabled, ignore it */
3004         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
3005                 return false;
3006
3007         /* If ops traces all then it includes this function */
3008         if (ops_traces_mod(ops))
3009                 return true;
3010
3011         /* The function must be in the filter */
3012         if (!ftrace_hash_empty(ops->func_hash->filter_hash) &&
3013             !__ftrace_lookup_ip(ops->func_hash->filter_hash, rec->ip))
3014                 return false;
3015
3016         /* If in notrace hash, we ignore it too */
3017         if (ftrace_lookup_ip(ops->func_hash->notrace_hash, rec->ip))
3018                 return false;
3019
3020         return true;
3021 }
3022
3023 static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs)
3024 {
3025         struct ftrace_page *pg;
3026         struct dyn_ftrace *p;
3027         u64 start, stop;
3028         unsigned long update_cnt = 0;
3029         unsigned long rec_flags = 0;
3030         int i;
3031
3032         start = ftrace_now(raw_smp_processor_id());
3033
3034         /*
3035          * When a module is loaded, this function is called to convert
3036          * the calls to mcount in its text to nops, and also to create
3037          * an entry in the ftrace data. Now, if ftrace is activated
3038          * after this call, but before the module sets its text to
3039          * read-only, the modification of enabling ftrace can fail if
3040          * the read-only is done while ftrace is converting the calls.
3041          * To prevent this, the module's records are set as disabled
3042          * and will be enabled after the call to set the module's text
3043          * to read-only.
3044          */
3045         if (mod)
3046                 rec_flags |= FTRACE_FL_DISABLED;
3047
3048         for (pg = new_pgs; pg; pg = pg->next) {
3049
3050                 for (i = 0; i < pg->index; i++) {
3051
3052                         /* If something went wrong, bail without enabling anything */
3053                         if (unlikely(ftrace_disabled))
3054                                 return -1;
3055
3056                         p = &pg->records[i];
3057                         p->flags = rec_flags;
3058
3059                         /*
3060                          * Do the initial record conversion from mcount jump
3061                          * to the NOP instructions.
3062                          */
3063                         if (!__is_defined(CC_USING_NOP_MCOUNT) &&
3064                             !ftrace_nop_initialize(mod, p))
3065                                 break;
3066
3067                         update_cnt++;
3068                 }
3069         }
3070
3071         stop = ftrace_now(raw_smp_processor_id());
3072         ftrace_update_time = stop - start;
3073         ftrace_update_tot_cnt += update_cnt;
3074
3075         return 0;
3076 }
3077
3078 static int ftrace_allocate_records(struct ftrace_page *pg, int count)
3079 {
3080         int order;
3081         int cnt;
3082
3083         if (WARN_ON(!count))
3084                 return -EINVAL;
3085
3086         order = get_count_order(DIV_ROUND_UP(count, ENTRIES_PER_PAGE));
3087
3088         /*
3089          * We want to fill as much as possible. No more than a page
3090          * may be empty.
3091          */
3092         while ((PAGE_SIZE << order) / ENTRY_SIZE >= count + ENTRIES_PER_PAGE)
3093                 order--;
3094
3095  again:
3096         pg->records = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
3097
3098         if (!pg->records) {
3099                 /* if we can't allocate this size, try something smaller */
3100                 if (!order)
3101                         return -ENOMEM;
3102                 order >>= 1;
3103                 goto again;
3104         }
3105
3106         ftrace_number_of_pages += 1 << order;
3107         ftrace_number_of_groups++;
3108
3109         cnt = (PAGE_SIZE << order) / ENTRY_SIZE;
3110         pg->size = cnt;
3111
3112         if (cnt > count)
3113                 cnt = count;
3114
3115         return cnt;
3116 }
3117
3118 static struct ftrace_page *
3119 ftrace_allocate_pages(unsigned long num_to_init)
3120 {
3121         struct ftrace_page *start_pg;
3122         struct ftrace_page *pg;
3123         int order;
3124         int cnt;
3125
3126         if (!num_to_init)
3127                 return NULL;
3128
3129         start_pg = pg = kzalloc(sizeof(*pg), GFP_KERNEL);
3130         if (!pg)
3131                 return NULL;
3132
3133         /*
3134          * Try to allocate as much as possible in one continues
3135          * location that fills in all of the space. We want to
3136          * waste as little space as possible.
3137          */
3138         for (;;) {
3139                 cnt = ftrace_allocate_records(pg, num_to_init);
3140                 if (cnt < 0)
3141                         goto free_pages;
3142
3143                 num_to_init -= cnt;
3144                 if (!num_to_init)
3145                         break;
3146
3147                 pg->next = kzalloc(sizeof(*pg), GFP_KERNEL);
3148                 if (!pg->next)
3149                         goto free_pages;
3150
3151                 pg = pg->next;
3152         }
3153
3154         return start_pg;
3155
3156  free_pages:
3157         pg = start_pg;
3158         while (pg) {
3159                 order = get_count_order(pg->size / ENTRIES_PER_PAGE);
3160                 free_pages((unsigned long)pg->records, order);
3161                 start_pg = pg->next;
3162                 kfree(pg);
3163                 pg = start_pg;
3164                 ftrace_number_of_pages -= 1 << order;
3165                 ftrace_number_of_groups--;
3166         }
3167         pr_info("ftrace: FAILED to allocate memory for functions\n");
3168         return NULL;
3169 }
3170
3171 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
3172
3173 struct ftrace_iterator {
3174         loff_t                          pos;
3175         loff_t                          func_pos;
3176         loff_t                          mod_pos;
3177         struct ftrace_page              *pg;
3178         struct dyn_ftrace               *func;
3179         struct ftrace_func_probe        *probe;
3180         struct ftrace_func_entry        *probe_entry;
3181         struct trace_parser             parser;
3182         struct ftrace_hash              *hash;
3183         struct ftrace_ops               *ops;
3184         struct trace_array              *tr;
3185         struct list_head                *mod_list;
3186         int                             pidx;
3187         int                             idx;
3188         unsigned                        flags;
3189 };
3190
3191 static void *
3192 t_probe_next(struct seq_file *m, loff_t *pos)
3193 {
3194         struct ftrace_iterator *iter = m->private;
3195         struct trace_array *tr = iter->ops->private;
3196         struct list_head *func_probes;
3197         struct ftrace_hash *hash;
3198         struct list_head *next;
3199         struct hlist_node *hnd = NULL;
3200         struct hlist_head *hhd;
3201         int size;
3202
3203         (*pos)++;
3204         iter->pos = *pos;
3205
3206         if (!tr)
3207                 return NULL;
3208
3209         func_probes = &tr->func_probes;
3210         if (list_empty(func_probes))
3211                 return NULL;
3212
3213         if (!iter->probe) {
3214                 next = func_probes->next;
3215                 iter->probe = list_entry(next, struct ftrace_func_probe, list);
3216         }
3217
3218         if (iter->probe_entry)
3219                 hnd = &iter->probe_entry->hlist;
3220
3221         hash = iter->probe->ops.func_hash->filter_hash;
3222
3223         /*
3224          * A probe being registered may temporarily have an empty hash
3225          * and it's at the end of the func_probes list.
3226          */
3227         if (!hash || hash == EMPTY_HASH)
3228                 return NULL;
3229
3230         size = 1 << hash->size_bits;
3231
3232  retry:
3233         if (iter->pidx >= size) {
3234                 if (iter->probe->list.next == func_probes)
3235                         return NULL;
3236                 next = iter->probe->list.next;
3237                 iter->probe = list_entry(next, struct ftrace_func_probe, list);
3238                 hash = iter->probe->ops.func_hash->filter_hash;
3239                 size = 1 << hash->size_bits;
3240                 iter->pidx = 0;
3241         }
3242
3243         hhd = &hash->buckets[iter->pidx];
3244
3245         if (hlist_empty(hhd)) {
3246                 iter->pidx++;
3247                 hnd = NULL;
3248                 goto retry;
3249         }
3250
3251         if (!hnd)
3252                 hnd = hhd->first;
3253         else {
3254                 hnd = hnd->next;
3255                 if (!hnd) {
3256                         iter->pidx++;
3257                         goto retry;
3258                 }
3259         }
3260
3261         if (WARN_ON_ONCE(!hnd))
3262                 return NULL;
3263
3264         iter->probe_entry = hlist_entry(hnd, struct ftrace_func_entry, hlist);
3265
3266         return iter;
3267 }
3268
3269 static void *t_probe_start(struct seq_file *m, loff_t *pos)
3270 {
3271         struct ftrace_iterator *iter = m->private;
3272         void *p = NULL;
3273         loff_t l;
3274
3275         if (!(iter->flags & FTRACE_ITER_DO_PROBES))
3276                 return NULL;
3277
3278         if (iter->mod_pos > *pos)
3279                 return NULL;
3280
3281         iter->probe = NULL;
3282         iter->probe_entry = NULL;
3283         iter->pidx = 0;
3284         for (l = 0; l <= (*pos - iter->mod_pos); ) {
3285                 p = t_probe_next(m, &l);
3286                 if (!p)
3287                         break;
3288         }
3289         if (!p)
3290                 return NULL;
3291
3292         /* Only set this if we have an item */
3293         iter->flags |= FTRACE_ITER_PROBE;
3294
3295         return iter;
3296 }
3297
3298 static int
3299 t_probe_show(struct seq_file *m, struct ftrace_iterator *iter)
3300 {
3301         struct ftrace_func_entry *probe_entry;
3302         struct ftrace_probe_ops *probe_ops;
3303         struct ftrace_func_probe *probe;
3304
3305         probe = iter->probe;
3306         probe_entry = iter->probe_entry;
3307
3308         if (WARN_ON_ONCE(!probe || !probe_entry))
3309                 return -EIO;
3310
3311         probe_ops = probe->probe_ops;
3312
3313         if (probe_ops->print)
3314                 return probe_ops->print(m, probe_entry->ip, probe_ops, probe->data);
3315
3316         seq_printf(m, "%ps:%ps\n", (void *)probe_entry->ip,
3317                    (void *)probe_ops->func);
3318
3319         return 0;
3320 }
3321
3322 static void *
3323 t_mod_next(struct seq_file *m, loff_t *pos)
3324 {
3325         struct ftrace_iterator *iter = m->private;
3326         struct trace_array *tr = iter->tr;
3327
3328         (*pos)++;
3329         iter->pos = *pos;
3330
3331         iter->mod_list = iter->mod_list->next;
3332
3333         if (iter->mod_list == &tr->mod_trace ||
3334             iter->mod_list == &tr->mod_notrace) {
3335                 iter->flags &= ~FTRACE_ITER_MOD;
3336                 return NULL;
3337         }
3338
3339         iter->mod_pos = *pos;
3340
3341         return iter;
3342 }
3343
3344 static void *t_mod_start(struct seq_file *m, loff_t *pos)
3345 {
3346         struct ftrace_iterator *iter = m->private;
3347         void *p = NULL;
3348         loff_t l;
3349
3350         if (iter->func_pos > *pos)
3351                 return NULL;
3352
3353         iter->mod_pos = iter->func_pos;
3354
3355         /* probes are only available if tr is set */
3356         if (!iter->tr)
3357                 return NULL;
3358
3359         for (l = 0; l <= (*pos - iter->func_pos); ) {
3360                 p = t_mod_next(m, &l);
3361                 if (!p)
3362                         break;
3363         }
3364         if (!p) {
3365                 iter->flags &= ~FTRACE_ITER_MOD;
3366                 return t_probe_start(m, pos);
3367         }
3368
3369         /* Only set this if we have an item */
3370         iter->flags |= FTRACE_ITER_MOD;
3371
3372         return iter;
3373 }
3374
3375 static int
3376 t_mod_show(struct seq_file *m, struct ftrace_iterator *iter)
3377 {
3378         struct ftrace_mod_load *ftrace_mod;
3379         struct trace_array *tr = iter->tr;
3380
3381         if (WARN_ON_ONCE(!iter->mod_list) ||
3382                          iter->mod_list == &tr->mod_trace ||
3383                          iter->mod_list == &tr->mod_notrace)
3384                 return -EIO;
3385
3386         ftrace_mod = list_entry(iter->mod_list, struct ftrace_mod_load, list);
3387
3388         if (ftrace_mod->func)
3389                 seq_printf(m, "%s", ftrace_mod->func);
3390         else
3391                 seq_putc(m, '*');
3392
3393         seq_printf(m, ":mod:%s\n", ftrace_mod->module);
3394
3395         return 0;
3396 }
3397
3398 static void *
3399 t_func_next(struct seq_file *m, loff_t *pos)
3400 {
3401         struct ftrace_iterator *iter = m->private;
3402         struct dyn_ftrace *rec = NULL;
3403
3404         (*pos)++;
3405
3406  retry:
3407         if (iter->idx >= iter->pg->index) {
3408                 if (iter->pg->next) {
3409                         iter->pg = iter->pg->next;
3410                         iter->idx = 0;
3411                         goto retry;
3412                 }
3413         } else {
3414                 rec = &iter->pg->records[iter->idx++];
3415                 if (((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) &&
3416                      !ftrace_lookup_ip(iter->hash, rec->ip)) ||
3417
3418                     ((iter->flags & FTRACE_ITER_ENABLED) &&
3419                      !(rec->flags & FTRACE_FL_ENABLED))) {
3420
3421                         rec = NULL;
3422                         goto retry;
3423                 }
3424         }
3425
3426         if (!rec)
3427                 return NULL;
3428
3429         iter->pos = iter->func_pos = *pos;
3430         iter->func = rec;
3431
3432         return iter;
3433 }
3434
3435 static void *
3436 t_next(struct seq_file *m, void *v, loff_t *pos)
3437 {
3438         struct ftrace_iterator *iter = m->private;
3439         loff_t l = *pos; /* t_probe_start() must use original pos */
3440         void *ret;
3441
3442         if (unlikely(ftrace_disabled))
3443                 return NULL;
3444
3445         if (iter->flags & FTRACE_ITER_PROBE)
3446                 return t_probe_next(m, pos);
3447
3448         if (iter->flags & FTRACE_ITER_MOD)
3449                 return t_mod_next(m, pos);
3450
3451         if (iter->flags & FTRACE_ITER_PRINTALL) {
3452                 /* next must increment pos, and t_probe_start does not */
3453                 (*pos)++;
3454                 return t_mod_start(m, &l);
3455         }
3456
3457         ret = t_func_next(m, pos);
3458
3459         if (!ret)
3460                 return t_mod_start(m, &l);
3461
3462         return ret;
3463 }
3464
3465 static void reset_iter_read(struct ftrace_iterator *iter)
3466 {
3467         iter->pos = 0;
3468         iter->func_pos = 0;
3469         iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_PROBE | FTRACE_ITER_MOD);
3470 }
3471
3472 static void *t_start(struct seq_file *m, loff_t *pos)
3473 {
3474         struct ftrace_iterator *iter = m->private;
3475         void *p = NULL;
3476         loff_t l;
3477
3478         mutex_lock(&ftrace_lock);
3479
3480         if (unlikely(ftrace_disabled))
3481                 return NULL;
3482
3483         /*
3484          * If an lseek was done, then reset and start from beginning.
3485          */
3486         if (*pos < iter->pos)
3487                 reset_iter_read(iter);
3488
3489         /*
3490          * For set_ftrace_filter reading, if we have the filter
3491          * off, we can short cut and just print out that all
3492          * functions are enabled.
3493          */
3494         if ((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) &&
3495             ftrace_hash_empty(iter->hash)) {
3496                 iter->func_pos = 1; /* Account for the message */
3497                 if (*pos > 0)
3498                         return t_mod_start(m, pos);
3499                 iter->flags |= FTRACE_ITER_PRINTALL;
3500                 /* reset in case of seek/pread */
3501                 iter->flags &= ~FTRACE_ITER_PROBE;
3502                 return iter;
3503         }
3504
3505         if (iter->flags & FTRACE_ITER_MOD)
3506                 return t_mod_start(m, pos);
3507
3508         /*
3509          * Unfortunately, we need to restart at ftrace_pages_start
3510          * every time we let go of the ftrace_mutex. This is because
3511          * those pointers can change without the lock.
3512          */
3513         iter->pg = ftrace_pages_start;
3514         iter->idx = 0;
3515         for (l = 0; l <= *pos; ) {
3516                 p = t_func_next(m, &l);
3517                 if (!p)
3518                         break;
3519         }
3520
3521         if (!p)
3522                 return t_mod_start(m, pos);
3523
3524         return iter;
3525 }
3526
3527 static void t_stop(struct seq_file *m, void *p)
3528 {
3529         mutex_unlock(&ftrace_lock);
3530 }
3531
3532 void * __weak
3533 arch_ftrace_trampoline_func(struct ftrace_ops *ops, struct dyn_ftrace *rec)
3534 {
3535         return NULL;
3536 }
3537
3538 static void add_trampoline_func(struct seq_file *m, struct ftrace_ops *ops,
3539                                 struct dyn_ftrace *rec)
3540 {
3541         void *ptr;
3542
3543         ptr = arch_ftrace_trampoline_func(ops, rec);
3544         if (ptr)
3545                 seq_printf(m, " ->%pS", ptr);
3546 }
3547
3548 static int t_show(struct seq_file *m, void *v)
3549 {
3550         struct ftrace_iterator *iter = m->private;
3551         struct dyn_ftrace *rec;
3552
3553         if (iter->flags & FTRACE_ITER_PROBE)
3554                 return t_probe_show(m, iter);
3555
3556         if (iter->flags & FTRACE_ITER_MOD)
3557                 return t_mod_show(m, iter);
3558
3559         if (iter->flags & FTRACE_ITER_PRINTALL) {
3560                 if (iter->flags & FTRACE_ITER_NOTRACE)
3561                         seq_puts(m, "#### no functions disabled ####\n");
3562                 else
3563                         seq_puts(m, "#### all functions enabled ####\n");
3564                 return 0;
3565         }
3566
3567         rec = iter->func;
3568
3569         if (!rec)
3570                 return 0;
3571
3572         seq_printf(m, "%ps", (void *)rec->ip);
3573         if (iter->flags & FTRACE_ITER_ENABLED) {
3574                 struct ftrace_ops *ops;
3575
3576                 seq_printf(m, " (%ld)%s%s%s",
3577                            ftrace_rec_count(rec),
3578                            rec->flags & FTRACE_FL_REGS ? " R" : "  ",
3579                            rec->flags & FTRACE_FL_IPMODIFY ? " I" : "  ",
3580                            rec->flags & FTRACE_FL_DIRECT ? " D" : "  ");
3581                 if (rec->flags & FTRACE_FL_TRAMP_EN) {
3582                         ops = ftrace_find_tramp_ops_any(rec);
3583                         if (ops) {
3584                                 do {
3585                                         seq_printf(m, "\ttramp: %pS (%pS)",
3586                                                    (void *)ops->trampoline,
3587                                                    (void *)ops->func);
3588                                         add_trampoline_func(m, ops, rec);
3589                                         ops = ftrace_find_tramp_ops_next(rec, ops);
3590                                 } while (ops);
3591                         } else
3592                                 seq_puts(m, "\ttramp: ERROR!");
3593                 } else {
3594                         add_trampoline_func(m, NULL, rec);
3595                 }
3596                 if (rec->flags & FTRACE_FL_DIRECT) {
3597                         unsigned long direct;
3598
3599                         direct = ftrace_find_rec_direct(rec->ip);
3600                         if (direct)
3601                                 seq_printf(m, "\n\tdirect-->%pS", (void *)direct);
3602                 }
3603         }
3604
3605         seq_putc(m, '\n');
3606
3607         return 0;
3608 }
3609
3610 static const struct seq_operations show_ftrace_seq_ops = {
3611         .start = t_start,
3612         .next = t_next,
3613         .stop = t_stop,
3614         .show = t_show,
3615 };
3616
3617 static int
3618 ftrace_avail_open(struct inode *inode, struct file *file)
3619 {
3620         struct ftrace_iterator *iter;
3621         int ret;
3622
3623         ret = security_locked_down(LOCKDOWN_TRACEFS);
3624         if (ret)
3625                 return ret;
3626
3627         if (unlikely(ftrace_disabled))
3628                 return -ENODEV;
3629
3630         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
3631         if (!iter)
3632                 return -ENOMEM;
3633
3634         iter->pg = ftrace_pages_start;
3635         iter->ops = &global_ops;
3636
3637         return 0;
3638 }
3639
3640 static int
3641 ftrace_enabled_open(struct inode *inode, struct file *file)
3642 {
3643         struct ftrace_iterator *iter;
3644
3645         /*
3646          * This shows us what functions are currently being
3647          * traced and by what. Not sure if we want lockdown
3648          * to hide such critical information for an admin.
3649          * Although, perhaps it can show information we don't
3650          * want people to see, but if something is tracing
3651          * something, we probably want to know about it.
3652          */
3653
3654         iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
3655         if (!iter)
3656                 return -ENOMEM;
3657
3658         iter->pg = ftrace_pages_start;
3659         iter->flags = FTRACE_ITER_ENABLED;
3660         iter->ops = &global_ops;
3661
3662         return 0;
3663 }
3664
3665 /**
3666  * ftrace_regex_open - initialize function tracer filter files
3667  * @ops: The ftrace_ops that hold the hash filters
3668  * @flag: The type of filter to process
3669  * @inode: The inode, usually passed in to your open routine
3670  * @file: The file, usually passed in to your open routine
3671  *
3672  * ftrace_regex_open() initializes the filter files for the
3673  * @ops. Depending on @flag it may process the filter hash or
3674  * the notrace hash of @ops. With this called from the open
3675  * routine, you can use ftrace_filter_write() for the write
3676  * routine if @flag has FTRACE_ITER_FILTER set, or
3677  * ftrace_notrace_write() if @flag has FTRACE_ITER_NOTRACE set.
3678  * tracing_lseek() should be used as the lseek routine, and
3679  * release must call ftrace_regex_release().
3680  */
3681 int
3682 ftrace_regex_open(struct ftrace_ops *ops, int flag,
3683                   struct inode *inode, struct file *file)
3684 {
3685         struct ftrace_iterator *iter;
3686         struct ftrace_hash *hash;
3687         struct list_head *mod_head;
3688         struct trace_array *tr = ops->private;
3689         int ret = -ENOMEM;
3690
3691         ftrace_ops_init(ops);
3692
3693         if (unlikely(ftrace_disabled))
3694                 return -ENODEV;
3695
3696         if (tracing_check_open_get_tr(tr))
3697                 return -ENODEV;
3698
3699         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
3700         if (!iter)
3701                 goto out;
3702
3703         if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX))
3704                 goto out;
3705
3706         iter->ops = ops;
3707         iter->flags = flag;
3708         iter->tr = tr;
3709
3710         mutex_lock(&ops->func_hash->regex_lock);
3711
3712         if (flag & FTRACE_ITER_NOTRACE) {
3713                 hash = ops->func_hash->notrace_hash;
3714                 mod_head = tr ? &tr->mod_notrace : NULL;
3715         } else {
3716                 hash = ops->func_hash->filter_hash;
3717                 mod_head = tr ? &tr->mod_trace : NULL;
3718         }
3719
3720         iter->mod_list = mod_head;
3721
3722         if (file->f_mode & FMODE_WRITE) {
3723                 const int size_bits = FTRACE_HASH_DEFAULT_BITS;
3724
3725                 if (file->f_flags & O_TRUNC) {
3726                         iter->hash = alloc_ftrace_hash(size_bits);
3727                         clear_ftrace_mod_list(mod_head);
3728                 } else {
3729                         iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash);
3730                 }
3731
3732                 if (!iter->hash) {
3733                         trace_parser_put(&iter->parser);
3734                         goto out_unlock;
3735                 }
3736         } else
3737                 iter->hash = hash;
3738
3739         ret = 0;
3740
3741         if (file->f_mode & FMODE_READ) {
3742                 iter->pg = ftrace_pages_start;
3743
3744                 ret = seq_open(file, &show_ftrace_seq_ops);
3745                 if (!ret) {
3746                         struct seq_file *m = file->private_data;
3747                         m->private = iter;
3748                 } else {
3749                         /* Failed */
3750                         free_ftrace_hash(iter->hash);
3751                         trace_parser_put(&iter->parser);
3752                 }
3753         } else
3754                 file->private_data = iter;
3755
3756  out_unlock:
3757         mutex_unlock(&ops->func_hash->regex_lock);
3758
3759  out:
3760         if (ret) {
3761                 kfree(iter);
3762                 if (tr)
3763                         trace_array_put(tr);
3764         }
3765
3766         return ret;
3767 }
3768
3769 static int
3770 ftrace_filter_open(struct inode *inode, struct file *file)
3771 {
3772         struct ftrace_ops *ops = inode->i_private;
3773
3774         /* Checks for tracefs lockdown */
3775         return ftrace_regex_open(ops,
3776                         FTRACE_ITER_FILTER | FTRACE_ITER_DO_PROBES,
3777                         inode, file);
3778 }
3779
3780 static int
3781 ftrace_notrace_open(struct inode *inode, struct file *file)
3782 {
3783         struct ftrace_ops *ops = inode->i_private;
3784
3785         /* Checks for tracefs lockdown */
3786         return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE,
3787                                  inode, file);
3788 }
3789
3790 /* Type for quick search ftrace basic regexes (globs) from filter_parse_regex */
3791 struct ftrace_glob {
3792         char *search;
3793         unsigned len;
3794         int type;
3795 };
3796
3797 /*
3798  * If symbols in an architecture don't correspond exactly to the user-visible
3799  * name of what they represent, it is possible to define this function to
3800  * perform the necessary adjustments.
3801 */
3802 char * __weak arch_ftrace_match_adjust(char *str, const char *search)
3803 {
3804         return str;
3805 }
3806
3807 static int ftrace_match(char *str, struct ftrace_glob *g)
3808 {
3809         int matched = 0;
3810         int slen;
3811
3812         str = arch_ftrace_match_adjust(str, g->search);
3813
3814         switch (g->type) {
3815         case MATCH_FULL:
3816                 if (strcmp(str, g->search) == 0)
3817                         matched = 1;
3818                 break;
3819         case MATCH_FRONT_ONLY:
3820                 if (strncmp(str, g->search, g->len) == 0)
3821                         matched = 1;
3822                 break;
3823         case MATCH_MIDDLE_ONLY:
3824                 if (strstr(str, g->search))
3825                         matched = 1;
3826                 break;
3827         case MATCH_END_ONLY:
3828                 slen = strlen(str);
3829                 if (slen >= g->len &&
3830                     memcmp(str + slen - g->len, g->search, g->len) == 0)
3831                         matched = 1;
3832                 break;
3833         case MATCH_GLOB:
3834                 if (glob_match(g->search, str))
3835                         matched = 1;
3836                 break;
3837         }
3838
3839         return matched;
3840 }
3841
3842 static int
3843 enter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int clear_filter)
3844 {
3845         struct ftrace_func_entry *entry;
3846         int ret = 0;
3847
3848         entry = ftrace_lookup_ip(hash, rec->ip);
3849         if (clear_filter) {
3850                 /* Do nothing if it doesn't exist */
3851                 if (!entry)
3852                         return 0;
3853
3854                 free_hash_entry(hash, entry);
3855         } else {
3856                 /* Do nothing if it exists */
3857                 if (entry)
3858                         return 0;
3859
3860                 ret = add_hash_entry(hash, rec->ip);
3861         }
3862         return ret;
3863 }
3864
3865 static int
3866 add_rec_by_index(struct ftrace_hash *hash, struct ftrace_glob *func_g,
3867                  int clear_filter)
3868 {
3869         long index = simple_strtoul(func_g->search, NULL, 0);
3870         struct ftrace_page *pg;
3871         struct dyn_ftrace *rec;
3872
3873         /* The index starts at 1 */
3874         if (--index < 0)
3875                 return 0;
3876
3877         do_for_each_ftrace_rec(pg, rec) {
3878                 if (pg->index <= index) {
3879                         index -= pg->index;
3880                         /* this is a double loop, break goes to the next page */
3881                         break;
3882                 }
3883                 rec = &pg->records[index];
3884                 enter_record(hash, rec, clear_filter);
3885                 return 1;
3886         } while_for_each_ftrace_rec();
3887         return 0;
3888 }
3889
3890 static int
3891 ftrace_match_record(struct dyn_ftrace *rec, struct ftrace_glob *func_g,
3892                 struct ftrace_glob *mod_g, int exclude_mod)
3893 {
3894         char str[KSYM_SYMBOL_LEN];
3895         char *modname;
3896
3897         kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
3898
3899         if (mod_g) {
3900                 int mod_matches = (modname) ? ftrace_match(modname, mod_g) : 0;
3901
3902                 /* blank module name to match all modules */
3903                 if (!mod_g->len) {
3904                         /* blank module globbing: modname xor exclude_mod */
3905                         if (!exclude_mod != !modname)
3906                                 goto func_match;
3907                         return 0;
3908                 }
3909
3910                 /*
3911                  * exclude_mod is set to trace everything but the given
3912                  * module. If it is set and the module matches, then
3913                  * return 0. If it is not set, and the module doesn't match
3914                  * also return 0. Otherwise, check the function to see if
3915                  * that matches.
3916                  */
3917                 if (!mod_matches == !exclude_mod)
3918                         return 0;
3919 func_match:
3920                 /* blank search means to match all funcs in the mod */
3921                 if (!func_g->len)
3922                         return 1;
3923         }
3924
3925         return ftrace_match(str, func_g);
3926 }
3927
3928 static int
3929 match_records(struct ftrace_hash *hash, char *func, int len, char *mod)
3930 {
3931         struct ftrace_page *pg;
3932         struct dyn_ftrace *rec;
3933         struct ftrace_glob func_g = { .type = MATCH_FULL };
3934         struct ftrace_glob mod_g = { .type = MATCH_FULL };
3935         struct ftrace_glob *mod_match = (mod) ? &mod_g : NULL;
3936         int exclude_mod = 0;
3937         int found = 0;
3938         int ret;
3939         int clear_filter = 0;
3940
3941         if (func) {
3942                 func_g.type = filter_parse_regex(func, len, &func_g.search,
3943                                                  &clear_filter);
3944                 func_g.len = strlen(func_g.search);
3945         }
3946
3947         if (mod) {
3948                 mod_g.type = filter_parse_regex(mod, strlen(mod),
3949                                 &mod_g.search, &exclude_mod);
3950                 mod_g.len = strlen(mod_g.search);
3951         }
3952
3953         mutex_lock(&ftrace_lock);
3954
3955         if (unlikely(ftrace_disabled))
3956                 goto out_unlock;
3957
3958         if (func_g.type == MATCH_INDEX) {
3959                 found = add_rec_by_index(hash, &func_g, clear_filter);
3960                 goto out_unlock;
3961         }
3962
3963         do_for_each_ftrace_rec(pg, rec) {
3964
3965                 if (rec->flags & FTRACE_FL_DISABLED)
3966                         continue;
3967
3968                 if (ftrace_match_record(rec, &func_g, mod_match, exclude_mod)) {
3969                         ret = enter_record(hash, rec, clear_filter);
3970                         if (ret < 0) {
3971                                 found = ret;
3972                                 goto out_unlock;
3973                         }
3974                         found = 1;
3975                 }
3976         } while_for_each_ftrace_rec();
3977  out_unlock:
3978         mutex_unlock(&ftrace_lock);
3979
3980         return found;
3981 }
3982
3983 static int
3984 ftrace_match_records(struct ftrace_hash *hash, char *buff, int len)
3985 {
3986         return match_records(hash, buff, len, NULL);
3987 }
3988
3989 static void ftrace_ops_update_code(struct ftrace_ops *ops,
3990                                    struct ftrace_ops_hash *old_hash)
3991 {
3992         struct ftrace_ops *op;
3993
3994         if (!ftrace_enabled)
3995                 return;
3996
3997         if (ops->flags & FTRACE_OPS_FL_ENABLED) {
3998                 ftrace_run_modify_code(ops, FTRACE_UPDATE_CALLS, old_hash);
3999                 return;
4000         }
4001
4002         /*
4003          * If this is the shared global_ops filter, then we need to
4004          * check if there is another ops that shares it, is enabled.
4005          * If so, we still need to run the modify code.
4006          */
4007         if (ops->func_hash != &global_ops.local_hash)
4008                 return;
4009
4010         do_for_each_ftrace_op(op, ftrace_ops_list) {
4011                 if (op->func_hash == &global_ops.local_hash &&
4012                     op->flags & FTRACE_OPS_FL_ENABLED) {
4013                         ftrace_run_modify_code(op, FTRACE_UPDATE_CALLS, old_hash);
4014                         /* Only need to do this once */
4015                         return;
4016                 }
4017         } while_for_each_ftrace_op(op);
4018 }
4019
4020 static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,
4021                                            struct ftrace_hash **orig_hash,
4022                                            struct ftrace_hash *hash,
4023                                            int enable)
4024 {
4025         struct ftrace_ops_hash old_hash_ops;
4026         struct ftrace_hash *old_hash;
4027         int ret;
4028
4029         old_hash = *orig_hash;
4030         old_hash_ops.filter_hash = ops->func_hash->filter_hash;
4031         old_hash_ops.notrace_hash = ops->func_hash->notrace_hash;
4032         ret = ftrace_hash_move(ops, enable, orig_hash, hash);
4033         if (!ret) {
4034                 ftrace_ops_update_code(ops, &old_hash_ops);
4035                 free_ftrace_hash_rcu(old_hash);
4036         }
4037         return ret;
4038 }
4039
4040 static bool module_exists(const char *module)
4041 {
4042         /* All modules have the symbol __this_module */
4043         static const char this_mod[] = "__this_module";
4044         char modname[MAX_PARAM_PREFIX_LEN + sizeof(this_mod) + 2];
4045         unsigned long val;
4046         int n;
4047
4048         n = snprintf(modname, sizeof(modname), "%s:%s", module, this_mod);
4049
4050         if (n > sizeof(modname) - 1)
4051                 return false;
4052
4053         val = module_kallsyms_lookup_name(modname);
4054         return val != 0;
4055 }
4056
4057 static int cache_mod(struct trace_array *tr,
4058                      const char *func, char *module, int enable)
4059 {
4060         struct ftrace_mod_load *ftrace_mod, *n;
4061         struct list_head *head = enable ? &tr->mod_trace : &tr->mod_notrace;
4062         int ret;
4063
4064         mutex_lock(&ftrace_lock);
4065
4066         /* We do not cache inverse filters */
4067         if (func[0] == '!') {
4068                 func++;
4069                 ret = -EINVAL;
4070
4071                 /* Look to remove this hash */
4072                 list_for_each_entry_safe(ftrace_mod, n, head, list) {
4073                         if (strcmp(ftrace_mod->module, module) != 0)
4074                                 continue;
4075
4076                         /* no func matches all */
4077                         if (strcmp(func, "*") == 0 ||
4078                             (ftrace_mod->func &&
4079                              strcmp(ftrace_mod->func, func) == 0)) {
4080                                 ret = 0;
4081                                 free_ftrace_mod(ftrace_mod);
4082                                 continue;
4083                         }
4084                 }
4085                 goto out;
4086         }
4087
4088         ret = -EINVAL;
4089         /* We only care about modules that have not been loaded yet */
4090         if (module_exists(module))
4091                 goto out;
4092
4093         /* Save this string off, and execute it when the module is loaded */
4094         ret = ftrace_add_mod(tr, func, module, enable);
4095  out:
4096         mutex_unlock(&ftrace_lock);
4097
4098         return ret;
4099 }
4100
4101 static int
4102 ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
4103                  int reset, int enable);
4104
4105 #ifdef CONFIG_MODULES
4106 static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,
4107                              char *mod, bool enable)
4108 {
4109         struct ftrace_mod_load *ftrace_mod, *n;
4110         struct ftrace_hash **orig_hash, *new_hash;
4111         LIST_HEAD(process_mods);
4112         char *func;
4113         int ret;
4114
4115         mutex_lock(&ops->func_hash->regex_lock);
4116
4117         if (enable)
4118                 orig_hash = &ops->func_hash->filter_hash;
4119         else
4120                 orig_hash = &ops->func_hash->notrace_hash;
4121
4122         new_hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS,
4123                                               *orig_hash);
4124         if (!new_hash)
4125                 goto out; /* warn? */
4126
4127         mutex_lock(&ftrace_lock);
4128
4129         list_for_each_entry_safe(ftrace_mod, n, head, list) {
4130
4131                 if (strcmp(ftrace_mod->module, mod) != 0)
4132                         continue;
4133
4134                 if (ftrace_mod->func)
4135                         func = kstrdup(ftrace_mod->func, GFP_KERNEL);
4136                 else
4137                         func = kstrdup("*", GFP_KERNEL);
4138
4139                 if (!func) /* warn? */
4140                         continue;
4141
4142                 list_del(&ftrace_mod->list);
4143                 list_add(&ftrace_mod->list, &process_mods);
4144
4145                 /* Use the newly allocated func, as it may be "*" */
4146                 kfree(ftrace_mod->func);
4147                 ftrace_mod->func = func;
4148         }
4149
4150         mutex_unlock(&ftrace_lock);
4151
4152         list_for_each_entry_safe(ftrace_mod, n, &process_mods, list) {
4153
4154                 func = ftrace_mod->func;
4155
4156                 /* Grabs ftrace_lock, which is why we have this extra step */
4157                 match_records(new_hash, func, strlen(func), mod);
4158                 free_ftrace_mod(ftrace_mod);
4159         }
4160
4161         if (enable && list_empty(head))
4162                 new_hash->flags &= ~FTRACE_HASH_FL_MOD;
4163
4164         mutex_lock(&ftrace_lock);
4165
4166         ret = ftrace_hash_move_and_update_ops(ops, orig_hash,
4167                                               new_hash, enable);
4168         mutex_unlock(&ftrace_lock);
4169
4170  out:
4171         mutex_unlock(&ops->func_hash->regex_lock);
4172
4173         free_ftrace_hash(new_hash);
4174 }
4175
4176 static void process_cached_mods(const char *mod_name)
4177 {
4178         struct trace_array *tr;
4179         char *mod;
4180
4181         mod = kstrdup(mod_name, GFP_KERNEL);
4182         if (!mod)
4183                 return;
4184
4185         mutex_lock(&trace_types_lock);
4186         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
4187                 if (!list_empty(&tr->mod_trace))
4188                         process_mod_list(&tr->mod_trace, tr->ops, mod, true);
4189                 if (!list_empty(&tr->mod_notrace))
4190                         process_mod_list(&tr->mod_notrace, tr->ops, mod, false);
4191         }
4192         mutex_unlock(&trace_types_lock);
4193
4194         kfree(mod);
4195 }
4196 #endif
4197
4198 /*
4199  * We register the module command as a template to show others how
4200  * to register the a command as well.
4201  */
4202
4203 static int
4204 ftrace_mod_callback(struct trace_array *tr, struct ftrace_hash *hash,
4205                     char *func_orig, char *cmd, char *module, int enable)
4206 {
4207         char *func;
4208         int ret;
4209
4210         /* match_records() modifies func, and we need the original */
4211         func = kstrdup(func_orig, GFP_KERNEL);
4212         if (!func)
4213                 return -ENOMEM;
4214
4215         /*
4216          * cmd == 'mod' because we only registered this func
4217          * for the 'mod' ftrace_func_command.
4218          * But if you register one func with multiple commands,
4219          * you can tell which command was used by the cmd
4220          * parameter.
4221          */
4222         ret = match_records(hash, func, strlen(func), module);
4223         kfree(func);
4224
4225         if (!ret)
4226                 return cache_mod(tr, func_orig, module, enable);
4227         if (ret < 0)
4228                 return ret;
4229         return 0;
4230 }
4231
4232 static struct ftrace_func_command ftrace_mod_cmd = {
4233         .name                   = "mod",
4234         .func                   = ftrace_mod_callback,
4235 };
4236
4237 static int __init ftrace_mod_cmd_init(void)
4238 {
4239         return register_ftrace_command(&ftrace_mod_cmd);
4240 }
4241 core_initcall(ftrace_mod_cmd_init);
4242
4243 static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip,
4244                                       struct ftrace_ops *op, struct pt_regs *pt_regs)
4245 {
4246         struct ftrace_probe_ops *probe_ops;
4247         struct ftrace_func_probe *probe;
4248
4249         probe = container_of(op, struct ftrace_func_probe, ops);
4250         probe_ops = probe->probe_ops;
4251
4252         /*
4253          * Disable preemption for these calls to prevent a RCU grace
4254          * period. This syncs the hash iteration and freeing of items
4255          * on the hash. rcu_read_lock is too dangerous here.
4256          */
4257         preempt_disable_notrace();
4258         probe_ops->func(ip, parent_ip, probe->tr, probe_ops, probe->data);
4259         preempt_enable_notrace();
4260 }
4261
4262 struct ftrace_func_map {
4263         struct ftrace_func_entry        entry;
4264         void                            *data;
4265 };
4266
4267 struct ftrace_func_mapper {
4268         struct ftrace_hash              hash;
4269 };
4270
4271 /**
4272  * allocate_ftrace_func_mapper - allocate a new ftrace_func_mapper
4273  *
4274  * Returns a ftrace_func_mapper descriptor that can be used to map ips to data.
4275  */
4276 struct ftrace_func_mapper *allocate_ftrace_func_mapper(void)
4277 {
4278         struct ftrace_hash *hash;
4279
4280         /*
4281          * The mapper is simply a ftrace_hash, but since the entries
4282          * in the hash are not ftrace_func_entry type, we define it
4283          * as a separate structure.
4284          */
4285         hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS);
4286         return (struct ftrace_func_mapper *)hash;
4287 }
4288
4289 /**
4290  * ftrace_func_mapper_find_ip - Find some data mapped to an ip
4291  * @mapper: The mapper that has the ip maps
4292  * @ip: the instruction pointer to find the data for
4293  *
4294  * Returns the data mapped to @ip if found otherwise NULL. The return
4295  * is actually the address of the mapper data pointer. The address is
4296  * returned for use cases where the data is no bigger than a long, and
4297  * the user can use the data pointer as its data instead of having to
4298  * allocate more memory for the reference.
4299  */
4300 void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper,
4301                                   unsigned long ip)
4302 {
4303         struct ftrace_func_entry *entry;
4304         struct ftrace_func_map *map;
4305
4306         entry = ftrace_lookup_ip(&mapper->hash, ip);
4307         if (!entry)
4308                 return NULL;
4309
4310         map = (struct ftrace_func_map *)entry;
4311         return &map->data;
4312 }
4313
4314 /**
4315  * ftrace_func_mapper_add_ip - Map some data to an ip
4316  * @mapper: The mapper that has the ip maps
4317  * @ip: The instruction pointer address to map @data to
4318  * @data: The data to map to @ip
4319  *
4320  * Returns 0 on succes otherwise an error.
4321  */
4322 int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper,
4323                               unsigned long ip, void *data)
4324 {
4325         struct ftrace_func_entry *entry;
4326         struct ftrace_func_map *map;
4327
4328         entry = ftrace_lookup_ip(&mapper->hash, ip);
4329         if (entry)
4330                 return -EBUSY;
4331
4332         map = kmalloc(sizeof(*map), GFP_KERNEL);
4333         if (!map)
4334                 return -ENOMEM;
4335
4336         map->entry.ip = ip;
4337         map->data = data;
4338
4339         __add_hash_entry(&mapper->hash, &map->entry);
4340
4341         return 0;
4342 }
4343
4344 /**
4345  * ftrace_func_mapper_remove_ip - Remove an ip from the mapping
4346  * @mapper: The mapper that has the ip maps
4347  * @ip: The instruction pointer address to remove the data from
4348  *
4349  * Returns the data if it is found, otherwise NULL.
4350  * Note, if the data pointer is used as the data itself, (see
4351  * ftrace_func_mapper_find_ip(), then the return value may be meaningless,
4352  * if the data pointer was set to zero.
4353  */
4354 void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper,
4355                                    unsigned long ip)
4356 {
4357         struct ftrace_func_entry *entry;
4358         struct ftrace_func_map *map;
4359         void *data;
4360
4361         entry = ftrace_lookup_ip(&mapper->hash, ip);
4362         if (!entry)
4363                 return NULL;
4364
4365         map = (struct ftrace_func_map *)entry;
4366         data = map->data;
4367
4368         remove_hash_entry(&mapper->hash, entry);
4369         kfree(entry);
4370
4371         return data;
4372 }
4373
4374 /**
4375  * free_ftrace_func_mapper - free a mapping of ips and data
4376  * @mapper: The mapper that has the ip maps
4377  * @free_func: A function to be called on each data item.
4378  *
4379  * This is used to free the function mapper. The @free_func is optional
4380  * and can be used if the data needs to be freed as well.
4381  */
4382 void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper,
4383                              ftrace_mapper_func free_func)
4384 {
4385         struct ftrace_func_entry *entry;
4386         struct ftrace_func_map *map;
4387         struct hlist_head *hhd;
4388         int size, i;
4389
4390         if (!mapper)
4391                 return;
4392
4393         if (free_func && mapper->hash.count) {
4394                 size = 1 << mapper->hash.size_bits;
4395                 for (i = 0; i < size; i++) {
4396                         hhd = &mapper->hash.buckets[i];
4397                         hlist_for_each_entry(entry, hhd, hlist) {
4398                                 map = (struct ftrace_func_map *)entry;
4399                                 free_func(map);
4400                         }
4401                 }
4402         }
4403         free_ftrace_hash(&mapper->hash);
4404 }
4405
4406 static void release_probe(struct ftrace_func_probe *probe)
4407 {
4408         struct ftrace_probe_ops *probe_ops;
4409
4410         mutex_lock(&ftrace_lock);
4411
4412         WARN_ON(probe->ref <= 0);
4413
4414         /* Subtract the ref that was used to protect this instance */
4415         probe->ref--;
4416
4417         if (!probe->ref) {
4418                 probe_ops = probe->probe_ops;
4419                 /*
4420                  * Sending zero as ip tells probe_ops to free
4421                  * the probe->data itself
4422                  */
4423                 if (probe_ops->free)
4424                         probe_ops->free(probe_ops, probe->tr, 0, probe->data);
4425                 list_del(&probe->list);
4426                 kfree(probe);
4427         }
4428         mutex_unlock(&ftrace_lock);
4429 }
4430
4431 static void acquire_probe_locked(struct ftrace_func_probe *probe)
4432 {
4433         /*
4434          * Add one ref to keep it from being freed when releasing the
4435          * ftrace_lock mutex.
4436          */
4437         probe->ref++;
4438 }
4439
4440 int
4441 register_ftrace_function_probe(char *glob, struct trace_array *tr,
4442                                struct ftrace_probe_ops *probe_ops,
4443                                void *data)
4444 {
4445         struct ftrace_func_entry *entry;
4446         struct ftrace_func_probe *probe;
4447         struct ftrace_hash **orig_hash;
4448         struct ftrace_hash *old_hash;
4449         struct ftrace_hash *hash;
4450         int count = 0;
4451         int size;
4452         int ret;
4453         int i;
4454
4455         if (WARN_ON(!tr))
4456                 return -EINVAL;
4457
4458         /* We do not support '!' for function probes */
4459         if (WARN_ON(glob[0] == '!'))
4460                 return -EINVAL;
4461
4462
4463         mutex_lock(&ftrace_lock);
4464         /* Check if the probe_ops is already registered */
4465         list_for_each_entry(probe, &tr->func_probes, list) {
4466                 if (probe->probe_ops == probe_ops)
4467                         break;
4468         }
4469         if (&probe->list == &tr->func_probes) {
4470                 probe = kzalloc(sizeof(*probe), GFP_KERNEL);
4471                 if (!probe) {
4472                         mutex_unlock(&ftrace_lock);
4473                         return -ENOMEM;
4474                 }
4475                 probe->probe_ops = probe_ops;
4476                 probe->ops.func = function_trace_probe_call;
4477                 probe->tr = tr;
4478                 ftrace_ops_init(&probe->ops);
4479                 list_add(&probe->list, &tr->func_probes);
4480         }
4481
4482         acquire_probe_locked(probe);
4483
4484         mutex_unlock(&ftrace_lock);
4485
4486         /*
4487          * Note, there's a small window here that the func_hash->filter_hash
4488          * may be NULL or empty. Need to be carefule when reading the loop.
4489          */
4490         mutex_lock(&probe->ops.func_hash->regex_lock);
4491
4492         orig_hash = &probe->ops.func_hash->filter_hash;
4493         old_hash = *orig_hash;
4494         hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash);
4495
4496         if (!hash) {
4497                 ret = -ENOMEM;
4498                 goto out;
4499         }
4500
4501         ret = ftrace_match_records(hash, glob, strlen(glob));
4502
4503         /* Nothing found? */
4504         if (!ret)
4505                 ret = -EINVAL;
4506
4507         if (ret < 0)
4508                 goto out;
4509
4510         size = 1 << hash->size_bits;
4511         for (i = 0; i < size; i++) {
4512                 hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
4513                         if (ftrace_lookup_ip(old_hash, entry->ip))
4514                                 continue;
4515                         /*
4516                          * The caller might want to do something special
4517                          * for each function we find. We call the callback
4518                          * to give the caller an opportunity to do so.
4519                          */
4520                         if (probe_ops->init) {
4521                                 ret = probe_ops->init(probe_ops, tr,
4522                                                       entry->ip, data,
4523                                                       &probe->data);
4524                                 if (ret < 0) {
4525                                         if (probe_ops->free && count)
4526                                                 probe_ops->free(probe_ops, tr,
4527                                                                 0, probe->data);
4528                                         probe->data = NULL;
4529                                         goto out;
4530                                 }
4531                         }
4532                         count++;
4533                 }
4534         }
4535
4536         mutex_lock(&ftrace_lock);
4537
4538         if (!count) {
4539                 /* Nothing was added? */
4540                 ret = -EINVAL;
4541                 goto out_unlock;
4542         }
4543
4544         ret = ftrace_hash_move_and_update_ops(&probe->ops, orig_hash,
4545                                               hash, 1);
4546         if (ret < 0)
4547                 goto err_unlock;
4548
4549         /* One ref for each new function traced */
4550         probe->ref += count;
4551
4552         if (!(probe->ops.flags & FTRACE_OPS_FL_ENABLED))
4553                 ret = ftrace_startup(&probe->ops, 0);
4554
4555  out_unlock:
4556         mutex_unlock(&ftrace_lock);
4557
4558         if (!ret)
4559                 ret = count;
4560  out:
4561         mutex_unlock(&probe->ops.func_hash->regex_lock);
4562         free_ftrace_hash(hash);
4563
4564         release_probe(probe);
4565
4566         return ret;
4567
4568  err_unlock:
4569         if (!probe_ops->free || !count)
4570                 goto out_unlock;
4571
4572         /* Failed to do the move, need to call the free functions */
4573         for (i = 0; i < size; i++) {
4574                 hlist_for_each_entry(entry, &hash->buckets[i], hlist) {
4575                         if (ftrace_lookup_ip(old_hash, entry->ip))
4576                                 continue;
4577                         probe_ops->free(probe_ops, tr, entry->ip, probe->data);
4578                 }
4579         }
4580         goto out_unlock;
4581 }
4582
4583 int
4584 unregister_ftrace_function_probe_func(char *glob, struct trace_array *tr,
4585                                       struct ftrace_probe_ops *probe_ops)
4586 {
4587         struct ftrace_ops_hash old_hash_ops;
4588         struct ftrace_func_entry *entry;
4589         struct ftrace_func_probe *probe;
4590         struct ftrace_glob func_g;
4591         struct ftrace_hash **orig_hash;
4592         struct ftrace_hash *old_hash;
4593         struct ftrace_hash *hash = NULL;
4594         struct hlist_node *tmp;
4595         struct hlist_head hhd;
4596         char str[KSYM_SYMBOL_LEN];
4597         int count = 0;
4598         int i, ret = -ENODEV;
4599         int size;
4600
4601         if (!glob || !strlen(glob) || !strcmp(glob, "*"))
4602                 func_g.search = NULL;
4603         else {
4604                 int not;
4605
4606                 func_g.type = filter_parse_regex(glob, strlen(glob),
4607                                                  &func_g.search, &not);
4608                 func_g.len = strlen(func_g.search);
4609
4610                 /* we do not support '!' for function probes */
4611                 if (WARN_ON(not))
4612                         return -EINVAL;
4613         }
4614
4615         mutex_lock(&ftrace_lock);
4616         /* Check if the probe_ops is already registered */
4617         list_for_each_entry(probe, &tr->func_probes, list) {
4618                 if (probe->probe_ops == probe_ops)
4619                         break;
4620         }
4621         if (&probe->list == &tr->func_probes)
4622                 goto err_unlock_ftrace;
4623
4624         ret = -EINVAL;
4625         if (!(probe->ops.flags & FTRACE_OPS_FL_INITIALIZED))
4626                 goto err_unlock_ftrace;
4627
4628         acquire_probe_locked(probe);
4629
4630         mutex_unlock(&ftrace_lock);
4631
4632         mutex_lock(&probe->ops.func_hash->regex_lock);
4633
4634         orig_hash = &probe->ops.func_hash->filter_hash;
4635         old_hash = *orig_hash;
4636
4637         if (ftrace_hash_empty(old_hash))
4638                 goto out_unlock;
4639
4640         old_hash_ops.filter_hash = old_hash;
4641         /* Probes only have filters */
4642         old_hash_ops.notrace_hash = NULL;
4643
4644         ret = -ENOMEM;
4645         hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash);
4646         if (!hash)
4647                 goto out_unlock;
4648
4649         INIT_HLIST_HEAD(&hhd);
4650
4651         size = 1 << hash->size_bits;
4652         for (i = 0; i < size; i++) {
4653                 hlist_for_each_entry_safe(entry, tmp, &hash->buckets[i], hlist) {
4654
4655                         if (func_g.search) {
4656                                 kallsyms_lookup(entry->ip, NULL, NULL,
4657                                                 NULL, str);
4658                                 if (!ftrace_match(str, &func_g))
4659                                         continue;
4660                         }
4661                         count++;
4662                         remove_hash_entry(hash, entry);
4663                         hlist_add_head(&entry->hlist, &hhd);
4664                 }
4665         }
4666
4667         /* Nothing found? */
4668         if (!count) {
4669                 ret = -EINVAL;
4670                 goto out_unlock;
4671         }
4672
4673         mutex_lock(&ftrace_lock);
4674
4675         WARN_ON(probe->ref < count);
4676
4677         probe->ref -= count;
4678
4679         if (ftrace_hash_empty(hash))
4680                 ftrace_shutdown(&probe->ops, 0);
4681
4682         ret = ftrace_hash_move_and_update_ops(&probe->ops, orig_hash,
4683                                               hash, 1);
4684
4685         /* still need to update the function call sites */
4686         if (ftrace_enabled && !ftrace_hash_empty(hash))
4687                 ftrace_run_modify_code(&probe->ops, FTRACE_UPDATE_CALLS,
4688                                        &old_hash_ops);
4689         synchronize_rcu();
4690
4691         hlist_for_each_entry_safe(entry, tmp, &hhd, hlist) {
4692                 hlist_del(&entry->hlist);
4693                 if (probe_ops->free)
4694                         probe_ops->free(probe_ops, tr, entry->ip, probe->data);
4695                 kfree(entry);
4696         }
4697         mutex_unlock(&ftrace_lock);
4698
4699  out_unlock:
4700         mutex_unlock(&probe->ops.func_hash->regex_lock);
4701         free_ftrace_hash(hash);
4702
4703         release_probe(probe);
4704
4705         return ret;
4706
4707  err_unlock_ftrace:
4708         mutex_unlock(&ftrace_lock);
4709         return ret;
4710 }
4711
4712 void clear_ftrace_function_probes(struct trace_array *tr)
4713 {
4714         struct ftrace_func_probe *probe, *n;
4715
4716         list_for_each_entry_safe(probe, n, &tr->func_probes, list)
4717                 unregister_ftrace_function_probe_func(NULL, tr, probe->probe_ops);
4718 }
4719
4720 static LIST_HEAD(ftrace_commands);
4721 static DEFINE_MUTEX(ftrace_cmd_mutex);
4722
4723 /*
4724  * Currently we only register ftrace commands from __init, so mark this
4725  * __init too.
4726  */
4727 __init int register_ftrace_command(struct ftrace_func_command *cmd)
4728 {
4729         struct ftrace_func_command *p;
4730         int ret = 0;
4731
4732         mutex_lock(&ftrace_cmd_mutex);
4733         list_for_each_entry(p, &ftrace_commands, list) {
4734                 if (strcmp(cmd->name, p->name) == 0) {
4735                         ret = -EBUSY;
4736                         goto out_unlock;
4737                 }
4738         }
4739         list_add(&cmd->list, &ftrace_commands);
4740  out_unlock:
4741         mutex_unlock(&ftrace_cmd_mutex);
4742
4743         return ret;
4744 }
4745
4746 /*
4747  * Currently we only unregister ftrace commands from __init, so mark
4748  * this __init too.
4749  */
4750 __init int unregister_ftrace_command(struct ftrace_func_command *cmd)
4751 {
4752         struct ftrace_func_command *p, *n;
4753         int ret = -ENODEV;
4754
4755         mutex_lock(&ftrace_cmd_mutex);
4756         list_for_each_entry_safe(p, n, &ftrace_commands, list) {
4757                 if (strcmp(cmd->name, p->name) == 0) {
4758                         ret = 0;
4759                         list_del_init(&p->list);
4760                         goto out_unlock;
4761                 }
4762         }
4763  out_unlock:
4764         mutex_unlock(&ftrace_cmd_mutex);
4765
4766         return ret;
4767 }
4768
4769 static int ftrace_process_regex(struct ftrace_iterator *iter,
4770                                 char *buff, int len, int enable)
4771 {
4772         struct ftrace_hash *hash = iter->hash;
4773         struct trace_array *tr = iter->ops->private;
4774         char *func, *command, *next = buff;
4775         struct ftrace_func_command *p;
4776         int ret = -EINVAL;
4777
4778         func = strsep(&next, ":");
4779
4780         if (!next) {
4781                 ret = ftrace_match_records(hash, func, len);
4782                 if (!ret)
4783                         ret = -EINVAL;
4784                 if (ret < 0)
4785                         return ret;
4786                 return 0;
4787         }
4788
4789         /* command found */
4790
4791         command = strsep(&next, ":");
4792
4793         mutex_lock(&ftrace_cmd_mutex);
4794         list_for_each_entry(p, &ftrace_commands, list) {
4795                 if (strcmp(p->name, command) == 0) {
4796                         ret = p->func(tr, hash, func, command, next, enable);
4797                         goto out_unlock;
4798                 }
4799         }
4800  out_unlock:
4801         mutex_unlock(&ftrace_cmd_mutex);
4802
4803         return ret;
4804 }
4805
4806 static ssize_t
4807 ftrace_regex_write(struct file *file, const char __user *ubuf,
4808                    size_t cnt, loff_t *ppos, int enable)
4809 {
4810         struct ftrace_iterator *iter;
4811         struct trace_parser *parser;
4812         ssize_t ret, read;
4813
4814         if (!cnt)
4815                 return 0;
4816
4817         if (file->f_mode & FMODE_READ) {
4818                 struct seq_file *m = file->private_data;
4819                 iter = m->private;
4820         } else
4821                 iter = file->private_data;
4822
4823         if (unlikely(ftrace_disabled))
4824                 return -ENODEV;
4825
4826         /* iter->hash is a local copy, so we don't need regex_lock */
4827
4828         parser = &iter->parser;
4829         read = trace_get_user(parser, ubuf, cnt, ppos);
4830
4831         if (read >= 0 && trace_parser_loaded(parser) &&
4832             !trace_parser_cont(parser)) {
4833                 ret = ftrace_process_regex(iter, parser->buffer,
4834                                            parser->idx, enable);
4835                 trace_parser_clear(parser);
4836                 if (ret < 0)
4837                         goto out;
4838         }
4839
4840         ret = read;
4841  out:
4842         return ret;
4843 }
4844
4845 ssize_t
4846 ftrace_filter_write(struct file *file, const char __user *ubuf,
4847                     size_t cnt, loff_t *ppos)
4848 {
4849         return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
4850 }
4851
4852 ssize_t
4853 ftrace_notrace_write(struct file *file, const char __user *ubuf,
4854                      size_t cnt, loff_t *ppos)
4855 {
4856         return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
4857 }
4858
4859 static int
4860 ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove)
4861 {
4862         struct ftrace_func_entry *entry;
4863
4864         if (!ftrace_location(ip))
4865                 return -EINVAL;
4866
4867         if (remove) {
4868                 entry = ftrace_lookup_ip(hash, ip);
4869                 if (!entry)
4870                         return -ENOENT;
4871                 free_hash_entry(hash, entry);
4872                 return 0;
4873         }
4874
4875         return add_hash_entry(hash, ip);
4876 }
4877
4878 static int
4879 ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
4880                 unsigned long ip, int remove, int reset, int enable)
4881 {
4882         struct ftrace_hash **orig_hash;
4883         struct ftrace_hash *hash;
4884         int ret;
4885
4886         if (unlikely(ftrace_disabled))
4887                 return -ENODEV;
4888
4889         mutex_lock(&ops->func_hash->regex_lock);
4890
4891         if (enable)
4892                 orig_hash = &ops->func_hash->filter_hash;
4893         else
4894                 orig_hash = &ops->func_hash->notrace_hash;
4895
4896         if (reset)
4897                 hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS);
4898         else
4899                 hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
4900
4901         if (!hash) {
4902                 ret = -ENOMEM;
4903                 goto out_regex_unlock;
4904         }
4905
4906         if (buf && !ftrace_match_records(hash, buf, len)) {
4907                 ret = -EINVAL;
4908                 goto out_regex_unlock;
4909         }
4910         if (ip) {
4911                 ret = ftrace_match_addr(hash, ip, remove);
4912                 if (ret < 0)
4913                         goto out_regex_unlock;
4914         }
4915
4916         mutex_lock(&ftrace_lock);
4917         ret = ftrace_hash_move_and_update_ops(ops, orig_hash, hash, enable);
4918         mutex_unlock(&ftrace_lock);
4919
4920  out_regex_unlock:
4921         mutex_unlock(&ops->func_hash->regex_lock);
4922
4923         free_ftrace_hash(hash);
4924         return ret;
4925 }
4926
4927 static int
4928 ftrace_set_addr(struct ftrace_ops *ops, unsigned long ip, int remove,
4929                 int reset, int enable)
4930 {
4931         return ftrace_set_hash(ops, NULL, 0, ip, remove, reset, enable);
4932 }
4933
4934 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
4935
4936 struct ftrace_direct_func {
4937         struct list_head        next;
4938         unsigned long           addr;
4939         int                     count;
4940 };
4941
4942 static LIST_HEAD(ftrace_direct_funcs);
4943
4944 /**
4945  * ftrace_find_direct_func - test an address if it is a registered direct caller
4946  * @addr: The address of a registered direct caller
4947  *
4948  * This searches to see if a ftrace direct caller has been registered
4949  * at a specific address, and if so, it returns a descriptor for it.
4950  *
4951  * This can be used by architecture code to see if an address is
4952  * a direct caller (trampoline) attached to a fentry/mcount location.
4953  * This is useful for the function_graph tracer, as it may need to
4954  * do adjustments if it traced a location that also has a direct
4955  * trampoline attached to it.
4956  */
4957 struct ftrace_direct_func *ftrace_find_direct_func(unsigned long addr)
4958 {
4959         struct ftrace_direct_func *entry;
4960         bool found = false;
4961
4962         /* May be called by fgraph trampoline (protected by rcu tasks) */
4963         list_for_each_entry_rcu(entry, &ftrace_direct_funcs, next) {
4964                 if (entry->addr == addr) {
4965                         found = true;
4966                         break;
4967                 }
4968         }
4969         if (found)
4970                 return entry;
4971
4972         return NULL;
4973 }
4974
4975 /**
4976  * register_ftrace_direct - Call a custom trampoline directly
4977  * @ip: The address of the nop at the beginning of a function
4978  * @addr: The address of the trampoline to call at @ip
4979  *
4980  * This is used to connect a direct call from the nop location (@ip)
4981  * at the start of ftrace traced functions. The location that it calls
4982  * (@addr) must be able to handle a direct call, and save the parameters
4983  * of the function being traced, and restore them (or inject new ones
4984  * if needed), before returning.
4985  *
4986  * Returns:
4987  *  0 on success
4988  *  -EBUSY - Another direct function is already attached (there can be only one)
4989  *  -ENODEV - @ip does not point to a ftrace nop location (or not supported)
4990  *  -ENOMEM - There was an allocation failure.
4991  */
4992 int register_ftrace_direct(unsigned long ip, unsigned long addr)
4993 {
4994         struct ftrace_direct_func *direct;
4995         struct ftrace_func_entry *entry;
4996         struct ftrace_hash *free_hash = NULL;
4997         struct dyn_ftrace *rec;
4998         int ret = -EBUSY;
4999
5000         mutex_lock(&direct_mutex);
5001
5002         /* See if there's a direct function at @ip already */
5003         if (ftrace_find_rec_direct(ip))
5004                 goto out_unlock;
5005
5006         ret = -ENODEV;
5007         rec = lookup_rec(ip, ip);
5008         if (!rec)
5009                 goto out_unlock;
5010
5011         /*
5012          * Check if the rec says it has a direct call but we didn't
5013          * find one earlier?
5014          */
5015         if (WARN_ON(rec->flags & FTRACE_FL_DIRECT))
5016                 goto out_unlock;
5017
5018         /* Make sure the ip points to the exact record */
5019         if (ip != rec->ip) {
5020                 ip = rec->ip;
5021                 /* Need to check this ip for a direct. */
5022                 if (ftrace_find_rec_direct(ip))
5023                         goto out_unlock;
5024         }
5025
5026         ret = -ENOMEM;
5027         if (ftrace_hash_empty(direct_functions) ||
5028             direct_functions->count > 2 * (1 << direct_functions->size_bits)) {
5029                 struct ftrace_hash *new_hash;
5030                 int size = ftrace_hash_empty(direct_functions) ? 0 :
5031                         direct_functions->count + 1;
5032
5033                 if (size < 32)
5034                         size = 32;
5035
5036                 new_hash = dup_hash(direct_functions, size);
5037                 if (!new_hash)
5038                         goto out_unlock;
5039
5040                 free_hash = direct_functions;
5041                 direct_functions = new_hash;
5042         }
5043
5044         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
5045         if (!entry)
5046                 goto out_unlock;
5047
5048         direct = ftrace_find_direct_func(addr);
5049         if (!direct) {
5050                 direct = kmalloc(sizeof(*direct), GFP_KERNEL);
5051                 if (!direct) {
5052                         kfree(entry);
5053                         goto out_unlock;
5054                 }
5055                 direct->addr = addr;
5056                 direct->count = 0;
5057                 list_add_rcu(&direct->next, &ftrace_direct_funcs);
5058                 ftrace_direct_func_count++;
5059         }
5060
5061         entry->ip = ip;
5062         entry->direct = addr;
5063         __add_hash_entry(direct_functions, entry);
5064
5065         ret = ftrace_set_filter_ip(&direct_ops, ip, 0, 0);
5066         if (ret)
5067                 remove_hash_entry(direct_functions, entry);
5068
5069         if (!ret && !(direct_ops.flags & FTRACE_OPS_FL_ENABLED)) {
5070                 ret = register_ftrace_function(&direct_ops);
5071                 if (ret)
5072                         ftrace_set_filter_ip(&direct_ops, ip, 1, 0);
5073         }
5074
5075         if (ret) {
5076                 kfree(entry);
5077                 if (!direct->count) {
5078                         list_del_rcu(&direct->next);
5079                         synchronize_rcu_tasks();
5080                         kfree(direct);
5081                         if (free_hash)
5082                                 free_ftrace_hash(free_hash);
5083                         free_hash = NULL;
5084                         ftrace_direct_func_count--;
5085                 }
5086         } else {
5087                 direct->count++;
5088         }
5089  out_unlock:
5090         mutex_unlock(&direct_mutex);
5091
5092         if (free_hash) {
5093                 synchronize_rcu_tasks();
5094                 free_ftrace_hash(free_hash);
5095         }
5096
5097         return ret;
5098 }
5099 EXPORT_SYMBOL_GPL(register_ftrace_direct);
5100
5101 static struct ftrace_func_entry *find_direct_entry(unsigned long *ip,
5102                                                    struct dyn_ftrace **recp)
5103 {
5104         struct ftrace_func_entry *entry;
5105         struct dyn_ftrace *rec;
5106
5107         rec = lookup_rec(*ip, *ip);
5108         if (!rec)
5109                 return NULL;
5110
5111         entry = __ftrace_lookup_ip(direct_functions, rec->ip);
5112         if (!entry) {
5113                 WARN_ON(rec->flags & FTRACE_FL_DIRECT);
5114                 return NULL;
5115         }
5116
5117         WARN_ON(!(rec->flags & FTRACE_FL_DIRECT));
5118
5119         /* Passed in ip just needs to be on the call site */
5120         *ip = rec->ip;
5121
5122         if (recp)
5123                 *recp = rec;
5124
5125         return entry;
5126 }
5127
5128 int unregister_ftrace_direct(unsigned long ip, unsigned long addr)
5129 {
5130         struct ftrace_direct_func *direct;
5131         struct ftrace_func_entry *entry;
5132         int ret = -ENODEV;
5133
5134         mutex_lock(&direct_mutex);
5135
5136         entry = find_direct_entry(&ip, NULL);
5137         if (!entry)
5138                 goto out_unlock;
5139
5140         if (direct_functions->count == 1)
5141                 unregister_ftrace_function(&direct_ops);
5142
5143         ret = ftrace_set_filter_ip(&direct_ops, ip, 1, 0);
5144
5145         WARN_ON(ret);
5146
5147         remove_hash_entry(direct_functions, entry);
5148
5149         direct = ftrace_find_direct_func(addr);
5150         if (!WARN_ON(!direct)) {
5151                 /* This is the good path (see the ! before WARN) */
5152                 direct->count--;
5153                 WARN_ON(direct->count < 0);
5154                 if (!direct->count) {
5155                         list_del_rcu(&direct->next);
5156                         synchronize_rcu_tasks();
5157                         kfree(direct);
5158                         ftrace_direct_func_count--;
5159                 }
5160         }
5161  out_unlock:
5162         mutex_unlock(&direct_mutex);
5163
5164         return ret;
5165 }
5166 EXPORT_SYMBOL_GPL(unregister_ftrace_direct);
5167
5168 static struct ftrace_ops stub_ops = {
5169         .func           = ftrace_stub,
5170 };
5171
5172 /**
5173  * ftrace_modify_direct_caller - modify ftrace nop directly
5174  * @entry: The ftrace hash entry of the direct helper for @rec
5175  * @rec: The record representing the function site to patch
5176  * @old_addr: The location that the site at @rec->ip currently calls
5177  * @new_addr: The location that the site at @rec->ip should call
5178  *
5179  * An architecture may overwrite this function to optimize the
5180  * changing of the direct callback on an ftrace nop location.
5181  * This is called with the ftrace_lock mutex held, and no other
5182  * ftrace callbacks are on the associated record (@rec). Thus,
5183  * it is safe to modify the ftrace record, where it should be
5184  * currently calling @old_addr directly, to call @new_addr.
5185  *
5186  * Safety checks should be made to make sure that the code at
5187  * @rec->ip is currently calling @old_addr. And this must
5188  * also update entry->direct to @new_addr.
5189  */
5190 int __weak ftrace_modify_direct_caller(struct ftrace_func_entry *entry,
5191                                        struct dyn_ftrace *rec,
5192                                        unsigned long old_addr,
5193                                        unsigned long new_addr)
5194 {
5195         unsigned long ip = rec->ip;
5196         int ret;
5197
5198         /*
5199          * The ftrace_lock was used to determine if the record
5200          * had more than one registered user to it. If it did,
5201          * we needed to prevent that from changing to do the quick
5202          * switch. But if it did not (only a direct caller was attached)
5203          * then this function is called. But this function can deal
5204          * with attached callers to the rec that we care about, and
5205          * since this function uses standard ftrace calls that take
5206          * the ftrace_lock mutex, we need to release it.
5207          */
5208         mutex_unlock(&ftrace_lock);
5209
5210         /*
5211          * By setting a stub function at the same address, we force
5212          * the code to call the iterator and the direct_ops helper.
5213          * This means that @ip does not call the direct call, and
5214          * we can simply modify it.
5215          */
5216         ret = ftrace_set_filter_ip(&stub_ops, ip, 0, 0);
5217         if (ret)
5218                 goto out_lock;
5219
5220         ret = register_ftrace_function(&stub_ops);
5221         if (ret) {
5222                 ftrace_set_filter_ip(&stub_ops, ip, 1, 0);
5223                 goto out_lock;
5224         }
5225
5226         entry->direct = new_addr;
5227
5228         /*
5229          * By removing the stub, we put back the direct call, calling
5230          * the @new_addr.
5231          */
5232         unregister_ftrace_function(&stub_ops);
5233         ftrace_set_filter_ip(&stub_ops, ip, 1, 0);
5234
5235  out_lock:
5236         mutex_lock(&ftrace_lock);
5237
5238         return ret;
5239 }
5240
5241 /**
5242  * modify_ftrace_direct - Modify an existing direct call to call something else
5243  * @ip: The instruction pointer to modify
5244  * @old_addr: The address that the current @ip calls directly
5245  * @new_addr: The address that the @ip should call
5246  *
5247  * This modifies a ftrace direct caller at an instruction pointer without
5248  * having to disable it first. The direct call will switch over to the
5249  * @new_addr without missing anything.
5250  *
5251  * Returns: zero on success. Non zero on error, which includes:
5252  *  -ENODEV : the @ip given has no direct caller attached
5253  *  -EINVAL : the @old_addr does not match the current direct caller
5254  */
5255 int modify_ftrace_direct(unsigned long ip,
5256                          unsigned long old_addr, unsigned long new_addr)
5257 {
5258         struct ftrace_func_entry *entry;
5259         struct dyn_ftrace *rec;
5260         int ret = -ENODEV;
5261
5262         mutex_lock(&direct_mutex);
5263
5264         mutex_lock(&ftrace_lock);
5265         entry = find_direct_entry(&ip, &rec);
5266         if (!entry)
5267                 goto out_unlock;
5268
5269         ret = -EINVAL;
5270         if (entry->direct != old_addr)
5271                 goto out_unlock;
5272
5273         /*
5274          * If there's no other ftrace callback on the rec->ip location,
5275          * then it can be changed directly by the architecture.
5276          * If there is another caller, then we just need to change the
5277          * direct caller helper to point to @new_addr.
5278          */
5279         if (ftrace_rec_count(rec) == 1) {
5280                 ret = ftrace_modify_direct_caller(entry, rec, old_addr, new_addr);
5281         } else {
5282                 entry->direct = new_addr;
5283                 ret = 0;
5284         }
5285
5286  out_unlock:
5287         mutex_unlock(&ftrace_lock);
5288         mutex_unlock(&direct_mutex);
5289         return ret;
5290 }
5291 EXPORT_SYMBOL_GPL(modify_ftrace_direct);
5292 #endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
5293
5294 /**
5295  * ftrace_set_filter_ip - set a function to filter on in ftrace by address
5296  * @ops - the ops to set the filter with
5297  * @ip - the address to add to or remove from the filter.
5298  * @remove - non zero to remove the ip from the filter
5299  * @reset - non zero to reset all filters before applying this filter.
5300  *
5301  * Filters denote which functions should be enabled when tracing is enabled
5302  * If @ip is NULL, it failes to update filter.
5303  */
5304 int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
5305                          int remove, int reset)
5306 {
5307         ftrace_ops_init(ops);
5308         return ftrace_set_addr(ops, ip, remove, reset, 1);
5309 }
5310 EXPORT_SYMBOL_GPL(ftrace_set_filter_ip);
5311
5312 /**
5313  * ftrace_ops_set_global_filter - setup ops to use global filters
5314  * @ops - the ops which will use the global filters
5315  *
5316  * ftrace users who need global function trace filtering should call this.
5317  * It can set the global filter only if ops were not initialized before.
5318  */
5319 void ftrace_ops_set_global_filter(struct ftrace_ops *ops)
5320 {
5321         if (ops->flags & FTRACE_OPS_FL_INITIALIZED)
5322                 return;
5323
5324         ftrace_ops_init(ops);
5325         ops->func_hash = &global_ops.local_hash;
5326 }
5327 EXPORT_SYMBOL_GPL(ftrace_ops_set_global_filter);
5328
5329 static int
5330 ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
5331                  int reset, int enable)
5332 {
5333         return ftrace_set_hash(ops, buf, len, 0, 0, reset, enable);
5334 }
5335
5336 /**
5337  * ftrace_set_filter - set a function to filter on in ftrace
5338  * @ops - the ops to set the filter with
5339  * @buf - the string that holds the function filter text.
5340  * @len - the length of the string.
5341  * @reset - non zero to reset all filters before applying this filter.
5342  *
5343  * Filters denote which functions should be enabled when tracing is enabled.
5344  * If @buf is NULL and reset is set, all functions will be enabled for tracing.
5345  */
5346 int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
5347                        int len, int reset)
5348 {
5349         ftrace_ops_init(ops);
5350         return ftrace_set_regex(ops, buf, len, reset, 1);
5351 }
5352 EXPORT_SYMBOL_GPL(ftrace_set_filter);
5353
5354 /**
5355  * ftrace_set_notrace - set a function to not trace in ftrace
5356  * @ops - the ops to set the notrace filter with
5357  * @buf - the string that holds the function notrace text.
5358  * @len - the length of the string.
5359  * @reset - non zero to reset all filters before applying this filter.
5360  *
5361  * Notrace Filters denote which functions should not be enabled when tracing
5362  * is enabled. If @buf is NULL and reset is set, all functions will be enabled
5363  * for tracing.
5364  */
5365 int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
5366                         int len, int reset)
5367 {
5368         ftrace_ops_init(ops);
5369         return ftrace_set_regex(ops, buf, len, reset, 0);
5370 }
5371 EXPORT_SYMBOL_GPL(ftrace_set_notrace);
5372 /**
5373  * ftrace_set_global_filter - set a function to filter on with global tracers
5374  * @buf - the string that holds the function filter text.
5375  * @len - the length of the string.
5376  * @reset - non zero to reset all filters before applying this filter.
5377  *
5378  * Filters denote which functions should be enabled when tracing is enabled.
5379  * If @buf is NULL and reset is set, all functions will be enabled for tracing.
5380  */
5381 void ftrace_set_global_filter(unsigned char *buf, int len, int reset)
5382 {
5383         ftrace_set_regex(&global_ops, buf, len, reset, 1);
5384 }
5385 EXPORT_SYMBOL_GPL(ftrace_set_global_filter);
5386
5387 /**
5388  * ftrace_set_global_notrace - set a function to not trace with global tracers
5389  * @buf - the string that holds the function notrace text.
5390  * @len - the length of the string.
5391  * @reset - non zero to reset all filters before applying this filter.
5392  *
5393  * Notrace Filters denote which functions should not be enabled when tracing
5394  * is enabled. If @buf is NULL and reset is set, all functions will be enabled
5395  * for tracing.
5396  */
5397 void ftrace_set_global_notrace(unsigned char *buf, int len, int reset)
5398 {
5399         ftrace_set_regex(&global_ops, buf, len, reset, 0);
5400 }
5401 EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
5402
5403 /*
5404  * command line interface to allow users to set filters on boot up.
5405  */
5406 #define FTRACE_FILTER_SIZE              COMMAND_LINE_SIZE
5407 static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
5408 static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
5409
5410 /* Used by function selftest to not test if filter is set */
5411 bool ftrace_filter_param __initdata;
5412
5413 static int __init set_ftrace_notrace(char *str)
5414 {
5415         ftrace_filter_param = true;
5416         strlcpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
5417         return 1;
5418 }
5419 __setup("ftrace_notrace=", set_ftrace_notrace);
5420
5421 static int __init set_ftrace_filter(char *str)
5422 {
5423         ftrace_filter_param = true;
5424         strlcpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
5425         return 1;
5426 }
5427 __setup("ftrace_filter=", set_ftrace_filter);
5428
5429 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
5430 static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
5431 static char ftrace_graph_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
5432 static int ftrace_graph_set_hash(struct ftrace_hash *hash, char *buffer);
5433
5434 static int __init set_graph_function(char *str)
5435 {
5436         strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
5437         return 1;
5438 }
5439 __setup("ftrace_graph_filter=", set_graph_function);
5440
5441 static int __init set_graph_notrace_function(char *str)
5442 {
5443         strlcpy(ftrace_graph_notrace_buf, str, FTRACE_FILTER_SIZE);
5444         return 1;
5445 }
5446 __setup("ftrace_graph_notrace=", set_graph_notrace_function);
5447
5448 static int __init set_graph_max_depth_function(char *str)
5449 {
5450         if (!str)
5451                 return 0;
5452         fgraph_max_depth = simple_strtoul(str, NULL, 0);
5453         return 1;
5454 }
5455 __setup("ftrace_graph_max_depth=", set_graph_max_depth_function);
5456
5457 static void __init set_ftrace_early_graph(char *buf, int enable)
5458 {
5459         int ret;
5460         char *func;
5461         struct ftrace_hash *hash;
5462
5463         hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS);
5464         if (MEM_FAIL(!hash, "Failed to allocate hash\n"))
5465                 return;
5466
5467         while (buf) {
5468                 func = strsep(&buf, ",");
5469                 /* we allow only one expression at a time */
5470                 ret = ftrace_graph_set_hash(hash, func);
5471                 if (ret)
5472                         printk(KERN_DEBUG "ftrace: function %s not "
5473                                           "traceable\n", func);
5474         }
5475
5476         if (enable)
5477                 ftrace_graph_hash = hash;
5478         else
5479                 ftrace_graph_notrace_hash = hash;
5480 }
5481 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
5482
5483 void __init
5484 ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable)
5485 {
5486         char *func;
5487
5488         ftrace_ops_init(ops);
5489
5490         while (buf) {
5491                 func = strsep(&buf, ",");
5492                 ftrace_set_regex(ops, func, strlen(func), 0, enable);
5493         }
5494 }
5495
5496 static void __init set_ftrace_early_filters(void)
5497 {
5498         if (ftrace_filter_buf[0])
5499                 ftrace_set_early_filter(&global_ops, ftrace_filter_buf, 1);
5500         if (ftrace_notrace_buf[0])
5501                 ftrace_set_early_filter(&global_ops, ftrace_notrace_buf, 0);
5502 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
5503         if (ftrace_graph_buf[0])
5504                 set_ftrace_early_graph(ftrace_graph_buf, 1);
5505         if (ftrace_graph_notrace_buf[0])
5506                 set_ftrace_early_graph(ftrace_graph_notrace_buf, 0);
5507 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
5508 }
5509
5510 int ftrace_regex_release(struct inode *inode, struct file *file)
5511 {
5512         struct seq_file *m = (struct seq_file *)file->private_data;
5513         struct ftrace_iterator *iter;
5514         struct ftrace_hash **orig_hash;
5515         struct trace_parser *parser;
5516         int filter_hash;
5517         int ret;
5518
5519         if (file->f_mode & FMODE_READ) {
5520                 iter = m->private;
5521                 seq_release(inode, file);
5522         } else
5523                 iter = file->private_data;
5524
5525         parser = &iter->parser;
5526         if (trace_parser_loaded(parser)) {
5527                 ftrace_match_records(iter->hash, parser->buffer, parser->idx);
5528         }
5529
5530         trace_parser_put(parser);
5531
5532         mutex_lock(&iter->ops->func_hash->regex_lock);
5533
5534         if (file->f_mode & FMODE_WRITE) {
5535                 filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
5536
5537                 if (filter_hash) {
5538                         orig_hash = &iter->ops->func_hash->filter_hash;
5539                         if (iter->tr && !list_empty(&iter->tr->mod_trace))
5540                                 iter->hash->flags |= FTRACE_HASH_FL_MOD;
5541                 } else
5542                         orig_hash = &iter->ops->func_hash->notrace_hash;
5543
5544                 mutex_lock(&ftrace_lock);
5545                 ret = ftrace_hash_move_and_update_ops(iter->ops, orig_hash,
5546                                                       iter->hash, filter_hash);
5547                 mutex_unlock(&ftrace_lock);
5548         } else {
5549                 /* For read only, the hash is the ops hash */
5550                 iter->hash = NULL;
5551         }
5552
5553         mutex_unlock(&iter->ops->func_hash->regex_lock);
5554         free_ftrace_hash(iter->hash);
5555         if (iter->tr)
5556                 trace_array_put(iter->tr);
5557         kfree(iter);
5558
5559         return 0;
5560 }
5561
5562 static const struct file_operations ftrace_avail_fops = {
5563         .open = ftrace_avail_open,
5564         .read = seq_read,
5565         .llseek = seq_lseek,
5566         .release = seq_release_private,
5567 };
5568
5569 static const struct file_operations ftrace_enabled_fops = {
5570         .open = ftrace_enabled_open,
5571         .read = seq_read,
5572         .llseek = seq_lseek,
5573         .release = seq_release_private,
5574 };
5575
5576 static const struct file_operations ftrace_filter_fops = {
5577         .open = ftrace_filter_open,
5578         .read = seq_read,
5579         .write = ftrace_filter_write,
5580         .llseek = tracing_lseek,
5581         .release = ftrace_regex_release,
5582 };
5583
5584 static const struct file_operations ftrace_notrace_fops = {
5585         .open = ftrace_notrace_open,
5586         .read = seq_read,
5587         .write = ftrace_notrace_write,
5588         .llseek = tracing_lseek,
5589         .release = ftrace_regex_release,
5590 };
5591
5592 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
5593
5594 static DEFINE_MUTEX(graph_lock);
5595
5596 struct ftrace_hash __rcu *ftrace_graph_hash = EMPTY_HASH;
5597 struct ftrace_hash __rcu *ftrace_graph_notrace_hash = EMPTY_HASH;
5598
5599 enum graph_filter_type {
5600         GRAPH_FILTER_NOTRACE    = 0,
5601         GRAPH_FILTER_FUNCTION,
5602 };
5603
5604 #define FTRACE_GRAPH_EMPTY      ((void *)1)
5605
5606 struct ftrace_graph_data {
5607         struct ftrace_hash              *hash;
5608         struct ftrace_func_entry        *entry;
5609         int                             idx;   /* for hash table iteration */
5610         enum graph_filter_type          type;
5611         struct ftrace_hash              *new_hash;
5612         const struct seq_operations     *seq_ops;
5613         struct trace_parser             parser;
5614 };
5615
5616 static void *
5617 __g_next(struct seq_file *m, loff_t *pos)
5618 {
5619         struct ftrace_graph_data *fgd = m->private;
5620         struct ftrace_func_entry *entry = fgd->entry;
5621         struct hlist_head *head;
5622         int i, idx = fgd->idx;
5623
5624         if (*pos >= fgd->hash->count)
5625                 return NULL;
5626
5627         if (entry) {
5628                 hlist_for_each_entry_continue(entry, hlist) {
5629                         fgd->entry = entry;
5630                         return entry;
5631                 }
5632
5633                 idx++;
5634         }
5635
5636         for (i = idx; i < 1 << fgd->hash->size_bits; i++) {
5637                 head = &fgd->hash->buckets[i];
5638                 hlist_for_each_entry(entry, head, hlist) {
5639                         fgd->entry = entry;
5640                         fgd->idx = i;
5641                         return entry;
5642                 }
5643         }
5644         return NULL;
5645 }
5646
5647 static void *
5648 g_next(struct seq_file *m, void *v, loff_t *pos)
5649 {
5650         (*pos)++;
5651         return __g_next(m, pos);
5652 }
5653
5654 static void *g_start(struct seq_file *m, loff_t *pos)
5655 {
5656         struct ftrace_graph_data *fgd = m->private;
5657
5658         mutex_lock(&graph_lock);
5659
5660         if (fgd->type == GRAPH_FILTER_FUNCTION)
5661                 fgd->hash = rcu_dereference_protected(ftrace_graph_hash,
5662                                         lockdep_is_held(&graph_lock));
5663         else
5664                 fgd->hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
5665                                         lockdep_is_held(&graph_lock));
5666
5667         /* Nothing, tell g_show to print all functions are enabled */
5668         if (ftrace_hash_empty(fgd->hash) && !*pos)
5669                 return FTRACE_GRAPH_EMPTY;
5670
5671         fgd->idx = 0;
5672         fgd->entry = NULL;
5673         return __g_next(m, pos);
5674 }
5675
5676 static void g_stop(struct seq_file *m, void *p)
5677 {
5678         mutex_unlock(&graph_lock);
5679 }
5680
5681 static int g_show(struct seq_file *m, void *v)
5682 {
5683         struct ftrace_func_entry *entry = v;
5684
5685         if (!entry)
5686                 return 0;
5687
5688         if (entry == FTRACE_GRAPH_EMPTY) {
5689                 struct ftrace_graph_data *fgd = m->private;
5690
5691                 if (fgd->type == GRAPH_FILTER_FUNCTION)
5692                         seq_puts(m, "#### all functions enabled ####\n");
5693                 else
5694                         seq_puts(m, "#### no functions disabled ####\n");
5695                 return 0;
5696         }
5697
5698         seq_printf(m, "%ps\n", (void *)entry->ip);
5699
5700         return 0;
5701 }
5702
5703 static const struct seq_operations ftrace_graph_seq_ops = {
5704         .start = g_start,
5705         .next = g_next,
5706         .stop = g_stop,
5707         .show = g_show,
5708 };
5709
5710 static int
5711 __ftrace_graph_open(struct inode *inode, struct file *file,
5712                     struct ftrace_graph_data *fgd)
5713 {
5714         int ret;
5715         struct ftrace_hash *new_hash = NULL;
5716
5717         ret = security_locked_down(LOCKDOWN_TRACEFS);
5718         if (ret)
5719                 return ret;
5720
5721         if (file->f_mode & FMODE_WRITE) {
5722                 const int size_bits = FTRACE_HASH_DEFAULT_BITS;
5723
5724                 if (trace_parser_get_init(&fgd->parser, FTRACE_BUFF_MAX))
5725                         return -ENOMEM;
5726
5727                 if (file->f_flags & O_TRUNC)
5728                         new_hash = alloc_ftrace_hash(size_bits);
5729                 else
5730                         new_hash = alloc_and_copy_ftrace_hash(size_bits,
5731                                                               fgd->hash);
5732                 if (!new_hash) {
5733                         ret = -ENOMEM;
5734                         goto out;
5735                 }
5736         }
5737
5738         if (file->f_mode & FMODE_READ) {
5739                 ret = seq_open(file, &ftrace_graph_seq_ops);
5740                 if (!ret) {
5741                         struct seq_file *m = file->private_data;
5742                         m->private = fgd;
5743                 } else {
5744                         /* Failed */
5745                         free_ftrace_hash(new_hash);
5746                         new_hash = NULL;
5747                 }
5748         } else
5749                 file->private_data = fgd;
5750
5751 out:
5752         if (ret < 0 && file->f_mode & FMODE_WRITE)
5753                 trace_parser_put(&fgd->parser);
5754
5755         fgd->new_hash = new_hash;
5756
5757         /*
5758          * All uses of fgd->hash must be taken with the graph_lock
5759          * held. The graph_lock is going to be released, so force
5760          * fgd->hash to be reinitialized when it is taken again.
5761          */
5762         fgd->hash = NULL;
5763
5764         return ret;
5765 }
5766
5767 static int
5768 ftrace_graph_open(struct inode *inode, struct file *file)
5769 {
5770         struct ftrace_graph_data *fgd;
5771         int ret;
5772
5773         if (unlikely(ftrace_disabled))
5774                 return -ENODEV;
5775
5776         fgd = kmalloc(sizeof(*fgd), GFP_KERNEL);
5777         if (fgd == NULL)
5778                 return -ENOMEM;
5779
5780         mutex_lock(&graph_lock);
5781
5782         fgd->hash = rcu_dereference_protected(ftrace_graph_hash,
5783                                         lockdep_is_held(&graph_lock));
5784         fgd->type = GRAPH_FILTER_FUNCTION;
5785         fgd->seq_ops = &ftrace_graph_seq_ops;
5786
5787         ret = __ftrace_graph_open(inode, file, fgd);
5788         if (ret < 0)
5789                 kfree(fgd);
5790
5791         mutex_unlock(&graph_lock);
5792         return ret;
5793 }
5794
5795 static int
5796 ftrace_graph_notrace_open(struct inode *inode, struct file *file)
5797 {
5798         struct ftrace_graph_data *fgd;
5799         int ret;
5800
5801         if (unlikely(ftrace_disabled))
5802                 return -ENODEV;
5803
5804         fgd = kmalloc(sizeof(*fgd), GFP_KERNEL);
5805         if (fgd == NULL)
5806                 return -ENOMEM;
5807
5808         mutex_lock(&graph_lock);
5809
5810         fgd->hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
5811                                         lockdep_is_held(&graph_lock));
5812         fgd->type = GRAPH_FILTER_NOTRACE;
5813         fgd->seq_ops = &ftrace_graph_seq_ops;
5814
5815         ret = __ftrace_graph_open(inode, file, fgd);
5816         if (ret < 0)
5817                 kfree(fgd);
5818
5819         mutex_unlock(&graph_lock);
5820         return ret;
5821 }
5822
5823 static int
5824 ftrace_graph_release(struct inode *inode, struct file *file)
5825 {
5826         struct ftrace_graph_data *fgd;
5827         struct ftrace_hash *old_hash, *new_hash;
5828         struct trace_parser *parser;
5829         int ret = 0;
5830
5831         if (file->f_mode & FMODE_READ) {
5832                 struct seq_file *m = file->private_data;
5833
5834                 fgd = m->private;
5835                 seq_release(inode, file);
5836         } else {
5837                 fgd = file->private_data;
5838         }
5839
5840
5841         if (file->f_mode & FMODE_WRITE) {
5842
5843                 parser = &fgd->parser;
5844
5845                 if (trace_parser_loaded((parser))) {
5846                         ret = ftrace_graph_set_hash(fgd->new_hash,
5847                                                     parser->buffer);
5848                 }
5849
5850                 trace_parser_put(parser);
5851
5852                 new_hash = __ftrace_hash_move(fgd->new_hash);
5853                 if (!new_hash) {
5854                         ret = -ENOMEM;
5855                         goto out;
5856                 }
5857
5858                 mutex_lock(&graph_lock);
5859
5860                 if (fgd->type == GRAPH_FILTER_FUNCTION) {
5861                         old_hash = rcu_dereference_protected(ftrace_graph_hash,
5862                                         lockdep_is_held(&graph_lock));
5863                         rcu_assign_pointer(ftrace_graph_hash, new_hash);
5864                 } else {
5865                         old_hash = rcu_dereference_protected(ftrace_graph_notrace_hash,
5866                                         lockdep_is_held(&graph_lock));
5867                         rcu_assign_pointer(ftrace_graph_notrace_hash, new_hash);
5868                 }
5869
5870                 mutex_unlock(&graph_lock);
5871
5872                 /*
5873                  * We need to do a hard force of sched synchronization.
5874                  * This is because we use preempt_disable() to do RCU, but
5875                  * the function tracers can be called where RCU is not watching
5876                  * (like before user_exit()). We can not rely on the RCU
5877                  * infrastructure to do the synchronization, thus we must do it
5878                  * ourselves.
5879                  */
5880                 schedule_on_each_cpu(ftrace_sync);
5881
5882                 free_ftrace_hash(old_hash);
5883         }
5884
5885  out:
5886         free_ftrace_hash(fgd->new_hash);
5887         kfree(fgd);
5888
5889         return ret;
5890 }
5891
5892 static int
5893 ftrace_graph_set_hash(struct ftrace_hash *hash, char *buffer)
5894 {
5895         struct ftrace_glob func_g;
5896         struct dyn_ftrace *rec;
5897         struct ftrace_page *pg;
5898         struct ftrace_func_entry *entry;
5899         int fail = 1;
5900         int not;
5901
5902         /* decode regex */
5903         func_g.type = filter_parse_regex(buffer, strlen(buffer),
5904                                          &func_g.search, &not);
5905
5906         func_g.len = strlen(func_g.search);
5907
5908         mutex_lock(&ftrace_lock);
5909
5910         if (unlikely(ftrace_disabled)) {
5911                 mutex_unlock(&ftrace_lock);
5912                 return -ENODEV;
5913         }
5914
5915         do_for_each_ftrace_rec(pg, rec) {
5916
5917                 if (rec->flags & FTRACE_FL_DISABLED)
5918                         continue;
5919
5920                 if (ftrace_match_record(rec, &func_g, NULL, 0)) {
5921                         entry = ftrace_lookup_ip(hash, rec->ip);
5922
5923                         if (!not) {
5924                                 fail = 0;
5925
5926                                 if (entry)
5927                                         continue;
5928                                 if (add_hash_entry(hash, rec->ip) < 0)
5929                                         goto out;
5930                         } else {
5931                                 if (entry) {
5932                                         free_hash_entry(hash, entry);
5933                                         fail = 0;
5934                                 }
5935                         }
5936                 }
5937         } while_for_each_ftrace_rec();
5938 out:
5939         mutex_unlock(&ftrace_lock);
5940
5941         if (fail)
5942                 return -EINVAL;
5943
5944         return 0;
5945 }
5946
5947 static ssize_t
5948 ftrace_graph_write(struct file *file, const char __user *ubuf,
5949                    size_t cnt, loff_t *ppos)
5950 {
5951         ssize_t read, ret = 0;
5952         struct ftrace_graph_data *fgd = file->private_data;
5953         struct trace_parser *parser;
5954
5955         if (!cnt)
5956                 return 0;
5957
5958         /* Read mode uses seq functions */
5959         if (file->f_mode & FMODE_READ) {
5960                 struct seq_file *m = file->private_data;
5961                 fgd = m->private;
5962         }
5963
5964         parser = &fgd->parser;
5965
5966         read = trace_get_user(parser, ubuf, cnt, ppos);
5967
5968         if (read >= 0 && trace_parser_loaded(parser) &&
5969             !trace_parser_cont(parser)) {
5970
5971                 ret = ftrace_graph_set_hash(fgd->new_hash,
5972                                             parser->buffer);
5973                 trace_parser_clear(parser);
5974         }
5975
5976         if (!ret)
5977                 ret = read;
5978
5979         return ret;
5980 }
5981
5982 static const struct file_operations ftrace_graph_fops = {
5983         .open           = ftrace_graph_open,
5984         .read           = seq_read,
5985         .write          = ftrace_graph_write,
5986         .llseek         = tracing_lseek,
5987         .release        = ftrace_graph_release,
5988 };
5989
5990 static const struct file_operations ftrace_graph_notrace_fops = {
5991         .open           = ftrace_graph_notrace_open,
5992         .read           = seq_read,
5993         .write          = ftrace_graph_write,
5994         .llseek         = tracing_lseek,
5995         .release        = ftrace_graph_release,
5996 };
5997 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
5998
5999 void ftrace_create_filter_files(struct ftrace_ops *ops,
6000                                 struct dentry *parent)
6001 {
6002
6003         trace_create_file("set_ftrace_filter", 0644, parent,
6004                           ops, &ftrace_filter_fops);
6005
6006         trace_create_file("set_ftrace_notrace", 0644, parent,
6007                           ops, &ftrace_notrace_fops);
6008 }
6009
6010 /*
6011  * The name "destroy_filter_files" is really a misnomer. Although
6012  * in the future, it may actually delete the files, but this is
6013  * really intended to make sure the ops passed in are disabled
6014  * and that when this function returns, the caller is free to
6015  * free the ops.
6016  *
6017  * The "destroy" name is only to match the "create" name that this
6018  * should be paired with.
6019  */
6020 void ftrace_destroy_filter_files(struct ftrace_ops *ops)
6021 {
6022         mutex_lock(&ftrace_lock);
6023         if (ops->flags & FTRACE_OPS_FL_ENABLED)
6024                 ftrace_shutdown(ops, 0);
6025         ops->flags |= FTRACE_OPS_FL_DELETED;
6026         ftrace_free_filter(ops);
6027         mutex_unlock(&ftrace_lock);
6028 }
6029
6030 static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer)
6031 {
6032
6033         trace_create_file("available_filter_functions", 0444,
6034                         d_tracer, NULL, &ftrace_avail_fops);
6035
6036         trace_create_file("enabled_functions", 0444,
6037                         d_tracer, NULL, &ftrace_enabled_fops);
6038
6039         ftrace_create_filter_files(&global_ops, d_tracer);
6040
6041 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
6042         trace_create_file("set_graph_function", 0644, d_tracer,
6043                                     NULL,
6044                                     &ftrace_graph_fops);
6045         trace_create_file("set_graph_notrace", 0644, d_tracer,
6046                                     NULL,
6047                                     &ftrace_graph_notrace_fops);
6048 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
6049
6050         return 0;
6051 }
6052
6053 static int ftrace_cmp_ips(const void *a, const void *b)
6054 {
6055         const unsigned long *ipa = a;
6056         const unsigned long *ipb = b;
6057
6058         if (*ipa > *ipb)
6059                 return 1;
6060         if (*ipa < *ipb)
6061                 return -1;
6062         return 0;
6063 }
6064
6065 static int ftrace_process_locs(struct module *mod,
6066                                unsigned long *start,
6067                                unsigned long *end)
6068 {
6069         struct ftrace_page *start_pg;
6070         struct ftrace_page *pg;
6071         struct dyn_ftrace *rec;
6072         unsigned long count;
6073         unsigned long *p;
6074         unsigned long addr;
6075         unsigned long flags = 0; /* Shut up gcc */
6076         int ret = -ENOMEM;
6077
6078         count = end - start;
6079
6080         if (!count)
6081                 return 0;
6082
6083         sort(start, count, sizeof(*start),
6084              ftrace_cmp_ips, NULL);
6085
6086         start_pg = ftrace_allocate_pages(count);
6087         if (!start_pg)
6088                 return -ENOMEM;
6089
6090         mutex_lock(&ftrace_lock);
6091
6092         /*
6093          * Core and each module needs their own pages, as
6094          * modules will free them when they are removed.
6095          * Force a new page to be allocated for modules.
6096          */
6097         if (!mod) {
6098                 WARN_ON(ftrace_pages || ftrace_pages_start);
6099                 /* First initialization */
6100                 ftrace_pages = ftrace_pages_start = start_pg;
6101         } else {
6102                 if (!ftrace_pages)
6103                         goto out;
6104
6105                 if (WARN_ON(ftrace_pages->next)) {
6106                         /* Hmm, we have free pages? */
6107                         while (ftrace_pages->next)
6108                                 ftrace_pages = ftrace_pages->next;
6109                 }
6110
6111                 ftrace_pages->next = start_pg;
6112         }
6113
6114         p = start;
6115         pg = start_pg;
6116         while (p < end) {
6117                 addr = ftrace_call_adjust(*p++);
6118                 /*
6119                  * Some architecture linkers will pad between
6120                  * the different mcount_loc sections of different
6121                  * object files to satisfy alignments.
6122                  * Skip any NULL pointers.
6123                  */
6124                 if (!addr)
6125                         continue;
6126
6127                 if (pg->index == pg->size) {
6128                         /* We should have allocated enough */
6129                         if (WARN_ON(!pg->next))
6130                                 break;
6131                         pg = pg->next;
6132                 }
6133
6134                 rec = &pg->records[pg->index++];
6135                 rec->ip = addr;
6136         }
6137
6138         /* We should have used all pages */
6139         WARN_ON(pg->next);
6140
6141         /* Assign the last page to ftrace_pages */
6142         ftrace_pages = pg;
6143
6144         /*
6145          * We only need to disable interrupts on start up
6146          * because we are modifying code that an interrupt
6147          * may execute, and the modification is not atomic.
6148          * But for modules, nothing runs the code we modify
6149          * until we are finished with it, and there's no
6150          * reason to cause large interrupt latencies while we do it.
6151          */
6152         if (!mod)
6153                 local_irq_save(flags);
6154         ftrace_update_code(mod, start_pg);
6155         if (!mod)
6156                 local_irq_restore(flags);
6157         ret = 0;
6158  out:
6159         mutex_unlock(&ftrace_lock);
6160
6161         return ret;
6162 }
6163
6164 struct ftrace_mod_func {
6165         struct list_head        list;
6166         char                    *name;
6167         unsigned long           ip;
6168         unsigned int            size;
6169 };
6170
6171 struct ftrace_mod_map {
6172         struct rcu_head         rcu;
6173         struct list_head        list;
6174         struct module           *mod;
6175         unsigned long           start_addr;
6176         unsigned long           end_addr;
6177         struct list_head        funcs;
6178         unsigned int            num_funcs;
6179 };
6180
6181 #ifdef CONFIG_MODULES
6182
6183 #define next_to_ftrace_page(p) container_of(p, struct ftrace_page, next)
6184
6185 static LIST_HEAD(ftrace_mod_maps);
6186
6187 static int referenced_filters(struct dyn_ftrace *rec)
6188 {
6189         struct ftrace_ops *ops;
6190         int cnt = 0;
6191
6192         for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {
6193                 if (ops_references_rec(ops, rec))
6194                     cnt++;
6195         }
6196
6197         return cnt;
6198 }
6199
6200 static void
6201 clear_mod_from_hash(struct ftrace_page *pg, struct ftrace_hash *hash)
6202 {
6203         struct ftrace_func_entry *entry;
6204         struct dyn_ftrace *rec;
6205         int i;
6206
6207         if (ftrace_hash_empty(hash))
6208                 return;
6209
6210         for (i = 0; i < pg->index; i++) {
6211                 rec = &pg->records[i];
6212                 entry = __ftrace_lookup_ip(hash, rec->ip);
6213                 /*
6214                  * Do not allow this rec to match again.
6215                  * Yeah, it may waste some memory, but will be removed
6216                  * if/when the hash is modified again.
6217                  */
6218                 if (entry)
6219                         entry->ip = 0;
6220         }
6221 }
6222
6223 /* Clear any records from hashs */
6224 static void clear_mod_from_hashes(struct ftrace_page *pg)
6225 {
6226         struct trace_array *tr;
6227
6228         mutex_lock(&trace_types_lock);
6229         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
6230                 if (!tr->ops || !tr->ops->func_hash)
6231                         continue;
6232                 mutex_lock(&tr->ops->func_hash->regex_lock);
6233                 clear_mod_from_hash(pg, tr->ops->func_hash->filter_hash);
6234                 clear_mod_from_hash(pg, tr->ops->func_hash->notrace_hash);
6235                 mutex_unlock(&tr->ops->func_hash->regex_lock);
6236         }
6237         mutex_unlock(&trace_types_lock);
6238 }
6239
6240 static void ftrace_free_mod_map(struct rcu_head *rcu)
6241 {
6242         struct ftrace_mod_map *mod_map = container_of(rcu, struct ftrace_mod_map, rcu);
6243         struct ftrace_mod_func *mod_func;
6244         struct ftrace_mod_func *n;
6245
6246         /* All the contents of mod_map are now not visible to readers */
6247         list_for_each_entry_safe(mod_func, n, &mod_map->funcs, list) {
6248                 kfree(mod_func->name);
6249                 list_del(&mod_func->list);
6250                 kfree(mod_func);
6251         }
6252
6253         kfree(mod_map);
6254 }
6255
6256 void ftrace_release_mod(struct module *mod)
6257 {
6258         struct ftrace_mod_map *mod_map;
6259         struct ftrace_mod_map *n;
6260         struct dyn_ftrace *rec;
6261         struct ftrace_page **last_pg;
6262         struct ftrace_page *tmp_page = NULL;
6263         struct ftrace_page *pg;
6264         int order;
6265
6266         mutex_lock(&ftrace_lock);
6267
6268         if (ftrace_disabled)
6269                 goto out_unlock;
6270
6271         list_for_each_entry_safe(mod_map, n, &ftrace_mod_maps, list) {
6272                 if (mod_map->mod == mod) {
6273                         list_del_rcu(&mod_map->list);
6274                         call_rcu(&mod_map->rcu, ftrace_free_mod_map);
6275                         break;
6276                 }
6277         }
6278
6279         /*
6280          * Each module has its own ftrace_pages, remove
6281          * them from the list.
6282          */
6283         last_pg = &ftrace_pages_start;
6284         for (pg = ftrace_pages_start; pg; pg = *last_pg) {
6285                 rec = &pg->records[0];
6286                 if (within_module_core(rec->ip, mod) ||
6287                     within_module_init(rec->ip, mod)) {
6288                         /*
6289                          * As core pages are first, the first
6290                          * page should never be a module page.
6291                          */
6292                         if (WARN_ON(pg == ftrace_pages_start))
6293                                 goto out_unlock;
6294
6295                         /* Check if we are deleting the last page */
6296                         if (pg == ftrace_pages)
6297                                 ftrace_pages = next_to_ftrace_page(last_pg);
6298
6299                         ftrace_update_tot_cnt -= pg->index;
6300                         *last_pg = pg->next;
6301
6302                         pg->next = tmp_page;
6303                         tmp_page = pg;
6304                 } else
6305                         last_pg = &pg->next;
6306         }
6307  out_unlock:
6308         mutex_unlock(&ftrace_lock);
6309
6310         for (pg = tmp_page; pg; pg = tmp_page) {
6311
6312                 /* Needs to be called outside of ftrace_lock */
6313                 clear_mod_from_hashes(pg);
6314
6315                 order = get_count_order(pg->size / ENTRIES_PER_PAGE);
6316                 free_pages((unsigned long)pg->records, order);
6317                 tmp_page = pg->next;
6318                 kfree(pg);
6319                 ftrace_number_of_pages -= 1 << order;
6320                 ftrace_number_of_groups--;
6321         }
6322 }
6323
6324 void ftrace_module_enable(struct module *mod)
6325 {
6326         struct dyn_ftrace *rec;
6327         struct ftrace_page *pg;
6328
6329         mutex_lock(&ftrace_lock);
6330
6331         if (ftrace_disabled)
6332                 goto out_unlock;
6333
6334         /*
6335          * If the tracing is enabled, go ahead and enable the record.
6336          *
6337          * The reason not to enable the record immediately is the
6338          * inherent check of ftrace_make_nop/ftrace_make_call for
6339          * correct previous instructions.  Making first the NOP
6340          * conversion puts the module to the correct state, thus
6341          * passing the ftrace_make_call check.
6342          *
6343          * We also delay this to after the module code already set the
6344          * text to read-only, as we now need to set it back to read-write
6345          * so that we can modify the text.
6346          */
6347         if (ftrace_start_up)
6348                 ftrace_arch_code_modify_prepare();
6349
6350         do_for_each_ftrace_rec(pg, rec) {
6351                 int cnt;
6352                 /*
6353                  * do_for_each_ftrace_rec() is a double loop.
6354                  * module text shares the pg. If a record is
6355                  * not part of this module, then skip this pg,
6356                  * which the "break" will do.
6357                  */
6358                 if (!within_module_core(rec->ip, mod) &&
6359                     !within_module_init(rec->ip, mod))
6360                         break;
6361
6362                 cnt = 0;
6363
6364                 /*
6365                  * When adding a module, we need to check if tracers are
6366                  * currently enabled and if they are, and can trace this record,
6367                  * we need to enable the module functions as well as update the
6368                  * reference counts for those function records.
6369                  */
6370                 if (ftrace_start_up)
6371                         cnt += referenced_filters(rec);
6372
6373                 /* This clears FTRACE_FL_DISABLED */
6374                 rec->flags = cnt;
6375
6376                 if (ftrace_start_up && cnt) {
6377                         int failed = __ftrace_replace_code(rec, 1);
6378                         if (failed) {
6379                                 ftrace_bug(failed, rec);
6380                                 goto out_loop;
6381                         }
6382                 }
6383
6384         } while_for_each_ftrace_rec();
6385
6386  out_loop:
6387         if (ftrace_start_up)
6388                 ftrace_arch_code_modify_post_process();
6389
6390  out_unlock:
6391         mutex_unlock(&ftrace_lock);
6392
6393         process_cached_mods(mod->name);
6394 }
6395
6396 void ftrace_module_init(struct module *mod)
6397 {
6398         if (ftrace_disabled || !mod->num_ftrace_callsites)
6399                 return;
6400
6401         ftrace_process_locs(mod, mod->ftrace_callsites,
6402                             mod->ftrace_callsites + mod->num_ftrace_callsites);
6403 }
6404
6405 static void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map,
6406                                 struct dyn_ftrace *rec)
6407 {
6408         struct ftrace_mod_func *mod_func;
6409         unsigned long symsize;
6410         unsigned long offset;
6411         char str[KSYM_SYMBOL_LEN];
6412         char *modname;
6413         const char *ret;
6414
6415         ret = kallsyms_lookup(rec->ip, &symsize, &offset, &modname, str);
6416         if (!ret)
6417                 return;
6418
6419         mod_func = kmalloc(sizeof(*mod_func), GFP_KERNEL);
6420         if (!mod_func)
6421                 return;
6422
6423         mod_func->name = kstrdup(str, GFP_KERNEL);
6424         if (!mod_func->name) {
6425                 kfree(mod_func);
6426                 return;
6427         }
6428
6429         mod_func->ip = rec->ip - offset;
6430         mod_func->size = symsize;
6431
6432         mod_map->num_funcs++;
6433
6434         list_add_rcu(&mod_func->list, &mod_map->funcs);
6435 }
6436
6437 static struct ftrace_mod_map *
6438 allocate_ftrace_mod_map(struct module *mod,
6439                         unsigned long start, unsigned long end)
6440 {
6441         struct ftrace_mod_map *mod_map;
6442
6443         mod_map = kmalloc(sizeof(*mod_map), GFP_KERNEL);
6444         if (!mod_map)
6445                 return NULL;
6446
6447         mod_map->mod = mod;
6448         mod_map->start_addr = start;
6449         mod_map->end_addr = end;
6450         mod_map->num_funcs = 0;
6451
6452         INIT_LIST_HEAD_RCU(&mod_map->funcs);
6453
6454         list_add_rcu(&mod_map->list, &ftrace_mod_maps);
6455
6456         return mod_map;
6457 }
6458
6459 static const char *
6460 ftrace_func_address_lookup(struct ftrace_mod_map *mod_map,
6461                            unsigned long addr, unsigned long *size,
6462                            unsigned long *off, char *sym)
6463 {
6464         struct ftrace_mod_func *found_func =  NULL;
6465         struct ftrace_mod_func *mod_func;
6466
6467         list_for_each_entry_rcu(mod_func, &mod_map->funcs, list) {
6468                 if (addr >= mod_func->ip &&
6469                     addr < mod_func->ip + mod_func->size) {
6470                         found_func = mod_func;
6471                         break;
6472                 }
6473         }
6474
6475         if (found_func) {
6476                 if (size)
6477                         *size = found_func->size;
6478                 if (off)
6479                         *off = addr - found_func->ip;
6480                 if (sym)
6481                         strlcpy(sym, found_func->name, KSYM_NAME_LEN);
6482
6483                 return found_func->name;
6484         }
6485
6486         return NULL;
6487 }
6488
6489 const char *
6490 ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,
6491                    unsigned long *off, char **modname, char *sym)
6492 {
6493         struct ftrace_mod_map *mod_map;
6494         const char *ret = NULL;
6495
6496         /* mod_map is freed via call_rcu() */
6497         preempt_disable();
6498         list_for_each_entry_rcu(mod_map, &ftrace_mod_maps, list) {
6499                 ret = ftrace_func_address_lookup(mod_map, addr, size, off, sym);
6500                 if (ret) {
6501                         if (modname)
6502                                 *modname = mod_map->mod->name;
6503                         break;
6504                 }
6505         }
6506         preempt_enable();
6507
6508         return ret;
6509 }
6510
6511 int ftrace_mod_get_kallsym(unsigned int symnum, unsigned long *value,
6512                            char *type, char *name,
6513                            char *module_name, int *exported)
6514 {
6515         struct ftrace_mod_map *mod_map;
6516         struct ftrace_mod_func *mod_func;
6517
6518         preempt_disable();
6519         list_for_each_entry_rcu(mod_map, &ftrace_mod_maps, list) {
6520
6521                 if (symnum >= mod_map->num_funcs) {
6522                         symnum -= mod_map->num_funcs;
6523                         continue;
6524                 }
6525
6526                 list_for_each_entry_rcu(mod_func, &mod_map->funcs, list) {
6527                         if (symnum > 1) {
6528                                 symnum--;
6529                                 continue;
6530                         }
6531
6532                         *value = mod_func->ip;
6533                         *type = 'T';
6534                         strlcpy(name, mod_func->name, KSYM_NAME_LEN);
6535                         strlcpy(module_name, mod_map->mod->name, MODULE_NAME_LEN);
6536                         *exported = 1;
6537                         preempt_enable();
6538                         return 0;
6539                 }
6540                 WARN_ON(1);
6541                 break;
6542         }
6543         preempt_enable();
6544         return -ERANGE;
6545 }
6546
6547 #else
6548 static void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map,
6549                                 struct dyn_ftrace *rec) { }
6550 static inline struct ftrace_mod_map *
6551 allocate_ftrace_mod_map(struct module *mod,
6552                         unsigned long start, unsigned long end)
6553 {
6554         return NULL;
6555 }
6556 #endif /* CONFIG_MODULES */
6557
6558 struct ftrace_init_func {
6559         struct list_head list;
6560         unsigned long ip;
6561 };
6562
6563 /* Clear any init ips from hashes */
6564 static void
6565 clear_func_from_hash(struct ftrace_init_func *func, struct ftrace_hash *hash)
6566 {
6567         struct ftrace_func_entry *entry;
6568
6569         entry = ftrace_lookup_ip(hash, func->ip);
6570         /*
6571          * Do not allow this rec to match again.
6572          * Yeah, it may waste some memory, but will be removed
6573          * if/when the hash is modified again.
6574          */
6575         if (entry)
6576                 entry->ip = 0;
6577 }
6578
6579 static void
6580 clear_func_from_hashes(struct ftrace_init_func *func)
6581 {
6582         struct trace_array *tr;
6583
6584         mutex_lock(&trace_types_lock);
6585         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
6586                 if (!tr->ops || !tr->ops->func_hash)
6587                         continue;
6588                 mutex_lock(&tr->ops->func_hash->regex_lock);
6589                 clear_func_from_hash(func, tr->ops->func_hash->filter_hash);
6590                 clear_func_from_hash(func, tr->ops->func_hash->notrace_hash);
6591                 mutex_unlock(&tr->ops->func_hash->regex_lock);
6592         }
6593         mutex_unlock(&trace_types_lock);
6594 }
6595
6596 static void add_to_clear_hash_list(struct list_head *clear_list,
6597                                    struct dyn_ftrace *rec)
6598 {
6599         struct ftrace_init_func *func;
6600
6601         func = kmalloc(sizeof(*func), GFP_KERNEL);
6602         if (!func) {
6603                 MEM_FAIL(1, "alloc failure, ftrace filter could be stale\n");
6604                 return;
6605         }
6606
6607         func->ip = rec->ip;
6608         list_add(&func->list, clear_list);
6609 }
6610
6611 void ftrace_free_mem(struct module *mod, void *start_ptr, void *end_ptr)
6612 {
6613         unsigned long start = (unsigned long)(start_ptr);
6614         unsigned long end = (unsigned long)(end_ptr);
6615         struct ftrace_page **last_pg = &ftrace_pages_start;
6616         struct ftrace_page *pg;
6617         struct dyn_ftrace *rec;
6618         struct dyn_ftrace key;
6619         struct ftrace_mod_map *mod_map = NULL;
6620         struct ftrace_init_func *func, *func_next;
6621         struct list_head clear_hash;
6622         int order;
6623
6624         INIT_LIST_HEAD(&clear_hash);
6625
6626         key.ip = start;
6627         key.flags = end;        /* overload flags, as it is unsigned long */
6628
6629         mutex_lock(&ftrace_lock);
6630
6631         /*
6632          * If we are freeing module init memory, then check if
6633          * any tracer is active. If so, we need to save a mapping of
6634          * the module functions being freed with the address.
6635          */
6636         if (mod && ftrace_ops_list != &ftrace_list_end)
6637                 mod_map = allocate_ftrace_mod_map(mod, start, end);
6638
6639         for (pg = ftrace_pages_start; pg; last_pg = &pg->next, pg = *last_pg) {
6640                 if (end < pg->records[0].ip ||
6641                     start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE))
6642                         continue;
6643  again:
6644                 rec = bsearch(&key, pg->records, pg->index,
6645                               sizeof(struct dyn_ftrace),
6646                               ftrace_cmp_recs);
6647                 if (!rec)
6648                         continue;
6649
6650                 /* rec will be cleared from hashes after ftrace_lock unlock */
6651                 add_to_clear_hash_list(&clear_hash, rec);
6652
6653                 if (mod_map)
6654                         save_ftrace_mod_rec(mod_map, rec);
6655
6656                 pg->index--;
6657                 ftrace_update_tot_cnt--;
6658                 if (!pg->index) {
6659                         *last_pg = pg->next;
6660                         order = get_count_order(pg->size / ENTRIES_PER_PAGE);
6661                         free_pages((unsigned long)pg->records, order);
6662                         ftrace_number_of_pages -= 1 << order;
6663                         ftrace_number_of_groups--;
6664                         kfree(pg);
6665                         pg = container_of(last_pg, struct ftrace_page, next);
6666                         if (!(*last_pg))
6667                                 ftrace_pages = pg;
6668                         continue;
6669                 }
6670                 memmove(rec, rec + 1,
6671                         (pg->index - (rec - pg->records)) * sizeof(*rec));
6672                 /* More than one function may be in this block */
6673                 goto again;
6674         }
6675         mutex_unlock(&ftrace_lock);
6676
6677         list_for_each_entry_safe(func, func_next, &clear_hash, list) {
6678                 clear_func_from_hashes(func);
6679                 kfree(func);
6680         }
6681 }
6682
6683 void __init ftrace_free_init_mem(void)
6684 {
6685         void *start = (void *)(&__init_begin);
6686         void *end = (void *)(&__init_end);
6687
6688         ftrace_free_mem(NULL, start, end);
6689 }
6690
6691 void __init ftrace_init(void)
6692 {
6693         extern unsigned long __start_mcount_loc[];
6694         extern unsigned long __stop_mcount_loc[];
6695         unsigned long count, flags;
6696         int ret;
6697
6698         local_irq_save(flags);
6699         ret = ftrace_dyn_arch_init();
6700         local_irq_restore(flags);
6701         if (ret)
6702                 goto failed;
6703
6704         count = __stop_mcount_loc - __start_mcount_loc;
6705         if (!count) {
6706                 pr_info("ftrace: No functions to be traced?\n");
6707                 goto failed;
6708         }
6709
6710         pr_info("ftrace: allocating %ld entries in %ld pages\n",
6711                 count, count / ENTRIES_PER_PAGE + 1);
6712
6713         last_ftrace_enabled = ftrace_enabled = 1;
6714
6715         ret = ftrace_process_locs(NULL,
6716                                   __start_mcount_loc,
6717                                   __stop_mcount_loc);
6718
6719         pr_info("ftrace: allocated %ld pages with %ld groups\n",
6720                 ftrace_number_of_pages, ftrace_number_of_groups);
6721
6722         set_ftrace_early_filters();
6723
6724         return;
6725  failed:
6726         ftrace_disabled = 1;
6727 }
6728
6729 /* Do nothing if arch does not support this */
6730 void __weak arch_ftrace_update_trampoline(struct ftrace_ops *ops)
6731 {
6732 }
6733
6734 static void ftrace_update_trampoline(struct ftrace_ops *ops)
6735 {
6736         arch_ftrace_update_trampoline(ops);
6737 }
6738
6739 void ftrace_init_trace_array(struct trace_array *tr)
6740 {
6741         INIT_LIST_HEAD(&tr->func_probes);
6742         INIT_LIST_HEAD(&tr->mod_trace);
6743         INIT_LIST_HEAD(&tr->mod_notrace);
6744 }
6745 #else
6746
6747 struct ftrace_ops global_ops = {
6748         .func                   = ftrace_stub,
6749         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE |
6750                                   FTRACE_OPS_FL_INITIALIZED |
6751                                   FTRACE_OPS_FL_PID,
6752 };
6753
6754 static int __init ftrace_nodyn_init(void)
6755 {
6756         ftrace_enabled = 1;
6757         return 0;
6758 }
6759 core_initcall(ftrace_nodyn_init);
6760
6761 static inline int ftrace_init_dyn_tracefs(struct dentry *d_tracer) { return 0; }
6762 static inline void ftrace_startup_enable(int command) { }
6763 static inline void ftrace_startup_all(int command) { }
6764
6765 # define ftrace_startup_sysctl()        do { } while (0)
6766 # define ftrace_shutdown_sysctl()       do { } while (0)
6767
6768 static void ftrace_update_trampoline(struct ftrace_ops *ops)
6769 {
6770 }
6771
6772 #endif /* CONFIG_DYNAMIC_FTRACE */
6773
6774 __init void ftrace_init_global_array_ops(struct trace_array *tr)
6775 {
6776         tr->ops = &global_ops;
6777         tr->ops->private = tr;
6778         ftrace_init_trace_array(tr);
6779 }
6780
6781 void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func)
6782 {
6783         /* If we filter on pids, update to use the pid function */
6784         if (tr->flags & TRACE_ARRAY_FL_GLOBAL) {
6785                 if (WARN_ON(tr->ops->func != ftrace_stub))
6786                         printk("ftrace ops had %pS for function\n",
6787                                tr->ops->func);
6788         }
6789         tr->ops->func = func;
6790         tr->ops->private = tr;
6791 }
6792
6793 void ftrace_reset_array_ops(struct trace_array *tr)
6794 {
6795         tr->ops->func = ftrace_stub;
6796 }
6797
6798 static nokprobe_inline void
6799 __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
6800                        struct ftrace_ops *ignored, struct pt_regs *regs)
6801 {
6802         struct ftrace_ops *op;
6803         int bit;
6804
6805         bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
6806         if (bit < 0)
6807                 return;
6808
6809         /*
6810          * Some of the ops may be dynamically allocated,
6811          * they must be freed after a synchronize_rcu().
6812          */
6813         preempt_disable_notrace();
6814
6815         do_for_each_ftrace_op(op, ftrace_ops_list) {
6816                 /* Stub functions don't need to be called nor tested */
6817                 if (op->flags & FTRACE_OPS_FL_STUB)
6818                         continue;
6819                 /*
6820                  * Check the following for each ops before calling their func:
6821                  *  if RCU flag is set, then rcu_is_watching() must be true
6822                  *  if PER_CPU is set, then ftrace_function_local_disable()
6823                  *                          must be false
6824                  *  Otherwise test if the ip matches the ops filter
6825                  *
6826                  * If any of the above fails then the op->func() is not executed.
6827                  */
6828                 if ((!(op->flags & FTRACE_OPS_FL_RCU) || rcu_is_watching()) &&
6829                     ftrace_ops_test(op, ip, regs)) {
6830                         if (FTRACE_WARN_ON(!op->func)) {
6831                                 pr_warn("op=%p %pS\n", op, op);
6832                                 goto out;
6833                         }
6834                         op->func(ip, parent_ip, op, regs);
6835                 }
6836         } while_for_each_ftrace_op(op);
6837 out:
6838         preempt_enable_notrace();
6839         trace_clear_recursion(bit);
6840 }
6841
6842 /*
6843  * Some archs only support passing ip and parent_ip. Even though
6844  * the list function ignores the op parameter, we do not want any
6845  * C side effects, where a function is called without the caller
6846  * sending a third parameter.
6847  * Archs are to support both the regs and ftrace_ops at the same time.
6848  * If they support ftrace_ops, it is assumed they support regs.
6849  * If call backs want to use regs, they must either check for regs
6850  * being NULL, or CONFIG_DYNAMIC_FTRACE_WITH_REGS.
6851  * Note, CONFIG_DYNAMIC_FTRACE_WITH_REGS expects a full regs to be saved.
6852  * An architecture can pass partial regs with ftrace_ops and still
6853  * set the ARCH_SUPPORTS_FTRACE_OPS.
6854  */
6855 #if ARCH_SUPPORTS_FTRACE_OPS
6856 static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
6857                                  struct ftrace_ops *op, struct pt_regs *regs)
6858 {
6859         __ftrace_ops_list_func(ip, parent_ip, NULL, regs);
6860 }
6861 NOKPROBE_SYMBOL(ftrace_ops_list_func);
6862 #else
6863 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
6864 {
6865         __ftrace_ops_list_func(ip, parent_ip, NULL, NULL);
6866 }
6867 NOKPROBE_SYMBOL(ftrace_ops_no_ops);
6868 #endif
6869
6870 /*
6871  * If there's only one function registered but it does not support
6872  * recursion, needs RCU protection and/or requires per cpu handling, then
6873  * this function will be called by the mcount trampoline.
6874  */
6875 static void ftrace_ops_assist_func(unsigned long ip, unsigned long parent_ip,
6876                                    struct ftrace_ops *op, struct pt_regs *regs)
6877 {
6878         int bit;
6879
6880         if ((op->flags & FTRACE_OPS_FL_RCU) && !rcu_is_watching())
6881                 return;
6882
6883         bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
6884         if (bit < 0)
6885                 return;
6886
6887         preempt_disable_notrace();
6888
6889         op->func(ip, parent_ip, op, regs);
6890
6891         preempt_enable_notrace();
6892         trace_clear_recursion(bit);
6893 }
6894 NOKPROBE_SYMBOL(ftrace_ops_assist_func);
6895
6896 /**
6897  * ftrace_ops_get_func - get the function a trampoline should call
6898  * @ops: the ops to get the function for
6899  *
6900  * Normally the mcount trampoline will call the ops->func, but there
6901  * are times that it should not. For example, if the ops does not
6902  * have its own recursion protection, then it should call the
6903  * ftrace_ops_assist_func() instead.
6904  *
6905  * Returns the function that the trampoline should call for @ops.
6906  */
6907 ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops)
6908 {
6909         /*
6910          * If the function does not handle recursion, needs to be RCU safe,
6911          * or does per cpu logic, then we need to call the assist handler.
6912          */
6913         if (!(ops->flags & FTRACE_OPS_FL_RECURSION_SAFE) ||
6914             ops->flags & FTRACE_OPS_FL_RCU)
6915                 return ftrace_ops_assist_func;
6916
6917         return ops->func;
6918 }
6919
6920 static void
6921 ftrace_filter_pid_sched_switch_probe(void *data, bool preempt,
6922                     struct task_struct *prev, struct task_struct *next)
6923 {
6924         struct trace_array *tr = data;
6925         struct trace_pid_list *pid_list;
6926
6927         pid_list = rcu_dereference_sched(tr->function_pids);
6928
6929         this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid,
6930                        trace_ignore_this_task(pid_list, next));
6931 }
6932
6933 static void
6934 ftrace_pid_follow_sched_process_fork(void *data,
6935                                      struct task_struct *self,
6936                                      struct task_struct *task)
6937 {
6938         struct trace_pid_list *pid_list;
6939         struct trace_array *tr = data;
6940
6941         pid_list = rcu_dereference_sched(tr->function_pids);
6942         trace_filter_add_remove_task(pid_list, self, task);
6943 }
6944
6945 static void
6946 ftrace_pid_follow_sched_process_exit(void *data, struct task_struct *task)
6947 {
6948         struct trace_pid_list *pid_list;
6949         struct trace_array *tr = data;
6950
6951         pid_list = rcu_dereference_sched(tr->function_pids);
6952         trace_filter_add_remove_task(pid_list, NULL, task);
6953 }
6954
6955 void ftrace_pid_follow_fork(struct trace_array *tr, bool enable)
6956 {
6957         if (enable) {
6958                 register_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork,
6959                                                   tr);
6960                 register_trace_sched_process_exit(ftrace_pid_follow_sched_process_exit,
6961                                                   tr);
6962         } else {
6963                 unregister_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork,
6964                                                     tr);
6965                 unregister_trace_sched_process_exit(ftrace_pid_follow_sched_process_exit,
6966                                                     tr);
6967         }
6968 }
6969
6970 static void clear_ftrace_pids(struct trace_array *tr)
6971 {
6972         struct trace_pid_list *pid_list;
6973         int cpu;
6974
6975         pid_list = rcu_dereference_protected(tr->function_pids,
6976                                              lockdep_is_held(&ftrace_lock));
6977         if (!pid_list)
6978                 return;
6979
6980         unregister_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr);
6981
6982         for_each_possible_cpu(cpu)
6983                 per_cpu_ptr(tr->array_buffer.data, cpu)->ftrace_ignore_pid = false;
6984
6985         rcu_assign_pointer(tr->function_pids, NULL);
6986
6987         /* Wait till all users are no longer using pid filtering */
6988         synchronize_rcu();
6989
6990         trace_free_pid_list(pid_list);
6991 }
6992
6993 void ftrace_clear_pids(struct trace_array *tr)
6994 {
6995         mutex_lock(&ftrace_lock);
6996
6997         clear_ftrace_pids(tr);
6998
6999         mutex_unlock(&ftrace_lock);
7000 }
7001
7002 static void ftrace_pid_reset(struct trace_array *tr)
7003 {
7004         mutex_lock(&ftrace_lock);
7005         clear_ftrace_pids(tr);
7006
7007         ftrace_update_pid_func();
7008         ftrace_startup_all(0);
7009
7010         mutex_unlock(&ftrace_lock);
7011 }
7012
7013 /* Greater than any max PID */
7014 #define FTRACE_NO_PIDS          (void *)(PID_MAX_LIMIT + 1)
7015
7016 static void *fpid_start(struct seq_file *m, loff_t *pos)
7017         __acquires(RCU)
7018 {
7019         struct trace_pid_list *pid_list;
7020         struct trace_array *tr = m->private;
7021
7022         mutex_lock(&ftrace_lock);
7023         rcu_read_lock_sched();
7024
7025         pid_list = rcu_dereference_sched(tr->function_pids);
7026
7027         if (!pid_list)
7028                 return !(*pos) ? FTRACE_NO_PIDS : NULL;
7029
7030         return trace_pid_start(pid_list, pos);
7031 }
7032
7033 static void *fpid_next(struct seq_file *m, void *v, loff_t *pos)
7034 {
7035         struct trace_array *tr = m->private;
7036         struct trace_pid_list *pid_list = rcu_dereference_sched(tr->function_pids);
7037
7038         if (v == FTRACE_NO_PIDS) {
7039                 (*pos)++;
7040                 return NULL;
7041         }
7042         return trace_pid_next(pid_list, v, pos);
7043 }
7044
7045 static void fpid_stop(struct seq_file *m, void *p)
7046         __releases(RCU)
7047 {
7048         rcu_read_unlock_sched();
7049         mutex_unlock(&ftrace_lock);
7050 }
7051
7052 static int fpid_show(struct seq_file *m, void *v)
7053 {
7054         if (v == FTRACE_NO_PIDS) {
7055                 seq_puts(m, "no pid\n");
7056                 return 0;
7057         }
7058
7059         return trace_pid_show(m, v);
7060 }
7061
7062 static const struct seq_operations ftrace_pid_sops = {
7063         .start = fpid_start,
7064         .next = fpid_next,
7065         .stop = fpid_stop,
7066         .show = fpid_show,
7067 };
7068
7069 static int
7070 ftrace_pid_open(struct inode *inode, struct file *file)
7071 {
7072         struct trace_array *tr = inode->i_private;
7073         struct seq_file *m;
7074         int ret = 0;
7075
7076         ret = tracing_check_open_get_tr(tr);
7077         if (ret)
7078                 return ret;
7079
7080         if ((file->f_mode & FMODE_WRITE) &&
7081             (file->f_flags & O_TRUNC))
7082                 ftrace_pid_reset(tr);
7083
7084         ret = seq_open(file, &ftrace_pid_sops);
7085         if (ret < 0) {
7086                 trace_array_put(tr);
7087         } else {
7088                 m = file->private_data;
7089                 /* copy tr over to seq ops */
7090                 m->private = tr;
7091         }
7092
7093         return ret;
7094 }
7095
7096 static void ignore_task_cpu(void *data)
7097 {
7098         struct trace_array *tr = data;
7099         struct trace_pid_list *pid_list;
7100
7101         /*
7102          * This function is called by on_each_cpu() while the
7103          * event_mutex is held.
7104          */
7105         pid_list = rcu_dereference_protected(tr->function_pids,
7106                                              mutex_is_locked(&ftrace_lock));
7107
7108         this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid,
7109                        trace_ignore_this_task(pid_list, current));
7110 }
7111
7112 static ssize_t
7113 ftrace_pid_write(struct file *filp, const char __user *ubuf,
7114                    size_t cnt, loff_t *ppos)
7115 {
7116         struct seq_file *m = filp->private_data;
7117         struct trace_array *tr = m->private;
7118         struct trace_pid_list *filtered_pids = NULL;
7119         struct trace_pid_list *pid_list;
7120         ssize_t ret;
7121
7122         if (!cnt)
7123                 return 0;
7124
7125         mutex_lock(&ftrace_lock);
7126
7127         filtered_pids = rcu_dereference_protected(tr->function_pids,
7128                                              lockdep_is_held(&ftrace_lock));
7129
7130         ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);
7131         if (ret < 0)
7132                 goto out;
7133
7134         rcu_assign_pointer(tr->function_pids, pid_list);
7135
7136         if (filtered_pids) {
7137                 synchronize_rcu();
7138                 trace_free_pid_list(filtered_pids);
7139         } else if (pid_list) {
7140                 /* Register a probe to set whether to ignore the tracing of a task */
7141                 register_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr);
7142         }
7143
7144         /*
7145          * Ignoring of pids is done at task switch. But we have to
7146          * check for those tasks that are currently running.
7147          * Always do this in case a pid was appended or removed.
7148          */
7149         on_each_cpu(ignore_task_cpu, tr, 1);
7150
7151         ftrace_update_pid_func();
7152         ftrace_startup_all(0);
7153  out:
7154         mutex_unlock(&ftrace_lock);
7155
7156         if (ret > 0)
7157                 *ppos += ret;
7158
7159         return ret;
7160 }
7161
7162 static int
7163 ftrace_pid_release(struct inode *inode, struct file *file)
7164 {
7165         struct trace_array *tr = inode->i_private;
7166
7167         trace_array_put(tr);
7168
7169         return seq_release(inode, file);
7170 }
7171
7172 static const struct file_operations ftrace_pid_fops = {
7173         .open           = ftrace_pid_open,
7174         .write          = ftrace_pid_write,
7175         .read           = seq_read,
7176         .llseek         = tracing_lseek,
7177         .release        = ftrace_pid_release,
7178 };
7179
7180 void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer)
7181 {
7182         trace_create_file("set_ftrace_pid", 0644, d_tracer,
7183                             tr, &ftrace_pid_fops);
7184 }
7185
7186 void __init ftrace_init_tracefs_toplevel(struct trace_array *tr,
7187                                          struct dentry *d_tracer)
7188 {
7189         /* Only the top level directory has the dyn_tracefs and profile */
7190         WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
7191
7192         ftrace_init_dyn_tracefs(d_tracer);
7193         ftrace_profile_tracefs(d_tracer);
7194 }
7195
7196 /**
7197  * ftrace_kill - kill ftrace
7198  *
7199  * This function should be used by panic code. It stops ftrace
7200  * but in a not so nice way. If you need to simply kill ftrace
7201  * from a non-atomic section, use ftrace_kill.
7202  */
7203 void ftrace_kill(void)
7204 {
7205         ftrace_disabled = 1;
7206         ftrace_enabled = 0;
7207         ftrace_trace_function = ftrace_stub;
7208 }
7209
7210 /**
7211  * Test if ftrace is dead or not.
7212  */
7213 int ftrace_is_dead(void)
7214 {
7215         return ftrace_disabled;
7216 }
7217
7218 /**
7219  * register_ftrace_function - register a function for profiling
7220  * @ops - ops structure that holds the function for profiling.
7221  *
7222  * Register a function to be called by all functions in the
7223  * kernel.
7224  *
7225  * Note: @ops->func and all the functions it calls must be labeled
7226  *       with "notrace", otherwise it will go into a
7227  *       recursive loop.
7228  */
7229 int register_ftrace_function(struct ftrace_ops *ops)
7230 {
7231         int ret = -1;
7232
7233         ftrace_ops_init(ops);
7234
7235         mutex_lock(&ftrace_lock);
7236
7237         ret = ftrace_startup(ops, 0);
7238
7239         mutex_unlock(&ftrace_lock);
7240
7241         return ret;
7242 }
7243 EXPORT_SYMBOL_GPL(register_ftrace_function);
7244
7245 /**
7246  * unregister_ftrace_function - unregister a function for profiling.
7247  * @ops - ops structure that holds the function to unregister
7248  *
7249  * Unregister a function that was added to be called by ftrace profiling.
7250  */
7251 int unregister_ftrace_function(struct ftrace_ops *ops)
7252 {
7253         int ret;
7254
7255         mutex_lock(&ftrace_lock);
7256         ret = ftrace_shutdown(ops, 0);
7257         mutex_unlock(&ftrace_lock);
7258
7259         return ret;
7260 }
7261 EXPORT_SYMBOL_GPL(unregister_ftrace_function);
7262
7263 static bool is_permanent_ops_registered(void)
7264 {
7265         struct ftrace_ops *op;
7266
7267         do_for_each_ftrace_op(op, ftrace_ops_list) {
7268                 if (op->flags & FTRACE_OPS_FL_PERMANENT)
7269                         return true;
7270         } while_for_each_ftrace_op(op);
7271
7272         return false;
7273 }
7274
7275 int
7276 ftrace_enable_sysctl(struct ctl_table *table, int write,
7277                      void __user *buffer, size_t *lenp,
7278                      loff_t *ppos)
7279 {
7280         int ret = -ENODEV;
7281
7282         mutex_lock(&ftrace_lock);
7283
7284         if (unlikely(ftrace_disabled))
7285                 goto out;
7286
7287         ret = proc_dointvec(table, write, buffer, lenp, ppos);
7288
7289         if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled))
7290                 goto out;
7291
7292         if (ftrace_enabled) {
7293
7294                 /* we are starting ftrace again */
7295                 if (rcu_dereference_protected(ftrace_ops_list,
7296                         lockdep_is_held(&ftrace_lock)) != &ftrace_list_end)
7297                         update_ftrace_function();
7298
7299                 ftrace_startup_sysctl();
7300
7301         } else {
7302                 if (is_permanent_ops_registered()) {
7303                         ftrace_enabled = true;
7304                         ret = -EBUSY;
7305                         goto out;
7306                 }
7307
7308                 /* stopping ftrace calls (just send to ftrace_stub) */
7309                 ftrace_trace_function = ftrace_stub;
7310
7311                 ftrace_shutdown_sysctl();
7312         }
7313
7314         last_ftrace_enabled = !!ftrace_enabled;
7315  out:
7316         mutex_unlock(&ftrace_lock);
7317         return ret;
7318 }