tools/perf/ui/browsers/hists.c

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