3 * Function graph tracer.
4 * Copyright (c) 2008-2009 Frederic Weisbecker <fweisbec@gmail.com>
5 * Mostly borrowed from function tracer which
6 * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
9 #include <linux/debugfs.h>
10 #include <linux/uaccess.h>
11 #include <linux/ftrace.h>
15 #include "trace_output.h"
22 #define TRACE_GRAPH_INDENT 2
25 #define TRACE_GRAPH_PRINT_OVERRUN 0x1
26 #define TRACE_GRAPH_PRINT_CPU 0x2
27 #define TRACE_GRAPH_PRINT_OVERHEAD 0x4
28 #define TRACE_GRAPH_PRINT_PROC 0x8
29 #define TRACE_GRAPH_PRINT_DURATION 0x10
30 #define TRACE_GRAPH_PRINT_ABS_TIME 0X20
32 static struct tracer_opt trace_opts
[] = {
33 /* Display overruns? (for self-debug purpose) */
34 { TRACER_OPT(funcgraph
-overrun
, TRACE_GRAPH_PRINT_OVERRUN
) },
36 { TRACER_OPT(funcgraph
-cpu
, TRACE_GRAPH_PRINT_CPU
) },
37 /* Display Overhead ? */
38 { TRACER_OPT(funcgraph
-overhead
, TRACE_GRAPH_PRINT_OVERHEAD
) },
39 /* Display proc name/pid */
40 { TRACER_OPT(funcgraph
-proc
, TRACE_GRAPH_PRINT_PROC
) },
41 /* Display duration of execution */
42 { TRACER_OPT(funcgraph
-duration
, TRACE_GRAPH_PRINT_DURATION
) },
43 /* Display absolute time of an entry */
44 { TRACER_OPT(funcgraph
-abstime
, TRACE_GRAPH_PRINT_ABS_TIME
) },
48 static struct tracer_flags tracer_flags
= {
49 /* Don't display overruns and proc by default */
50 .val
= TRACE_GRAPH_PRINT_CPU
| TRACE_GRAPH_PRINT_OVERHEAD
|
51 TRACE_GRAPH_PRINT_DURATION
,
55 /* pid on the last trace processed */
58 /* Add a function return address to the trace stack on thread info.*/
60 ftrace_push_return_trace(unsigned long ret
, unsigned long func
, int *depth
)
62 unsigned long long calltime
;
65 if (!current
->ret_stack
)
68 /* The return trace stack is full */
69 if (current
->curr_ret_stack
== FTRACE_RETFUNC_DEPTH
- 1) {
70 atomic_inc(¤t
->trace_overrun
);
74 calltime
= trace_clock_local();
76 index
= ++current
->curr_ret_stack
;
78 current
->ret_stack
[index
].ret
= ret
;
79 current
->ret_stack
[index
].func
= func
;
80 current
->ret_stack
[index
].calltime
= calltime
;
81 current
->ret_stack
[index
].subtime
= 0;
87 /* Retrieve a function return address to the trace stack on thread info.*/
89 ftrace_pop_return_trace(struct ftrace_graph_ret
*trace
, unsigned long *ret
)
93 index
= current
->curr_ret_stack
;
95 if (unlikely(index
< 0)) {
98 /* Might as well panic, otherwise we have no where to go */
99 *ret
= (unsigned long)panic
;
103 *ret
= current
->ret_stack
[index
].ret
;
104 trace
->func
= current
->ret_stack
[index
].func
;
105 trace
->calltime
= current
->ret_stack
[index
].calltime
;
106 trace
->overrun
= atomic_read(¤t
->trace_overrun
);
107 trace
->depth
= index
;
111 * Send the trace to the ring-buffer.
112 * @return the original return address.
114 unsigned long ftrace_return_to_handler(void)
116 struct ftrace_graph_ret trace
;
119 ftrace_pop_return_trace(&trace
, &ret
);
120 trace
.rettime
= trace_clock_local();
121 ftrace_graph_return(&trace
);
123 current
->curr_ret_stack
--;
125 if (unlikely(!ret
)) {
128 /* Might as well panic. What else to do? */
129 ret
= (unsigned long)panic
;
135 static int graph_trace_init(struct trace_array
*tr
)
137 int ret
= register_ftrace_graph(&trace_graph_return
,
141 tracing_start_cmdline_record();
146 static void graph_trace_reset(struct trace_array
*tr
)
148 tracing_stop_cmdline_record();
149 unregister_ftrace_graph();
152 static inline int log10_cpu(int nb
)
161 static enum print_line_t
162 print_graph_cpu(struct trace_seq
*s
, int cpu
)
166 int log10_this
= log10_cpu(cpu
);
167 int log10_all
= log10_cpu(cpumask_weight(cpu_online_mask
));
171 * Start with a space character - to make it stand out
172 * to the right a bit when trace output is pasted into
175 ret
= trace_seq_printf(s
, " ");
178 * Tricky - we space the CPU field according to the max
179 * number of online CPUs. On a 2-cpu system it would take
180 * a maximum of 1 digit - on a 128 cpu system it would
181 * take up to 3 digits:
183 for (i
= 0; i
< log10_all
- log10_this
; i
++) {
184 ret
= trace_seq_printf(s
, " ");
186 return TRACE_TYPE_PARTIAL_LINE
;
188 ret
= trace_seq_printf(s
, "%d) ", cpu
);
190 return TRACE_TYPE_PARTIAL_LINE
;
192 return TRACE_TYPE_HANDLED
;
195 #define TRACE_GRAPH_PROCINFO_LENGTH 14
197 static enum print_line_t
198 print_graph_proc(struct trace_seq
*s
, pid_t pid
)
200 char comm
[TASK_COMM_LEN
];
201 /* sign + log10(MAX_INT) + '\0' */
208 trace_find_cmdline(pid
, comm
);
210 sprintf(pid_str
, "%d", pid
);
212 /* 1 stands for the "-" character */
213 len
= strlen(comm
) + strlen(pid_str
) + 1;
215 if (len
< TRACE_GRAPH_PROCINFO_LENGTH
)
216 spaces
= TRACE_GRAPH_PROCINFO_LENGTH
- len
;
218 /* First spaces to align center */
219 for (i
= 0; i
< spaces
/ 2; i
++) {
220 ret
= trace_seq_printf(s
, " ");
222 return TRACE_TYPE_PARTIAL_LINE
;
225 ret
= trace_seq_printf(s
, "%s-%s", comm
, pid_str
);
227 return TRACE_TYPE_PARTIAL_LINE
;
229 /* Last spaces to align center */
230 for (i
= 0; i
< spaces
- (spaces
/ 2); i
++) {
231 ret
= trace_seq_printf(s
, " ");
233 return TRACE_TYPE_PARTIAL_LINE
;
235 return TRACE_TYPE_HANDLED
;
239 /* If the pid changed since the last trace, output this event */
240 static enum print_line_t
241 verif_pid(struct trace_seq
*s
, pid_t pid
, int cpu
, struct fgraph_data
*data
)
248 return TRACE_TYPE_HANDLED
;
250 last_pid
= &(per_cpu_ptr(data
, cpu
)->last_pid
);
252 if (*last_pid
== pid
)
253 return TRACE_TYPE_HANDLED
;
255 prev_pid
= *last_pid
;
259 return TRACE_TYPE_HANDLED
;
261 * Context-switch trace line:
263 ------------------------------------------
264 | 1) migration/0--1 => sshd-1755
265 ------------------------------------------
268 ret
= trace_seq_printf(s
,
269 " ------------------------------------------\n");
271 return TRACE_TYPE_PARTIAL_LINE
;
273 ret
= print_graph_cpu(s
, cpu
);
274 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
275 return TRACE_TYPE_PARTIAL_LINE
;
277 ret
= print_graph_proc(s
, prev_pid
);
278 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
279 return TRACE_TYPE_PARTIAL_LINE
;
281 ret
= trace_seq_printf(s
, " => ");
283 return TRACE_TYPE_PARTIAL_LINE
;
285 ret
= print_graph_proc(s
, pid
);
286 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
287 return TRACE_TYPE_PARTIAL_LINE
;
289 ret
= trace_seq_printf(s
,
290 "\n ------------------------------------------\n\n");
292 return TRACE_TYPE_PARTIAL_LINE
;
294 return TRACE_TYPE_HANDLED
;
297 static struct ftrace_graph_ret_entry
*
298 get_return_for_leaf(struct trace_iterator
*iter
,
299 struct ftrace_graph_ent_entry
*curr
)
301 struct ring_buffer_iter
*ring_iter
;
302 struct ring_buffer_event
*event
;
303 struct ftrace_graph_ret_entry
*next
;
305 ring_iter
= iter
->buffer_iter
[iter
->cpu
];
307 /* First peek to compare current entry and the next one */
309 event
= ring_buffer_iter_peek(ring_iter
, NULL
);
311 /* We need to consume the current entry to see the next one */
312 ring_buffer_consume(iter
->tr
->buffer
, iter
->cpu
, NULL
);
313 event
= ring_buffer_peek(iter
->tr
->buffer
, iter
->cpu
,
320 next
= ring_buffer_event_data(event
);
322 if (next
->ent
.type
!= TRACE_GRAPH_RET
)
325 if (curr
->ent
.pid
!= next
->ent
.pid
||
326 curr
->graph_ent
.func
!= next
->ret
.func
)
329 /* this is a leaf, now advance the iterator */
331 ring_buffer_read(ring_iter
, NULL
);
336 /* Signal a overhead of time execution to the output */
338 print_graph_overhead(unsigned long long duration
, struct trace_seq
*s
)
340 /* If duration disappear, we don't need anything */
341 if (!(tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
))
344 /* Non nested entry or return */
346 return trace_seq_printf(s
, " ");
348 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_OVERHEAD
) {
349 /* Duration exceeded 100 msecs */
350 if (duration
> 100000ULL)
351 return trace_seq_printf(s
, "! ");
353 /* Duration exceeded 10 msecs */
354 if (duration
> 10000ULL)
355 return trace_seq_printf(s
, "+ ");
358 return trace_seq_printf(s
, " ");
361 static int print_graph_abs_time(u64 t
, struct trace_seq
*s
)
363 unsigned long usecs_rem
;
365 usecs_rem
= do_div(t
, NSEC_PER_SEC
);
368 return trace_seq_printf(s
, "%5lu.%06lu | ",
369 (unsigned long)t
, usecs_rem
);
372 static enum print_line_t
373 print_graph_irq(struct trace_iterator
*iter
, unsigned long addr
,
374 enum trace_type type
, int cpu
, pid_t pid
)
377 struct trace_seq
*s
= &iter
->seq
;
379 if (addr
< (unsigned long)__irqentry_text_start
||
380 addr
>= (unsigned long)__irqentry_text_end
)
381 return TRACE_TYPE_UNHANDLED
;
384 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_ABS_TIME
) {
385 ret
= print_graph_abs_time(iter
->ts
, s
);
387 return TRACE_TYPE_PARTIAL_LINE
;
391 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_CPU
) {
392 ret
= print_graph_cpu(s
, cpu
);
393 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
394 return TRACE_TYPE_PARTIAL_LINE
;
397 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_PROC
) {
398 ret
= print_graph_proc(s
, pid
);
399 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
400 return TRACE_TYPE_PARTIAL_LINE
;
401 ret
= trace_seq_printf(s
, " | ");
403 return TRACE_TYPE_PARTIAL_LINE
;
407 ret
= print_graph_overhead(-1, s
);
409 return TRACE_TYPE_PARTIAL_LINE
;
411 if (type
== TRACE_GRAPH_ENT
)
412 ret
= trace_seq_printf(s
, "==========>");
414 ret
= trace_seq_printf(s
, "<==========");
417 return TRACE_TYPE_PARTIAL_LINE
;
419 /* Don't close the duration column if haven't one */
420 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
)
421 trace_seq_printf(s
, " |");
422 ret
= trace_seq_printf(s
, "\n");
425 return TRACE_TYPE_PARTIAL_LINE
;
426 return TRACE_TYPE_HANDLED
;
430 trace_print_graph_duration(unsigned long long duration
, struct trace_seq
*s
)
432 unsigned long nsecs_rem
= do_div(duration
, 1000);
433 /* log10(ULONG_MAX) + '\0' */
439 snprintf(msecs_str
, sizeof(msecs_str
), "%lu", (unsigned long) duration
);
442 ret
= trace_seq_printf(s
, "%s", msecs_str
);
444 return TRACE_TYPE_PARTIAL_LINE
;
446 len
= strlen(msecs_str
);
448 /* Print nsecs (we don't want to exceed 7 numbers) */
450 snprintf(nsecs_str
, 8 - len
, "%03lu", nsecs_rem
);
451 ret
= trace_seq_printf(s
, ".%s", nsecs_str
);
453 return TRACE_TYPE_PARTIAL_LINE
;
454 len
+= strlen(nsecs_str
);
457 ret
= trace_seq_printf(s
, " us ");
459 return TRACE_TYPE_PARTIAL_LINE
;
461 /* Print remaining spaces to fit the row's width */
462 for (i
= len
; i
< 7; i
++) {
463 ret
= trace_seq_printf(s
, " ");
465 return TRACE_TYPE_PARTIAL_LINE
;
467 return TRACE_TYPE_HANDLED
;
470 static enum print_line_t
471 print_graph_duration(unsigned long long duration
, struct trace_seq
*s
)
475 ret
= trace_print_graph_duration(duration
, s
);
476 if (ret
!= TRACE_TYPE_HANDLED
)
479 ret
= trace_seq_printf(s
, "| ");
481 return TRACE_TYPE_PARTIAL_LINE
;
483 return TRACE_TYPE_HANDLED
;
486 /* Case of a leaf function on its call entry */
487 static enum print_line_t
488 print_graph_entry_leaf(struct trace_iterator
*iter
,
489 struct ftrace_graph_ent_entry
*entry
,
490 struct ftrace_graph_ret_entry
*ret_entry
, struct trace_seq
*s
)
492 struct fgraph_data
*data
= iter
->private;
493 struct ftrace_graph_ret
*graph_ret
;
494 struct ftrace_graph_ent
*call
;
495 unsigned long long duration
;
499 graph_ret
= &ret_entry
->ret
;
500 call
= &entry
->graph_ent
;
501 duration
= graph_ret
->rettime
- graph_ret
->calltime
;
505 int *depth
= &(per_cpu_ptr(data
, cpu
)->depth
);
508 * Comments display at + 1 to depth. Since
509 * this is a leaf function, keep the comments
510 * equal to this depth.
512 *depth
= call
->depth
- 1;
516 ret
= print_graph_overhead(duration
, s
);
518 return TRACE_TYPE_PARTIAL_LINE
;
521 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
) {
522 ret
= print_graph_duration(duration
, s
);
523 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
524 return TRACE_TYPE_PARTIAL_LINE
;
528 for (i
= 0; i
< call
->depth
* TRACE_GRAPH_INDENT
; i
++) {
529 ret
= trace_seq_printf(s
, " ");
531 return TRACE_TYPE_PARTIAL_LINE
;
534 ret
= seq_print_ip_sym(s
, call
->func
, 0);
536 return TRACE_TYPE_PARTIAL_LINE
;
538 ret
= trace_seq_printf(s
, "();\n");
540 return TRACE_TYPE_PARTIAL_LINE
;
542 return TRACE_TYPE_HANDLED
;
545 static enum print_line_t
546 print_graph_entry_nested(struct trace_iterator
*iter
,
547 struct ftrace_graph_ent_entry
*entry
,
548 struct trace_seq
*s
, int cpu
)
550 struct ftrace_graph_ent
*call
= &entry
->graph_ent
;
551 struct fgraph_data
*data
= iter
->private;
557 int *depth
= &(per_cpu_ptr(data
, cpu
)->depth
);
559 *depth
= call
->depth
;
563 ret
= print_graph_overhead(-1, s
);
565 return TRACE_TYPE_PARTIAL_LINE
;
568 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
) {
569 ret
= trace_seq_printf(s
, " | ");
571 return TRACE_TYPE_PARTIAL_LINE
;
575 for (i
= 0; i
< call
->depth
* TRACE_GRAPH_INDENT
; i
++) {
576 ret
= trace_seq_printf(s
, " ");
578 return TRACE_TYPE_PARTIAL_LINE
;
581 ret
= seq_print_ip_sym(s
, call
->func
, 0);
583 return TRACE_TYPE_PARTIAL_LINE
;
585 ret
= trace_seq_printf(s
, "() {\n");
587 return TRACE_TYPE_PARTIAL_LINE
;
590 * we already consumed the current entry to check the next one
591 * and see if this is a leaf.
593 return TRACE_TYPE_NO_CONSUME
;
596 static enum print_line_t
597 print_graph_prologue(struct trace_iterator
*iter
, struct trace_seq
*s
,
598 int type
, unsigned long addr
)
600 struct fgraph_data
*data
= iter
->private;
601 struct trace_entry
*ent
= iter
->ent
;
606 if (verif_pid(s
, ent
->pid
, cpu
, data
) == TRACE_TYPE_PARTIAL_LINE
)
607 return TRACE_TYPE_PARTIAL_LINE
;
611 ret
= print_graph_irq(iter
, addr
, type
, cpu
, ent
->pid
);
612 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
613 return TRACE_TYPE_PARTIAL_LINE
;
617 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_ABS_TIME
) {
618 ret
= print_graph_abs_time(iter
->ts
, s
);
620 return TRACE_TYPE_PARTIAL_LINE
;
624 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_CPU
) {
625 ret
= print_graph_cpu(s
, cpu
);
626 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
627 return TRACE_TYPE_PARTIAL_LINE
;
631 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_PROC
) {
632 ret
= print_graph_proc(s
, ent
->pid
);
633 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
634 return TRACE_TYPE_PARTIAL_LINE
;
636 ret
= trace_seq_printf(s
, " | ");
638 return TRACE_TYPE_PARTIAL_LINE
;
644 static enum print_line_t
645 print_graph_entry(struct ftrace_graph_ent_entry
*field
, struct trace_seq
*s
,
646 struct trace_iterator
*iter
)
649 struct ftrace_graph_ent
*call
= &field
->graph_ent
;
650 struct ftrace_graph_ret_entry
*leaf_ret
;
652 if (print_graph_prologue(iter
, s
, TRACE_GRAPH_ENT
, call
->func
))
653 return TRACE_TYPE_PARTIAL_LINE
;
655 leaf_ret
= get_return_for_leaf(iter
, field
);
657 return print_graph_entry_leaf(iter
, field
, leaf_ret
, s
);
659 return print_graph_entry_nested(iter
, field
, s
, cpu
);
663 static enum print_line_t
664 print_graph_return(struct ftrace_graph_ret
*trace
, struct trace_seq
*s
,
665 struct trace_entry
*ent
, struct trace_iterator
*iter
)
667 unsigned long long duration
= trace
->rettime
- trace
->calltime
;
668 struct fgraph_data
*data
= iter
->private;
669 pid_t pid
= ent
->pid
;
676 int *depth
= &(per_cpu_ptr(data
, cpu
)->depth
);
679 * Comments display at + 1 to depth. This is the
680 * return from a function, we now want the comments
681 * to display at the same level of the bracket.
683 *depth
= trace
->depth
- 1;
686 if (print_graph_prologue(iter
, s
, 0, 0))
687 return TRACE_TYPE_PARTIAL_LINE
;
690 ret
= print_graph_overhead(duration
, s
);
692 return TRACE_TYPE_PARTIAL_LINE
;
695 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
) {
696 ret
= print_graph_duration(duration
, s
);
697 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
698 return TRACE_TYPE_PARTIAL_LINE
;
702 for (i
= 0; i
< trace
->depth
* TRACE_GRAPH_INDENT
; i
++) {
703 ret
= trace_seq_printf(s
, " ");
705 return TRACE_TYPE_PARTIAL_LINE
;
708 ret
= trace_seq_printf(s
, "}\n");
710 return TRACE_TYPE_PARTIAL_LINE
;
713 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_OVERRUN
) {
714 ret
= trace_seq_printf(s
, " (Overruns: %lu)\n",
717 return TRACE_TYPE_PARTIAL_LINE
;
720 ret
= print_graph_irq(iter
, trace
->func
, TRACE_GRAPH_RET
, cpu
, pid
);
721 if (ret
== TRACE_TYPE_PARTIAL_LINE
)
722 return TRACE_TYPE_PARTIAL_LINE
;
724 return TRACE_TYPE_HANDLED
;
727 static enum print_line_t
728 print_graph_comment(struct trace_seq
*s
, struct trace_entry
*ent
,
729 struct trace_iterator
*iter
)
731 unsigned long sym_flags
= (trace_flags
& TRACE_ITER_SYM_MASK
);
732 struct fgraph_data
*data
= iter
->private;
733 struct trace_event
*event
;
739 depth
= per_cpu_ptr(data
, iter
->cpu
)->depth
;
741 if (print_graph_prologue(iter
, s
, 0, 0))
742 return TRACE_TYPE_PARTIAL_LINE
;
745 ret
= print_graph_overhead(-1, s
);
747 return TRACE_TYPE_PARTIAL_LINE
;
750 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
) {
751 ret
= trace_seq_printf(s
, " | ");
753 return TRACE_TYPE_PARTIAL_LINE
;
758 for (i
= 0; i
< (depth
+ 1) * TRACE_GRAPH_INDENT
; i
++) {
759 ret
= trace_seq_printf(s
, " ");
761 return TRACE_TYPE_PARTIAL_LINE
;
765 ret
= trace_seq_printf(s
, "/* ");
767 return TRACE_TYPE_PARTIAL_LINE
;
769 switch (iter
->ent
->type
) {
771 ret
= trace_print_bprintk_msg_only(iter
);
772 if (ret
!= TRACE_TYPE_HANDLED
)
776 ret
= trace_print_printk_msg_only(iter
);
777 if (ret
!= TRACE_TYPE_HANDLED
)
781 event
= ftrace_find_event(ent
->type
);
783 return TRACE_TYPE_UNHANDLED
;
785 ret
= event
->trace(iter
, sym_flags
);
786 if (ret
!= TRACE_TYPE_HANDLED
)
790 /* Strip ending newline */
791 if (s
->buffer
[s
->len
- 1] == '\n') {
792 s
->buffer
[s
->len
- 1] = '\0';
796 ret
= trace_seq_printf(s
, " */\n");
798 return TRACE_TYPE_PARTIAL_LINE
;
800 return TRACE_TYPE_HANDLED
;
805 print_graph_function(struct trace_iterator
*iter
)
807 struct trace_entry
*entry
= iter
->ent
;
808 struct trace_seq
*s
= &iter
->seq
;
810 switch (entry
->type
) {
811 case TRACE_GRAPH_ENT
: {
812 struct ftrace_graph_ent_entry
*field
;
813 trace_assign_type(field
, entry
);
814 return print_graph_entry(field
, s
, iter
);
816 case TRACE_GRAPH_RET
: {
817 struct ftrace_graph_ret_entry
*field
;
818 trace_assign_type(field
, entry
);
819 return print_graph_return(&field
->ret
, s
, entry
, iter
);
822 return print_graph_comment(s
, entry
, iter
);
825 return TRACE_TYPE_HANDLED
;
828 static void print_graph_headers(struct seq_file
*s
)
832 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_ABS_TIME
)
833 seq_printf(s
, " TIME ");
834 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_CPU
)
835 seq_printf(s
, "CPU");
836 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_PROC
)
837 seq_printf(s
, " TASK/PID ");
838 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
)
839 seq_printf(s
, " DURATION ");
840 seq_printf(s
, " FUNCTION CALLS\n");
844 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_ABS_TIME
)
845 seq_printf(s
, " | ");
846 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_CPU
)
848 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_PROC
)
849 seq_printf(s
, " | | ");
850 if (tracer_flags
.val
& TRACE_GRAPH_PRINT_DURATION
)
851 seq_printf(s
, " | | ");
852 seq_printf(s
, " | | | |\n");
855 static void graph_trace_open(struct trace_iterator
*iter
)
857 /* pid and depth on the last trace processed */
858 struct fgraph_data
*data
= alloc_percpu(struct fgraph_data
);
862 pr_warning("function graph tracer: not enough memory\n");
864 for_each_possible_cpu(cpu
) {
865 pid_t
*pid
= &(per_cpu_ptr(data
, cpu
)->last_pid
);
866 int *depth
= &(per_cpu_ptr(data
, cpu
)->depth
);
871 iter
->private = data
;
874 static void graph_trace_close(struct trace_iterator
*iter
)
876 free_percpu(iter
->private);
879 static struct tracer graph_trace __read_mostly
= {
880 .name
= "function_graph",
881 .open
= graph_trace_open
,
882 .close
= graph_trace_close
,
883 .wait_pipe
= poll_wait_pipe
,
884 .init
= graph_trace_init
,
885 .reset
= graph_trace_reset
,
886 .print_line
= print_graph_function
,
887 .print_header
= print_graph_headers
,
888 .flags
= &tracer_flags
,
889 #ifdef CONFIG_FTRACE_SELFTEST
890 .selftest
= trace_selftest_startup_function_graph
,
894 static __init
int init_graph_trace(void)
896 return register_tracer(&graph_trace
);
899 device_initcall(init_graph_trace
);