~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_functions_graph.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp