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

Archive Download this file



interactive