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