kernel/trace/trace_functions

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
__trace_graph_entry
ftrace_graph_ignore_irqs
trace_graph_entry
__trace_graph_function
trace_graph_function
__trace_graph_return
trace_graph_return
set_graph_array
trace_graph_thresh_return
graph_trace_init
graph_trace_reset
graph_trace_update_thresh
print_graph_cpu
print_graph_proc
print_graph_lat_fmt
verif_pid
get_return_for_leaf
print_graph_abs_time
print_graph_rel_time
print_graph_irq
trace_print_graph_duration
print_graph_duration
print_graph_entry_leaf
print_graph_entry_nested
print_graph_prologue
check_irq_entry
check_irq_return
print_graph_entry
print_graph_return
print_graph_comment
print_graph_function_flags
print_graph_function
print_graph_function_event
print_lat_header
__print_graph_headers_flags
print_graph_headers
print_graph_headers_flags
graph_trace_open
graph_trace_close
func_graph_set_flag
graph_depth_write
graph_depth_read
init_graph_tracefs
init_graph_trace
   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);
/* [<][>][^][v][top][bottom][index][help] */
root/kernel/trace/trace_functions_graph.c

DEFINITIONS
