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 10static 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 26static 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 */ 63static 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 97static 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 106static int trace_selftest_test_probe1_cnt; 107static 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 115static int trace_selftest_test_probe2_cnt; 116static 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 124static int trace_selftest_test_probe3_cnt; 125static 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 133static int trace_selftest_test_global_cnt; 134static 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 142static int trace_selftest_test_dyn_cnt; 143static 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 151static struct ftrace_ops test_probe1 = { 152 .func = trace_selftest_test_probe1_func, 153}; 154 155static struct ftrace_ops test_probe2 = { 156 .func = trace_selftest_test_probe2_func, 157}; 158 159static struct ftrace_ops test_probe3 = { 160 .func = trace_selftest_test_probe3_func, 161}; 162 163static 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 173static 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 182static 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 */ 356static 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 447static int trace_selftest_recursion_cnt; 448static 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 463static 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 480static struct ftrace_ops test_rec_probe = { 481 .func = trace_selftest_test_recursion_func, 482 .flags = FTRACE_OPS_FL_RECURSION, 483}; 484 485static struct ftrace_ops test_recsafe_probe = { 486 .func = trace_selftest_test_recursion_safe_func, 487}; 488 489static int 490trace_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; 566out: 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 576static enum { 577 TRACE_SELFTEST_REGS_START, 578 TRACE_SELFTEST_REGS_FOUND, 579 TRACE_SELFTEST_REGS_NOT_FOUND, 580} trace_selftest_regs_stat; 581 582static 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 595static struct ftrace_ops test_regs_probe = { 596 .func = trace_selftest_test_regs_func, 597 .flags = FTRACE_OPS_FL_SAVE_REGS, 598}; 599 600static int 601trace_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; 679out: 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 691trace_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 762static unsigned int graph_hang_thresh; 763 764/* Wrap the real function entry probe to avoid possible hanging */ 765static 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_enabled()) { 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 782static 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 788static struct ftrace_ops direct; 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 796trace_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 /* 852 * These tests can take some time to run. Make sure on non PREEMPT 853 * kernels, we do not trigger the softlockup detector. 854 */ 855 cond_resched(); 856 857 tracing_reset_online_cpus(&tr->array_buffer); 858 set_graph_array(tr); 859 860 /* 861 * Some archs *cough*PowerPC*cough* add characters to the 862 * start of the function names. We simply put a '*' to 863 * accommodate them. 864 */ 865 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME); 866 ftrace_set_global_filter(func_name, strlen(func_name), 1); 867 868 /* 869 * Register direct function together with graph tracer 870 * and make sure we get graph trace. 871 */ 872 ftrace_set_filter_ip(&direct, (unsigned long)DYN_FTRACE_TEST_NAME, 0, 0); 873 ret = register_ftrace_direct(&direct, 874 (unsigned long)ftrace_stub_direct_tramp); 875 if (ret) 876 goto out; 877 878 cond_resched(); 879 880 ret = register_ftrace_graph(&fgraph_ops); 881 if (ret) { 882 warn_failed_init_tracer(trace, ret); 883 goto out; 884 } 885 886 DYN_FTRACE_TEST_NAME(); 887 888 count = 0; 889 890 tracing_stop(); 891 /* check the trace buffer */ 892 ret = trace_test_buffer(&tr->array_buffer, &count); 893 894 unregister_ftrace_graph(&fgraph_ops); 895 896 ret = unregister_ftrace_direct(&direct, 897 (unsigned long)ftrace_stub_direct_tramp, 898 true); 899 if (ret) 900 goto out; 901 902 cond_resched(); 903 904 tracing_start(); 905 906 if (!ret && !count) { 907 ret = -1; 908 goto out; 909 } 910 911 /* Enable tracing on all functions again */ 912 ftrace_set_global_filter(NULL, 0, 1); 913#endif 914 915 /* Don't test dynamic tracing, the function tracer already did */ 916out: 917 /* Stop it if we failed */ 918 if (ret) 919 ftrace_graph_stop(); 920 921 return ret; 922} 923#endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 924 925 926#ifdef CONFIG_IRQSOFF_TRACER 927int 928trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr) 929{ 930 unsigned long save_max = tr->max_latency; 931 unsigned long count; 932 int ret; 933 934 /* start the tracing */ 935 ret = tracer_init(trace, tr); 936 if (ret) { 937 warn_failed_init_tracer(trace, ret); 938 return ret; 939 } 940 941 /* reset the max latency */ 942 tr->max_latency = 0; 943 /* disable interrupts for a bit */ 944 local_irq_disable(); 945 udelay(100); 946 local_irq_enable(); 947 948 /* 949 * Stop the tracer to avoid a warning subsequent 950 * to buffer flipping failure because tracing_stop() 951 * disables the tr and max buffers, making flipping impossible 952 * in case of parallels max irqs off latencies. 953 */ 954 trace->stop(tr); 955 /* stop the tracing. */ 956 tracing_stop(); 957 /* check both trace buffers */ 958 ret = trace_test_buffer(&tr->array_buffer, NULL); 959 if (!ret) 960 ret = trace_test_buffer(&tr->max_buffer, &count); 961 trace->reset(tr); 962 tracing_start(); 963 964 if (!ret && !count) { 965 printk(KERN_CONT ".. no entries found .."); 966 ret = -1; 967 } 968 969 tr->max_latency = save_max; 970 971 return ret; 972} 973#endif /* CONFIG_IRQSOFF_TRACER */ 974 975#ifdef CONFIG_PREEMPT_TRACER 976int 977trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr) 978{ 979 unsigned long save_max = tr->max_latency; 980 unsigned long count; 981 int ret; 982 983 /* 984 * Now that the big kernel lock is no longer preemptible, 985 * and this is called with the BKL held, it will always 986 * fail. If preemption is already disabled, simply 987 * pass the test. When the BKL is removed, or becomes 988 * preemptible again, we will once again test this, 989 * so keep it in. 990 */ 991 if (preempt_count()) { 992 printk(KERN_CONT "can not test ... force "); 993 return 0; 994 } 995 996 /* start the tracing */ 997 ret = tracer_init(trace, tr); 998 if (ret) { 999 warn_failed_init_tracer(trace, ret); 1000 return ret; 1001 } 1002 1003 /* reset the max latency */ 1004 tr->max_latency = 0; 1005 /* disable preemption for a bit */ 1006 preempt_disable(); 1007 udelay(100); 1008 preempt_enable(); 1009 1010 /* 1011 * Stop the tracer to avoid a warning subsequent 1012 * to buffer flipping failure because tracing_stop() 1013 * disables the tr and max buffers, making flipping impossible 1014 * in case of parallels max preempt off latencies. 1015 */ 1016 trace->stop(tr); 1017 /* stop the tracing. */ 1018 tracing_stop(); 1019 /* check both trace buffers */ 1020 ret = trace_test_buffer(&tr->array_buffer, NULL); 1021 if (!ret) 1022 ret = trace_test_buffer(&tr->max_buffer, &count); 1023 trace->reset(tr); 1024 tracing_start(); 1025 1026 if (!ret && !count) { 1027 printk(KERN_CONT ".. no entries found .."); 1028 ret = -1; 1029 } 1030 1031 tr->max_latency = save_max; 1032 1033 return ret; 1034} 1035#endif /* CONFIG_PREEMPT_TRACER */ 1036 1037#if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER) 1038int 1039trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr) 1040{ 1041 unsigned long save_max = tr->max_latency; 1042 unsigned long count; 1043 int ret; 1044 1045 /* 1046 * Now that the big kernel lock is no longer preemptible, 1047 * and this is called with the BKL held, it will always 1048 * fail. If preemption is already disabled, simply 1049 * pass the test. When the BKL is removed, or becomes 1050 * preemptible again, we will once again test this, 1051 * so keep it in. 1052 */ 1053 if (preempt_count()) { 1054 printk(KERN_CONT "can not test ... force "); 1055 return 0; 1056 } 1057 1058 /* start the tracing */ 1059 ret = tracer_init(trace, tr); 1060 if (ret) { 1061 warn_failed_init_tracer(trace, ret); 1062 goto out_no_start; 1063 } 1064 1065 /* reset the max latency */ 1066 tr->max_latency = 0; 1067 1068 /* disable preemption and interrupts for a bit */ 1069 preempt_disable(); 1070 local_irq_disable(); 1071 udelay(100); 1072 preempt_enable(); 1073 /* reverse the order of preempt vs irqs */ 1074 local_irq_enable(); 1075 1076 /* 1077 * Stop the tracer to avoid a warning subsequent 1078 * to buffer flipping failure because tracing_stop() 1079 * disables the tr and max buffers, making flipping impossible 1080 * in case of parallels max irqs/preempt off latencies. 1081 */ 1082 trace->stop(tr); 1083 /* stop the tracing. */ 1084 tracing_stop(); 1085 /* check both trace buffers */ 1086 ret = trace_test_buffer(&tr->array_buffer, NULL); 1087 if (ret) 1088 goto out; 1089 1090 ret = trace_test_buffer(&tr->max_buffer, &count); 1091 if (ret) 1092 goto out; 1093 1094 if (!ret && !count) { 1095 printk(KERN_CONT ".. no entries found .."); 1096 ret = -1; 1097 goto out; 1098 } 1099 1100 /* do the test by disabling interrupts first this time */ 1101 tr->max_latency = 0; 1102 tracing_start(); 1103 trace->start(tr); 1104 1105 preempt_disable(); 1106 local_irq_disable(); 1107 udelay(100); 1108 preempt_enable(); 1109 /* reverse the order of preempt vs irqs */ 1110 local_irq_enable(); 1111 1112 trace->stop(tr); 1113 /* stop the tracing. */ 1114 tracing_stop(); 1115 /* check both trace buffers */ 1116 ret = trace_test_buffer(&tr->array_buffer, NULL); 1117 if (ret) 1118 goto out; 1119 1120 ret = trace_test_buffer(&tr->max_buffer, &count); 1121 1122 if (!ret && !count) { 1123 printk(KERN_CONT ".. no entries found .."); 1124 ret = -1; 1125 goto out; 1126 } 1127 1128out: 1129 tracing_start(); 1130out_no_start: 1131 trace->reset(tr); 1132 tr->max_latency = save_max; 1133 1134 return ret; 1135} 1136#endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */ 1137 1138#ifdef CONFIG_NOP_TRACER 1139int 1140trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr) 1141{ 1142 /* What could possibly go wrong? */ 1143 return 0; 1144} 1145#endif 1146 1147#ifdef CONFIG_SCHED_TRACER 1148 1149struct wakeup_test_data { 1150 struct completion is_ready; 1151 int go; 1152}; 1153 1154static int trace_wakeup_test_thread(void *data) 1155{ 1156 /* Make this a -deadline thread */ 1157 static const struct sched_attr attr = { 1158 .sched_policy = SCHED_DEADLINE, 1159 .sched_runtime = 100000ULL, 1160 .sched_deadline = 10000000ULL, 1161 .sched_period = 10000000ULL 1162 }; 1163 struct wakeup_test_data *x = data; 1164 1165 sched_setattr(current, &attr); 1166 1167 /* Make it know we have a new prio */ 1168 complete(&x->is_ready); 1169 1170 /* now go to sleep and let the test wake us up */ 1171 set_current_state(TASK_INTERRUPTIBLE); 1172 while (!x->go) { 1173 schedule(); 1174 set_current_state(TASK_INTERRUPTIBLE); 1175 } 1176 1177 complete(&x->is_ready); 1178 1179 set_current_state(TASK_INTERRUPTIBLE); 1180 1181 /* we are awake, now wait to disappear */ 1182 while (!kthread_should_stop()) { 1183 schedule(); 1184 set_current_state(TASK_INTERRUPTIBLE); 1185 } 1186 1187 __set_current_state(TASK_RUNNING); 1188 1189 return 0; 1190} 1191int 1192trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr) 1193{ 1194 unsigned long save_max = tr->max_latency; 1195 struct task_struct *p; 1196 struct wakeup_test_data data; 1197 unsigned long count; 1198 int ret; 1199 1200 memset(&data, 0, sizeof(data)); 1201 1202 init_completion(&data.is_ready); 1203 1204 /* create a -deadline thread */ 1205 p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test"); 1206 if (IS_ERR(p)) { 1207 printk(KERN_CONT "Failed to create ftrace wakeup test thread "); 1208 return -1; 1209 } 1210 1211 /* make sure the thread is running at -deadline policy */ 1212 wait_for_completion(&data.is_ready); 1213 1214 /* start the tracing */ 1215 ret = tracer_init(trace, tr); 1216 if (ret) { 1217 warn_failed_init_tracer(trace, ret); 1218 return ret; 1219 } 1220 1221 /* reset the max latency */ 1222 tr->max_latency = 0; 1223 1224 while (p->on_rq) { 1225 /* 1226 * Sleep to make sure the -deadline thread is asleep too. 1227 * On virtual machines we can't rely on timings, 1228 * but we want to make sure this test still works. 1229 */ 1230 msleep(100); 1231 } 1232 1233 init_completion(&data.is_ready); 1234 1235 data.go = 1; 1236 /* memory barrier is in the wake_up_process() */ 1237 1238 wake_up_process(p); 1239 1240 /* Wait for the task to wake up */ 1241 wait_for_completion(&data.is_ready); 1242 1243 /* stop the tracing. */ 1244 tracing_stop(); 1245 /* check both trace buffers */ 1246 ret = trace_test_buffer(&tr->array_buffer, NULL); 1247 if (!ret) 1248 ret = trace_test_buffer(&tr->max_buffer, &count); 1249 1250 1251 trace->reset(tr); 1252 tracing_start(); 1253 1254 tr->max_latency = save_max; 1255 1256 /* kill the thread */ 1257 kthread_stop(p); 1258 1259 if (!ret && !count) { 1260 printk(KERN_CONT ".. no entries found .."); 1261 ret = -1; 1262 } 1263 1264 return ret; 1265} 1266#endif /* CONFIG_SCHED_TRACER */ 1267 1268#ifdef CONFIG_BRANCH_TRACER 1269int 1270trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr) 1271{ 1272 unsigned long count; 1273 int ret; 1274 1275 /* start the tracing */ 1276 ret = tracer_init(trace, tr); 1277 if (ret) { 1278 warn_failed_init_tracer(trace, ret); 1279 return ret; 1280 } 1281 1282 /* Sleep for a 1/10 of a second */ 1283 msleep(100); 1284 /* stop the tracing. */ 1285 tracing_stop(); 1286 /* check the trace buffer */ 1287 ret = trace_test_buffer(&tr->array_buffer, &count); 1288 trace->reset(tr); 1289 tracing_start(); 1290 1291 if (!ret && !count) { 1292 printk(KERN_CONT ".. no entries found .."); 1293 ret = -1; 1294 } 1295 1296 return ret; 1297} 1298#endif /* CONFIG_BRANCH_TRACER */ 1299 1300