kernel/trace/trace_selftest.c

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