kernel/trace/trace_functions_graph.c

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