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 || symbol_conf.has_filter;
  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, const char *help)
 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, help) < 0)
 440                 return -1;
 441
 442         while (1) {
 443                 key = ui_browser__run(&browser->b, delay_secs);
 444
 445                 switch (key) {
 446                 case K_TIMER: {
 447                         u64 nr_entries;
 448                         hbt->timer(hbt->arg);
 449
 450                         if (hist_browser__has_filter(browser))
 451                                 hist_browser__update_nr_entries(browser);
 452
 453                         nr_entries = hist_browser__nr_entries(browser);
 454                         ui_browser__update_nr_entries(&browser->b, nr_entries);
 455
 456                         if (browser->hists->stats.nr_lost_warned !=
 457                             browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
 458                                 browser->hists->stats.nr_lost_warned =
 459                                         browser->hists->stats.nr_events[PERF_RECORD_LOST];
 460                                 ui_browser__warn_lost_events(&browser->b);
 461                         }
 462
 463                         hists__browser_title(browser->hists,
 464                                              hbt, title, sizeof(title));
 465                         ui_browser__show_title(&browser->b, title);
 466                         continue;
 467                 }
 468                 case 'D': { /* Debug */
 469                         static int seq;
 470                         struct hist_entry *h = rb_entry(browser->b.top,
 471                                                         struct hist_entry, rb_node);
 472                         ui_helpline__pop();
 473                         ui_helpline__fpush("%d: nr_ent=(%d,%d), rows=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
 474                                            seq++, browser->b.nr_entries,
 475                                            browser->hists->nr_entries,
 476                                            browser->b.rows,
 477                                            browser->b.index,
 478                                            browser->b.top_idx,
 479                                            h->row_offset, h->nr_rows);
 480                 }
 481                         break;
 482                 case 'C':
 483                         /* Collapse the whole world. */
 484                         hist_browser__set_folding(browser, false);
 485                         break;
 486                 case 'E':
 487                         /* Expand the whole world. */
 488                         hist_browser__set_folding(browser, true);
 489                         break;
 490                 case 'H':
 491                         browser->show_headers = !browser->show_headers;
 492                         hist_browser__update_rows(browser);
 493                         break;
 494                 case K_ENTER:
 495                         if (hist_browser__toggle_fold(browser))
 496                                 break;
 497                         /* fall thru */
 498                 default:
 499                         goto out;
 500                 }
 501         }
 502 out:
 503         ui_browser__hide(&browser->b);
 504         return key;
 505 }
 506
 507 struct callchain_print_arg {
 508         /* for hists browser */
 509         off_t   row_offset;
 510         bool    is_current_entry;
 511
 512         /* for file dump */
 513         FILE    *fp;
 514         int     printed;
 515 };
 516
 517 typedef void (*print_callchain_entry_fn)(struct hist_browser *browser,
 518                                          struct callchain_list *chain,
 519                                          const char *str, int offset,
 520                                          unsigned short row,
 521                                          struct callchain_print_arg *arg);
 522
 523 static void hist_browser__show_callchain_entry(struct hist_browser *browser,
 524                                                struct callchain_list *chain,
 525                                                const char *str, int offset,
 526                                                unsigned short row,
 527                                                struct callchain_print_arg *arg)
 528 {
 529         int color, width;
 530         char folded_sign = callchain_list__folded(chain);
 531         bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;
 532
 533         color = HE_COLORSET_NORMAL;
 534         width = browser->b.width - (offset + 2);
 535         if (ui_browser__is_current_entry(&browser->b, row)) {
 536                 browser->selection = &chain->ms;
 537                 color = HE_COLORSET_SELECTED;
 538                 arg->is_current_entry = true;
 539         }
 540
 541         ui_browser__set_color(&browser->b, color);
 542         hist_browser__gotorc(browser, row, 0);
 543         slsmg_write_nstring(" ", offset);
 544         slsmg_printf("%c", folded_sign);
 545         ui_browser__write_graph(&browser->b, show_annotated ? SLSMG_RARROW_CHAR : ' ');
 546         slsmg_write_nstring(str, width);
 547 }
 548
 549 static void hist_browser__fprintf_callchain_entry(struct hist_browser *b __maybe_unused,
 550                                                   struct callchain_list *chain,
 551                                                   const char *str, int offset,
 552                                                   unsigned short row __maybe_unused,
 553                                                   struct callchain_print_arg *arg)
 554 {
 555         char folded_sign = callchain_list__folded(chain);
 556
 557         arg->printed += fprintf(arg->fp, "%*s%c %s\n", offset, " ",
 558                                 folded_sign, str);
 559 }
 560
 561 typedef bool (*check_output_full_fn)(struct hist_browser *browser,
 562                                      unsigned short row);
 563
 564 static bool hist_browser__check_output_full(struct hist_browser *browser,
 565                                             unsigned short row)
 566 {
 567         return browser->b.rows == row;
 568 }
 569
 570 static bool hist_browser__check_dump_full(struct hist_browser *browser __maybe_unused,
 571                                           unsigned short row __maybe_unused)
 572 {
 573         return false;
 574 }
 575
 576 #define LEVEL_OFFSET_STEP 3
 577
 578 static int hist_browser__show_callchain(struct hist_browser *browser,
 579                                         struct rb_root *root, int level,
 580                                         unsigned short row, u64 total,
 581                                         print_callchain_entry_fn print,
 582                                         struct callchain_print_arg *arg,
 583                                         check_output_full_fn is_output_full)
 584 {
 585         struct rb_node *node;
 586         int first_row = row, offset = level * LEVEL_OFFSET_STEP;
 587         u64 new_total;
 588         bool need_percent;
 589
 590         node = rb_first(root);
 591         need_percent = node && rb_next(node);
 592
 593         while (node) {
 594                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 595                 struct rb_node *next = rb_next(node);
 596                 u64 cumul = callchain_cumul_hits(child);
 597                 struct callchain_list *chain;
 598                 char folded_sign = ' ';
 599                 int first = true;
 600                 int extra_offset = 0;
 601
 602                 list_for_each_entry(chain, &child->val, list) {
 603                         char bf[1024], *alloc_str;
 604                         const char *str;
 605                         bool was_first = first;
 606
 607                         if (first)
 608                                 first = false;
 609                         else if (need_percent)
 610                                 extra_offset = LEVEL_OFFSET_STEP;
 611
 612                         folded_sign = callchain_list__folded(chain);
 613                         if (arg->row_offset != 0) {
 614                                 arg->row_offset--;
 615                                 goto do_next;
 616                         }
 617
 618                         alloc_str = NULL;
 619                         str = callchain_list__sym_name(chain, bf, sizeof(bf),
 620                                                        browser->show_dso);
 621
 622                         if (was_first && need_percent) {
 623                                 double percent = cumul * 100.0 / total;
 624
 625                                 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
 626                                         str = "Not enough memory!";
 627                                 else
 628                                         str = alloc_str;
 629                         }
 630
 631                         print(browser, chain, str, offset + extra_offset, row, arg);
 632
 633                         free(alloc_str);
 634
 635                         if (is_output_full(browser, ++row))
 636                                 goto out;
 637 do_next:
 638                         if (folded_sign == '+')
 639                                 break;
 640                 }
 641
 642                 if (folded_sign == '-') {
 643                         const int new_level = level + (extra_offset ? 2 : 1);
 644
 645                         if (callchain_param.mode == CHAIN_GRAPH_REL)
 646                                 new_total = child->children_hit;
 647                         else
 648                                 new_total = total;
 649
 650                         row += hist_browser__show_callchain(browser, &child->rb_root,
 651                                                             new_level, row, new_total,
 652                                                             print, arg, is_output_full);
 653                 }
 654                 if (is_output_full(browser, row))
 655                         break;
 656                 node = next;
 657         }
 658 out:
 659         return row - first_row;
 660 }
 661
 662 struct hpp_arg {
 663         struct ui_browser *b;
 664         char folded_sign;
 665         bool current_entry;
 666 };
 667
 668 static int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
 669 {
 670         struct hpp_arg *arg = hpp->ptr;
 671         int ret, len;
 672         va_list args;
 673         double percent;
 674
 675         va_start(args, fmt);
 676         len = va_arg(args, int);
 677         percent = va_arg(args, double);
 678         va_end(args);
 679
 680         ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
 681
 682         ret = scnprintf(hpp->buf, hpp->size, fmt, len, percent);
 683         slsmg_printf("%s", hpp->buf);
 684
 685         advance_hpp(hpp, ret);
 686         return ret;
 687 }
 688
 689 #define __HPP_COLOR_PERCENT_FN(_type, _field)                           \
 690 static u64 __hpp_get_##_field(struct hist_entry *he)                    \
 691 {                                                                       \
 692         return he->stat._field;                                         \
 693 }                                                                       \
 694                                                                         \
 695 static int                                                              \
 696 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
 697                                 struct perf_hpp *hpp,                   \
 698                                 struct hist_entry *he)                  \
 699 {                                                                       \
 700         return hpp__fmt(fmt, hpp, he, __hpp_get_##_field, " %*.2f%%",   \
 701                         __hpp__slsmg_color_printf, true);               \
 702 }
 703
 704 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                       \
 705 static u64 __hpp_get_acc_##_field(struct hist_entry *he)                \
 706 {                                                                       \
 707         return he->stat_acc->_field;                                    \
 708 }                                                                       \
 709                                                                         \
 710 static int                                                              \
 711 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
 712                                 struct perf_hpp *hpp,                   \
 713                                 struct hist_entry *he)                  \
 714 {                                                                       \
 715         if (!symbol_conf.cumulate_callchain) {                          \
 716                 int len = fmt->user_len ?: fmt->len;                    \
 717                 int ret = scnprintf(hpp->buf, hpp->size,                \
 718                                     "%*s", len, "N/A");                 \
 719                 slsmg_printf("%s", hpp->buf);                           \
 720                                                                         \
 721                 return ret;                                             \
 722         }                                                               \
 723         return hpp__fmt(fmt, hpp, he, __hpp_get_acc_##_field,           \
 724                         " %*.2f%%", __hpp__slsmg_color_printf, true);   \
 725 }
 726
 727 __HPP_COLOR_PERCENT_FN(overhead, period)
 728 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
 729 __HPP_COLOR_PERCENT_FN(overhead_us, period_us)
 730 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
 731 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
 732 __HPP_COLOR_ACC_PERCENT_FN(overhead_acc, period)
 733
 734 #undef __HPP_COLOR_PERCENT_FN
 735 #undef __HPP_COLOR_ACC_PERCENT_FN
 736
 737 void hist_browser__init_hpp(void)
 738 {
 739         perf_hpp__format[PERF_HPP__OVERHEAD].color =
 740                                 hist_browser__hpp_color_overhead;
 741         perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
 742                                 hist_browser__hpp_color_overhead_sys;
 743         perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
 744                                 hist_browser__hpp_color_overhead_us;
 745         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
 746                                 hist_browser__hpp_color_overhead_guest_sys;
 747         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
 748                                 hist_browser__hpp_color_overhead_guest_us;
 749         perf_hpp__format[PERF_HPP__OVERHEAD_ACC].color =
 750                                 hist_browser__hpp_color_overhead_acc;
 751 }
 752
 753 static int hist_browser__show_entry(struct hist_browser *browser,
 754                                     struct hist_entry *entry,
 755                                     unsigned short row)
 756 {
 757         char s[256];
 758         int printed = 0;
 759         int width = browser->b.width;
 760         char folded_sign = ' ';
 761         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
 762         off_t row_offset = entry->row_offset;
 763         bool first = true;
 764         struct perf_hpp_fmt *fmt;
 765
 766         if (current_entry) {
 767                 browser->he_selection = entry;
 768                 browser->selection = &entry->ms;
 769         }
 770
 771         if (symbol_conf.use_callchain) {
 772                 hist_entry__init_have_children(entry);
 773                 folded_sign = hist_entry__folded(entry);
 774         }
 775
 776         if (row_offset == 0) {
 777                 struct hpp_arg arg = {
 778                         .b              = &browser->b,
 779                         .folded_sign    = folded_sign,
 780                         .current_entry  = current_entry,
 781                 };
 782                 struct perf_hpp hpp = {
 783                         .buf            = s,
 784                         .size           = sizeof(s),
 785                         .ptr            = &arg,
 786                 };
 787
 788                 hist_browser__gotorc(browser, row, 0);
 789
 790                 perf_hpp__for_each_format(fmt) {
 791                         if (perf_hpp__should_skip(fmt))
 792                                 continue;
 793
 794                         if (current_entry && browser->b.navkeypressed) {
 795                                 ui_browser__set_color(&browser->b,
 796                                                       HE_COLORSET_SELECTED);
 797                         } else {
 798                                 ui_browser__set_color(&browser->b,
 799                                                       HE_COLORSET_NORMAL);
 800                         }
 801
 802                         if (first) {
 803                                 if (symbol_conf.use_callchain) {
 804                                         slsmg_printf("%c ", folded_sign);
 805                                         width -= 2;
 806                                 }
 807                                 first = false;
 808                         } else {
 809                                 slsmg_printf("  ");
 810                                 width -= 2;
 811                         }
 812
 813                         if (fmt->color) {
 814                                 width -= fmt->color(fmt, &hpp, entry);
 815                         } else {
 816                                 width -= fmt->entry(fmt, &hpp, entry);
 817                                 slsmg_printf("%s", s);
 818                         }
 819                 }
 820
 821                 /* The scroll bar isn't being used */
 822                 if (!browser->b.navkeypressed)
 823                         width += 1;
 824
 825                 slsmg_write_nstring("", width);
 826
 827                 ++row;
 828                 ++printed;
 829         } else
 830                 --row_offset;
 831
 832         if (folded_sign == '-' && row != browser->b.rows) {
 833                 u64 total = hists__total_period(entry->hists);
 834                 struct callchain_print_arg arg = {
 835                         .row_offset = row_offset,
 836                         .is_current_entry = current_entry,
 837                 };
 838
 839                 if (callchain_param.mode == CHAIN_GRAPH_REL) {
 840                         if (symbol_conf.cumulate_callchain)
 841                                 total = entry->stat_acc->period;
 842                         else
 843                                 total = entry->stat.period;
 844                 }
 845
 846                 printed += hist_browser__show_callchain(browser,
 847                                         &entry->sorted_chain, 1, row, total,
 848                                         hist_browser__show_callchain_entry, &arg,
 849                                         hist_browser__check_output_full);
 850
 851                 if (arg.is_current_entry)
 852                         browser->he_selection = entry;
 853         }
 854
 855         return printed;
 856 }
 857
 858 static int advance_hpp_check(struct perf_hpp *hpp, int inc)
 859 {
 860         advance_hpp(hpp, inc);
 861         return hpp->size <= 0;
 862 }
 863
 864 static int hists__scnprintf_headers(char *buf, size_t size, struct hists *hists)
 865 {
 866         struct perf_hpp dummy_hpp = {
 867                 .buf    = buf,
 868                 .size   = size,
 869         };
 870         struct perf_hpp_fmt *fmt;
 871         size_t ret = 0;
 872
 873         if (symbol_conf.use_callchain) {
 874                 ret = scnprintf(buf, size, "  ");
 875                 if (advance_hpp_check(&dummy_hpp, ret))
 876                         return ret;
 877         }
 878
 879         perf_hpp__for_each_format(fmt) {
 880                 if (perf_hpp__should_skip(fmt))
 881                         continue;
 882
 883                 ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
 884                 if (advance_hpp_check(&dummy_hpp, ret))
 885                         break;
 886
 887                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
 888                 if (advance_hpp_check(&dummy_hpp, ret))
 889                         break;
 890         }
 891
 892         return ret;
 893 }
 894
 895 static void hist_browser__show_headers(struct hist_browser *browser)
 896 {
 897         char headers[1024];
 898
 899         hists__scnprintf_headers(headers, sizeof(headers), browser->hists);
 900         ui_browser__gotorc(&browser->b, 0, 0);
 901         ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
 902         slsmg_write_nstring(headers, browser->b.width + 1);
 903 }
 904
 905 static void ui_browser__hists_init_top(struct ui_browser *browser)
 906 {
 907         if (browser->top == NULL) {
 908                 struct hist_browser *hb;
 909
 910                 hb = container_of(browser, struct hist_browser, b);
 911                 browser->top = rb_first(&hb->hists->entries);
 912         }
 913 }
 914
 915 static unsigned int hist_browser__refresh(struct ui_browser *browser)
 916 {
 917         unsigned row = 0;
 918         u16 header_offset = 0;
 919         struct rb_node *nd;
 920         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
 921
 922         if (hb->show_headers) {
 923                 hist_browser__show_headers(hb);
 924                 header_offset = 1;
 925         }
 926
 927         ui_browser__hists_init_top(browser);
 928
 929         for (nd = browser->top; nd; nd = rb_next(nd)) {
 930                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 931                 float percent;
 932
 933                 if (h->filtered)
 934                         continue;
 935
 936                 percent = hist_entry__get_percent_limit(h);
 937                 if (percent < hb->min_pcnt)
 938                         continue;
 939
 940                 row += hist_browser__show_entry(hb, h, row);
 941                 if (row == browser->rows)
 942                         break;
 943         }
 944
 945         return row + header_offset;
 946 }
 947
 948 static struct rb_node *hists__filter_entries(struct rb_node *nd,
 949                                              float min_pcnt)
 950 {
 951         while (nd != NULL) {
 952                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 953                 float percent = hist_entry__get_percent_limit(h);
 954
 955                 if (!h->filtered && percent >= min_pcnt)
 956                         return nd;
 957
 958                 nd = rb_next(nd);
 959         }
 960
 961         return NULL;
 962 }
 963
 964 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
 965                                                   float min_pcnt)
 966 {
 967         while (nd != NULL) {
 968                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 969                 float percent = hist_entry__get_percent_limit(h);
 970
 971                 if (!h->filtered && percent >= min_pcnt)
 972                         return nd;
 973
 974                 nd = rb_prev(nd);
 975         }
 976
 977         return NULL;
 978 }
 979
 980 static void ui_browser__hists_seek(struct ui_browser *browser,
 981                                    off_t offset, int whence)
 982 {
 983         struct hist_entry *h;
 984         struct rb_node *nd;
 985         bool first = true;
 986         struct hist_browser *hb;
 987
 988         hb = container_of(browser, struct hist_browser, b);
 989
 990         if (browser->nr_entries == 0)
 991                 return;
 992
 993         ui_browser__hists_init_top(browser);
 994
 995         switch (whence) {
 996         case SEEK_SET:
 997                 nd = hists__filter_entries(rb_first(browser->entries),
 998                                            hb->min_pcnt);
 999                 break;
1000         case SEEK_CUR:
1001                 nd = browser->top;
1002                 goto do_offset;
1003         case SEEK_END:
1004                 nd = hists__filter_prev_entries(rb_last(browser->entries),
1005                                                 hb->min_pcnt);
1006                 first = false;
1007                 break;
1008         default:
1009                 return;
1010         }
1011
1012         /*
1013          * Moves not relative to the first visible entry invalidates its
1014          * row_offset:
1015          */
1016         h = rb_entry(browser->top, struct hist_entry, rb_node);
1017         h->row_offset = 0;
1018
1019         /*
1020          * Here we have to check if nd is expanded (+), if it is we can't go
1021          * the next top level hist_entry, instead we must compute an offset of
1022          * what _not_ to show and not change the first visible entry.
1023          *
1024          * This offset increments when we are going from top to bottom and
1025          * decreases when we're going from bottom to top.
1026          *
1027          * As we don't have backpointers to the top level in the callchains
1028          * structure, we need to always print the whole hist_entry callchain,
1029          * skipping the first ones that are before the first visible entry
1030          * and stop when we printed enough lines to fill the screen.
1031          */
1032 do_offset:
1033         if (offset > 0) {
1034                 do {
1035                         h = rb_entry(nd, struct hist_entry, rb_node);
1036                         if (h->unfolded) {
1037                                 u16 remaining = h->nr_rows - h->row_offset;
1038                                 if (offset > remaining) {
1039                                         offset -= remaining;
1040                                         h->row_offset = 0;
1041                                 } else {
1042                                         h->row_offset += offset;
1043                                         offset = 0;
1044                                         browser->top = nd;
1045                                         break;
1046                                 }
1047                         }
1048                         nd = hists__filter_entries(rb_next(nd), hb->min_pcnt);
1049                         if (nd == NULL)
1050                                 break;
1051                         --offset;
1052                         browser->top = nd;
1053                 } while (offset != 0);
1054         } else if (offset < 0) {
1055                 while (1) {
1056                         h = rb_entry(nd, struct hist_entry, rb_node);
1057                         if (h->unfolded) {
1058                                 if (first) {
1059                                         if (-offset > h->row_offset) {
1060                                                 offset += h->row_offset;
1061                                                 h->row_offset = 0;
1062                                         } else {
1063                                                 h->row_offset += offset;
1064                                                 offset = 0;
1065                                                 browser->top = nd;
1066                                                 break;
1067                                         }
1068                                 } else {
1069                                         if (-offset > h->nr_rows) {
1070                                                 offset += h->nr_rows;
1071                                                 h->row_offset = 0;
1072                                         } else {
1073                                                 h->row_offset = h->nr_rows + offset;
1074                                                 offset = 0;
1075                                                 browser->top = nd;
1076                                                 break;
1077                                         }
1078                                 }
1079                         }
1080
1081                         nd = hists__filter_prev_entries(rb_prev(nd),
1082                                                         hb->min_pcnt);
1083                         if (nd == NULL)
1084                                 break;
1085                         ++offset;
1086                         browser->top = nd;
1087                         if (offset == 0) {
1088                                 /*
1089                                  * Last unfiltered hist_entry, check if it is
1090                                  * unfolded, if it is then we should have
1091                                  * row_offset at its last entry.
1092                                  */
1093                                 h = rb_entry(nd, struct hist_entry, rb_node);
1094                                 if (h->unfolded)
1095                                         h->row_offset = h->nr_rows;
1096                                 break;
1097                         }
1098                         first = false;
1099                 }
1100         } else {
1101                 browser->top = nd;
1102                 h = rb_entry(nd, struct hist_entry, rb_node);
1103                 h->row_offset = 0;
1104         }
1105 }
1106
1107 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
1108                                            struct hist_entry *he, FILE *fp)
1109 {
1110         u64 total = hists__total_period(he->hists);
1111         struct callchain_print_arg arg  = {
1112                 .fp = fp,
1113         };
1114
1115         if (symbol_conf.cumulate_callchain)
1116                 total = he->stat_acc->period;
1117
1118         hist_browser__show_callchain(browser, &he->sorted_chain, 1, 0, total,
1119                                      hist_browser__fprintf_callchain_entry, &arg,
1120                                      hist_browser__check_dump_full);
1121         return arg.printed;
1122 }
1123
1124 static int hist_browser__fprintf_entry(struct hist_browser *browser,
1125                                        struct hist_entry *he, FILE *fp)
1126 {
1127         char s[8192];
1128         int printed = 0;
1129         char folded_sign = ' ';
1130         struct perf_hpp hpp = {
1131                 .buf = s,
1132                 .size = sizeof(s),
1133         };
1134         struct perf_hpp_fmt *fmt;
1135         bool first = true;
1136         int ret;
1137
1138         if (symbol_conf.use_callchain)
1139                 folded_sign = hist_entry__folded(he);
1140
1141         if (symbol_conf.use_callchain)
1142                 printed += fprintf(fp, "%c ", folded_sign);
1143
1144         perf_hpp__for_each_format(fmt) {
1145                 if (perf_hpp__should_skip(fmt))
1146                         continue;
1147
1148                 if (!first) {
1149                         ret = scnprintf(hpp.buf, hpp.size, "  ");
1150                         advance_hpp(&hpp, ret);
1151                 } else
1152                         first = false;
1153
1154                 ret = fmt->entry(fmt, &hpp, he);
1155                 advance_hpp(&hpp, ret);
1156         }
1157         printed += fprintf(fp, "%s\n", rtrim(s));
1158
1159         if (folded_sign == '-')
1160                 printed += hist_browser__fprintf_callchain(browser, he, fp);
1161
1162         return printed;
1163 }
1164
1165 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
1166 {
1167         struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
1168                                                    browser->min_pcnt);
1169         int printed = 0;
1170
1171         while (nd) {
1172                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1173
1174                 printed += hist_browser__fprintf_entry(browser, h, fp);
1175                 nd = hists__filter_entries(rb_next(nd), browser->min_pcnt);
1176         }
1177
1178         return printed;
1179 }
1180
1181 static int hist_browser__dump(struct hist_browser *browser)
1182 {
1183         char filename[64];
1184         FILE *fp;
1185
1186         while (1) {
1187                 scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
1188                 if (access(filename, F_OK))
1189                         break;
1190                 /*
1191                  * XXX: Just an arbitrary lazy upper limit
1192                  */
1193                 if (++browser->print_seq == 8192) {
1194                         ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
1195                         return -1;
1196                 }
1197         }
1198
1199         fp = fopen(filename, "w");
1200         if (fp == NULL) {
1201                 char bf[64];
1202                 const char *err = strerror_r(errno, bf, sizeof(bf));
1203                 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
1204                 return -1;
1205         }
1206
1207         ++browser->print_seq;
1208         hist_browser__fprintf(browser, fp);
1209         fclose(fp);
1210         ui_helpline__fpush("%s written!", filename);
1211
1212         return 0;
1213 }
1214
1215 static struct hist_browser *hist_browser__new(struct hists *hists,
1216                                               struct hist_browser_timer *hbt,
1217                                               struct perf_session_env *env)
1218 {
1219         struct hist_browser *browser = zalloc(sizeof(*browser));
1220
1221         if (browser) {
1222                 browser->hists = hists;
1223                 browser->b.refresh = hist_browser__refresh;
1224                 browser->b.refresh_dimensions = hist_browser__refresh_dimensions;
1225                 browser->b.seek = ui_browser__hists_seek;
1226                 browser->b.use_navkeypressed = true;
1227                 browser->show_headers = symbol_conf.show_hist_headers;
1228                 browser->hbt = hbt;
1229                 browser->env = env;
1230         }
1231
1232         return browser;
1233 }
1234
1235 static void hist_browser__delete(struct hist_browser *browser)
1236 {
1237         free(browser);
1238 }
1239
1240 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
1241 {
1242         return browser->he_selection;
1243 }
1244
1245 static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
1246 {
1247         return browser->he_selection->thread;
1248 }
1249
1250 /* Check whether the browser is for 'top' or 'report' */
1251 static inline bool is_report_browser(void *timer)
1252 {
1253         return timer == NULL;
1254 }
1255
1256 static int hists__browser_title(struct hists *hists,
1257                                 struct hist_browser_timer *hbt,
1258                                 char *bf, size_t size)
1259 {
1260         char unit;
1261         int printed;
1262         const struct dso *dso = hists->dso_filter;
1263         const struct thread *thread = hists->thread_filter;
1264         unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
1265         u64 nr_events = hists->stats.total_period;
1266         struct perf_evsel *evsel = hists_to_evsel(hists);
1267         const char *ev_name = perf_evsel__name(evsel);
1268         char buf[512];
1269         size_t buflen = sizeof(buf);
1270
1271         if (symbol_conf.filter_relative) {
1272                 nr_samples = hists->stats.nr_non_filtered_samples;
1273                 nr_events = hists->stats.total_non_filtered_period;
1274         }
1275
1276         if (perf_evsel__is_group_event(evsel)) {
1277                 struct perf_evsel *pos;
1278
1279                 perf_evsel__group_desc(evsel, buf, buflen);
1280                 ev_name = buf;
1281
1282                 for_each_group_member(pos, evsel) {
1283                         struct hists *pos_hists = evsel__hists(pos);
1284
1285                         if (symbol_conf.filter_relative) {
1286                                 nr_samples += pos_hists->stats.nr_non_filtered_samples;
1287                                 nr_events += pos_hists->stats.total_non_filtered_period;
1288                         } else {
1289                                 nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
1290                                 nr_events += pos_hists->stats.total_period;
1291                         }
1292                 }
1293         }
1294
1295         nr_samples = convert_unit(nr_samples, &unit);
1296         printed = scnprintf(bf, size,
1297                            "Samples: %lu%c of event '%s', Event count (approx.): %" PRIu64,
1298                            nr_samples, unit, ev_name, nr_events);
1299
1300
1301         if (hists->uid_filter_str)
1302                 printed += snprintf(bf + printed, size - printed,
1303                                     ", UID: %s", hists->uid_filter_str);
1304         if (thread)
1305                 printed += scnprintf(bf + printed, size - printed,
1306                                     ", Thread: %s(%d)",
1307                                      (thread->comm_set ? thread__comm_str(thread) : ""),
1308                                     thread->tid);
1309         if (dso)
1310                 printed += scnprintf(bf + printed, size - printed,
1311                                     ", DSO: %s", dso->short_name);
1312         if (!is_report_browser(hbt)) {
1313                 struct perf_top *top = hbt->arg;
1314
1315                 if (top->zero)
1316                         printed += scnprintf(bf + printed, size - printed, " [z]");
1317         }
1318
1319         return printed;
1320 }
1321
1322 static inline void free_popup_options(char **options, int n)
1323 {
1324         int i;
1325
1326         for (i = 0; i < n; ++i)
1327                 zfree(&options[i]);
1328 }
1329
1330 /*
1331  * Only runtime switching of perf data file will make "input_name" point
1332  * to a malloced buffer. So add "is_input_name_malloced" flag to decide
1333  * whether we need to call free() for current "input_name" during the switch.
1334  */
1335 static bool is_input_name_malloced = false;
1336
1337 static int switch_data_file(void)
1338 {
1339         char *pwd, *options[32], *abs_path[32], *tmp;
1340         DIR *pwd_dir;
1341         int nr_options = 0, choice = -1, ret = -1;
1342         struct dirent *dent;
1343
1344         pwd = getenv("PWD");
1345         if (!pwd)
1346                 return ret;
1347
1348         pwd_dir = opendir(pwd);
1349         if (!pwd_dir)
1350                 return ret;
1351
1352         memset(options, 0, sizeof(options));
1353         memset(options, 0, sizeof(abs_path));
1354
1355         while ((dent = readdir(pwd_dir))) {
1356                 char path[PATH_MAX];
1357                 u64 magic;
1358                 char *name = dent->d_name;
1359                 FILE *file;
1360
1361                 if (!(dent->d_type == DT_REG))
1362                         continue;
1363
1364                 snprintf(path, sizeof(path), "%s/%s", pwd, name);
1365
1366                 file = fopen(path, "r");
1367                 if (!file)
1368                         continue;
1369
1370                 if (fread(&magic, 1, 8, file) < 8)
1371                         goto close_file_and_continue;
1372
1373                 if (is_perf_magic(magic)) {
1374                         options[nr_options] = strdup(name);
1375                         if (!options[nr_options])
1376                                 goto close_file_and_continue;
1377
1378                         abs_path[nr_options] = strdup(path);
1379                         if (!abs_path[nr_options]) {
1380                                 zfree(&options[nr_options]);
1381                                 ui__warning("Can't search all data files due to memory shortage.\n");
1382                                 fclose(file);
1383                                 break;
1384                         }
1385
1386                         nr_options++;
1387                 }
1388
1389 close_file_and_continue:
1390                 fclose(file);
1391                 if (nr_options >= 32) {
1392                         ui__warning("Too many perf data files in PWD!\n"
1393                                     "Only the first 32 files will be listed.\n");
1394                         break;
1395                 }
1396         }
1397         closedir(pwd_dir);
1398
1399         if (nr_options) {
1400                 choice = ui__popup_menu(nr_options, options);
1401                 if (choice < nr_options && choice >= 0) {
1402                         tmp = strdup(abs_path[choice]);
1403                         if (tmp) {
1404                                 if (is_input_name_malloced)
1405                                         free((void *)input_name);
1406                                 input_name = tmp;
1407                                 is_input_name_malloced = true;
1408                                 ret = 0;
1409                         } else
1410                                 ui__warning("Data switch failed due to memory shortage!\n");
1411                 }
1412         }
1413
1414         free_popup_options(options, nr_options);
1415         free_popup_options(abs_path, nr_options);
1416         return ret;
1417 }
1418
1419 struct popup_action {
1420         struct thread           *thread;
1421         struct dso              *dso;
1422         struct map_symbol       ms;
1423
1424         int (*fn)(struct hist_browser *browser, struct popup_action *act);
1425 };
1426
1427 static int
1428 do_annotate(struct hist_browser *browser, struct popup_action *act)
1429 {
1430         struct perf_evsel *evsel;
1431         struct annotation *notes;
1432         struct hist_entry *he;
1433         int err;
1434
1435         if (!objdump_path && perf_session_env__lookup_objdump(browser->env))
1436                 return 0;
1437
1438         notes = symbol__annotation(act->ms.sym);
1439         if (!notes->src)
1440                 return 0;
1441
1442         evsel = hists_to_evsel(browser->hists);
1443         err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt);
1444         he = hist_browser__selected_entry(browser);
1445         /*
1446          * offer option to annotate the other branch source or target
1447          * (if they exists) when returning from annotate
1448          */
1449         if ((err == 'q' || err == CTRL('c')) && he->branch_info)
1450                 return 1;
1451
1452         ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
1453         if (err)
1454                 ui_browser__handle_resize(&browser->b);
1455         return 0;
1456 }
1457
1458 static int
1459 add_annotate_opt(struct hist_browser *browser __maybe_unused,
1460                  struct popup_action *act, char **optstr,
1461                  struct map *map, struct symbol *sym)
1462 {
1463         if (sym == NULL || map->dso->annotate_warned)
1464                 return 0;
1465
1466         if (asprintf(optstr, "Annotate %s", sym->name) < 0)
1467                 return 0;
1468
1469         act->ms.map = map;
1470         act->ms.sym = sym;
1471         act->fn = do_annotate;
1472         return 1;
1473 }
1474
1475 static int
1476 do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
1477 {
1478         struct thread *thread = act->thread;
1479
1480         if (browser->hists->thread_filter) {
1481                 pstack__remove(browser->pstack, &browser->hists->thread_filter);
1482                 perf_hpp__set_elide(HISTC_THREAD, false);
1483                 thread__zput(browser->hists->thread_filter);
1484                 ui_helpline__pop();
1485         } else {
1486                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1487                                    thread->comm_set ? thread__comm_str(thread) : "",
1488                                    thread->tid);
1489                 browser->hists->thread_filter = thread__get(thread);
1490                 perf_hpp__set_elide(HISTC_THREAD, false);
1491                 pstack__push(browser->pstack, &browser->hists->thread_filter);
1492         }
1493
1494         hists__filter_by_thread(browser->hists);
1495         hist_browser__reset(browser);
1496         return 0;
1497 }
1498
1499 static int
1500 add_thread_opt(struct hist_browser *browser, struct popup_action *act,
1501                char **optstr, struct thread *thread)
1502 {
1503         if (thread == NULL)
1504                 return 0;
1505
1506         if (asprintf(optstr, "Zoom %s %s(%d) thread",
1507                      browser->hists->thread_filter ? "out of" : "into",
1508                      thread->comm_set ? thread__comm_str(thread) : "",
1509                      thread->tid) < 0)
1510                 return 0;
1511
1512         act->thread = thread;
1513         act->fn = do_zoom_thread;
1514         return 1;
1515 }
1516
1517 static int
1518 do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
1519 {
1520         struct dso *dso = act->dso;
1521
1522         if (browser->hists->dso_filter) {
1523                 pstack__remove(browser->pstack, &browser->hists->dso_filter);
1524                 perf_hpp__set_elide(HISTC_DSO, false);
1525                 browser->hists->dso_filter = NULL;
1526                 ui_helpline__pop();
1527         } else {
1528                 if (dso == NULL)
1529                         return 0;
1530                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1531                                    dso->kernel ? "the Kernel" : dso->short_name);
1532                 browser->hists->dso_filter = dso;
1533                 perf_hpp__set_elide(HISTC_DSO, true);
1534                 pstack__push(browser->pstack, &browser->hists->dso_filter);
1535         }
1536
1537         hists__filter_by_dso(browser->hists);
1538         hist_browser__reset(browser);
1539         return 0;
1540 }
1541
1542 static int
1543 add_dso_opt(struct hist_browser *browser, struct popup_action *act,
1544             char **optstr, struct dso *dso)
1545 {
1546         if (dso == NULL)
1547                 return 0;
1548
1549         if (asprintf(optstr, "Zoom %s %s DSO",
1550                      browser->hists->dso_filter ? "out of" : "into",
1551                      dso->kernel ? "the Kernel" : dso->short_name) < 0)
1552                 return 0;
1553
1554         act->dso = dso;
1555         act->fn = do_zoom_dso;
1556         return 1;
1557 }
1558
1559 static int
1560 do_browse_map(struct hist_browser *browser __maybe_unused,
1561               struct popup_action *act)
1562 {
1563         map__browse(act->ms.map);
1564         return 0;
1565 }
1566
1567 static int
1568 add_map_opt(struct hist_browser *browser __maybe_unused,
1569             struct popup_action *act, char **optstr, struct map *map)
1570 {
1571         if (map == NULL)
1572                 return 0;
1573
1574         if (asprintf(optstr, "Browse map details") < 0)
1575                 return 0;
1576
1577         act->ms.map = map;
1578         act->fn = do_browse_map;
1579         return 1;
1580 }
1581
1582 static int
1583 do_run_script(struct hist_browser *browser __maybe_unused,
1584               struct popup_action *act)
1585 {
1586         char script_opt[64];
1587         memset(script_opt, 0, sizeof(script_opt));
1588
1589         if (act->thread) {
1590                 scnprintf(script_opt, sizeof(script_opt), " -c %s ",
1591                           thread__comm_str(act->thread));
1592         } else if (act->ms.sym) {
1593                 scnprintf(script_opt, sizeof(script_opt), " -S %s ",
1594                           act->ms.sym->name);
1595         }
1596
1597         script_browse(script_opt);
1598         return 0;
1599 }
1600
1601 static int
1602 add_script_opt(struct hist_browser *browser __maybe_unused,
1603                struct popup_action *act, char **optstr,
1604                struct thread *thread, struct symbol *sym)
1605 {
1606         if (thread) {
1607                 if (asprintf(optstr, "Run scripts for samples of thread [%s]",
1608                              thread__comm_str(thread)) < 0)
1609                         return 0;
1610         } else if (sym) {
1611                 if (asprintf(optstr, "Run scripts for samples of symbol [%s]",
1612                              sym->name) < 0)
1613                         return 0;
1614         } else {
1615                 if (asprintf(optstr, "Run scripts for all samples") < 0)
1616                         return 0;
1617         }
1618
1619         act->thread = thread;
1620         act->ms.sym = sym;
1621         act->fn = do_run_script;
1622         return 1;
1623 }
1624
1625 static int
1626 do_switch_data(struct hist_browser *browser __maybe_unused,
1627                struct popup_action *act __maybe_unused)
1628 {
1629         if (switch_data_file()) {
1630                 ui__warning("Won't switch the data files due to\n"
1631                             "no valid data file get selected!\n");
1632                 return 0;
1633         }
1634
1635         return K_SWITCH_INPUT_DATA;
1636 }
1637
1638 static int
1639 add_switch_opt(struct hist_browser *browser,
1640                struct popup_action *act, char **optstr)
1641 {
1642         if (!is_report_browser(browser->hbt))
1643                 return 0;
1644
1645         if (asprintf(optstr, "Switch to another data file in PWD") < 0)
1646                 return 0;
1647
1648         act->fn = do_switch_data;
1649         return 1;
1650 }
1651
1652 static int
1653 do_exit_browser(struct hist_browser *browser __maybe_unused,
1654                 struct popup_action *act __maybe_unused)
1655 {
1656         return 0;
1657 }
1658
1659 static int
1660 add_exit_opt(struct hist_browser *browser __maybe_unused,
1661              struct popup_action *act, char **optstr)
1662 {
1663         if (asprintf(optstr, "Exit") < 0)
1664                 return 0;
1665
1666         act->fn = do_exit_browser;
1667         return 1;
1668 }
1669
1670 static void hist_browser__update_nr_entries(struct hist_browser *hb)
1671 {
1672         u64 nr_entries = 0;
1673         struct rb_node *nd = rb_first(&hb->hists->entries);
1674
1675         if (hb->min_pcnt == 0) {
1676                 hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;
1677                 return;
1678         }
1679
1680         while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
1681                 nr_entries++;
1682                 nd = rb_next(nd);
1683         }
1684
1685         hb->nr_non_filtered_entries = nr_entries;
1686 }
1687
1688 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
1689                                     const char *helpline,
1690                                     bool left_exits,
1691                                     struct hist_browser_timer *hbt,
1692                                     float min_pcnt,
1693                                     struct perf_session_env *env)
1694 {
1695         struct hists *hists = evsel__hists(evsel);
1696         struct hist_browser *browser = hist_browser__new(hists, hbt, env);
1697         struct branch_info *bi;
1698 #define MAX_OPTIONS  16
1699         char *options[MAX_OPTIONS];
1700         struct popup_action actions[MAX_OPTIONS];
1701         int nr_options = 0;
1702         int key = -1;
1703         char buf[64];
1704         int delay_secs = hbt ? hbt->refresh : 0;
1705         struct perf_hpp_fmt *fmt;
1706
1707 #define HIST_BROWSER_HELP_COMMON                                        \
1708         "h/?/F1        Show this window\n"                              \
1709         "UP/DOWN/PGUP\n"                                                \
1710         "PGDN/SPACE    Navigate\n"                                      \
1711         "q/ESC/CTRL+C  Exit browser\n\n"                                \
1712         "For multiple event sessions:\n\n"                              \
1713         "TAB/UNTAB     Switch events\n\n"                               \
1714         "For symbolic views (--sort has sym):\n\n"                      \
1715         "->            Zoom into DSO/Threads & Annotate current symbol\n" \
1716         "<-            Zoom out\n"                                      \
1717         "a             Annotate current symbol\n"                       \
1718         "C             Collapse all callchains\n"                       \
1719         "d             Zoom into current DSO\n"                         \
1720         "E             Expand all callchains\n"                         \
1721         "F             Toggle percentage of filtered entries\n"         \
1722         "H             Display column headers\n"                        \
1723
1724         /* help messages are sorted by lexical order of the hotkey */
1725         const char report_help[] = HIST_BROWSER_HELP_COMMON
1726         "i             Show header information\n"
1727         "P             Print histograms to perf.hist.N\n"
1728         "r             Run available scripts\n"
1729         "s             Switch to another data file in PWD\n"
1730         "t             Zoom into current Thread\n"
1731         "V             Verbose (DSO names in callchains, etc)\n"
1732         "/             Filter symbol by name";
1733         const char top_help[] = HIST_BROWSER_HELP_COMMON
1734         "P             Print histograms to perf.hist.N\n"
1735         "t             Zoom into current Thread\n"
1736         "V             Verbose (DSO names in callchains, etc)\n"
1737         "z             Toggle zeroing of samples\n"
1738         "f             Enable/Disable events\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, helpline);
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                 case 'f':
1905                         if (!is_report_browser(hbt)) {
1906                                 struct perf_top *top = hbt->arg;
1907
1908                                 perf_evlist__toggle_enable(top->evlist);
1909                                 /*
1910                                  * No need to refresh, resort/decay histogram
1911                                  * entries if we are not collecting samples:
1912                                  */
1913                                 if (top->evlist->enabled) {
1914                                         helpline = "Press 'f' to disable the events or 'h' to see other hotkeys";
1915                                         hbt->refresh = delay_secs;
1916                                 } else {
1917                                         helpline = "Press 'f' again to re-enable the events";
1918                                         hbt->refresh = 0;
1919                                 }
1920                                 continue;
1921                         }
1922                         /* Fall thru */
1923                 default:
1924                         helpline = "Press '?' for help on key bindings";
1925                         continue;
1926                 }
1927
1928                 if (!sort__has_sym)
1929                         goto add_exit_option;
1930
1931                 if (browser->selection == NULL)
1932                         goto skip_annotation;
1933
1934                 if (sort__mode == SORT_MODE__BRANCH) {
1935                         bi = browser->he_selection->branch_info;
1936
1937                         if (bi == NULL)
1938                                 goto skip_annotation;
1939
1940                         nr_options += add_annotate_opt(browser,
1941                                                        &actions[nr_options],
1942                                                        &options[nr_options],
1943                                                        bi->from.map,
1944                                                        bi->from.sym);
1945                         if (bi->to.sym != bi->from.sym)
1946                                 nr_options += add_annotate_opt(browser,
1947                                                         &actions[nr_options],
1948                                                         &options[nr_options],
1949                                                         bi->to.map,
1950                                                         bi->to.sym);
1951                 } else {
1952                         nr_options += add_annotate_opt(browser,
1953                                                        &actions[nr_options],
1954                                                        &options[nr_options],
1955                                                        browser->selection->map,
1956                                                        browser->selection->sym);
1957                 }
1958 skip_annotation:
1959                 nr_options += add_thread_opt(browser, &actions[nr_options],
1960                                              &options[nr_options], thread);
1961                 nr_options += add_dso_opt(browser, &actions[nr_options],
1962                                           &options[nr_options], dso);
1963                 nr_options += add_map_opt(browser, &actions[nr_options],
1964                                           &options[nr_options],
1965                                           browser->selection->map);
1966
1967                 /* perf script support */
1968                 if (browser->he_selection) {
1969                         nr_options += add_script_opt(browser,
1970                                                      &actions[nr_options],
1971                                                      &options[nr_options],
1972                                                      thread, NULL);
1973                         nr_options += add_script_opt(browser,
1974                                                      &actions[nr_options],
1975                                                      &options[nr_options],
1976                                                      NULL, browser->selection->sym);
1977                 }
1978                 nr_options += add_script_opt(browser, &actions[nr_options],
1979                                              &options[nr_options], NULL, NULL);
1980                 nr_options += add_switch_opt(browser, &actions[nr_options],
1981                                              &options[nr_options]);
1982 add_exit_option:
1983                 nr_options += add_exit_opt(browser, &actions[nr_options],
1984                                            &options[nr_options]);
1985
1986                 do {
1987                         struct popup_action *act;
1988
1989                         choice = ui__popup_menu(nr_options, options);
1990                         if (choice == -1 || choice >= nr_options)
1991                                 break;
1992
1993                         act = &actions[choice];
1994                         key = act->fn(browser, act);
1995                 } while (key == 1);
1996
1997                 if (key == K_SWITCH_INPUT_DATA)
1998                         break;
1999         }
2000 out_free_stack:
2001         pstack__delete(browser->pstack);
2002 out:
2003         hist_browser__delete(browser);
2004         free_popup_options(options, MAX_OPTIONS);
2005         return key;
2006 }
2007
2008 struct perf_evsel_menu {
2009         struct ui_browser b;
2010         struct perf_evsel *selection;
2011         bool lost_events, lost_events_warned;
2012         float min_pcnt;
2013         struct perf_session_env *env;
2014 };
2015
2016 static void perf_evsel_menu__write(struct ui_browser *browser,
2017                                    void *entry, int row)
2018 {
2019         struct perf_evsel_menu *menu = container_of(browser,
2020                                                     struct perf_evsel_menu, b);
2021         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
2022         struct hists *hists = evsel__hists(evsel);
2023         bool current_entry = ui_browser__is_current_entry(browser, row);
2024         unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
2025         const char *ev_name = perf_evsel__name(evsel);
2026         char bf[256], unit;
2027         const char *warn = " ";
2028         size_t printed;
2029
2030         ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
2031                                                        HE_COLORSET_NORMAL);
2032
2033         if (perf_evsel__is_group_event(evsel)) {
2034                 struct perf_evsel *pos;
2035
2036                 ev_name = perf_evsel__group_name(evsel);
2037
2038                 for_each_group_member(pos, evsel) {
2039                         struct hists *pos_hists = evsel__hists(pos);
2040                         nr_events += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
2041                 }
2042         }
2043
2044         nr_events = convert_unit(nr_events, &unit);
2045         printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
2046                            unit, unit == ' ' ? "" : " ", ev_name);
2047         slsmg_printf("%s", bf);
2048
2049         nr_events = hists->stats.nr_events[PERF_RECORD_LOST];
2050         if (nr_events != 0) {
2051                 menu->lost_events = true;
2052                 if (!current_entry)
2053                         ui_browser__set_color(browser, HE_COLORSET_TOP);
2054                 nr_events = convert_unit(nr_events, &unit);
2055                 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
2056                                      nr_events, unit, unit == ' ' ? "" : " ");
2057                 warn = bf;
2058         }
2059
2060         slsmg_write_nstring(warn, browser->width - printed);
2061
2062         if (current_entry)
2063                 menu->selection = evsel;
2064 }
2065
2066 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
2067                                 int nr_events, const char *help,
2068                                 struct hist_browser_timer *hbt)
2069 {
2070         struct perf_evlist *evlist = menu->b.priv;
2071         struct perf_evsel *pos;
2072         const char *title = "Available samples";
2073         int delay_secs = hbt ? hbt->refresh : 0;
2074         int key;
2075
2076         if (ui_browser__show(&menu->b, title,
2077                              "ESC: exit, ENTER|->: Browse histograms") < 0)
2078                 return -1;
2079
2080         while (1) {
2081                 key = ui_browser__run(&menu->b, delay_secs);
2082
2083                 switch (key) {
2084                 case K_TIMER:
2085                         hbt->timer(hbt->arg);
2086
2087                         if (!menu->lost_events_warned && menu->lost_events) {
2088                                 ui_browser__warn_lost_events(&menu->b);
2089                                 menu->lost_events_warned = true;
2090                         }
2091                         continue;
2092                 case K_RIGHT:
2093                 case K_ENTER:
2094                         if (!menu->selection)
2095                                 continue;
2096                         pos = menu->selection;
2097 browse_hists:
2098                         perf_evlist__set_selected(evlist, pos);
2099                         /*
2100                          * Give the calling tool a chance to populate the non
2101                          * default evsel resorted hists tree.
2102                          */
2103                         if (hbt)
2104                                 hbt->timer(hbt->arg);
2105                         key = perf_evsel__hists_browse(pos, nr_events, help,
2106                                                        true, hbt,
2107                                                        menu->min_pcnt,
2108                                                        menu->env);
2109                         ui_browser__show_title(&menu->b, title);
2110                         switch (key) {
2111                         case K_TAB:
2112                                 if (pos->node.next == &evlist->entries)
2113                                         pos = perf_evlist__first(evlist);
2114                                 else
2115                                         pos = perf_evsel__next(pos);
2116                                 goto browse_hists;
2117                         case K_UNTAB:
2118                                 if (pos->node.prev == &evlist->entries)
2119                                         pos = perf_evlist__last(evlist);
2120                                 else
2121                                         pos = perf_evsel__prev(pos);
2122                                 goto browse_hists;
2123                         case K_ESC:
2124                                 if (!ui_browser__dialog_yesno(&menu->b,
2125                                                 "Do you really want to exit?"))
2126                                         continue;
2127                                 /* Fall thru */
2128                         case K_SWITCH_INPUT_DATA:
2129                         case 'q':
2130                         case CTRL('c'):
2131                                 goto out;
2132                         default:
2133                                 continue;
2134                         }
2135                 case K_LEFT:
2136                         continue;
2137                 case K_ESC:
2138                         if (!ui_browser__dialog_yesno(&menu->b,
2139                                                "Do you really want to exit?"))
2140                                 continue;
2141                         /* Fall thru */
2142                 case 'q':
2143                 case CTRL('c'):
2144                         goto out;
2145                 default:
2146                         continue;
2147                 }
2148         }
2149
2150 out:
2151         ui_browser__hide(&menu->b);
2152         return key;
2153 }
2154
2155 static bool filter_group_entries(struct ui_browser *browser __maybe_unused,
2156                                  void *entry)
2157 {
2158         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
2159
2160         if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
2161                 return true;
2162
2163         return false;
2164 }
2165
2166 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
2167                                            int nr_entries, const char *help,
2168                                            struct hist_browser_timer *hbt,
2169                                            float min_pcnt,
2170                                            struct perf_session_env *env)
2171 {
2172         struct perf_evsel *pos;
2173         struct perf_evsel_menu menu = {
2174                 .b = {
2175                         .entries    = &evlist->entries,
2176                         .refresh    = ui_browser__list_head_refresh,
2177                         .seek       = ui_browser__list_head_seek,
2178                         .write      = perf_evsel_menu__write,
2179                         .filter     = filter_group_entries,
2180                         .nr_entries = nr_entries,
2181                         .priv       = evlist,
2182                 },
2183                 .min_pcnt = min_pcnt,
2184                 .env = env,
2185         };
2186
2187         ui_helpline__push("Press ESC to exit");
2188
2189         evlist__for_each(evlist, pos) {
2190                 const char *ev_name = perf_evsel__name(pos);
2191                 size_t line_len = strlen(ev_name) + 7;
2192
2193                 if (menu.b.width < line_len)
2194                         menu.b.width = line_len;
2195         }
2196
2197         return perf_evsel_menu__run(&menu, nr_entries, help, hbt);
2198 }
2199
2200 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
2201                                   struct hist_browser_timer *hbt,
2202                                   float min_pcnt,
2203                                   struct perf_session_env *env)
2204 {
2205         int nr_entries = evlist->nr_entries;
2206
2207 single_entry:
2208         if (nr_entries == 1) {
2209                 struct perf_evsel *first = perf_evlist__first(evlist);
2210
2211                 return perf_evsel__hists_browse(first, nr_entries, help,
2212                                                 false, hbt, min_pcnt,
2213                                                 env);
2214         }
2215
2216         if (symbol_conf.event_group) {
2217                 struct perf_evsel *pos;
2218
2219                 nr_entries = 0;
2220                 evlist__for_each(evlist, pos) {
2221                         if (perf_evsel__is_group_leader(pos))
2222                                 nr_entries++;
2223                 }
2224
2225                 if (nr_entries == 1)
2226                         goto single_entry;
2227         }
2228
2229         return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
2230                                                hbt, min_pcnt, env);
2231 }