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