kernel/trace/trace_selftest.c

   1 /* Include in trace.c */
   2
   3 #include <uapi/linux/sched/types.h>
   4 #include <linux/stringify.h>
   5 #include <linux/kthread.h>
   6 #include <linux/delay.h>
   7 #include <linux/slab.h>
   8
   9 static inline int trace_valid_entry(struct trace_entry *entry)
  10 {
  11         switch (entry->type) {
  12         case TRACE_FN:
  13         case TRACE_CTX:
  14         case TRACE_WAKE:
  15         case TRACE_STACK:
  16         case TRACE_PRINT:
  17         case TRACE_BRANCH:
  18         case TRACE_GRAPH_ENT:
  19         case TRACE_GRAPH_RET:
  20                 return 1;
  21         }
  22         return 0;
  23 }
  24
  25 static int trace_test_buffer_cpu(struct trace_buffer *buf, int cpu)
  26 {
  27         struct ring_buffer_event *event;
  28         struct trace_entry *entry;
  29         unsigned int loops = 0;
  30
  31         while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
  32                 entry = ring_buffer_event_data(event);
  33
  34                 /*
  35                  * The ring buffer is a size of trace_buf_size, if
  36                  * we loop more than the size, there's something wrong
  37                  * with the ring buffer.
  38                  */
  39                 if (loops++ > trace_buf_size) {
  40                         printk(KERN_CONT ".. bad ring buffer ");
  41                         goto failed;
  42                 }
  43                 if (!trace_valid_entry(entry)) {
  44                         printk(KERN_CONT ".. invalid entry %d ",
  45                                 entry->type);
  46                         goto failed;
  47                 }
  48         }
  49         return 0;
  50
  51  failed:
  52         /* disable tracing */
  53         tracing_disabled = 1;
  54         printk(KERN_CONT ".. corrupted trace buffer .. ");
  55         return -1;
  56 }
  57
  58 /*
  59  * Test the trace buffer to see if all the elements
  60  * are still sane.
  61  */
  62 static int trace_test_buffer(struct trace_buffer *buf, unsigned long *count)
  63 {
  64         unsigned long flags, cnt = 0;
  65         int cpu, ret = 0;
  66
  67         /* Don't allow flipping of max traces now */
  68         local_irq_save(flags);
  69         arch_spin_lock(&buf->tr->max_lock);
  70
  71         cnt = ring_buffer_entries(buf->buffer);
  72
  73         /*
  74          * The trace_test_buffer_cpu runs a while loop to consume all data.
  75          * If the calling tracer is broken, and is constantly filling
  76          * the buffer, this will run forever, and hard lock the box.
  77          * We disable the ring buffer while we do this test to prevent
  78          * a hard lock up.
  79          */
  80         tracing_off();
  81         for_each_possible_cpu(cpu) {
  82                 ret = trace_test_buffer_cpu(buf, cpu);
  83                 if (ret)
  84                         break;
  85         }
  86         tracing_on();
  87         arch_spin_unlock(&buf->tr->max_lock);
  88         local_irq_restore(flags);
  89
  90         if (count)
  91                 *count = cnt;
  92
  93         return ret;
  94 }
  95
  96 static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
  97 {
  98         printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
  99                 trace->name, init_ret);
 100 }
 101 #ifdef CONFIG_FUNCTION_TRACER
 102
 103 #ifdef CONFIG_DYNAMIC_FTRACE
 104
 105 static int trace_selftest_test_probe1_cnt;
 106 static void trace_selftest_test_probe1_func(unsigned long ip,
 107                                             unsigned long pip,
 108                                             struct ftrace_ops *op,
 109                                             struct pt_regs *pt_regs)
 110 {
 111         trace_selftest_test_probe1_cnt++;
 112 }
 113
 114 static int trace_selftest_test_probe2_cnt;
 115 static void trace_selftest_test_probe2_func(unsigned long ip,
 116                                             unsigned long pip,
 117                                             struct ftrace_ops *op,
 118                                             struct pt_regs *pt_regs)
 119 {
 120         trace_selftest_test_probe2_cnt++;
 121 }
 122
 123 static int trace_selftest_test_probe3_cnt;
 124 static void trace_selftest_test_probe3_func(unsigned long ip,
 125                                             unsigned long pip,
 126                                             struct ftrace_ops *op,
 127                                             struct pt_regs *pt_regs)
 128 {
 129         trace_selftest_test_probe3_cnt++;
 130 }
 131
 132 static int trace_selftest_test_global_cnt;
 133 static void trace_selftest_test_global_func(unsigned long ip,
 134                                             unsigned long pip,
 135                                             struct ftrace_ops *op,
 136                                             struct pt_regs *pt_regs)
 137 {
 138         trace_selftest_test_global_cnt++;
 139 }
 140
 141 static int trace_selftest_test_dyn_cnt;
 142 static void trace_selftest_test_dyn_func(unsigned long ip,
 143                                          unsigned long pip,
 144                                          struct ftrace_ops *op,
 145                                          struct pt_regs *pt_regs)
 146 {
 147         trace_selftest_test_dyn_cnt++;
 148 }
 149
 150 static struct ftrace_ops test_probe1 = {
 151         .func                   = trace_selftest_test_probe1_func,
 152         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
 153 };
 154
 155 static struct ftrace_ops test_probe2 = {
 156         .func                   = trace_selftest_test_probe2_func,
 157         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
 158 };
 159
 160 static struct ftrace_ops test_probe3 = {
 161         .func                   = trace_selftest_test_probe3_func,
 162         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
 163 };
 164
 165 static void print_counts(void)
 166 {
 167         printk("(%d %d %d %d %d) ",
 168                trace_selftest_test_probe1_cnt,
 169                trace_selftest_test_probe2_cnt,
 170                trace_selftest_test_probe3_cnt,
 171                trace_selftest_test_global_cnt,
 172                trace_selftest_test_dyn_cnt);
 173 }
 174
 175 static void reset_counts(void)
 176 {
 177         trace_selftest_test_probe1_cnt = 0;
 178         trace_selftest_test_probe2_cnt = 0;
 179         trace_selftest_test_probe3_cnt = 0;
 180         trace_selftest_test_global_cnt = 0;
 181         trace_selftest_test_dyn_cnt = 0;
 182 }
 183
 184 static int trace_selftest_ops(struct trace_array *tr, int cnt)
 185 {
 186         int save_ftrace_enabled = ftrace_enabled;
 187         struct ftrace_ops *dyn_ops;
 188         char *func1_name;
 189         char *func2_name;
 190         int len1;
 191         int len2;
 192         int ret = -1;
 193
 194         printk(KERN_CONT "PASSED\n");
 195         pr_info("Testing dynamic ftrace ops #%d: ", cnt);
 196
 197         ftrace_enabled = 1;
 198         reset_counts();
 199
 200         /* Handle PPC64 '.' name */
 201         func1_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 202         func2_name = "*" __stringify(DYN_FTRACE_TEST_NAME2);
 203         len1 = strlen(func1_name);
 204         len2 = strlen(func2_name);
 205
 206         /*
 207          * Probe 1 will trace function 1.
 208          * Probe 2 will trace function 2.
 209          * Probe 3 will trace functions 1 and 2.
 210          */
 211         ftrace_set_filter(&test_probe1, func1_name, len1, 1);
 212         ftrace_set_filter(&test_probe2, func2_name, len2, 1);
 213         ftrace_set_filter(&test_probe3, func1_name, len1, 1);
 214         ftrace_set_filter(&test_probe3, func2_name, len2, 0);
 215
 216         register_ftrace_function(&test_probe1);
 217         register_ftrace_function(&test_probe2);
 218         register_ftrace_function(&test_probe3);
 219         /* First time we are running with main function */
 220         if (cnt > 1) {
 221                 ftrace_init_array_ops(tr, trace_selftest_test_global_func);
 222                 register_ftrace_function(tr->ops);
 223         }
 224
 225         DYN_FTRACE_TEST_NAME();
 226
 227         print_counts();
 228
 229         if (trace_selftest_test_probe1_cnt != 1)
 230                 goto out;
 231         if (trace_selftest_test_probe2_cnt != 0)
 232                 goto out;
 233         if (trace_selftest_test_probe3_cnt != 1)
 234                 goto out;
 235         if (cnt > 1) {
 236                 if (trace_selftest_test_global_cnt == 0)
 237                         goto out;
 238         }
 239
 240         DYN_FTRACE_TEST_NAME2();
 241
 242         print_counts();
 243
 244         if (trace_selftest_test_probe1_cnt != 1)
 245                 goto out;
 246         if (trace_selftest_test_probe2_cnt != 1)
 247                 goto out;
 248         if (trace_selftest_test_probe3_cnt != 2)
 249                 goto out;
 250
 251         /* Add a dynamic probe */
 252         dyn_ops = kzalloc(sizeof(*dyn_ops), GFP_KERNEL);
 253         if (!dyn_ops) {
 254                 printk("MEMORY ERROR ");
 255                 goto out;
 256         }
 257
 258         dyn_ops->func = trace_selftest_test_dyn_func;
 259
 260         register_ftrace_function(dyn_ops);
 261
 262         trace_selftest_test_global_cnt = 0;
 263
 264         DYN_FTRACE_TEST_NAME();
 265
 266         print_counts();
 267
 268         if (trace_selftest_test_probe1_cnt != 2)
 269                 goto out_free;
 270         if (trace_selftest_test_probe2_cnt != 1)
 271                 goto out_free;
 272         if (trace_selftest_test_probe3_cnt != 3)
 273                 goto out_free;
 274         if (cnt > 1) {
 275                 if (trace_selftest_test_global_cnt == 0)
 276                         goto out_free;
 277         }
 278         if (trace_selftest_test_dyn_cnt == 0)
 279                 goto out_free;
 280
 281         DYN_FTRACE_TEST_NAME2();
 282
 283         print_counts();
 284
 285         if (trace_selftest_test_probe1_cnt != 2)
 286                 goto out_free;
 287         if (trace_selftest_test_probe2_cnt != 2)
 288                 goto out_free;
 289         if (trace_selftest_test_probe3_cnt != 4)
 290                 goto out_free;
 291
 292         ret = 0;
 293  out_free:
 294         unregister_ftrace_function(dyn_ops);
 295         kfree(dyn_ops);
 296
 297  out:
 298         /* Purposely unregister in the same order */
 299         unregister_ftrace_function(&test_probe1);
 300         unregister_ftrace_function(&test_probe2);
 301         unregister_ftrace_function(&test_probe3);
 302         if (cnt > 1)
 303                 unregister_ftrace_function(tr->ops);
 304         ftrace_reset_array_ops(tr);
 305
 306         /* Make sure everything is off */
 307         reset_counts();
 308         DYN_FTRACE_TEST_NAME();
 309         DYN_FTRACE_TEST_NAME();
 310
 311         if (trace_selftest_test_probe1_cnt ||
 312             trace_selftest_test_probe2_cnt ||
 313             trace_selftest_test_probe3_cnt ||
 314             trace_selftest_test_global_cnt ||
 315             trace_selftest_test_dyn_cnt)
 316                 ret = -1;
 317
 318         ftrace_enabled = save_ftrace_enabled;
 319
 320         return ret;
 321 }
 322
 323 /* Test dynamic code modification and ftrace filters */
 324 static int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 325                                                   struct trace_array *tr,
 326                                                   int (*func)(void))
 327 {
 328         int save_ftrace_enabled = ftrace_enabled;
 329         unsigned long count;
 330         char *func_name;
 331         int ret;
 332
 333         /* The ftrace test PASSED */
 334         printk(KERN_CONT "PASSED\n");
 335         pr_info("Testing dynamic ftrace: ");
 336
 337         /* enable tracing, and record the filter function */
 338         ftrace_enabled = 1;
 339
 340         /* passed in by parameter to fool gcc from optimizing */
 341         func();
 342
 343         /*
 344          * Some archs *cough*PowerPC*cough* add characters to the
 345          * start of the function names. We simply put a '*' to
 346          * accommodate them.
 347          */
 348         func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 349
 350         /* filter only on our function */
 351         ftrace_set_global_filter(func_name, strlen(func_name), 1);
 352
 353         /* enable tracing */
 354         ret = tracer_init(trace, tr);
 355         if (ret) {
 356                 warn_failed_init_tracer(trace, ret);
 357                 goto out;
 358         }
 359
 360         /* Sleep for a 1/10 of a second */
 361         msleep(100);
 362
 363         /* we should have nothing in the buffer */
 364         ret = trace_test_buffer(&tr->trace_buffer, &count);
 365         if (ret)
 366                 goto out;
 367
 368         if (count) {
 369                 ret = -1;
 370                 printk(KERN_CONT ".. filter did not filter .. ");
 371                 goto out;
 372         }
 373
 374         /* call our function again */
 375         func();
 376
 377         /* sleep again */
 378         msleep(100);
 379
 380         /* stop the tracing. */
 381         tracing_stop();
 382         ftrace_enabled = 0;
 383
 384         /* check the trace buffer */
 385         ret = trace_test_buffer(&tr->trace_buffer, &count);
 386
 387         ftrace_enabled = 1;
 388         tracing_start();
 389
 390         /* we should only have one item */
 391         if (!ret && count != 1) {
 392                 trace->reset(tr);
 393                 printk(KERN_CONT ".. filter failed count=%ld ..", count);
 394                 ret = -1;
 395                 goto out;
 396         }
 397
 398         /* Test the ops with global tracing running */
 399         ret = trace_selftest_ops(tr, 1);
 400         trace->reset(tr);
 401
 402  out:
 403         ftrace_enabled = save_ftrace_enabled;
 404
 405         /* Enable tracing on all functions again */
 406         ftrace_set_global_filter(NULL, 0, 1);
 407
 408         /* Test the ops with global tracing off */
 409         if (!ret)
 410                 ret = trace_selftest_ops(tr, 2);
 411
 412         return ret;
 413 }
 414
 415 static int trace_selftest_recursion_cnt;
 416 static void trace_selftest_test_recursion_func(unsigned long ip,
 417                                                unsigned long pip,
 418                                                struct ftrace_ops *op,
 419                                                struct pt_regs *pt_regs)
 420 {
 421         /*
 422          * This function is registered without the recursion safe flag.
 423          * The ftrace infrastructure should provide the recursion
 424          * protection. If not, this will crash the kernel!
 425          */
 426         if (trace_selftest_recursion_cnt++ > 10)
 427                 return;
 428         DYN_FTRACE_TEST_NAME();
 429 }
 430
 431 static void trace_selftest_test_recursion_safe_func(unsigned long ip,
 432                                                     unsigned long pip,
 433                                                     struct ftrace_ops *op,
 434                                                     struct pt_regs *pt_regs)
 435 {
 436         /*
 437          * We said we would provide our own recursion. By calling
 438          * this function again, we should recurse back into this function
 439          * and count again. But this only happens if the arch supports
 440          * all of ftrace features and nothing else is using the function
 441          * tracing utility.
 442          */
 443         if (trace_selftest_recursion_cnt++)
 444                 return;
 445         DYN_FTRACE_TEST_NAME();
 446 }
 447
 448 static struct ftrace_ops test_rec_probe = {
 449         .func                   = trace_selftest_test_recursion_func,
 450 };
 451
 452 static struct ftrace_ops test_recsafe_probe = {
 453         .func                   = trace_selftest_test_recursion_safe_func,
 454         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
 455 };
 456
 457 static int
 458 trace_selftest_function_recursion(void)
 459 {
 460         int save_ftrace_enabled = ftrace_enabled;
 461         char *func_name;
 462         int len;
 463         int ret;
 464
 465         /* The previous test PASSED */
 466         pr_cont("PASSED\n");
 467         pr_info("Testing ftrace recursion: ");
 468
 469
 470         /* enable tracing, and record the filter function */
 471         ftrace_enabled = 1;
 472
 473         /* Handle PPC64 '.' name */
 474         func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 475         len = strlen(func_name);
 476
 477         ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
 478         if (ret) {
 479                 pr_cont("*Could not set filter* ");
 480                 goto out;
 481         }
 482
 483         ret = register_ftrace_function(&test_rec_probe);
 484         if (ret) {
 485                 pr_cont("*could not register callback* ");
 486                 goto out;
 487         }
 488
 489         DYN_FTRACE_TEST_NAME();
 490
 491         unregister_ftrace_function(&test_rec_probe);
 492
 493         ret = -1;
 494         if (trace_selftest_recursion_cnt != 1) {
 495                 pr_cont("*callback not called once (%d)* ",
 496                         trace_selftest_recursion_cnt);
 497                 goto out;
 498         }
 499
 500         trace_selftest_recursion_cnt = 1;
 501
 502         pr_cont("PASSED\n");
 503         pr_info("Testing ftrace recursion safe: ");
 504
 505         ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
 506         if (ret) {
 507                 pr_cont("*Could not set filter* ");
 508                 goto out;
 509         }
 510
 511         ret = register_ftrace_function(&test_recsafe_probe);
 512         if (ret) {
 513                 pr_cont("*could not register callback* ");
 514                 goto out;
 515         }
 516
 517         DYN_FTRACE_TEST_NAME();
 518
 519         unregister_ftrace_function(&test_recsafe_probe);
 520
 521         ret = -1;
 522         if (trace_selftest_recursion_cnt != 2) {
 523                 pr_cont("*callback not called expected 2 times (%d)* ",
 524                         trace_selftest_recursion_cnt);
 525                 goto out;
 526         }
 527
 528         ret = 0;
 529 out:
 530         ftrace_enabled = save_ftrace_enabled;
 531
 532         return ret;
 533 }
 534 #else
 535 # define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
 536 # define trace_selftest_function_recursion() ({ 0; })
 537 #endif /* CONFIG_DYNAMIC_FTRACE */
 538
 539 static enum {
 540         TRACE_SELFTEST_REGS_START,
 541         TRACE_SELFTEST_REGS_FOUND,
 542         TRACE_SELFTEST_REGS_NOT_FOUND,
 543 } trace_selftest_regs_stat;
 544
 545 static void trace_selftest_test_regs_func(unsigned long ip,
 546                                           unsigned long pip,
 547                                           struct ftrace_ops *op,
 548                                           struct pt_regs *pt_regs)
 549 {
 550         if (pt_regs)
 551                 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
 552         else
 553                 trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
 554 }
 555
 556 static struct ftrace_ops test_regs_probe = {
 557         .func           = trace_selftest_test_regs_func,
 558         .flags          = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_SAVE_REGS,
 559 };
 560
 561 static int
 562 trace_selftest_function_regs(void)
 563 {
 564         int save_ftrace_enabled = ftrace_enabled;
 565         char *func_name;
 566         int len;
 567         int ret;
 568         int supported = 0;
 569
 570 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
 571         supported = 1;
 572 #endif
 573
 574         /* The previous test PASSED */
 575         pr_cont("PASSED\n");
 576         pr_info("Testing ftrace regs%s: ",
 577                 !supported ? "(no arch support)" : "");
 578
 579         /* enable tracing, and record the filter function */
 580         ftrace_enabled = 1;
 581
 582         /* Handle PPC64 '.' name */
 583         func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 584         len = strlen(func_name);
 585
 586         ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
 587         /*
 588          * If DYNAMIC_FTRACE is not set, then we just trace all functions.
 589          * This test really doesn't care.
 590          */
 591         if (ret && ret != -ENODEV) {
 592                 pr_cont("*Could not set filter* ");
 593                 goto out;
 594         }
 595
 596         ret = register_ftrace_function(&test_regs_probe);
 597         /*
 598          * Now if the arch does not support passing regs, then this should
 599          * have failed.
 600          */
 601         if (!supported) {
 602                 if (!ret) {
 603                         pr_cont("*registered save-regs without arch support* ");
 604                         goto out;
 605                 }
 606                 test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
 607                 ret = register_ftrace_function(&test_regs_probe);
 608         }
 609         if (ret) {
 610                 pr_cont("*could not register callback* ");
 611                 goto out;
 612         }
 613
 614
 615         DYN_FTRACE_TEST_NAME();
 616
 617         unregister_ftrace_function(&test_regs_probe);
 618
 619         ret = -1;
 620
 621         switch (trace_selftest_regs_stat) {
 622         case TRACE_SELFTEST_REGS_START:
 623                 pr_cont("*callback never called* ");
 624                 goto out;
 625
 626         case TRACE_SELFTEST_REGS_FOUND:
 627                 if (supported)
 628                         break;
 629                 pr_cont("*callback received regs without arch support* ");
 630                 goto out;
 631
 632         case TRACE_SELFTEST_REGS_NOT_FOUND:
 633                 if (!supported)
 634                         break;
 635                 pr_cont("*callback received NULL regs* ");
 636                 goto out;
 637         }
 638
 639         ret = 0;
 640 out:
 641         ftrace_enabled = save_ftrace_enabled;
 642
 643         return ret;
 644 }
 645
 646 /*
 647  * Simple verification test of ftrace function tracer.
 648  * Enable ftrace, sleep 1/10 second, and then read the trace
 649  * buffer to see if all is in order.
 650  */
 651 __init int
 652 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 653 {
 654         int save_ftrace_enabled = ftrace_enabled;
 655         unsigned long count;
 656         int ret;
 657
 658 #ifdef CONFIG_DYNAMIC_FTRACE
 659         if (ftrace_filter_param) {
 660                 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
 661                 return 0;
 662         }
 663 #endif
 664
 665         /* make sure msleep has been recorded */
 666         msleep(1);
 667
 668         /* start the tracing */
 669         ftrace_enabled = 1;
 670
 671         ret = tracer_init(trace, tr);
 672         if (ret) {
 673                 warn_failed_init_tracer(trace, ret);
 674                 goto out;
 675         }
 676
 677         /* Sleep for a 1/10 of a second */
 678         msleep(100);
 679         /* stop the tracing. */
 680         tracing_stop();
 681         ftrace_enabled = 0;
 682
 683         /* check the trace buffer */
 684         ret = trace_test_buffer(&tr->trace_buffer, &count);
 685
 686         ftrace_enabled = 1;
 687         trace->reset(tr);
 688         tracing_start();
 689
 690         if (!ret && !count) {
 691                 printk(KERN_CONT ".. no entries found ..");
 692                 ret = -1;
 693                 goto out;
 694         }
 695
 696         ret = trace_selftest_startup_dynamic_tracing(trace, tr,
 697                                                      DYN_FTRACE_TEST_NAME);
 698         if (ret)
 699                 goto out;
 700
 701         ret = trace_selftest_function_recursion();
 702         if (ret)
 703                 goto out;
 704
 705         ret = trace_selftest_function_regs();
 706  out:
 707         ftrace_enabled = save_ftrace_enabled;
 708
 709         /* kill ftrace totally if we failed */
 710         if (ret)
 711                 ftrace_kill();
 712
 713         return ret;
 714 }
 715 #endif /* CONFIG_FUNCTION_TRACER */
 716
 717
 718 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 719
 720 /* Maximum number of functions to trace before diagnosing a hang */
 721 #define GRAPH_MAX_FUNC_TEST     100000000
 722
 723 static unsigned int graph_hang_thresh;
 724
 725 /* Wrap the real function entry probe to avoid possible hanging */
 726 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
 727 {
 728         /* This is harmlessly racy, we want to approximately detect a hang */
 729         if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
 730                 ftrace_graph_stop();
 731                 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
 732                 if (ftrace_dump_on_oops) {
 733                         ftrace_dump(DUMP_ALL);
 734                         /* ftrace_dump() disables tracing */
 735                         tracing_on();
 736                 }
 737                 return 0;
 738         }
 739
 740         return trace_graph_entry(trace);
 741 }
 742
 743 /*
 744  * Pretty much the same than for the function tracer from which the selftest
 745  * has been borrowed.
 746  */
 747 __init int
 748 trace_selftest_startup_function_graph(struct tracer *trace,
 749                                         struct trace_array *tr)
 750 {
 751         int ret;
 752         unsigned long count;
 753
 754 #ifdef CONFIG_DYNAMIC_FTRACE
 755         if (ftrace_filter_param) {
 756                 printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
 757                 return 0;
 758         }
 759 #endif
 760
 761         /*
 762          * Simulate the init() callback but we attach a watchdog callback
 763          * to detect and recover from possible hangs
 764          */
 765         tracing_reset_online_cpus(&tr->trace_buffer);
 766         set_graph_array(tr);
 767         ret = register_ftrace_graph(&trace_graph_return,
 768                                     &trace_graph_entry_watchdog);
 769         if (ret) {
 770                 warn_failed_init_tracer(trace, ret);
 771                 goto out;
 772         }
 773         tracing_start_cmdline_record();
 774
 775         /* Sleep for a 1/10 of a second */
 776         msleep(100);
 777
 778         /* Have we just recovered from a hang? */
 779         if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
 780                 tracing_selftest_disabled = true;
 781                 ret = -1;
 782                 goto out;
 783         }
 784
 785         tracing_stop();
 786
 787         /* check the trace buffer */
 788         ret = trace_test_buffer(&tr->trace_buffer, &count);
 789
 790         trace->reset(tr);
 791         tracing_start();
 792
 793         if (!ret && !count) {
 794                 printk(KERN_CONT ".. no entries found ..");
 795                 ret = -1;
 796                 goto out;
 797         }
 798
 799         /* Don't test dynamic tracing, the function tracer already did */
 800
 801 out:
 802         /* Stop it if we failed */
 803         if (ret)
 804                 ftrace_graph_stop();
 805
 806         return ret;
 807 }
 808 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 809
 810
 811 #ifdef CONFIG_IRQSOFF_TRACER
 812 int
 813 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
 814 {
 815         unsigned long save_max = tr->max_latency;
 816         unsigned long count;
 817         int ret;
 818
 819         /* start the tracing */
 820         ret = tracer_init(trace, tr);
 821         if (ret) {
 822                 warn_failed_init_tracer(trace, ret);
 823                 return ret;
 824         }
 825
 826         /* reset the max latency */
 827         tr->max_latency = 0;
 828         /* disable interrupts for a bit */
 829         local_irq_disable();
 830         udelay(100);
 831         local_irq_enable();
 832
 833         /*
 834          * Stop the tracer to avoid a warning subsequent
 835          * to buffer flipping failure because tracing_stop()
 836          * disables the tr and max buffers, making flipping impossible
 837          * in case of parallels max irqs off latencies.
 838          */
 839         trace->stop(tr);
 840         /* stop the tracing. */
 841         tracing_stop();
 842         /* check both trace buffers */
 843         ret = trace_test_buffer(&tr->trace_buffer, NULL);
 844         if (!ret)
 845                 ret = trace_test_buffer(&tr->max_buffer, &count);
 846         trace->reset(tr);
 847         tracing_start();
 848
 849         if (!ret && !count) {
 850                 printk(KERN_CONT ".. no entries found ..");
 851                 ret = -1;
 852         }
 853
 854         tr->max_latency = save_max;
 855
 856         return ret;
 857 }
 858 #endif /* CONFIG_IRQSOFF_TRACER */
 859
 860 #ifdef CONFIG_PREEMPT_TRACER
 861 int
 862 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
 863 {
 864         unsigned long save_max = tr->max_latency;
 865         unsigned long count;
 866         int ret;
 867
 868         /*
 869          * Now that the big kernel lock is no longer preemptable,
 870          * and this is called with the BKL held, it will always
 871          * fail. If preemption is already disabled, simply
 872          * pass the test. When the BKL is removed, or becomes
 873          * preemptible again, we will once again test this,
 874          * so keep it in.
 875          */
 876         if (preempt_count()) {
 877                 printk(KERN_CONT "can not test ... force ");
 878                 return 0;
 879         }
 880
 881         /* start the tracing */
 882         ret = tracer_init(trace, tr);
 883         if (ret) {
 884                 warn_failed_init_tracer(trace, ret);
 885                 return ret;
 886         }
 887
 888         /* reset the max latency */
 889         tr->max_latency = 0;
 890         /* disable preemption for a bit */
 891         preempt_disable();
 892         udelay(100);
 893         preempt_enable();
 894
 895         /*
 896          * Stop the tracer to avoid a warning subsequent
 897          * to buffer flipping failure because tracing_stop()
 898          * disables the tr and max buffers, making flipping impossible
 899          * in case of parallels max preempt off latencies.
 900          */
 901         trace->stop(tr);
 902         /* stop the tracing. */
 903         tracing_stop();
 904         /* check both trace buffers */
 905         ret = trace_test_buffer(&tr->trace_buffer, NULL);
 906         if (!ret)
 907                 ret = trace_test_buffer(&tr->max_buffer, &count);
 908         trace->reset(tr);
 909         tracing_start();
 910
 911         if (!ret && !count) {
 912                 printk(KERN_CONT ".. no entries found ..");
 913                 ret = -1;
 914         }
 915
 916         tr->max_latency = save_max;
 917
 918         return ret;
 919 }
 920 #endif /* CONFIG_PREEMPT_TRACER */
 921
 922 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
 923 int
 924 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
 925 {
 926         unsigned long save_max = tr->max_latency;
 927         unsigned long count;
 928         int ret;
 929
 930         /*
 931          * Now that the big kernel lock is no longer preemptable,
 932          * and this is called with the BKL held, it will always
 933          * fail. If preemption is already disabled, simply
 934          * pass the test. When the BKL is removed, or becomes
 935          * preemptible again, we will once again test this,
 936          * so keep it in.
 937          */
 938         if (preempt_count()) {
 939                 printk(KERN_CONT "can not test ... force ");
 940                 return 0;
 941         }
 942
 943         /* start the tracing */
 944         ret = tracer_init(trace, tr);
 945         if (ret) {
 946                 warn_failed_init_tracer(trace, ret);
 947                 goto out_no_start;
 948         }
 949
 950         /* reset the max latency */
 951         tr->max_latency = 0;
 952
 953         /* disable preemption and interrupts for a bit */
 954         preempt_disable();
 955         local_irq_disable();
 956         udelay(100);
 957         preempt_enable();
 958         /* reverse the order of preempt vs irqs */
 959         local_irq_enable();
 960
 961         /*
 962          * Stop the tracer to avoid a warning subsequent
 963          * to buffer flipping failure because tracing_stop()
 964          * disables the tr and max buffers, making flipping impossible
 965          * in case of parallels max irqs/preempt off latencies.
 966          */
 967         trace->stop(tr);
 968         /* stop the tracing. */
 969         tracing_stop();
 970         /* check both trace buffers */
 971         ret = trace_test_buffer(&tr->trace_buffer, NULL);
 972         if (ret)
 973                 goto out;
 974
 975         ret = trace_test_buffer(&tr->max_buffer, &count);
 976         if (ret)
 977                 goto out;
 978
 979         if (!ret && !count) {
 980                 printk(KERN_CONT ".. no entries found ..");
 981                 ret = -1;
 982                 goto out;
 983         }
 984
 985         /* do the test by disabling interrupts first this time */
 986         tr->max_latency = 0;
 987         tracing_start();
 988         trace->start(tr);
 989
 990         preempt_disable();
 991         local_irq_disable();
 992         udelay(100);
 993         preempt_enable();
 994         /* reverse the order of preempt vs irqs */
 995         local_irq_enable();
 996
 997         trace->stop(tr);
 998         /* stop the tracing. */
 999         tracing_stop();
1000         /* check both trace buffers */
1001         ret = trace_test_buffer(&tr->trace_buffer, NULL);
1002         if (ret)
1003                 goto out;
1004
1005         ret = trace_test_buffer(&tr->max_buffer, &count);
1006
1007         if (!ret && !count) {
1008                 printk(KERN_CONT ".. no entries found ..");
1009                 ret = -1;
1010                 goto out;
1011         }
1012
1013 out:
1014         tracing_start();
1015 out_no_start:
1016         trace->reset(tr);
1017         tr->max_latency = save_max;
1018
1019         return ret;
1020 }
1021 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
1022
1023 #ifdef CONFIG_NOP_TRACER
1024 int
1025 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
1026 {
1027         /* What could possibly go wrong? */
1028         return 0;
1029 }
1030 #endif
1031
1032 #ifdef CONFIG_SCHED_TRACER
1033
1034 struct wakeup_test_data {
1035         struct completion       is_ready;
1036         int                     go;
1037 };
1038
1039 static int trace_wakeup_test_thread(void *data)
1040 {
1041         /* Make this a -deadline thread */
1042         static const struct sched_attr attr = {
1043                 .sched_policy = SCHED_DEADLINE,
1044                 .sched_runtime = 100000ULL,
1045                 .sched_deadline = 10000000ULL,
1046                 .sched_period = 10000000ULL
1047         };
1048         struct wakeup_test_data *x = data;
1049
1050         sched_setattr(current, &attr);
1051
1052         /* Make it know we have a new prio */
1053         complete(&x->is_ready);
1054
1055         /* now go to sleep and let the test wake us up */
1056         set_current_state(TASK_INTERRUPTIBLE);
1057         while (!x->go) {
1058                 schedule();
1059                 set_current_state(TASK_INTERRUPTIBLE);
1060         }
1061
1062         complete(&x->is_ready);
1063
1064         set_current_state(TASK_INTERRUPTIBLE);
1065
1066         /* we are awake, now wait to disappear */
1067         while (!kthread_should_stop()) {
1068                 schedule();
1069                 set_current_state(TASK_INTERRUPTIBLE);
1070         }
1071
1072         __set_current_state(TASK_RUNNING);
1073
1074         return 0;
1075 }
1076 int
1077 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
1078 {
1079         unsigned long save_max = tr->max_latency;
1080         struct task_struct *p;
1081         struct wakeup_test_data data;
1082         unsigned long count;
1083         int ret;
1084
1085         memset(&data, 0, sizeof(data));
1086
1087         init_completion(&data.is_ready);
1088
1089         /* create a -deadline thread */
1090         p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
1091         if (IS_ERR(p)) {
1092                 printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
1093                 return -1;
1094         }
1095
1096         /* make sure the thread is running at -deadline policy */
1097         wait_for_completion(&data.is_ready);
1098
1099         /* start the tracing */
1100         ret = tracer_init(trace, tr);
1101         if (ret) {
1102                 warn_failed_init_tracer(trace, ret);
1103                 return ret;
1104         }
1105
1106         /* reset the max latency */
1107         tr->max_latency = 0;
1108
1109         while (p->on_rq) {
1110                 /*
1111                  * Sleep to make sure the -deadline thread is asleep too.
1112                  * On virtual machines we can't rely on timings,
1113                  * but we want to make sure this test still works.
1114                  */
1115                 msleep(100);
1116         }
1117
1118         init_completion(&data.is_ready);
1119
1120         data.go = 1;
1121         /* memory barrier is in the wake_up_process() */
1122
1123         wake_up_process(p);
1124
1125         /* Wait for the task to wake up */
1126         wait_for_completion(&data.is_ready);
1127
1128         /* stop the tracing. */
1129         tracing_stop();
1130         /* check both trace buffers */
1131         ret = trace_test_buffer(&tr->trace_buffer, NULL);
1132         if (!ret)
1133                 ret = trace_test_buffer(&tr->max_buffer, &count);
1134
1135
1136         trace->reset(tr);
1137         tracing_start();
1138
1139         tr->max_latency = save_max;
1140
1141         /* kill the thread */
1142         kthread_stop(p);
1143
1144         if (!ret && !count) {
1145                 printk(KERN_CONT ".. no entries found ..");
1146                 ret = -1;
1147         }
1148
1149         return ret;
1150 }
1151 #endif /* CONFIG_SCHED_TRACER */
1152
1153 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
1154 int
1155 trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
1156 {
1157         unsigned long count;
1158         int ret;
1159
1160         /* start the tracing */
1161         ret = tracer_init(trace, tr);
1162         if (ret) {
1163                 warn_failed_init_tracer(trace, ret);
1164                 return ret;
1165         }
1166
1167         /* Sleep for a 1/10 of a second */
1168         msleep(100);
1169         /* stop the tracing. */
1170         tracing_stop();
1171         /* check the trace buffer */
1172         ret = trace_test_buffer(&tr->trace_buffer, &count);
1173         trace->reset(tr);
1174         tracing_start();
1175
1176         if (!ret && !count) {
1177                 printk(KERN_CONT ".. no entries found ..");
1178                 ret = -1;
1179         }
1180
1181         return ret;
1182 }
1183 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
1184
1185 #ifdef CONFIG_BRANCH_TRACER
1186 int
1187 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
1188 {
1189         unsigned long count;
1190         int ret;
1191
1192         /* start the tracing */
1193         ret = tracer_init(trace, tr);
1194         if (ret) {
1195                 warn_failed_init_tracer(trace, ret);
1196                 return ret;
1197         }
1198
1199         /* Sleep for a 1/10 of a second */
1200         msleep(100);
1201         /* stop the tracing. */
1202         tracing_stop();
1203         /* check the trace buffer */
1204         ret = trace_test_buffer(&tr->trace_buffer, &count);
1205         trace->reset(tr);
1206         tracing_start();
1207
1208         if (!ret && !count) {
1209                 printk(KERN_CONT ".. no entries found ..");
1210                 ret = -1;
1211         }
1212
1213         return ret;
1214 }
1215 #endif /* CONFIG_BRANCH_TRACER */
1216