tracing/core: bring back raw trace_printk for dynamic formats strings
[linux-2.6] / kernel / trace / trace_functions_graph.c
1 /*
2  *
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>
7  *
8  */
9 #include <linux/debugfs.h>
10 #include <linux/uaccess.h>
11 #include <linux/ftrace.h>
12 #include <linux/fs.h>
13
14 #include "trace.h"
15 #include "trace_output.h"
16
17 #define TRACE_GRAPH_INDENT      2
18
19 /* Flag options */
20 #define TRACE_GRAPH_PRINT_OVERRUN       0x1
21 #define TRACE_GRAPH_PRINT_CPU           0x2
22 #define TRACE_GRAPH_PRINT_OVERHEAD      0x4
23 #define TRACE_GRAPH_PRINT_PROC          0x8
24 #define TRACE_GRAPH_PRINT_DURATION      0x10
25 #define TRACE_GRAPH_PRINT_ABS_TIME      0X20
26
27 static struct tracer_opt trace_opts[] = {
28         /* Display overruns? (for self-debug purpose) */
29         { TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
30         /* Display CPU ? */
31         { TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
32         /* Display Overhead ? */
33         { TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
34         /* Display proc name/pid */
35         { TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
36         /* Display duration of execution */
37         { TRACER_OPT(funcgraph-duration, TRACE_GRAPH_PRINT_DURATION) },
38         /* Display absolute time of an entry */
39         { TRACER_OPT(funcgraph-abstime, TRACE_GRAPH_PRINT_ABS_TIME) },
40         { } /* Empty entry */
41 };
42
43 static struct tracer_flags tracer_flags = {
44         /* Don't display overruns and proc by default */
45         .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD |
46                TRACE_GRAPH_PRINT_DURATION,
47         .opts = trace_opts
48 };
49
50 /* pid on the last trace processed */
51
52
53 /* Add a function return address to the trace stack on thread info.*/
54 int
55 ftrace_push_return_trace(unsigned long ret, unsigned long long time,
56                          unsigned long func, int *depth)
57 {
58         int index;
59
60         if (!current->ret_stack)
61                 return -EBUSY;
62
63         /* The return trace stack is full */
64         if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
65                 atomic_inc(&current->trace_overrun);
66                 return -EBUSY;
67         }
68
69         index = ++current->curr_ret_stack;
70         barrier();
71         current->ret_stack[index].ret = ret;
72         current->ret_stack[index].func = func;
73         current->ret_stack[index].calltime = time;
74         *depth = index;
75
76         return 0;
77 }
78
79 /* Retrieve a function return address to the trace stack on thread info.*/
80 void
81 ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
82 {
83         int index;
84
85         index = current->curr_ret_stack;
86
87         if (unlikely(index < 0)) {
88                 ftrace_graph_stop();
89                 WARN_ON(1);
90                 /* Might as well panic, otherwise we have no where to go */
91                 *ret = (unsigned long)panic;
92                 return;
93         }
94
95         *ret = current->ret_stack[index].ret;
96         trace->func = current->ret_stack[index].func;
97         trace->calltime = current->ret_stack[index].calltime;
98         trace->overrun = atomic_read(&current->trace_overrun);
99         trace->depth = index;
100         barrier();
101         current->curr_ret_stack--;
102
103 }
104
105 /*
106  * Send the trace to the ring-buffer.
107  * @return the original return address.
108  */
109 unsigned long ftrace_return_to_handler(void)
110 {
111         struct ftrace_graph_ret trace;
112         unsigned long ret;
113
114         ftrace_pop_return_trace(&trace, &ret);
115         trace.rettime = trace_clock_local();
116         ftrace_graph_return(&trace);
117
118         if (unlikely(!ret)) {
119                 ftrace_graph_stop();
120                 WARN_ON(1);
121                 /* Might as well panic. What else to do? */
122                 ret = (unsigned long)panic;
123         }
124
125         return ret;
126 }
127
128 static int graph_trace_init(struct trace_array *tr)
129 {
130         int ret = register_ftrace_graph(&trace_graph_return,
131                                         &trace_graph_entry);
132         if (ret)
133                 return ret;
134         tracing_start_cmdline_record();
135
136         return 0;
137 }
138
139 static void graph_trace_reset(struct trace_array *tr)
140 {
141         tracing_stop_cmdline_record();
142         unregister_ftrace_graph();
143 }
144
145 static inline int log10_cpu(int nb)
146 {
147         if (nb / 100)
148                 return 3;
149         if (nb / 10)
150                 return 2;
151         return 1;
152 }
153
154 static enum print_line_t
155 print_graph_cpu(struct trace_seq *s, int cpu)
156 {
157         int i;
158         int ret;
159         int log10_this = log10_cpu(cpu);
160         int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
161
162
163         /*
164          * Start with a space character - to make it stand out
165          * to the right a bit when trace output is pasted into
166          * email:
167          */
168         ret = trace_seq_printf(s, " ");
169
170         /*
171          * Tricky - we space the CPU field according to the max
172          * number of online CPUs. On a 2-cpu system it would take
173          * a maximum of 1 digit - on a 128 cpu system it would
174          * take up to 3 digits:
175          */
176         for (i = 0; i < log10_all - log10_this; i++) {
177                 ret = trace_seq_printf(s, " ");
178                 if (!ret)
179                         return TRACE_TYPE_PARTIAL_LINE;
180         }
181         ret = trace_seq_printf(s, "%d) ", cpu);
182         if (!ret)
183                 return TRACE_TYPE_PARTIAL_LINE;
184
185         return TRACE_TYPE_HANDLED;
186 }
187
188 #define TRACE_GRAPH_PROCINFO_LENGTH     14
189
190 static enum print_line_t
191 print_graph_proc(struct trace_seq *s, pid_t pid)
192 {
193         int i;
194         int ret;
195         int len;
196         char comm[8];
197         int spaces = 0;
198         /* sign + log10(MAX_INT) + '\0' */
199         char pid_str[11];
200
201         strncpy(comm, trace_find_cmdline(pid), 7);
202         comm[7] = '\0';
203         sprintf(pid_str, "%d", pid);
204
205         /* 1 stands for the "-" character */
206         len = strlen(comm) + strlen(pid_str) + 1;
207
208         if (len < TRACE_GRAPH_PROCINFO_LENGTH)
209                 spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
210
211         /* First spaces to align center */
212         for (i = 0; i < spaces / 2; i++) {
213                 ret = trace_seq_printf(s, " ");
214                 if (!ret)
215                         return TRACE_TYPE_PARTIAL_LINE;
216         }
217
218         ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
219         if (!ret)
220                 return TRACE_TYPE_PARTIAL_LINE;
221
222         /* Last spaces to align center */
223         for (i = 0; i < spaces - (spaces / 2); i++) {
224                 ret = trace_seq_printf(s, " ");
225                 if (!ret)
226                         return TRACE_TYPE_PARTIAL_LINE;
227         }
228         return TRACE_TYPE_HANDLED;
229 }
230
231
232 /* If the pid changed since the last trace, output this event */
233 static enum print_line_t
234 verif_pid(struct trace_seq *s, pid_t pid, int cpu, pid_t *last_pids_cpu)
235 {
236         pid_t prev_pid;
237         pid_t *last_pid;
238         int ret;
239
240         if (!last_pids_cpu)
241                 return TRACE_TYPE_HANDLED;
242
243         last_pid = per_cpu_ptr(last_pids_cpu, cpu);
244
245         if (*last_pid == pid)
246                 return TRACE_TYPE_HANDLED;
247
248         prev_pid = *last_pid;
249         *last_pid = pid;
250
251         if (prev_pid == -1)
252                 return TRACE_TYPE_HANDLED;
253 /*
254  * Context-switch trace line:
255
256  ------------------------------------------
257  | 1)  migration/0--1  =>  sshd-1755
258  ------------------------------------------
259
260  */
261         ret = trace_seq_printf(s,
262                 " ------------------------------------------\n");
263         if (!ret)
264                 return TRACE_TYPE_PARTIAL_LINE;
265
266         ret = print_graph_cpu(s, cpu);
267         if (ret == TRACE_TYPE_PARTIAL_LINE)
268                 return TRACE_TYPE_PARTIAL_LINE;
269
270         ret = print_graph_proc(s, prev_pid);
271         if (ret == TRACE_TYPE_PARTIAL_LINE)
272                 return TRACE_TYPE_PARTIAL_LINE;
273
274         ret = trace_seq_printf(s, " => ");
275         if (!ret)
276                 return TRACE_TYPE_PARTIAL_LINE;
277
278         ret = print_graph_proc(s, pid);
279         if (ret == TRACE_TYPE_PARTIAL_LINE)
280                 return TRACE_TYPE_PARTIAL_LINE;
281
282         ret = trace_seq_printf(s,
283                 "\n ------------------------------------------\n\n");
284         if (!ret)
285                 return TRACE_TYPE_PARTIAL_LINE;
286
287         return TRACE_TYPE_HANDLED;
288 }
289
290 static struct ftrace_graph_ret_entry *
291 get_return_for_leaf(struct trace_iterator *iter,
292                 struct ftrace_graph_ent_entry *curr)
293 {
294         struct ring_buffer_iter *ring_iter;
295         struct ring_buffer_event *event;
296         struct ftrace_graph_ret_entry *next;
297
298         ring_iter = iter->buffer_iter[iter->cpu];
299
300         /* First peek to compare current entry and the next one */
301         if (ring_iter)
302                 event = ring_buffer_iter_peek(ring_iter, NULL);
303         else {
304         /* We need to consume the current entry to see the next one */
305                 ring_buffer_consume(iter->tr->buffer, iter->cpu, NULL);
306                 event = ring_buffer_peek(iter->tr->buffer, iter->cpu,
307                                         NULL);
308         }
309
310         if (!event)
311                 return NULL;
312
313         next = ring_buffer_event_data(event);
314
315         if (next->ent.type != TRACE_GRAPH_RET)
316                 return NULL;
317
318         if (curr->ent.pid != next->ent.pid ||
319                         curr->graph_ent.func != next->ret.func)
320                 return NULL;
321
322         /* this is a leaf, now advance the iterator */
323         if (ring_iter)
324                 ring_buffer_read(ring_iter, NULL);
325
326         return next;
327 }
328
329 /* Signal a overhead of time execution to the output */
330 static int
331 print_graph_overhead(unsigned long long duration, struct trace_seq *s)
332 {
333         /* If duration disappear, we don't need anything */
334         if (!(tracer_flags.val & TRACE_GRAPH_PRINT_DURATION))
335                 return 1;
336
337         /* Non nested entry or return */
338         if (duration == -1)
339                 return trace_seq_printf(s, "  ");
340
341         if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
342                 /* Duration exceeded 100 msecs */
343                 if (duration > 100000ULL)
344                         return trace_seq_printf(s, "! ");
345
346                 /* Duration exceeded 10 msecs */
347                 if (duration > 10000ULL)
348                         return trace_seq_printf(s, "+ ");
349         }
350
351         return trace_seq_printf(s, "  ");
352 }
353
354 static int print_graph_abs_time(u64 t, struct trace_seq *s)
355 {
356         unsigned long usecs_rem;
357
358         usecs_rem = do_div(t, NSEC_PER_SEC);
359         usecs_rem /= 1000;
360
361         return trace_seq_printf(s, "%5lu.%06lu |  ",
362                         (unsigned long)t, usecs_rem);
363 }
364
365 static enum print_line_t
366 print_graph_irq(struct trace_iterator *iter, unsigned long addr,
367                 enum trace_type type, int cpu, pid_t pid)
368 {
369         int ret;
370         struct trace_seq *s = &iter->seq;
371
372         if (addr < (unsigned long)__irqentry_text_start ||
373                 addr >= (unsigned long)__irqentry_text_end)
374                 return TRACE_TYPE_UNHANDLED;
375
376         /* Absolute time */
377         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
378                 ret = print_graph_abs_time(iter->ts, s);
379                 if (!ret)
380                         return TRACE_TYPE_PARTIAL_LINE;
381         }
382
383         /* Cpu */
384         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
385                 ret = print_graph_cpu(s, cpu);
386                 if (ret == TRACE_TYPE_PARTIAL_LINE)
387                         return TRACE_TYPE_PARTIAL_LINE;
388         }
389         /* Proc */
390         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
391                 ret = print_graph_proc(s, pid);
392                 if (ret == TRACE_TYPE_PARTIAL_LINE)
393                         return TRACE_TYPE_PARTIAL_LINE;
394                 ret = trace_seq_printf(s, " | ");
395                 if (!ret)
396                         return TRACE_TYPE_PARTIAL_LINE;
397         }
398
399         /* No overhead */
400         ret = print_graph_overhead(-1, s);
401         if (!ret)
402                 return TRACE_TYPE_PARTIAL_LINE;
403
404         if (type == TRACE_GRAPH_ENT)
405                 ret = trace_seq_printf(s, "==========>");
406         else
407                 ret = trace_seq_printf(s, "<==========");
408
409         if (!ret)
410                 return TRACE_TYPE_PARTIAL_LINE;
411
412         /* Don't close the duration column if haven't one */
413         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
414                 trace_seq_printf(s, " |");
415         ret = trace_seq_printf(s, "\n");
416
417         if (!ret)
418                 return TRACE_TYPE_PARTIAL_LINE;
419         return TRACE_TYPE_HANDLED;
420 }
421
422 static enum print_line_t
423 print_graph_duration(unsigned long long duration, struct trace_seq *s)
424 {
425         unsigned long nsecs_rem = do_div(duration, 1000);
426         /* log10(ULONG_MAX) + '\0' */
427         char msecs_str[21];
428         char nsecs_str[5];
429         int ret, len;
430         int i;
431
432         sprintf(msecs_str, "%lu", (unsigned long) duration);
433
434         /* Print msecs */
435         ret = trace_seq_printf(s, "%s", msecs_str);
436         if (!ret)
437                 return TRACE_TYPE_PARTIAL_LINE;
438
439         len = strlen(msecs_str);
440
441         /* Print nsecs (we don't want to exceed 7 numbers) */
442         if (len < 7) {
443                 snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
444                 ret = trace_seq_printf(s, ".%s", nsecs_str);
445                 if (!ret)
446                         return TRACE_TYPE_PARTIAL_LINE;
447                 len += strlen(nsecs_str);
448         }
449
450         ret = trace_seq_printf(s, " us ");
451         if (!ret)
452                 return TRACE_TYPE_PARTIAL_LINE;
453
454         /* Print remaining spaces to fit the row's width */
455         for (i = len; i < 7; i++) {
456                 ret = trace_seq_printf(s, " ");
457                 if (!ret)
458                         return TRACE_TYPE_PARTIAL_LINE;
459         }
460
461         ret = trace_seq_printf(s, "|  ");
462         if (!ret)
463                 return TRACE_TYPE_PARTIAL_LINE;
464         return TRACE_TYPE_HANDLED;
465
466 }
467
468 /* Case of a leaf function on its call entry */
469 static enum print_line_t
470 print_graph_entry_leaf(struct trace_iterator *iter,
471                 struct ftrace_graph_ent_entry *entry,
472                 struct ftrace_graph_ret_entry *ret_entry, struct trace_seq *s)
473 {
474         struct ftrace_graph_ret *graph_ret;
475         struct ftrace_graph_ent *call;
476         unsigned long long duration;
477         int ret;
478         int i;
479
480         graph_ret = &ret_entry->ret;
481         call = &entry->graph_ent;
482         duration = graph_ret->rettime - graph_ret->calltime;
483
484         /* Overhead */
485         ret = print_graph_overhead(duration, s);
486         if (!ret)
487                 return TRACE_TYPE_PARTIAL_LINE;
488
489         /* Duration */
490         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
491                 ret = print_graph_duration(duration, s);
492                 if (ret == TRACE_TYPE_PARTIAL_LINE)
493                         return TRACE_TYPE_PARTIAL_LINE;
494         }
495
496         /* Function */
497         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
498                 ret = trace_seq_printf(s, " ");
499                 if (!ret)
500                         return TRACE_TYPE_PARTIAL_LINE;
501         }
502
503         ret = seq_print_ip_sym(s, call->func, 0);
504         if (!ret)
505                 return TRACE_TYPE_PARTIAL_LINE;
506
507         ret = trace_seq_printf(s, "();\n");
508         if (!ret)
509                 return TRACE_TYPE_PARTIAL_LINE;
510
511         return TRACE_TYPE_HANDLED;
512 }
513
514 static enum print_line_t
515 print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
516                         struct trace_seq *s, pid_t pid, int cpu)
517 {
518         int i;
519         int ret;
520         struct ftrace_graph_ent *call = &entry->graph_ent;
521
522         /* No overhead */
523         ret = print_graph_overhead(-1, s);
524         if (!ret)
525                 return TRACE_TYPE_PARTIAL_LINE;
526
527         /* No time */
528         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
529                 ret = trace_seq_printf(s, "            |  ");
530                 if (!ret)
531                         return TRACE_TYPE_PARTIAL_LINE;
532         }
533
534         /* Function */
535         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
536                 ret = trace_seq_printf(s, " ");
537                 if (!ret)
538                         return TRACE_TYPE_PARTIAL_LINE;
539         }
540
541         ret = seq_print_ip_sym(s, call->func, 0);
542         if (!ret)
543                 return TRACE_TYPE_PARTIAL_LINE;
544
545         ret = trace_seq_printf(s, "() {\n");
546         if (!ret)
547                 return TRACE_TYPE_PARTIAL_LINE;
548
549         /*
550          * we already consumed the current entry to check the next one
551          * and see if this is a leaf.
552          */
553         return TRACE_TYPE_NO_CONSUME;
554 }
555
556 static enum print_line_t
557 print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
558                         struct trace_iterator *iter)
559 {
560         int ret;
561         int cpu = iter->cpu;
562         pid_t *last_entry = iter->private;
563         struct trace_entry *ent = iter->ent;
564         struct ftrace_graph_ent *call = &field->graph_ent;
565         struct ftrace_graph_ret_entry *leaf_ret;
566
567         /* Pid */
568         if (verif_pid(s, ent->pid, cpu, last_entry) == TRACE_TYPE_PARTIAL_LINE)
569                 return TRACE_TYPE_PARTIAL_LINE;
570
571         /* Interrupt */
572         ret = print_graph_irq(iter, call->func, TRACE_GRAPH_ENT, cpu, ent->pid);
573         if (ret == TRACE_TYPE_PARTIAL_LINE)
574                 return TRACE_TYPE_PARTIAL_LINE;
575
576         /* Absolute time */
577         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
578                 ret = print_graph_abs_time(iter->ts, s);
579                 if (!ret)
580                         return TRACE_TYPE_PARTIAL_LINE;
581         }
582
583         /* Cpu */
584         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
585                 ret = print_graph_cpu(s, cpu);
586                 if (ret == TRACE_TYPE_PARTIAL_LINE)
587                         return TRACE_TYPE_PARTIAL_LINE;
588         }
589
590         /* Proc */
591         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
592                 ret = print_graph_proc(s, ent->pid);
593                 if (ret == TRACE_TYPE_PARTIAL_LINE)
594                         return TRACE_TYPE_PARTIAL_LINE;
595
596                 ret = trace_seq_printf(s, " | ");
597                 if (!ret)
598                         return TRACE_TYPE_PARTIAL_LINE;
599         }
600
601         leaf_ret = get_return_for_leaf(iter, field);
602         if (leaf_ret)
603                 return print_graph_entry_leaf(iter, field, leaf_ret, s);
604         else
605                 return print_graph_entry_nested(field, s, iter->ent->pid, cpu);
606
607 }
608
609 static enum print_line_t
610 print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
611                    struct trace_entry *ent, struct trace_iterator *iter)
612 {
613         int i;
614         int ret;
615         int cpu = iter->cpu;
616         pid_t *last_pid = iter->private, pid = ent->pid;
617         unsigned long long duration = trace->rettime - trace->calltime;
618
619         /* Pid */
620         if (verif_pid(s, pid, cpu, last_pid) == TRACE_TYPE_PARTIAL_LINE)
621                 return TRACE_TYPE_PARTIAL_LINE;
622
623         /* Absolute time */
624         if (tracer_flags.val & 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 (tracer_flags.val & 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 (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
639                 ret = print_graph_proc(s, ent->pid);
640                 if (ret == TRACE_TYPE_PARTIAL_LINE)
641                         return TRACE_TYPE_PARTIAL_LINE;
642
643                 ret = trace_seq_printf(s, " | ");
644                 if (!ret)
645                         return TRACE_TYPE_PARTIAL_LINE;
646         }
647
648         /* Overhead */
649         ret = print_graph_overhead(duration, s);
650         if (!ret)
651                 return TRACE_TYPE_PARTIAL_LINE;
652
653         /* Duration */
654         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
655                 ret = print_graph_duration(duration, s);
656                 if (ret == TRACE_TYPE_PARTIAL_LINE)
657                         return TRACE_TYPE_PARTIAL_LINE;
658         }
659
660         /* Closing brace */
661         for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
662                 ret = trace_seq_printf(s, " ");
663                 if (!ret)
664                         return TRACE_TYPE_PARTIAL_LINE;
665         }
666
667         ret = trace_seq_printf(s, "}\n");
668         if (!ret)
669                 return TRACE_TYPE_PARTIAL_LINE;
670
671         /* Overrun */
672         if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {
673                 ret = trace_seq_printf(s, " (Overruns: %lu)\n",
674                                         trace->overrun);
675                 if (!ret)
676                         return TRACE_TYPE_PARTIAL_LINE;
677         }
678
679         ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, cpu, pid);
680         if (ret == TRACE_TYPE_PARTIAL_LINE)
681                 return TRACE_TYPE_PARTIAL_LINE;
682
683         return TRACE_TYPE_HANDLED;
684 }
685
686 static enum print_line_t
687 print_graph_comment(struct bprint_entry *trace, struct trace_seq *s,
688                    struct trace_entry *ent, struct trace_iterator *iter)
689 {
690         int i;
691         int ret;
692         int cpu = iter->cpu;
693         pid_t *last_pid = iter->private;
694
695         /* Pid */
696         if (verif_pid(s, ent->pid, cpu, last_pid) == TRACE_TYPE_PARTIAL_LINE)
697                 return TRACE_TYPE_PARTIAL_LINE;
698
699         /* Absolute time */
700         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
701                 ret = print_graph_abs_time(iter->ts, s);
702                 if (!ret)
703                         return TRACE_TYPE_PARTIAL_LINE;
704         }
705
706         /* Cpu */
707         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
708                 ret = print_graph_cpu(s, cpu);
709                 if (ret == TRACE_TYPE_PARTIAL_LINE)
710                         return TRACE_TYPE_PARTIAL_LINE;
711         }
712
713         /* Proc */
714         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
715                 ret = print_graph_proc(s, ent->pid);
716                 if (ret == TRACE_TYPE_PARTIAL_LINE)
717                         return TRACE_TYPE_PARTIAL_LINE;
718
719                 ret = trace_seq_printf(s, " | ");
720                 if (!ret)
721                         return TRACE_TYPE_PARTIAL_LINE;
722         }
723
724         /* No overhead */
725         ret = print_graph_overhead(-1, s);
726         if (!ret)
727                 return TRACE_TYPE_PARTIAL_LINE;
728
729         /* No time */
730         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
731                 ret = trace_seq_printf(s, "            |  ");
732                 if (!ret)
733                         return TRACE_TYPE_PARTIAL_LINE;
734         }
735
736         /* Indentation */
737         if (trace->depth > 0)
738                 for (i = 0; i < (trace->depth + 1) * TRACE_GRAPH_INDENT; i++) {
739                         ret = trace_seq_printf(s, " ");
740                         if (!ret)
741                                 return TRACE_TYPE_PARTIAL_LINE;
742                 }
743
744         /* The comment */
745         ret = trace_seq_printf(s, "/* ");
746         if (!ret)
747                 return TRACE_TYPE_PARTIAL_LINE;
748
749         ret = trace_seq_bprintf(s, trace->fmt, trace->buf);
750         if (!ret)
751                 return TRACE_TYPE_PARTIAL_LINE;
752
753         /* Strip ending newline */
754         if (s->buffer[s->len - 1] == '\n') {
755                 s->buffer[s->len - 1] = '\0';
756                 s->len--;
757         }
758
759         ret = trace_seq_printf(s, " */\n");
760         if (!ret)
761                 return TRACE_TYPE_PARTIAL_LINE;
762
763         return TRACE_TYPE_HANDLED;
764 }
765
766
767 enum print_line_t
768 print_graph_function(struct trace_iterator *iter)
769 {
770         struct trace_seq *s = &iter->seq;
771         struct trace_entry *entry = iter->ent;
772
773         switch (entry->type) {
774         case TRACE_GRAPH_ENT: {
775                 struct ftrace_graph_ent_entry *field;
776                 trace_assign_type(field, entry);
777                 return print_graph_entry(field, s, iter);
778         }
779         case TRACE_GRAPH_RET: {
780                 struct ftrace_graph_ret_entry *field;
781                 trace_assign_type(field, entry);
782                 return print_graph_return(&field->ret, s, entry, iter);
783         }
784         case TRACE_BPRINT: {
785                 struct bprint_entry *field;
786                 trace_assign_type(field, entry);
787                 return print_graph_comment(field, s, entry, iter);
788         }
789         default:
790                 return TRACE_TYPE_UNHANDLED;
791         }
792 }
793
794 static void print_graph_headers(struct seq_file *s)
795 {
796         /* 1st line */
797         seq_printf(s, "# ");
798         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
799                 seq_printf(s, "     TIME       ");
800         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
801                 seq_printf(s, "CPU");
802         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
803                 seq_printf(s, "  TASK/PID      ");
804         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
805                 seq_printf(s, "  DURATION   ");
806         seq_printf(s, "               FUNCTION CALLS\n");
807
808         /* 2nd line */
809         seq_printf(s, "# ");
810         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
811                 seq_printf(s, "      |         ");
812         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
813                 seq_printf(s, "|  ");
814         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
815                 seq_printf(s, "  |    |        ");
816         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
817                 seq_printf(s, "   |   |      ");
818         seq_printf(s, "               |   |   |   |\n");
819 }
820
821 static void graph_trace_open(struct trace_iterator *iter)
822 {
823         /* pid on the last trace processed */
824         pid_t *last_pid = alloc_percpu(pid_t);
825         int cpu;
826
827         if (!last_pid)
828                 pr_warning("function graph tracer: not enough memory\n");
829         else
830                 for_each_possible_cpu(cpu) {
831                         pid_t *pid = per_cpu_ptr(last_pid, cpu);
832                         *pid = -1;
833                 }
834
835         iter->private = last_pid;
836 }
837
838 static void graph_trace_close(struct trace_iterator *iter)
839 {
840         free_percpu(iter->private);
841 }
842
843 static struct tracer graph_trace __read_mostly = {
844         .name           = "function_graph",
845         .open           = graph_trace_open,
846         .close          = graph_trace_close,
847         .wait_pipe      = poll_wait_pipe,
848         .init           = graph_trace_init,
849         .reset          = graph_trace_reset,
850         .print_line     = print_graph_function,
851         .print_header   = print_graph_headers,
852         .flags          = &tracer_flags,
853 #ifdef CONFIG_FTRACE_SELFTEST
854         .selftest       = trace_selftest_startup_function_graph,
855 #endif
856 };
857
858 static __init int init_graph_trace(void)
859 {
860         return register_tracer(&graph_trace);
861 }
862
863 device_initcall(init_graph_trace);