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

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

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

~ [ 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