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/fs.h>
  13
  14 #include "trace.h"
  15 #include "trace_output.h"
  16
  17 struct fgraph_data {
  18         pid_t           last_pid;
  19         int             depth;
  20 };
  21
  22 #define TRACE_GRAPH_INDENT      2
  23
  24 /* Flag options */
  25 #define TRACE_GRAPH_PRINT_OVERRUN       0x1
  26 #define TRACE_GRAPH_PRINT_CPU           0x2
  27 #define TRACE_GRAPH_PRINT_OVERHEAD      0x4
  28 #define TRACE_GRAPH_PRINT_PROC          0x8
  29 #define TRACE_GRAPH_PRINT_DURATION      0x10
  30 #define TRACE_GRAPH_PRINT_ABS_TIME      0X20
  31
  32 static struct tracer_opt trace_opts[] = {
  33         /* Display overruns? (for self-debug purpose) */
  34         { TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
  35         /* Display CPU ? */
  36         { TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
  37         /* Display Overhead ? */
  38         { TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
  39         /* Display proc name/pid */
  40         { TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
  41         /* Display duration of execution */
  42         { TRACER_OPT(funcgraph-duration, TRACE_GRAPH_PRINT_DURATION) },
  43         /* Display absolute time of an entry */
  44         { TRACER_OPT(funcgraph-abstime, TRACE_GRAPH_PRINT_ABS_TIME) },
  45         { } /* Empty entry */
  46 };
  47
  48 static struct tracer_flags tracer_flags = {
  49         /* Don't display overruns and proc by default */
  50         .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD |
  51                TRACE_GRAPH_PRINT_DURATION,
  52         .opts = trace_opts
  53 };
  54
  55 /* pid on the last trace processed */
  56
  57
  58 /* Add a function return address to the trace stack on thread info.*/
  59 int
  60 ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth)
  61 {
  62         unsigned long long calltime;
  63         int index;
  64
  65         if (!current->ret_stack)
  66                 return -EBUSY;
  67
  68         /*
  69          * We must make sure the ret_stack is tested before we read
  70          * anything else.
  71          */
  72         smp_rmb();
  73
  74         /* The return trace stack is full */
  75         if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
  76                 atomic_inc(&current->trace_overrun);
  77                 return -EBUSY;
  78         }
  79
  80         calltime = trace_clock_local();
  81
  82         index = ++current->curr_ret_stack;
  83         barrier();
  84         current->ret_stack[index].ret = ret;
  85         current->ret_stack[index].func = func;
  86         current->ret_stack[index].calltime = calltime;
  87         *depth = index;
  88
  89         return 0;
  90 }
  91
  92 /* Retrieve a function return address to the trace stack on thread info.*/
  93 void
  94 ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
  95 {
  96         int index;
  97
  98         index = current->curr_ret_stack;
  99
 100         if (unlikely(index < 0)) {
 101                 ftrace_graph_stop();
 102                 WARN_ON(1);
 103                 /* Might as well panic, otherwise we have no where to go */
 104                 *ret = (unsigned long)panic;
 105                 return;
 106         }
 107
 108         *ret = current->ret_stack[index].ret;
 109         trace->func = current->ret_stack[index].func;
 110         trace->calltime = current->ret_stack[index].calltime;
 111         trace->overrun = atomic_read(&current->trace_overrun);
 112         trace->depth = index;
 113         barrier();
 114         current->curr_ret_stack--;
 115
 116 }
 117
 118 /*
 119  * Send the trace to the ring-buffer.
 120  * @return the original return address.
 121  */
 122 unsigned long ftrace_return_to_handler(void)
 123 {
 124         struct ftrace_graph_ret trace;
 125         unsigned long ret;
 126
 127         ftrace_pop_return_trace(&trace, &ret);
 128         trace.rettime = trace_clock_local();
 129         ftrace_graph_return(&trace);
 130
 131         if (unlikely(!ret)) {
 132                 ftrace_graph_stop();
 133                 WARN_ON(1);
 134                 /* Might as well panic. What else to do? */
 135                 ret = (unsigned long)panic;
 136         }
 137
 138         return ret;
 139 }
 140
 141 static int graph_trace_init(struct trace_array *tr)
 142 {
 143         int ret = register_ftrace_graph(&trace_graph_return,
 144                                         &trace_graph_entry);
 145         if (ret)
 146                 return ret;
 147         tracing_start_cmdline_record();
 148
 149         return 0;
 150 }
 151
 152 static void graph_trace_reset(struct trace_array *tr)
 153 {
 154         tracing_stop_cmdline_record();
 155         unregister_ftrace_graph();
 156 }
 157
 158 static inline int log10_cpu(int nb)
 159 {
 160         if (nb / 100)
 161                 return 3;
 162         if (nb / 10)
 163                 return 2;
 164         return 1;
 165 }
 166
 167 static enum print_line_t
 168 print_graph_cpu(struct trace_seq *s, int cpu)
 169 {
 170         int i;
 171         int ret;
 172         int log10_this = log10_cpu(cpu);
 173         int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
 174
 175
 176         /*
 177          * Start with a space character - to make it stand out
 178          * to the right a bit when trace output is pasted into
 179          * email:
 180          */
 181         ret = trace_seq_printf(s, " ");
 182
 183         /*
 184          * Tricky - we space the CPU field according to the max
 185          * number of online CPUs. On a 2-cpu system it would take
 186          * a maximum of 1 digit - on a 128 cpu system it would
 187          * take up to 3 digits:
 188          */
 189         for (i = 0; i < log10_all - log10_this; i++) {
 190                 ret = trace_seq_printf(s, " ");
 191                 if (!ret)
 192                         return TRACE_TYPE_PARTIAL_LINE;
 193         }
 194         ret = trace_seq_printf(s, "%d) ", cpu);
 195         if (!ret)
 196                 return TRACE_TYPE_PARTIAL_LINE;
 197
 198         return TRACE_TYPE_HANDLED;
 199 }
 200
 201 #define TRACE_GRAPH_PROCINFO_LENGTH     14
 202
 203 static enum print_line_t
 204 print_graph_proc(struct trace_seq *s, pid_t pid)
 205 {
 206         char comm[TASK_COMM_LEN];
 207         /* sign + log10(MAX_INT) + '\0' */
 208         char pid_str[11];
 209         int spaces = 0;
 210         int ret;
 211         int len;
 212         int i;
 213
 214         trace_find_cmdline(pid, comm);
 215         comm[7] = '\0';
 216         sprintf(pid_str, "%d", pid);
 217
 218         /* 1 stands for the "-" character */
 219         len = strlen(comm) + strlen(pid_str) + 1;
 220
 221         if (len < TRACE_GRAPH_PROCINFO_LENGTH)
 222                 spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
 223
 224         /* First spaces to align center */
 225         for (i = 0; i < spaces / 2; i++) {
 226                 ret = trace_seq_printf(s, " ");
 227                 if (!ret)
 228                         return TRACE_TYPE_PARTIAL_LINE;
 229         }
 230
 231         ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
 232         if (!ret)
 233                 return TRACE_TYPE_PARTIAL_LINE;
 234
 235         /* Last spaces to align center */
 236         for (i = 0; i < spaces - (spaces / 2); i++) {
 237                 ret = trace_seq_printf(s, " ");
 238                 if (!ret)
 239                         return TRACE_TYPE_PARTIAL_LINE;
 240         }
 241         return TRACE_TYPE_HANDLED;
 242 }
 243
 244
 245 /* If the pid changed since the last trace, output this event */
 246 static enum print_line_t
 247 verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
 248 {
 249         pid_t prev_pid;
 250         pid_t *last_pid;
 251         int ret;
 252
 253         if (!data)
 254                 return TRACE_TYPE_HANDLED;
 255
 256         last_pid = &(per_cpu_ptr(data, cpu)->last_pid);
 257
 258         if (*last_pid == pid)
 259                 return TRACE_TYPE_HANDLED;
 260
 261         prev_pid = *last_pid;
 262         *last_pid = pid;
 263
 264         if (prev_pid == -1)
 265                 return TRACE_TYPE_HANDLED;
 266 /*
 267  * Context-switch trace line:
 268
 269  ------------------------------------------
 270  | 1)  migration/0--1  =>  sshd-1755
 271  ------------------------------------------
 272
 273  */
 274         ret = trace_seq_printf(s,
 275                 " ------------------------------------------\n");
 276         if (!ret)
 277                 return TRACE_TYPE_PARTIAL_LINE;
 278
 279         ret = print_graph_cpu(s, cpu);
 280         if (ret == TRACE_TYPE_PARTIAL_LINE)
 281                 return TRACE_TYPE_PARTIAL_LINE;
 282
 283         ret = print_graph_proc(s, prev_pid);
 284         if (ret == TRACE_TYPE_PARTIAL_LINE)
 285                 return TRACE_TYPE_PARTIAL_LINE;
 286
 287         ret = trace_seq_printf(s, " => ");
 288         if (!ret)
 289                 return TRACE_TYPE_PARTIAL_LINE;
 290
 291         ret = print_graph_proc(s, pid);
 292         if (ret == TRACE_TYPE_PARTIAL_LINE)
 293                 return TRACE_TYPE_PARTIAL_LINE;
 294
 295         ret = trace_seq_printf(s,
 296                 "\n ------------------------------------------\n\n");
 297         if (!ret)
 298                 return TRACE_TYPE_PARTIAL_LINE;
 299
 300         return TRACE_TYPE_HANDLED;
 301 }
 302
 303 static struct ftrace_graph_ret_entry *
 304 get_return_for_leaf(struct trace_iterator *iter,
 305                 struct ftrace_graph_ent_entry *curr)
 306 {
 307         struct ring_buffer_iter *ring_iter;
 308         struct ring_buffer_event *event;
 309         struct ftrace_graph_ret_entry *next;
 310
 311         ring_iter = iter->buffer_iter[iter->cpu];
 312
 313         /* First peek to compare current entry and the next one */
 314         if (ring_iter)
 315                 event = ring_buffer_iter_peek(ring_iter, NULL);
 316         else {
 317         /* We need to consume the current entry to see the next one */
 318                 ring_buffer_consume(iter->tr->buffer, iter->cpu, NULL);
 319                 event = ring_buffer_peek(iter->tr->buffer, iter->cpu,
 320                                         NULL);
 321         }
 322
 323         if (!event)
 324                 return NULL;
 325
 326         next = ring_buffer_event_data(event);
 327
 328         if (next->ent.type != TRACE_GRAPH_RET)
 329                 return NULL;
 330
 331         if (curr->ent.pid != next->ent.pid ||
 332                         curr->graph_ent.func != next->ret.func)
 333                 return NULL;
 334
 335         /* this is a leaf, now advance the iterator */
 336         if (ring_iter)
 337                 ring_buffer_read(ring_iter, NULL);
 338
 339         return next;
 340 }
 341
 342 /* Signal a overhead of time execution to the output */
 343 static int
 344 print_graph_overhead(unsigned long long duration, struct trace_seq *s)
 345 {
 346         /* If duration disappear, we don't need anything */
 347         if (!(tracer_flags.val & TRACE_GRAPH_PRINT_DURATION))
 348                 return 1;
 349
 350         /* Non nested entry or return */
 351         if (duration == -1)
 352                 return trace_seq_printf(s, "  ");
 353
 354         if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
 355                 /* Duration exceeded 100 msecs */
 356                 if (duration > 100000ULL)
 357                         return trace_seq_printf(s, "! ");
 358
 359                 /* Duration exceeded 10 msecs */
 360                 if (duration > 10000ULL)
 361                         return trace_seq_printf(s, "+ ");
 362         }
 363
 364         return trace_seq_printf(s, "  ");
 365 }
 366
 367 static int print_graph_abs_time(u64 t, struct trace_seq *s)
 368 {
 369         unsigned long usecs_rem;
 370
 371         usecs_rem = do_div(t, NSEC_PER_SEC);
 372         usecs_rem /= 1000;
 373
 374         return trace_seq_printf(s, "%5lu.%06lu |  ",
 375                         (unsigned long)t, usecs_rem);
 376 }
 377
 378 static enum print_line_t
 379 print_graph_irq(struct trace_iterator *iter, unsigned long addr,
 380                 enum trace_type type, int cpu, pid_t pid)
 381 {
 382         int ret;
 383         struct trace_seq *s = &iter->seq;
 384
 385         if (addr < (unsigned long)__irqentry_text_start ||
 386                 addr >= (unsigned long)__irqentry_text_end)
 387                 return TRACE_TYPE_UNHANDLED;
 388
 389         /* Absolute time */
 390         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
 391                 ret = print_graph_abs_time(iter->ts, s);
 392                 if (!ret)
 393                         return TRACE_TYPE_PARTIAL_LINE;
 394         }
 395
 396         /* Cpu */
 397         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
 398                 ret = print_graph_cpu(s, cpu);
 399                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 400                         return TRACE_TYPE_PARTIAL_LINE;
 401         }
 402         /* Proc */
 403         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
 404                 ret = print_graph_proc(s, pid);
 405                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 406                         return TRACE_TYPE_PARTIAL_LINE;
 407                 ret = trace_seq_printf(s, " | ");
 408                 if (!ret)
 409                         return TRACE_TYPE_PARTIAL_LINE;
 410         }
 411
 412         /* No overhead */
 413         ret = print_graph_overhead(-1, s);
 414         if (!ret)
 415                 return TRACE_TYPE_PARTIAL_LINE;
 416
 417         if (type == TRACE_GRAPH_ENT)
 418                 ret = trace_seq_printf(s, "==========>");
 419         else
 420                 ret = trace_seq_printf(s, "<==========");
 421
 422         if (!ret)
 423                 return TRACE_TYPE_PARTIAL_LINE;
 424
 425         /* Don't close the duration column if haven't one */
 426         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
 427                 trace_seq_printf(s, " |");
 428         ret = trace_seq_printf(s, "\n");
 429
 430         if (!ret)
 431                 return TRACE_TYPE_PARTIAL_LINE;
 432         return TRACE_TYPE_HANDLED;
 433 }
 434
 435 static enum print_line_t
 436 print_graph_duration(unsigned long long duration, struct trace_seq *s)
 437 {
 438         unsigned long nsecs_rem = do_div(duration, 1000);
 439         /* log10(ULONG_MAX) + '\0' */
 440         char msecs_str[21];
 441         char nsecs_str[5];
 442         int ret, len;
 443         int i;
 444
 445         sprintf(msecs_str, "%lu", (unsigned long) duration);
 446
 447         /* Print msecs */
 448         ret = trace_seq_printf(s, "%s", msecs_str);
 449         if (!ret)
 450                 return TRACE_TYPE_PARTIAL_LINE;
 451
 452         len = strlen(msecs_str);
 453
 454         /* Print nsecs (we don't want to exceed 7 numbers) */
 455         if (len < 7) {
 456                 snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
 457                 ret = trace_seq_printf(s, ".%s", nsecs_str);
 458                 if (!ret)
 459                         return TRACE_TYPE_PARTIAL_LINE;
 460                 len += strlen(nsecs_str);
 461         }
 462
 463         ret = trace_seq_printf(s, " us ");
 464         if (!ret)
 465                 return TRACE_TYPE_PARTIAL_LINE;
 466
 467         /* Print remaining spaces to fit the row's width */
 468         for (i = len; i < 7; i++) {
 469                 ret = trace_seq_printf(s, " ");
 470                 if (!ret)
 471                         return TRACE_TYPE_PARTIAL_LINE;
 472         }
 473
 474         ret = trace_seq_printf(s, "|  ");
 475         if (!ret)
 476                 return TRACE_TYPE_PARTIAL_LINE;
 477         return TRACE_TYPE_HANDLED;
 478
 479 }
 480
 481 /* Case of a leaf function on its call entry */
 482 static enum print_line_t
 483 print_graph_entry_leaf(struct trace_iterator *iter,
 484                 struct ftrace_graph_ent_entry *entry,
 485                 struct ftrace_graph_ret_entry *ret_entry, struct trace_seq *s)
 486 {
 487         struct fgraph_data *data = iter->private;
 488         struct ftrace_graph_ret *graph_ret;
 489         struct ftrace_graph_ent *call;
 490         unsigned long long duration;
 491         int ret;
 492         int i;
 493
 494         graph_ret = &ret_entry->ret;
 495         call = &entry->graph_ent;
 496         duration = graph_ret->rettime - graph_ret->calltime;
 497
 498         if (data) {
 499                 int cpu = iter->cpu;
 500                 int *depth = &(per_cpu_ptr(data, cpu)->depth);
 501
 502                 /*
 503                  * Comments display at + 1 to depth. Since
 504                  * this is a leaf function, keep the comments
 505                  * equal to this depth.
 506                  */
 507                 *depth = call->depth - 1;
 508         }
 509
 510         /* Overhead */
 511         ret = print_graph_overhead(duration, s);
 512         if (!ret)
 513                 return TRACE_TYPE_PARTIAL_LINE;
 514
 515         /* Duration */
 516         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
 517                 ret = print_graph_duration(duration, s);
 518                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 519                         return TRACE_TYPE_PARTIAL_LINE;
 520         }
 521
 522         /* Function */
 523         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
 524                 ret = trace_seq_printf(s, " ");
 525                 if (!ret)
 526                         return TRACE_TYPE_PARTIAL_LINE;
 527         }
 528
 529         ret = seq_print_ip_sym(s, call->func, 0);
 530         if (!ret)
 531                 return TRACE_TYPE_PARTIAL_LINE;
 532
 533         ret = trace_seq_printf(s, "();\n");
 534         if (!ret)
 535                 return TRACE_TYPE_PARTIAL_LINE;
 536
 537         return TRACE_TYPE_HANDLED;
 538 }
 539
 540 static enum print_line_t
 541 print_graph_entry_nested(struct trace_iterator *iter,
 542                          struct ftrace_graph_ent_entry *entry,
 543                          struct trace_seq *s, int cpu)
 544 {
 545         struct ftrace_graph_ent *call = &entry->graph_ent;
 546         struct fgraph_data *data = iter->private;
 547         int ret;
 548         int i;
 549
 550         if (data) {
 551                 int cpu = iter->cpu;
 552                 int *depth = &(per_cpu_ptr(data, cpu)->depth);
 553
 554                 *depth = call->depth;
 555         }
 556
 557         /* No overhead */
 558         ret = print_graph_overhead(-1, s);
 559         if (!ret)
 560                 return TRACE_TYPE_PARTIAL_LINE;
 561
 562         /* No time */
 563         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
 564                 ret = trace_seq_printf(s, "            |  ");
 565                 if (!ret)
 566                         return TRACE_TYPE_PARTIAL_LINE;
 567         }
 568
 569         /* Function */
 570         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
 571                 ret = trace_seq_printf(s, " ");
 572                 if (!ret)
 573                         return TRACE_TYPE_PARTIAL_LINE;
 574         }
 575
 576         ret = seq_print_ip_sym(s, call->func, 0);
 577         if (!ret)
 578                 return TRACE_TYPE_PARTIAL_LINE;
 579
 580         ret = trace_seq_printf(s, "() {\n");
 581         if (!ret)
 582                 return TRACE_TYPE_PARTIAL_LINE;
 583
 584         /*
 585          * we already consumed the current entry to check the next one
 586          * and see if this is a leaf.
 587          */
 588         return TRACE_TYPE_NO_CONSUME;
 589 }
 590
 591 static enum print_line_t
 592 print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
 593                      int type, unsigned long addr)
 594 {
 595         struct fgraph_data *data = iter->private;
 596         struct trace_entry *ent = iter->ent;
 597         int cpu = iter->cpu;
 598         int ret;
 599
 600         /* Pid */
 601         if (verif_pid(s, ent->pid, cpu, data) == TRACE_TYPE_PARTIAL_LINE)
 602                 return TRACE_TYPE_PARTIAL_LINE;
 603
 604         if (type) {
 605                 /* Interrupt */
 606                 ret = print_graph_irq(iter, addr, type, cpu, ent->pid);
 607                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 608                         return TRACE_TYPE_PARTIAL_LINE;
 609         }
 610
 611         /* Absolute time */
 612         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
 613                 ret = print_graph_abs_time(iter->ts, s);
 614                 if (!ret)
 615                         return TRACE_TYPE_PARTIAL_LINE;
 616         }
 617
 618         /* Cpu */
 619         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
 620                 ret = print_graph_cpu(s, cpu);
 621                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 622                         return TRACE_TYPE_PARTIAL_LINE;
 623         }
 624
 625         /* Proc */
 626         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
 627                 ret = print_graph_proc(s, ent->pid);
 628                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 629                         return TRACE_TYPE_PARTIAL_LINE;
 630
 631                 ret = trace_seq_printf(s, " | ");
 632                 if (!ret)
 633                         return TRACE_TYPE_PARTIAL_LINE;
 634         }
 635
 636         return 0;
 637 }
 638
 639 static enum print_line_t
 640 print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
 641                         struct trace_iterator *iter)
 642 {
 643         int cpu = iter->cpu;
 644         struct ftrace_graph_ent *call = &field->graph_ent;
 645         struct ftrace_graph_ret_entry *leaf_ret;
 646
 647         if (print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func))
 648                 return TRACE_TYPE_PARTIAL_LINE;
 649
 650         leaf_ret = get_return_for_leaf(iter, field);
 651         if (leaf_ret)
 652                 return print_graph_entry_leaf(iter, field, leaf_ret, s);
 653         else
 654                 return print_graph_entry_nested(iter, field, s, cpu);
 655
 656 }
 657
 658 static enum print_line_t
 659 print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
 660                    struct trace_entry *ent, struct trace_iterator *iter)
 661 {
 662         unsigned long long duration = trace->rettime - trace->calltime;
 663         struct fgraph_data *data = iter->private;
 664         pid_t pid = ent->pid;
 665         int cpu = iter->cpu;
 666         int ret;
 667         int i;
 668
 669         if (data) {
 670                 int cpu = iter->cpu;
 671                 int *depth = &(per_cpu_ptr(data, cpu)->depth);
 672
 673                 /*
 674                  * Comments display at + 1 to depth. This is the
 675                  * return from a function, we now want the comments
 676                  * to display at the same level of the bracket.
 677                  */
 678                 *depth = trace->depth - 1;
 679         }
 680
 681         if (print_graph_prologue(iter, s, 0, 0))
 682                 return TRACE_TYPE_PARTIAL_LINE;
 683
 684         /* Overhead */
 685         ret = print_graph_overhead(duration, s);
 686         if (!ret)
 687                 return TRACE_TYPE_PARTIAL_LINE;
 688
 689         /* Duration */
 690         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
 691                 ret = print_graph_duration(duration, s);
 692                 if (ret == TRACE_TYPE_PARTIAL_LINE)
 693                         return TRACE_TYPE_PARTIAL_LINE;
 694         }
 695
 696         /* Closing brace */
 697         for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
 698                 ret = trace_seq_printf(s, " ");
 699                 if (!ret)
 700                         return TRACE_TYPE_PARTIAL_LINE;
 701         }
 702
 703         ret = trace_seq_printf(s, "}\n");
 704         if (!ret)
 705                 return TRACE_TYPE_PARTIAL_LINE;
 706
 707         /* Overrun */
 708         if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {
 709                 ret = trace_seq_printf(s, " (Overruns: %lu)\n",
 710                                         trace->overrun);
 711                 if (!ret)
 712                         return TRACE_TYPE_PARTIAL_LINE;
 713         }
 714
 715         ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, cpu, pid);
 716         if (ret == TRACE_TYPE_PARTIAL_LINE)
 717                 return TRACE_TYPE_PARTIAL_LINE;
 718
 719         return TRACE_TYPE_HANDLED;
 720 }
 721
 722 static enum print_line_t
 723 print_graph_comment(struct trace_seq *s,  struct trace_entry *ent,
 724                     struct trace_iterator *iter)
 725 {
 726         unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
 727         struct fgraph_data *data = iter->private;
 728         struct trace_event *event;
 729         int depth = 0;
 730         int ret;
 731         int i;
 732
 733         if (data)
 734                 depth = per_cpu_ptr(data, iter->cpu)->depth;
 735
 736         if (print_graph_prologue(iter, s, 0, 0))
 737                 return TRACE_TYPE_PARTIAL_LINE;
 738
 739         /* No overhead */
 740         ret = print_graph_overhead(-1, s);
 741         if (!ret)
 742                 return TRACE_TYPE_PARTIAL_LINE;
 743
 744         /* No time */
 745         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
 746                 ret = trace_seq_printf(s, "            |  ");
 747                 if (!ret)
 748                         return TRACE_TYPE_PARTIAL_LINE;
 749         }
 750
 751         /* Indentation */
 752         if (depth > 0)
 753                 for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++) {
 754                         ret = trace_seq_printf(s, " ");
 755                         if (!ret)
 756                                 return TRACE_TYPE_PARTIAL_LINE;
 757                 }
 758
 759         /* The comment */
 760         ret = trace_seq_printf(s, "/* ");
 761         if (!ret)
 762                 return TRACE_TYPE_PARTIAL_LINE;
 763
 764         switch (iter->ent->type) {
 765         case TRACE_BPRINT:
 766                 ret = trace_print_bprintk_msg_only(iter);
 767                 if (ret != TRACE_TYPE_HANDLED)
 768                         return ret;
 769                 break;
 770         case TRACE_PRINT:
 771                 ret = trace_print_printk_msg_only(iter);
 772                 if (ret != TRACE_TYPE_HANDLED)
 773                         return ret;
 774                 break;
 775         default:
 776                 event = ftrace_find_event(ent->type);
 777                 if (!event)
 778                         return TRACE_TYPE_UNHANDLED;
 779
 780                 ret = event->trace(iter, sym_flags);
 781                 if (ret != TRACE_TYPE_HANDLED)
 782                         return ret;
 783         }
 784
 785         /* Strip ending newline */
 786         if (s->buffer[s->len - 1] == '\n') {
 787                 s->buffer[s->len - 1] = '\0';
 788                 s->len--;
 789         }
 790
 791         ret = trace_seq_printf(s, " */\n");
 792         if (!ret)
 793                 return TRACE_TYPE_PARTIAL_LINE;
 794
 795         return TRACE_TYPE_HANDLED;
 796 }
 797
 798
 799 enum print_line_t
 800 print_graph_function(struct trace_iterator *iter)
 801 {
 802         struct trace_entry *entry = iter->ent;
 803         struct trace_seq *s = &iter->seq;
 804
 805         switch (entry->type) {
 806         case TRACE_GRAPH_ENT: {
 807                 struct ftrace_graph_ent_entry *field;
 808                 trace_assign_type(field, entry);
 809                 return print_graph_entry(field, s, iter);
 810         }
 811         case TRACE_GRAPH_RET: {
 812                 struct ftrace_graph_ret_entry *field;
 813                 trace_assign_type(field, entry);
 814                 return print_graph_return(&field->ret, s, entry, iter);
 815         }
 816         default:
 817                 return print_graph_comment(s, entry, iter);
 818         }
 819
 820         return TRACE_TYPE_HANDLED;
 821 }
 822
 823 static void print_graph_headers(struct seq_file *s)
 824 {
 825         /* 1st line */
 826         seq_printf(s, "# ");
 827         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
 828                 seq_printf(s, "     TIME       ");
 829         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
 830                 seq_printf(s, "CPU");
 831         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
 832                 seq_printf(s, "  TASK/PID      ");
 833         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
 834                 seq_printf(s, "  DURATION   ");
 835         seq_printf(s, "               FUNCTION CALLS\n");
 836
 837         /* 2nd line */
 838         seq_printf(s, "# ");
 839         if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
 840                 seq_printf(s, "      |         ");
 841         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
 842                 seq_printf(s, "|  ");
 843         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
 844                 seq_printf(s, "  |    |        ");
 845         if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
 846                 seq_printf(s, "   |   |      ");
 847         seq_printf(s, "               |   |   |   |\n");
 848 }
 849
 850 static void graph_trace_open(struct trace_iterator *iter)
 851 {
 852         /* pid and depth on the last trace processed */
 853         struct fgraph_data *data = alloc_percpu(struct fgraph_data);
 854         int cpu;
 855
 856         if (!data)
 857                 pr_warning("function graph tracer: not enough memory\n");
 858         else
 859                 for_each_possible_cpu(cpu) {
 860                         pid_t *pid = &(per_cpu_ptr(data, cpu)->last_pid);
 861                         int *depth = &(per_cpu_ptr(data, cpu)->depth);
 862                         *pid = -1;
 863                         *depth = 0;
 864                 }
 865
 866         iter->private = data;
 867 }
 868
 869 static void graph_trace_close(struct trace_iterator *iter)
 870 {
 871         free_percpu(iter->private);
 872 }
 873
 874 static struct tracer graph_trace __read_mostly = {
 875         .name           = "function_graph",
 876         .open           = graph_trace_open,
 877         .close          = graph_trace_close,
 878         .wait_pipe      = poll_wait_pipe,
 879         .init           = graph_trace_init,
 880         .reset          = graph_trace_reset,
 881         .print_line     = print_graph_function,
 882         .print_header   = print_graph_headers,
 883         .flags          = &tracer_flags,
 884 #ifdef CONFIG_FTRACE_SELFTEST
 885         .selftest       = trace_selftest_startup_function_graph,
 886 #endif
 887 };
 888
 889 static __init int init_graph_trace(void)
 890 {
 891         return register_tracer(&graph_trace);
 892 }
 893
 894 device_initcall(init_graph_trace);