kernel/trace/trace_functions_graph.c

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