tools/perf/ui/stdio/hist.c

   1 #include <stdio.h>
   2
   3 #include "../../util/util.h"
   4 #include "../../util/hist.h"
   5 #include "../../util/sort.h"
   6 #include "../../util/evsel.h"
   7 #include "../../util/srcline.h"
   8 #include "../../util/string2.h"
   9 #include "../../util/thread.h"
  10 #include "../../util/sane_ctype.h"
  11
  12 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
  13 {
  14         int i;
  15         int ret = fprintf(fp, "            ");
  16
  17         for (i = 0; i < left_margin; i++)
  18                 ret += fprintf(fp, " ");
  19
  20         return ret;
  21 }
  22
  23 static size_t inline__fprintf(struct map *map, u64 ip, int left_margin,
  24                               int depth, int depth_mask, FILE *fp)
  25 {
  26         struct dso *dso;
  27         struct inline_node *node;
  28         struct inline_list *ilist;
  29         int ret = 0, i;
  30
  31         if (map == NULL)
  32                 return 0;
  33
  34         dso = map->dso;
  35         if (dso == NULL)
  36                 return 0;
  37
  38         if (dso->kernel != DSO_TYPE_USER)
  39                 return 0;
  40
  41         node = dso__parse_addr_inlines(dso,
  42                                        map__rip_2objdump(map, ip));
  43         if (node == NULL)
  44                 return 0;
  45
  46         list_for_each_entry(ilist, &node->val, list) {
  47                 if ((ilist->filename != NULL) || (ilist->funcname != NULL)) {
  48                         ret += callchain__fprintf_left_margin(fp, left_margin);
  49
  50                         for (i = 0; i < depth; i++) {
  51                                 if (depth_mask & (1 << i))
  52                                         ret += fprintf(fp, "|");
  53                                 else
  54                                         ret += fprintf(fp, " ");
  55                                 ret += fprintf(fp, "          ");
  56                         }
  57
  58                         if (callchain_param.key == CCKEY_ADDRESS ||
  59                             callchain_param.key == CCKEY_SRCLINE) {
  60                                 if (ilist->filename != NULL)
  61                                         ret += fprintf(fp, "%s:%d (inline)",
  62                                                        ilist->filename,
  63                                                        ilist->line_nr);
  64                                 else
  65                                         ret += fprintf(fp, "??");
  66                         } else if (ilist->funcname != NULL)
  67                                 ret += fprintf(fp, "%s (inline)",
  68                                                ilist->funcname);
  69                         else if (ilist->filename != NULL)
  70                                 ret += fprintf(fp, "%s:%d (inline)",
  71                                                ilist->filename,
  72                                                ilist->line_nr);
  73                         else
  74                                 ret += fprintf(fp, "??");
  75
  76                         ret += fprintf(fp, "\n");
  77                 }
  78         }
  79
  80         inline_node__delete(node);
  81         return ret;
  82 }
  83
  84 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
  85                                           int left_margin)
  86 {
  87         int i;
  88         size_t ret = callchain__fprintf_left_margin(fp, left_margin);
  89
  90         for (i = 0; i < depth; i++)
  91                 if (depth_mask & (1 << i))
  92                         ret += fprintf(fp, "|          ");
  93                 else
  94                         ret += fprintf(fp, "           ");
  95
  96         ret += fprintf(fp, "\n");
  97
  98         return ret;
  99 }
 100
 101 static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_node *node,
 102                                      struct callchain_list *chain,
 103                                      int depth, int depth_mask, int period,
 104                                      u64 total_samples, int left_margin)
 105 {
 106         int i;
 107         size_t ret = 0;
 108         char bf[1024], *alloc_str = NULL;
 109         char buf[64];
 110         const char *str;
 111
 112         ret += callchain__fprintf_left_margin(fp, left_margin);
 113         for (i = 0; i < depth; i++) {
 114                 if (depth_mask & (1 << i))
 115                         ret += fprintf(fp, "|");
 116                 else
 117                         ret += fprintf(fp, " ");
 118                 if (!period && i == depth - 1) {
 119                         ret += fprintf(fp, "--");
 120                         ret += callchain_node__fprintf_value(node, fp, total_samples);
 121                         ret += fprintf(fp, "--");
 122                 } else
 123                         ret += fprintf(fp, "%s", "          ");
 124         }
 125
 126         str = callchain_list__sym_name(chain, bf, sizeof(bf), false);
 127
 128         if (symbol_conf.show_branchflag_count) {
 129                 if (!period)
 130                         callchain_list_counts__printf_value(node, chain, NULL,
 131                                                             buf, sizeof(buf));
 132                 else
 133                         callchain_list_counts__printf_value(NULL, chain, NULL,
 134                                                             buf, sizeof(buf));
 135
 136                 if (asprintf(&alloc_str, "%s%s", str, buf) < 0)
 137                         str = "Not enough memory!";
 138                 else
 139                         str = alloc_str;
 140         }
 141
 142         fputs(str, fp);
 143         fputc('\n', fp);
 144         free(alloc_str);
 145
 146         if (symbol_conf.inline_name)
 147                 ret += inline__fprintf(chain->ms.map, chain->ip,
 148                                        left_margin, depth, depth_mask, fp);
 149         return ret;
 150 }
 151
 152 static struct symbol *rem_sq_bracket;
 153 static struct callchain_list rem_hits;
 154
 155 static void init_rem_hits(void)
 156 {
 157         rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
 158         if (!rem_sq_bracket) {
 159                 fprintf(stderr, "Not enough memory to display remaining hits\n");
 160                 return;
 161         }
 162
 163         strcpy(rem_sq_bracket->name, "[...]");
 164         rem_hits.ms.sym = rem_sq_bracket;
 165 }
 166
 167 static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
 168                                          u64 total_samples, int depth,
 169                                          int depth_mask, int left_margin)
 170 {
 171         struct rb_node *node, *next;
 172         struct callchain_node *child = NULL;
 173         struct callchain_list *chain;
 174         int new_depth_mask = depth_mask;
 175         u64 remaining;
 176         size_t ret = 0;
 177         int i;
 178         uint entries_printed = 0;
 179         int cumul_count = 0;
 180
 181         remaining = total_samples;
 182
 183         node = rb_first(root);
 184         while (node) {
 185                 u64 new_total;
 186                 u64 cumul;
 187
 188                 child = rb_entry(node, struct callchain_node, rb_node);
 189                 cumul = callchain_cumul_hits(child);
 190                 remaining -= cumul;
 191                 cumul_count += callchain_cumul_counts(child);
 192
 193                 /*
 194                  * The depth mask manages the output of pipes that show
 195                  * the depth. We don't want to keep the pipes of the current
 196                  * level for the last child of this depth.
 197                  * Except if we have remaining filtered hits. They will
 198                  * supersede the last child
 199                  */
 200                 next = rb_next(node);
 201                 if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
 202                         new_depth_mask &= ~(1 << (depth - 1));
 203
 204                 /*
 205                  * But we keep the older depth mask for the line separator
 206                  * to keep the level link until we reach the last child
 207                  */
 208                 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
 209                                                    left_margin);
 210                 i = 0;
 211                 list_for_each_entry(chain, &child->val, list) {
 212                         ret += ipchain__fprintf_graph(fp, child, chain, depth,
 213                                                       new_depth_mask, i++,
 214                                                       total_samples,
 215                                                       left_margin);
 216                 }
 217
 218                 if (callchain_param.mode == CHAIN_GRAPH_REL)
 219                         new_total = child->children_hit;
 220                 else
 221                         new_total = total_samples;
 222
 223                 ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
 224                                                   depth + 1,
 225                                                   new_depth_mask | (1 << depth),
 226                                                   left_margin);
 227                 node = next;
 228                 if (++entries_printed == callchain_param.print_limit)
 229                         break;
 230         }
 231
 232         if (callchain_param.mode == CHAIN_GRAPH_REL &&
 233                 remaining && remaining != total_samples) {
 234                 struct callchain_node rem_node = {
 235                         .hit = remaining,
 236                 };
 237
 238                 if (!rem_sq_bracket)
 239                         return ret;
 240
 241                 if (callchain_param.value == CCVAL_COUNT && child && child->parent) {
 242                         rem_node.count = child->parent->children_count - cumul_count;
 243                         if (rem_node.count <= 0)
 244                                 return ret;
 245                 }
 246
 247                 new_depth_mask &= ~(1 << (depth - 1));
 248                 ret += ipchain__fprintf_graph(fp, &rem_node, &rem_hits, depth,
 249                                               new_depth_mask, 0, total_samples,
 250                                               left_margin);
 251         }
 252
 253         return ret;
 254 }
 255
 256 /*
 257  * If have one single callchain root, don't bother printing
 258  * its percentage (100 % in fractal mode and the same percentage
 259  * than the hist in graph mode). This also avoid one level of column.
 260  *
 261  * However when percent-limit applied, it's possible that single callchain
 262  * node have different (non-100% in fractal mode) percentage.
 263  */
 264 static bool need_percent_display(struct rb_node *node, u64 parent_samples)
 265 {
 266         struct callchain_node *cnode;
 267
 268         if (rb_next(node))
 269                 return true;
 270
 271         cnode = rb_entry(node, struct callchain_node, rb_node);
 272         return callchain_cumul_hits(cnode) != parent_samples;
 273 }
 274
 275 static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
 276                                        u64 total_samples, u64 parent_samples,
 277                                        int left_margin)
 278 {
 279         struct callchain_node *cnode;
 280         struct callchain_list *chain;
 281         u32 entries_printed = 0;
 282         bool printed = false;
 283         struct rb_node *node;
 284         int i = 0;
 285         int ret = 0;
 286         char bf[1024];
 287
 288         node = rb_first(root);
 289         if (node && !need_percent_display(node, parent_samples)) {
 290                 cnode = rb_entry(node, struct callchain_node, rb_node);
 291                 list_for_each_entry(chain, &cnode->val, list) {
 292                         /*
 293                          * If we sort by symbol, the first entry is the same than
 294                          * the symbol. No need to print it otherwise it appears as
 295                          * displayed twice.
 296                          */
 297                         if (!i++ && field_order == NULL &&
 298                             sort_order && !prefixcmp(sort_order, "sym"))
 299                                 continue;
 300
 301                         if (!printed) {
 302                                 ret += callchain__fprintf_left_margin(fp, left_margin);
 303                                 ret += fprintf(fp, "|\n");
 304                                 ret += callchain__fprintf_left_margin(fp, left_margin);
 305                                 ret += fprintf(fp, "---");
 306                                 left_margin += 3;
 307                                 printed = true;
 308                         } else
 309                                 ret += callchain__fprintf_left_margin(fp, left_margin);
 310
 311                         ret += fprintf(fp, "%s",
 312                                        callchain_list__sym_name(chain, bf,
 313                                                                 sizeof(bf),
 314                                                                 false));
 315
 316                         if (symbol_conf.show_branchflag_count)
 317                                 ret += callchain_list_counts__printf_value(
 318                                                 NULL, chain, fp, NULL, 0);
 319                         ret += fprintf(fp, "\n");
 320
 321                         if (++entries_printed == callchain_param.print_limit)
 322                                 break;
 323
 324                         if (symbol_conf.inline_name)
 325                                 ret += inline__fprintf(chain->ms.map,
 326                                                        chain->ip,
 327                                                        left_margin,
 328                                                        0, 0,
 329                                                        fp);
 330                 }
 331                 root = &cnode->rb_root;
 332         }
 333
 334         if (callchain_param.mode == CHAIN_GRAPH_REL)
 335                 total_samples = parent_samples;
 336
 337         ret += __callchain__fprintf_graph(fp, root, total_samples,
 338                                           1, 1, left_margin);
 339         if (ret) {
 340                 /* do not add a blank line if it printed nothing */
 341                 ret += fprintf(fp, "\n");
 342         }
 343
 344         return ret;
 345 }
 346
 347 static size_t __callchain__fprintf_flat(FILE *fp, struct callchain_node *node,
 348                                         u64 total_samples)
 349 {
 350         struct callchain_list *chain;
 351         size_t ret = 0;
 352         char bf[1024];
 353
 354         if (!node)
 355                 return 0;
 356
 357         ret += __callchain__fprintf_flat(fp, node->parent, total_samples);
 358
 359
 360         list_for_each_entry(chain, &node->val, list) {
 361                 if (chain->ip >= PERF_CONTEXT_MAX)
 362                         continue;
 363                 ret += fprintf(fp, "                %s\n", callchain_list__sym_name(chain,
 364                                         bf, sizeof(bf), false));
 365         }
 366
 367         return ret;
 368 }
 369
 370 static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *tree,
 371                                       u64 total_samples)
 372 {
 373         size_t ret = 0;
 374         u32 entries_printed = 0;
 375         struct callchain_node *chain;
 376         struct rb_node *rb_node = rb_first(tree);
 377
 378         while (rb_node) {
 379                 chain = rb_entry(rb_node, struct callchain_node, rb_node);
 380
 381                 ret += fprintf(fp, "           ");
 382                 ret += callchain_node__fprintf_value(chain, fp, total_samples);
 383                 ret += fprintf(fp, "\n");
 384                 ret += __callchain__fprintf_flat(fp, chain, total_samples);
 385                 ret += fprintf(fp, "\n");
 386                 if (++entries_printed == callchain_param.print_limit)
 387                         break;
 388
 389                 rb_node = rb_next(rb_node);
 390         }
 391
 392         return ret;
 393 }
 394
 395 static size_t __callchain__fprintf_folded(FILE *fp, struct callchain_node *node)
 396 {
 397         const char *sep = symbol_conf.field_sep ?: ";";
 398         struct callchain_list *chain;
 399         size_t ret = 0;
 400         char bf[1024];
 401         bool first;
 402
 403         if (!node)
 404                 return 0;
 405
 406         ret += __callchain__fprintf_folded(fp, node->parent);
 407
 408         first = (ret == 0);
 409         list_for_each_entry(chain, &node->val, list) {
 410                 if (chain->ip >= PERF_CONTEXT_MAX)
 411                         continue;
 412                 ret += fprintf(fp, "%s%s", first ? "" : sep,
 413                                callchain_list__sym_name(chain,
 414                                                 bf, sizeof(bf), false));
 415                 first = false;
 416         }
 417
 418         return ret;
 419 }
 420
 421 static size_t callchain__fprintf_folded(FILE *fp, struct rb_root *tree,
 422                                         u64 total_samples)
 423 {
 424         size_t ret = 0;
 425         u32 entries_printed = 0;
 426         struct callchain_node *chain;
 427         struct rb_node *rb_node = rb_first(tree);
 428
 429         while (rb_node) {
 430
 431                 chain = rb_entry(rb_node, struct callchain_node, rb_node);
 432
 433                 ret += callchain_node__fprintf_value(chain, fp, total_samples);
 434                 ret += fprintf(fp, " ");
 435                 ret += __callchain__fprintf_folded(fp, chain);
 436                 ret += fprintf(fp, "\n");
 437                 if (++entries_printed == callchain_param.print_limit)
 438                         break;
 439
 440                 rb_node = rb_next(rb_node);
 441         }
 442
 443         return ret;
 444 }
 445
 446 static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
 447                                             u64 total_samples, int left_margin,
 448                                             FILE *fp)
 449 {
 450         u64 parent_samples = he->stat.period;
 451
 452         if (symbol_conf.cumulate_callchain)
 453                 parent_samples = he->stat_acc->period;
 454
 455         switch (callchain_param.mode) {
 456         case CHAIN_GRAPH_REL:
 457                 return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
 458                                                 parent_samples, left_margin);
 459                 break;
 460         case CHAIN_GRAPH_ABS:
 461                 return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
 462                                                 parent_samples, left_margin);
 463                 break;
 464         case CHAIN_FLAT:
 465                 return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
 466                 break;
 467         case CHAIN_FOLDED:
 468                 return callchain__fprintf_folded(fp, &he->sorted_chain, total_samples);
 469                 break;
 470         case CHAIN_NONE:
 471                 break;
 472         default:
 473                 pr_err("Bad callchain mode\n");
 474         }
 475
 476         return 0;
 477 }
 478
 479 int __hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp,
 480                            struct perf_hpp_list *hpp_list)
 481 {
 482         const char *sep = symbol_conf.field_sep;
 483         struct perf_hpp_fmt *fmt;
 484         char *start = hpp->buf;
 485         int ret;
 486         bool first = true;
 487
 488         if (symbol_conf.exclude_other && !he->parent)
 489                 return 0;
 490
 491         perf_hpp_list__for_each_format(hpp_list, fmt) {
 492                 if (perf_hpp__should_skip(fmt, he->hists))
 493                         continue;
 494
 495                 /*
 496                  * If there's no field_sep, we still need
 497                  * to display initial '  '.
 498                  */
 499                 if (!sep || !first) {
 500                         ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
 501                         advance_hpp(hpp, ret);
 502                 } else
 503                         first = false;
 504
 505                 if (perf_hpp__use_color() && fmt->color)
 506                         ret = fmt->color(fmt, hpp, he);
 507                 else
 508                         ret = fmt->entry(fmt, hpp, he);
 509
 510                 ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
 511                 advance_hpp(hpp, ret);
 512         }
 513
 514         return hpp->buf - start;
 515 }
 516
 517 static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
 518 {
 519         return __hist_entry__snprintf(he, hpp, he->hists->hpp_list);
 520 }
 521
 522 static int hist_entry__hierarchy_fprintf(struct hist_entry *he,
 523                                          struct perf_hpp *hpp,
 524                                          struct hists *hists,
 525                                          FILE *fp)
 526 {
 527         const char *sep = symbol_conf.field_sep;
 528         struct perf_hpp_fmt *fmt;
 529         struct perf_hpp_list_node *fmt_node;
 530         char *buf = hpp->buf;
 531         size_t size = hpp->size;
 532         int ret, printed = 0;
 533         bool first = true;
 534
 535         if (symbol_conf.exclude_other && !he->parent)
 536                 return 0;
 537
 538         ret = scnprintf(hpp->buf, hpp->size, "%*s", he->depth * HIERARCHY_INDENT, "");
 539         advance_hpp(hpp, ret);
 540
 541         /* the first hpp_list_node is for overhead columns */
 542         fmt_node = list_first_entry(&hists->hpp_formats,
 543                                     struct perf_hpp_list_node, list);
 544         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
 545                 /*
 546                  * If there's no field_sep, we still need
 547                  * to display initial '  '.
 548                  */
 549                 if (!sep || !first) {
 550                         ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
 551                         advance_hpp(hpp, ret);
 552                 } else
 553                         first = false;
 554
 555                 if (perf_hpp__use_color() && fmt->color)
 556                         ret = fmt->color(fmt, hpp, he);
 557                 else
 558                         ret = fmt->entry(fmt, hpp, he);
 559
 560                 ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
 561                 advance_hpp(hpp, ret);
 562         }
 563
 564         if (!sep)
 565                 ret = scnprintf(hpp->buf, hpp->size, "%*s",
 566                                 (hists->nr_hpp_node - 2) * HIERARCHY_INDENT, "");
 567         advance_hpp(hpp, ret);
 568
 569         printed += fprintf(fp, "%s", buf);
 570
 571         perf_hpp_list__for_each_format(he->hpp_list, fmt) {
 572                 hpp->buf  = buf;
 573                 hpp->size = size;
 574
 575                 /*
 576                  * No need to call hist_entry__snprintf_alignment() since this
 577                  * fmt is always the last column in the hierarchy mode.
 578                  */
 579                 if (perf_hpp__use_color() && fmt->color)
 580                         fmt->color(fmt, hpp, he);
 581                 else
 582                         fmt->entry(fmt, hpp, he);
 583
 584                 /*
 585                  * dynamic entries are right-aligned but we want left-aligned
 586                  * in the hierarchy mode
 587                  */
 588                 printed += fprintf(fp, "%s%s", sep ?: "  ", ltrim(buf));
 589         }
 590         printed += putc('\n', fp);
 591
 592         if (symbol_conf.use_callchain && he->leaf) {
 593                 u64 total = hists__total_period(hists);
 594
 595                 printed += hist_entry_callchain__fprintf(he, total, 0, fp);
 596                 goto out;
 597         }
 598
 599 out:
 600         return printed;
 601 }
 602
 603 static int hist_entry__fprintf(struct hist_entry *he, size_t size,
 604                                char *bf, size_t bfsz, FILE *fp,
 605                                bool use_callchain)
 606 {
 607         int ret;
 608         int callchain_ret = 0;
 609         int inline_ret = 0;
 610         struct perf_hpp hpp = {
 611                 .buf            = bf,
 612                 .size           = size,
 613         };
 614         struct hists *hists = he->hists;
 615         u64 total_period = hists->stats.total_period;
 616
 617         if (size == 0 || size > bfsz)
 618                 size = hpp.size = bfsz;
 619
 620         if (symbol_conf.report_hierarchy)
 621                 return hist_entry__hierarchy_fprintf(he, &hpp, hists, fp);
 622
 623         hist_entry__snprintf(he, &hpp);
 624
 625         ret = fprintf(fp, "%s\n", bf);
 626
 627         if (use_callchain)
 628                 callchain_ret = hist_entry_callchain__fprintf(he, total_period,
 629                                                               0, fp);
 630
 631         if (callchain_ret == 0 && symbol_conf.inline_name) {
 632                 inline_ret = inline__fprintf(he->ms.map, he->ip, 0, 0, 0, fp);
 633                 ret += inline_ret;
 634                 if (inline_ret > 0)
 635                         ret += fprintf(fp, "\n");
 636         } else
 637                 ret += callchain_ret;
 638
 639         return ret;
 640 }
 641
 642 static int print_hierarchy_indent(const char *sep, int indent,
 643                                   const char *line, FILE *fp)
 644 {
 645         if (sep != NULL || indent < 2)
 646                 return 0;
 647
 648         return fprintf(fp, "%-.*s", (indent - 2) * HIERARCHY_INDENT, line);
 649 }
 650
 651 static int hists__fprintf_hierarchy_headers(struct hists *hists,
 652                                             struct perf_hpp *hpp, FILE *fp)
 653 {
 654         bool first_node, first_col;
 655         int indent;
 656         int depth;
 657         unsigned width = 0;
 658         unsigned header_width = 0;
 659         struct perf_hpp_fmt *fmt;
 660         struct perf_hpp_list_node *fmt_node;
 661         const char *sep = symbol_conf.field_sep;
 662
 663         indent = hists->nr_hpp_node;
 664
 665         /* preserve max indent depth for column headers */
 666         print_hierarchy_indent(sep, indent, spaces, fp);
 667
 668         /* the first hpp_list_node is for overhead columns */
 669         fmt_node = list_first_entry(&hists->hpp_formats,
 670                                     struct perf_hpp_list_node, list);
 671
 672         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
 673                 fmt->header(fmt, hpp, hists, 0, NULL);
 674                 fprintf(fp, "%s%s", hpp->buf, sep ?: "  ");
 675         }
 676
 677         /* combine sort headers with ' / ' */
 678         first_node = true;
 679         list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
 680                 if (!first_node)
 681                         header_width += fprintf(fp, " / ");
 682                 first_node = false;
 683
 684                 first_col = true;
 685                 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
 686                         if (perf_hpp__should_skip(fmt, hists))
 687                                 continue;
 688
 689                         if (!first_col)
 690                                 header_width += fprintf(fp, "+");
 691                         first_col = false;
 692
 693                         fmt->header(fmt, hpp, hists, 0, NULL);
 694
 695                         header_width += fprintf(fp, "%s", trim(hpp->buf));
 696                 }
 697         }
 698
 699         fprintf(fp, "\n# ");
 700
 701         /* preserve max indent depth for initial dots */
 702         print_hierarchy_indent(sep, indent, dots, fp);
 703
 704         /* the first hpp_list_node is for overhead columns */
 705         fmt_node = list_first_entry(&hists->hpp_formats,
 706                                     struct perf_hpp_list_node, list);
 707
 708         first_col = true;
 709         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
 710                 if (!first_col)
 711                         fprintf(fp, "%s", sep ?: "..");
 712                 first_col = false;
 713
 714                 width = fmt->width(fmt, hpp, hists);
 715                 fprintf(fp, "%.*s", width, dots);
 716         }
 717
 718         depth = 0;
 719         list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
 720                 first_col = true;
 721                 width = depth * HIERARCHY_INDENT;
 722
 723                 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
 724                         if (perf_hpp__should_skip(fmt, hists))
 725                                 continue;
 726
 727                         if (!first_col)
 728                                 width++;  /* for '+' sign between column header */
 729                         first_col = false;
 730
 731                         width += fmt->width(fmt, hpp, hists);
 732                 }
 733
 734                 if (width > header_width)
 735                         header_width = width;
 736
 737                 depth++;
 738         }
 739
 740         fprintf(fp, "%s%-.*s", sep ?: "  ", header_width, dots);
 741
 742         fprintf(fp, "\n#\n");
 743
 744         return 2;
 745 }
 746
 747 static void fprintf_line(struct hists *hists, struct perf_hpp *hpp,
 748                          int line, FILE *fp)
 749 {
 750         struct perf_hpp_fmt *fmt;
 751         const char *sep = symbol_conf.field_sep;
 752         bool first = true;
 753         int span = 0;
 754
 755         hists__for_each_format(hists, fmt) {
 756                 if (perf_hpp__should_skip(fmt, hists))
 757                         continue;
 758
 759                 if (!first && !span)
 760                         fprintf(fp, "%s", sep ?: "  ");
 761                 else
 762                         first = false;
 763
 764                 fmt->header(fmt, hpp, hists, line, &span);
 765
 766                 if (!span)
 767                         fprintf(fp, "%s", hpp->buf);
 768         }
 769 }
 770
 771 static int
 772 hists__fprintf_standard_headers(struct hists *hists,
 773                                 struct perf_hpp *hpp,
 774                                 FILE *fp)
 775 {
 776         struct perf_hpp_list *hpp_list = hists->hpp_list;
 777         struct perf_hpp_fmt *fmt;
 778         unsigned int width;
 779         const char *sep = symbol_conf.field_sep;
 780         bool first = true;
 781         int line;
 782
 783         for (line = 0; line < hpp_list->nr_header_lines; line++) {
 784                 /* first # is displayed one level up */
 785                 if (line)
 786                         fprintf(fp, "# ");
 787                 fprintf_line(hists, hpp, line, fp);
 788                 fprintf(fp, "\n");
 789         }
 790
 791         if (sep)
 792                 return hpp_list->nr_header_lines;
 793
 794         first = true;
 795
 796         fprintf(fp, "# ");
 797
 798         hists__for_each_format(hists, fmt) {
 799                 unsigned int i;
 800
 801                 if (perf_hpp__should_skip(fmt, hists))
 802                         continue;
 803
 804                 if (!first)
 805                         fprintf(fp, "%s", sep ?: "  ");
 806                 else
 807                         first = false;
 808
 809                 width = fmt->width(fmt, hpp, hists);
 810                 for (i = 0; i < width; i++)
 811                         fprintf(fp, ".");
 812         }
 813
 814         fprintf(fp, "\n");
 815         fprintf(fp, "#\n");
 816         return hpp_list->nr_header_lines + 2;
 817 }
 818
 819 int hists__fprintf_headers(struct hists *hists, FILE *fp)
 820 {
 821         char bf[1024];
 822         struct perf_hpp dummy_hpp = {
 823                 .buf    = bf,
 824                 .size   = sizeof(bf),
 825         };
 826
 827         fprintf(fp, "# ");
 828
 829         if (symbol_conf.report_hierarchy)
 830                 return hists__fprintf_hierarchy_headers(hists, &dummy_hpp, fp);
 831         else
 832                 return hists__fprintf_standard_headers(hists, &dummy_hpp, fp);
 833
 834 }
 835
 836 size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
 837                       int max_cols, float min_pcnt, FILE *fp,
 838                       bool use_callchain)
 839 {
 840         struct rb_node *nd;
 841         size_t ret = 0;
 842         const char *sep = symbol_conf.field_sep;
 843         int nr_rows = 0;
 844         size_t linesz;
 845         char *line = NULL;
 846         unsigned indent;
 847
 848         init_rem_hits();
 849
 850         hists__reset_column_width(hists);
 851
 852         if (symbol_conf.col_width_list_str)
 853                 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
 854
 855         if (show_header)
 856                 nr_rows += hists__fprintf_headers(hists, fp);
 857
 858         if (max_rows && nr_rows >= max_rows)
 859                 goto out;
 860
 861         linesz = hists__sort_list_width(hists) + 3 + 1;
 862         linesz += perf_hpp__color_overhead();
 863         line = malloc(linesz);
 864         if (line == NULL) {
 865                 ret = -1;
 866                 goto out;
 867         }
 868
 869         indent = hists__overhead_width(hists) + 4;
 870
 871         for (nd = rb_first(&hists->entries); nd; nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD)) {
 872                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 873                 float percent;
 874
 875                 if (h->filtered)
 876                         continue;
 877
 878                 percent = hist_entry__get_percent_limit(h);
 879                 if (percent < min_pcnt)
 880                         continue;
 881
 882                 ret += hist_entry__fprintf(h, max_cols, line, linesz, fp, use_callchain);
 883
 884                 if (max_rows && ++nr_rows >= max_rows)
 885                         break;
 886
 887                 /*
 888                  * If all children are filtered out or percent-limited,
 889                  * display "no entry >= x.xx%" message.
 890                  */
 891                 if (!h->leaf && !hist_entry__has_hierarchy_children(h, min_pcnt)) {
 892                         int depth = hists->nr_hpp_node + h->depth + 1;
 893
 894                         print_hierarchy_indent(sep, depth, spaces, fp);
 895                         fprintf(fp, "%*sno entry >= %.2f%%\n", indent, "", min_pcnt);
 896
 897                         if (max_rows && ++nr_rows >= max_rows)
 898                                 break;
 899                 }
 900
 901                 if (h->ms.map == NULL && verbose > 1) {
 902                         __map_groups__fprintf_maps(h->thread->mg,
 903                                                    MAP__FUNCTION, fp);
 904                         fprintf(fp, "%.10s end\n", graph_dotted_line);
 905                 }
 906         }
 907
 908         free(line);
 909 out:
 910         zfree(&rem_sq_bracket);
 911
 912         return ret;
 913 }
 914
 915 size_t events_stats__fprintf(struct events_stats *stats, FILE *fp)
 916 {
 917         int i;
 918         size_t ret = 0;
 919
 920         for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
 921                 const char *name;
 922
 923                 if (stats->nr_events[i] == 0)
 924                         continue;
 925
 926                 name = perf_event__name(i);
 927                 if (!strcmp(name, "UNKNOWN"))
 928                         continue;
 929
 930                 ret += fprintf(fp, "%16s events: %10d\n", name,
 931                                stats->nr_events[i]);
 932         }
 933
 934         return ret;
 935 }