tools/perf/ui/browsers/hists.c

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