1 /* 2 * 3 * Function graph tracer. 4 * Copyright (c) 2008-2009 Frederic Weisbecker <[email protected]> 5 * Mostly borrowed from function tracer which 6 * is Copyright (c) Steven Rostedt <[email protected]> 7 * 8 */ 9 #include <linux/debugfs.h> 10 #include <linux/uaccess.h> 11 #include <linux/ftrace.h> 12 #include <linux/slab.h> 13 #include <linux/fs.h> 14 15 #include "trace.h" 16 #include "trace_output.h" 17 18 /* When set, irq functions will be ignored */ 19 static int ftrace_graph_skip_irqs; 20 21 struct fgraph_cpu_data { 22 pid_t last_pid; 23 int depth; 24 int depth_irq; 25 int ignore; 26 unsigned long enter_funcs[FTRACE_RETFUNC_DEPTH]; 27 }; 28 29 struct fgraph_data { 30 struct fgraph_cpu_data __percpu *cpu_data; 31 32 /* Place to preserve last processed entry. */ 33 struct ftrace_graph_ent_entry ent; 34 struct ftrace_graph_ret_entry ret; 35 int failed; 36 int cpu; 37 }; 38 39 #define TRACE_GRAPH_INDENT 2 40 41 /* Flag options */ 42 #define TRACE_GRAPH_PRINT_OVERRUN 0x1 43 #define TRACE_GRAPH_PRINT_CPU 0x2 44 #define TRACE_GRAPH_PRINT_OVERHEAD 0x4 45 #define TRACE_GRAPH_PRINT_PROC 0x8 46 #define TRACE_GRAPH_PRINT_DURATION 0x10 47 #define TRACE_GRAPH_PRINT_ABS_TIME 0x20 48 #define TRACE_GRAPH_PRINT_IRQS 0x40 49 50 static unsigned int max_depth; 51 52 static struct tracer_opt trace_opts[] = { 53 /* Display overruns? (for self-debug purpose) */ 54 { TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) }, 55 /* Display CPU ? */ 56 { TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) }, 57 /* Display Overhead ? */ 58 { TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) }, 59 /* Display proc name/pid */ 60 { TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) }, 61 /* Display duration of execution */ 62 { TRACER_OPT(funcgraph-duration, TRACE_GRAPH_PRINT_DURATION) }, 63 /* Display absolute time of an entry */ 64 { TRACER_OPT(funcgraph-abstime, TRACE_GRAPH_PRINT_ABS_TIME) }, 65 /* Display interrupts */ 66 { TRACER_OPT(funcgraph-irqs, TRACE_GRAPH_PRINT_IRQS) }, 67 { } /* Empty entry */ 68 }; 69 70 static struct tracer_flags tracer_flags = { 71 /* Don't display overruns and proc by default */ 72 .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD | 73 TRACE_GRAPH_PRINT_DURATION | TRACE_GRAPH_PRINT_IRQS, 74 .opts = trace_opts 75 }; 76 77 static struct trace_array *graph_array; 78 79 /* 80 * DURATION column is being also used to display IRQ signs, 81 * following values are used by print_graph_irq and others 82 * to fill in space into DURATION column. 83 */ 84 enum { 85 DURATION_FILL_FULL = -1, 86 DURATION_FILL_START = -2, 87 DURATION_FILL_END = -3, 88 }; 89 90 static enum print_line_t 91 print_graph_duration(unsigned long long duration, struct trace_seq *s, 92 u32 flags); 93 94 /* Add a function return address to the trace stack on thread info.*/ 95 int 96 ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth, 97 unsigned long frame_pointer) 98 { 99 unsigned long long calltime; 100 int index; 101 102 if (!current->ret_stack) 103 return -EBUSY; 104 105 /* 106 * We must make sure the ret_stack is tested before we read 107 * anything else. 108 */ 109 smp_rmb(); 110 111 /* The return trace stack is full */ 112 if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) { 113 atomic_inc(¤t->trace_overrun); 114 return -EBUSY; 115 } 116 117 calltime = trace_clock_local(); 118 119 index = ++current->curr_ret_stack; 120 barrier(); 121 current->ret_stack[index].ret = ret; 122 current->ret_stack[index].func = func; 123 current->ret_stack[index].calltime = calltime; 124 current->ret_stack[index].subtime = 0; 125 current->ret_stack[index].fp = frame_pointer; 126 *depth = index; 127 128 return 0; 129 } 130 131 /* Retrieve a function return address to the trace stack on thread info.*/ 132 static void 133 ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret, 134 unsigned long frame_pointer) 135 { 136 int index; 137 138 index = current->curr_ret_stack; 139 140 if (unlikely(index < 0)) { 141 ftrace_graph_stop(); 142 WARN_ON(1); 143 /* Might as well panic, otherwise we have no where to go */ 144 *ret = (unsigned long)panic; 145 return; 146 } 147 148 #if defined(CONFIG_HAVE_FUNCTION_GRAPH_FP_TEST) && !defined(CC_USING_FENTRY) 149 /* 150 * The arch may choose to record the frame pointer used 151 * and check it here to make sure that it is what we expect it 152 * to be. If gcc does not set the place holder of the return 153 * address in the frame pointer, and does a copy instead, then 154 * the function graph trace will fail. This test detects this 155 * case. 156 * 157 * Currently, x86_32 with optimize for size (-Os) makes the latest 158 * gcc do the above. 159 * 160 * Note, -mfentry does not use frame pointers, and this test 161 * is not needed if CC_USING_FENTRY is set. 162 */ 163 if (unlikely(current->ret_stack[index].fp != frame_pointer)) { 164 ftrace_graph_stop(); 165 WARN(1, "Bad frame pointer: expected %lx, received %lx\n" 166 " from func %ps return to %lx\n", 167 current->ret_stack[index].fp, 168 frame_pointer, 169 (void *)current->ret_stack[index].func, 170 current->ret_stack[index].ret); 171 *ret = (unsigned long)panic; 172 return; 173 } 174 #endif 175 176 *ret = current->ret_stack[index].ret; 177 trace->func = current->ret_stack[index].func; 178 trace->calltime = current->ret_stack[index].calltime; 179 trace->overrun = atomic_read(¤t->trace_overrun); 180 trace->depth = index; 181 } 182 183 /* 184 * Send the trace to the ring-buffer. 185 * @return the original return address. 186 */ 187 unsigned long ftrace_return_to_handler(unsigned long frame_pointer) 188 { 189 struct ftrace_graph_ret trace; 190 unsigned long ret; 191 192 ftrace_pop_return_trace(&trace, &ret, frame_pointer); 193 trace.rettime = trace_clock_local(); 194 ftrace_graph_return(&trace); 195 barrier(); 196 current->curr_ret_stack--; 197 198 if (unlikely(!ret)) { 199 ftrace_graph_stop(); 200 WARN_ON(1); 201 /* Might as well panic. What else to do? */ 202 ret = (unsigned long)panic; 203 } 204 205 return ret; 206 } 207 208 int __trace_graph_entry(struct trace_array *tr, 209 struct ftrace_graph_ent *trace, 210 unsigned long flags, 211 int pc) 212 { 213 struct ftrace_event_call *call = &event_funcgraph_entry; 214 struct ring_buffer_event *event; 215 struct ring_buffer *buffer = tr->buffer; 216 struct ftrace_graph_ent_entry *entry; 217 218 if (unlikely(__this_cpu_read(ftrace_cpu_disabled))) 219 return 0; 220 221 event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_ENT, 222 sizeof(*entry), flags, pc); 223 if (!event) 224 return 0; 225 entry = ring_buffer_event_data(event); 226 entry->graph_ent = *trace; 227 if (!filter_current_check_discard(buffer, call, entry, event)) 228 __buffer_unlock_commit(buffer, event); 229 230 return 1; 231 } 232 233 static inline int ftrace_graph_ignore_irqs(void) 234 { 235 if (!ftrace_graph_skip_irqs || trace_recursion_test(TRACE_IRQ_BIT)) 236 return 0; 237 238 return in_irq(); 239 } 240 241 int trace_graph_entry(struct ftrace_graph_ent *trace) 242 { 243 struct trace_array *tr = graph_array; 244 struct trace_array_cpu *data; 245 unsigned long flags; 246 long disabled; 247 int ret; 248 int cpu; 249 int pc; 250 251 if (!ftrace_trace_task(current)) 252 return 0; 253 254 /* trace it when it is-nested-in or is a function enabled. */ 255 if ((!(trace->depth || ftrace_graph_addr(trace->func)) || 256 ftrace_graph_ignore_irqs()) || 257 (max_depth && trace->depth >= max_depth)) 258 return 0; 259 260 local_irq_save(flags); 261 cpu = raw_smp_processor_id(); 262 data = tr->data[cpu]; 263 disabled = atomic_inc_return(&data->disabled); 264 if (likely(disabled == 1)) { 265 pc = preempt_count(); 266 ret = __trace_graph_entry(tr, trace, flags, pc); 267 } else { 268 ret = 0; 269 } 270 271 atomic_dec(&data->disabled); 272 local_irq_restore(flags); 273 274 return ret; 275 } 276 277 int trace_graph_thresh_entry(struct ftrace_graph_ent *trace) 278 { 279 if (tracing_thresh) 280 return 1; 281 else 282 return trace_graph_entry(trace); 283 } 284 285 static void 286 __trace_graph_function(struct trace_array *tr, 287 unsigned long ip, unsigned long flags, int pc) 288 { 289 u64 time = trace_clock_local(); 290 struct ftrace_graph_ent ent = { 291 .func = ip, 292 .depth = 0, 293 }; 294 struct ftrace_graph_ret ret = { 295 .func = ip, 296 .depth = 0, 297 .calltime = time, 298 .rettime = time, 299 }; 300 301 __trace_graph_entry(tr, &ent, flags, pc); 302 __trace_graph_return(tr, &ret, flags, pc); 303 } 304 305 void 306 trace_graph_function(struct trace_array *tr, 307 unsigned long ip, unsigned long parent_ip, 308 unsigned long flags, int pc) 309 { 310 __trace_graph_function(tr, ip, flags, pc); 311 } 312 313 void __trace_graph_return(struct trace_array *tr, 314 struct ftrace_graph_ret *trace, 315 unsigned long flags, 316 int pc) 317 { 318 struct ftrace_event_call *call = &event_funcgraph_exit; 319 struct ring_buffer_event *event; 320 struct ring_buffer *buffer = tr->buffer; 321 struct ftrace_graph_ret_entry *entry; 322 323 if (unlikely(__this_cpu_read(ftrace_cpu_disabled))) 324 return; 325 326 event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_RET, 327 sizeof(*entry), flags, pc); 328 if (!event) 329 return; 330 entry = ring_buffer_event_data(event); 331 entry->ret = *trace; 332 if (!filter_current_check_discard(buffer, call, entry, event)) 333 __buffer_unlock_commit(buffer, event); 334 } 335 336 void trace_graph_return(struct ftrace_graph_ret *trace) 337 { 338 struct trace_array *tr = graph_array; 339 struct trace_array_cpu *data; 340 unsigned long flags; 341 long disabled; 342 int cpu; 343 int pc; 344 345 local_irq_save(flags); 346 cpu = raw_smp_processor_id(); 347 data = tr->data[cpu]; 348 disabled = atomic_inc_return(&data->disabled); 349 if (likely(disabled == 1)) { 350 pc = preempt_count(); 351 __trace_graph_return(tr, trace, flags, pc); 352 } 353 atomic_dec(&data->disabled); 354 local_irq_restore(flags); 355 } 356 357 void set_graph_array(struct trace_array *tr) 358 { 359 graph_array = tr; 360 361 /* Make graph_array visible before we start tracing */ 362 363 smp_mb(); 364 } 365 366 void trace_graph_thresh_return(struct ftrace_graph_ret *trace) 367 { 368 if (tracing_thresh && 369 (trace->rettime - trace->calltime < tracing_thresh)) 370 return; 371 else 372 trace_graph_return(trace); 373 } 374 375 static int graph_trace_init(struct trace_array *tr) 376 { 377 int ret; 378 379 set_graph_array(tr); 380 if (tracing_thresh) 381 ret = register_ftrace_graph(&trace_graph_thresh_return, 382 &trace_graph_thresh_entry); 383 else 384 ret = register_ftrace_graph(&trace_graph_return, 385 &trace_graph_entry); 386 if (ret) 387 return ret; 388 tracing_start_cmdline_record(); 389 390 return 0; 391 } 392 393 static void graph_trace_reset(struct trace_array *tr) 394 { 395 tracing_stop_cmdline_record(); 396 unregister_ftrace_graph(); 397 } 398 399 static int max_bytes_for_cpu; 400 401 static enum print_line_t 402 print_graph_cpu(struct trace_seq *s, int cpu) 403 { 404 int ret; 405 406 /* 407 * Start with a space character - to make it stand out 408 * to the right a bit when trace output is pasted into 409 * email: 410 */ 411 ret = trace_seq_printf(s, " %*d) ", max_bytes_for_cpu, cpu); 412 if (!ret) 413 return TRACE_TYPE_PARTIAL_LINE; 414 415 return TRACE_TYPE_HANDLED; 416 } 417 418 #define TRACE_GRAPH_PROCINFO_LENGTH 14 419 420 static enum print_line_t 421 print_graph_proc(struct trace_seq *s, pid_t pid) 422 { 423 char comm[TASK_COMM_LEN]; 424 /* sign + log10(MAX_INT) + '\0' */ 425 char pid_str[11]; 426 int spaces = 0; 427 int ret; 428 int len; 429 int i; 430 431 trace_find_cmdline(pid, comm); 432 comm[7] = '\0'; 433 sprintf(pid_str, "%d", pid); 434 435 /* 1 stands for the "-" character */ 436 len = strlen(comm) + strlen(pid_str) + 1; 437 438 if (len < TRACE_GRAPH_PROCINFO_LENGTH) 439 spaces = TRACE_GRAPH_PROCINFO_LENGTH - len; 440 441 /* First spaces to align center */ 442 for (i = 0; i < spaces / 2; i++) { 443 ret = trace_seq_printf(s, " "); 444 if (!ret) 445 return TRACE_TYPE_PARTIAL_LINE; 446 } 447 448 ret = trace_seq_printf(s, "%s-%s", comm, pid_str); 449 if (!ret) 450 return TRACE_TYPE_PARTIAL_LINE; 451 452 /* Last spaces to align center */ 453 for (i = 0; i < spaces - (spaces / 2); i++) { 454 ret = trace_seq_printf(s, " "); 455 if (!ret) 456 return TRACE_TYPE_PARTIAL_LINE; 457 } 458 return TRACE_TYPE_HANDLED; 459 } 460 461 462 static enum print_line_t 463 print_graph_lat_fmt(struct trace_seq *s, struct trace_entry *entry) 464 { 465 if (!trace_seq_putc(s, ' ')) 466 return 0; 467 468 return trace_print_lat_fmt(s, entry); 469 } 470 471 /* If the pid changed since the last trace, output this event */ 472 static enum print_line_t 473 verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data) 474 { 475 pid_t prev_pid; 476 pid_t *last_pid; 477 int ret; 478 479 if (!data) 480 return TRACE_TYPE_HANDLED; 481 482 last_pid = &(per_cpu_ptr(data->cpu_data, cpu)->last_pid); 483 484 if (*last_pid == pid) 485 return TRACE_TYPE_HANDLED; 486 487 prev_pid = *last_pid; 488 *last_pid = pid; 489 490 if (prev_pid == -1) 491 return TRACE_TYPE_HANDLED; 492 /* 493 * Context-switch trace line: 494 495 ------------------------------------------ 496 | 1) migration/0--1 => sshd-1755 497 ------------------------------------------ 498 499 */ 500 ret = trace_seq_printf(s, 501 " ------------------------------------------\n"); 502 if (!ret) 503 return TRACE_TYPE_PARTIAL_LINE; 504 505 ret = print_graph_cpu(s, cpu); 506 if (ret == TRACE_TYPE_PARTIAL_LINE) 507 return TRACE_TYPE_PARTIAL_LINE; 508 509 ret = print_graph_proc(s, prev_pid); 510 if (ret == TRACE_TYPE_PARTIAL_LINE) 511 return TRACE_TYPE_PARTIAL_LINE; 512 513 ret = trace_seq_printf(s, " => "); 514 if (!ret) 515 return TRACE_TYPE_PARTIAL_LINE; 516 517 ret = print_graph_proc(s, pid); 518 if (ret == TRACE_TYPE_PARTIAL_LINE) 519 return TRACE_TYPE_PARTIAL_LINE; 520 521 ret = trace_seq_printf(s, 522 "\n ------------------------------------------\n\n"); 523 if (!ret) 524 return TRACE_TYPE_PARTIAL_LINE; 525 526 return TRACE_TYPE_HANDLED; 527 } 528 529 static struct ftrace_graph_ret_entry * 530 get_return_for_leaf(struct trace_iterator *iter, 531 struct ftrace_graph_ent_entry *curr) 532 { 533 struct fgraph_data *data = iter->private; 534 struct ring_buffer_iter *ring_iter = NULL; 535 struct ring_buffer_event *event; 536 struct ftrace_graph_ret_entry *next; 537 538 /* 539 * If the previous output failed to write to the seq buffer, 540 * then we just reuse the data from before. 541 */ 542 if (data && data->failed) { 543 curr = &data->ent; 544 next = &data->ret; 545 } else { 546 547 ring_iter = trace_buffer_iter(iter, iter->cpu); 548 549 /* First peek to compare current entry and the next one */ 550 if (ring_iter) 551 event = ring_buffer_iter_peek(ring_iter, NULL); 552 else { 553 /* 554 * We need to consume the current entry to see 555 * the next one. 556 */ 557 ring_buffer_consume(iter->tr->buffer, iter->cpu, 558 NULL, NULL); 559 event = ring_buffer_peek(iter->tr->buffer, iter->cpu, 560 NULL, NULL); 561 } 562 563 if (!event) 564 return NULL; 565 566 next = ring_buffer_event_data(event); 567 568 if (data) { 569 /* 570 * Save current and next entries for later reference 571 * if the output fails. 572 */ 573 data->ent = *curr; 574 /* 575 * If the next event is not a return type, then 576 * we only care about what type it is. Otherwise we can 577 * safely copy the entire event. 578 */ 579 if (next->ent.type == TRACE_GRAPH_RET) 580 data->ret = *next; 581 else 582 data->ret.ent.type = next->ent.type; 583 } 584 } 585 586 if (next->ent.type != TRACE_GRAPH_RET) 587 return NULL; 588 589 if (curr->ent.pid != next->ent.pid || 590 curr->graph_ent.func != next->ret.func) 591 return NULL; 592 593 /* this is a leaf, now advance the iterator */ 594 if (ring_iter) 595 ring_buffer_read(ring_iter, NULL); 596 597 return next; 598 } 599 600 static int print_graph_abs_time(u64 t, struct trace_seq *s) 601 { 602 unsigned long usecs_rem; 603 604 usecs_rem = do_div(t, NSEC_PER_SEC); 605 usecs_rem /= 1000; 606 607 return trace_seq_printf(s, "%5lu.%06lu | ", 608 (unsigned long)t, usecs_rem); 609 } 610 611 static enum print_line_t 612 print_graph_irq(struct trace_iterator *iter, unsigned long addr, 613 enum trace_type type, int cpu, pid_t pid, u32 flags) 614 { 615 int ret; 616 struct trace_seq *s = &iter->seq; 617 618 if (addr < (unsigned long)__irqentry_text_start || 619 addr >= (unsigned long)__irqentry_text_end) 620 return TRACE_TYPE_UNHANDLED; 621 622 if (trace_flags & TRACE_ITER_CONTEXT_INFO) { 623 /* Absolute time */ 624 if (flags & TRACE_GRAPH_PRINT_ABS_TIME) { 625 ret = print_graph_abs_time(iter->ts, s); 626 if (!ret) 627 return TRACE_TYPE_PARTIAL_LINE; 628 } 629 630 /* Cpu */ 631 if (flags & TRACE_GRAPH_PRINT_CPU) { 632 ret = print_graph_cpu(s, cpu); 633 if (ret == TRACE_TYPE_PARTIAL_LINE) 634 return TRACE_TYPE_PARTIAL_LINE; 635 } 636 637 /* Proc */ 638 if (flags & TRACE_GRAPH_PRINT_PROC) { 639 ret = print_graph_proc(s, pid); 640 if (ret == TRACE_TYPE_PARTIAL_LINE) 641 return TRACE_TYPE_PARTIAL_LINE; 642 ret = trace_seq_printf(s, " | "); 643 if (!ret) 644 return TRACE_TYPE_PARTIAL_LINE; 645 } 646 } 647 648 /* No overhead */ 649 ret = print_graph_duration(DURATION_FILL_START, s, flags); 650 if (ret != TRACE_TYPE_HANDLED) 651 return ret; 652 653 if (type == TRACE_GRAPH_ENT) 654 ret = trace_seq_printf(s, "==========>"); 655 else 656 ret = trace_seq_printf(s, "<=========="); 657 658 if (!ret) 659 return TRACE_TYPE_PARTIAL_LINE; 660 661 ret = print_graph_duration(DURATION_FILL_END, s, flags); 662 if (ret != TRACE_TYPE_HANDLED) 663 return ret; 664 665 ret = trace_seq_printf(s, "\n"); 666 667 if (!ret) 668 return TRACE_TYPE_PARTIAL_LINE; 669 return TRACE_TYPE_HANDLED; 670 } 671 672 enum print_line_t 673 trace_print_graph_duration(unsigned long long duration, struct trace_seq *s) 674 { 675 unsigned long nsecs_rem = do_div(duration, 1000); 676 /* log10(ULONG_MAX) + '\0' */ 677 char msecs_str[21]; 678 char nsecs_str[5]; 679 int ret, len; 680 int i; 681 682 sprintf(msecs_str, "%lu", (unsigned long) duration); 683 684 /* Print msecs */ 685 ret = trace_seq_printf(s, "%s", msecs_str); 686 if (!ret) 687 return TRACE_TYPE_PARTIAL_LINE; 688 689 len = strlen(msecs_str); 690 691 /* Print nsecs (we don't want to exceed 7 numbers) */ 692 if (len < 7) { 693 size_t slen = min_t(size_t, sizeof(nsecs_str), 8UL - len); 694 695 snprintf(nsecs_str, slen, "%03lu", nsecs_rem); 696 ret = trace_seq_printf(s, ".%s", nsecs_str); 697 if (!ret) 698 return TRACE_TYPE_PARTIAL_LINE; 699 len += strlen(nsecs_str); 700 } 701 702 ret = trace_seq_printf(s, " us "); 703 if (!ret) 704 return TRACE_TYPE_PARTIAL_LINE; 705 706 /* Print remaining spaces to fit the row's width */ 707 for (i = len; i < 7; i++) { 708 ret = trace_seq_printf(s, " "); 709 if (!ret) 710 return TRACE_TYPE_PARTIAL_LINE; 711 } 712 return TRACE_TYPE_HANDLED; 713 } 714 715 static enum print_line_t 716 print_graph_duration(unsigned long long duration, struct trace_seq *s, 717 u32 flags) 718 { 719 int ret = -1; 720 721 if (!(flags & TRACE_GRAPH_PRINT_DURATION) || 722 !(trace_flags & TRACE_ITER_CONTEXT_INFO)) 723 return TRACE_TYPE_HANDLED; 724 725 /* No real adata, just filling the column with spaces */ 726 switch (duration) { 727 case DURATION_FILL_FULL: 728 ret = trace_seq_printf(s, " | "); 729 return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE; 730 case DURATION_FILL_START: 731 ret = trace_seq_printf(s, " "); 732 return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE; 733 case DURATION_FILL_END: 734 ret = trace_seq_printf(s, " |"); 735 return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE; 736 } 737 738 /* Signal a overhead of time execution to the output */ 739 if (flags & TRACE_GRAPH_PRINT_OVERHEAD) { 740 /* Duration exceeded 100 msecs */ 741 if (duration > 100000ULL) 742 ret = trace_seq_printf(s, "! "); 743 /* Duration exceeded 10 msecs */ 744 else if (duration > 10000ULL) 745 ret = trace_seq_printf(s, "+ "); 746 } 747 748 /* 749 * The -1 means we either did not exceed the duration tresholds 750 * or we dont want to print out the overhead. Either way we need 751 * to fill out the space. 752 */ 753 if (ret == -1) 754 ret = trace_seq_printf(s, " "); 755 756 /* Catching here any failure happenned above */ 757 if (!ret) 758 return TRACE_TYPE_PARTIAL_LINE; 759 760 ret = trace_print_graph_duration(duration, s); 761 if (ret != TRACE_TYPE_HANDLED) 762 return ret; 763 764 ret = trace_seq_printf(s, "| "); 765 if (!ret) 766 return TRACE_TYPE_PARTIAL_LINE; 767 768 return TRACE_TYPE_HANDLED; 769 } 770 771 /* Case of a leaf function on its call entry */ 772 static enum print_line_t 773 print_graph_entry_leaf(struct trace_iterator *iter, 774 struct ftrace_graph_ent_entry *entry, 775 struct ftrace_graph_ret_entry *ret_entry, 776 struct trace_seq *s, u32 flags) 777 { 778 struct fgraph_data *data = iter->private; 779 struct ftrace_graph_ret *graph_ret; 780 struct ftrace_graph_ent *call; 781 unsigned long long duration; 782 int ret; 783 int i; 784 785 graph_ret = &ret_entry->ret; 786 call = &entry->graph_ent; 787 duration = graph_ret->rettime - graph_ret->calltime; 788 789 if (data) { 790 struct fgraph_cpu_data *cpu_data; 791 int cpu = iter->cpu; 792 793 cpu_data = per_cpu_ptr(data->cpu_data, cpu); 794 795 /* 796 * Comments display at + 1 to depth. Since 797 * this is a leaf function, keep the comments 798 * equal to this depth. 799 */ 800 cpu_data->depth = call->depth - 1; 801 802 /* No need to keep this function around for this depth */ 803 if (call->depth < FTRACE_RETFUNC_DEPTH) 804 cpu_data->enter_funcs[call->depth] = 0; 805 } 806 807 /* Overhead and duration */ 808 ret = print_graph_duration(duration, s, flags); 809 if (ret == TRACE_TYPE_PARTIAL_LINE) 810 return TRACE_TYPE_PARTIAL_LINE; 811 812 /* Function */ 813 for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) { 814 ret = trace_seq_printf(s, " "); 815 if (!ret) 816 return TRACE_TYPE_PARTIAL_LINE; 817 } 818 819 ret = trace_seq_printf(s, "%ps();\n", (void *)call->func); 820 if (!ret) 821 return TRACE_TYPE_PARTIAL_LINE; 822 823 return TRACE_TYPE_HANDLED; 824 } 825 826 static enum print_line_t 827 print_graph_entry_nested(struct trace_iterator *iter, 828 struct ftrace_graph_ent_entry *entry, 829 struct trace_seq *s, int cpu, u32 flags) 830 { 831 struct ftrace_graph_ent *call = &entry->graph_ent; 832 struct fgraph_data *data = iter->private; 833 int ret; 834 int i; 835 836 if (data) { 837 struct fgraph_cpu_data *cpu_data; 838 int cpu = iter->cpu; 839 840 cpu_data = per_cpu_ptr(data->cpu_data, cpu); 841 cpu_data->depth = call->depth; 842 843 /* Save this function pointer to see if the exit matches */ 844 if (call->depth < FTRACE_RETFUNC_DEPTH) 845 cpu_data->enter_funcs[call->depth] = call->func; 846 } 847 848 /* No time */ 849 ret = print_graph_duration(DURATION_FILL_FULL, s, flags); 850 if (ret != TRACE_TYPE_HANDLED) 851 return ret; 852 853 /* Function */ 854 for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) { 855 ret = trace_seq_printf(s, " "); 856 if (!ret) 857 return TRACE_TYPE_PARTIAL_LINE; 858 } 859 860 ret = trace_seq_printf(s, "%ps() {\n", (void *)call->func); 861 if (!ret) 862 return TRACE_TYPE_PARTIAL_LINE; 863 864 /* 865 * we already consumed the current entry to check the next one 866 * and see if this is a leaf. 867 */ 868 return TRACE_TYPE_NO_CONSUME; 869 } 870 871 static enum print_line_t 872 print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s, 873 int type, unsigned long addr, u32 flags) 874 { 875 struct fgraph_data *data = iter->private; 876 struct trace_entry *ent = iter->ent; 877 int cpu = iter->cpu; 878 int ret; 879 880 /* Pid */ 881 if (verif_pid(s, ent->pid, cpu, data) == TRACE_TYPE_PARTIAL_LINE) 882 return TRACE_TYPE_PARTIAL_LINE; 883 884 if (type) { 885 /* Interrupt */ 886 ret = print_graph_irq(iter, addr, type, cpu, ent->pid, flags); 887 if (ret == TRACE_TYPE_PARTIAL_LINE) 888 return TRACE_TYPE_PARTIAL_LINE; 889 } 890 891 if (!(trace_flags & TRACE_ITER_CONTEXT_INFO)) 892 return 0; 893 894 /* Absolute time */ 895 if (flags & TRACE_GRAPH_PRINT_ABS_TIME) { 896 ret = print_graph_abs_time(iter->ts, s); 897 if (!ret) 898 return TRACE_TYPE_PARTIAL_LINE; 899 } 900 901 /* Cpu */ 902 if (flags & TRACE_GRAPH_PRINT_CPU) { 903 ret = print_graph_cpu(s, cpu); 904 if (ret == TRACE_TYPE_PARTIAL_LINE) 905 return TRACE_TYPE_PARTIAL_LINE; 906 } 907 908 /* Proc */ 909 if (flags & TRACE_GRAPH_PRINT_PROC) { 910 ret = print_graph_proc(s, ent->pid); 911 if (ret == TRACE_TYPE_PARTIAL_LINE) 912 return TRACE_TYPE_PARTIAL_LINE; 913 914 ret = trace_seq_printf(s, " | "); 915 if (!ret) 916 return TRACE_TYPE_PARTIAL_LINE; 917 } 918 919 /* Latency format */ 920 if (trace_flags & TRACE_ITER_LATENCY_FMT) { 921 ret = print_graph_lat_fmt(s, ent); 922 if (ret == TRACE_TYPE_PARTIAL_LINE) 923 return TRACE_TYPE_PARTIAL_LINE; 924 } 925 926 return 0; 927 } 928 929 /* 930 * Entry check for irq code 931 * 932 * returns 1 if 933 * - we are inside irq code 934 * - we just entered irq code 935 * 936 * retunns 0 if 937 * - funcgraph-interrupts option is set 938 * - we are not inside irq code 939 */ 940 static int 941 check_irq_entry(struct trace_iterator *iter, u32 flags, 942 unsigned long addr, int depth) 943 { 944 int cpu = iter->cpu; 945 int *depth_irq; 946 struct fgraph_data *data = iter->private; 947 948 /* 949 * If we are either displaying irqs, or we got called as 950 * a graph event and private data does not exist, 951 * then we bypass the irq check. 952 */ 953 if ((flags & TRACE_GRAPH_PRINT_IRQS) || 954 (!data)) 955 return 0; 956 957 depth_irq = &(per_cpu_ptr(data->cpu_data, cpu)->depth_irq); 958 959 /* 960 * We are inside the irq code 961 */ 962 if (*depth_irq >= 0) 963 return 1; 964 965 if ((addr < (unsigned long)__irqentry_text_start) || 966 (addr >= (unsigned long)__irqentry_text_end)) 967 return 0; 968 969 /* 970 * We are entering irq code. 971 */ 972 *depth_irq = depth; 973 return 1; 974 } 975 976 /* 977 * Return check for irq code 978 * 979 * returns 1 if 980 * - we are inside irq code 981 * - we just left irq code 982 * 983 * returns 0 if 984 * - funcgraph-interrupts option is set 985 * - we are not inside irq code 986 */ 987 static int 988 check_irq_return(struct trace_iterator *iter, u32 flags, int depth) 989 { 990 int cpu = iter->cpu; 991 int *depth_irq; 992 struct fgraph_data *data = iter->private; 993 994 /* 995 * If we are either displaying irqs, or we got called as 996 * a graph event and private data does not exist, 997 * then we bypass the irq check. 998 */ 999 if ((flags & TRACE_GRAPH_PRINT_IRQS) || 1000 (!data)) 1001 return 0; 1002 1003 depth_irq = &(per_cpu_ptr(data->cpu_data, cpu)->depth_irq); 1004 1005 /* 1006 * We are not inside the irq code. 1007 */ 1008 if (*depth_irq == -1) 1009 return 0; 1010 1011 /* 1012 * We are inside the irq code, and this is returning entry. 1013 * Let's not trace it and clear the entry depth, since 1014 * we are out of irq code. 1015 * 1016 * This condition ensures that we 'leave the irq code' once 1017 * we are out of the entry depth. Thus protecting us from 1018 * the RETURN entry loss. 1019 */ 1020 if (*depth_irq >= depth) { 1021 *depth_irq = -1; 1022 return 1; 1023 } 1024 1025 /* 1026 * We are inside the irq code, and this is not the entry. 1027 */ 1028 return 1; 1029 } 1030 1031 static enum print_line_t 1032 print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s, 1033 struct trace_iterator *iter, u32 flags) 1034 { 1035 struct fgraph_data *data = iter->private; 1036 struct ftrace_graph_ent *call = &field->graph_ent; 1037 struct ftrace_graph_ret_entry *leaf_ret; 1038 static enum print_line_t ret; 1039 int cpu = iter->cpu; 1040 1041 if (check_irq_entry(iter, flags, call->func, call->depth)) 1042 return TRACE_TYPE_HANDLED; 1043 1044 if (print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func, flags)) 1045 return TRACE_TYPE_PARTIAL_LINE; 1046 1047 leaf_ret = get_return_for_leaf(iter, field); 1048 if (leaf_ret) 1049 ret = print_graph_entry_leaf(iter, field, leaf_ret, s, flags); 1050 else 1051 ret = print_graph_entry_nested(iter, field, s, cpu, flags); 1052 1053 if (data) { 1054 /* 1055 * If we failed to write our output, then we need to make 1056 * note of it. Because we already consumed our entry. 1057 */ 1058 if (s->full) { 1059 data->failed = 1; 1060 data->cpu = cpu; 1061 } else 1062 data->failed = 0; 1063 } 1064 1065 return ret; 1066 } 1067 1068 static enum print_line_t 1069 print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s, 1070 struct trace_entry *ent, struct trace_iterator *iter, 1071 u32 flags) 1072 { 1073 unsigned long long duration = trace->rettime - trace->calltime; 1074 struct fgraph_data *data = iter->private; 1075 pid_t pid = ent->pid; 1076 int cpu = iter->cpu; 1077 int func_match = 1; 1078 int ret; 1079 int i; 1080 1081 if (check_irq_return(iter, flags, trace->depth)) 1082 return TRACE_TYPE_HANDLED; 1083 1084 if (data) { 1085 struct fgraph_cpu_data *cpu_data; 1086 int cpu = iter->cpu; 1087 1088 cpu_data = per_cpu_ptr(data->cpu_data, cpu); 1089 1090 /* 1091 * Comments display at + 1 to depth. This is the 1092 * return from a function, we now want the comments 1093 * to display at the same level of the bracket. 1094 */ 1095 cpu_data->depth = trace->depth - 1; 1096 1097 if (trace->depth < FTRACE_RETFUNC_DEPTH) { 1098 if (cpu_data->enter_funcs[trace->depth] != trace->func) 1099 func_match = 0; 1100 cpu_data->enter_funcs[trace->depth] = 0; 1101 } 1102 } 1103 1104 if (print_graph_prologue(iter, s, 0, 0, flags)) 1105 return TRACE_TYPE_PARTIAL_LINE; 1106 1107 /* Overhead and duration */ 1108 ret = print_graph_duration(duration, s, flags); 1109 if (ret == TRACE_TYPE_PARTIAL_LINE) 1110 return TRACE_TYPE_PARTIAL_LINE; 1111 1112 /* Closing brace */ 1113 for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) { 1114 ret = trace_seq_printf(s, " "); 1115 if (!ret) 1116 return TRACE_TYPE_PARTIAL_LINE; 1117 } 1118 1119 /* 1120 * If the return function does not have a matching entry, 1121 * then the entry was lost. Instead of just printing 1122 * the '}' and letting the user guess what function this 1123 * belongs to, write out the function name. 1124 */ 1125 if (func_match) { 1126 ret = trace_seq_printf(s, "}\n"); 1127 if (!ret) 1128 return TRACE_TYPE_PARTIAL_LINE; 1129 } else { 1130 ret = trace_seq_printf(s, "} /* %ps */\n", (void *)trace->func); 1131 if (!ret) 1132 return TRACE_TYPE_PARTIAL_LINE; 1133 } 1134 1135 /* Overrun */ 1136 if (flags & TRACE_GRAPH_PRINT_OVERRUN) { 1137 ret = trace_seq_printf(s, " (Overruns: %lu)\n", 1138 trace->overrun); 1139 if (!ret) 1140 return TRACE_TYPE_PARTIAL_LINE; 1141 } 1142 1143 ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, 1144 cpu, pid, flags); 1145 if (ret == TRACE_TYPE_PARTIAL_LINE) 1146 return TRACE_TYPE_PARTIAL_LINE; 1147 1148 return TRACE_TYPE_HANDLED; 1149 } 1150 1151 static enum print_line_t 1152 print_graph_comment(struct trace_seq *s, struct trace_entry *ent, 1153 struct trace_iterator *iter, u32 flags) 1154 { 1155 unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK); 1156 struct fgraph_data *data = iter->private; 1157 struct trace_event *event; 1158 int depth = 0; 1159 int ret; 1160 int i; 1161 1162 if (data) 1163 depth = per_cpu_ptr(data->cpu_data, iter->cpu)->depth; 1164 1165 if (print_graph_prologue(iter, s, 0, 0, flags)) 1166 return TRACE_TYPE_PARTIAL_LINE; 1167 1168 /* No time */ 1169 ret = print_graph_duration(DURATION_FILL_FULL, s, flags); 1170 if (ret != TRACE_TYPE_HANDLED) 1171 return ret; 1172 1173 /* Indentation */ 1174 if (depth > 0) 1175 for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++) { 1176 ret = trace_seq_printf(s, " "); 1177 if (!ret) 1178 return TRACE_TYPE_PARTIAL_LINE; 1179 } 1180 1181 /* The comment */ 1182 ret = trace_seq_printf(s, "/* "); 1183 if (!ret) 1184 return TRACE_TYPE_PARTIAL_LINE; 1185 1186 switch (iter->ent->type) { 1187 case TRACE_BPRINT: 1188 ret = trace_print_bprintk_msg_only(iter); 1189 if (ret != TRACE_TYPE_HANDLED) 1190 return ret; 1191 break; 1192 case TRACE_PRINT: 1193 ret = trace_print_printk_msg_only(iter); 1194 if (ret != TRACE_TYPE_HANDLED) 1195 return ret; 1196 break; 1197 default: 1198 event = ftrace_find_event(ent->type); 1199 if (!event) 1200 return TRACE_TYPE_UNHANDLED; 1201 1202 ret = event->funcs->trace(iter, sym_flags, event); 1203 if (ret != TRACE_TYPE_HANDLED) 1204 return ret; 1205 } 1206 1207 /* Strip ending newline */ 1208 if (s->buffer[s->len - 1] == '\n') { 1209 s->buffer[s->len - 1] = '\0'; 1210 s->len--; 1211 } 1212 1213 ret = trace_seq_printf(s, " */\n"); 1214 if (!ret) 1215 return TRACE_TYPE_PARTIAL_LINE; 1216 1217 return TRACE_TYPE_HANDLED; 1218 } 1219 1220 1221 enum print_line_t 1222 print_graph_function_flags(struct trace_iterator *iter, u32 flags) 1223 { 1224 struct ftrace_graph_ent_entry *field; 1225 struct fgraph_data *data = iter->private; 1226 struct trace_entry *entry = iter->ent; 1227 struct trace_seq *s = &iter->seq; 1228 int cpu = iter->cpu; 1229 int ret; 1230 1231 if (data && per_cpu_ptr(data->cpu_data, cpu)->ignore) { 1232 per_cpu_ptr(data->cpu_data, cpu)->ignore = 0; 1233 return TRACE_TYPE_HANDLED; 1234 } 1235 1236 /* 1237 * If the last output failed, there's a possibility we need 1238 * to print out the missing entry which would never go out. 1239 */ 1240 if (data && data->failed) { 1241 field = &data->ent; 1242 iter->cpu = data->cpu; 1243 ret = print_graph_entry(field, s, iter, flags); 1244 if (ret == TRACE_TYPE_HANDLED && iter->cpu != cpu) { 1245 per_cpu_ptr(data->cpu_data, iter->cpu)->ignore = 1; 1246 ret = TRACE_TYPE_NO_CONSUME; 1247 } 1248 iter->cpu = cpu; 1249 return ret; 1250 } 1251 1252 switch (entry->type) { 1253 case TRACE_GRAPH_ENT: { 1254 /* 1255 * print_graph_entry() may consume the current event, 1256 * thus @field may become invalid, so we need to save it. 1257 * sizeof(struct ftrace_graph_ent_entry) is very small, 1258 * it can be safely saved at the stack. 1259 */ 1260 struct ftrace_graph_ent_entry saved; 1261 trace_assign_type(field, entry); 1262 saved = *field; 1263 return print_graph_entry(&saved, s, iter, flags); 1264 } 1265 case TRACE_GRAPH_RET: { 1266 struct ftrace_graph_ret_entry *field; 1267 trace_assign_type(field, entry); 1268 return print_graph_return(&field->ret, s, entry, iter, flags); 1269 } 1270 case TRACE_STACK: 1271 case TRACE_FN: 1272 /* dont trace stack and functions as comments */ 1273 return TRACE_TYPE_UNHANDLED; 1274 1275 default: 1276 return print_graph_comment(s, entry, iter, flags); 1277 } 1278 1279 return TRACE_TYPE_HANDLED; 1280 } 1281 1282 static enum print_line_t 1283 print_graph_function(struct trace_iterator *iter) 1284 { 1285 return print_graph_function_flags(iter, tracer_flags.val); 1286 } 1287 1288 static enum print_line_t 1289 print_graph_function_event(struct trace_iterator *iter, int flags, 1290 struct trace_event *event) 1291 { 1292 return print_graph_function(iter); 1293 } 1294 1295 static void print_lat_header(struct seq_file *s, u32 flags) 1296 { 1297 static const char spaces[] = " " /* 16 spaces */ 1298 " " /* 4 spaces */ 1299 " "; /* 17 spaces */ 1300 int size = 0; 1301 1302 if (flags & TRACE_GRAPH_PRINT_ABS_TIME) 1303 size += 16; 1304 if (flags & TRACE_GRAPH_PRINT_CPU) 1305 size += 4; 1306 if (flags & TRACE_GRAPH_PRINT_PROC) 1307 size += 17; 1308 1309 seq_printf(s, "#%.*s _-----=> irqs-off \n", size, spaces); 1310 seq_printf(s, "#%.*s / _----=> need-resched \n", size, spaces); 1311 seq_printf(s, "#%.*s| / _---=> hardirq/softirq \n", size, spaces); 1312 seq_printf(s, "#%.*s|| / _--=> preempt-depth \n", size, spaces); 1313 seq_printf(s, "#%.*s||| / \n", size, spaces); 1314 } 1315 1316 static void __print_graph_headers_flags(struct seq_file *s, u32 flags) 1317 { 1318 int lat = trace_flags & TRACE_ITER_LATENCY_FMT; 1319 1320 if (lat) 1321 print_lat_header(s, flags); 1322 1323 /* 1st line */ 1324 seq_printf(s, "#"); 1325 if (flags & TRACE_GRAPH_PRINT_ABS_TIME) 1326 seq_printf(s, " TIME "); 1327 if (flags & TRACE_GRAPH_PRINT_CPU) 1328 seq_printf(s, " CPU"); 1329 if (flags & TRACE_GRAPH_PRINT_PROC) 1330 seq_printf(s, " TASK/PID "); 1331 if (lat) 1332 seq_printf(s, "||||"); 1333 if (flags & TRACE_GRAPH_PRINT_DURATION) 1334 seq_printf(s, " DURATION "); 1335 seq_printf(s, " FUNCTION CALLS\n"); 1336 1337 /* 2nd line */ 1338 seq_printf(s, "#"); 1339 if (flags & TRACE_GRAPH_PRINT_ABS_TIME) 1340 seq_printf(s, " | "); 1341 if (flags & TRACE_GRAPH_PRINT_CPU) 1342 seq_printf(s, " | "); 1343 if (flags & TRACE_GRAPH_PRINT_PROC) 1344 seq_printf(s, " | | "); 1345 if (lat) 1346 seq_printf(s, "||||"); 1347 if (flags & TRACE_GRAPH_PRINT_DURATION) 1348 seq_printf(s, " | | "); 1349 seq_printf(s, " | | | |\n"); 1350 } 1351 1352 void print_graph_headers(struct seq_file *s) 1353 { 1354 print_graph_headers_flags(s, tracer_flags.val); 1355 } 1356 1357 void print_graph_headers_flags(struct seq_file *s, u32 flags) 1358 { 1359 struct trace_iterator *iter = s->private; 1360 1361 if (!(trace_flags & TRACE_ITER_CONTEXT_INFO)) 1362 return; 1363 1364 if (trace_flags & TRACE_ITER_LATENCY_FMT) { 1365 /* print nothing if the buffers are empty */ 1366 if (trace_empty(iter)) 1367 return; 1368 1369 print_trace_header(s, iter); 1370 } 1371 1372 __print_graph_headers_flags(s, flags); 1373 } 1374 1375 void graph_trace_open(struct trace_iterator *iter) 1376 { 1377 /* pid and depth on the last trace processed */ 1378 struct fgraph_data *data; 1379 int cpu; 1380 1381 iter->private = NULL; 1382 1383 data = kzalloc(sizeof(*data), GFP_KERNEL); 1384 if (!data) 1385 goto out_err; 1386 1387 data->cpu_data = alloc_percpu(struct fgraph_cpu_data); 1388 if (!data->cpu_data) 1389 goto out_err_free; 1390 1391 for_each_possible_cpu(cpu) { 1392 pid_t *pid = &(per_cpu_ptr(data->cpu_data, cpu)->last_pid); 1393 int *depth = &(per_cpu_ptr(data->cpu_data, cpu)->depth); 1394 int *ignore = &(per_cpu_ptr(data->cpu_data, cpu)->ignore); 1395 int *depth_irq = &(per_cpu_ptr(data->cpu_data, cpu)->depth_irq); 1396 1397 *pid = -1; 1398 *depth = 0; 1399 *ignore = 0; 1400 *depth_irq = -1; 1401 } 1402 1403 iter->private = data; 1404 1405 return; 1406 1407 out_err_free: 1408 kfree(data); 1409 out_err: 1410 pr_warning("function graph tracer: not enough memory\n"); 1411 } 1412 1413 void graph_trace_close(struct trace_iterator *iter) 1414 { 1415 struct fgraph_data *data = iter->private; 1416 1417 if (data) { 1418 free_percpu(data->cpu_data); 1419 kfree(data); 1420 } 1421 } 1422 1423 static int func_graph_set_flag(u32 old_flags, u32 bit, int set) 1424 { 1425 if (bit == TRACE_GRAPH_PRINT_IRQS) 1426 ftrace_graph_skip_irqs = !set; 1427 1428 return 0; 1429 } 1430 1431 static struct trace_event_functions graph_functions = { 1432 .trace = print_graph_function_event, 1433 }; 1434 1435 static struct trace_event graph_trace_entry_event = { 1436 .type = TRACE_GRAPH_ENT, 1437 .funcs = &graph_functions, 1438 }; 1439 1440 static struct trace_event graph_trace_ret_event = { 1441 .type = TRACE_GRAPH_RET, 1442 .funcs = &graph_functions 1443 }; 1444 1445 static struct tracer graph_trace __read_mostly = { 1446 .name = "function_graph", 1447 .open = graph_trace_open, 1448 .pipe_open = graph_trace_open, 1449 .close = graph_trace_close, 1450 .pipe_close = graph_trace_close, 1451 .wait_pipe = poll_wait_pipe, 1452 .init = graph_trace_init, 1453 .reset = graph_trace_reset, 1454 .print_line = print_graph_function, 1455 .print_header = print_graph_headers, 1456 .flags = &tracer_flags, 1457 .set_flag = func_graph_set_flag, 1458 #ifdef CONFIG_FTRACE_SELFTEST 1459 .selftest = trace_selftest_startup_function_graph, 1460 #endif 1461 }; 1462 1463 1464 static ssize_t 1465 graph_depth_write(struct file *filp, const char __user *ubuf, size_t cnt, 1466 loff_t *ppos) 1467 { 1468 unsigned long val; 1469 int ret; 1470 1471 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 1472 if (ret) 1473 return ret; 1474 1475 max_depth = val; 1476 1477 *ppos += cnt; 1478 1479 return cnt; 1480 } 1481 1482 static ssize_t 1483 graph_depth_read(struct file *filp, char __user *ubuf, size_t cnt, 1484 loff_t *ppos) 1485 { 1486 char buf[15]; /* More than enough to hold UINT_MAX + "\n"*/ 1487 int n; 1488 1489 n = sprintf(buf, "%d\n", max_depth); 1490 1491 return simple_read_from_buffer(ubuf, cnt, ppos, buf, n); 1492 } 1493 1494 static const struct file_operations graph_depth_fops = { 1495 .open = tracing_open_generic, 1496 .write = graph_depth_write, 1497 .read = graph_depth_read, 1498 .llseek = generic_file_llseek, 1499 }; 1500 1501 static __init int init_graph_debugfs(void) 1502 { 1503 struct dentry *d_tracer; 1504 1505 d_tracer = tracing_init_dentry(); 1506 if (!d_tracer) 1507 return 0; 1508 1509 trace_create_file("max_graph_depth", 0644, d_tracer, 1510 NULL, &graph_depth_fops); 1511 1512 return 0; 1513 } 1514 fs_initcall(init_graph_debugfs); 1515 1516 static __init int init_graph_trace(void) 1517 { 1518 max_bytes_for_cpu = snprintf(NULL, 0, "%d", nr_cpu_ids - 1); 1519 1520 if (!register_ftrace_event(&graph_trace_entry_event)) { 1521 pr_warning("Warning: could not register graph trace events\n"); 1522 return 1; 1523 } 1524 1525 if (!register_ftrace_event(&graph_trace_ret_event)) { 1526 pr_warning("Warning: could not register graph trace events\n"); 1527 return 1; 1528 } 1529 1530 return register_tracer(&graph_trace); 1531 } 1532 1533 core_initcall(init_graph_trace); 1534