tools/perf/ui/browsers/hists.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <dirent.h>
   3 #include <errno.h>
   4 #include <inttypes.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <linux/rbtree.h>
   9 #include <sys/ttydefaults.h>
  10
  11 #include "../../util/evsel.h"
  12 #include "../../util/evlist.h"
  13 #include "../../util/hist.h"
  14 #include "../../util/pstack.h"
  15 #include "../../util/sort.h"
  16 #include "../../util/util.h"
  17 #include "../../util/top.h"
  18 #include "../../util/thread.h"
  19 #include "../../arch/common.h"
  20
  21 #include "../browsers/hists.h"
  22 #include "../helpline.h"
  23 #include "../util.h"
  24 #include "../ui.h"
  25 #include "map.h"
  26 #include "annotate.h"
  27 #include "srcline.h"
  28 #include "string2.h"
  29 #include "units.h"
  30
  31 #include "sane_ctype.h"
  32
  33 extern void hist_browser__init_hpp(void);
  34
  35 static int perf_evsel_browser_title(struct hist_browser *browser,
  36                                     char *bf, size_t size);
  37 static void hist_browser__update_nr_entries(struct hist_browser *hb);
  38
  39 static struct rb_node *hists__filter_entries(struct rb_node *nd,
  40                                              float min_pcnt);
  41
  42 static bool hist_browser__has_filter(struct hist_browser *hb)
  43 {
  44         return hists__has_filter(hb->hists) || hb->min_pcnt || symbol_conf.has_filter || hb->c2c_filter;
  45 }
  46
  47 static int hist_browser__get_folding(struct hist_browser *browser)
  48 {
  49         struct rb_node *nd;
  50         struct hists *hists = browser->hists;
  51         int unfolded_rows = 0;
  52
  53         for (nd = rb_first(&hists->entries);
  54              (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
  55              nd = rb_hierarchy_next(nd)) {
  56                 struct hist_entry *he =
  57                         rb_entry(nd, struct hist_entry, rb_node);
  58
  59                 if (he->leaf && he->unfolded)
  60                         unfolded_rows += he->nr_rows;
  61         }
  62         return unfolded_rows;
  63 }
  64
  65 static u32 hist_browser__nr_entries(struct hist_browser *hb)
  66 {
  67         u32 nr_entries;
  68
  69         if (symbol_conf.report_hierarchy)
  70                 nr_entries = hb->nr_hierarchy_entries;
  71         else if (hist_browser__has_filter(hb))
  72                 nr_entries = hb->nr_non_filtered_entries;
  73         else
  74                 nr_entries = hb->hists->nr_entries;
  75
  76         hb->nr_callchain_rows = hist_browser__get_folding(hb);
  77         return nr_entries + hb->nr_callchain_rows;
  78 }
  79
  80 static void hist_browser__update_rows(struct hist_browser *hb)
  81 {
  82         struct ui_browser *browser = &hb->b;
  83         struct hists *hists = hb->hists;
  84         struct perf_hpp_list *hpp_list = hists->hpp_list;
  85         u16 header_offset, index_row;
  86
  87         header_offset = hb->show_headers ? hpp_list->nr_header_lines : 0;
  88         browser->rows = browser->height - header_offset;
  89         /*
  90          * Verify if we were at the last line and that line isn't
  91          * visibe because we now show the header line(s).
  92          */
  93         index_row = browser->index - browser->top_idx;
  94         if (index_row >= browser->rows)
  95                 browser->index -= index_row - browser->rows + 1;
  96 }
  97
  98 static void hist_browser__refresh_dimensions(struct ui_browser *browser)
  99 {
 100         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
 101
 102         /* 3 == +/- toggle symbol before actual hist_entry rendering */
 103         browser->width = 3 + (hists__sort_list_width(hb->hists) + sizeof("[k]"));
 104         /*
 105          * FIXME: Just keeping existing behaviour, but this really should be
 106          *        before updating browser->width, as it will invalidate the
 107          *        calculation above. Fix this and the fallout in another
 108          *        changeset.
 109          */
 110         ui_browser__refresh_dimensions(browser);
 111         hist_browser__update_rows(hb);
 112 }
 113
 114 static void hist_browser__gotorc(struct hist_browser *browser, int row, int column)
 115 {
 116         struct hists *hists = browser->hists;
 117         struct perf_hpp_list *hpp_list = hists->hpp_list;
 118         u16 header_offset;
 119
 120         header_offset = browser->show_headers ? hpp_list->nr_header_lines : 0;
 121         ui_browser__gotorc(&browser->b, row + header_offset, column);
 122 }
 123
 124 static void hist_browser__reset(struct hist_browser *browser)
 125 {
 126         /*
 127          * The hists__remove_entry_filter() already folds non-filtered
 128          * entries so we can assume it has 0 callchain rows.
 129          */
 130         browser->nr_callchain_rows = 0;
 131
 132         hist_browser__update_nr_entries(browser);
 133         browser->b.nr_entries = hist_browser__nr_entries(browser);
 134         hist_browser__refresh_dimensions(&browser->b);
 135         ui_browser__reset_index(&browser->b);
 136 }
 137
 138 static char tree__folded_sign(bool unfolded)
 139 {
 140         return unfolded ? '-' : '+';
 141 }
 142
 143 static char hist_entry__folded(const struct hist_entry *he)
 144 {
 145         return he->has_children ? tree__folded_sign(he->unfolded) : ' ';
 146 }
 147
 148 static char callchain_list__folded(const struct callchain_list *cl)
 149 {
 150         return cl->has_children ? tree__folded_sign(cl->unfolded) : ' ';
 151 }
 152
 153 static void callchain_list__set_folding(struct callchain_list *cl, bool unfold)
 154 {
 155         cl->unfolded = unfold ? cl->has_children : false;
 156 }
 157
 158 static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
 159 {
 160         int n = 0;
 161         struct rb_node *nd;
 162
 163         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
 164                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 165                 struct callchain_list *chain;
 166                 char folded_sign = ' '; /* No children */
 167
 168                 list_for_each_entry(chain, &child->val, list) {
 169                         ++n;
 170
 171                         /* We need this because we may not have children */
 172                         folded_sign = callchain_list__folded(chain);
 173                         if (folded_sign == '+')
 174                                 break;
 175                 }
 176
 177                 if (folded_sign == '-') /* Have children and they're unfolded */
 178                         n += callchain_node__count_rows_rb_tree(child);
 179         }
 180
 181         return n;
 182 }
 183
 184 static int callchain_node__count_flat_rows(struct callchain_node *node)
 185 {
 186         struct callchain_list *chain;
 187         char folded_sign = 0;
 188         int n = 0;
 189
 190         list_for_each_entry(chain, &node->parent_val, list) {
 191                 if (!folded_sign) {
 192                         /* only check first chain list entry */
 193                         folded_sign = callchain_list__folded(chain);
 194                         if (folded_sign == '+')
 195                                 return 1;
 196                 }
 197                 n++;
 198         }
 199
 200         list_for_each_entry(chain, &node->val, list) {
 201                 if (!folded_sign) {
 202                         /* node->parent_val list might be empty */
 203                         folded_sign = callchain_list__folded(chain);
 204                         if (folded_sign == '+')
 205                                 return 1;
 206                 }
 207                 n++;
 208         }
 209
 210         return n;
 211 }
 212
 213 static int callchain_node__count_folded_rows(struct callchain_node *node __maybe_unused)
 214 {
 215         return 1;
 216 }
 217
 218 static int callchain_node__count_rows(struct callchain_node *node)
 219 {
 220         struct callchain_list *chain;
 221         bool unfolded = false;
 222         int n = 0;
 223
 224         if (callchain_param.mode == CHAIN_FLAT)
 225                 return callchain_node__count_flat_rows(node);
 226         else if (callchain_param.mode == CHAIN_FOLDED)
 227                 return callchain_node__count_folded_rows(node);
 228
 229         list_for_each_entry(chain, &node->val, list) {
 230                 ++n;
 231
 232                 unfolded = chain->unfolded;
 233         }
 234
 235         if (unfolded)
 236                 n += callchain_node__count_rows_rb_tree(node);
 237
 238         return n;
 239 }
 240
 241 static int callchain__count_rows(struct rb_root *chain)
 242 {
 243         struct rb_node *nd;
 244         int n = 0;
 245
 246         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 247                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 248                 n += callchain_node__count_rows(node);
 249         }
 250
 251         return n;
 252 }
 253
 254 static int hierarchy_count_rows(struct hist_browser *hb, struct hist_entry *he,
 255                                 bool include_children)
 256 {
 257         int count = 0;
 258         struct rb_node *node;
 259         struct hist_entry *child;
 260
 261         if (he->leaf)
 262                 return callchain__count_rows(&he->sorted_chain);
 263
 264         if (he->has_no_entry)
 265                 return 1;
 266
 267         node = rb_first(&he->hroot_out);
 268         while (node) {
 269                 float percent;
 270
 271                 child = rb_entry(node, struct hist_entry, rb_node);
 272                 percent = hist_entry__get_percent_limit(child);
 273
 274                 if (!child->filtered && percent >= hb->min_pcnt) {
 275                         count++;
 276
 277                         if (include_children && child->unfolded)
 278                                 count += hierarchy_count_rows(hb, child, true);
 279                 }
 280
 281                 node = rb_next(node);
 282         }
 283         return count;
 284 }
 285
 286 static bool hist_entry__toggle_fold(struct hist_entry *he)
 287 {
 288         if (!he)
 289                 return false;
 290
 291         if (!he->has_children)
 292                 return false;
 293
 294         he->unfolded = !he->unfolded;
 295         return true;
 296 }
 297
 298 static bool callchain_list__toggle_fold(struct callchain_list *cl)
 299 {
 300         if (!cl)
 301                 return false;
 302
 303         if (!cl->has_children)
 304                 return false;
 305
 306         cl->unfolded = !cl->unfolded;
 307         return true;
 308 }
 309
 310 static void callchain_node__init_have_children_rb_tree(struct callchain_node *node)
 311 {
 312         struct rb_node *nd = rb_first(&node->rb_root);
 313
 314         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
 315                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 316                 struct callchain_list *chain;
 317                 bool first = true;
 318
 319                 list_for_each_entry(chain, &child->val, list) {
 320                         if (first) {
 321                                 first = false;
 322                                 chain->has_children = chain->list.next != &child->val ||
 323                                                          !RB_EMPTY_ROOT(&child->rb_root);
 324                         } else
 325                                 chain->has_children = chain->list.next == &child->val &&
 326                                                          !RB_EMPTY_ROOT(&child->rb_root);
 327                 }
 328
 329                 callchain_node__init_have_children_rb_tree(child);
 330         }
 331 }
 332
 333 static void callchain_node__init_have_children(struct callchain_node *node,
 334                                                bool has_sibling)
 335 {
 336         struct callchain_list *chain;
 337
 338         chain = list_entry(node->val.next, struct callchain_list, list);
 339         chain->has_children = has_sibling;
 340
 341         if (!list_empty(&node->val)) {
 342                 chain = list_entry(node->val.prev, struct callchain_list, list);
 343                 chain->has_children = !RB_EMPTY_ROOT(&node->rb_root);
 344         }
 345
 346         callchain_node__init_have_children_rb_tree(node);
 347 }
 348
 349 static void callchain__init_have_children(struct rb_root *root)
 350 {
 351         struct rb_node *nd = rb_first(root);
 352         bool has_sibling = nd && rb_next(nd);
 353
 354         for (nd = rb_first(root); nd; nd = rb_next(nd)) {
 355                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 356                 callchain_node__init_have_children(node, has_sibling);
 357                 if (callchain_param.mode == CHAIN_FLAT ||
 358                     callchain_param.mode == CHAIN_FOLDED)
 359                         callchain_node__make_parent_list(node);
 360         }
 361 }
 362
 363 static void hist_entry__init_have_children(struct hist_entry *he)
 364 {
 365         if (he->init_have_children)
 366                 return;
 367
 368         if (he->leaf) {
 369                 he->has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
 370                 callchain__init_have_children(&he->sorted_chain);
 371         } else {
 372                 he->has_children = !RB_EMPTY_ROOT(&he->hroot_out);
 373         }
 374
 375         he->init_have_children = true;
 376 }
 377
 378 static bool hist_browser__toggle_fold(struct hist_browser *browser)
 379 {
 380         struct hist_entry *he = browser->he_selection;
 381         struct map_symbol *ms = browser->selection;
 382         struct callchain_list *cl = container_of(ms, struct callchain_list, ms);
 383         bool has_children;
 384
 385         if (!he || !ms)
 386                 return false;
 387
 388         if (ms == &he->ms)
 389                 has_children = hist_entry__toggle_fold(he);
 390         else
 391                 has_children = callchain_list__toggle_fold(cl);
 392
 393         if (has_children) {
 394                 int child_rows = 0;
 395
 396                 hist_entry__init_have_children(he);
 397                 browser->b.nr_entries -= he->nr_rows;
 398
 399                 if (he->leaf)
 400                         browser->nr_callchain_rows -= he->nr_rows;
 401                 else
 402                         browser->nr_hierarchy_entries -= he->nr_rows;
 403
 404                 if (symbol_conf.report_hierarchy)
 405                         child_rows = hierarchy_count_rows(browser, he, true);
 406
 407                 if (he->unfolded) {
 408                         if (he->leaf)
 409                                 he->nr_rows = callchain__count_rows(
 410                                                 &he->sorted_chain);
 411                         else
 412                                 he->nr_rows = hierarchy_count_rows(browser, he, false);
 413
 414                         /* account grand children */
 415                         if (symbol_conf.report_hierarchy)
 416                                 browser->b.nr_entries += child_rows - he->nr_rows;
 417
 418                         if (!he->leaf && he->nr_rows == 0) {
 419                                 he->has_no_entry = true;
 420                                 he->nr_rows = 1;
 421                         }
 422                 } else {
 423                         if (symbol_conf.report_hierarchy)
 424                                 browser->b.nr_entries -= child_rows - he->nr_rows;
 425
 426                         if (he->has_no_entry)
 427                                 he->has_no_entry = false;
 428
 429                         he->nr_rows = 0;
 430                 }
 431
 432                 browser->b.nr_entries += he->nr_rows;
 433
 434                 if (he->leaf)
 435                         browser->nr_callchain_rows += he->nr_rows;
 436                 else
 437                         browser->nr_hierarchy_entries += he->nr_rows;
 438
 439                 return true;
 440         }
 441
 442         /* If it doesn't have children, no toggling performed */
 443         return false;
 444 }
 445
 446 static int callchain_node__set_folding_rb_tree(struct callchain_node *node, bool unfold)
 447 {
 448         int n = 0;
 449         struct rb_node *nd;
 450
 451         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
 452                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 453                 struct callchain_list *chain;
 454                 bool has_children = false;
 455
 456                 list_for_each_entry(chain, &child->val, list) {
 457                         ++n;
 458                         callchain_list__set_folding(chain, unfold);
 459                         has_children = chain->has_children;
 460                 }
 461
 462                 if (has_children)
 463                         n += callchain_node__set_folding_rb_tree(child, unfold);
 464         }
 465
 466         return n;
 467 }
 468
 469 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
 470 {
 471         struct callchain_list *chain;
 472         bool has_children = false;
 473         int n = 0;
 474
 475         list_for_each_entry(chain, &node->val, list) {
 476                 ++n;
 477                 callchain_list__set_folding(chain, unfold);
 478                 has_children = chain->has_children;
 479         }
 480
 481         if (has_children)
 482                 n += callchain_node__set_folding_rb_tree(node, unfold);
 483
 484         return n;
 485 }
 486
 487 static int callchain__set_folding(struct rb_root *chain, bool unfold)
 488 {
 489         struct rb_node *nd;
 490         int n = 0;
 491
 492         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 493                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 494                 n += callchain_node__set_folding(node, unfold);
 495         }
 496
 497         return n;
 498 }
 499
 500 static int hierarchy_set_folding(struct hist_browser *hb, struct hist_entry *he,
 501                                  bool unfold __maybe_unused)
 502 {
 503         float percent;
 504         struct rb_node *nd;
 505         struct hist_entry *child;
 506         int n = 0;
 507
 508         for (nd = rb_first(&he->hroot_out); nd; nd = rb_next(nd)) {
 509                 child = rb_entry(nd, struct hist_entry, rb_node);
 510                 percent = hist_entry__get_percent_limit(child);
 511                 if (!child->filtered && percent >= hb->min_pcnt)
 512                         n++;
 513         }
 514
 515         return n;
 516 }
 517
 518 static void __hist_entry__set_folding(struct hist_entry *he,
 519                                       struct hist_browser *hb, bool unfold)
 520 {
 521         hist_entry__init_have_children(he);
 522         he->unfolded = unfold ? he->has_children : false;
 523
 524         if (he->has_children) {
 525                 int n;
 526
 527                 if (he->leaf)
 528                         n = callchain__set_folding(&he->sorted_chain, unfold);
 529                 else
 530                         n = hierarchy_set_folding(hb, he, unfold);
 531
 532                 he->nr_rows = unfold ? n : 0;
 533         } else
 534                 he->nr_rows = 0;
 535 }
 536
 537 static void hist_entry__set_folding(struct hist_entry *he,
 538                                     struct hist_browser *browser, bool unfold)
 539 {
 540         double percent;
 541
 542         percent = hist_entry__get_percent_limit(he);
 543         if (he->filtered || percent < browser->min_pcnt)
 544                 return;
 545
 546         __hist_entry__set_folding(he, browser, unfold);
 547
 548         if (!he->depth || unfold)
 549                 browser->nr_hierarchy_entries++;
 550         if (he->leaf)
 551                 browser->nr_callchain_rows += he->nr_rows;
 552         else if (unfold && !hist_entry__has_hierarchy_children(he, browser->min_pcnt)) {
 553                 browser->nr_hierarchy_entries++;
 554                 he->has_no_entry = true;
 555                 he->nr_rows = 1;
 556         } else
 557                 he->has_no_entry = false;
 558 }
 559
 560 static void
 561 __hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 562 {
 563         struct rb_node *nd;
 564         struct hist_entry *he;
 565
 566         nd = rb_first(&browser->hists->entries);
 567         while (nd) {
 568                 he = rb_entry(nd, struct hist_entry, rb_node);
 569
 570                 /* set folding state even if it's currently folded */
 571                 nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
 572
 573                 hist_entry__set_folding(he, browser, unfold);
 574         }
 575 }
 576
 577 static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 578 {
 579         browser->nr_hierarchy_entries = 0;
 580         browser->nr_callchain_rows = 0;
 581         __hist_browser__set_folding(browser, unfold);
 582
 583         browser->b.nr_entries = hist_browser__nr_entries(browser);
 584         /* Go to the start, we may be way after valid entries after a collapse */
 585         ui_browser__reset_index(&browser->b);
 586 }
 587
 588 static void hist_browser__set_folding_selected(struct hist_browser *browser, bool unfold)
 589 {
 590         if (!browser->he_selection)
 591                 return;
 592
 593         hist_entry__set_folding(browser->he_selection, browser, unfold);
 594         browser->b.nr_entries = hist_browser__nr_entries(browser);
 595 }
 596
 597 static void ui_browser__warn_lost_events(struct ui_browser *browser)
 598 {
 599         ui_browser__warning(browser, 4,
 600                 "Events are being lost, check IO/CPU overload!\n\n"
 601                 "You may want to run 'perf' using a RT scheduler policy:\n\n"
 602                 " perf top -r 80\n\n"
 603                 "Or reduce the sampling frequency.");
 604 }
 605
 606 static int hist_browser__title(struct hist_browser *browser, char *bf, size_t size)
 607 {
 608         return browser->title ? browser->title(browser, bf, size) : 0;
 609 }
 610
 611 int hist_browser__run(struct hist_browser *browser, const char *help,
 612                       bool warn_lost_event)
 613 {
 614         int key;
 615         char title[160];
 616         struct hist_browser_timer *hbt = browser->hbt;
 617         int delay_secs = hbt ? hbt->refresh : 0;
 618
 619         browser->b.entries = &browser->hists->entries;
 620         browser->b.nr_entries = hist_browser__nr_entries(browser);
 621
 622         hist_browser__title(browser, title, sizeof(title));
 623
 624         if (ui_browser__show(&browser->b, title, "%s", help) < 0)
 625                 return -1;
 626
 627         while (1) {
 628                 key = ui_browser__run(&browser->b, delay_secs);
 629
 630                 switch (key) {
 631                 case K_TIMER: {
 632                         u64 nr_entries;
 633                         hbt->timer(hbt->arg);
 634
 635                         if (hist_browser__has_filter(browser) ||
 636                             symbol_conf.report_hierarchy)
 637                                 hist_browser__update_nr_entries(browser);
 638
 639                         nr_entries = hist_browser__nr_entries(browser);
 640                         ui_browser__update_nr_entries(&browser->b, nr_entries);
 641
 642                         if (warn_lost_event &&
 643                             (browser->hists->stats.nr_lost_warned !=
 644                             browser->hists->stats.nr_events[PERF_RECORD_LOST])) {
 645                                 browser->hists->stats.nr_lost_warned =
 646                                         browser->hists->stats.nr_events[PERF_RECORD_LOST];
 647                                 ui_browser__warn_lost_events(&browser->b);
 648                         }
 649
 650                         hist_browser__title(browser, title, sizeof(title));
 651                         ui_browser__show_title(&browser->b, title);
 652                         continue;
 653                 }
 654                 case 'D': { /* Debug */
 655                         static int seq;
 656                         struct hist_entry *h = rb_entry(browser->b.top,
 657                                                         struct hist_entry, rb_node);
 658                         ui_helpline__pop();
 659                         ui_helpline__fpush("%d: nr_ent=(%d,%d), rows=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
 660                                            seq++, browser->b.nr_entries,
 661                                            browser->hists->nr_entries,
 662                                            browser->b.rows,
 663                                            browser->b.index,
 664                                            browser->b.top_idx,
 665                                            h->row_offset, h->nr_rows);
 666                 }
 667                         break;
 668                 case 'C':
 669                         /* Collapse the whole world. */
 670                         hist_browser__set_folding(browser, false);
 671                         break;
 672                 case 'c':
 673                         /* Collapse the selected entry. */
 674                         hist_browser__set_folding_selected(browser, false);
 675                         break;
 676                 case 'E':
 677                         /* Expand the whole world. */
 678                         hist_browser__set_folding(browser, true);
 679                         break;
 680                 case 'e':
 681                         /* Expand the selected entry. */
 682                         hist_browser__set_folding_selected(browser, true);
 683                         break;
 684                 case 'H':
 685                         browser->show_headers = !browser->show_headers;
 686                         hist_browser__update_rows(browser);
 687                         break;
 688                 case K_ENTER:
 689                         if (hist_browser__toggle_fold(browser))
 690                                 break;
 691                         /* fall thru */
 692                 default:
 693                         goto out;
 694                 }
 695         }
 696 out:
 697         ui_browser__hide(&browser->b);
 698         return key;
 699 }
 700
 701 struct callchain_print_arg {
 702         /* for hists browser */
 703         off_t   row_offset;
 704         bool    is_current_entry;
 705
 706         /* for file dump */
 707         FILE    *fp;
 708         int     printed;
 709 };
 710
 711 typedef void (*print_callchain_entry_fn)(struct hist_browser *browser,
 712                                          struct callchain_list *chain,
 713                                          const char *str, int offset,
 714                                          unsigned short row,
 715                                          struct callchain_print_arg *arg);
 716
 717 static void hist_browser__show_callchain_entry(struct hist_browser *browser,
 718                                                struct callchain_list *chain,
 719                                                const char *str, int offset,
 720                                                unsigned short row,
 721                                                struct callchain_print_arg *arg)
 722 {
 723         int color, width;
 724         char folded_sign = callchain_list__folded(chain);
 725         bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;
 726
 727         color = HE_COLORSET_NORMAL;
 728         width = browser->b.width - (offset + 2);
 729         if (ui_browser__is_current_entry(&browser->b, row)) {
 730                 browser->selection = &chain->ms;
 731                 color = HE_COLORSET_SELECTED;
 732                 arg->is_current_entry = true;
 733         }
 734
 735         ui_browser__set_color(&browser->b, color);
 736         hist_browser__gotorc(browser, row, 0);
 737         ui_browser__write_nstring(&browser->b, " ", offset);
 738         ui_browser__printf(&browser->b, "%c", folded_sign);
 739         ui_browser__write_graph(&browser->b, show_annotated ? SLSMG_RARROW_CHAR : ' ');
 740         ui_browser__write_nstring(&browser->b, str, width);
 741 }
 742
 743 static void hist_browser__fprintf_callchain_entry(struct hist_browser *b __maybe_unused,
 744                                                   struct callchain_list *chain,
 745                                                   const char *str, int offset,
 746                                                   unsigned short row __maybe_unused,
 747                                                   struct callchain_print_arg *arg)
 748 {
 749         char folded_sign = callchain_list__folded(chain);
 750
 751         arg->printed += fprintf(arg->fp, "%*s%c %s\n", offset, " ",
 752                                 folded_sign, str);
 753 }
 754
 755 typedef bool (*check_output_full_fn)(struct hist_browser *browser,
 756                                      unsigned short row);
 757
 758 static bool hist_browser__check_output_full(struct hist_browser *browser,
 759                                             unsigned short row)
 760 {
 761         return browser->b.rows == row;
 762 }
 763
 764 static bool hist_browser__check_dump_full(struct hist_browser *browser __maybe_unused,
 765                                           unsigned short row __maybe_unused)
 766 {
 767         return false;
 768 }
 769
 770 #define LEVEL_OFFSET_STEP 3
 771
 772 static int hist_browser__show_callchain_list(struct hist_browser *browser,
 773                                              struct callchain_node *node,
 774                                              struct callchain_list *chain,
 775                                              unsigned short row, u64 total,
 776                                              bool need_percent, int offset,
 777                                              print_callchain_entry_fn print,
 778                                              struct callchain_print_arg *arg)
 779 {
 780         char bf[1024], *alloc_str;
 781         char buf[64], *alloc_str2;
 782         const char *str;
 783         int ret = 1;
 784
 785         if (arg->row_offset != 0) {
 786                 arg->row_offset--;
 787                 return 0;
 788         }
 789
 790         alloc_str = NULL;
 791         alloc_str2 = NULL;
 792
 793         str = callchain_list__sym_name(chain, bf, sizeof(bf),
 794                                        browser->show_dso);
 795
 796         if (symbol_conf.show_branchflag_count) {
 797                 callchain_list_counts__printf_value(chain, NULL,
 798                                                     buf, sizeof(buf));
 799
 800                 if (asprintf(&alloc_str2, "%s%s", str, buf) < 0)
 801                         str = "Not enough memory!";
 802                 else
 803                         str = alloc_str2;
 804         }
 805
 806         if (need_percent) {
 807                 callchain_node__scnprintf_value(node, buf, sizeof(buf),
 808                                                 total);
 809
 810                 if (asprintf(&alloc_str, "%s %s", buf, str) < 0)
 811                         str = "Not enough memory!";
 812                 else
 813                         str = alloc_str;
 814         }
 815
 816         print(browser, chain, str, offset, row, arg);
 817         free(alloc_str);
 818         free(alloc_str2);
 819
 820         return ret;
 821 }
 822
 823 static bool check_percent_display(struct rb_node *node, u64 parent_total)
 824 {
 825         struct callchain_node *child;
 826
 827         if (node == NULL)
 828                 return false;
 829
 830         if (rb_next(node))
 831                 return true;
 832
 833         child = rb_entry(node, struct callchain_node, rb_node);
 834         return callchain_cumul_hits(child) != parent_total;
 835 }
 836
 837 static int hist_browser__show_callchain_flat(struct hist_browser *browser,
 838                                              struct rb_root *root,
 839                                              unsigned short row, u64 total,
 840                                              u64 parent_total,
 841                                              print_callchain_entry_fn print,
 842                                              struct callchain_print_arg *arg,
 843                                              check_output_full_fn is_output_full)
 844 {
 845         struct rb_node *node;
 846         int first_row = row, offset = LEVEL_OFFSET_STEP;
 847         bool need_percent;
 848
 849         node = rb_first(root);
 850         need_percent = check_percent_display(node, parent_total);
 851
 852         while (node) {
 853                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 854                 struct rb_node *next = rb_next(node);
 855                 struct callchain_list *chain;
 856                 char folded_sign = ' ';
 857                 int first = true;
 858                 int extra_offset = 0;
 859
 860                 list_for_each_entry(chain, &child->parent_val, list) {
 861                         bool was_first = first;
 862
 863                         if (first)
 864                                 first = false;
 865                         else if (need_percent)
 866                                 extra_offset = LEVEL_OFFSET_STEP;
 867
 868                         folded_sign = callchain_list__folded(chain);
 869
 870                         row += hist_browser__show_callchain_list(browser, child,
 871                                                         chain, row, total,
 872                                                         was_first && need_percent,
 873                                                         offset + extra_offset,
 874                                                         print, arg);
 875
 876                         if (is_output_full(browser, row))
 877                                 goto out;
 878
 879                         if (folded_sign == '+')
 880                                 goto next;
 881                 }
 882
 883                 list_for_each_entry(chain, &child->val, list) {
 884                         bool was_first = first;
 885
 886                         if (first)
 887                                 first = false;
 888                         else if (need_percent)
 889                                 extra_offset = LEVEL_OFFSET_STEP;
 890
 891                         folded_sign = callchain_list__folded(chain);
 892
 893                         row += hist_browser__show_callchain_list(browser, child,
 894                                                         chain, row, total,
 895                                                         was_first && need_percent,
 896                                                         offset + extra_offset,
 897                                                         print, arg);
 898
 899                         if (is_output_full(browser, row))
 900                                 goto out;
 901
 902                         if (folded_sign == '+')
 903                                 break;
 904                 }
 905
 906 next:
 907                 if (is_output_full(browser, row))
 908                         break;
 909                 node = next;
 910         }
 911 out:
 912         return row - first_row;
 913 }
 914
 915 static char *hist_browser__folded_callchain_str(struct hist_browser *browser,
 916                                                 struct callchain_list *chain,
 917                                                 char *value_str, char *old_str)
 918 {
 919         char bf[1024];
 920         const char *str;
 921         char *new;
 922
 923         str = callchain_list__sym_name(chain, bf, sizeof(bf),
 924                                        browser->show_dso);
 925         if (old_str) {
 926                 if (asprintf(&new, "%s%s%s", old_str,
 927                              symbol_conf.field_sep ?: ";", str) < 0)
 928                         new = NULL;
 929         } else {
 930                 if (value_str) {
 931                         if (asprintf(&new, "%s %s", value_str, str) < 0)
 932                                 new = NULL;
 933                 } else {
 934                         if (asprintf(&new, "%s", str) < 0)
 935                                 new = NULL;
 936                 }
 937         }
 938         return new;
 939 }
 940
 941 static int hist_browser__show_callchain_folded(struct hist_browser *browser,
 942                                                struct rb_root *root,
 943                                                unsigned short row, u64 total,
 944                                                u64 parent_total,
 945                                                print_callchain_entry_fn print,
 946                                                struct callchain_print_arg *arg,
 947                                                check_output_full_fn is_output_full)
 948 {
 949         struct rb_node *node;
 950         int first_row = row, offset = LEVEL_OFFSET_STEP;
 951         bool need_percent;
 952
 953         node = rb_first(root);
 954         need_percent = check_percent_display(node, parent_total);
 955
 956         while (node) {
 957                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 958                 struct rb_node *next = rb_next(node);
 959                 struct callchain_list *chain, *first_chain = NULL;
 960                 int first = true;
 961                 char *value_str = NULL, *value_str_alloc = NULL;
 962                 char *chain_str = NULL, *chain_str_alloc = NULL;
 963
 964                 if (arg->row_offset != 0) {
 965                         arg->row_offset--;
 966                         goto next;
 967                 }
 968
 969                 if (need_percent) {
 970                         char buf[64];
 971
 972                         callchain_node__scnprintf_value(child, buf, sizeof(buf), total);
 973                         if (asprintf(&value_str, "%s", buf) < 0) {
 974                                 value_str = (char *)"<...>";
 975                                 goto do_print;
 976                         }
 977                         value_str_alloc = value_str;
 978                 }
 979
 980                 list_for_each_entry(chain, &child->parent_val, list) {
 981                         chain_str = hist_browser__folded_callchain_str(browser,
 982                                                 chain, value_str, chain_str);
 983                         if (first) {
 984                                 first = false;
 985                                 first_chain = chain;
 986                         }
 987
 988                         if (chain_str == NULL) {
 989                                 chain_str = (char *)"Not enough memory!";
 990                                 goto do_print;
 991                         }
 992
 993                         chain_str_alloc = chain_str;
 994                 }
 995
 996                 list_for_each_entry(chain, &child->val, list) {
 997                         chain_str = hist_browser__folded_callchain_str(browser,
 998                                                 chain, value_str, chain_str);
 999                         if (first) {
1000                                 first = false;
1001                                 first_chain = chain;
1002                         }
1003
1004                         if (chain_str == NULL) {
1005                                 chain_str = (char *)"Not enough memory!";
1006                                 goto do_print;
1007                         }
1008
1009                         chain_str_alloc = chain_str;
1010                 }
1011
1012 do_print:
1013                 print(browser, first_chain, chain_str, offset, row++, arg);
1014                 free(value_str_alloc);
1015                 free(chain_str_alloc);
1016
1017 next:
1018                 if (is_output_full(browser, row))
1019                         break;
1020                 node = next;
1021         }
1022
1023         return row - first_row;
1024 }
1025
1026 static int hist_browser__show_callchain_graph(struct hist_browser *browser,
1027                                         struct rb_root *root, int level,
1028                                         unsigned short row, u64 total,
1029                                         u64 parent_total,
1030                                         print_callchain_entry_fn print,
1031                                         struct callchain_print_arg *arg,
1032                                         check_output_full_fn is_output_full)
1033 {
1034         struct rb_node *node;
1035         int first_row = row, offset = level * LEVEL_OFFSET_STEP;
1036         bool need_percent;
1037         u64 percent_total = total;
1038
1039         if (callchain_param.mode == CHAIN_GRAPH_REL)
1040                 percent_total = parent_total;
1041
1042         node = rb_first(root);
1043         need_percent = check_percent_display(node, parent_total);
1044
1045         while (node) {
1046                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
1047                 struct rb_node *next = rb_next(node);
1048                 struct callchain_list *chain;
1049                 char folded_sign = ' ';
1050                 int first = true;
1051                 int extra_offset = 0;
1052
1053                 list_for_each_entry(chain, &child->val, list) {
1054                         bool was_first = first;
1055
1056                         if (first)
1057                                 first = false;
1058                         else if (need_percent)
1059                                 extra_offset = LEVEL_OFFSET_STEP;
1060
1061                         folded_sign = callchain_list__folded(chain);
1062
1063                         row += hist_browser__show_callchain_list(browser, child,
1064                                                         chain, row, percent_total,
1065                                                         was_first && need_percent,
1066                                                         offset + extra_offset,
1067                                                         print, arg);
1068
1069                         if (is_output_full(browser, row))
1070                                 goto out;
1071
1072                         if (folded_sign == '+')
1073                                 break;
1074                 }
1075
1076                 if (folded_sign == '-') {
1077                         const int new_level = level + (extra_offset ? 2 : 1);
1078
1079                         row += hist_browser__show_callchain_graph(browser, &child->rb_root,
1080                                                             new_level, row, total,
1081                                                             child->children_hit,
1082                                                             print, arg, is_output_full);
1083                 }
1084                 if (is_output_full(browser, row))
1085                         break;
1086                 node = next;
1087         }
1088 out:
1089         return row - first_row;
1090 }
1091
1092 static int hist_browser__show_callchain(struct hist_browser *browser,
1093                                         struct hist_entry *entry, int level,
1094                                         unsigned short row,
1095                                         print_callchain_entry_fn print,
1096                                         struct callchain_print_arg *arg,
1097                                         check_output_full_fn is_output_full)
1098 {
1099         u64 total = hists__total_period(entry->hists);
1100         u64 parent_total;
1101         int printed;
1102
1103         if (symbol_conf.cumulate_callchain)
1104                 parent_total = entry->stat_acc->period;
1105         else
1106                 parent_total = entry->stat.period;
1107
1108         if (callchain_param.mode == CHAIN_FLAT) {
1109                 printed = hist_browser__show_callchain_flat(browser,
1110                                                 &entry->sorted_chain, row,
1111                                                 total, parent_total, print, arg,
1112                                                 is_output_full);
1113         } else if (callchain_param.mode == CHAIN_FOLDED) {
1114                 printed = hist_browser__show_callchain_folded(browser,
1115                                                 &entry->sorted_chain, row,
1116                                                 total, parent_total, print, arg,
1117                                                 is_output_full);
1118         } else {
1119                 printed = hist_browser__show_callchain_graph(browser,
1120                                                 &entry->sorted_chain, level, row,
1121                                                 total, parent_total, print, arg,
1122                                                 is_output_full);
1123         }
1124
1125         if (arg->is_current_entry)
1126                 browser->he_selection = entry;
1127
1128         return printed;
1129 }
1130
1131 struct hpp_arg {
1132         struct ui_browser *b;
1133         char folded_sign;
1134         bool current_entry;
1135 };
1136
1137 int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
1138 {
1139         struct hpp_arg *arg = hpp->ptr;
1140         int ret, len;
1141         va_list args;
1142         double percent;
1143
1144         va_start(args, fmt);
1145         len = va_arg(args, int);
1146         percent = va_arg(args, double);
1147         va_end(args);
1148
1149         ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
1150
1151         ret = scnprintf(hpp->buf, hpp->size, fmt, len, percent);
1152         ui_browser__printf(arg->b, "%s", hpp->buf);
1153
1154         return ret;
1155 }
1156
1157 #define __HPP_COLOR_PERCENT_FN(_type, _field)                           \
1158 static u64 __hpp_get_##_field(struct hist_entry *he)                    \
1159 {                                                                       \
1160         return he->stat._field;                                         \
1161 }                                                                       \
1162                                                                         \
1163 static int                                                              \
1164 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
1165                                 struct perf_hpp *hpp,                   \
1166                                 struct hist_entry *he)                  \
1167 {                                                                       \
1168         return hpp__fmt(fmt, hpp, he, __hpp_get_##_field, " %*.2f%%",   \
1169                         __hpp__slsmg_color_printf, true);               \
1170 }
1171
1172 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                       \
1173 static u64 __hpp_get_acc_##_field(struct hist_entry *he)                \
1174 {                                                                       \
1175         return he->stat_acc->_field;                                    \
1176 }                                                                       \
1177                                                                         \
1178 static int                                                              \
1179 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
1180                                 struct perf_hpp *hpp,                   \
1181                                 struct hist_entry *he)                  \
1182 {                                                                       \
1183         if (!symbol_conf.cumulate_callchain) {                          \
1184                 struct hpp_arg *arg = hpp->ptr;                         \
1185                 int len = fmt->user_len ?: fmt->len;                    \
1186                 int ret = scnprintf(hpp->buf, hpp->size,                \
1187                                     "%*s", len, "N/A");                 \
1188                 ui_browser__printf(arg->b, "%s", hpp->buf);             \
1189                                                                         \
1190                 return ret;                                             \
1191         }                                                               \
1192         return hpp__fmt(fmt, hpp, he, __hpp_get_acc_##_field,           \
1193                         " %*.2f%%", __hpp__slsmg_color_printf, true);   \
1194 }
1195
1196 __HPP_COLOR_PERCENT_FN(overhead, period)
1197 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
1198 __HPP_COLOR_PERCENT_FN(overhead_us, period_us)
1199 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
1200 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
1201 __HPP_COLOR_ACC_PERCENT_FN(overhead_acc, period)
1202
1203 #undef __HPP_COLOR_PERCENT_FN
1204 #undef __HPP_COLOR_ACC_PERCENT_FN
1205
1206 void hist_browser__init_hpp(void)
1207 {
1208         perf_hpp__format[PERF_HPP__OVERHEAD].color =
1209                                 hist_browser__hpp_color_overhead;
1210         perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
1211                                 hist_browser__hpp_color_overhead_sys;
1212         perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
1213                                 hist_browser__hpp_color_overhead_us;
1214         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
1215                                 hist_browser__hpp_color_overhead_guest_sys;
1216         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
1217                                 hist_browser__hpp_color_overhead_guest_us;
1218         perf_hpp__format[PERF_HPP__OVERHEAD_ACC].color =
1219                                 hist_browser__hpp_color_overhead_acc;
1220 }
1221
1222 static int hist_browser__show_entry(struct hist_browser *browser,
1223                                     struct hist_entry *entry,
1224                                     unsigned short row)
1225 {
1226         int printed = 0;
1227         int width = browser->b.width;
1228         char folded_sign = ' ';
1229         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
1230         off_t row_offset = entry->row_offset;
1231         bool first = true;
1232         struct perf_hpp_fmt *fmt;
1233
1234         if (current_entry) {
1235                 browser->he_selection = entry;
1236                 browser->selection = &entry->ms;
1237         }
1238
1239         if (symbol_conf.use_callchain) {
1240                 hist_entry__init_have_children(entry);
1241                 folded_sign = hist_entry__folded(entry);
1242         }
1243
1244         if (row_offset == 0) {
1245                 struct hpp_arg arg = {
1246                         .b              = &browser->b,
1247                         .folded_sign    = folded_sign,
1248                         .current_entry  = current_entry,
1249                 };
1250                 int column = 0;
1251
1252                 hist_browser__gotorc(browser, row, 0);
1253
1254                 hists__for_each_format(browser->hists, fmt) {
1255                         char s[2048];
1256                         struct perf_hpp hpp = {
1257                                 .buf    = s,
1258                                 .size   = sizeof(s),
1259                                 .ptr    = &arg,
1260                         };
1261
1262                         if (perf_hpp__should_skip(fmt, entry->hists) ||
1263                             column++ < browser->b.horiz_scroll)
1264                                 continue;
1265
1266                         if (current_entry && browser->b.navkeypressed) {
1267                                 ui_browser__set_color(&browser->b,
1268                                                       HE_COLORSET_SELECTED);
1269                         } else {
1270                                 ui_browser__set_color(&browser->b,
1271                                                       HE_COLORSET_NORMAL);
1272                         }
1273
1274                         if (first) {
1275                                 if (symbol_conf.use_callchain) {
1276                                         ui_browser__printf(&browser->b, "%c ", folded_sign);
1277                                         width -= 2;
1278                                 }
1279                                 first = false;
1280                         } else {
1281                                 ui_browser__printf(&browser->b, "  ");
1282                                 width -= 2;
1283                         }
1284
1285                         if (fmt->color) {
1286                                 int ret = fmt->color(fmt, &hpp, entry);
1287                                 hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
1288                                 /*
1289                                  * fmt->color() already used ui_browser to
1290                                  * print the non alignment bits, skip it (+ret):
1291                                  */
1292                                 ui_browser__printf(&browser->b, "%s", s + ret);
1293                         } else {
1294                                 hist_entry__snprintf_alignment(entry, &hpp, fmt, fmt->entry(fmt, &hpp, entry));
1295                                 ui_browser__printf(&browser->b, "%s", s);
1296                         }
1297                         width -= hpp.buf - s;
1298                 }
1299
1300                 /* The scroll bar isn't being used */
1301                 if (!browser->b.navkeypressed)
1302                         width += 1;
1303
1304                 ui_browser__write_nstring(&browser->b, "", width);
1305
1306                 ++row;
1307                 ++printed;
1308         } else
1309                 --row_offset;
1310
1311         if (folded_sign == '-' && row != browser->b.rows) {
1312                 struct callchain_print_arg arg = {
1313                         .row_offset = row_offset,
1314                         .is_current_entry = current_entry,
1315                 };
1316
1317                 printed += hist_browser__show_callchain(browser,
1318                                 entry, 1, row,
1319                                 hist_browser__show_callchain_entry,
1320                                 &arg,
1321                                 hist_browser__check_output_full);
1322         }
1323
1324         return printed;
1325 }
1326
1327 static int hist_browser__show_hierarchy_entry(struct hist_browser *browser,
1328                                               struct hist_entry *entry,
1329                                               unsigned short row,
1330                                               int level)
1331 {
1332         int printed = 0;
1333         int width = browser->b.width;
1334         char folded_sign = ' ';
1335         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
1336         off_t row_offset = entry->row_offset;
1337         bool first = true;
1338         struct perf_hpp_fmt *fmt;
1339         struct perf_hpp_list_node *fmt_node;
1340         struct hpp_arg arg = {
1341                 .b              = &browser->b,
1342                 .current_entry  = current_entry,
1343         };
1344         int column = 0;
1345         int hierarchy_indent = (entry->hists->nr_hpp_node - 2) * HIERARCHY_INDENT;
1346
1347         if (current_entry) {
1348                 browser->he_selection = entry;
1349                 browser->selection = &entry->ms;
1350         }
1351
1352         hist_entry__init_have_children(entry);
1353         folded_sign = hist_entry__folded(entry);
1354         arg.folded_sign = folded_sign;
1355
1356         if (entry->leaf && row_offset) {
1357                 row_offset--;
1358                 goto show_callchain;
1359         }
1360
1361         hist_browser__gotorc(browser, row, 0);
1362
1363         if (current_entry && browser->b.navkeypressed)
1364                 ui_browser__set_color(&browser->b, HE_COLORSET_SELECTED);
1365         else
1366                 ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
1367
1368         ui_browser__write_nstring(&browser->b, "", level * HIERARCHY_INDENT);
1369         width -= level * HIERARCHY_INDENT;
1370
1371         /* the first hpp_list_node is for overhead columns */
1372         fmt_node = list_first_entry(&entry->hists->hpp_formats,
1373                                     struct perf_hpp_list_node, list);
1374         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1375                 char s[2048];
1376                 struct perf_hpp hpp = {
1377                         .buf            = s,
1378                         .size           = sizeof(s),
1379                         .ptr            = &arg,
1380                 };
1381
1382                 if (perf_hpp__should_skip(fmt, entry->hists) ||
1383                     column++ < browser->b.horiz_scroll)
1384                         continue;
1385
1386                 if (current_entry && browser->b.navkeypressed) {
1387                         ui_browser__set_color(&browser->b,
1388                                               HE_COLORSET_SELECTED);
1389                 } else {
1390                         ui_browser__set_color(&browser->b,
1391                                               HE_COLORSET_NORMAL);
1392                 }
1393
1394                 if (first) {
1395                         ui_browser__printf(&browser->b, "%c ", folded_sign);
1396                         width -= 2;
1397                         first = false;
1398                 } else {
1399                         ui_browser__printf(&browser->b, "  ");
1400                         width -= 2;
1401                 }
1402
1403                 if (fmt->color) {
1404                         int ret = fmt->color(fmt, &hpp, entry);
1405                         hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
1406                         /*
1407                          * fmt->color() already used ui_browser to
1408                          * print the non alignment bits, skip it (+ret):
1409                          */
1410                         ui_browser__printf(&browser->b, "%s", s + ret);
1411                 } else {
1412                         int ret = fmt->entry(fmt, &hpp, entry);
1413                         hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
1414                         ui_browser__printf(&browser->b, "%s", s);
1415                 }
1416                 width -= hpp.buf - s;
1417         }
1418
1419         if (!first) {
1420                 ui_browser__write_nstring(&browser->b, "", hierarchy_indent);
1421                 width -= hierarchy_indent;
1422         }
1423
1424         if (column >= browser->b.horiz_scroll) {
1425                 char s[2048];
1426                 struct perf_hpp hpp = {
1427                         .buf            = s,
1428                         .size           = sizeof(s),
1429                         .ptr            = &arg,
1430                 };
1431
1432                 if (current_entry && browser->b.navkeypressed) {
1433                         ui_browser__set_color(&browser->b,
1434                                               HE_COLORSET_SELECTED);
1435                 } else {
1436                         ui_browser__set_color(&browser->b,
1437                                               HE_COLORSET_NORMAL);
1438                 }
1439
1440                 perf_hpp_list__for_each_format(entry->hpp_list, fmt) {
1441                         if (first) {
1442                                 ui_browser__printf(&browser->b, "%c ", folded_sign);
1443                                 first = false;
1444                         } else {
1445                                 ui_browser__write_nstring(&browser->b, "", 2);
1446                         }
1447
1448                         width -= 2;
1449
1450                         /*
1451                          * No need to call hist_entry__snprintf_alignment()
1452                          * since this fmt is always the last column in the
1453                          * hierarchy mode.
1454                          */
1455                         if (fmt->color) {
1456                                 width -= fmt->color(fmt, &hpp, entry);
1457                         } else {
1458                                 int i = 0;
1459
1460                                 width -= fmt->entry(fmt, &hpp, entry);
1461                                 ui_browser__printf(&browser->b, "%s", ltrim(s));
1462
1463                                 while (isspace(s[i++]))
1464                                         width++;
1465                         }
1466                 }
1467         }
1468
1469         /* The scroll bar isn't being used */
1470         if (!browser->b.navkeypressed)
1471                 width += 1;
1472
1473         ui_browser__write_nstring(&browser->b, "", width);
1474
1475         ++row;
1476         ++printed;
1477
1478 show_callchain:
1479         if (entry->leaf && folded_sign == '-' && row != browser->b.rows) {
1480                 struct callchain_print_arg carg = {
1481                         .row_offset = row_offset,
1482                 };
1483
1484                 printed += hist_browser__show_callchain(browser, entry,
1485                                         level + 1, row,
1486                                         hist_browser__show_callchain_entry, &carg,
1487                                         hist_browser__check_output_full);
1488         }
1489
1490         return printed;
1491 }
1492
1493 static int hist_browser__show_no_entry(struct hist_browser *browser,
1494                                        unsigned short row, int level)
1495 {
1496         int width = browser->b.width;
1497         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
1498         bool first = true;
1499         int column = 0;
1500         int ret;
1501         struct perf_hpp_fmt *fmt;
1502         struct perf_hpp_list_node *fmt_node;
1503         int indent = browser->hists->nr_hpp_node - 2;
1504
1505         if (current_entry) {
1506                 browser->he_selection = NULL;
1507                 browser->selection = NULL;
1508         }
1509
1510         hist_browser__gotorc(browser, row, 0);
1511
1512         if (current_entry && browser->b.navkeypressed)
1513                 ui_browser__set_color(&browser->b, HE_COLORSET_SELECTED);
1514         else
1515                 ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
1516
1517         ui_browser__write_nstring(&browser->b, "", level * HIERARCHY_INDENT);
1518         width -= level * HIERARCHY_INDENT;
1519
1520         /* the first hpp_list_node is for overhead columns */
1521         fmt_node = list_first_entry(&browser->hists->hpp_formats,
1522                                     struct perf_hpp_list_node, list);
1523         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1524                 if (perf_hpp__should_skip(fmt, browser->hists) ||
1525                     column++ < browser->b.horiz_scroll)
1526                         continue;
1527
1528                 ret = fmt->width(fmt, NULL, browser->hists);
1529
1530                 if (first) {
1531                         /* for folded sign */
1532                         first = false;
1533                         ret++;
1534                 } else {
1535                         /* space between columns */
1536                         ret += 2;
1537                 }
1538
1539                 ui_browser__write_nstring(&browser->b, "", ret);
1540                 width -= ret;
1541         }
1542
1543         ui_browser__write_nstring(&browser->b, "", indent * HIERARCHY_INDENT);
1544         width -= indent * HIERARCHY_INDENT;
1545
1546         if (column >= browser->b.horiz_scroll) {
1547                 char buf[32];
1548
1549                 ret = snprintf(buf, sizeof(buf), "no entry >= %.2f%%", browser->min_pcnt);
1550                 ui_browser__printf(&browser->b, "  %s", buf);
1551                 width -= ret + 2;
1552         }
1553
1554         /* The scroll bar isn't being used */
1555         if (!browser->b.navkeypressed)
1556                 width += 1;
1557
1558         ui_browser__write_nstring(&browser->b, "", width);
1559         return 1;
1560 }
1561
1562 static int advance_hpp_check(struct perf_hpp *hpp, int inc)
1563 {
1564         advance_hpp(hpp, inc);
1565         return hpp->size <= 0;
1566 }
1567
1568 static int
1569 hists_browser__scnprintf_headers(struct hist_browser *browser, char *buf,
1570                                  size_t size, int line)
1571 {
1572         struct hists *hists = browser->hists;
1573         struct perf_hpp dummy_hpp = {
1574                 .buf    = buf,
1575                 .size   = size,
1576         };
1577         struct perf_hpp_fmt *fmt;
1578         size_t ret = 0;
1579         int column = 0;
1580         int span = 0;
1581
1582         if (symbol_conf.use_callchain) {
1583                 ret = scnprintf(buf, size, "  ");
1584                 if (advance_hpp_check(&dummy_hpp, ret))
1585                         return ret;
1586         }
1587
1588         hists__for_each_format(browser->hists, fmt) {
1589                 if (perf_hpp__should_skip(fmt, hists)  || column++ < browser->b.horiz_scroll)
1590                         continue;
1591
1592                 ret = fmt->header(fmt, &dummy_hpp, hists, line, &span);
1593                 if (advance_hpp_check(&dummy_hpp, ret))
1594                         break;
1595
1596                 if (span)
1597                         continue;
1598
1599                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
1600                 if (advance_hpp_check(&dummy_hpp, ret))
1601                         break;
1602         }
1603
1604         return ret;
1605 }
1606
1607 static int hists_browser__scnprintf_hierarchy_headers(struct hist_browser *browser, char *buf, size_t size)
1608 {
1609         struct hists *hists = browser->hists;
1610         struct perf_hpp dummy_hpp = {
1611                 .buf    = buf,
1612                 .size   = size,
1613         };
1614         struct perf_hpp_fmt *fmt;
1615         struct perf_hpp_list_node *fmt_node;
1616         size_t ret = 0;
1617         int column = 0;
1618         int indent = hists->nr_hpp_node - 2;
1619         bool first_node, first_col;
1620
1621         ret = scnprintf(buf, size, "  ");
1622         if (advance_hpp_check(&dummy_hpp, ret))
1623                 return ret;
1624
1625         first_node = true;
1626         /* the first hpp_list_node is for overhead columns */
1627         fmt_node = list_first_entry(&hists->hpp_formats,
1628                                     struct perf_hpp_list_node, list);
1629         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1630                 if (column++ < browser->b.horiz_scroll)
1631                         continue;
1632
1633                 ret = fmt->header(fmt, &dummy_hpp, hists, 0, NULL);
1634                 if (advance_hpp_check(&dummy_hpp, ret))
1635                         break;
1636
1637                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
1638                 if (advance_hpp_check(&dummy_hpp, ret))
1639                         break;
1640
1641                 first_node = false;
1642         }
1643
1644         if (!first_node) {
1645                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "%*s",
1646                                 indent * HIERARCHY_INDENT, "");
1647                 if (advance_hpp_check(&dummy_hpp, ret))
1648                         return ret;
1649         }
1650
1651         first_node = true;
1652         list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
1653                 if (!first_node) {
1654                         ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, " / ");
1655                         if (advance_hpp_check(&dummy_hpp, ret))
1656                                 break;
1657                 }
1658                 first_node = false;
1659
1660                 first_col = true;
1661                 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1662                         char *start;
1663
1664                         if (perf_hpp__should_skip(fmt, hists))
1665                                 continue;
1666
1667                         if (!first_col) {
1668                                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "+");
1669                                 if (advance_hpp_check(&dummy_hpp, ret))
1670                                         break;
1671                         }
1672                         first_col = false;
1673
1674                         ret = fmt->header(fmt, &dummy_hpp, hists, 0, NULL);
1675                         dummy_hpp.buf[ret] = '\0';
1676
1677                         start = trim(dummy_hpp.buf);
1678                         ret = strlen(start);
1679
1680                         if (start != dummy_hpp.buf)
1681                                 memmove(dummy_hpp.buf, start, ret + 1);
1682
1683                         if (advance_hpp_check(&dummy_hpp, ret))
1684                                 break;
1685                 }
1686         }
1687
1688         return ret;
1689 }
1690
1691 static void hists_browser__hierarchy_headers(struct hist_browser *browser)
1692 {
1693         char headers[1024];
1694
1695         hists_browser__scnprintf_hierarchy_headers(browser, headers,
1696                                                    sizeof(headers));
1697
1698         ui_browser__gotorc(&browser->b, 0, 0);
1699         ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
1700         ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
1701 }
1702
1703 static void hists_browser__headers(struct hist_browser *browser)
1704 {
1705         struct hists *hists = browser->hists;
1706         struct perf_hpp_list *hpp_list = hists->hpp_list;
1707
1708         int line;
1709
1710         for (line = 0; line < hpp_list->nr_header_lines; line++) {
1711                 char headers[1024];
1712
1713                 hists_browser__scnprintf_headers(browser, headers,
1714                                                  sizeof(headers), line);
1715
1716                 ui_browser__gotorc(&browser->b, line, 0);
1717                 ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
1718                 ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
1719         }
1720 }
1721
1722 static void hist_browser__show_headers(struct hist_browser *browser)
1723 {
1724         if (symbol_conf.report_hierarchy)
1725                 hists_browser__hierarchy_headers(browser);
1726         else
1727                 hists_browser__headers(browser);
1728 }
1729
1730 static void ui_browser__hists_init_top(struct ui_browser *browser)
1731 {
1732         if (browser->top == NULL) {
1733                 struct hist_browser *hb;
1734
1735                 hb = container_of(browser, struct hist_browser, b);
1736                 browser->top = rb_first(&hb->hists->entries);
1737         }
1738 }
1739
1740 static unsigned int hist_browser__refresh(struct ui_browser *browser)
1741 {
1742         unsigned row = 0;
1743         u16 header_offset = 0;
1744         struct rb_node *nd;
1745         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
1746         struct hists *hists = hb->hists;
1747
1748         if (hb->show_headers) {
1749                 struct perf_hpp_list *hpp_list = hists->hpp_list;
1750
1751                 hist_browser__show_headers(hb);
1752                 header_offset = hpp_list->nr_header_lines;
1753         }
1754
1755         ui_browser__hists_init_top(browser);
1756         hb->he_selection = NULL;
1757         hb->selection = NULL;
1758
1759         for (nd = browser->top; nd; nd = rb_hierarchy_next(nd)) {
1760                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1761                 float percent;
1762
1763                 if (h->filtered) {
1764                         /* let it move to sibling */
1765                         h->unfolded = false;
1766                         continue;
1767                 }
1768
1769                 percent = hist_entry__get_percent_limit(h);
1770                 if (percent < hb->min_pcnt)
1771                         continue;
1772
1773                 if (symbol_conf.report_hierarchy) {
1774                         row += hist_browser__show_hierarchy_entry(hb, h, row,
1775                                                                   h->depth);
1776                         if (row == browser->rows)
1777                                 break;
1778
1779                         if (h->has_no_entry) {
1780                                 hist_browser__show_no_entry(hb, row, h->depth + 1);
1781                                 row++;
1782                         }
1783                 } else {
1784                         row += hist_browser__show_entry(hb, h, row);
1785                 }
1786
1787                 if (row == browser->rows)
1788                         break;
1789         }
1790
1791         return row + header_offset;
1792 }
1793
1794 static struct rb_node *hists__filter_entries(struct rb_node *nd,
1795                                              float min_pcnt)
1796 {
1797         while (nd != NULL) {
1798                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1799                 float percent = hist_entry__get_percent_limit(h);
1800
1801                 if (!h->filtered && percent >= min_pcnt)
1802                         return nd;
1803
1804                 /*
1805                  * If it's filtered, its all children also were filtered.
1806                  * So move to sibling node.
1807                  */
1808                 if (rb_next(nd))
1809                         nd = rb_next(nd);
1810                 else
1811                         nd = rb_hierarchy_next(nd);
1812         }
1813
1814         return NULL;
1815 }
1816
1817 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
1818                                                   float min_pcnt)
1819 {
1820         while (nd != NULL) {
1821                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1822                 float percent = hist_entry__get_percent_limit(h);
1823
1824                 if (!h->filtered && percent >= min_pcnt)
1825                         return nd;
1826
1827                 nd = rb_hierarchy_prev(nd);
1828         }
1829
1830         return NULL;
1831 }
1832
1833 static void ui_browser__hists_seek(struct ui_browser *browser,
1834                                    off_t offset, int whence)
1835 {
1836         struct hist_entry *h;
1837         struct rb_node *nd;
1838         bool first = true;
1839         struct hist_browser *hb;
1840
1841         hb = container_of(browser, struct hist_browser, b);
1842
1843         if (browser->nr_entries == 0)
1844                 return;
1845
1846         ui_browser__hists_init_top(browser);
1847
1848         switch (whence) {
1849         case SEEK_SET:
1850                 nd = hists__filter_entries(rb_first(browser->entries),
1851                                            hb->min_pcnt);
1852                 break;
1853         case SEEK_CUR:
1854                 nd = browser->top;
1855                 goto do_offset;
1856         case SEEK_END:
1857                 nd = rb_hierarchy_last(rb_last(browser->entries));
1858                 nd = hists__filter_prev_entries(nd, hb->min_pcnt);
1859                 first = false;
1860                 break;
1861         default:
1862                 return;
1863         }
1864
1865         /*
1866          * Moves not relative to the first visible entry invalidates its
1867          * row_offset:
1868          */
1869         h = rb_entry(browser->top, struct hist_entry, rb_node);
1870         h->row_offset = 0;
1871
1872         /*
1873          * Here we have to check if nd is expanded (+), if it is we can't go
1874          * the next top level hist_entry, instead we must compute an offset of
1875          * what _not_ to show and not change the first visible entry.
1876          *
1877          * This offset increments when we are going from top to bottom and
1878          * decreases when we're going from bottom to top.
1879          *
1880          * As we don't have backpointers to the top level in the callchains
1881          * structure, we need to always print the whole hist_entry callchain,
1882          * skipping the first ones that are before the first visible entry
1883          * and stop when we printed enough lines to fill the screen.
1884          */
1885 do_offset:
1886         if (!nd)
1887                 return;
1888
1889         if (offset > 0) {
1890                 do {
1891                         h = rb_entry(nd, struct hist_entry, rb_node);
1892                         if (h->unfolded && h->leaf) {
1893                                 u16 remaining = h->nr_rows - h->row_offset;
1894                                 if (offset > remaining) {
1895                                         offset -= remaining;
1896                                         h->row_offset = 0;
1897                                 } else {
1898                                         h->row_offset += offset;
1899                                         offset = 0;
1900                                         browser->top = nd;
1901                                         break;
1902                                 }
1903                         }
1904                         nd = hists__filter_entries(rb_hierarchy_next(nd),
1905                                                    hb->min_pcnt);
1906                         if (nd == NULL)
1907                                 break;
1908                         --offset;
1909                         browser->top = nd;
1910                 } while (offset != 0);
1911         } else if (offset < 0) {
1912                 while (1) {
1913                         h = rb_entry(nd, struct hist_entry, rb_node);
1914                         if (h->unfolded && h->leaf) {
1915                                 if (first) {
1916                                         if (-offset > h->row_offset) {
1917                                                 offset += h->row_offset;
1918                                                 h->row_offset = 0;
1919                                         } else {
1920                                                 h->row_offset += offset;
1921                                                 offset = 0;
1922                                                 browser->top = nd;
1923                                                 break;
1924                                         }
1925                                 } else {
1926                                         if (-offset > h->nr_rows) {
1927                                                 offset += h->nr_rows;
1928                                                 h->row_offset = 0;
1929                                         } else {
1930                                                 h->row_offset = h->nr_rows + offset;
1931                                                 offset = 0;
1932                                                 browser->top = nd;
1933                                                 break;
1934                                         }
1935                                 }
1936                         }
1937
1938                         nd = hists__filter_prev_entries(rb_hierarchy_prev(nd),
1939                                                         hb->min_pcnt);
1940                         if (nd == NULL)
1941                                 break;
1942                         ++offset;
1943                         browser->top = nd;
1944                         if (offset == 0) {
1945                                 /*
1946                                  * Last unfiltered hist_entry, check if it is
1947                                  * unfolded, if it is then we should have
1948                                  * row_offset at its last entry.
1949                                  */
1950                                 h = rb_entry(nd, struct hist_entry, rb_node);
1951                                 if (h->unfolded && h->leaf)
1952                                         h->row_offset = h->nr_rows;
1953                                 break;
1954                         }
1955                         first = false;
1956                 }
1957         } else {
1958                 browser->top = nd;
1959                 h = rb_entry(nd, struct hist_entry, rb_node);
1960                 h->row_offset = 0;
1961         }
1962 }
1963
1964 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
1965                                            struct hist_entry *he, FILE *fp,
1966                                            int level)
1967 {
1968         struct callchain_print_arg arg  = {
1969                 .fp = fp,
1970         };
1971
1972         hist_browser__show_callchain(browser, he, level, 0,
1973                                      hist_browser__fprintf_callchain_entry, &arg,
1974                                      hist_browser__check_dump_full);
1975         return arg.printed;
1976 }
1977
1978 static int hist_browser__fprintf_entry(struct hist_browser *browser,
1979                                        struct hist_entry *he, FILE *fp)
1980 {
1981         char s[8192];
1982         int printed = 0;
1983         char folded_sign = ' ';
1984         struct perf_hpp hpp = {
1985                 .buf = s,
1986                 .size = sizeof(s),
1987         };
1988         struct perf_hpp_fmt *fmt;
1989         bool first = true;
1990         int ret;
1991
1992         if (symbol_conf.use_callchain) {
1993                 folded_sign = hist_entry__folded(he);
1994                 printed += fprintf(fp, "%c ", folded_sign);
1995         }
1996
1997         hists__for_each_format(browser->hists, fmt) {
1998                 if (perf_hpp__should_skip(fmt, he->hists))
1999                         continue;
2000
2001                 if (!first) {
2002                         ret = scnprintf(hpp.buf, hpp.size, "  ");
2003                         advance_hpp(&hpp, ret);
2004                 } else
2005                         first = false;
2006
2007                 ret = fmt->entry(fmt, &hpp, he);
2008                 ret = hist_entry__snprintf_alignment(he, &hpp, fmt, ret);
2009                 advance_hpp(&hpp, ret);
2010         }
2011         printed += fprintf(fp, "%s\n", s);
2012
2013         if (folded_sign == '-')
2014                 printed += hist_browser__fprintf_callchain(browser, he, fp, 1);
2015
2016         return printed;
2017 }
2018
2019
2020 static int hist_browser__fprintf_hierarchy_entry(struct hist_browser *browser,
2021                                                  struct hist_entry *he,
2022                                                  FILE *fp, int level)
2023 {
2024         char s[8192];
2025         int printed = 0;
2026         char folded_sign = ' ';
2027         struct perf_hpp hpp = {
2028                 .buf = s,
2029                 .size = sizeof(s),
2030         };
2031         struct perf_hpp_fmt *fmt;
2032         struct perf_hpp_list_node *fmt_node;
2033         bool first = true;
2034         int ret;
2035         int hierarchy_indent = (he->hists->nr_hpp_node - 2) * HIERARCHY_INDENT;
2036
2037         printed = fprintf(fp, "%*s", level * HIERARCHY_INDENT, "");
2038
2039         folded_sign = hist_entry__folded(he);
2040         printed += fprintf(fp, "%c", folded_sign);
2041
2042         /* the first hpp_list_node is for overhead columns */
2043         fmt_node = list_first_entry(&he->hists->hpp_formats,
2044                                     struct perf_hpp_list_node, list);
2045         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
2046                 if (!first) {
2047                         ret = scnprintf(hpp.buf, hpp.size, "  ");
2048                         advance_hpp(&hpp, ret);
2049                 } else
2050                         first = false;
2051
2052                 ret = fmt->entry(fmt, &hpp, he);
2053                 advance_hpp(&hpp, ret);
2054         }
2055
2056         ret = scnprintf(hpp.buf, hpp.size, "%*s", hierarchy_indent, "");
2057         advance_hpp(&hpp, ret);
2058
2059         perf_hpp_list__for_each_format(he->hpp_list, fmt) {
2060                 ret = scnprintf(hpp.buf, hpp.size, "  ");
2061                 advance_hpp(&hpp, ret);
2062
2063                 ret = fmt->entry(fmt, &hpp, he);
2064                 advance_hpp(&hpp, ret);
2065         }
2066
2067         printed += fprintf(fp, "%s\n", rtrim(s));
2068
2069         if (he->leaf && folded_sign == '-') {
2070                 printed += hist_browser__fprintf_callchain(browser, he, fp,
2071                                                            he->depth + 1);
2072         }
2073
2074         return printed;
2075 }
2076
2077 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
2078 {
2079         struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
2080                                                    browser->min_pcnt);
2081         int printed = 0;
2082
2083         while (nd) {
2084                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
2085
2086                 if (symbol_conf.report_hierarchy) {
2087                         printed += hist_browser__fprintf_hierarchy_entry(browser,
2088                                                                          h, fp,
2089                                                                          h->depth);
2090                 } else {
2091                         printed += hist_browser__fprintf_entry(browser, h, fp);
2092                 }
2093
2094                 nd = hists__filter_entries(rb_hierarchy_next(nd),
2095                                            browser->min_pcnt);
2096         }
2097
2098         return printed;
2099 }
2100
2101 static int hist_browser__dump(struct hist_browser *browser)
2102 {
2103         char filename[64];
2104         FILE *fp;
2105
2106         while (1) {
2107                 scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
2108                 if (access(filename, F_OK))
2109                         break;
2110                 /*
2111                  * XXX: Just an arbitrary lazy upper limit
2112                  */
2113                 if (++browser->print_seq == 8192) {
2114                         ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
2115                         return -1;
2116                 }
2117         }
2118
2119         fp = fopen(filename, "w");
2120         if (fp == NULL) {
2121                 char bf[64];
2122                 const char *err = str_error_r(errno, bf, sizeof(bf));
2123                 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
2124                 return -1;
2125         }
2126
2127         ++browser->print_seq;
2128         hist_browser__fprintf(browser, fp);
2129         fclose(fp);
2130         ui_helpline__fpush("%s written!", filename);
2131
2132         return 0;
2133 }
2134
2135 void hist_browser__init(struct hist_browser *browser,
2136                         struct hists *hists)
2137 {
2138         struct perf_hpp_fmt *fmt;
2139
2140         browser->hists                  = hists;
2141         browser->b.refresh              = hist_browser__refresh;
2142         browser->b.refresh_dimensions   = hist_browser__refresh_dimensions;
2143         browser->b.seek                 = ui_browser__hists_seek;
2144         browser->b.use_navkeypressed    = true;
2145         browser->show_headers           = symbol_conf.show_hist_headers;
2146
2147         if (symbol_conf.report_hierarchy) {
2148                 struct perf_hpp_list_node *fmt_node;
2149
2150                 /* count overhead columns (in the first node) */
2151                 fmt_node = list_first_entry(&hists->hpp_formats,
2152                                             struct perf_hpp_list_node, list);
2153                 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt)
2154                         ++browser->b.columns;
2155
2156                 /* add a single column for whole hierarchy sort keys*/
2157                 ++browser->b.columns;
2158         } else {
2159                 hists__for_each_format(hists, fmt)
2160                         ++browser->b.columns;
2161         }
2162
2163         hists__reset_column_width(hists);
2164 }
2165
2166 struct hist_browser *hist_browser__new(struct hists *hists)
2167 {
2168         struct hist_browser *browser = zalloc(sizeof(*browser));
2169
2170         if (browser)
2171                 hist_browser__init(browser, hists);
2172
2173         return browser;
2174 }
2175
2176 static struct hist_browser *
2177 perf_evsel_browser__new(struct perf_evsel *evsel,
2178                         struct hist_browser_timer *hbt,
2179                         struct perf_env *env)
2180 {
2181         struct hist_browser *browser = hist_browser__new(evsel__hists(evsel));
2182
2183         if (browser) {
2184                 browser->hbt   = hbt;
2185                 browser->env   = env;
2186                 browser->title = perf_evsel_browser_title;
2187         }
2188         return browser;
2189 }
2190
2191 void hist_browser__delete(struct hist_browser *browser)
2192 {
2193         free(browser);
2194 }
2195
2196 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
2197 {
2198         return browser->he_selection;
2199 }
2200
2201 static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
2202 {
2203         return browser->he_selection->thread;
2204 }
2205
2206 /* Check whether the browser is for 'top' or 'report' */
2207 static inline bool is_report_browser(void *timer)
2208 {
2209         return timer == NULL;
2210 }
2211
2212 static int perf_evsel_browser_title(struct hist_browser *browser,
2213                                 char *bf, size_t size)
2214 {
2215         struct hist_browser_timer *hbt = browser->hbt;
2216         struct hists *hists = browser->hists;
2217         char unit;
2218         int printed;
2219         const struct dso *dso = hists->dso_filter;
2220         const struct thread *thread = hists->thread_filter;
2221         int socket_id = hists->socket_filter;
2222         unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
2223         u64 nr_events = hists->stats.total_period;
2224         struct perf_evsel *evsel = hists_to_evsel(hists);
2225         const char *ev_name = perf_evsel__name(evsel);
2226         char buf[512];
2227         size_t buflen = sizeof(buf);
2228         char ref[30] = " show reference callgraph, ";
2229         bool enable_ref = false;
2230
2231         if (symbol_conf.filter_relative) {
2232                 nr_samples = hists->stats.nr_non_filtered_samples;
2233                 nr_events = hists->stats.total_non_filtered_period;
2234         }
2235
2236         if (perf_evsel__is_group_event(evsel)) {
2237                 struct perf_evsel *pos;
2238
2239                 perf_evsel__group_desc(evsel, buf, buflen);
2240                 ev_name = buf;
2241
2242                 for_each_group_member(pos, evsel) {
2243                         struct hists *pos_hists = evsel__hists(pos);
2244
2245                         if (symbol_conf.filter_relative) {
2246                                 nr_samples += pos_hists->stats.nr_non_filtered_samples;
2247                                 nr_events += pos_hists->stats.total_non_filtered_period;
2248                         } else {
2249                                 nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
2250                                 nr_events += pos_hists->stats.total_period;
2251                         }
2252                 }
2253         }
2254
2255         if (symbol_conf.show_ref_callgraph &&
2256             strstr(ev_name, "call-graph=no"))
2257                 enable_ref = true;
2258         nr_samples = convert_unit(nr_samples, &unit);
2259         printed = scnprintf(bf, size,
2260                            "Samples: %lu%c of event '%s',%sEvent count (approx.): %" PRIu64,
2261                            nr_samples, unit, ev_name, enable_ref ? ref : " ", nr_events);
2262
2263
2264         if (hists->uid_filter_str)
2265                 printed += snprintf(bf + printed, size - printed,
2266                                     ", UID: %s", hists->uid_filter_str);
2267         if (thread) {
2268                 if (hists__has(hists, thread)) {
2269                         printed += scnprintf(bf + printed, size - printed,
2270                                     ", Thread: %s(%d)",
2271                                      (thread->comm_set ? thread__comm_str(thread) : ""),
2272                                     thread->tid);
2273                 } else {
2274                         printed += scnprintf(bf + printed, size - printed,
2275                                     ", Thread: %s",
2276                                      (thread->comm_set ? thread__comm_str(thread) : ""));
2277                 }
2278         }
2279         if (dso)
2280                 printed += scnprintf(bf + printed, size - printed,
2281                                     ", DSO: %s", dso->short_name);
2282         if (socket_id > -1)
2283                 printed += scnprintf(bf + printed, size - printed,
2284                                     ", Processor Socket: %d", socket_id);
2285         if (!is_report_browser(hbt)) {
2286                 struct perf_top *top = hbt->arg;
2287
2288                 if (top->zero)
2289                         printed += scnprintf(bf + printed, size - printed, " [z]");
2290         }
2291
2292         return printed;
2293 }
2294
2295 static inline void free_popup_options(char **options, int n)
2296 {
2297         int i;
2298
2299         for (i = 0; i < n; ++i)
2300                 zfree(&options[i]);
2301 }
2302
2303 /*
2304  * Only runtime switching of perf data file will make "input_name" point
2305  * to a malloced buffer. So add "is_input_name_malloced" flag to decide
2306  * whether we need to call free() for current "input_name" during the switch.
2307  */
2308 static bool is_input_name_malloced = false;
2309
2310 static int switch_data_file(void)
2311 {
2312         char *pwd, *options[32], *abs_path[32], *tmp;
2313         DIR *pwd_dir;
2314         int nr_options = 0, choice = -1, ret = -1;
2315         struct dirent *dent;
2316
2317         pwd = getenv("PWD");
2318         if (!pwd)
2319                 return ret;
2320
2321         pwd_dir = opendir(pwd);
2322         if (!pwd_dir)
2323                 return ret;
2324
2325         memset(options, 0, sizeof(options));
2326         memset(abs_path, 0, sizeof(abs_path));
2327
2328         while ((dent = readdir(pwd_dir))) {
2329                 char path[PATH_MAX];
2330                 u64 magic;
2331                 char *name = dent->d_name;
2332                 FILE *file;
2333
2334                 if (!(dent->d_type == DT_REG))
2335                         continue;
2336
2337                 snprintf(path, sizeof(path), "%s/%s", pwd, name);
2338
2339                 file = fopen(path, "r");
2340                 if (!file)
2341                         continue;
2342
2343                 if (fread(&magic, 1, 8, file) < 8)
2344                         goto close_file_and_continue;
2345
2346                 if (is_perf_magic(magic)) {
2347                         options[nr_options] = strdup(name);
2348                         if (!options[nr_options])
2349                                 goto close_file_and_continue;
2350
2351                         abs_path[nr_options] = strdup(path);
2352                         if (!abs_path[nr_options]) {
2353                                 zfree(&options[nr_options]);
2354                                 ui__warning("Can't search all data files due to memory shortage.\n");
2355                                 fclose(file);
2356                                 break;
2357                         }
2358
2359                         nr_options++;
2360                 }
2361
2362 close_file_and_continue:
2363                 fclose(file);
2364                 if (nr_options >= 32) {
2365                         ui__warning("Too many perf data files in PWD!\n"
2366                                     "Only the first 32 files will be listed.\n");
2367                         break;
2368                 }
2369         }
2370         closedir(pwd_dir);
2371
2372         if (nr_options) {
2373                 choice = ui__popup_menu(nr_options, options);
2374                 if (choice < nr_options && choice >= 0) {
2375                         tmp = strdup(abs_path[choice]);
2376                         if (tmp) {
2377                                 if (is_input_name_malloced)
2378                                         free((void *)input_name);
2379                                 input_name = tmp;
2380                                 is_input_name_malloced = true;
2381                                 ret = 0;
2382                         } else
2383                                 ui__warning("Data switch failed due to memory shortage!\n");
2384                 }
2385         }
2386
2387         free_popup_options(options, nr_options);
2388         free_popup_options(abs_path, nr_options);
2389         return ret;
2390 }
2391
2392 struct popup_action {
2393         struct thread           *thread;
2394         struct map_symbol       ms;
2395         int                     socket;
2396
2397         int (*fn)(struct hist_browser *browser, struct popup_action *act);
2398 };
2399
2400 static int
2401 do_annotate(struct hist_browser *browser, struct popup_action *act)
2402 {
2403         struct perf_evsel *evsel;
2404         struct annotation *notes;
2405         struct hist_entry *he;
2406         int err;
2407
2408         if (!objdump_path && perf_env__lookup_objdump(browser->env))
2409                 return 0;
2410
2411         notes = symbol__annotation(act->ms.sym);
2412         if (!notes->src)
2413                 return 0;
2414
2415         evsel = hists_to_evsel(browser->hists);
2416         err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt);
2417         he = hist_browser__selected_entry(browser);
2418         /*
2419          * offer option to annotate the other branch source or target
2420          * (if they exists) when returning from annotate
2421          */
2422         if ((err == 'q' || err == CTRL('c')) && he->branch_info)
2423                 return 1;
2424
2425         ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
2426         if (err)
2427                 ui_browser__handle_resize(&browser->b);
2428         return 0;
2429 }
2430
2431 static int
2432 add_annotate_opt(struct hist_browser *browser __maybe_unused,
2433                  struct popup_action *act, char **optstr,
2434                  struct map *map, struct symbol *sym)
2435 {
2436         if (sym == NULL || map->dso->annotate_warned)
2437                 return 0;
2438
2439         if (asprintf(optstr, "Annotate %s", sym->name) < 0)
2440                 return 0;
2441
2442         act->ms.map = map;
2443         act->ms.sym = sym;
2444         act->fn = do_annotate;
2445         return 1;
2446 }
2447
2448 static int
2449 do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
2450 {
2451         struct thread *thread = act->thread;
2452
2453         if ((!hists__has(browser->hists, thread) &&
2454              !hists__has(browser->hists, comm)) || thread == NULL)
2455                 return 0;
2456
2457         if (browser->hists->thread_filter) {
2458                 pstack__remove(browser->pstack, &browser->hists->thread_filter);
2459                 perf_hpp__set_elide(HISTC_THREAD, false);
2460                 thread__zput(browser->hists->thread_filter);
2461                 ui_helpline__pop();
2462         } else {
2463                 if (hists__has(browser->hists, thread)) {
2464                         ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s(%d) thread\"",
2465                                            thread->comm_set ? thread__comm_str(thread) : "",
2466                                            thread->tid);
2467                 } else {
2468                         ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s thread\"",
2469                                            thread->comm_set ? thread__comm_str(thread) : "");
2470                 }
2471
2472                 browser->hists->thread_filter = thread__get(thread);
2473                 perf_hpp__set_elide(HISTC_THREAD, false);
2474                 pstack__push(browser->pstack, &browser->hists->thread_filter);
2475         }
2476
2477         hists__filter_by_thread(browser->hists);
2478         hist_browser__reset(browser);
2479         return 0;
2480 }
2481
2482 static int
2483 add_thread_opt(struct hist_browser *browser, struct popup_action *act,
2484                char **optstr, struct thread *thread)
2485 {
2486         int ret;
2487
2488         if ((!hists__has(browser->hists, thread) &&
2489              !hists__has(browser->hists, comm)) || thread == NULL)
2490                 return 0;
2491
2492         if (hists__has(browser->hists, thread)) {
2493                 ret = asprintf(optstr, "Zoom %s %s(%d) thread",
2494                                browser->hists->thread_filter ? "out of" : "into",
2495                                thread->comm_set ? thread__comm_str(thread) : "",
2496                                thread->tid);
2497         } else {
2498                 ret = asprintf(optstr, "Zoom %s %s thread",
2499                                browser->hists->thread_filter ? "out of" : "into",
2500                                thread->comm_set ? thread__comm_str(thread) : "");
2501         }
2502         if (ret < 0)
2503                 return 0;
2504
2505         act->thread = thread;
2506         act->fn = do_zoom_thread;
2507         return 1;
2508 }
2509
2510 static int
2511 do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
2512 {
2513         struct map *map = act->ms.map;
2514
2515         if (!hists__has(browser->hists, dso) || map == NULL)
2516                 return 0;
2517
2518         if (browser->hists->dso_filter) {
2519                 pstack__remove(browser->pstack, &browser->hists->dso_filter);
2520                 perf_hpp__set_elide(HISTC_DSO, false);
2521                 browser->hists->dso_filter = NULL;
2522                 ui_helpline__pop();
2523         } else {
2524                 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s DSO\"",
2525                                    __map__is_kernel(map) ? "the Kernel" : map->dso->short_name);
2526                 browser->hists->dso_filter = map->dso;
2527                 perf_hpp__set_elide(HISTC_DSO, true);
2528                 pstack__push(browser->pstack, &browser->hists->dso_filter);
2529         }
2530
2531         hists__filter_by_dso(browser->hists);
2532         hist_browser__reset(browser);
2533         return 0;
2534 }
2535
2536 static int
2537 add_dso_opt(struct hist_browser *browser, struct popup_action *act,
2538             char **optstr, struct map *map)
2539 {
2540         if (!hists__has(browser->hists, dso) || map == NULL)
2541                 return 0;
2542
2543         if (asprintf(optstr, "Zoom %s %s DSO",
2544                      browser->hists->dso_filter ? "out of" : "into",
2545                      __map__is_kernel(map) ? "the Kernel" : map->dso->short_name) < 0)
2546                 return 0;
2547
2548         act->ms.map = map;
2549         act->fn = do_zoom_dso;
2550         return 1;
2551 }
2552
2553 static int
2554 do_browse_map(struct hist_browser *browser __maybe_unused,
2555               struct popup_action *act)
2556 {
2557         map__browse(act->ms.map);
2558         return 0;
2559 }
2560
2561 static int
2562 add_map_opt(struct hist_browser *browser,
2563             struct popup_action *act, char **optstr, struct map *map)
2564 {
2565         if (!hists__has(browser->hists, dso) || map == NULL)
2566                 return 0;
2567
2568         if (asprintf(optstr, "Browse map details") < 0)
2569                 return 0;
2570
2571         act->ms.map = map;
2572         act->fn = do_browse_map;
2573         return 1;
2574 }
2575
2576 static int
2577 do_run_script(struct hist_browser *browser __maybe_unused,
2578               struct popup_action *act)
2579 {
2580         char script_opt[64];
2581         memset(script_opt, 0, sizeof(script_opt));
2582
2583         if (act->thread) {
2584                 scnprintf(script_opt, sizeof(script_opt), " -c %s ",
2585                           thread__comm_str(act->thread));
2586         } else if (act->ms.sym) {
2587                 scnprintf(script_opt, sizeof(script_opt), " -S %s ",
2588                           act->ms.sym->name);
2589         }
2590
2591         script_browse(script_opt);
2592         return 0;
2593 }
2594
2595 static int
2596 add_script_opt(struct hist_browser *browser __maybe_unused,
2597                struct popup_action *act, char **optstr,
2598                struct thread *thread, struct symbol *sym)
2599 {
2600         if (thread) {
2601                 if (asprintf(optstr, "Run scripts for samples of thread [%s]",
2602                              thread__comm_str(thread)) < 0)
2603                         return 0;
2604         } else if (sym) {
2605                 if (asprintf(optstr, "Run scripts for samples of symbol [%s]",
2606                              sym->name) < 0)
2607                         return 0;
2608         } else {
2609                 if (asprintf(optstr, "Run scripts for all samples") < 0)
2610                         return 0;
2611         }
2612
2613         act->thread = thread;
2614         act->ms.sym = sym;
2615         act->fn = do_run_script;
2616         return 1;
2617 }
2618
2619 static int
2620 do_switch_data(struct hist_browser *browser __maybe_unused,
2621                struct popup_action *act __maybe_unused)
2622 {
2623         if (switch_data_file()) {
2624                 ui__warning("Won't switch the data files due to\n"
2625                             "no valid data file get selected!\n");
2626                 return 0;
2627         }
2628
2629         return K_SWITCH_INPUT_DATA;
2630 }
2631
2632 static int
2633 add_switch_opt(struct hist_browser *browser,
2634                struct popup_action *act, char **optstr)
2635 {
2636         if (!is_report_browser(browser->hbt))
2637                 return 0;
2638
2639         if (asprintf(optstr, "Switch to another data file in PWD") < 0)
2640                 return 0;
2641
2642         act->fn = do_switch_data;
2643         return 1;
2644 }
2645
2646 static int
2647 do_exit_browser(struct hist_browser *browser __maybe_unused,
2648                 struct popup_action *act __maybe_unused)
2649 {
2650         return 0;
2651 }
2652
2653 static int
2654 add_exit_opt(struct hist_browser *browser __maybe_unused,
2655              struct popup_action *act, char **optstr)
2656 {
2657         if (asprintf(optstr, "Exit") < 0)
2658                 return 0;
2659
2660         act->fn = do_exit_browser;
2661         return 1;
2662 }
2663
2664 static int
2665 do_zoom_socket(struct hist_browser *browser, struct popup_action *act)
2666 {
2667         if (!hists__has(browser->hists, socket) || act->socket < 0)
2668                 return 0;
2669
2670         if (browser->hists->socket_filter > -1) {
2671                 pstack__remove(browser->pstack, &browser->hists->socket_filter);
2672                 browser->hists->socket_filter = -1;
2673                 perf_hpp__set_elide(HISTC_SOCKET, false);
2674         } else {
2675                 browser->hists->socket_filter = act->socket;
2676                 perf_hpp__set_elide(HISTC_SOCKET, true);
2677                 pstack__push(browser->pstack, &browser->hists->socket_filter);
2678         }
2679
2680         hists__filter_by_socket(browser->hists);
2681         hist_browser__reset(browser);
2682         return 0;
2683 }
2684
2685 static int
2686 add_socket_opt(struct hist_browser *browser, struct popup_action *act,
2687                char **optstr, int socket_id)
2688 {
2689         if (!hists__has(browser->hists, socket) || socket_id < 0)
2690                 return 0;
2691
2692         if (asprintf(optstr, "Zoom %s Processor Socket %d",
2693                      (browser->hists->socket_filter > -1) ? "out of" : "into",
2694                      socket_id) < 0)
2695                 return 0;
2696
2697         act->socket = socket_id;
2698         act->fn = do_zoom_socket;
2699         return 1;
2700 }
2701
2702 static void hist_browser__update_nr_entries(struct hist_browser *hb)
2703 {
2704         u64 nr_entries = 0;
2705         struct rb_node *nd = rb_first(&hb->hists->entries);
2706
2707         if (hb->min_pcnt == 0 && !symbol_conf.report_hierarchy) {
2708                 hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;
2709                 return;
2710         }
2711
2712         while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
2713                 nr_entries++;
2714                 nd = rb_hierarchy_next(nd);
2715         }
2716
2717         hb->nr_non_filtered_entries = nr_entries;
2718         hb->nr_hierarchy_entries = nr_entries;
2719 }
2720
2721 static void hist_browser__update_percent_limit(struct hist_browser *hb,
2722                                                double percent)
2723 {
2724         struct hist_entry *he;
2725         struct rb_node *nd = rb_first(&hb->hists->entries);
2726         u64 total = hists__total_period(hb->hists);
2727         u64 min_callchain_hits = total * (percent / 100);
2728
2729         hb->min_pcnt = callchain_param.min_percent = percent;
2730
2731         while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
2732                 he = rb_entry(nd, struct hist_entry, rb_node);
2733
2734                 if (he->has_no_entry) {
2735                         he->has_no_entry = false;
2736                         he->nr_rows = 0;
2737                 }
2738
2739                 if (!he->leaf || !symbol_conf.use_callchain)
2740                         goto next;
2741
2742                 if (callchain_param.mode == CHAIN_GRAPH_REL) {
2743                         total = he->stat.period;
2744
2745                         if (symbol_conf.cumulate_callchain)
2746                                 total = he->stat_acc->period;
2747
2748                         min_callchain_hits = total * (percent / 100);
2749                 }
2750
2751                 callchain_param.sort(&he->sorted_chain, he->callchain,
2752                                      min_callchain_hits, &callchain_param);
2753
2754 next:
2755                 nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
2756
2757                 /* force to re-evaluate folding state of callchains */
2758                 he->init_have_children = false;
2759                 hist_entry__set_folding(he, hb, false);
2760         }
2761 }
2762
2763 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
2764                                     const char *helpline,
2765                                     bool left_exits,
2766                                     struct hist_browser_timer *hbt,
2767                                     float min_pcnt,
2768                                     struct perf_env *env,
2769                                     bool warn_lost_event)
2770 {
2771         struct hists *hists = evsel__hists(evsel);
2772         struct hist_browser *browser = perf_evsel_browser__new(evsel, hbt, env);
2773         struct branch_info *bi;
2774 #define MAX_OPTIONS  16
2775         char *options[MAX_OPTIONS];
2776         struct popup_action actions[MAX_OPTIONS];
2777         int nr_options = 0;
2778         int key = -1;
2779         char buf[64];
2780         int delay_secs = hbt ? hbt->refresh : 0;
2781
2782 #define HIST_BROWSER_HELP_COMMON                                        \
2783         "h/?/F1        Show this window\n"                              \
2784         "UP/DOWN/PGUP\n"                                                \
2785         "PGDN/SPACE    Navigate\n"                                      \
2786         "q/ESC/CTRL+C  Exit browser\n\n"                                \
2787         "For multiple event sessions:\n\n"                              \
2788         "TAB/UNTAB     Switch events\n\n"                               \
2789         "For symbolic views (--sort has sym):\n\n"                      \
2790         "ENTER         Zoom into DSO/Threads & Annotate current symbol\n" \
2791         "ESC           Zoom out\n"                                      \
2792         "a             Annotate current symbol\n"                       \
2793         "C             Collapse all callchains\n"                       \
2794         "d             Zoom into current DSO\n"                         \
2795         "E             Expand all callchains\n"                         \
2796         "F             Toggle percentage of filtered entries\n"         \
2797         "H             Display column headers\n"                        \
2798         "L             Change percent limit\n"                          \
2799         "m             Display context menu\n"                          \
2800         "S             Zoom into current Processor Socket\n"            \
2801
2802         /* help messages are sorted by lexical order of the hotkey */
2803         const char report_help[] = HIST_BROWSER_HELP_COMMON
2804         "i             Show header information\n"
2805         "P             Print histograms to perf.hist.N\n"
2806         "r             Run available scripts\n"
2807         "s             Switch to another data file in PWD\n"
2808         "t             Zoom into current Thread\n"
2809         "V             Verbose (DSO names in callchains, etc)\n"
2810         "/             Filter symbol by name";
2811         const char top_help[] = HIST_BROWSER_HELP_COMMON
2812         "P             Print histograms to perf.hist.N\n"
2813         "t             Zoom into current Thread\n"
2814         "V             Verbose (DSO names in callchains, etc)\n"
2815         "z             Toggle zeroing of samples\n"
2816         "f             Enable/Disable events\n"
2817         "/             Filter symbol by name";
2818
2819         if (browser == NULL)
2820                 return -1;
2821
2822         /* reset abort key so that it can get Ctrl-C as a key */
2823         SLang_reset_tty();
2824         SLang_init_tty(0, 0, 0);
2825
2826         if (min_pcnt)
2827                 browser->min_pcnt = min_pcnt;
2828         hist_browser__update_nr_entries(browser);
2829
2830         browser->pstack = pstack__new(3);
2831         if (browser->pstack == NULL)
2832                 goto out;
2833
2834         ui_helpline__push(helpline);
2835
2836         memset(options, 0, sizeof(options));
2837         memset(actions, 0, sizeof(actions));
2838
2839         if (symbol_conf.col_width_list_str)
2840                 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
2841
2842         while (1) {
2843                 struct thread *thread = NULL;
2844                 struct map *map = NULL;
2845                 int choice = 0;
2846                 int socked_id = -1;
2847
2848                 nr_options = 0;
2849
2850                 key = hist_browser__run(browser, helpline,
2851                                         warn_lost_event);
2852
2853                 if (browser->he_selection != NULL) {
2854                         thread = hist_browser__selected_thread(browser);
2855                         map = browser->selection->map;
2856                         socked_id = browser->he_selection->socket;
2857                 }
2858                 switch (key) {
2859                 case K_TAB:
2860                 case K_UNTAB:
2861                         if (nr_events == 1)
2862                                 continue;
2863                         /*
2864                          * Exit the browser, let hists__browser_tree
2865                          * go to the next or previous
2866                          */
2867                         goto out_free_stack;
2868                 case 'a':
2869                         if (!hists__has(hists, sym)) {
2870                                 ui_browser__warning(&browser->b, delay_secs * 2,
2871                         "Annotation is only available for symbolic views, "
2872                         "include \"sym*\" in --sort to use it.");
2873                                 continue;
2874                         }
2875
2876                         if (browser->selection == NULL ||
2877                             browser->selection->sym == NULL ||
2878                             browser->selection->map->dso->annotate_warned)
2879                                 continue;
2880
2881                         actions->ms.map = browser->selection->map;
2882                         actions->ms.sym = browser->selection->sym;
2883                         do_annotate(browser, actions);
2884                         continue;
2885                 case 'P':
2886                         hist_browser__dump(browser);
2887                         continue;
2888                 case 'd':
2889                         actions->ms.map = map;
2890                         do_zoom_dso(browser, actions);
2891                         continue;
2892                 case 'V':
2893                         verbose = (verbose + 1) % 4;
2894                         browser->show_dso = verbose > 0;
2895                         ui_helpline__fpush("Verbosity level set to %d\n",
2896                                            verbose);
2897                         continue;
2898                 case 't':
2899                         actions->thread = thread;
2900                         do_zoom_thread(browser, actions);
2901                         continue;
2902                 case 'S':
2903                         actions->socket = socked_id;
2904                         do_zoom_socket(browser, actions);
2905                         continue;
2906                 case '/':
2907                         if (ui_browser__input_window("Symbol to show",
2908                                         "Please enter the name of symbol you want to see.\n"
2909                                         "To remove the filter later, press / + ENTER.",
2910                                         buf, "ENTER: OK, ESC: Cancel",
2911                                         delay_secs * 2) == K_ENTER) {
2912                                 hists->symbol_filter_str = *buf ? buf : NULL;
2913                                 hists__filter_by_symbol(hists);
2914                                 hist_browser__reset(browser);
2915                         }
2916                         continue;
2917                 case 'r':
2918                         if (is_report_browser(hbt)) {
2919                                 actions->thread = NULL;
2920                                 actions->ms.sym = NULL;
2921                                 do_run_script(browser, actions);
2922                         }
2923                         continue;
2924                 case 's':
2925                         if (is_report_browser(hbt)) {
2926                                 key = do_switch_data(browser, actions);
2927                                 if (key == K_SWITCH_INPUT_DATA)
2928                                         goto out_free_stack;
2929                         }
2930                         continue;
2931                 case 'i':
2932                         /* env->arch is NULL for live-mode (i.e. perf top) */
2933                         if (env->arch)
2934                                 tui__header_window(env);
2935                         continue;
2936                 case 'F':
2937                         symbol_conf.filter_relative ^= 1;
2938                         continue;
2939                 case 'z':
2940                         if (!is_report_browser(hbt)) {
2941                                 struct perf_top *top = hbt->arg;
2942
2943                                 top->zero = !top->zero;
2944                         }
2945                         continue;
2946                 case 'L':
2947                         if (ui_browser__input_window("Percent Limit",
2948                                         "Please enter the value you want to hide entries under that percent.",
2949                                         buf, "ENTER: OK, ESC: Cancel",
2950                                         delay_secs * 2) == K_ENTER) {
2951                                 char *end;
2952                                 double new_percent = strtod(buf, &end);
2953
2954                                 if (new_percent < 0 || new_percent > 100) {
2955                                         ui_browser__warning(&browser->b, delay_secs * 2,
2956                                                 "Invalid percent: %.2f", new_percent);
2957                                         continue;
2958                                 }
2959
2960                                 hist_browser__update_percent_limit(browser, new_percent);
2961                                 hist_browser__reset(browser);
2962                         }
2963                         continue;
2964                 case K_F1:
2965                 case 'h':
2966                 case '?':
2967                         ui_browser__help_window(&browser->b,
2968                                 is_report_browser(hbt) ? report_help : top_help);
2969                         continue;
2970                 case K_ENTER:
2971                 case K_RIGHT:
2972                 case 'm':
2973                         /* menu */
2974                         break;
2975                 case K_ESC:
2976                 case K_LEFT: {
2977                         const void *top;
2978
2979                         if (pstack__empty(browser->pstack)) {
2980                                 /*
2981                                  * Go back to the perf_evsel_menu__run or other user
2982                                  */
2983                                 if (left_exits)
2984                                         goto out_free_stack;
2985
2986                                 if (key == K_ESC &&
2987                                     ui_browser__dialog_yesno(&browser->b,
2988                                                              "Do you really want to exit?"))
2989                                         goto out_free_stack;
2990
2991                                 continue;
2992                         }
2993                         top = pstack__peek(browser->pstack);
2994                         if (top == &browser->hists->dso_filter) {
2995                                 /*
2996                                  * No need to set actions->dso here since
2997                                  * it's just to remove the current filter.
2998                                  * Ditto for thread below.
2999                                  */
3000                                 do_zoom_dso(browser, actions);
3001                         } else if (top == &browser->hists->thread_filter) {
3002                                 do_zoom_thread(browser, actions);
3003                         } else if (top == &browser->hists->socket_filter) {
3004                                 do_zoom_socket(browser, actions);
3005                         }
3006                         continue;
3007                 }
3008                 case 'q':
3009                 case CTRL('c'):
3010                         goto out_free_stack;
3011                 case 'f':
3012                         if (!is_report_browser(hbt)) {
3013                                 struct perf_top *top = hbt->arg;
3014
3015                                 perf_evlist__toggle_enable(top->evlist);
3016                                 /*
3017                                  * No need to refresh, resort/decay histogram
3018                                  * entries if we are not collecting samples:
3019                                  */
3020                                 if (top->evlist->enabled) {
3021                                         helpline = "Press 'f' to disable the events or 'h' to see other hotkeys";
3022                                         hbt->refresh = delay_secs;
3023                                 } else {
3024                                         helpline = "Press 'f' again to re-enable the events";
3025                                         hbt->refresh = 0;
3026                                 }
3027                                 continue;
3028                         }
3029                         /* Fall thru */
3030                 default:
3031                         helpline = "Press '?' for help on key bindings";
3032                         continue;
3033                 }
3034
3035                 if (!hists__has(hists, sym) || browser->selection == NULL)
3036                         goto skip_annotation;
3037
3038                 if (sort__mode == SORT_MODE__BRANCH) {
3039                         bi = browser->he_selection->branch_info;
3040
3041                         if (bi == NULL)
3042                                 goto skip_annotation;
3043
3044                         nr_options += add_annotate_opt(browser,
3045                                                        &actions[nr_options],
3046                                                        &options[nr_options],
3047                                                        bi->from.map,
3048                                                        bi->from.sym);
3049                         if (bi->to.sym != bi->from.sym)
3050                                 nr_options += add_annotate_opt(browser,
3051                                                         &actions[nr_options],
3052                                                         &options[nr_options],
3053                                                         bi->to.map,
3054                                                         bi->to.sym);
3055                 } else {
3056                         nr_options += add_annotate_opt(browser,
3057                                                        &actions[nr_options],
3058                                                        &options[nr_options],
3059                                                        browser->selection->map,
3060                                                        browser->selection->sym);
3061                 }
3062 skip_annotation:
3063                 nr_options += add_thread_opt(browser, &actions[nr_options],
3064                                              &options[nr_options], thread);
3065                 nr_options += add_dso_opt(browser, &actions[nr_options],
3066                                           &options[nr_options], map);
3067                 nr_options += add_map_opt(browser, &actions[nr_options],
3068                                           &options[nr_options],
3069                                           browser->selection ?
3070                                                 browser->selection->map : NULL);
3071                 nr_options += add_socket_opt(browser, &actions[nr_options],
3072                                              &options[nr_options],
3073                                              socked_id);
3074                 /* perf script support */
3075                 if (!is_report_browser(hbt))
3076                         goto skip_scripting;
3077
3078                 if (browser->he_selection) {
3079                         if (hists__has(hists, thread) && thread) {
3080                                 nr_options += add_script_opt(browser,
3081                                                              &actions[nr_options],
3082                                                              &options[nr_options],
3083                                                              thread, NULL);
3084                         }
3085                         /*
3086                          * Note that browser->selection != NULL
3087                          * when browser->he_selection is not NULL,
3088                          * so we don't need to check browser->selection
3089                          * before fetching browser->selection->sym like what
3090                          * we do before fetching browser->selection->map.
3091                          *
3092                          * See hist_browser__show_entry.
3093                          */
3094                         if (hists__has(hists, sym) && browser->selection->sym) {
3095                                 nr_options += add_script_opt(browser,
3096                                                              &actions[nr_options],
3097                                                              &options[nr_options],
3098                                                              NULL, browser->selection->sym);
3099                         }
3100                 }
3101                 nr_options += add_script_opt(browser, &actions[nr_options],
3102                                              &options[nr_options], NULL, NULL);
3103                 nr_options += add_switch_opt(browser, &actions[nr_options],
3104                                              &options[nr_options]);
3105 skip_scripting:
3106                 nr_options += add_exit_opt(browser, &actions[nr_options],
3107                                            &options[nr_options]);
3108
3109                 do {
3110                         struct popup_action *act;
3111
3112                         choice = ui__popup_menu(nr_options, options);
3113                         if (choice == -1 || choice >= nr_options)
3114                                 break;
3115
3116                         act = &actions[choice];
3117                         key = act->fn(browser, act);
3118                 } while (key == 1);
3119
3120                 if (key == K_SWITCH_INPUT_DATA)
3121                         break;
3122         }
3123 out_free_stack:
3124         pstack__delete(browser->pstack);
3125 out:
3126         hist_browser__delete(browser);
3127         free_popup_options(options, MAX_OPTIONS);
3128         return key;
3129 }
3130
3131 struct perf_evsel_menu {
3132         struct ui_browser b;
3133         struct perf_evsel *selection;
3134         bool lost_events, lost_events_warned;
3135         float min_pcnt;
3136         struct perf_env *env;
3137 };
3138
3139 static void perf_evsel_menu__write(struct ui_browser *browser,
3140                                    void *entry, int row)
3141 {
3142         struct perf_evsel_menu *menu = container_of(browser,
3143                                                     struct perf_evsel_menu, b);
3144         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
3145         struct hists *hists = evsel__hists(evsel);
3146         bool current_entry = ui_browser__is_current_entry(browser, row);
3147         unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
3148         const char *ev_name = perf_evsel__name(evsel);
3149         char bf[256], unit;
3150         const char *warn = " ";
3151         size_t printed;
3152
3153         ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
3154                                                        HE_COLORSET_NORMAL);
3155
3156         if (perf_evsel__is_group_event(evsel)) {
3157                 struct perf_evsel *pos;
3158
3159                 ev_name = perf_evsel__group_name(evsel);
3160
3161                 for_each_group_member(pos, evsel) {
3162                         struct hists *pos_hists = evsel__hists(pos);
3163                         nr_events += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
3164                 }
3165         }
3166
3167         nr_events = convert_unit(nr_events, &unit);
3168         printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
3169                            unit, unit == ' ' ? "" : " ", ev_name);
3170         ui_browser__printf(browser, "%s", bf);
3171
3172         nr_events = hists->stats.nr_events[PERF_RECORD_LOST];
3173         if (nr_events != 0) {
3174                 menu->lost_events = true;
3175                 if (!current_entry)
3176                         ui_browser__set_color(browser, HE_COLORSET_TOP);
3177                 nr_events = convert_unit(nr_events, &unit);
3178                 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
3179                                      nr_events, unit, unit == ' ' ? "" : " ");
3180                 warn = bf;
3181         }
3182
3183         ui_browser__write_nstring(browser, warn, browser->width - printed);
3184
3185         if (current_entry)
3186                 menu->selection = evsel;
3187 }
3188
3189 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
3190                                 int nr_events, const char *help,
3191                                 struct hist_browser_timer *hbt,
3192                                 bool warn_lost_event)
3193 {
3194         struct perf_evlist *evlist = menu->b.priv;
3195         struct perf_evsel *pos;
3196         const char *title = "Available samples";
3197         int delay_secs = hbt ? hbt->refresh : 0;
3198         int key;
3199
3200         if (ui_browser__show(&menu->b, title,
3201                              "ESC: exit, ENTER|->: Browse histograms") < 0)
3202                 return -1;
3203
3204         while (1) {
3205                 key = ui_browser__run(&menu->b, delay_secs);
3206
3207                 switch (key) {
3208                 case K_TIMER:
3209                         hbt->timer(hbt->arg);
3210
3211                         if (!menu->lost_events_warned &&
3212                             menu->lost_events &&
3213                             warn_lost_event) {
3214                                 ui_browser__warn_lost_events(&menu->b);
3215                                 menu->lost_events_warned = true;
3216                         }
3217                         continue;
3218                 case K_RIGHT:
3219                 case K_ENTER:
3220                         if (!menu->selection)
3221                                 continue;
3222                         pos = menu->selection;
3223 browse_hists:
3224                         perf_evlist__set_selected(evlist, pos);
3225                         /*
3226                          * Give the calling tool a chance to populate the non
3227                          * default evsel resorted hists tree.
3228                          */
3229                         if (hbt)
3230                                 hbt->timer(hbt->arg);
3231                         key = perf_evsel__hists_browse(pos, nr_events, help,
3232                                                        true, hbt,
3233                                                        menu->min_pcnt,
3234                                                        menu->env,
3235                                                        warn_lost_event);
3236                         ui_browser__show_title(&menu->b, title);
3237                         switch (key) {
3238                         case K_TAB:
3239                                 if (pos->node.next == &evlist->entries)
3240                                         pos = perf_evlist__first(evlist);
3241                                 else
3242                                         pos = perf_evsel__next(pos);
3243                                 goto browse_hists;
3244                         case K_UNTAB:
3245                                 if (pos->node.prev == &evlist->entries)
3246                                         pos = perf_evlist__last(evlist);
3247                                 else
3248                                         pos = perf_evsel__prev(pos);
3249                                 goto browse_hists;
3250                         case K_SWITCH_INPUT_DATA:
3251                         case 'q':
3252                         case CTRL('c'):
3253                                 goto out;
3254                         case K_ESC:
3255                         default:
3256                                 continue;
3257                         }
3258                 case K_LEFT:
3259                         continue;
3260                 case K_ESC:
3261                         if (!ui_browser__dialog_yesno(&menu->b,
3262                                                "Do you really want to exit?"))
3263                                 continue;
3264                         /* Fall thru */
3265                 case 'q':
3266                 case CTRL('c'):
3267                         goto out;
3268                 default:
3269                         continue;
3270                 }
3271         }
3272
3273 out:
3274         ui_browser__hide(&menu->b);
3275         return key;
3276 }
3277
3278 static bool filter_group_entries(struct ui_browser *browser __maybe_unused,
3279                                  void *entry)
3280 {
3281         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
3282
3283         if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
3284                 return true;
3285
3286         return false;
3287 }
3288
3289 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
3290                                            int nr_entries, const char *help,
3291                                            struct hist_browser_timer *hbt,
3292                                            float min_pcnt,
3293                                            struct perf_env *env,
3294                                            bool warn_lost_event)
3295 {
3296         struct perf_evsel *pos;
3297         struct perf_evsel_menu menu = {
3298                 .b = {
3299                         .entries    = &evlist->entries,
3300                         .refresh    = ui_browser__list_head_refresh,
3301                         .seek       = ui_browser__list_head_seek,
3302                         .write      = perf_evsel_menu__write,
3303                         .filter     = filter_group_entries,
3304                         .nr_entries = nr_entries,
3305                         .priv       = evlist,
3306                 },
3307                 .min_pcnt = min_pcnt,
3308                 .env = env,
3309         };
3310
3311         ui_helpline__push("Press ESC to exit");
3312
3313         evlist__for_each_entry(evlist, pos) {
3314                 const char *ev_name = perf_evsel__name(pos);
3315                 size_t line_len = strlen(ev_name) + 7;
3316
3317                 if (menu.b.width < line_len)
3318                         menu.b.width = line_len;
3319         }
3320
3321         return perf_evsel_menu__run(&menu, nr_entries, help,
3322                                     hbt, warn_lost_event);
3323 }
3324
3325 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
3326                                   struct hist_browser_timer *hbt,
3327                                   float min_pcnt,
3328                                   struct perf_env *env,
3329                                   bool warn_lost_event)
3330 {
3331         int nr_entries = evlist->nr_entries;
3332
3333 single_entry:
3334         if (nr_entries == 1) {
3335                 struct perf_evsel *first = perf_evlist__first(evlist);
3336
3337                 return perf_evsel__hists_browse(first, nr_entries, help,
3338                                                 false, hbt, min_pcnt,
3339                                                 env, warn_lost_event);
3340         }
3341
3342         if (symbol_conf.event_group) {
3343                 struct perf_evsel *pos;
3344
3345                 nr_entries = 0;
3346                 evlist__for_each_entry(evlist, pos) {
3347                         if (perf_evsel__is_group_leader(pos))
3348                                 nr_entries++;
3349                 }
3350
3351                 if (nr_entries == 1)
3352                         goto single_entry;
3353         }
3354
3355         return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
3356                                                hbt, min_pcnt, env,
3357                                                warn_lost_event);
3358 }