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 #ifdef CONFIG_DYNAMIC_FTRACE 760 761 #define CHAR_NUMBER 123 762 #define SHORT_NUMBER 12345 763 #define WORD_NUMBER 1234567890 764 #define LONG_NUMBER 1234567890123456789LL 765 #define ERRSTR_BUFLEN 128 766 767 struct fgraph_fixture { 768 struct fgraph_ops gops; 769 int store_size; 770 const char *store_type_name; 771 char error_str_buf[ERRSTR_BUFLEN]; 772 char *error_str; 773 }; 774 775 static __init int store_entry(struct ftrace_graph_ent *trace, 776 struct fgraph_ops *gops) 777 { 778 struct fgraph_fixture *fixture = container_of(gops, struct fgraph_fixture, gops); 779 const char *type = fixture->store_type_name; 780 int size = fixture->store_size; 781 void *p; 782 783 p = fgraph_reserve_data(gops->idx, size); 784 if (!p) { 785 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN, 786 "Failed to reserve %s\n", type); 787 return 0; 788 } 789 790 switch (size) { 791 case 1: 792 *(char *)p = CHAR_NUMBER; 793 break; 794 case 2: 795 *(short *)p = SHORT_NUMBER; 796 break; 797 case 4: 798 *(int *)p = WORD_NUMBER; 799 break; 800 case 8: 801 *(long long *)p = LONG_NUMBER; 802 break; 803 } 804 805 return 1; 806 } 807 808 static __init void store_return(struct ftrace_graph_ret *trace, 809 struct fgraph_ops *gops) 810 { 811 struct fgraph_fixture *fixture = container_of(gops, struct fgraph_fixture, gops); 812 const char *type = fixture->store_type_name; 813 long long expect = 0; 814 long long found = -1; 815 int size; 816 char *p; 817 818 p = fgraph_retrieve_data(gops->idx, &size); 819 if (!p) { 820 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN, 821 "Failed to retrieve %s\n", type); 822 return; 823 } 824 if (fixture->store_size > size) { 825 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN, 826 "Retrieved size %d is smaller than expected %d\n", 827 size, (int)fixture->store_size); 828 return; 829 } 830 831 switch (fixture->store_size) { 832 case 1: 833 expect = CHAR_NUMBER; 834 found = *(char *)p; 835 break; 836 case 2: 837 expect = SHORT_NUMBER; 838 found = *(short *)p; 839 break; 840 case 4: 841 expect = WORD_NUMBER; 842 found = *(int *)p; 843 break; 844 case 8: 845 expect = LONG_NUMBER; 846 found = *(long long *)p; 847 break; 848 } 849 850 if (found != expect) { 851 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN, 852 "%s returned not %lld but %lld\n", type, expect, found); 853 return; 854 } 855 fixture->error_str = NULL; 856 } 857 858 static int __init init_fgraph_fixture(struct fgraph_fixture *fixture) 859 { 860 char *func_name; 861 int len; 862 863 snprintf(fixture->error_str_buf, ERRSTR_BUFLEN, 864 "Failed to execute storage %s\n", fixture->store_type_name); 865 fixture->error_str = fixture->error_str_buf; 866 867 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME); 868 len = strlen(func_name); 869 870 return ftrace_set_filter(&fixture->gops.ops, func_name, len, 1); 871 } 872 873 /* Test fgraph storage for each size */ 874 static int __init test_graph_storage_single(struct fgraph_fixture *fixture) 875 { 876 int size = fixture->store_size; 877 int ret; 878 879 pr_cont("PASSED\n"); 880 pr_info("Testing fgraph storage of %d byte%s: ", size, str_plural(size)); 881 882 ret = init_fgraph_fixture(fixture); 883 if (ret && ret != -ENODEV) { 884 pr_cont("*Could not set filter* "); 885 return -1; 886 } 887 888 ret = register_ftrace_graph(&fixture->gops); 889 if (ret) { 890 pr_warn("Failed to init store_bytes fgraph tracing\n"); 891 return -1; 892 } 893 894 DYN_FTRACE_TEST_NAME(); 895 896 unregister_ftrace_graph(&fixture->gops); 897 898 if (fixture->error_str) { 899 pr_cont("*** %s ***", fixture->error_str); 900 return -1; 901 } 902 903 return 0; 904 } 905 906 static struct fgraph_fixture store_bytes[4] __initdata = { 907 [0] = { 908 .gops = { 909 .entryfunc = store_entry, 910 .retfunc = store_return, 911 }, 912 .store_size = 1, 913 .store_type_name = "byte", 914 }, 915 [1] = { 916 .gops = { 917 .entryfunc = store_entry, 918 .retfunc = store_return, 919 }, 920 .store_size = 2, 921 .store_type_name = "short", 922 }, 923 [2] = { 924 .gops = { 925 .entryfunc = store_entry, 926 .retfunc = store_return, 927 }, 928 .store_size = 4, 929 .store_type_name = "word", 930 }, 931 [3] = { 932 .gops = { 933 .entryfunc = store_entry, 934 .retfunc = store_return, 935 }, 936 .store_size = 8, 937 .store_type_name = "long long", 938 }, 939 }; 940 941 static __init int test_graph_storage_multi(void) 942 { 943 struct fgraph_fixture *fixture; 944 bool printed = false; 945 int i, ret; 946 947 pr_cont("PASSED\n"); 948 pr_info("Testing multiple fgraph storage on a function: "); 949 950 for (i = 0; i < ARRAY_SIZE(store_bytes); i++) { 951 fixture = &store_bytes[i]; 952 ret = init_fgraph_fixture(fixture); 953 if (ret && ret != -ENODEV) { 954 pr_cont("*Could not set filter* "); 955 printed = true; 956 goto out; 957 } 958 959 ret = register_ftrace_graph(&fixture->gops); 960 if (ret) { 961 pr_warn("Failed to init store_bytes fgraph tracing\n"); 962 printed = true; 963 goto out; 964 } 965 } 966 967 DYN_FTRACE_TEST_NAME(); 968 out: 969 while (--i >= 0) { 970 fixture = &store_bytes[i]; 971 unregister_ftrace_graph(&fixture->gops); 972 973 if (fixture->error_str && !printed) { 974 pr_cont("*** %s ***", fixture->error_str); 975 printed = true; 976 } 977 } 978 return printed ? -1 : 0; 979 } 980 981 /* Test the storage passed across function_graph entry and return */ 982 static __init int test_graph_storage(void) 983 { 984 int ret; 985 986 ret = test_graph_storage_single(&store_bytes[0]); 987 if (ret) 988 return ret; 989 ret = test_graph_storage_single(&store_bytes[1]); 990 if (ret) 991 return ret; 992 ret = test_graph_storage_single(&store_bytes[2]); 993 if (ret) 994 return ret; 995 ret = test_graph_storage_single(&store_bytes[3]); 996 if (ret) 997 return ret; 998 ret = test_graph_storage_multi(); 999 if (ret) 1000 return ret; 1001 return 0; 1002 } 1003 #else 1004 static inline int test_graph_storage(void) { return 0; } 1005 #endif /* CONFIG_DYNAMIC_FTRACE */ 1006 1007 /* Maximum number of functions to trace before diagnosing a hang */ 1008 #define GRAPH_MAX_FUNC_TEST 100000000 1009 1010 static unsigned int graph_hang_thresh; 1011 1012 /* Wrap the real function entry probe to avoid possible hanging */ 1013 static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace, 1014 struct fgraph_ops *gops) 1015 { 1016 /* This is harmlessly racy, we want to approximately detect a hang */ 1017 if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) { 1018 ftrace_graph_stop(); 1019 printk(KERN_WARNING "BUG: Function graph tracer hang!\n"); 1020 if (ftrace_dump_on_oops_enabled()) { 1021 ftrace_dump(DUMP_ALL); 1022 /* ftrace_dump() disables tracing */ 1023 tracing_on(); 1024 } 1025 return 0; 1026 } 1027 1028 return trace_graph_entry(trace, gops); 1029 } 1030 1031 static struct fgraph_ops fgraph_ops __initdata = { 1032 .entryfunc = &trace_graph_entry_watchdog, 1033 .retfunc = &trace_graph_return, 1034 }; 1035 1036 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS 1037 static struct ftrace_ops direct; 1038 #endif 1039 1040 /* 1041 * Pretty much the same than for the function tracer from which the selftest 1042 * has been borrowed. 1043 */ 1044 __init int 1045 trace_selftest_startup_function_graph(struct tracer *trace, 1046 struct trace_array *tr) 1047 { 1048 int ret; 1049 unsigned long count; 1050 char *func_name __maybe_unused; 1051 1052 #ifdef CONFIG_DYNAMIC_FTRACE 1053 if (ftrace_filter_param) { 1054 printk(KERN_CONT " ... kernel command line filter set: force PASS ... "); 1055 return 0; 1056 } 1057 #endif 1058 1059 /* 1060 * Simulate the init() callback but we attach a watchdog callback 1061 * to detect and recover from possible hangs 1062 */ 1063 tracing_reset_online_cpus(&tr->array_buffer); 1064 fgraph_ops.private = tr; 1065 ret = register_ftrace_graph(&fgraph_ops); 1066 if (ret) { 1067 warn_failed_init_tracer(trace, ret); 1068 goto out; 1069 } 1070 tracing_start_cmdline_record(); 1071 1072 /* Sleep for a 1/10 of a second */ 1073 msleep(100); 1074 1075 /* Have we just recovered from a hang? */ 1076 if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) { 1077 disable_tracing_selftest("recovering from a hang"); 1078 ret = -1; 1079 goto out; 1080 } 1081 1082 tracing_stop(); 1083 1084 /* check the trace buffer */ 1085 ret = trace_test_buffer(&tr->array_buffer, &count); 1086 1087 /* Need to also simulate the tr->reset to remove this fgraph_ops */ 1088 tracing_stop_cmdline_record(); 1089 unregister_ftrace_graph(&fgraph_ops); 1090 1091 tracing_start(); 1092 1093 if (!ret && !count) { 1094 printk(KERN_CONT ".. no entries found .."); 1095 ret = -1; 1096 goto out; 1097 } 1098 1099 #ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS 1100 /* 1101 * These tests can take some time to run. Make sure on non PREEMPT 1102 * kernels, we do not trigger the softlockup detector. 1103 */ 1104 cond_resched(); 1105 1106 tracing_reset_online_cpus(&tr->array_buffer); 1107 fgraph_ops.private = tr; 1108 1109 /* 1110 * Some archs *cough*PowerPC*cough* add characters to the 1111 * start of the function names. We simply put a '*' to 1112 * accommodate them. 1113 */ 1114 func_name = "*" __stringify(DYN_FTRACE_TEST_NAME); 1115 ftrace_set_global_filter(func_name, strlen(func_name), 1); 1116 1117 /* 1118 * Register direct function together with graph tracer 1119 * and make sure we get graph trace. 1120 */ 1121 ftrace_set_filter_ip(&direct, (unsigned long)DYN_FTRACE_TEST_NAME, 0, 0); 1122 ret = register_ftrace_direct(&direct, 1123 (unsigned long)ftrace_stub_direct_tramp); 1124 if (ret) 1125 goto out; 1126 1127 cond_resched(); 1128 1129 ret = register_ftrace_graph(&fgraph_ops); 1130 if (ret) { 1131 warn_failed_init_tracer(trace, ret); 1132 goto out; 1133 } 1134 1135 DYN_FTRACE_TEST_NAME(); 1136 1137 count = 0; 1138 1139 tracing_stop(); 1140 /* check the trace buffer */ 1141 ret = trace_test_buffer(&tr->array_buffer, &count); 1142 1143 unregister_ftrace_graph(&fgraph_ops); 1144 1145 ret = unregister_ftrace_direct(&direct, 1146 (unsigned long)ftrace_stub_direct_tramp, 1147 true); 1148 if (ret) 1149 goto out; 1150 1151 cond_resched(); 1152 1153 tracing_start(); 1154 1155 if (!ret && !count) { 1156 ret = -1; 1157 goto out; 1158 } 1159 1160 /* Enable tracing on all functions again */ 1161 ftrace_set_global_filter(NULL, 0, 1); 1162 #endif 1163 1164 ret = test_graph_storage(); 1165 1166 /* Don't test dynamic tracing, the function tracer already did */ 1167 out: 1168 /* Stop it if we failed */ 1169 if (ret) 1170 ftrace_graph_stop(); 1171 1172 return ret; 1173 } 1174 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 1175 1176 1177 #ifdef CONFIG_IRQSOFF_TRACER 1178 int 1179 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr) 1180 { 1181 unsigned long save_max = tr->max_latency; 1182 unsigned long count; 1183 int ret; 1184 1185 /* start the tracing */ 1186 ret = tracer_init(trace, tr); 1187 if (ret) { 1188 warn_failed_init_tracer(trace, ret); 1189 return ret; 1190 } 1191 1192 /* reset the max latency */ 1193 tr->max_latency = 0; 1194 /* disable interrupts for a bit */ 1195 local_irq_disable(); 1196 udelay(100); 1197 local_irq_enable(); 1198 1199 /* 1200 * Stop the tracer to avoid a warning subsequent 1201 * to buffer flipping failure because tracing_stop() 1202 * disables the tr and max buffers, making flipping impossible 1203 * in case of parallels max irqs off latencies. 1204 */ 1205 trace->stop(tr); 1206 /* stop the tracing. */ 1207 tracing_stop(); 1208 /* check both trace buffers */ 1209 ret = trace_test_buffer(&tr->array_buffer, NULL); 1210 if (!ret) 1211 ret = trace_test_buffer(&tr->max_buffer, &count); 1212 trace->reset(tr); 1213 tracing_start(); 1214 1215 if (!ret && !count) { 1216 printk(KERN_CONT ".. no entries found .."); 1217 ret = -1; 1218 } 1219 1220 tr->max_latency = save_max; 1221 1222 return ret; 1223 } 1224 #endif /* CONFIG_IRQSOFF_TRACER */ 1225 1226 #ifdef CONFIG_PREEMPT_TRACER 1227 int 1228 trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr) 1229 { 1230 unsigned long save_max = tr->max_latency; 1231 unsigned long count; 1232 int ret; 1233 1234 /* 1235 * Now that the big kernel lock is no longer preemptible, 1236 * and this is called with the BKL held, it will always 1237 * fail. If preemption is already disabled, simply 1238 * pass the test. When the BKL is removed, or becomes 1239 * preemptible again, we will once again test this, 1240 * so keep it in. 1241 */ 1242 if (preempt_count()) { 1243 printk(KERN_CONT "can not test ... force "); 1244 return 0; 1245 } 1246 1247 /* start the tracing */ 1248 ret = tracer_init(trace, tr); 1249 if (ret) { 1250 warn_failed_init_tracer(trace, ret); 1251 return ret; 1252 } 1253 1254 /* reset the max latency */ 1255 tr->max_latency = 0; 1256 /* disable preemption for a bit */ 1257 preempt_disable(); 1258 udelay(100); 1259 preempt_enable(); 1260 1261 /* 1262 * Stop the tracer to avoid a warning subsequent 1263 * to buffer flipping failure because tracing_stop() 1264 * disables the tr and max buffers, making flipping impossible 1265 * in case of parallels max preempt off latencies. 1266 */ 1267 trace->stop(tr); 1268 /* stop the tracing. */ 1269 tracing_stop(); 1270 /* check both trace buffers */ 1271 ret = trace_test_buffer(&tr->array_buffer, NULL); 1272 if (!ret) 1273 ret = trace_test_buffer(&tr->max_buffer, &count); 1274 trace->reset(tr); 1275 tracing_start(); 1276 1277 if (!ret && !count) { 1278 printk(KERN_CONT ".. no entries found .."); 1279 ret = -1; 1280 } 1281 1282 tr->max_latency = save_max; 1283 1284 return ret; 1285 } 1286 #endif /* CONFIG_PREEMPT_TRACER */ 1287 1288 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER) 1289 int 1290 trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr) 1291 { 1292 unsigned long save_max = tr->max_latency; 1293 unsigned long count; 1294 int ret; 1295 1296 /* 1297 * Now that the big kernel lock is no longer preemptible, 1298 * and this is called with the BKL held, it will always 1299 * fail. If preemption is already disabled, simply 1300 * pass the test. When the BKL is removed, or becomes 1301 * preemptible again, we will once again test this, 1302 * so keep it in. 1303 */ 1304 if (preempt_count()) { 1305 printk(KERN_CONT "can not test ... force "); 1306 return 0; 1307 } 1308 1309 /* start the tracing */ 1310 ret = tracer_init(trace, tr); 1311 if (ret) { 1312 warn_failed_init_tracer(trace, ret); 1313 goto out_no_start; 1314 } 1315 1316 /* reset the max latency */ 1317 tr->max_latency = 0; 1318 1319 /* disable preemption and interrupts for a bit */ 1320 preempt_disable(); 1321 local_irq_disable(); 1322 udelay(100); 1323 preempt_enable(); 1324 /* reverse the order of preempt vs irqs */ 1325 local_irq_enable(); 1326 1327 /* 1328 * Stop the tracer to avoid a warning subsequent 1329 * to buffer flipping failure because tracing_stop() 1330 * disables the tr and max buffers, making flipping impossible 1331 * in case of parallels max irqs/preempt off latencies. 1332 */ 1333 trace->stop(tr); 1334 /* stop the tracing. */ 1335 tracing_stop(); 1336 /* check both trace buffers */ 1337 ret = trace_test_buffer(&tr->array_buffer, NULL); 1338 if (ret) 1339 goto out; 1340 1341 ret = trace_test_buffer(&tr->max_buffer, &count); 1342 if (ret) 1343 goto out; 1344 1345 if (!ret && !count) { 1346 printk(KERN_CONT ".. no entries found .."); 1347 ret = -1; 1348 goto out; 1349 } 1350 1351 /* do the test by disabling interrupts first this time */ 1352 tr->max_latency = 0; 1353 tracing_start(); 1354 trace->start(tr); 1355 1356 preempt_disable(); 1357 local_irq_disable(); 1358 udelay(100); 1359 preempt_enable(); 1360 /* reverse the order of preempt vs irqs */ 1361 local_irq_enable(); 1362 1363 trace->stop(tr); 1364 /* stop the tracing. */ 1365 tracing_stop(); 1366 /* check both trace buffers */ 1367 ret = trace_test_buffer(&tr->array_buffer, NULL); 1368 if (ret) 1369 goto out; 1370 1371 ret = trace_test_buffer(&tr->max_buffer, &count); 1372 1373 if (!ret && !count) { 1374 printk(KERN_CONT ".. no entries found .."); 1375 ret = -1; 1376 goto out; 1377 } 1378 1379 out: 1380 tracing_start(); 1381 out_no_start: 1382 trace->reset(tr); 1383 tr->max_latency = save_max; 1384 1385 return ret; 1386 } 1387 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */ 1388 1389 #ifdef CONFIG_NOP_TRACER 1390 int 1391 trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr) 1392 { 1393 /* What could possibly go wrong? */ 1394 return 0; 1395 } 1396 #endif 1397 1398 #ifdef CONFIG_SCHED_TRACER 1399 1400 struct wakeup_test_data { 1401 struct completion is_ready; 1402 int go; 1403 }; 1404 1405 static int trace_wakeup_test_thread(void *data) 1406 { 1407 /* Make this a -deadline thread */ 1408 static const struct sched_attr attr = { 1409 .sched_policy = SCHED_DEADLINE, 1410 .sched_runtime = 100000ULL, 1411 .sched_deadline = 10000000ULL, 1412 .sched_period = 10000000ULL 1413 }; 1414 struct wakeup_test_data *x = data; 1415 1416 sched_setattr(current, &attr); 1417 1418 /* Make it know we have a new prio */ 1419 complete(&x->is_ready); 1420 1421 /* now go to sleep and let the test wake us up */ 1422 set_current_state(TASK_INTERRUPTIBLE); 1423 while (!x->go) { 1424 schedule(); 1425 set_current_state(TASK_INTERRUPTIBLE); 1426 } 1427 1428 complete(&x->is_ready); 1429 1430 set_current_state(TASK_INTERRUPTIBLE); 1431 1432 /* we are awake, now wait to disappear */ 1433 while (!kthread_should_stop()) { 1434 schedule(); 1435 set_current_state(TASK_INTERRUPTIBLE); 1436 } 1437 1438 __set_current_state(TASK_RUNNING); 1439 1440 return 0; 1441 } 1442 int 1443 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr) 1444 { 1445 unsigned long save_max = tr->max_latency; 1446 struct task_struct *p; 1447 struct wakeup_test_data data; 1448 unsigned long count; 1449 int ret; 1450 1451 memset(&data, 0, sizeof(data)); 1452 1453 init_completion(&data.is_ready); 1454 1455 /* create a -deadline thread */ 1456 p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test"); 1457 if (IS_ERR(p)) { 1458 printk(KERN_CONT "Failed to create ftrace wakeup test thread "); 1459 return -1; 1460 } 1461 1462 /* make sure the thread is running at -deadline policy */ 1463 wait_for_completion(&data.is_ready); 1464 1465 /* start the tracing */ 1466 ret = tracer_init(trace, tr); 1467 if (ret) { 1468 warn_failed_init_tracer(trace, ret); 1469 return ret; 1470 } 1471 1472 /* reset the max latency */ 1473 tr->max_latency = 0; 1474 1475 while (p->on_rq) { 1476 /* 1477 * Sleep to make sure the -deadline thread is asleep too. 1478 * On virtual machines we can't rely on timings, 1479 * but we want to make sure this test still works. 1480 */ 1481 msleep(100); 1482 } 1483 1484 init_completion(&data.is_ready); 1485 1486 data.go = 1; 1487 /* memory barrier is in the wake_up_process() */ 1488 1489 wake_up_process(p); 1490 1491 /* Wait for the task to wake up */ 1492 wait_for_completion(&data.is_ready); 1493 1494 /* stop the tracing. */ 1495 tracing_stop(); 1496 /* check both trace buffers */ 1497 ret = trace_test_buffer(&tr->array_buffer, NULL); 1498 if (!ret) 1499 ret = trace_test_buffer(&tr->max_buffer, &count); 1500 1501 1502 trace->reset(tr); 1503 tracing_start(); 1504 1505 tr->max_latency = save_max; 1506 1507 /* kill the thread */ 1508 kthread_stop(p); 1509 1510 if (!ret && !count) { 1511 printk(KERN_CONT ".. no entries found .."); 1512 ret = -1; 1513 } 1514 1515 return ret; 1516 } 1517 #endif /* CONFIG_SCHED_TRACER */ 1518 1519 #ifdef CONFIG_BRANCH_TRACER 1520 int 1521 trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr) 1522 { 1523 unsigned long count; 1524 int ret; 1525 1526 /* start the tracing */ 1527 ret = tracer_init(trace, tr); 1528 if (ret) { 1529 warn_failed_init_tracer(trace, ret); 1530 return ret; 1531 } 1532 1533 /* Sleep for a 1/10 of a second */ 1534 msleep(100); 1535 /* stop the tracing. */ 1536 tracing_stop(); 1537 /* check the trace buffer */ 1538 ret = trace_test_buffer(&tr->array_buffer, &count); 1539 trace->reset(tr); 1540 tracing_start(); 1541 1542 if (!ret && !count) { 1543 printk(KERN_CONT ".. no entries found .."); 1544 ret = -1; 1545 } 1546 1547 return ret; 1548 } 1549 #endif /* CONFIG_BRANCH_TRACER */ 1550 1551