kernel/trace/trace_selftest.c

   1 /* Include in trace.c */
   2
   3 #include <linux/stringify.h>
   4 #include <linux/kthread.h>
   5 #include <linux/delay.h>
   6 #include <linux/slab.h>
   7
   8 static inline int trace_valid_entry(struct trace_entry *entry)
   9 {
  10         switch (entry->type) {
  11         case TRACE_FN:
  12         case TRACE_CTX:
  13         case TRACE_WAKE:
  14         case TRACE_STACK:
  15         case TRACE_PRINT:
  16         case TRACE_BRANCH:
  17         case TRACE_GRAPH_ENT:
  18         case TRACE_GRAPH_RET:
  19                 return 1;
  20         }
  21         return 0;
  22 }
  23
  24 static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
  25 {
  26         struct ring_buffer_event *event;
  27         struct trace_entry *entry;
  28         unsigned int loops = 0;
  29
  30         while ((event = ring_buffer_consume(tr->buffer, cpu, NULL, NULL))) {
  31                 entry = ring_buffer_event_data(event);
  32
  33                 /*
  34                  * The ring buffer is a size of trace_buf_size, if
  35                  * we loop more than the size, there's something wrong
  36                  * with the ring buffer.
  37                  */
  38                 if (loops++ > trace_buf_size) {
  39                         printk(KERN_CONT ".. bad ring buffer ");
  40                         goto failed;
  41                 }
  42                 if (!trace_valid_entry(entry)) {
  43                         printk(KERN_CONT ".. invalid entry %d ",
  44                                 entry->type);
  45                         goto failed;
  46                 }
  47         }
  48         return 0;
  49
  50  failed:
  51         /* disable tracing */
  52         tracing_disabled = 1;
  53         printk(KERN_CONT ".. corrupted trace buffer .. ");
  54         return -1;
  55 }
  56
  57 /*
  58  * Test the trace buffer to see if all the elements
  59  * are still sane.
  60  */
  61 static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
  62 {
  63         unsigned long flags, cnt = 0;
  64         int cpu, ret = 0;
  65
  66         /* Don't allow flipping of max traces now */
  67         local_irq_save(flags);
  68         arch_spin_lock(&ftrace_max_lock);
  69
  70         cnt = ring_buffer_entries(tr->buffer);
  71
  72         /*
  73          * The trace_test_buffer_cpu runs a while loop to consume all data.
  74          * If the calling tracer is broken, and is constantly filling
  75          * the buffer, this will run forever, and hard lock the box.
  76          * We disable the ring buffer while we do this test to prevent
  77          * a hard lock up.
  78          */
  79         tracing_off();
  80         for_each_possible_cpu(cpu) {
  81                 ret = trace_test_buffer_cpu(tr, cpu);
  82                 if (ret)
  83                         break;
  84         }
  85         tracing_on();
  86         arch_spin_unlock(&ftrace_max_lock);
  87         local_irq_restore(flags);
  88
  89         if (count)
  90                 *count = cnt;
  91
  92         return ret;
  93 }
  94
  95 static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
  96 {
  97         printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
  98                 trace->name, init_ret);
  99 }
 100 #ifdef CONFIG_FUNCTION_TRACER
 101
 102 #ifdef CONFIG_DYNAMIC_FTRACE
 103
 104 static int trace_selftest_test_probe1_cnt;
 105 static void trace_selftest_test_probe1_func(unsigned long ip,
 106                                             unsigned long pip)
 107 {
 108         trace_selftest_test_probe1_cnt++;
 109 }
 110
 111 static int trace_selftest_test_probe2_cnt;
 112 static void trace_selftest_test_probe2_func(unsigned long ip,
 113                                             unsigned long pip)
 114 {
 115         trace_selftest_test_probe2_cnt++;
 116 }
 117
 118 static int trace_selftest_test_probe3_cnt;
 119 static void trace_selftest_test_probe3_func(unsigned long ip,
 120                                             unsigned long pip)
 121 {
 122         trace_selftest_test_probe3_cnt++;
 123 }
 124
 125 static int trace_selftest_test_global_cnt;
 126 static void trace_selftest_test_global_func(unsigned long ip,
 127                                             unsigned long pip)
 128 {
 129         trace_selftest_test_global_cnt++;
 130 }
 131
 132 static int trace_selftest_test_dyn_cnt;
 133 static void trace_selftest_test_dyn_func(unsigned long ip,
 134                                          unsigned long pip)
 135 {
 136         trace_selftest_test_dyn_cnt++;
 137 }
 138
 139 static struct ftrace_ops test_probe1 = {
 140         .func                   = trace_selftest_test_probe1_func,
 141 };
 142
 143 static struct ftrace_ops test_probe2 = {
 144         .func                   = trace_selftest_test_probe2_func,
 145 };
 146
 147 static struct ftrace_ops test_probe3 = {
 148         .func                   = trace_selftest_test_probe3_func,
 149 };
 150
 151 static struct ftrace_ops test_global = {
 152         .func                   = trace_selftest_test_global_func,
 153         .flags                  = FTRACE_OPS_FL_GLOBAL,
 154 };
 155
 156 static void print_counts(void)
 157 {
 158         printk("(%d %d %d %d %d) ",
 159                trace_selftest_test_probe1_cnt,
 160                trace_selftest_test_probe2_cnt,
 161                trace_selftest_test_probe3_cnt,
 162                trace_selftest_test_global_cnt,
 163                trace_selftest_test_dyn_cnt);
 164 }
 165
 166 static void reset_counts(void)
 167 {
 168         trace_selftest_test_probe1_cnt = 0;
 169         trace_selftest_test_probe2_cnt = 0;
 170         trace_selftest_test_probe3_cnt = 0;
 171         trace_selftest_test_global_cnt = 0;
 172         trace_selftest_test_dyn_cnt = 0;
 173 }
 174
 175 static int trace_selftest_ops(int cnt)
 176 {
 177         int save_ftrace_enabled = ftrace_enabled;
 178         struct ftrace_ops *dyn_ops;
 179         char *func1_name;
 180         char *func2_name;
 181         int len1;
 182         int len2;
 183         int ret = -1;
 184
 185         printk(KERN_CONT "PASSED\n");
 186         pr_info("Testing dynamic ftrace ops #%d: ", cnt);
 187
 188         ftrace_enabled = 1;
 189         reset_counts();
 190
 191         /* Handle PPC64 '.' name */
 192         func1_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 193         func2_name = "*" __stringify(DYN_FTRACE_TEST_NAME2);
 194         len1 = strlen(func1_name);
 195         len2 = strlen(func2_name);
 196
 197         /*
 198          * Probe 1 will trace function 1.
 199          * Probe 2 will trace function 2.
 200          * Probe 3 will trace functions 1 and 2.
 201          */
 202         ftrace_set_filter(&test_probe1, func1_name, len1, 1);
 203         ftrace_set_filter(&test_probe2, func2_name, len2, 1);
 204         ftrace_set_filter(&test_probe3, func1_name, len1, 1);
 205         ftrace_set_filter(&test_probe3, func2_name, len2, 0);
 206
 207         register_ftrace_function(&test_probe1);
 208         register_ftrace_function(&test_probe2);
 209         register_ftrace_function(&test_probe3);
 210         register_ftrace_function(&test_global);
 211
 212         DYN_FTRACE_TEST_NAME();
 213
 214         print_counts();
 215
 216         if (trace_selftest_test_probe1_cnt != 1)
 217                 goto out;
 218         if (trace_selftest_test_probe2_cnt != 0)
 219                 goto out;
 220         if (trace_selftest_test_probe3_cnt != 1)
 221                 goto out;
 222         if (trace_selftest_test_global_cnt == 0)
 223                 goto out;
 224
 225         DYN_FTRACE_TEST_NAME2();
 226
 227         print_counts();
 228
 229         if (trace_selftest_test_probe1_cnt != 1)
 230                 goto out;
 231         if (trace_selftest_test_probe2_cnt != 1)
 232                 goto out;
 233         if (trace_selftest_test_probe3_cnt != 2)
 234                 goto out;
 235
 236         /* Add a dynamic probe */
 237         dyn_ops = kzalloc(sizeof(*dyn_ops), GFP_KERNEL);
 238         if (!dyn_ops) {
 239                 printk("MEMORY ERROR ");
 240                 goto out;
 241         }
 242
 243         dyn_ops->func = trace_selftest_test_dyn_func;
 244
 245         register_ftrace_function(dyn_ops);
 246
 247         trace_selftest_test_global_cnt = 0;
 248
 249         DYN_FTRACE_TEST_NAME();
 250
 251         print_counts();
 252
 253         if (trace_selftest_test_probe1_cnt != 2)
 254                 goto out_free;
 255         if (trace_selftest_test_probe2_cnt != 1)
 256                 goto out_free;
 257         if (trace_selftest_test_probe3_cnt != 3)
 258                 goto out_free;
 259         if (trace_selftest_test_global_cnt == 0)
 260                 goto out;
 261         if (trace_selftest_test_dyn_cnt == 0)
 262                 goto out_free;
 263
 264         DYN_FTRACE_TEST_NAME2();
 265
 266         print_counts();
 267
 268         if (trace_selftest_test_probe1_cnt != 2)
 269                 goto out_free;
 270         if (trace_selftest_test_probe2_cnt != 2)
 271                 goto out_free;
 272         if (trace_selftest_test_probe3_cnt != 4)
 273                 goto out_free;
 274
 275         ret = 0;
 276  out_free:
 277         unregister_ftrace_function(dyn_ops);
 278         kfree(dyn_ops);
 279
 280  out:
 281         /* Purposely unregister in the same order */
 282         unregister_ftrace_function(&test_probe1);
 283         unregister_ftrace_function(&test_probe2);
 284         unregister_ftrace_function(&test_probe3);
 285         unregister_ftrace_function(&test_global);
 286
 287         /* Make sure everything is off */
 288         reset_counts();
 289         DYN_FTRACE_TEST_NAME();
 290         DYN_FTRACE_TEST_NAME();
 291
 292         if (trace_selftest_test_probe1_cnt ||
 293             trace_selftest_test_probe2_cnt ||
 294             trace_selftest_test_probe3_cnt ||
 295             trace_selftest_test_global_cnt ||
 296             trace_selftest_test_dyn_cnt)
 297                 ret = -1;
 298
 299         ftrace_enabled = save_ftrace_enabled;
 300
 301         return ret;
 302 }
 303
 304 /* Test dynamic code modification and ftrace filters */
 305 int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 306                                            struct trace_array *tr,
 307                                            int (*func)(void))
 308 {
 309         int save_ftrace_enabled = ftrace_enabled;
 310         int save_tracer_enabled = tracer_enabled;
 311         unsigned long count;
 312         char *func_name;
 313         int ret;
 314
 315         /* The ftrace test PASSED */
 316         printk(KERN_CONT "PASSED\n");
 317         pr_info("Testing dynamic ftrace: ");
 318
 319         /* enable tracing, and record the filter function */
 320         ftrace_enabled = 1;
 321         tracer_enabled = 1;
 322
 323         /* passed in by parameter to fool gcc from optimizing */
 324         func();
 325
 326         /*
 327          * Some archs *cough*PowerPC*cough* add characters to the
 328          * start of the function names. We simply put a '*' to
 329          * accommodate them.
 330          */
 331         func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 332
 333         /* filter only on our function */
 334         ftrace_set_global_filter(func_name, strlen(func_name), 1);
 335
 336         /* enable tracing */
 337         ret = tracer_init(trace, tr);
 338         if (ret) {
 339                 warn_failed_init_tracer(trace, ret);
 340                 goto out;
 341         }
 342
 343         /* Sleep for a 1/10 of a second */
 344         msleep(100);
 345
 346         /* we should have nothing in the buffer */
 347         ret = trace_test_buffer(tr, &count);
 348         if (ret)
 349                 goto out;
 350
 351         if (count) {
 352                 ret = -1;
 353                 printk(KERN_CONT ".. filter did not filter .. ");
 354                 goto out;
 355         }
 356
 357         /* call our function again */
 358         func();
 359
 360         /* sleep again */
 361         msleep(100);
 362
 363         /* stop the tracing. */
 364         tracing_stop();
 365         ftrace_enabled = 0;
 366
 367         /* check the trace buffer */
 368         ret = trace_test_buffer(tr, &count);
 369         tracing_start();
 370
 371         /* we should only have one item */
 372         if (!ret && count != 1) {
 373                 trace->reset(tr);
 374                 printk(KERN_CONT ".. filter failed count=%ld ..", count);
 375                 ret = -1;
 376                 goto out;
 377         }
 378
 379         /* Test the ops with global tracing running */
 380         ret = trace_selftest_ops(1);
 381         trace->reset(tr);
 382
 383  out:
 384         ftrace_enabled = save_ftrace_enabled;
 385         tracer_enabled = save_tracer_enabled;
 386
 387         /* Enable tracing on all functions again */
 388         ftrace_set_global_filter(NULL, 0, 1);
 389
 390         /* Test the ops with global tracing off */
 391         if (!ret)
 392                 ret = trace_selftest_ops(2);
 393
 394         return ret;
 395 }
 396 #else
 397 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
 398 #endif /* CONFIG_DYNAMIC_FTRACE */
 399
 400 /*
 401  * Simple verification test of ftrace function tracer.
 402  * Enable ftrace, sleep 1/10 second, and then read the trace
 403  * buffer to see if all is in order.
 404  */
 405 int
 406 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 407 {
 408         int save_ftrace_enabled = ftrace_enabled;
 409         int save_tracer_enabled = tracer_enabled;
 410         unsigned long count;
 411         int ret;
 412
 413         /* make sure msleep has been recorded */
 414         msleep(1);
 415
 416         /* start the tracing */
 417         ftrace_enabled = 1;
 418         tracer_enabled = 1;
 419
 420         ret = tracer_init(trace, tr);
 421         if (ret) {
 422                 warn_failed_init_tracer(trace, ret);
 423                 goto out;
 424         }
 425
 426         /* Sleep for a 1/10 of a second */
 427         msleep(100);
 428         /* stop the tracing. */
 429         tracing_stop();
 430         ftrace_enabled = 0;
 431
 432         /* check the trace buffer */
 433         ret = trace_test_buffer(tr, &count);
 434         trace->reset(tr);
 435         tracing_start();
 436
 437         if (!ret && !count) {
 438                 printk(KERN_CONT ".. no entries found ..");
 439                 ret = -1;
 440                 goto out;
 441         }
 442
 443         ret = trace_selftest_startup_dynamic_tracing(trace, tr,
 444                                                      DYN_FTRACE_TEST_NAME);
 445
 446  out:
 447         ftrace_enabled = save_ftrace_enabled;
 448         tracer_enabled = save_tracer_enabled;
 449
 450         /* kill ftrace totally if we failed */
 451         if (ret)
 452                 ftrace_kill();
 453
 454         return ret;
 455 }
 456 #endif /* CONFIG_FUNCTION_TRACER */
 457
 458
 459 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 460
 461 /* Maximum number of functions to trace before diagnosing a hang */
 462 #define GRAPH_MAX_FUNC_TEST     100000000
 463
 464 static unsigned int graph_hang_thresh;
 465
 466 /* Wrap the real function entry probe to avoid possible hanging */
 467 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
 468 {
 469         /* This is harmlessly racy, we want to approximately detect a hang */
 470         if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
 471                 ftrace_graph_stop();
 472                 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
 473                 if (ftrace_dump_on_oops) {
 474                         ftrace_dump(DUMP_ALL);
 475                         /* ftrace_dump() disables tracing */
 476                         tracing_on();
 477                 }
 478                 return 0;
 479         }
 480
 481         return trace_graph_entry(trace);
 482 }
 483
 484 /*
 485  * Pretty much the same than for the function tracer from which the selftest
 486  * has been borrowed.
 487  */
 488 int
 489 trace_selftest_startup_function_graph(struct tracer *trace,
 490                                         struct trace_array *tr)
 491 {
 492         int ret;
 493         unsigned long count;
 494
 495         /*
 496          * Simulate the init() callback but we attach a watchdog callback
 497          * to detect and recover from possible hangs
 498          */
 499         tracing_reset_online_cpus(tr);
 500         set_graph_array(tr);
 501         ret = register_ftrace_graph(&trace_graph_return,
 502                                     &trace_graph_entry_watchdog);
 503         if (ret) {
 504                 warn_failed_init_tracer(trace, ret);
 505                 goto out;
 506         }
 507         tracing_start_cmdline_record();
 508
 509         /* Sleep for a 1/10 of a second */
 510         msleep(100);
 511
 512         /* Have we just recovered from a hang? */
 513         if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
 514                 tracing_selftest_disabled = true;
 515                 ret = -1;
 516                 goto out;
 517         }
 518
 519         tracing_stop();
 520
 521         /* check the trace buffer */
 522         ret = trace_test_buffer(tr, &count);
 523
 524         trace->reset(tr);
 525         tracing_start();
 526
 527         if (!ret && !count) {
 528                 printk(KERN_CONT ".. no entries found ..");
 529                 ret = -1;
 530                 goto out;
 531         }
 532
 533         /* Don't test dynamic tracing, the function tracer already did */
 534
 535 out:
 536         /* Stop it if we failed */
 537         if (ret)
 538                 ftrace_graph_stop();
 539
 540         return ret;
 541 }
 542 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 543
 544
 545 #ifdef CONFIG_IRQSOFF_TRACER
 546 int
 547 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
 548 {
 549         unsigned long save_max = tracing_max_latency;
 550         unsigned long count;
 551         int ret;
 552
 553         /* start the tracing */
 554         ret = tracer_init(trace, tr);
 555         if (ret) {
 556                 warn_failed_init_tracer(trace, ret);
 557                 return ret;
 558         }
 559
 560         /* reset the max latency */
 561         tracing_max_latency = 0;
 562         /* disable interrupts for a bit */
 563         local_irq_disable();
 564         udelay(100);
 565         local_irq_enable();
 566
 567         /*
 568          * Stop the tracer to avoid a warning subsequent
 569          * to buffer flipping failure because tracing_stop()
 570          * disables the tr and max buffers, making flipping impossible
 571          * in case of parallels max irqs off latencies.
 572          */
 573         trace->stop(tr);
 574         /* stop the tracing. */
 575         tracing_stop();
 576         /* check both trace buffers */
 577         ret = trace_test_buffer(tr, NULL);
 578         if (!ret)
 579                 ret = trace_test_buffer(&max_tr, &count);
 580         trace->reset(tr);
 581         tracing_start();
 582
 583         if (!ret && !count) {
 584                 printk(KERN_CONT ".. no entries found ..");
 585                 ret = -1;
 586         }
 587
 588         tracing_max_latency = save_max;
 589
 590         return ret;
 591 }
 592 #endif /* CONFIG_IRQSOFF_TRACER */
 593
 594 #ifdef CONFIG_PREEMPT_TRACER
 595 int
 596 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
 597 {
 598         unsigned long save_max = tracing_max_latency;
 599         unsigned long count;
 600         int ret;
 601
 602         /*
 603          * Now that the big kernel lock is no longer preemptable,
 604          * and this is called with the BKL held, it will always
 605          * fail. If preemption is already disabled, simply
 606          * pass the test. When the BKL is removed, or becomes
 607          * preemptible again, we will once again test this,
 608          * so keep it in.
 609          */
 610         if (preempt_count()) {
 611                 printk(KERN_CONT "can not test ... force ");
 612                 return 0;
 613         }
 614
 615         /* start the tracing */
 616         ret = tracer_init(trace, tr);
 617         if (ret) {
 618                 warn_failed_init_tracer(trace, ret);
 619                 return ret;
 620         }
 621
 622         /* reset the max latency */
 623         tracing_max_latency = 0;
 624         /* disable preemption for a bit */
 625         preempt_disable();
 626         udelay(100);
 627         preempt_enable();
 628
 629         /*
 630          * Stop the tracer to avoid a warning subsequent
 631          * to buffer flipping failure because tracing_stop()
 632          * disables the tr and max buffers, making flipping impossible
 633          * in case of parallels max preempt off latencies.
 634          */
 635         trace->stop(tr);
 636         /* stop the tracing. */
 637         tracing_stop();
 638         /* check both trace buffers */
 639         ret = trace_test_buffer(tr, NULL);
 640         if (!ret)
 641                 ret = trace_test_buffer(&max_tr, &count);
 642         trace->reset(tr);
 643         tracing_start();
 644
 645         if (!ret && !count) {
 646                 printk(KERN_CONT ".. no entries found ..");
 647                 ret = -1;
 648         }
 649
 650         tracing_max_latency = save_max;
 651
 652         return ret;
 653 }
 654 #endif /* CONFIG_PREEMPT_TRACER */
 655
 656 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
 657 int
 658 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
 659 {
 660         unsigned long save_max = tracing_max_latency;
 661         unsigned long count;
 662         int ret;
 663
 664         /*
 665          * Now that the big kernel lock is no longer preemptable,
 666          * and this is called with the BKL held, it will always
 667          * fail. If preemption is already disabled, simply
 668          * pass the test. When the BKL is removed, or becomes
 669          * preemptible again, we will once again test this,
 670          * so keep it in.
 671          */
 672         if (preempt_count()) {
 673                 printk(KERN_CONT "can not test ... force ");
 674                 return 0;
 675         }
 676
 677         /* start the tracing */
 678         ret = tracer_init(trace, tr);
 679         if (ret) {
 680                 warn_failed_init_tracer(trace, ret);
 681                 goto out_no_start;
 682         }
 683
 684         /* reset the max latency */
 685         tracing_max_latency = 0;
 686
 687         /* disable preemption and interrupts for a bit */
 688         preempt_disable();
 689         local_irq_disable();
 690         udelay(100);
 691         preempt_enable();
 692         /* reverse the order of preempt vs irqs */
 693         local_irq_enable();
 694
 695         /*
 696          * Stop the tracer to avoid a warning subsequent
 697          * to buffer flipping failure because tracing_stop()
 698          * disables the tr and max buffers, making flipping impossible
 699          * in case of parallels max irqs/preempt off latencies.
 700          */
 701         trace->stop(tr);
 702         /* stop the tracing. */
 703         tracing_stop();
 704         /* check both trace buffers */
 705         ret = trace_test_buffer(tr, NULL);
 706         if (ret)
 707                 goto out;
 708
 709         ret = trace_test_buffer(&max_tr, &count);
 710         if (ret)
 711                 goto out;
 712
 713         if (!ret && !count) {
 714                 printk(KERN_CONT ".. no entries found ..");
 715                 ret = -1;
 716                 goto out;
 717         }
 718
 719         /* do the test by disabling interrupts first this time */
 720         tracing_max_latency = 0;
 721         tracing_start();
 722         trace->start(tr);
 723
 724         preempt_disable();
 725         local_irq_disable();
 726         udelay(100);
 727         preempt_enable();
 728         /* reverse the order of preempt vs irqs */
 729         local_irq_enable();
 730
 731         trace->stop(tr);
 732         /* stop the tracing. */
 733         tracing_stop();
 734         /* check both trace buffers */
 735         ret = trace_test_buffer(tr, NULL);
 736         if (ret)
 737                 goto out;
 738
 739         ret = trace_test_buffer(&max_tr, &count);
 740
 741         if (!ret && !count) {
 742                 printk(KERN_CONT ".. no entries found ..");
 743                 ret = -1;
 744                 goto out;
 745         }
 746
 747 out:
 748         tracing_start();
 749 out_no_start:
 750         trace->reset(tr);
 751         tracing_max_latency = save_max;
 752
 753         return ret;
 754 }
 755 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
 756
 757 #ifdef CONFIG_NOP_TRACER
 758 int
 759 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
 760 {
 761         /* What could possibly go wrong? */
 762         return 0;
 763 }
 764 #endif
 765
 766 #ifdef CONFIG_SCHED_TRACER
 767 static int trace_wakeup_test_thread(void *data)
 768 {
 769         /* Make this a RT thread, doesn't need to be too high */
 770         static const struct sched_param param = { .sched_priority = 5 };
 771         struct completion *x = data;
 772
 773         sched_setscheduler(current, SCHED_FIFO, &param);
 774
 775         /* Make it know we have a new prio */
 776         complete(x);
 777
 778         /* now go to sleep and let the test wake us up */
 779         set_current_state(TASK_INTERRUPTIBLE);
 780         schedule();
 781
 782         /* we are awake, now wait to disappear */
 783         while (!kthread_should_stop()) {
 784                 /*
 785                  * This is an RT task, do short sleeps to let
 786                  * others run.
 787                  */
 788                 msleep(100);
 789         }
 790
 791         return 0;
 792 }
 793
 794 int
 795 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
 796 {
 797         unsigned long save_max = tracing_max_latency;
 798         struct task_struct *p;
 799         struct completion isrt;
 800         unsigned long count;
 801         int ret;
 802
 803         init_completion(&isrt);
 804
 805         /* create a high prio thread */
 806         p = kthread_run(trace_wakeup_test_thread, &isrt, "ftrace-test");
 807         if (IS_ERR(p)) {
 808                 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
 809                 return -1;
 810         }
 811
 812         /* make sure the thread is running at an RT prio */
 813         wait_for_completion(&isrt);
 814
 815         /* start the tracing */
 816         ret = tracer_init(trace, tr);
 817         if (ret) {
 818                 warn_failed_init_tracer(trace, ret);
 819                 return ret;
 820         }
 821
 822         /* reset the max latency */
 823         tracing_max_latency = 0;
 824
 825         /* sleep to let the RT thread sleep too */
 826         msleep(100);
 827
 828         /*
 829          * Yes this is slightly racy. It is possible that for some
 830          * strange reason that the RT thread we created, did not
 831          * call schedule for 100ms after doing the completion,
 832          * and we do a wakeup on a task that already is awake.
 833          * But that is extremely unlikely, and the worst thing that
 834          * happens in such a case, is that we disable tracing.
 835          * Honestly, if this race does happen something is horrible
 836          * wrong with the system.
 837          */
 838
 839         wake_up_process(p);
 840
 841         /* give a little time to let the thread wake up */
 842         msleep(100);
 843
 844         /* stop the tracing. */
 845         tracing_stop();
 846         /* check both trace buffers */
 847         ret = trace_test_buffer(tr, NULL);
 848         if (!ret)
 849                 ret = trace_test_buffer(&max_tr, &count);
 850
 851
 852         trace->reset(tr);
 853         tracing_start();
 854
 855         tracing_max_latency = save_max;
 856
 857         /* kill the thread */
 858         kthread_stop(p);
 859
 860         if (!ret && !count) {
 861                 printk(KERN_CONT ".. no entries found ..");
 862                 ret = -1;
 863         }
 864
 865         return ret;
 866 }
 867 #endif /* CONFIG_SCHED_TRACER */
 868
 869 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
 870 int
 871 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
 872 {
 873         unsigned long count;
 874         int ret;
 875
 876         /* start the tracing */
 877         ret = tracer_init(trace, tr);
 878         if (ret) {
 879                 warn_failed_init_tracer(trace, ret);
 880                 return ret;
 881         }
 882
 883         /* Sleep for a 1/10 of a second */
 884         msleep(100);
 885         /* stop the tracing. */
 886         tracing_stop();
 887         /* check the trace buffer */
 888         ret = trace_test_buffer(tr, &count);
 889         trace->reset(tr);
 890         tracing_start();
 891
 892         if (!ret && !count) {
 893                 printk(KERN_CONT ".. no entries found ..");
 894                 ret = -1;
 895         }
 896
 897         return ret;
 898 }
 899 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
 900
 901 #ifdef CONFIG_BRANCH_TRACER
 902 int
 903 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
 904 {
 905         unsigned long count;
 906         int ret;
 907
 908         /* start the tracing */
 909         ret = tracer_init(trace, tr);
 910         if (ret) {
 911                 warn_failed_init_tracer(trace, ret);
 912                 return ret;
 913         }
 914
 915         /* Sleep for a 1/10 of a second */
 916         msleep(100);
 917         /* stop the tracing. */
 918         tracing_stop();
 919         /* check the trace buffer */
 920         ret = trace_test_buffer(tr, &count);
 921         trace->reset(tr);
 922         tracing_start();
 923
 924         if (!ret && !count) {
 925                 printk(KERN_CONT ".. no entries found ..");
 926                 ret = -1;
 927         }
 928
 929         return ret;
 930 }
 931 #endif /* CONFIG_BRANCH_TRACER */
 932