kernel/trace/ftrace.c

   1 /*
   2  * Infrastructure for profiling code inserted by 'gcc -pg'.
   3  *
   4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
   5  * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
   6  *
   7  * Originally ported from the -rt patch by:
   8  *   Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
   9  *
  10  * Based on code in the latency_tracer, that is:
  11  *
  12  *  Copyright (C) 2004-2006 Ingo Molnar
  13  *  Copyright (C) 2004 William Lee Irwin III
  14  */
  15
  16 #include <linux/stop_machine.h>
  17 #include <linux/clocksource.h>
  18 #include <linux/kallsyms.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/hardirq.h>
  22 #include <linux/kthread.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/ftrace.h>
  25 #include <linux/sysctl.h>
  26 #include <linux/ctype.h>
  27 #include <linux/hash.h>
  28 #include <linux/list.h>
  29
  30 #include "trace.h"
  31
  32 /* ftrace_enabled is a method to turn ftrace on or off */
  33 int ftrace_enabled __read_mostly;
  34 static int last_ftrace_enabled;
  35
  36 /*
  37  * ftrace_disabled is set when an anomaly is discovered.
  38  * ftrace_disabled is much stronger than ftrace_enabled.
  39  */
  40 static int ftrace_disabled __read_mostly;
  41
  42 static DEFINE_SPINLOCK(ftrace_lock);
  43 static DEFINE_MUTEX(ftrace_sysctl_lock);
  44
  45 static struct ftrace_ops ftrace_list_end __read_mostly =
  46 {
  47         .func = ftrace_stub,
  48 };
  49
  50 static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
  51 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
  52
  53 void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
  54 {
  55         struct ftrace_ops *op = ftrace_list;
  56
  57         /* in case someone actually ports this to alpha! */
  58         read_barrier_depends();
  59
  60         while (op != &ftrace_list_end) {
  61                 /* silly alpha */
  62                 read_barrier_depends();
  63                 op->func(ip, parent_ip);
  64                 op = op->next;
  65         };
  66 }
  67
  68 /**
  69  * clear_ftrace_function - reset the ftrace function
  70  *
  71  * This NULLs the ftrace function and in essence stops
  72  * tracing.  There may be lag
  73  */
  74 void clear_ftrace_function(void)
  75 {
  76         ftrace_trace_function = ftrace_stub;
  77 }
  78
  79 static int __register_ftrace_function(struct ftrace_ops *ops)
  80 {
  81         /* Should never be called by interrupts */
  82         spin_lock(&ftrace_lock);
  83
  84         ops->next = ftrace_list;
  85         /*
  86          * We are entering ops into the ftrace_list but another
  87          * CPU might be walking that list. We need to make sure
  88          * the ops->next pointer is valid before another CPU sees
  89          * the ops pointer included into the ftrace_list.
  90          */
  91         smp_wmb();
  92         ftrace_list = ops;
  93
  94         if (ftrace_enabled) {
  95                 /*
  96                  * For one func, simply call it directly.
  97                  * For more than one func, call the chain.
  98                  */
  99                 if (ops->next == &ftrace_list_end)
 100                         ftrace_trace_function = ops->func;
 101                 else
 102                         ftrace_trace_function = ftrace_list_func;
 103         }
 104
 105         spin_unlock(&ftrace_lock);
 106
 107         return 0;
 108 }
 109
 110 static int __unregister_ftrace_function(struct ftrace_ops *ops)
 111 {
 112         struct ftrace_ops **p;
 113         int ret = 0;
 114
 115         spin_lock(&ftrace_lock);
 116
 117         /*
 118          * If we are removing the last function, then simply point
 119          * to the ftrace_stub.
 120          */
 121         if (ftrace_list == ops && ops->next == &ftrace_list_end) {
 122                 ftrace_trace_function = ftrace_stub;
 123                 ftrace_list = &ftrace_list_end;
 124                 goto out;
 125         }
 126
 127         for (p = &ftrace_list; *p != &ftrace_list_end; p = &(*p)->next)
 128                 if (*p == ops)
 129                         break;
 130
 131         if (*p != ops) {
 132                 ret = -1;
 133                 goto out;
 134         }
 135
 136         *p = (*p)->next;
 137
 138         if (ftrace_enabled) {
 139                 /* If we only have one func left, then call that directly */
 140                 if (ftrace_list == &ftrace_list_end ||
 141                     ftrace_list->next == &ftrace_list_end)
 142                         ftrace_trace_function = ftrace_list->func;
 143         }
 144
 145  out:
 146         spin_unlock(&ftrace_lock);
 147
 148         return ret;
 149 }
 150
 151 #ifdef CONFIG_DYNAMIC_FTRACE
 152
 153 static struct task_struct *ftraced_task;
 154
 155 enum {
 156         FTRACE_ENABLE_CALLS             = (1 << 0),
 157         FTRACE_DISABLE_CALLS            = (1 << 1),
 158         FTRACE_UPDATE_TRACE_FUNC        = (1 << 2),
 159         FTRACE_ENABLE_MCOUNT            = (1 << 3),
 160         FTRACE_DISABLE_MCOUNT           = (1 << 4),
 161 };
 162
 163 static int ftrace_filtered;
 164
 165 static struct hlist_head ftrace_hash[FTRACE_HASHSIZE];
 166
 167 static DEFINE_PER_CPU(int, ftrace_shutdown_disable_cpu);
 168
 169 static DEFINE_SPINLOCK(ftrace_shutdown_lock);
 170 static DEFINE_MUTEX(ftraced_lock);
 171 static DEFINE_MUTEX(ftrace_regex_lock);
 172
 173 struct ftrace_page {
 174         struct ftrace_page      *next;
 175         unsigned long           index;
 176         struct dyn_ftrace       records[];
 177 };
 178
 179 #define ENTRIES_PER_PAGE \
 180   ((PAGE_SIZE - sizeof(struct ftrace_page)) / sizeof(struct dyn_ftrace))
 181
 182 /* estimate from running different kernels */
 183 #define NR_TO_INIT              10000
 184
 185 static struct ftrace_page       *ftrace_pages_start;
 186 static struct ftrace_page       *ftrace_pages;
 187
 188 static int ftraced_trigger;
 189 static int ftraced_suspend;
 190 static int ftraced_stop;
 191
 192 static int ftrace_record_suspend;
 193
 194 static struct dyn_ftrace *ftrace_free_records;
 195
 196 static inline int
 197 ftrace_ip_in_hash(unsigned long ip, unsigned long key)
 198 {
 199         struct dyn_ftrace *p;
 200         struct hlist_node *t;
 201         int found = 0;
 202
 203         hlist_for_each_entry_rcu(p, t, &ftrace_hash[key], node) {
 204                 if (p->ip == ip) {
 205                         found = 1;
 206                         break;
 207                 }
 208         }
 209
 210         return found;
 211 }
 212
 213 static inline void
 214 ftrace_add_hash(struct dyn_ftrace *node, unsigned long key)
 215 {
 216         hlist_add_head_rcu(&node->node, &ftrace_hash[key]);
 217 }
 218
 219 /* called from kstop_machine */
 220 static inline void ftrace_del_hash(struct dyn_ftrace *node)
 221 {
 222         hlist_del(&node->node);
 223 }
 224
 225 static void ftrace_free_rec(struct dyn_ftrace *rec)
 226 {
 227         /* no locking, only called from kstop_machine */
 228
 229         rec->ip = (unsigned long)ftrace_free_records;
 230         ftrace_free_records = rec;
 231         rec->flags |= FTRACE_FL_FREE;
 232 }
 233
 234 static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
 235 {
 236         struct dyn_ftrace *rec;
 237
 238         /* First check for freed records */
 239         if (ftrace_free_records) {
 240                 rec = ftrace_free_records;
 241
 242                 if (unlikely(!(rec->flags & FTRACE_FL_FREE))) {
 243                         WARN_ON_ONCE(1);
 244                         ftrace_free_records = NULL;
 245                         ftrace_disabled = 1;
 246                         ftrace_enabled = 0;
 247                         return NULL;
 248                 }
 249
 250                 ftrace_free_records = (void *)rec->ip;
 251                 memset(rec, 0, sizeof(*rec));
 252                 return rec;
 253         }
 254
 255         if (ftrace_pages->index == ENTRIES_PER_PAGE) {
 256                 if (!ftrace_pages->next)
 257                         return NULL;
 258                 ftrace_pages = ftrace_pages->next;
 259         }
 260
 261         return &ftrace_pages->records[ftrace_pages->index++];
 262 }
 263
 264 static void
 265 ftrace_record_ip(unsigned long ip)
 266 {
 267         struct dyn_ftrace *node;
 268         unsigned long flags;
 269         unsigned long key;
 270         int resched;
 271         int atomic;
 272         int cpu;
 273
 274         if (!ftrace_enabled || ftrace_disabled)
 275                 return;
 276
 277         resched = need_resched();
 278         preempt_disable_notrace();
 279
 280         /*
 281          * We simply need to protect against recursion.
 282          * Use the the raw version of smp_processor_id and not
 283          * __get_cpu_var which can call debug hooks that can
 284          * cause a recursive crash here.
 285          */
 286         cpu = raw_smp_processor_id();
 287         per_cpu(ftrace_shutdown_disable_cpu, cpu)++;
 288         if (per_cpu(ftrace_shutdown_disable_cpu, cpu) != 1)
 289                 goto out;
 290
 291         if (unlikely(ftrace_record_suspend))
 292                 goto out;
 293
 294         key = hash_long(ip, FTRACE_HASHBITS);
 295
 296         WARN_ON_ONCE(key >= FTRACE_HASHSIZE);
 297
 298         if (ftrace_ip_in_hash(ip, key))
 299                 goto out;
 300
 301         atomic = irqs_disabled();
 302
 303         spin_lock_irqsave(&ftrace_shutdown_lock, flags);
 304
 305         /* This ip may have hit the hash before the lock */
 306         if (ftrace_ip_in_hash(ip, key))
 307                 goto out_unlock;
 308
 309         node = ftrace_alloc_dyn_node(ip);
 310         if (!node)
 311                 goto out_unlock;
 312
 313         node->ip = ip;
 314
 315         ftrace_add_hash(node, key);
 316
 317         ftraced_trigger = 1;
 318
 319  out_unlock:
 320         spin_unlock_irqrestore(&ftrace_shutdown_lock, flags);
 321  out:
 322         per_cpu(ftrace_shutdown_disable_cpu, cpu)--;
 323
 324         /* prevent recursion with scheduler */
 325         if (resched)
 326                 preempt_enable_no_resched_notrace();
 327         else
 328                 preempt_enable_notrace();
 329 }
 330
 331 #define FTRACE_ADDR ((long)(ftrace_caller))
 332 #define MCOUNT_ADDR ((long)(mcount))
 333
 334 static int
 335 __ftrace_replace_code(struct dyn_ftrace *rec,
 336                       unsigned char *old, unsigned char *new, int enable)
 337 {
 338         unsigned long ip, fl;
 339
 340         ip = rec->ip;
 341
 342         if (ftrace_filtered && enable) {
 343                 /*
 344                  * If filtering is on:
 345                  *
 346                  * If this record is set to be filtered and
 347                  * is enabled then do nothing.
 348                  *
 349                  * If this record is set to be filtered and
 350                  * it is not enabled, enable it.
 351                  *
 352                  * If this record is not set to be filtered
 353                  * and it is not enabled do nothing.
 354                  *
 355                  * If this record is set not to trace then
 356                  * do nothing.
 357                  *
 358                  * If this record is not set to be filtered and
 359                  * it is enabled, disable it.
 360                  */
 361                 fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
 362
 363                 if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
 364                     (fl == 0) || (rec->flags & FTRACE_FL_NOTRACE))
 365                         return 0;
 366
 367                 /*
 368                  * If it is enabled disable it,
 369                  * otherwise enable it!
 370                  */
 371                 if (fl == FTRACE_FL_ENABLED) {
 372                         /* swap new and old */
 373                         new = old;
 374                         old = ftrace_call_replace(ip, FTRACE_ADDR);
 375                         rec->flags &= ~FTRACE_FL_ENABLED;
 376                 } else {
 377                         new = ftrace_call_replace(ip, FTRACE_ADDR);
 378                         rec->flags |= FTRACE_FL_ENABLED;
 379                 }
 380         } else {
 381
 382                 if (enable) {
 383                         /*
 384                          * If this record is set not to trace and is
 385                          * not enabled, do nothing.
 386                          */
 387                         fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
 388                         if (fl == FTRACE_FL_NOTRACE)
 389                                 return 0;
 390
 391                         new = ftrace_call_replace(ip, FTRACE_ADDR);
 392                 } else
 393                         old = ftrace_call_replace(ip, FTRACE_ADDR);
 394
 395                 if (enable) {
 396                         if (rec->flags & FTRACE_FL_ENABLED)
 397                                 return 0;
 398                         rec->flags |= FTRACE_FL_ENABLED;
 399                 } else {
 400                         if (!(rec->flags & FTRACE_FL_ENABLED))
 401                                 return 0;
 402                         rec->flags &= ~FTRACE_FL_ENABLED;
 403                 }
 404         }
 405
 406         return ftrace_modify_code(ip, old, new);
 407 }
 408
 409 static void ftrace_replace_code(int enable)
 410 {
 411         int i, failed;
 412         unsigned char *new = NULL, *old = NULL;
 413         struct dyn_ftrace *rec;
 414         struct ftrace_page *pg;
 415
 416         if (enable)
 417                 old = ftrace_nop_replace();
 418         else
 419                 new = ftrace_nop_replace();
 420
 421         for (pg = ftrace_pages_start; pg; pg = pg->next) {
 422                 for (i = 0; i < pg->index; i++) {
 423                         rec = &pg->records[i];
 424
 425                         /* don't modify code that has already faulted */
 426                         if (rec->flags & FTRACE_FL_FAILED)
 427                                 continue;
 428
 429                         failed = __ftrace_replace_code(rec, old, new, enable);
 430                         if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
 431                                 rec->flags |= FTRACE_FL_FAILED;
 432                                 if ((system_state == SYSTEM_BOOTING) ||
 433                                     !kernel_text_address(rec->ip)) {
 434                                         ftrace_del_hash(rec);
 435                                         ftrace_free_rec(rec);
 436                                 }
 437                         }
 438                 }
 439         }
 440 }
 441
 442 static void ftrace_shutdown_replenish(void)
 443 {
 444         if (ftrace_pages->next)
 445                 return;
 446
 447         /* allocate another page */
 448         ftrace_pages->next = (void *)get_zeroed_page(GFP_KERNEL);
 449 }
 450
 451 static int
 452 ftrace_code_disable(struct dyn_ftrace *rec)
 453 {
 454         unsigned long ip;
 455         unsigned char *nop, *call;
 456         int failed;
 457
 458         ip = rec->ip;
 459
 460         nop = ftrace_nop_replace();
 461         call = ftrace_call_replace(ip, MCOUNT_ADDR);
 462
 463         failed = ftrace_modify_code(ip, call, nop);
 464         if (failed) {
 465                 rec->flags |= FTRACE_FL_FAILED;
 466                 return 0;
 467         }
 468         return 1;
 469 }
 470
 471 static int __ftrace_update_code(void *ignore);
 472
 473 static int __ftrace_modify_code(void *data)
 474 {
 475         unsigned long addr;
 476         int *command = data;
 477
 478         if (*command & FTRACE_ENABLE_CALLS) {
 479                 /*
 480                  * Update any recorded ips now that we have the
 481                  * machine stopped
 482                  */
 483                 __ftrace_update_code(NULL);
 484                 ftrace_replace_code(1);
 485         } else if (*command & FTRACE_DISABLE_CALLS)
 486                 ftrace_replace_code(0);
 487
 488         if (*command & FTRACE_UPDATE_TRACE_FUNC)
 489                 ftrace_update_ftrace_func(ftrace_trace_function);
 490
 491         if (*command & FTRACE_ENABLE_MCOUNT) {
 492                 addr = (unsigned long)ftrace_record_ip;
 493                 ftrace_mcount_set(&addr);
 494         } else if (*command & FTRACE_DISABLE_MCOUNT) {
 495                 addr = (unsigned long)ftrace_stub;
 496                 ftrace_mcount_set(&addr);
 497         }
 498
 499         return 0;
 500 }
 501
 502 static void ftrace_run_update_code(int command)
 503 {
 504         stop_machine_run(__ftrace_modify_code, &command, NR_CPUS);
 505 }
 506
 507 void ftrace_disable_daemon(void)
 508 {
 509         /* Stop the daemon from calling kstop_machine */
 510         mutex_lock(&ftraced_lock);
 511         ftraced_stop = 1;
 512         mutex_unlock(&ftraced_lock);
 513
 514         ftrace_force_update();
 515 }
 516
 517 void ftrace_enable_daemon(void)
 518 {
 519         mutex_lock(&ftraced_lock);
 520         ftraced_stop = 0;
 521         mutex_unlock(&ftraced_lock);
 522
 523         ftrace_force_update();
 524 }
 525
 526 static ftrace_func_t saved_ftrace_func;
 527
 528 static void ftrace_startup(void)
 529 {
 530         int command = 0;
 531
 532         if (unlikely(ftrace_disabled))
 533                 return;
 534
 535         mutex_lock(&ftraced_lock);
 536         ftraced_suspend++;
 537         if (ftraced_suspend == 1)
 538                 command |= FTRACE_ENABLE_CALLS;
 539
 540         if (saved_ftrace_func != ftrace_trace_function) {
 541                 saved_ftrace_func = ftrace_trace_function;
 542                 command |= FTRACE_UPDATE_TRACE_FUNC;
 543         }
 544
 545         if (!command || !ftrace_enabled)
 546                 goto out;
 547
 548         ftrace_run_update_code(command);
 549  out:
 550         mutex_unlock(&ftraced_lock);
 551 }
 552
 553 static void ftrace_shutdown(void)
 554 {
 555         int command = 0;
 556
 557         if (unlikely(ftrace_disabled))
 558                 return;
 559
 560         mutex_lock(&ftraced_lock);
 561         ftraced_suspend--;
 562         if (!ftraced_suspend)
 563                 command |= FTRACE_DISABLE_CALLS;
 564
 565         if (saved_ftrace_func != ftrace_trace_function) {
 566                 saved_ftrace_func = ftrace_trace_function;
 567                 command |= FTRACE_UPDATE_TRACE_FUNC;
 568         }
 569
 570         if (!command || !ftrace_enabled)
 571                 goto out;
 572
 573         ftrace_run_update_code(command);
 574  out:
 575         mutex_unlock(&ftraced_lock);
 576 }
 577
 578 static void ftrace_startup_sysctl(void)
 579 {
 580         int command = FTRACE_ENABLE_MCOUNT;
 581
 582         if (unlikely(ftrace_disabled))
 583                 return;
 584
 585         mutex_lock(&ftraced_lock);
 586         /* Force update next time */
 587         saved_ftrace_func = NULL;
 588         /* ftraced_suspend is true if we want ftrace running */
 589         if (ftraced_suspend)
 590                 command |= FTRACE_ENABLE_CALLS;
 591
 592         ftrace_run_update_code(command);
 593         mutex_unlock(&ftraced_lock);
 594 }
 595
 596 static void ftrace_shutdown_sysctl(void)
 597 {
 598         int command = FTRACE_DISABLE_MCOUNT;
 599
 600         if (unlikely(ftrace_disabled))
 601                 return;
 602
 603         mutex_lock(&ftraced_lock);
 604         /* ftraced_suspend is true if ftrace is running */
 605         if (ftraced_suspend)
 606                 command |= FTRACE_DISABLE_CALLS;
 607
 608         ftrace_run_update_code(command);
 609         mutex_unlock(&ftraced_lock);
 610 }
 611
 612 static cycle_t          ftrace_update_time;
 613 static unsigned long    ftrace_update_cnt;
 614 unsigned long           ftrace_update_tot_cnt;
 615
 616 static int __ftrace_update_code(void *ignore)
 617 {
 618         struct dyn_ftrace *p;
 619         struct hlist_node *t, *n;
 620         int save_ftrace_enabled;
 621         cycle_t start, stop;
 622         int i;
 623
 624         /* Don't be recording funcs now */
 625         ftrace_record_suspend++;
 626         save_ftrace_enabled = ftrace_enabled;
 627         ftrace_enabled = 0;
 628
 629         start = ftrace_now(raw_smp_processor_id());
 630         ftrace_update_cnt = 0;
 631
 632         /* No locks needed, the machine is stopped! */
 633         for (i = 0; i < FTRACE_HASHSIZE; i++) {
 634                 /* all CPUS are stopped, we are safe to modify code */
 635                 hlist_for_each_entry_safe(p, t, n, &ftrace_hash[i], node) {
 636                         /* Skip over failed records which have not been
 637                          * freed. */
 638                         if (p->flags & FTRACE_FL_FAILED)
 639                                 continue;
 640
 641                         /* Unconverted records are always at the head of the
 642                          * hash bucket. Once we encounter a converted record,
 643                          * simply skip over to the next bucket. Saves ftraced
 644                          * some processor cycles (ftrace does its bid for
 645                          * global warming :-p ). */
 646                         if (p->flags & (FTRACE_FL_CONVERTED))
 647                                 break;
 648
 649                         if (ftrace_code_disable(p)) {
 650                                 p->flags |= FTRACE_FL_CONVERTED;
 651                                 ftrace_update_cnt++;
 652                         } else {
 653                                 if ((system_state == SYSTEM_BOOTING) ||
 654                                     !kernel_text_address(p->ip)) {
 655                                         ftrace_del_hash(p);
 656                                         ftrace_free_rec(p);
 657
 658                                 }
 659                         }
 660                 }
 661         }
 662
 663         stop = ftrace_now(raw_smp_processor_id());
 664         ftrace_update_time = stop - start;
 665         ftrace_update_tot_cnt += ftrace_update_cnt;
 666         ftraced_trigger = 0;
 667
 668         ftrace_enabled = save_ftrace_enabled;
 669         ftrace_record_suspend--;
 670
 671         return 0;
 672 }
 673
 674 static int ftrace_update_code(void)
 675 {
 676         if (unlikely(ftrace_disabled) ||
 677             !ftrace_enabled || !ftraced_trigger)
 678                 return 0;
 679
 680         stop_machine_run(__ftrace_update_code, NULL, NR_CPUS);
 681
 682         return 1;
 683 }
 684
 685 static int ftraced(void *ignore)
 686 {
 687         unsigned long usecs;
 688
 689         while (!kthread_should_stop()) {
 690
 691                 set_current_state(TASK_INTERRUPTIBLE);
 692
 693                 /* check once a second */
 694                 schedule_timeout(HZ);
 695
 696                 if (unlikely(ftrace_disabled))
 697                         continue;
 698
 699                 mutex_lock(&ftrace_sysctl_lock);
 700                 mutex_lock(&ftraced_lock);
 701                 if (!ftraced_suspend && !ftraced_stop &&
 702                     ftrace_update_code()) {
 703                         usecs = nsecs_to_usecs(ftrace_update_time);
 704                         if (ftrace_update_tot_cnt > 100000) {
 705                                 ftrace_update_tot_cnt = 0;
 706                                 pr_info("hm, dftrace overflow: %lu change%s"
 707                                         " (%lu total) in %lu usec%s\n",
 708                                         ftrace_update_cnt,
 709                                         ftrace_update_cnt != 1 ? "s" : "",
 710                                         ftrace_update_tot_cnt,
 711                                         usecs, usecs != 1 ? "s" : "");
 712                                 ftrace_disabled = 1;
 713                                 WARN_ON_ONCE(1);
 714                         }
 715                 }
 716                 mutex_unlock(&ftraced_lock);
 717                 mutex_unlock(&ftrace_sysctl_lock);
 718
 719                 ftrace_shutdown_replenish();
 720         }
 721         __set_current_state(TASK_RUNNING);
 722         return 0;
 723 }
 724
 725 static int __init ftrace_dyn_table_alloc(void)
 726 {
 727         struct ftrace_page *pg;
 728         int cnt;
 729         int i;
 730
 731         /* allocate a few pages */
 732         ftrace_pages_start = (void *)get_zeroed_page(GFP_KERNEL);
 733         if (!ftrace_pages_start)
 734                 return -1;
 735
 736         /*
 737          * Allocate a few more pages.
 738          *
 739          * TODO: have some parser search vmlinux before
 740          *   final linking to find all calls to ftrace.
 741          *   Then we can:
 742          *    a) know how many pages to allocate.
 743          *     and/or
 744          *    b) set up the table then.
 745          *
 746          *  The dynamic code is still necessary for
 747          *  modules.
 748          */
 749
 750         pg = ftrace_pages = ftrace_pages_start;
 751
 752         cnt = NR_TO_INIT / ENTRIES_PER_PAGE;
 753
 754         for (i = 0; i < cnt; i++) {
 755                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
 756
 757                 /* If we fail, we'll try later anyway */
 758                 if (!pg->next)
 759                         break;
 760
 761                 pg = pg->next;
 762         }
 763
 764         return 0;
 765 }
 766
 767 enum {
 768         FTRACE_ITER_FILTER      = (1 << 0),
 769         FTRACE_ITER_CONT        = (1 << 1),
 770         FTRACE_ITER_NOTRACE     = (1 << 2),
 771 };
 772
 773 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
 774
 775 struct ftrace_iterator {
 776         loff_t                  pos;
 777         struct ftrace_page      *pg;
 778         unsigned                idx;
 779         unsigned                flags;
 780         unsigned char           buffer[FTRACE_BUFF_MAX+1];
 781         unsigned                buffer_idx;
 782         unsigned                filtered;
 783 };
 784
 785 static void *
 786 t_next(struct seq_file *m, void *v, loff_t *pos)
 787 {
 788         struct ftrace_iterator *iter = m->private;
 789         struct dyn_ftrace *rec = NULL;
 790
 791         (*pos)++;
 792
 793  retry:
 794         if (iter->idx >= iter->pg->index) {
 795                 if (iter->pg->next) {
 796                         iter->pg = iter->pg->next;
 797                         iter->idx = 0;
 798                         goto retry;
 799                 }
 800         } else {
 801                 rec = &iter->pg->records[iter->idx++];
 802                 if ((rec->flags & FTRACE_FL_FAILED) ||
 803                     ((iter->flags & FTRACE_ITER_FILTER) &&
 804                      !(rec->flags & FTRACE_FL_FILTER)) ||
 805                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
 806                      !(rec->flags & FTRACE_FL_NOTRACE))) {
 807                         rec = NULL;
 808                         goto retry;
 809                 }
 810         }
 811
 812         iter->pos = *pos;
 813
 814         return rec;
 815 }
 816
 817 static void *t_start(struct seq_file *m, loff_t *pos)
 818 {
 819         struct ftrace_iterator *iter = m->private;
 820         void *p = NULL;
 821         loff_t l = -1;
 822
 823         if (*pos != iter->pos) {
 824                 for (p = t_next(m, p, &l); p && l < *pos; p = t_next(m, p, &l))
 825                         ;
 826         } else {
 827                 l = *pos;
 828                 p = t_next(m, p, &l);
 829         }
 830
 831         return p;
 832 }
 833
 834 static void t_stop(struct seq_file *m, void *p)
 835 {
 836 }
 837
 838 static int t_show(struct seq_file *m, void *v)
 839 {
 840         struct dyn_ftrace *rec = v;
 841         char str[KSYM_SYMBOL_LEN];
 842
 843         if (!rec)
 844                 return 0;
 845
 846         kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
 847
 848         seq_printf(m, "%s\n", str);
 849
 850         return 0;
 851 }
 852
 853 static struct seq_operations show_ftrace_seq_ops = {
 854         .start = t_start,
 855         .next = t_next,
 856         .stop = t_stop,
 857         .show = t_show,
 858 };
 859
 860 static int
 861 ftrace_avail_open(struct inode *inode, struct file *file)
 862 {
 863         struct ftrace_iterator *iter;
 864         int ret;
 865
 866         if (unlikely(ftrace_disabled))
 867                 return -ENODEV;
 868
 869         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
 870         if (!iter)
 871                 return -ENOMEM;
 872
 873         iter->pg = ftrace_pages_start;
 874         iter->pos = -1;
 875
 876         ret = seq_open(file, &show_ftrace_seq_ops);
 877         if (!ret) {
 878                 struct seq_file *m = file->private_data;
 879
 880                 m->private = iter;
 881         } else {
 882                 kfree(iter);
 883         }
 884
 885         return ret;
 886 }
 887
 888 int ftrace_avail_release(struct inode *inode, struct file *file)
 889 {
 890         struct seq_file *m = (struct seq_file *)file->private_data;
 891         struct ftrace_iterator *iter = m->private;
 892
 893         seq_release(inode, file);
 894         kfree(iter);
 895
 896         return 0;
 897 }
 898
 899 static void ftrace_filter_reset(int enable)
 900 {
 901         struct ftrace_page *pg;
 902         struct dyn_ftrace *rec;
 903         unsigned long type = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
 904         unsigned i;
 905
 906         /* keep kstop machine from running */
 907         preempt_disable();
 908         if (enable)
 909                 ftrace_filtered = 0;
 910         pg = ftrace_pages_start;
 911         while (pg) {
 912                 for (i = 0; i < pg->index; i++) {
 913                         rec = &pg->records[i];
 914                         if (rec->flags & FTRACE_FL_FAILED)
 915                                 continue;
 916                         rec->flags &= ~type;
 917                 }
 918                 pg = pg->next;
 919         }
 920         preempt_enable();
 921 }
 922
 923 static int
 924 ftrace_regex_open(struct inode *inode, struct file *file, int enable)
 925 {
 926         struct ftrace_iterator *iter;
 927         int ret = 0;
 928
 929         if (unlikely(ftrace_disabled))
 930                 return -ENODEV;
 931
 932         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
 933         if (!iter)
 934                 return -ENOMEM;
 935
 936         mutex_lock(&ftrace_regex_lock);
 937         if ((file->f_mode & FMODE_WRITE) &&
 938             !(file->f_flags & O_APPEND))
 939                 ftrace_filter_reset(enable);
 940
 941         if (file->f_mode & FMODE_READ) {
 942                 iter->pg = ftrace_pages_start;
 943                 iter->pos = -1;
 944                 iter->flags = enable ? FTRACE_ITER_FILTER :
 945                         FTRACE_ITER_NOTRACE;
 946
 947                 ret = seq_open(file, &show_ftrace_seq_ops);
 948                 if (!ret) {
 949                         struct seq_file *m = file->private_data;
 950                         m->private = iter;
 951                 } else
 952                         kfree(iter);
 953         } else
 954                 file->private_data = iter;
 955         mutex_unlock(&ftrace_regex_lock);
 956
 957         return ret;
 958 }
 959
 960 static int
 961 ftrace_filter_open(struct inode *inode, struct file *file)
 962 {
 963         return ftrace_regex_open(inode, file, 1);
 964 }
 965
 966 static int
 967 ftrace_notrace_open(struct inode *inode, struct file *file)
 968 {
 969         return ftrace_regex_open(inode, file, 0);
 970 }
 971
 972 static ssize_t
 973 ftrace_regex_read(struct file *file, char __user *ubuf,
 974                        size_t cnt, loff_t *ppos)
 975 {
 976         if (file->f_mode & FMODE_READ)
 977                 return seq_read(file, ubuf, cnt, ppos);
 978         else
 979                 return -EPERM;
 980 }
 981
 982 static loff_t
 983 ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
 984 {
 985         loff_t ret;
 986
 987         if (file->f_mode & FMODE_READ)
 988                 ret = seq_lseek(file, offset, origin);
 989         else
 990                 file->f_pos = ret = 1;
 991
 992         return ret;
 993 }
 994
 995 enum {
 996         MATCH_FULL,
 997         MATCH_FRONT_ONLY,
 998         MATCH_MIDDLE_ONLY,
 999         MATCH_END_ONLY,
1000 };
1001
1002 static void
1003 ftrace_match(unsigned char *buff, int len, int enable)
1004 {
1005         char str[KSYM_SYMBOL_LEN];
1006         char *search = NULL;
1007         struct ftrace_page *pg;
1008         struct dyn_ftrace *rec;
1009         int type = MATCH_FULL;
1010         unsigned long flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
1011         unsigned i, match = 0, search_len = 0;
1012
1013         for (i = 0; i < len; i++) {
1014                 if (buff[i] == '*') {
1015                         if (!i) {
1016                                 search = buff + i + 1;
1017                                 type = MATCH_END_ONLY;
1018                                 search_len = len - (i + 1);
1019                         } else {
1020                                 if (type == MATCH_END_ONLY) {
1021                                         type = MATCH_MIDDLE_ONLY;
1022                                 } else {
1023                                         match = i;
1024                                         type = MATCH_FRONT_ONLY;
1025                                 }
1026                                 buff[i] = 0;
1027                                 break;
1028                         }
1029                 }
1030         }
1031
1032         /* keep kstop machine from running */
1033         preempt_disable();
1034         if (enable)
1035                 ftrace_filtered = 1;
1036         pg = ftrace_pages_start;
1037         while (pg) {
1038                 for (i = 0; i < pg->index; i++) {
1039                         int matched = 0;
1040                         char *ptr;
1041
1042                         rec = &pg->records[i];
1043                         if (rec->flags & FTRACE_FL_FAILED)
1044                                 continue;
1045                         kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
1046                         switch (type) {
1047                         case MATCH_FULL:
1048                                 if (strcmp(str, buff) == 0)
1049                                         matched = 1;
1050                                 break;
1051                         case MATCH_FRONT_ONLY:
1052                                 if (memcmp(str, buff, match) == 0)
1053                                         matched = 1;
1054                                 break;
1055                         case MATCH_MIDDLE_ONLY:
1056                                 if (strstr(str, search))
1057                                         matched = 1;
1058                                 break;
1059                         case MATCH_END_ONLY:
1060                                 ptr = strstr(str, search);
1061                                 if (ptr && (ptr[search_len] == 0))
1062                                         matched = 1;
1063                                 break;
1064                         }
1065                         if (matched)
1066                                 rec->flags |= flag;
1067                 }
1068                 pg = pg->next;
1069         }
1070         preempt_enable();
1071 }
1072
1073 static ssize_t
1074 ftrace_regex_write(struct file *file, const char __user *ubuf,
1075                    size_t cnt, loff_t *ppos, int enable)
1076 {
1077         struct ftrace_iterator *iter;
1078         char ch;
1079         size_t read = 0;
1080         ssize_t ret;
1081
1082         if (!cnt || cnt < 0)
1083                 return 0;
1084
1085         mutex_lock(&ftrace_regex_lock);
1086
1087         if (file->f_mode & FMODE_READ) {
1088                 struct seq_file *m = file->private_data;
1089                 iter = m->private;
1090         } else
1091                 iter = file->private_data;
1092
1093         if (!*ppos) {
1094                 iter->flags &= ~FTRACE_ITER_CONT;
1095                 iter->buffer_idx = 0;
1096         }
1097
1098         ret = get_user(ch, ubuf++);
1099         if (ret)
1100                 goto out;
1101         read++;
1102         cnt--;
1103
1104         if (!(iter->flags & ~FTRACE_ITER_CONT)) {
1105                 /* skip white space */
1106                 while (cnt && isspace(ch)) {
1107                         ret = get_user(ch, ubuf++);
1108                         if (ret)
1109                                 goto out;
1110                         read++;
1111                         cnt--;
1112                 }
1113
1114                 if (isspace(ch)) {
1115                         file->f_pos += read;
1116                         ret = read;
1117                         goto out;
1118                 }
1119
1120                 iter->buffer_idx = 0;
1121         }
1122
1123         while (cnt && !isspace(ch)) {
1124                 if (iter->buffer_idx < FTRACE_BUFF_MAX)
1125                         iter->buffer[iter->buffer_idx++] = ch;
1126                 else {
1127                         ret = -EINVAL;
1128                         goto out;
1129                 }
1130                 ret = get_user(ch, ubuf++);
1131                 if (ret)
1132                         goto out;
1133                 read++;
1134                 cnt--;
1135         }
1136
1137         if (isspace(ch)) {
1138                 iter->filtered++;
1139                 iter->buffer[iter->buffer_idx] = 0;
1140                 ftrace_match(iter->buffer, iter->buffer_idx, enable);
1141                 iter->buffer_idx = 0;
1142         } else
1143                 iter->flags |= FTRACE_ITER_CONT;
1144
1145
1146         file->f_pos += read;
1147
1148         ret = read;
1149  out:
1150         mutex_unlock(&ftrace_regex_lock);
1151
1152         return ret;
1153 }
1154
1155 static ssize_t
1156 ftrace_filter_write(struct file *file, const char __user *ubuf,
1157                     size_t cnt, loff_t *ppos)
1158 {
1159         return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
1160 }
1161
1162 static ssize_t
1163 ftrace_notrace_write(struct file *file, const char __user *ubuf,
1164                      size_t cnt, loff_t *ppos)
1165 {
1166         return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
1167 }
1168
1169 static void
1170 ftrace_set_regex(unsigned char *buf, int len, int reset, int enable)
1171 {
1172         if (unlikely(ftrace_disabled))
1173                 return;
1174
1175         mutex_lock(&ftrace_regex_lock);
1176         if (reset)
1177                 ftrace_filter_reset(enable);
1178         if (buf)
1179                 ftrace_match(buf, len, enable);
1180         mutex_unlock(&ftrace_regex_lock);
1181 }
1182
1183 /**
1184  * ftrace_set_filter - set a function to filter on in ftrace
1185  * @buf - the string that holds the function filter text.
1186  * @len - the length of the string.
1187  * @reset - non zero to reset all filters before applying this filter.
1188  *
1189  * Filters denote which functions should be enabled when tracing is enabled.
1190  * If @buf is NULL and reset is set, all functions will be enabled for tracing.
1191  */
1192 void ftrace_set_filter(unsigned char *buf, int len, int reset)
1193 {
1194         ftrace_set_regex(buf, len, reset, 1);
1195 }
1196
1197 /**
1198  * ftrace_set_notrace - set a function to not trace in ftrace
1199  * @buf - the string that holds the function notrace text.
1200  * @len - the length of the string.
1201  * @reset - non zero to reset all filters before applying this filter.
1202  *
1203  * Notrace Filters denote which functions should not be enabled when tracing
1204  * is enabled. If @buf is NULL and reset is set, all functions will be enabled
1205  * for tracing.
1206  */
1207 void ftrace_set_notrace(unsigned char *buf, int len, int reset)
1208 {
1209         ftrace_set_regex(buf, len, reset, 0);
1210 }
1211
1212 static int
1213 ftrace_regex_release(struct inode *inode, struct file *file, int enable)
1214 {
1215         struct seq_file *m = (struct seq_file *)file->private_data;
1216         struct ftrace_iterator *iter;
1217
1218         mutex_lock(&ftrace_regex_lock);
1219         if (file->f_mode & FMODE_READ) {
1220                 iter = m->private;
1221
1222                 seq_release(inode, file);
1223         } else
1224                 iter = file->private_data;
1225
1226         if (iter->buffer_idx) {
1227                 iter->filtered++;
1228                 iter->buffer[iter->buffer_idx] = 0;
1229                 ftrace_match(iter->buffer, iter->buffer_idx, enable);
1230         }
1231
1232         mutex_lock(&ftrace_sysctl_lock);
1233         mutex_lock(&ftraced_lock);
1234         if (iter->filtered && ftraced_suspend && ftrace_enabled)
1235                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
1236         mutex_unlock(&ftraced_lock);
1237         mutex_unlock(&ftrace_sysctl_lock);
1238
1239         kfree(iter);
1240         mutex_unlock(&ftrace_regex_lock);
1241         return 0;
1242 }
1243
1244 static int
1245 ftrace_filter_release(struct inode *inode, struct file *file)
1246 {
1247         return ftrace_regex_release(inode, file, 1);
1248 }
1249
1250 static int
1251 ftrace_notrace_release(struct inode *inode, struct file *file)
1252 {
1253         return ftrace_regex_release(inode, file, 0);
1254 }
1255
1256 static ssize_t
1257 ftraced_read(struct file *filp, char __user *ubuf,
1258                      size_t cnt, loff_t *ppos)
1259 {
1260         /* don't worry about races */
1261         char *buf = ftraced_stop ? "disabled\n" : "enabled\n";
1262         int r = strlen(buf);
1263
1264         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
1265 }
1266
1267 static ssize_t
1268 ftraced_write(struct file *filp, const char __user *ubuf,
1269                       size_t cnt, loff_t *ppos)
1270 {
1271         char buf[64];
1272         long val;
1273         int ret;
1274
1275         if (cnt >= sizeof(buf))
1276                 return -EINVAL;
1277
1278         if (copy_from_user(&buf, ubuf, cnt))
1279                 return -EFAULT;
1280
1281         if (strncmp(buf, "enable", 6) == 0)
1282                 val = 1;
1283         else if (strncmp(buf, "disable", 7) == 0)
1284                 val = 0;
1285         else {
1286                 buf[cnt] = 0;
1287
1288                 ret = strict_strtoul(buf, 10, &val);
1289                 if (ret < 0)
1290                         return ret;
1291
1292                 val = !!val;
1293         }
1294
1295         if (val)
1296                 ftrace_enable_daemon();
1297         else
1298                 ftrace_disable_daemon();
1299
1300         filp->f_pos += cnt;
1301
1302         return cnt;
1303 }
1304
1305 static struct file_operations ftrace_avail_fops = {
1306         .open = ftrace_avail_open,
1307         .read = seq_read,
1308         .llseek = seq_lseek,
1309         .release = ftrace_avail_release,
1310 };
1311
1312 static struct file_operations ftrace_filter_fops = {
1313         .open = ftrace_filter_open,
1314         .read = ftrace_regex_read,
1315         .write = ftrace_filter_write,
1316         .llseek = ftrace_regex_lseek,
1317         .release = ftrace_filter_release,
1318 };
1319
1320 static struct file_operations ftrace_notrace_fops = {
1321         .open = ftrace_notrace_open,
1322         .read = ftrace_regex_read,
1323         .write = ftrace_notrace_write,
1324         .llseek = ftrace_regex_lseek,
1325         .release = ftrace_notrace_release,
1326 };
1327
1328 static struct file_operations ftraced_fops = {
1329         .open = tracing_open_generic,
1330         .read = ftraced_read,
1331         .write = ftraced_write,
1332 };
1333
1334 /**
1335  * ftrace_force_update - force an update to all recording ftrace functions
1336  */
1337 int ftrace_force_update(void)
1338 {
1339         int ret = 0;
1340
1341         if (unlikely(ftrace_disabled))
1342                 return -ENODEV;
1343
1344         mutex_lock(&ftrace_sysctl_lock);
1345         mutex_lock(&ftraced_lock);
1346
1347         /*
1348          * If ftraced_trigger is not set, then there is nothing
1349          * to update.
1350          */
1351         if (ftraced_trigger && !ftrace_update_code())
1352                 ret = -EBUSY;
1353
1354         mutex_unlock(&ftraced_lock);
1355         mutex_unlock(&ftrace_sysctl_lock);
1356
1357         return ret;
1358 }
1359
1360 static void ftrace_force_shutdown(void)
1361 {
1362         struct task_struct *task;
1363         int command = FTRACE_DISABLE_CALLS | FTRACE_UPDATE_TRACE_FUNC;
1364
1365         mutex_lock(&ftraced_lock);
1366         task = ftraced_task;
1367         ftraced_task = NULL;
1368         ftraced_suspend = -1;
1369         ftrace_run_update_code(command);
1370         mutex_unlock(&ftraced_lock);
1371
1372         if (task)
1373                 kthread_stop(task);
1374 }
1375
1376 static __init int ftrace_init_debugfs(void)
1377 {
1378         struct dentry *d_tracer;
1379         struct dentry *entry;
1380
1381         d_tracer = tracing_init_dentry();
1382
1383         entry = debugfs_create_file("available_filter_functions", 0444,
1384                                     d_tracer, NULL, &ftrace_avail_fops);
1385         if (!entry)
1386                 pr_warning("Could not create debugfs "
1387                            "'available_filter_functions' entry\n");
1388
1389         entry = debugfs_create_file("set_ftrace_filter", 0644, d_tracer,
1390                                     NULL, &ftrace_filter_fops);
1391         if (!entry)
1392                 pr_warning("Could not create debugfs "
1393                            "'set_ftrace_filter' entry\n");
1394
1395         entry = debugfs_create_file("set_ftrace_notrace", 0644, d_tracer,
1396                                     NULL, &ftrace_notrace_fops);
1397         if (!entry)
1398                 pr_warning("Could not create debugfs "
1399                            "'set_ftrace_notrace' entry\n");
1400
1401         entry = debugfs_create_file("ftraced_enabled", 0644, d_tracer,
1402                                     NULL, &ftraced_fops);
1403         if (!entry)
1404                 pr_warning("Could not create debugfs "
1405                            "'ftraced_enabled' entry\n");
1406         return 0;
1407 }
1408
1409 fs_initcall(ftrace_init_debugfs);
1410
1411 static int __init ftrace_dynamic_init(void)
1412 {
1413         struct task_struct *p;
1414         unsigned long addr;
1415         int ret;
1416
1417         addr = (unsigned long)ftrace_record_ip;
1418
1419         stop_machine_run(ftrace_dyn_arch_init, &addr, NR_CPUS);
1420
1421         /* ftrace_dyn_arch_init places the return code in addr */
1422         if (addr) {
1423                 ret = (int)addr;
1424                 goto failed;
1425         }
1426
1427         ret = ftrace_dyn_table_alloc();
1428         if (ret)
1429                 goto failed;
1430
1431         p = kthread_run(ftraced, NULL, "ftraced");
1432         if (IS_ERR(p)) {
1433                 ret = -1;
1434                 goto failed;
1435         }
1436
1437         last_ftrace_enabled = ftrace_enabled = 1;
1438         ftraced_task = p;
1439
1440         return 0;
1441
1442  failed:
1443         ftrace_disabled = 1;
1444         return ret;
1445 }
1446
1447 core_initcall(ftrace_dynamic_init);
1448 #else
1449 # define ftrace_startup()               do { } while (0)
1450 # define ftrace_shutdown()              do { } while (0)
1451 # define ftrace_startup_sysctl()        do { } while (0)
1452 # define ftrace_shutdown_sysctl()       do { } while (0)
1453 # define ftrace_force_shutdown()        do { } while (0)
1454 #endif /* CONFIG_DYNAMIC_FTRACE */
1455
1456 /**
1457  * ftrace_kill - totally shutdown ftrace
1458  *
1459  * This is a safety measure. If something was detected that seems
1460  * wrong, calling this function will keep ftrace from doing
1461  * any more modifications, and updates.
1462  * used when something went wrong.
1463  */
1464 void ftrace_kill(void)
1465 {
1466         mutex_lock(&ftrace_sysctl_lock);
1467         ftrace_disabled = 1;
1468         ftrace_enabled = 0;
1469
1470         clear_ftrace_function();
1471         mutex_unlock(&ftrace_sysctl_lock);
1472
1473         /* Try to totally disable ftrace */
1474         ftrace_force_shutdown();
1475 }
1476
1477 /**
1478  * register_ftrace_function - register a function for profiling
1479  * @ops - ops structure that holds the function for profiling.
1480  *
1481  * Register a function to be called by all functions in the
1482  * kernel.
1483  *
1484  * Note: @ops->func and all the functions it calls must be labeled
1485  *       with "notrace", otherwise it will go into a
1486  *       recursive loop.
1487  */
1488 int register_ftrace_function(struct ftrace_ops *ops)
1489 {
1490         int ret;
1491
1492         if (unlikely(ftrace_disabled))
1493                 return -1;
1494
1495         mutex_lock(&ftrace_sysctl_lock);
1496         ret = __register_ftrace_function(ops);
1497         ftrace_startup();
1498         mutex_unlock(&ftrace_sysctl_lock);
1499
1500         return ret;
1501 }
1502
1503 /**
1504  * unregister_ftrace_function - unresgister a function for profiling.
1505  * @ops - ops structure that holds the function to unregister
1506  *
1507  * Unregister a function that was added to be called by ftrace profiling.
1508  */
1509 int unregister_ftrace_function(struct ftrace_ops *ops)
1510 {
1511         int ret;
1512
1513         mutex_lock(&ftrace_sysctl_lock);
1514         ret = __unregister_ftrace_function(ops);
1515         ftrace_shutdown();
1516         mutex_unlock(&ftrace_sysctl_lock);
1517
1518         return ret;
1519 }
1520
1521 int
1522 ftrace_enable_sysctl(struct ctl_table *table, int write,
1523                      struct file *file, void __user *buffer, size_t *lenp,
1524                      loff_t *ppos)
1525 {
1526         int ret;
1527
1528         if (unlikely(ftrace_disabled))
1529                 return -ENODEV;
1530
1531         mutex_lock(&ftrace_sysctl_lock);
1532
1533         ret  = proc_dointvec(table, write, file, buffer, lenp, ppos);
1534
1535         if (ret || !write || (last_ftrace_enabled == ftrace_enabled))
1536                 goto out;
1537
1538         last_ftrace_enabled = ftrace_enabled;
1539
1540         if (ftrace_enabled) {
1541
1542                 ftrace_startup_sysctl();
1543
1544                 /* we are starting ftrace again */
1545                 if (ftrace_list != &ftrace_list_end) {
1546                         if (ftrace_list->next == &ftrace_list_end)
1547                                 ftrace_trace_function = ftrace_list->func;
1548                         else
1549                                 ftrace_trace_function = ftrace_list_func;
1550                 }
1551
1552         } else {
1553                 /* stopping ftrace calls (just send to ftrace_stub) */
1554                 ftrace_trace_function = ftrace_stub;
1555
1556                 ftrace_shutdown_sysctl();
1557         }
1558
1559  out:
1560         mutex_unlock(&ftrace_sysctl_lock);
1561         return ret;
1562 }