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