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