tools/perf/ui/browsers/hists.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <linux/rbtree.h>
   5
   6 #include "../../util/evsel.h"
   7 #include "../../util/evlist.h"
   8 #include "../../util/hist.h"
   9 #include "../../util/pstack.h"
  10 #include "../../util/sort.h"
  11 #include "../../util/util.h"
  12 #include "../../util/top.h"
  13 #include "../../arch/common.h"
  14
  15 #include "../browser.h"
  16 #include "../helpline.h"
  17 #include "../util.h"
  18 #include "../ui.h"
  19 #include "map.h"
  20 #include "annotate.h"
  21
  22 struct hist_browser {
  23         struct ui_browser   b;
  24         struct hists        *hists;
  25         struct hist_entry   *he_selection;
  26         struct map_symbol   *selection;
  27         struct hist_browser_timer *hbt;
  28         struct pstack       *pstack;
  29         struct perf_env *env;
  30         int                  print_seq;
  31         bool                 show_dso;
  32         bool                 show_headers;
  33         float                min_pcnt;
  34         u64                  nr_non_filtered_entries;
  35         u64                  nr_callchain_rows;
  36 };
  37
  38 extern void hist_browser__init_hpp(void);
  39
  40 static int hists__browser_title(struct hists *hists,
  41                                 struct hist_browser_timer *hbt,
  42                                 char *bf, size_t size);
  43 static void hist_browser__update_nr_entries(struct hist_browser *hb);
  44
  45 static struct rb_node *hists__filter_entries(struct rb_node *nd,
  46                                              float min_pcnt);
  47
  48 static bool hist_browser__has_filter(struct hist_browser *hb)
  49 {
  50         return hists__has_filter(hb->hists) || hb->min_pcnt || symbol_conf.has_filter;
  51 }
  52
  53 static int hist_browser__get_folding(struct hist_browser *browser)
  54 {
  55         struct rb_node *nd;
  56         struct hists *hists = browser->hists;
  57         int unfolded_rows = 0;
  58
  59         for (nd = rb_first(&hists->entries);
  60              (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
  61              nd = rb_next(nd)) {
  62                 struct hist_entry *he =
  63                         rb_entry(nd, struct hist_entry, rb_node);
  64
  65                 if (he->unfolded)
  66                         unfolded_rows += he->nr_rows;
  67         }
  68         return unfolded_rows;
  69 }
  70
  71 static u32 hist_browser__nr_entries(struct hist_browser *hb)
  72 {
  73         u32 nr_entries;
  74
  75         if (hist_browser__has_filter(hb))
  76                 nr_entries = hb->nr_non_filtered_entries;
  77         else
  78                 nr_entries = hb->hists->nr_entries;
  79
  80         hb->nr_callchain_rows = hist_browser__get_folding(hb);
  81         return nr_entries + hb->nr_callchain_rows;
  82 }
  83
  84 static void hist_browser__update_rows(struct hist_browser *hb)
  85 {
  86         struct ui_browser *browser = &hb->b;
  87         u16 header_offset = hb->show_headers ? 1 : 0, index_row;
  88
  89         browser->rows = browser->height - header_offset;
  90         /*
  91          * Verify if we were at the last line and that line isn't
  92          * visibe because we now show the header line(s).
  93          */
  94         index_row = browser->index - browser->top_idx;
  95         if (index_row >= browser->rows)
  96                 browser->index -= index_row - browser->rows + 1;
  97 }
  98
  99 static void hist_browser__refresh_dimensions(struct ui_browser *browser)
 100 {
 101         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
 102
 103         /* 3 == +/- toggle symbol before actual hist_entry rendering */
 104         browser->width = 3 + (hists__sort_list_width(hb->hists) + sizeof("[k]"));
 105         /*
 106          * FIXME: Just keeping existing behaviour, but this really should be
 107          *        before updating browser->width, as it will invalidate the
 108          *        calculation above. Fix this and the fallout in another
 109          *        changeset.
 110          */
 111         ui_browser__refresh_dimensions(browser);
 112         hist_browser__update_rows(hb);
 113 }
 114
 115 static void hist_browser__gotorc(struct hist_browser *browser, int row, int column)
 116 {
 117         u16 header_offset = browser->show_headers ? 1 : 0;
 118
 119         ui_browser__gotorc(&browser->b, row + header_offset, column);
 120 }
 121
 122 static void hist_browser__reset(struct hist_browser *browser)
 123 {
 124         /*
 125          * The hists__remove_entry_filter() already folds non-filtered
 126          * entries so we can assume it has 0 callchain rows.
 127          */
 128         browser->nr_callchain_rows = 0;
 129
 130         hist_browser__update_nr_entries(browser);
 131         browser->b.nr_entries = hist_browser__nr_entries(browser);
 132         hist_browser__refresh_dimensions(&browser->b);
 133         ui_browser__reset_index(&browser->b);
 134 }
 135
 136 static char tree__folded_sign(bool unfolded)
 137 {
 138         return unfolded ? '-' : '+';
 139 }
 140
 141 static char hist_entry__folded(const struct hist_entry *he)
 142 {
 143         return he->has_children ? tree__folded_sign(he->unfolded) : ' ';
 144 }
 145
 146 static char callchain_list__folded(const struct callchain_list *cl)
 147 {
 148         return cl->has_children ? tree__folded_sign(cl->unfolded) : ' ';
 149 }
 150
 151 static void callchain_list__set_folding(struct callchain_list *cl, bool unfold)
 152 {
 153         cl->unfolded = unfold ? cl->has_children : false;
 154 }
 155
 156 static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
 157 {
 158         int n = 0;
 159         struct rb_node *nd;
 160
 161         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
 162                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 163                 struct callchain_list *chain;
 164                 char folded_sign = ' '; /* No children */
 165
 166                 list_for_each_entry(chain, &child->val, list) {
 167                         ++n;
 168                         /* We need this because we may not have children */
 169                         folded_sign = callchain_list__folded(chain);
 170                         if (folded_sign == '+')
 171                                 break;
 172                 }
 173
 174                 if (folded_sign == '-') /* Have children and they're unfolded */
 175                         n += callchain_node__count_rows_rb_tree(child);
 176         }
 177
 178         return n;
 179 }
 180
 181 static int callchain_node__count_rows(struct callchain_node *node)
 182 {
 183         struct callchain_list *chain;
 184         bool unfolded = false;
 185         int n = 0;
 186
 187         list_for_each_entry(chain, &node->val, list) {
 188                 ++n;
 189                 unfolded = chain->unfolded;
 190         }
 191
 192         if (unfolded)
 193                 n += callchain_node__count_rows_rb_tree(node);
 194
 195         return n;
 196 }
 197
 198 static int callchain__count_rows(struct rb_root *chain)
 199 {
 200         struct rb_node *nd;
 201         int n = 0;
 202
 203         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 204                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 205                 n += callchain_node__count_rows(node);
 206         }
 207
 208         return n;
 209 }
 210
 211 static bool hist_entry__toggle_fold(struct hist_entry *he)
 212 {
 213         if (!he)
 214                 return false;
 215
 216         if (!he->has_children)
 217                 return false;
 218
 219         he->unfolded = !he->unfolded;
 220         return true;
 221 }
 222
 223 static bool callchain_list__toggle_fold(struct callchain_list *cl)
 224 {
 225         if (!cl)
 226                 return false;
 227
 228         if (!cl->has_children)
 229                 return false;
 230
 231         cl->unfolded = !cl->unfolded;
 232         return true;
 233 }
 234
 235 static void callchain_node__init_have_children_rb_tree(struct callchain_node *node)
 236 {
 237         struct rb_node *nd = rb_first(&node->rb_root);
 238
 239         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
 240                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 241                 struct callchain_list *chain;
 242                 bool first = true;
 243
 244                 list_for_each_entry(chain, &child->val, list) {
 245                         if (first) {
 246                                 first = false;
 247                                 chain->has_children = chain->list.next != &child->val ||
 248                                                          !RB_EMPTY_ROOT(&child->rb_root);
 249                         } else
 250                                 chain->has_children = chain->list.next == &child->val &&
 251                                                          !RB_EMPTY_ROOT(&child->rb_root);
 252                 }
 253
 254                 callchain_node__init_have_children_rb_tree(child);
 255         }
 256 }
 257
 258 static void callchain_node__init_have_children(struct callchain_node *node,
 259                                                bool has_sibling)
 260 {
 261         struct callchain_list *chain;
 262
 263         chain = list_entry(node->val.next, struct callchain_list, list);
 264         chain->has_children = has_sibling;
 265
 266         if (!list_empty(&node->val)) {
 267                 chain = list_entry(node->val.prev, struct callchain_list, list);
 268                 chain->has_children = !RB_EMPTY_ROOT(&node->rb_root);
 269         }
 270
 271         callchain_node__init_have_children_rb_tree(node);
 272 }
 273
 274 static void callchain__init_have_children(struct rb_root *root)
 275 {
 276         struct rb_node *nd = rb_first(root);
 277         bool has_sibling = nd && rb_next(nd);
 278
 279         for (nd = rb_first(root); nd; nd = rb_next(nd)) {
 280                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 281                 callchain_node__init_have_children(node, has_sibling);
 282         }
 283 }
 284
 285 static void hist_entry__init_have_children(struct hist_entry *he)
 286 {
 287         if (!he->init_have_children) {
 288                 he->has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
 289                 callchain__init_have_children(&he->sorted_chain);
 290                 he->init_have_children = true;
 291         }
 292 }
 293
 294 static bool hist_browser__toggle_fold(struct hist_browser *browser)
 295 {
 296         struct hist_entry *he = browser->he_selection;
 297         struct map_symbol *ms = browser->selection;
 298         struct callchain_list *cl = container_of(ms, struct callchain_list, ms);
 299         bool has_children;
 300
 301         if (ms == &he->ms)
 302                 has_children = hist_entry__toggle_fold(he);
 303         else
 304                 has_children = callchain_list__toggle_fold(cl);
 305
 306         if (has_children) {
 307                 hist_entry__init_have_children(he);
 308                 browser->b.nr_entries -= he->nr_rows;
 309                 browser->nr_callchain_rows -= he->nr_rows;
 310
 311                 if (he->unfolded)
 312                         he->nr_rows = callchain__count_rows(&he->sorted_chain);
 313                 else
 314                         he->nr_rows = 0;
 315
 316                 browser->b.nr_entries += he->nr_rows;
 317                 browser->nr_callchain_rows += he->nr_rows;
 318
 319                 return true;
 320         }
 321
 322         /* If it doesn't have children, no toggling performed */
 323         return false;
 324 }
 325
 326 static int callchain_node__set_folding_rb_tree(struct callchain_node *node, bool unfold)
 327 {
 328         int n = 0;
 329         struct rb_node *nd;
 330
 331         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
 332                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 333                 struct callchain_list *chain;
 334                 bool has_children = false;
 335
 336                 list_for_each_entry(chain, &child->val, list) {
 337                         ++n;
 338                         callchain_list__set_folding(chain, unfold);
 339                         has_children = chain->has_children;
 340                 }
 341
 342                 if (has_children)
 343                         n += callchain_node__set_folding_rb_tree(child, unfold);
 344         }
 345
 346         return n;
 347 }
 348
 349 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
 350 {
 351         struct callchain_list *chain;
 352         bool has_children = false;
 353         int n = 0;
 354
 355         list_for_each_entry(chain, &node->val, list) {
 356                 ++n;
 357                 callchain_list__set_folding(chain, unfold);
 358                 has_children = chain->has_children;
 359         }
 360
 361         if (has_children)
 362                 n += callchain_node__set_folding_rb_tree(node, unfold);
 363
 364         return n;
 365 }
 366
 367 static int callchain__set_folding(struct rb_root *chain, bool unfold)
 368 {
 369         struct rb_node *nd;
 370         int n = 0;
 371
 372         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 373                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 374                 n += callchain_node__set_folding(node, unfold);
 375         }
 376
 377         return n;
 378 }
 379
 380 static void hist_entry__set_folding(struct hist_entry *he, bool unfold)
 381 {
 382         hist_entry__init_have_children(he);
 383         he->unfolded = unfold ? he->has_children : false;
 384
 385         if (he->has_children) {
 386                 int n = callchain__set_folding(&he->sorted_chain, unfold);
 387                 he->nr_rows = unfold ? n : 0;
 388         } else
 389                 he->nr_rows = 0;
 390 }
 391
 392 static void
 393 __hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 394 {
 395         struct rb_node *nd;
 396         struct hists *hists = browser->hists;
 397
 398         for (nd = rb_first(&hists->entries);
 399              (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
 400              nd = rb_next(nd)) {
 401                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
 402                 hist_entry__set_folding(he, unfold);
 403                 browser->nr_callchain_rows += he->nr_rows;
 404         }
 405 }
 406
 407 static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 408 {
 409         browser->nr_callchain_rows = 0;
 410         __hist_browser__set_folding(browser, unfold);
 411
 412         browser->b.nr_entries = hist_browser__nr_entries(browser);
 413         /* Go to the start, we may be way after valid entries after a collapse */
 414         ui_browser__reset_index(&browser->b);
 415 }
 416
 417 static void ui_browser__warn_lost_events(struct ui_browser *browser)
 418 {
 419         ui_browser__warning(browser, 4,
 420                 "Events are being lost, check IO/CPU overload!\n\n"
 421                 "You may want to run 'perf' using a RT scheduler policy:\n\n"
 422                 " perf top -r 80\n\n"
 423                 "Or reduce the sampling frequency.");
 424 }
 425
 426 static int hist_browser__run(struct hist_browser *browser, const char *help)
 427 {
 428         int key;
 429         char title[160];
 430         struct hist_browser_timer *hbt = browser->hbt;
 431         int delay_secs = hbt ? hbt->refresh : 0;
 432
 433         browser->b.entries = &browser->hists->entries;
 434         browser->b.nr_entries = hist_browser__nr_entries(browser);
 435
 436         hists__browser_title(browser->hists, hbt, title, sizeof(title));
 437
 438         if (ui_browser__show(&browser->b, title, help) < 0)
 439                 return -1;
 440
 441         while (1) {
 442                 key = ui_browser__run(&browser->b, delay_secs);
 443
 444                 switch (key) {
 445                 case K_TIMER: {
 446                         u64 nr_entries;
 447                         hbt->timer(hbt->arg);
 448
 449                         if (hist_browser__has_filter(browser))
 450                                 hist_browser__update_nr_entries(browser);
 451
 452                         nr_entries = hist_browser__nr_entries(browser);
 453                         ui_browser__update_nr_entries(&browser->b, nr_entries);
 454
 455                         if (browser->hists->stats.nr_lost_warned !=
 456                             browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
 457                                 browser->hists->stats.nr_lost_warned =
 458                                         browser->hists->stats.nr_events[PERF_RECORD_LOST];
 459                                 ui_browser__warn_lost_events(&browser->b);
 460                         }
 461
 462                         hists__browser_title(browser->hists,
 463                                              hbt, title, sizeof(title));
 464                         ui_browser__show_title(&browser->b, title);
 465                         continue;
 466                 }
 467                 case 'D': { /* Debug */
 468                         static int seq;
 469                         struct hist_entry *h = rb_entry(browser->b.top,
 470                                                         struct hist_entry, rb_node);
 471                         ui_helpline__pop();
 472                         ui_helpline__fpush("%d: nr_ent=(%d,%d), rows=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
 473                                            seq++, browser->b.nr_entries,
 474                                            browser->hists->nr_entries,
 475                                            browser->b.rows,
 476                                            browser->b.index,
 477                                            browser->b.top_idx,
 478                                            h->row_offset, h->nr_rows);
 479                 }
 480                         break;
 481                 case 'C':
 482                         /* Collapse the whole world. */
 483                         hist_browser__set_folding(browser, false);
 484                         break;
 485                 case 'E':
 486                         /* Expand the whole world. */
 487                         hist_browser__set_folding(browser, true);
 488                         break;
 489                 case 'H':
 490                         browser->show_headers = !browser->show_headers;
 491                         hist_browser__update_rows(browser);
 492                         break;
 493                 case K_ENTER:
 494                         if (hist_browser__toggle_fold(browser))
 495                                 break;
 496                         /* fall thru */
 497                 default:
 498                         goto out;
 499                 }
 500         }
 501 out:
 502         ui_browser__hide(&browser->b);
 503         return key;
 504 }
 505
 506 struct callchain_print_arg {
 507         /* for hists browser */
 508         off_t   row_offset;
 509         bool    is_current_entry;
 510
 511         /* for file dump */
 512         FILE    *fp;
 513         int     printed;
 514 };
 515
 516 typedef void (*print_callchain_entry_fn)(struct hist_browser *browser,
 517                                          struct callchain_list *chain,
 518                                          const char *str, int offset,
 519                                          unsigned short row,
 520                                          struct callchain_print_arg *arg);
 521
 522 static void hist_browser__show_callchain_entry(struct hist_browser *browser,
 523                                                struct callchain_list *chain,
 524                                                const char *str, int offset,
 525                                                unsigned short row,
 526                                                struct callchain_print_arg *arg)
 527 {
 528         int color, width;
 529         char folded_sign = callchain_list__folded(chain);
 530         bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;
 531
 532         color = HE_COLORSET_NORMAL;
 533         width = browser->b.width - (offset + 2);
 534         if (ui_browser__is_current_entry(&browser->b, row)) {
 535                 browser->selection = &chain->ms;
 536                 color = HE_COLORSET_SELECTED;
 537                 arg->is_current_entry = true;
 538         }
 539
 540         ui_browser__set_color(&browser->b, color);
 541         hist_browser__gotorc(browser, row, 0);
 542         ui_browser__write_nstring(&browser->b, " ", offset);
 543         ui_browser__printf(&browser->b, "%c", folded_sign);
 544         ui_browser__write_graph(&browser->b, show_annotated ? SLSMG_RARROW_CHAR : ' ');
 545         ui_browser__write_nstring(&browser->b, str, width);
 546 }
 547
 548 static void hist_browser__fprintf_callchain_entry(struct hist_browser *b __maybe_unused,
 549                                                   struct callchain_list *chain,
 550                                                   const char *str, int offset,
 551                                                   unsigned short row __maybe_unused,
 552                                                   struct callchain_print_arg *arg)
 553 {
 554         char folded_sign = callchain_list__folded(chain);
 555
 556         arg->printed += fprintf(arg->fp, "%*s%c %s\n", offset, " ",
 557                                 folded_sign, str);
 558 }
 559
 560 typedef bool (*check_output_full_fn)(struct hist_browser *browser,
 561                                      unsigned short row);
 562
 563 static bool hist_browser__check_output_full(struct hist_browser *browser,
 564                                             unsigned short row)
 565 {
 566         return browser->b.rows == row;
 567 }
 568
 569 static bool hist_browser__check_dump_full(struct hist_browser *browser __maybe_unused,
 570                                           unsigned short row __maybe_unused)
 571 {
 572         return false;
 573 }
 574
 575 #define LEVEL_OFFSET_STEP 3
 576
 577 static int hist_browser__show_callchain(struct hist_browser *browser,
 578                                         struct rb_root *root, int level,
 579                                         unsigned short row, u64 total,
 580                                         print_callchain_entry_fn print,
 581                                         struct callchain_print_arg *arg,
 582                                         check_output_full_fn is_output_full)
 583 {
 584         struct rb_node *node;
 585         int first_row = row, offset = level * LEVEL_OFFSET_STEP;
 586         u64 new_total;
 587         bool need_percent;
 588
 589         node = rb_first(root);
 590         need_percent = node && rb_next(node);
 591
 592         while (node) {
 593                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 594                 struct rb_node *next = rb_next(node);
 595                 u64 cumul = callchain_cumul_hits(child);
 596                 struct callchain_list *chain;
 597                 char folded_sign = ' ';
 598                 int first = true;
 599                 int extra_offset = 0;
 600
 601                 list_for_each_entry(chain, &child->val, list) {
 602                         char bf[1024], *alloc_str;
 603                         const char *str;
 604                         bool was_first = first;
 605
 606                         if (first)
 607                                 first = false;
 608                         else if (need_percent)
 609                                 extra_offset = LEVEL_OFFSET_STEP;
 610
 611                         folded_sign = callchain_list__folded(chain);
 612                         if (arg->row_offset != 0) {
 613                                 arg->row_offset--;
 614                                 goto do_next;
 615                         }
 616
 617                         alloc_str = NULL;
 618                         str = callchain_list__sym_name(chain, bf, sizeof(bf),
 619                                                        browser->show_dso);
 620
 621                         if (was_first && need_percent) {
 622                                 double percent = cumul * 100.0 / total;
 623
 624                                 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
 625                                         str = "Not enough memory!";
 626                                 else
 627                                         str = alloc_str;
 628                         }
 629
 630                         print(browser, chain, str, offset + extra_offset, row, arg);
 631
 632                         free(alloc_str);
 633
 634                         if (is_output_full(browser, ++row))
 635                                 goto out;
 636 do_next:
 637                         if (folded_sign == '+')
 638                                 break;
 639                 }
 640
 641                 if (folded_sign == '-') {
 642                         const int new_level = level + (extra_offset ? 2 : 1);
 643
 644                         if (callchain_param.mode == CHAIN_GRAPH_REL)
 645                                 new_total = child->children_hit;
 646                         else
 647                                 new_total = total;
 648
 649                         row += hist_browser__show_callchain(browser, &child->rb_root,
 650                                                             new_level, row, new_total,
 651                                                             print, arg, is_output_full);
 652                 }
 653                 if (is_output_full(browser, row))
 654                         break;
 655                 node = next;
 656         }
 657 out:
 658         return row - first_row;
 659 }
 660
 661 struct hpp_arg {
 662         struct ui_browser *b;
 663         char folded_sign;
 664         bool current_entry;
 665 };
 666
 667 static int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
 668 {
 669         struct hpp_arg *arg = hpp->ptr;
 670         int ret, len;
 671         va_list args;
 672         double percent;
 673
 674         va_start(args, fmt);
 675         len = va_arg(args, int);
 676         percent = va_arg(args, double);
 677         va_end(args);
 678
 679         ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
 680
 681         ret = scnprintf(hpp->buf, hpp->size, fmt, len, percent);
 682         ui_browser__printf(arg->b, "%s", hpp->buf);
 683
 684         advance_hpp(hpp, ret);
 685         return ret;
 686 }
 687
 688 #define __HPP_COLOR_PERCENT_FN(_type, _field)                           \
 689 static u64 __hpp_get_##_field(struct hist_entry *he)                    \
 690 {                                                                       \
 691         return he->stat._field;                                         \
 692 }                                                                       \
 693                                                                         \
 694 static int                                                              \
 695 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
 696                                 struct perf_hpp *hpp,                   \
 697                                 struct hist_entry *he)                  \
 698 {                                                                       \
 699         return hpp__fmt(fmt, hpp, he, __hpp_get_##_field, " %*.2f%%",   \
 700                         __hpp__slsmg_color_printf, true);               \
 701 }
 702
 703 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                       \
 704 static u64 __hpp_get_acc_##_field(struct hist_entry *he)                \
 705 {                                                                       \
 706         return he->stat_acc->_field;                                    \
 707 }                                                                       \
 708                                                                         \
 709 static int                                                              \
 710 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
 711                                 struct perf_hpp *hpp,                   \
 712                                 struct hist_entry *he)                  \
 713 {                                                                       \
 714         if (!symbol_conf.cumulate_callchain) {                          \
 715                 struct hpp_arg *arg = hpp->ptr;                         \
 716                 int len = fmt->user_len ?: fmt->len;                    \
 717                 int ret = scnprintf(hpp->buf, hpp->size,                \
 718                                     "%*s", len, "N/A");                 \
 719                 ui_browser__printf(arg->b, "%s", hpp->buf);             \
 720                                                                         \
 721                 return ret;                                             \
 722         }                                                               \
 723         return hpp__fmt(fmt, hpp, he, __hpp_get_acc_##_field,           \
 724                         " %*.2f%%", __hpp__slsmg_color_printf, true);   \
 725 }
 726
 727 __HPP_COLOR_PERCENT_FN(overhead, period)
 728 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
 729 __HPP_COLOR_PERCENT_FN(overhead_us, period_us)
 730 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
 731 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
 732 __HPP_COLOR_ACC_PERCENT_FN(overhead_acc, period)
 733
 734 #undef __HPP_COLOR_PERCENT_FN
 735 #undef __HPP_COLOR_ACC_PERCENT_FN
 736
 737 void hist_browser__init_hpp(void)
 738 {
 739         perf_hpp__format[PERF_HPP__OVERHEAD].color =
 740                                 hist_browser__hpp_color_overhead;
 741         perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
 742                                 hist_browser__hpp_color_overhead_sys;
 743         perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
 744                                 hist_browser__hpp_color_overhead_us;
 745         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
 746                                 hist_browser__hpp_color_overhead_guest_sys;
 747         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
 748                                 hist_browser__hpp_color_overhead_guest_us;
 749         perf_hpp__format[PERF_HPP__OVERHEAD_ACC].color =
 750                                 hist_browser__hpp_color_overhead_acc;
 751 }
 752
 753 static int hist_browser__show_entry(struct hist_browser *browser,
 754                                     struct hist_entry *entry,
 755                                     unsigned short row)
 756 {
 757         char s[256];
 758         int printed = 0;
 759         int width = browser->b.width;
 760         char folded_sign = ' ';
 761         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
 762         off_t row_offset = entry->row_offset;
 763         bool first = true;
 764         struct perf_hpp_fmt *fmt;
 765
 766         if (current_entry) {
 767                 browser->he_selection = entry;
 768                 browser->selection = &entry->ms;
 769         }
 770
 771         if (symbol_conf.use_callchain) {
 772                 hist_entry__init_have_children(entry);
 773                 folded_sign = hist_entry__folded(entry);
 774         }
 775
 776         if (row_offset == 0) {
 777                 struct hpp_arg arg = {
 778                         .b              = &browser->b,
 779                         .folded_sign    = folded_sign,
 780                         .current_entry  = current_entry,
 781                 };
 782                 struct perf_hpp hpp = {
 783                         .buf            = s,
 784                         .size           = sizeof(s),
 785                         .ptr            = &arg,
 786                 };
 787                 int column = 0;
 788
 789                 hist_browser__gotorc(browser, row, 0);
 790
 791                 perf_hpp__for_each_format(fmt) {
 792                         if (perf_hpp__should_skip(fmt) || column++ < browser->b.horiz_scroll)
 793                                 continue;
 794
 795                         if (current_entry && browser->b.navkeypressed) {
 796                                 ui_browser__set_color(&browser->b,
 797                                                       HE_COLORSET_SELECTED);
 798                         } else {
 799                                 ui_browser__set_color(&browser->b,
 800                                                       HE_COLORSET_NORMAL);
 801                         }
 802
 803                         if (first) {
 804                                 if (symbol_conf.use_callchain) {
 805                                         ui_browser__printf(&browser->b, "%c ", folded_sign);
 806                                         width -= 2;
 807                                 }
 808                                 first = false;
 809                         } else {
 810                                 ui_browser__printf(&browser->b, "  ");
 811                                 width -= 2;
 812                         }
 813
 814                         if (fmt->color) {
 815                                 width -= fmt->color(fmt, &hpp, entry);
 816                         } else {
 817                                 width -= fmt->entry(fmt, &hpp, entry);
 818                                 ui_browser__printf(&browser->b, "%s", s);
 819                         }
 820                 }
 821
 822                 /* The scroll bar isn't being used */
 823                 if (!browser->b.navkeypressed)
 824                         width += 1;
 825
 826                 ui_browser__write_nstring(&browser->b, "", width);
 827
 828                 ++row;
 829                 ++printed;
 830         } else
 831                 --row_offset;
 832
 833         if (folded_sign == '-' && row != browser->b.rows) {
 834                 u64 total = hists__total_period(entry->hists);
 835                 struct callchain_print_arg arg = {
 836                         .row_offset = row_offset,
 837                         .is_current_entry = current_entry,
 838                 };
 839
 840                 if (callchain_param.mode == CHAIN_GRAPH_REL) {
 841                         if (symbol_conf.cumulate_callchain)
 842                                 total = entry->stat_acc->period;
 843                         else
 844                                 total = entry->stat.period;
 845                 }
 846
 847                 printed += hist_browser__show_callchain(browser,
 848                                         &entry->sorted_chain, 1, row, total,
 849                                         hist_browser__show_callchain_entry, &arg,
 850                                         hist_browser__check_output_full);
 851
 852                 if (arg.is_current_entry)
 853                         browser->he_selection = entry;
 854         }
 855
 856         return printed;
 857 }
 858
 859 static int advance_hpp_check(struct perf_hpp *hpp, int inc)
 860 {
 861         advance_hpp(hpp, inc);
 862         return hpp->size <= 0;
 863 }
 864
 865 static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *buf, size_t size)
 866 {
 867         struct hists *hists = browser->hists;
 868         struct perf_hpp dummy_hpp = {
 869                 .buf    = buf,
 870                 .size   = size,
 871         };
 872         struct perf_hpp_fmt *fmt;
 873         size_t ret = 0;
 874         int column = 0;
 875
 876         if (symbol_conf.use_callchain) {
 877                 ret = scnprintf(buf, size, "  ");
 878                 if (advance_hpp_check(&dummy_hpp, ret))
 879                         return ret;
 880         }
 881
 882         perf_hpp__for_each_format(fmt) {
 883                 if (perf_hpp__should_skip(fmt)  || column++ < browser->b.horiz_scroll)
 884                         continue;
 885
 886                 ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
 887                 if (advance_hpp_check(&dummy_hpp, ret))
 888                         break;
 889
 890                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
 891                 if (advance_hpp_check(&dummy_hpp, ret))
 892                         break;
 893         }
 894
 895         return ret;
 896 }
 897
 898 static void hist_browser__show_headers(struct hist_browser *browser)
 899 {
 900         char headers[1024];
 901
 902         hists_browser__scnprintf_headers(browser, headers, sizeof(headers));
 903         ui_browser__gotorc(&browser->b, 0, 0);
 904         ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
 905         ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
 906 }
 907
 908 static void ui_browser__hists_init_top(struct ui_browser *browser)
 909 {
 910         if (browser->top == NULL) {
 911                 struct hist_browser *hb;
 912
 913                 hb = container_of(browser, struct hist_browser, b);
 914                 browser->top = rb_first(&hb->hists->entries);
 915         }
 916 }
 917
 918 static unsigned int hist_browser__refresh(struct ui_browser *browser)
 919 {
 920         unsigned row = 0;
 921         u16 header_offset = 0;
 922         struct rb_node *nd;
 923         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
 924
 925         if (hb->show_headers) {
 926                 hist_browser__show_headers(hb);
 927                 header_offset = 1;
 928         }
 929
 930         ui_browser__hists_init_top(browser);
 931
 932         for (nd = browser->top; nd; nd = rb_next(nd)) {
 933                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 934                 float percent;
 935
 936                 if (h->filtered)
 937                         continue;
 938
 939                 percent = hist_entry__get_percent_limit(h);
 940                 if (percent < hb->min_pcnt)
 941                         continue;
 942
 943                 row += hist_browser__show_entry(hb, h, row);
 944                 if (row == browser->rows)
 945                         break;
 946         }
 947
 948         return row + header_offset;
 949 }
 950
 951 static struct rb_node *hists__filter_entries(struct rb_node *nd,
 952                                              float min_pcnt)
 953 {
 954         while (nd != NULL) {
 955                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 956                 float percent = hist_entry__get_percent_limit(h);
 957
 958                 if (!h->filtered && percent >= min_pcnt)
 959                         return nd;
 960
 961                 nd = rb_next(nd);
 962         }
 963
 964         return NULL;
 965 }
 966
 967 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
 968                                                   float min_pcnt)
 969 {
 970         while (nd != NULL) {
 971                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 972                 float percent = hist_entry__get_percent_limit(h);
 973
 974                 if (!h->filtered && percent >= min_pcnt)
 975                         return nd;
 976
 977                 nd = rb_prev(nd);
 978         }
 979
 980         return NULL;
 981 }
 982
 983 static void ui_browser__hists_seek(struct ui_browser *browser,
 984                                    off_t offset, int whence)
 985 {
 986         struct hist_entry *h;
 987         struct rb_node *nd;
 988         bool first = true;
 989         struct hist_browser *hb;
 990
 991         hb = container_of(browser, struct hist_browser, b);
 992
 993         if (browser->nr_entries == 0)
 994                 return;
 995
 996         ui_browser__hists_init_top(browser);
 997
 998         switch (whence) {
 999         case SEEK_SET:
1000                 nd = hists__filter_entries(rb_first(browser->entries),
1001                                            hb->min_pcnt);
1002                 break;
1003         case SEEK_CUR:
1004                 nd = browser->top;
1005                 goto do_offset;
1006         case SEEK_END:
1007                 nd = hists__filter_prev_entries(rb_last(browser->entries),
1008                                                 hb->min_pcnt);
1009                 first = false;
1010                 break;
1011         default:
1012                 return;
1013         }
1014
1015         /*
1016          * Moves not relative to the first visible entry invalidates its
1017          * row_offset:
1018          */
1019         h = rb_entry(browser->top, struct hist_entry, rb_node);
1020         h->row_offset = 0;
1021
1022         /*
1023          * Here we have to check if nd is expanded (+), if it is we can't go
1024          * the next top level hist_entry, instead we must compute an offset of
1025          * what _not_ to show and not change the first visible entry.
1026          *
1027          * This offset increments when we are going from top to bottom and
1028          * decreases when we're going from bottom to top.
1029          *
1030          * As we don't have backpointers to the top level in the callchains
1031          * structure, we need to always print the whole hist_entry callchain,
1032          * skipping the first ones that are before the first visible entry
1033          * and stop when we printed enough lines to fill the screen.
1034          */
1035 do_offset:
1036         if (offset > 0) {
1037                 do {
1038                         h = rb_entry(nd, struct hist_entry, rb_node);
1039                         if (h->unfolded) {
1040                                 u16 remaining = h->nr_rows - h->row_offset;
1041                                 if (offset > remaining) {
1042                                         offset -= remaining;
1043                                         h->row_offset = 0;
1044                                 } else {
1045                                         h->row_offset += offset;
1046                                         offset = 0;
1047                                         browser->top = nd;
1048                                         break;
1049                                 }
1050                         }
1051                         nd = hists__filter_entries(rb_next(nd), hb->min_pcnt);
1052                         if (nd == NULL)
1053                                 break;
1054                         --offset;
1055                         browser->top = nd;
1056                 } while (offset != 0);
1057         } else if (offset < 0) {
1058                 while (1) {
1059                         h = rb_entry(nd, struct hist_entry, rb_node);
1060                         if (h->unfolded) {
1061                                 if (first) {
1062                                         if (-offset > h->row_offset) {
1063                                                 offset += h->row_offset;
1064                                                 h->row_offset = 0;
1065                                         } else {
1066                                                 h->row_offset += offset;
1067                                                 offset = 0;
1068                                                 browser->top = nd;
1069                                                 break;
1070                                         }
1071                                 } else {
1072                                         if (-offset > h->nr_rows) {
1073                                                 offset += h->nr_rows;
1074                                                 h->row_offset = 0;
1075                                         } else {
1076                                                 h->row_offset = h->nr_rows + offset;
1077                                                 offset = 0;
1078                                                 browser->top = nd;
1079                                                 break;
1080                                         }
1081                                 }
1082                         }
1083
1084                         nd = hists__filter_prev_entries(rb_prev(nd),
1085                                                         hb->min_pcnt);
1086                         if (nd == NULL)
1087                                 break;
1088                         ++offset;
1089                         browser->top = nd;
1090                         if (offset == 0) {
1091                                 /*
1092                                  * Last unfiltered hist_entry, check if it is
1093                                  * unfolded, if it is then we should have
1094                                  * row_offset at its last entry.
1095                                  */
1096                                 h = rb_entry(nd, struct hist_entry, rb_node);
1097                                 if (h->unfolded)
1098                                         h->row_offset = h->nr_rows;
1099                                 break;
1100                         }
1101                         first = false;
1102                 }
1103         } else {
1104                 browser->top = nd;
1105                 h = rb_entry(nd, struct hist_entry, rb_node);
1106                 h->row_offset = 0;
1107         }
1108 }
1109
1110 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
1111                                            struct hist_entry *he, FILE *fp)
1112 {
1113         u64 total = hists__total_period(he->hists);
1114         struct callchain_print_arg arg  = {
1115                 .fp = fp,
1116         };
1117
1118         if (symbol_conf.cumulate_callchain)
1119                 total = he->stat_acc->period;
1120
1121         hist_browser__show_callchain(browser, &he->sorted_chain, 1, 0, total,
1122                                      hist_browser__fprintf_callchain_entry, &arg,
1123                                      hist_browser__check_dump_full);
1124         return arg.printed;
1125 }
1126
1127 static int hist_browser__fprintf_entry(struct hist_browser *browser,
1128                                        struct hist_entry *he, FILE *fp)
1129 {
1130         char s[8192];
1131         int printed = 0;
1132         char folded_sign = ' ';
1133         struct perf_hpp hpp = {
1134                 .buf = s,
1135                 .size = sizeof(s),
1136         };
1137         struct perf_hpp_fmt *fmt;
1138         bool first = true;
1139         int ret;
1140
1141         if (symbol_conf.use_callchain)
1142                 folded_sign = hist_entry__folded(he);
1143
1144         if (symbol_conf.use_callchain)
1145                 printed += fprintf(fp, "%c ", folded_sign);
1146
1147         perf_hpp__for_each_format(fmt) {
1148                 if (perf_hpp__should_skip(fmt))
1149                         continue;
1150
1151                 if (!first) {
1152                         ret = scnprintf(hpp.buf, hpp.size, "  ");
1153                         advance_hpp(&hpp, ret);
1154                 } else
1155                         first = false;
1156
1157                 ret = fmt->entry(fmt, &hpp, he);
1158                 advance_hpp(&hpp, ret);
1159         }
1160         printed += fprintf(fp, "%s\n", rtrim(s));
1161
1162         if (folded_sign == '-')
1163                 printed += hist_browser__fprintf_callchain(browser, he, fp);
1164
1165         return printed;
1166 }
1167
1168 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
1169 {
1170         struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
1171                                                    browser->min_pcnt);
1172         int printed = 0;
1173
1174         while (nd) {
1175                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1176
1177                 printed += hist_browser__fprintf_entry(browser, h, fp);
1178                 nd = hists__filter_entries(rb_next(nd), browser->min_pcnt);
1179         }
1180
1181         return printed;
1182 }
1183
1184 static int hist_browser__dump(struct hist_browser *browser)
1185 {
1186         char filename[64];
1187         FILE *fp;
1188
1189         while (1) {
1190                 scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
1191                 if (access(filename, F_OK))
1192                         break;
1193                 /*
1194                  * XXX: Just an arbitrary lazy upper limit
1195                  */
1196                 if (++browser->print_seq == 8192) {
1197                         ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
1198                         return -1;
1199                 }
1200         }
1201
1202         fp = fopen(filename, "w");
1203         if (fp == NULL) {
1204                 char bf[64];
1205                 const char *err = strerror_r(errno, bf, sizeof(bf));
1206                 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
1207                 return -1;
1208         }
1209
1210         ++browser->print_seq;
1211         hist_browser__fprintf(browser, fp);
1212         fclose(fp);
1213         ui_helpline__fpush("%s written!", filename);
1214
1215         return 0;
1216 }
1217
1218 static struct hist_browser *hist_browser__new(struct hists *hists,
1219                                               struct hist_browser_timer *hbt,
1220                                               struct perf_env *env)
1221 {
1222         struct hist_browser *browser = zalloc(sizeof(*browser));
1223
1224         if (browser) {
1225                 browser->hists = hists;
1226                 browser->b.refresh = hist_browser__refresh;
1227                 browser->b.refresh_dimensions = hist_browser__refresh_dimensions;
1228                 browser->b.seek = ui_browser__hists_seek;
1229                 browser->b.use_navkeypressed = true;
1230                 browser->show_headers = symbol_conf.show_hist_headers;
1231                 browser->hbt = hbt;
1232                 browser->env = env;
1233         }
1234
1235         return browser;
1236 }
1237
1238 static void hist_browser__delete(struct hist_browser *browser)
1239 {
1240         free(browser);
1241 }
1242
1243 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
1244 {
1245         return browser->he_selection;
1246 }
1247
1248 static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
1249 {
1250         return browser->he_selection->thread;
1251 }
1252
1253 /* Check whether the browser is for 'top' or 'report' */
1254 static inline bool is_report_browser(void *timer)
1255 {
1256         return timer == NULL;
1257 }
1258
1259 static int hists__browser_title(struct hists *hists,
1260                                 struct hist_browser_timer *hbt,
1261                                 char *bf, size_t size)
1262 {
1263         char unit;
1264         int printed;
1265         const struct dso *dso = hists->dso_filter;
1266         const struct thread *thread = hists->thread_filter;
1267         int socket_id = hists->socket_filter;
1268         unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
1269         u64 nr_events = hists->stats.total_period;
1270         struct perf_evsel *evsel = hists_to_evsel(hists);
1271         const char *ev_name = perf_evsel__name(evsel);
1272         char buf[512];
1273         size_t buflen = sizeof(buf);
1274         char ref[30] = " show reference callgraph, ";
1275         bool enable_ref = false;
1276
1277         if (symbol_conf.filter_relative) {
1278                 nr_samples = hists->stats.nr_non_filtered_samples;
1279                 nr_events = hists->stats.total_non_filtered_period;
1280         }
1281
1282         if (perf_evsel__is_group_event(evsel)) {
1283                 struct perf_evsel *pos;
1284
1285                 perf_evsel__group_desc(evsel, buf, buflen);
1286                 ev_name = buf;
1287
1288                 for_each_group_member(pos, evsel) {
1289                         struct hists *pos_hists = evsel__hists(pos);
1290
1291                         if (symbol_conf.filter_relative) {
1292                                 nr_samples += pos_hists->stats.nr_non_filtered_samples;
1293                                 nr_events += pos_hists->stats.total_non_filtered_period;
1294                         } else {
1295                                 nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
1296                                 nr_events += pos_hists->stats.total_period;
1297                         }
1298                 }
1299         }
1300
1301         if (symbol_conf.show_ref_callgraph &&
1302             strstr(ev_name, "call-graph=no"))
1303                 enable_ref = true;
1304         nr_samples = convert_unit(nr_samples, &unit);
1305         printed = scnprintf(bf, size,
1306                            "Samples: %lu%c of event '%s',%sEvent count (approx.): %" PRIu64,
1307                            nr_samples, unit, ev_name, enable_ref ? ref : " ", nr_events);
1308
1309
1310         if (hists->uid_filter_str)
1311                 printed += snprintf(bf + printed, size - printed,
1312                                     ", UID: %s", hists->uid_filter_str);
1313         if (thread)
1314                 printed += scnprintf(bf + printed, size - printed,
1315                                     ", Thread: %s(%d)",
1316                                      (thread->comm_set ? thread__comm_str(thread) : ""),
1317                                     thread->tid);
1318         if (dso)
1319                 printed += scnprintf(bf + printed, size - printed,
1320                                     ", DSO: %s", dso->short_name);
1321         if (socket_id > -1)
1322                 printed += scnprintf(bf + printed, size - printed,
1323                                     ", Processor Socket: %d", socket_id);
1324         if (!is_report_browser(hbt)) {
1325                 struct perf_top *top = hbt->arg;
1326
1327                 if (top->zero)
1328                         printed += scnprintf(bf + printed, size - printed, " [z]");
1329         }
1330
1331         return printed;
1332 }
1333
1334 static inline void free_popup_options(char **options, int n)
1335 {
1336         int i;
1337
1338         for (i = 0; i < n; ++i)
1339                 zfree(&options[i]);
1340 }
1341
1342 /*
1343  * Only runtime switching of perf data file will make "input_name" point
1344  * to a malloced buffer. So add "is_input_name_malloced" flag to decide
1345  * whether we need to call free() for current "input_name" during the switch.
1346  */
1347 static bool is_input_name_malloced = false;
1348
1349 static int switch_data_file(void)
1350 {
1351         char *pwd, *options[32], *abs_path[32], *tmp;
1352         DIR *pwd_dir;
1353         int nr_options = 0, choice = -1, ret = -1;
1354         struct dirent *dent;
1355
1356         pwd = getenv("PWD");
1357         if (!pwd)
1358                 return ret;
1359
1360         pwd_dir = opendir(pwd);
1361         if (!pwd_dir)
1362                 return ret;
1363
1364         memset(options, 0, sizeof(options));
1365         memset(options, 0, sizeof(abs_path));
1366
1367         while ((dent = readdir(pwd_dir))) {
1368                 char path[PATH_MAX];
1369                 u64 magic;
1370                 char *name = dent->d_name;
1371                 FILE *file;
1372
1373                 if (!(dent->d_type == DT_REG))
1374                         continue;
1375
1376                 snprintf(path, sizeof(path), "%s/%s", pwd, name);
1377
1378                 file = fopen(path, "r");
1379                 if (!file)
1380                         continue;
1381
1382                 if (fread(&magic, 1, 8, file) < 8)
1383                         goto close_file_and_continue;
1384
1385                 if (is_perf_magic(magic)) {
1386                         options[nr_options] = strdup(name);
1387                         if (!options[nr_options])
1388                                 goto close_file_and_continue;
1389
1390                         abs_path[nr_options] = strdup(path);
1391                         if (!abs_path[nr_options]) {
1392                                 zfree(&options[nr_options]);
1393                                 ui__warning("Can't search all data files due to memory shortage.\n");
1394                                 fclose(file);
1395                                 break;
1396                         }
1397
1398                         nr_options++;
1399                 }
1400
1401 close_file_and_continue:
1402                 fclose(file);
1403                 if (nr_options >= 32) {
1404                         ui__warning("Too many perf data files in PWD!\n"
1405                                     "Only the first 32 files will be listed.\n");
1406                         break;
1407                 }
1408         }
1409         closedir(pwd_dir);
1410
1411         if (nr_options) {
1412                 choice = ui__popup_menu(nr_options, options);
1413                 if (choice < nr_options && choice >= 0) {
1414                         tmp = strdup(abs_path[choice]);
1415                         if (tmp) {
1416                                 if (is_input_name_malloced)
1417                                         free((void *)input_name);
1418                                 input_name = tmp;
1419                                 is_input_name_malloced = true;
1420                                 ret = 0;
1421                         } else
1422                                 ui__warning("Data switch failed due to memory shortage!\n");
1423                 }
1424         }
1425
1426         free_popup_options(options, nr_options);
1427         free_popup_options(abs_path, nr_options);
1428         return ret;
1429 }
1430
1431 struct popup_action {
1432         struct thread           *thread;
1433         struct map_symbol       ms;
1434         int                     socket;
1435
1436         int (*fn)(struct hist_browser *browser, struct popup_action *act);
1437 };
1438
1439 static int
1440 do_annotate(struct hist_browser *browser, struct popup_action *act)
1441 {
1442         struct perf_evsel *evsel;
1443         struct annotation *notes;
1444         struct hist_entry *he;
1445         int err;
1446
1447         if (!objdump_path && perf_env__lookup_objdump(browser->env))
1448                 return 0;
1449
1450         notes = symbol__annotation(act->ms.sym);
1451         if (!notes->src)
1452                 return 0;
1453
1454         evsel = hists_to_evsel(browser->hists);
1455         err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt);
1456         he = hist_browser__selected_entry(browser);
1457         /*
1458          * offer option to annotate the other branch source or target
1459          * (if they exists) when returning from annotate
1460          */
1461         if ((err == 'q' || err == CTRL('c')) && he->branch_info)
1462                 return 1;
1463
1464         ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
1465         if (err)
1466                 ui_browser__handle_resize(&browser->b);
1467         return 0;
1468 }
1469
1470 static int
1471 add_annotate_opt(struct hist_browser *browser __maybe_unused,
1472                  struct popup_action *act, char **optstr,
1473                  struct map *map, struct symbol *sym)
1474 {
1475         if (sym == NULL || map->dso->annotate_warned)
1476                 return 0;
1477
1478         if (asprintf(optstr, "Annotate %s", sym->name) < 0)
1479                 return 0;
1480
1481         act->ms.map = map;
1482         act->ms.sym = sym;
1483         act->fn = do_annotate;
1484         return 1;
1485 }
1486
1487 static int
1488 do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
1489 {
1490         struct thread *thread = act->thread;
1491
1492         if (browser->hists->thread_filter) {
1493                 pstack__remove(browser->pstack, &browser->hists->thread_filter);
1494                 perf_hpp__set_elide(HISTC_THREAD, false);
1495                 thread__zput(browser->hists->thread_filter);
1496                 ui_helpline__pop();
1497         } else {
1498                 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s(%d) thread\"",
1499                                    thread->comm_set ? thread__comm_str(thread) : "",
1500                                    thread->tid);
1501                 browser->hists->thread_filter = thread__get(thread);
1502                 perf_hpp__set_elide(HISTC_THREAD, false);
1503                 pstack__push(browser->pstack, &browser->hists->thread_filter);
1504         }
1505
1506         hists__filter_by_thread(browser->hists);
1507         hist_browser__reset(browser);
1508         return 0;
1509 }
1510
1511 static int
1512 add_thread_opt(struct hist_browser *browser, struct popup_action *act,
1513                char **optstr, struct thread *thread)
1514 {
1515         if (thread == NULL)
1516                 return 0;
1517
1518         if (asprintf(optstr, "Zoom %s %s(%d) thread",
1519                      browser->hists->thread_filter ? "out of" : "into",
1520                      thread->comm_set ? thread__comm_str(thread) : "",
1521                      thread->tid) < 0)
1522                 return 0;
1523
1524         act->thread = thread;
1525         act->fn = do_zoom_thread;
1526         return 1;
1527 }
1528
1529 static int
1530 do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
1531 {
1532         struct map *map = act->ms.map;
1533
1534         if (browser->hists->dso_filter) {
1535                 pstack__remove(browser->pstack, &browser->hists->dso_filter);
1536                 perf_hpp__set_elide(HISTC_DSO, false);
1537                 browser->hists->dso_filter = NULL;
1538                 ui_helpline__pop();
1539         } else {
1540                 if (map == NULL)
1541                         return 0;
1542                 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s DSO\"",
1543                                    __map__is_kernel(map) ? "the Kernel" : map->dso->short_name);
1544                 browser->hists->dso_filter = map->dso;
1545                 perf_hpp__set_elide(HISTC_DSO, true);
1546                 pstack__push(browser->pstack, &browser->hists->dso_filter);
1547         }
1548
1549         hists__filter_by_dso(browser->hists);
1550         hist_browser__reset(browser);
1551         return 0;
1552 }
1553
1554 static int
1555 add_dso_opt(struct hist_browser *browser, struct popup_action *act,
1556             char **optstr, struct map *map)
1557 {
1558         if (map == NULL)
1559                 return 0;
1560
1561         if (asprintf(optstr, "Zoom %s %s DSO",
1562                      browser->hists->dso_filter ? "out of" : "into",
1563                      __map__is_kernel(map) ? "the Kernel" : map->dso->short_name) < 0)
1564                 return 0;
1565
1566         act->ms.map = map;
1567         act->fn = do_zoom_dso;
1568         return 1;
1569 }
1570
1571 static int
1572 do_browse_map(struct hist_browser *browser __maybe_unused,
1573               struct popup_action *act)
1574 {
1575         map__browse(act->ms.map);
1576         return 0;
1577 }
1578
1579 static int
1580 add_map_opt(struct hist_browser *browser __maybe_unused,
1581             struct popup_action *act, char **optstr, struct map *map)
1582 {
1583         if (map == NULL)
1584                 return 0;
1585
1586         if (asprintf(optstr, "Browse map details") < 0)
1587                 return 0;
1588
1589         act->ms.map = map;
1590         act->fn = do_browse_map;
1591         return 1;
1592 }
1593
1594 static int
1595 do_run_script(struct hist_browser *browser __maybe_unused,
1596               struct popup_action *act)
1597 {
1598         char script_opt[64];
1599         memset(script_opt, 0, sizeof(script_opt));
1600
1601         if (act->thread) {
1602                 scnprintf(script_opt, sizeof(script_opt), " -c %s ",
1603                           thread__comm_str(act->thread));
1604         } else if (act->ms.sym) {
1605                 scnprintf(script_opt, sizeof(script_opt), " -S %s ",
1606                           act->ms.sym->name);
1607         }
1608
1609         script_browse(script_opt);
1610         return 0;
1611 }
1612
1613 static int
1614 add_script_opt(struct hist_browser *browser __maybe_unused,
1615                struct popup_action *act, char **optstr,
1616                struct thread *thread, struct symbol *sym)
1617 {
1618         if (thread) {
1619                 if (asprintf(optstr, "Run scripts for samples of thread [%s]",
1620                              thread__comm_str(thread)) < 0)
1621                         return 0;
1622         } else if (sym) {
1623                 if (asprintf(optstr, "Run scripts for samples of symbol [%s]",
1624                              sym->name) < 0)
1625                         return 0;
1626         } else {
1627                 if (asprintf(optstr, "Run scripts for all samples") < 0)
1628                         return 0;
1629         }
1630
1631         act->thread = thread;
1632         act->ms.sym = sym;
1633         act->fn = do_run_script;
1634         return 1;
1635 }
1636
1637 static int
1638 do_switch_data(struct hist_browser *browser __maybe_unused,
1639                struct popup_action *act __maybe_unused)
1640 {
1641         if (switch_data_file()) {
1642                 ui__warning("Won't switch the data files due to\n"
1643                             "no valid data file get selected!\n");
1644                 return 0;
1645         }
1646
1647         return K_SWITCH_INPUT_DATA;
1648 }
1649
1650 static int
1651 add_switch_opt(struct hist_browser *browser,
1652                struct popup_action *act, char **optstr)
1653 {
1654         if (!is_report_browser(browser->hbt))
1655                 return 0;
1656
1657         if (asprintf(optstr, "Switch to another data file in PWD") < 0)
1658                 return 0;
1659
1660         act->fn = do_switch_data;
1661         return 1;
1662 }
1663
1664 static int
1665 do_exit_browser(struct hist_browser *browser __maybe_unused,
1666                 struct popup_action *act __maybe_unused)
1667 {
1668         return 0;
1669 }
1670
1671 static int
1672 add_exit_opt(struct hist_browser *browser __maybe_unused,
1673              struct popup_action *act, char **optstr)
1674 {
1675         if (asprintf(optstr, "Exit") < 0)
1676                 return 0;
1677
1678         act->fn = do_exit_browser;
1679         return 1;
1680 }
1681
1682 static int
1683 do_zoom_socket(struct hist_browser *browser, struct popup_action *act)
1684 {
1685         if (browser->hists->socket_filter > -1) {
1686                 pstack__remove(browser->pstack, &browser->hists->socket_filter);
1687                 browser->hists->socket_filter = -1;
1688                 perf_hpp__set_elide(HISTC_SOCKET, false);
1689         } else {
1690                 browser->hists->socket_filter = act->socket;
1691                 perf_hpp__set_elide(HISTC_SOCKET, true);
1692                 pstack__push(browser->pstack, &browser->hists->socket_filter);
1693         }
1694
1695         hists__filter_by_socket(browser->hists);
1696         hist_browser__reset(browser);
1697         return 0;
1698 }
1699
1700 static int
1701 add_socket_opt(struct hist_browser *browser, struct popup_action *act,
1702                char **optstr, int socket_id)
1703 {
1704         if (socket_id < 0)
1705                 return 0;
1706
1707         if (asprintf(optstr, "Zoom %s Processor Socket %d",
1708                      (browser->hists->socket_filter > -1) ? "out of" : "into",
1709                      socket_id) < 0)
1710                 return 0;
1711
1712         act->socket = socket_id;
1713         act->fn = do_zoom_socket;
1714         return 1;
1715 }
1716
1717 static void hist_browser__update_nr_entries(struct hist_browser *hb)
1718 {
1719         u64 nr_entries = 0;
1720         struct rb_node *nd = rb_first(&hb->hists->entries);
1721
1722         if (hb->min_pcnt == 0) {
1723                 hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;
1724                 return;
1725         }
1726
1727         while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
1728                 nr_entries++;
1729                 nd = rb_next(nd);
1730         }
1731
1732         hb->nr_non_filtered_entries = nr_entries;
1733 }
1734
1735 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
1736                                     const char *helpline,
1737                                     bool left_exits,
1738                                     struct hist_browser_timer *hbt,
1739                                     float min_pcnt,
1740                                     struct perf_env *env)
1741 {
1742         struct hists *hists = evsel__hists(evsel);
1743         struct hist_browser *browser = hist_browser__new(hists, hbt, env);
1744         struct branch_info *bi;
1745 #define MAX_OPTIONS  16
1746         char *options[MAX_OPTIONS];
1747         struct popup_action actions[MAX_OPTIONS];
1748         int nr_options = 0;
1749         int key = -1;
1750         char buf[64];
1751         int delay_secs = hbt ? hbt->refresh : 0;
1752         struct perf_hpp_fmt *fmt;
1753
1754 #define HIST_BROWSER_HELP_COMMON                                        \
1755         "h/?/F1        Show this window\n"                              \
1756         "UP/DOWN/PGUP\n"                                                \
1757         "PGDN/SPACE    Navigate\n"                                      \
1758         "q/ESC/CTRL+C  Exit browser\n\n"                                \
1759         "For multiple event sessions:\n\n"                              \
1760         "TAB/UNTAB     Switch events\n\n"                               \
1761         "For symbolic views (--sort has sym):\n\n"                      \
1762         "ENTER         Zoom into DSO/Threads & Annotate current symbol\n" \
1763         "ESC           Zoom out\n"                                      \
1764         "a             Annotate current symbol\n"                       \
1765         "C             Collapse all callchains\n"                       \
1766         "d             Zoom into current DSO\n"                         \
1767         "E             Expand all callchains\n"                         \
1768         "F             Toggle percentage of filtered entries\n"         \
1769         "H             Display column headers\n"                        \
1770         "m             Display context menu\n"                          \
1771         "S             Zoom into current Processor Socket\n"            \
1772
1773         /* help messages are sorted by lexical order of the hotkey */
1774         const char report_help[] = HIST_BROWSER_HELP_COMMON
1775         "i             Show header information\n"
1776         "P             Print histograms to perf.hist.N\n"
1777         "r             Run available scripts\n"
1778         "s             Switch to another data file in PWD\n"
1779         "t             Zoom into current Thread\n"
1780         "V             Verbose (DSO names in callchains, etc)\n"
1781         "/             Filter symbol by name";
1782         const char top_help[] = HIST_BROWSER_HELP_COMMON
1783         "P             Print histograms to perf.hist.N\n"
1784         "t             Zoom into current Thread\n"
1785         "V             Verbose (DSO names in callchains, etc)\n"
1786         "z             Toggle zeroing of samples\n"
1787         "f             Enable/Disable events\n"
1788         "/             Filter symbol by name";
1789
1790         if (browser == NULL)
1791                 return -1;
1792
1793         /* reset abort key so that it can get Ctrl-C as a key */
1794         SLang_reset_tty();
1795         SLang_init_tty(0, 0, 0);
1796
1797         if (min_pcnt) {
1798                 browser->min_pcnt = min_pcnt;
1799                 hist_browser__update_nr_entries(browser);
1800         }
1801
1802         browser->pstack = pstack__new(3);
1803         if (browser->pstack == NULL)
1804                 goto out;
1805
1806         ui_helpline__push(helpline);
1807
1808         memset(options, 0, sizeof(options));
1809         memset(actions, 0, sizeof(actions));
1810
1811         perf_hpp__for_each_format(fmt) {
1812                 perf_hpp__reset_width(fmt, hists);
1813                 /*
1814                  * This is done just once, and activates the horizontal scrolling
1815                  * code in the ui_browser code, it would be better to have a the
1816                  * counter in the perf_hpp code, but I couldn't find doing it here
1817                  * works, FIXME by setting this in hist_browser__new, for now, be
1818                  * clever 8-)
1819                  */
1820                 ++browser->b.columns;
1821         }
1822
1823         if (symbol_conf.col_width_list_str)
1824                 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
1825
1826         while (1) {
1827                 struct thread *thread = NULL;
1828                 struct map *map = NULL;
1829                 int choice = 0;
1830                 int socked_id = -1;
1831
1832                 nr_options = 0;
1833
1834                 key = hist_browser__run(browser, helpline);
1835
1836                 if (browser->he_selection != NULL) {
1837                         thread = hist_browser__selected_thread(browser);
1838                         map = browser->selection->map;
1839                         socked_id = browser->he_selection->socket;
1840                 }
1841                 switch (key) {
1842                 case K_TAB:
1843                 case K_UNTAB:
1844                         if (nr_events == 1)
1845                                 continue;
1846                         /*
1847                          * Exit the browser, let hists__browser_tree
1848                          * go to the next or previous
1849                          */
1850                         goto out_free_stack;
1851                 case 'a':
1852                         if (!sort__has_sym) {
1853                                 ui_browser__warning(&browser->b, delay_secs * 2,
1854                         "Annotation is only available for symbolic views, "
1855                         "include \"sym*\" in --sort to use it.");
1856                                 continue;
1857                         }
1858
1859                         if (browser->selection == NULL ||
1860                             browser->selection->sym == NULL ||
1861                             browser->selection->map->dso->annotate_warned)
1862                                 continue;
1863
1864                         actions->ms.map = browser->selection->map;
1865                         actions->ms.sym = browser->selection->sym;
1866                         do_annotate(browser, actions);
1867                         continue;
1868                 case 'P':
1869                         hist_browser__dump(browser);
1870                         continue;
1871                 case 'd':
1872                         actions->ms.map = map;
1873                         do_zoom_dso(browser, actions);
1874                         continue;
1875                 case 'V':
1876                         browser->show_dso = !browser->show_dso;
1877                         continue;
1878                 case 't':
1879                         actions->thread = thread;
1880                         do_zoom_thread(browser, actions);
1881                         continue;
1882                 case 'S':
1883                         actions->socket = socked_id;
1884                         do_zoom_socket(browser, actions);
1885                         continue;
1886                 case '/':
1887                         if (ui_browser__input_window("Symbol to show",
1888                                         "Please enter the name of symbol you want to see.\n"
1889                                         "To remove the filter later, press / + ENTER.",
1890                                         buf, "ENTER: OK, ESC: Cancel",
1891                                         delay_secs * 2) == K_ENTER) {
1892                                 hists->symbol_filter_str = *buf ? buf : NULL;
1893                                 hists__filter_by_symbol(hists);
1894                                 hist_browser__reset(browser);
1895                         }
1896                         continue;
1897                 case 'r':
1898                         if (is_report_browser(hbt)) {
1899                                 actions->thread = NULL;
1900                                 actions->ms.sym = NULL;
1901                                 do_run_script(browser, actions);
1902                         }
1903                         continue;
1904                 case 's':
1905                         if (is_report_browser(hbt)) {
1906                                 key = do_switch_data(browser, actions);
1907                                 if (key == K_SWITCH_INPUT_DATA)
1908                                         goto out_free_stack;
1909                         }
1910                         continue;
1911                 case 'i':
1912                         /* env->arch is NULL for live-mode (i.e. perf top) */
1913                         if (env->arch)
1914                                 tui__header_window(env);
1915                         continue;
1916                 case 'F':
1917                         symbol_conf.filter_relative ^= 1;
1918                         continue;
1919                 case 'z':
1920                         if (!is_report_browser(hbt)) {
1921                                 struct perf_top *top = hbt->arg;
1922
1923                                 top->zero = !top->zero;
1924                         }
1925                         continue;
1926                 case K_F1:
1927                 case 'h':
1928                 case '?':
1929                         ui_browser__help_window(&browser->b,
1930                                 is_report_browser(hbt) ? report_help : top_help);
1931                         continue;
1932                 case K_ENTER:
1933                 case K_RIGHT:
1934                 case 'm':
1935                         /* menu */
1936                         break;
1937                 case K_ESC:
1938                 case K_LEFT: {
1939                         const void *top;
1940
1941                         if (pstack__empty(browser->pstack)) {
1942                                 /*
1943                                  * Go back to the perf_evsel_menu__run or other user
1944                                  */
1945                                 if (left_exits)
1946                                         goto out_free_stack;
1947
1948                                 if (key == K_ESC &&
1949                                     ui_browser__dialog_yesno(&browser->b,
1950                                                              "Do you really want to exit?"))
1951                                         goto out_free_stack;
1952
1953                                 continue;
1954                         }
1955                         top = pstack__peek(browser->pstack);
1956                         if (top == &browser->hists->dso_filter) {
1957                                 /*
1958                                  * No need to set actions->dso here since
1959                                  * it's just to remove the current filter.
1960                                  * Ditto for thread below.
1961                                  */
1962                                 do_zoom_dso(browser, actions);
1963                         } else if (top == &browser->hists->thread_filter) {
1964                                 do_zoom_thread(browser, actions);
1965                         } else if (top == &browser->hists->socket_filter) {
1966                                 do_zoom_socket(browser, actions);
1967                         }
1968                         continue;
1969                 }
1970                 case 'q':
1971                 case CTRL('c'):
1972                         goto out_free_stack;
1973                 case 'f':
1974                         if (!is_report_browser(hbt)) {
1975                                 struct perf_top *top = hbt->arg;
1976
1977                                 perf_evlist__toggle_enable(top->evlist);
1978                                 /*
1979                                  * No need to refresh, resort/decay histogram
1980                                  * entries if we are not collecting samples:
1981                                  */
1982                                 if (top->evlist->enabled) {
1983                                         helpline = "Press 'f' to disable the events or 'h' to see other hotkeys";
1984                                         hbt->refresh = delay_secs;
1985                                 } else {
1986                                         helpline = "Press 'f' again to re-enable the events";
1987                                         hbt->refresh = 0;
1988                                 }
1989                                 continue;
1990                         }
1991                         /* Fall thru */
1992                 default:
1993                         helpline = "Press '?' for help on key bindings";
1994                         continue;
1995                 }
1996
1997                 if (!sort__has_sym)
1998                         goto add_exit_option;
1999
2000                 if (browser->selection == NULL)
2001                         goto skip_annotation;
2002
2003                 if (sort__mode == SORT_MODE__BRANCH) {
2004                         bi = browser->he_selection->branch_info;
2005
2006                         if (bi == NULL)
2007                                 goto skip_annotation;
2008
2009                         nr_options += add_annotate_opt(browser,
2010                                                        &actions[nr_options],
2011                                                        &options[nr_options],
2012                                                        bi->from.map,
2013                                                        bi->from.sym);
2014                         if (bi->to.sym != bi->from.sym)
2015                                 nr_options += add_annotate_opt(browser,
2016                                                         &actions[nr_options],
2017                                                         &options[nr_options],
2018                                                         bi->to.map,
2019                                                         bi->to.sym);
2020                 } else {
2021                         nr_options += add_annotate_opt(browser,
2022                                                        &actions[nr_options],
2023                                                        &options[nr_options],
2024                                                        browser->selection->map,
2025                                                        browser->selection->sym);
2026                 }
2027 skip_annotation:
2028                 nr_options += add_thread_opt(browser, &actions[nr_options],
2029                                              &options[nr_options], thread);
2030                 nr_options += add_dso_opt(browser, &actions[nr_options],
2031                                           &options[nr_options], map);
2032                 nr_options += add_map_opt(browser, &actions[nr_options],
2033                                           &options[nr_options],
2034                                           browser->selection ?
2035                                                 browser->selection->map : NULL);
2036                 nr_options += add_socket_opt(browser, &actions[nr_options],
2037                                              &options[nr_options],
2038                                              socked_id);
2039                 /* perf script support */
2040                 if (browser->he_selection) {
2041                         nr_options += add_script_opt(browser,
2042                                                      &actions[nr_options],
2043                                                      &options[nr_options],
2044                                                      thread, NULL);
2045                         /*
2046                          * Note that browser->selection != NULL
2047                          * when browser->he_selection is not NULL,
2048                          * so we don't need to check browser->selection
2049                          * before fetching browser->selection->sym like what
2050                          * we do before fetching browser->selection->map.
2051                          *
2052                          * See hist_browser__show_entry.
2053                          */
2054                         nr_options += add_script_opt(browser,
2055                                                      &actions[nr_options],
2056                                                      &options[nr_options],
2057                                                      NULL, browser->selection->sym);
2058                 }
2059                 nr_options += add_script_opt(browser, &actions[nr_options],
2060                                              &options[nr_options], NULL, NULL);
2061                 nr_options += add_switch_opt(browser, &actions[nr_options],
2062                                              &options[nr_options]);
2063 add_exit_option:
2064                 nr_options += add_exit_opt(browser, &actions[nr_options],
2065                                            &options[nr_options]);
2066
2067                 do {
2068                         struct popup_action *act;
2069
2070                         choice = ui__popup_menu(nr_options, options);
2071                         if (choice == -1 || choice >= nr_options)
2072                                 break;
2073
2074                         act = &actions[choice];
2075                         key = act->fn(browser, act);
2076                 } while (key == 1);
2077
2078                 if (key == K_SWITCH_INPUT_DATA)
2079                         break;
2080         }
2081 out_free_stack:
2082         pstack__delete(browser->pstack);
2083 out:
2084         hist_browser__delete(browser);
2085         free_popup_options(options, MAX_OPTIONS);
2086         return key;
2087 }
2088
2089 struct perf_evsel_menu {
2090         struct ui_browser b;
2091         struct perf_evsel *selection;
2092         bool lost_events, lost_events_warned;
2093         float min_pcnt;
2094         struct perf_env *env;
2095 };
2096
2097 static void perf_evsel_menu__write(struct ui_browser *browser,
2098                                    void *entry, int row)
2099 {
2100         struct perf_evsel_menu *menu = container_of(browser,
2101                                                     struct perf_evsel_menu, b);
2102         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
2103         struct hists *hists = evsel__hists(evsel);
2104         bool current_entry = ui_browser__is_current_entry(browser, row);
2105         unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
2106         const char *ev_name = perf_evsel__name(evsel);
2107         char bf[256], unit;
2108         const char *warn = " ";
2109         size_t printed;
2110
2111         ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
2112                                                        HE_COLORSET_NORMAL);
2113
2114         if (perf_evsel__is_group_event(evsel)) {
2115                 struct perf_evsel *pos;
2116
2117                 ev_name = perf_evsel__group_name(evsel);
2118
2119                 for_each_group_member(pos, evsel) {
2120                         struct hists *pos_hists = evsel__hists(pos);
2121                         nr_events += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
2122                 }
2123         }
2124
2125         nr_events = convert_unit(nr_events, &unit);
2126         printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
2127                            unit, unit == ' ' ? "" : " ", ev_name);
2128         ui_browser__printf(browser, "%s", bf);
2129
2130         nr_events = hists->stats.nr_events[PERF_RECORD_LOST];
2131         if (nr_events != 0) {
2132                 menu->lost_events = true;
2133                 if (!current_entry)
2134                         ui_browser__set_color(browser, HE_COLORSET_TOP);
2135                 nr_events = convert_unit(nr_events, &unit);
2136                 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
2137                                      nr_events, unit, unit == ' ' ? "" : " ");
2138                 warn = bf;
2139         }
2140
2141         ui_browser__write_nstring(browser, warn, browser->width - printed);
2142
2143         if (current_entry)
2144                 menu->selection = evsel;
2145 }
2146
2147 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
2148                                 int nr_events, const char *help,
2149                                 struct hist_browser_timer *hbt)
2150 {
2151         struct perf_evlist *evlist = menu->b.priv;
2152         struct perf_evsel *pos;
2153         const char *title = "Available samples";
2154         int delay_secs = hbt ? hbt->refresh : 0;
2155         int key;
2156
2157         if (ui_browser__show(&menu->b, title,
2158                              "ESC: exit, ENTER|->: Browse histograms") < 0)
2159                 return -1;
2160
2161         while (1) {
2162                 key = ui_browser__run(&menu->b, delay_secs);
2163
2164                 switch (key) {
2165                 case K_TIMER:
2166                         hbt->timer(hbt->arg);
2167
2168                         if (!menu->lost_events_warned && menu->lost_events) {
2169                                 ui_browser__warn_lost_events(&menu->b);
2170                                 menu->lost_events_warned = true;
2171                         }
2172                         continue;
2173                 case K_RIGHT:
2174                 case K_ENTER:
2175                         if (!menu->selection)
2176                                 continue;
2177                         pos = menu->selection;
2178 browse_hists:
2179                         perf_evlist__set_selected(evlist, pos);
2180                         /*
2181                          * Give the calling tool a chance to populate the non
2182                          * default evsel resorted hists tree.
2183                          */
2184                         if (hbt)
2185                                 hbt->timer(hbt->arg);
2186                         key = perf_evsel__hists_browse(pos, nr_events, help,
2187                                                        true, hbt,
2188                                                        menu->min_pcnt,
2189                                                        menu->env);
2190                         ui_browser__show_title(&menu->b, title);
2191                         switch (key) {
2192                         case K_TAB:
2193                                 if (pos->node.next == &evlist->entries)
2194                                         pos = perf_evlist__first(evlist);
2195                                 else
2196                                         pos = perf_evsel__next(pos);
2197                                 goto browse_hists;
2198                         case K_UNTAB:
2199                                 if (pos->node.prev == &evlist->entries)
2200                                         pos = perf_evlist__last(evlist);
2201                                 else
2202                                         pos = perf_evsel__prev(pos);
2203                                 goto browse_hists;
2204                         case K_SWITCH_INPUT_DATA:
2205                         case 'q':
2206                         case CTRL('c'):
2207                                 goto out;
2208                         case K_ESC:
2209                         default:
2210                                 continue;
2211                         }
2212                 case K_LEFT:
2213                         continue;
2214                 case K_ESC:
2215                         if (!ui_browser__dialog_yesno(&menu->b,
2216                                                "Do you really want to exit?"))
2217                                 continue;
2218                         /* Fall thru */
2219                 case 'q':
2220                 case CTRL('c'):
2221                         goto out;
2222                 default:
2223                         continue;
2224                 }
2225         }
2226
2227 out:
2228         ui_browser__hide(&menu->b);
2229         return key;
2230 }
2231
2232 static bool filter_group_entries(struct ui_browser *browser __maybe_unused,
2233                                  void *entry)
2234 {
2235         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
2236
2237         if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
2238                 return true;
2239
2240         return false;
2241 }
2242
2243 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
2244                                            int nr_entries, const char *help,
2245                                            struct hist_browser_timer *hbt,
2246                                            float min_pcnt,
2247                                            struct perf_env *env)
2248 {
2249         struct perf_evsel *pos;
2250         struct perf_evsel_menu menu = {
2251                 .b = {
2252                         .entries    = &evlist->entries,
2253                         .refresh    = ui_browser__list_head_refresh,
2254                         .seek       = ui_browser__list_head_seek,
2255                         .write      = perf_evsel_menu__write,
2256                         .filter     = filter_group_entries,
2257                         .nr_entries = nr_entries,
2258                         .priv       = evlist,
2259                 },
2260                 .min_pcnt = min_pcnt,
2261                 .env = env,
2262         };
2263
2264         ui_helpline__push("Press ESC to exit");
2265
2266         evlist__for_each(evlist, pos) {
2267                 const char *ev_name = perf_evsel__name(pos);
2268                 size_t line_len = strlen(ev_name) + 7;
2269
2270                 if (menu.b.width < line_len)
2271                         menu.b.width = line_len;
2272         }
2273
2274         return perf_evsel_menu__run(&menu, nr_entries, help, hbt);
2275 }
2276
2277 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
2278                                   struct hist_browser_timer *hbt,
2279                                   float min_pcnt,
2280                                   struct perf_env *env)
2281 {
2282         int nr_entries = evlist->nr_entries;
2283
2284 single_entry:
2285         if (nr_entries == 1) {
2286                 struct perf_evsel *first = perf_evlist__first(evlist);
2287
2288                 return perf_evsel__hists_browse(first, nr_entries, help,
2289                                                 false, hbt, min_pcnt,
2290                                                 env);
2291         }
2292
2293         if (symbol_conf.event_group) {
2294                 struct perf_evsel *pos;
2295
2296                 nr_entries = 0;
2297                 evlist__for_each(evlist, pos) {
2298                         if (perf_evsel__is_group_leader(pos))
2299                                 nr_entries++;
2300                 }
2301
2302                 if (nr_entries == 1)
2303                         goto single_entry;
2304         }
2305
2306         return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
2307                                                hbt, min_pcnt, env);
2308 }