tools/perf/util/ui/browsers/hists.c

   1 #include <stdio.h>
   2 #include "../libslang.h"
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <newt.h>
   6 #include <linux/rbtree.h>
   7
   8 #include "../../evsel.h"
   9 #include "../../evlist.h"
  10 #include "../../hist.h"
  11 #include "../../pstack.h"
  12 #include "../../sort.h"
  13 #include "../../util.h"
  14
  15 #include "../browser.h"
  16 #include "../helpline.h"
  17 #include "../util.h"
  18 #include "../ui.h"
  19 #include "map.h"
  20
  21 struct hist_browser {
  22         struct ui_browser   b;
  23         struct hists        *hists;
  24         struct hist_entry   *he_selection;
  25         struct map_symbol   *selection;
  26         bool                 has_symbols;
  27 };
  28
  29 static int hists__browser_title(struct hists *self, char *bf, size_t size,
  30                                 const char *ev_name);
  31
  32 static void hist_browser__refresh_dimensions(struct hist_browser *self)
  33 {
  34         /* 3 == +/- toggle symbol before actual hist_entry rendering */
  35         self->b.width = 3 + (hists__sort_list_width(self->hists) +
  36                              sizeof("[k]"));
  37 }
  38
  39 static void hist_browser__reset(struct hist_browser *self)
  40 {
  41         self->b.nr_entries = self->hists->nr_entries;
  42         hist_browser__refresh_dimensions(self);
  43         ui_browser__reset_index(&self->b);
  44 }
  45
  46 static char tree__folded_sign(bool unfolded)
  47 {
  48         return unfolded ? '-' : '+';
  49 }
  50
  51 static char map_symbol__folded(const struct map_symbol *self)
  52 {
  53         return self->has_children ? tree__folded_sign(self->unfolded) : ' ';
  54 }
  55
  56 static char hist_entry__folded(const struct hist_entry *self)
  57 {
  58         return map_symbol__folded(&self->ms);
  59 }
  60
  61 static char callchain_list__folded(const struct callchain_list *self)
  62 {
  63         return map_symbol__folded(&self->ms);
  64 }
  65
  66 static void map_symbol__set_folding(struct map_symbol *self, bool unfold)
  67 {
  68         self->unfolded = unfold ? self->has_children : false;
  69 }
  70
  71 static int callchain_node__count_rows_rb_tree(struct callchain_node *self)
  72 {
  73         int n = 0;
  74         struct rb_node *nd;
  75
  76         for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
  77                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
  78                 struct callchain_list *chain;
  79                 char folded_sign = ' '; /* No children */
  80
  81                 list_for_each_entry(chain, &child->val, list) {
  82                         ++n;
  83                         /* We need this because we may not have children */
  84                         folded_sign = callchain_list__folded(chain);
  85                         if (folded_sign == '+')
  86                                 break;
  87                 }
  88
  89                 if (folded_sign == '-') /* Have children and they're unfolded */
  90                         n += callchain_node__count_rows_rb_tree(child);
  91         }
  92
  93         return n;
  94 }
  95
  96 static int callchain_node__count_rows(struct callchain_node *node)
  97 {
  98         struct callchain_list *chain;
  99         bool unfolded = false;
 100         int n = 0;
 101
 102         list_for_each_entry(chain, &node->val, list) {
 103                 ++n;
 104                 unfolded = chain->ms.unfolded;
 105         }
 106
 107         if (unfolded)
 108                 n += callchain_node__count_rows_rb_tree(node);
 109
 110         return n;
 111 }
 112
 113 static int callchain__count_rows(struct rb_root *chain)
 114 {
 115         struct rb_node *nd;
 116         int n = 0;
 117
 118         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 119                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 120                 n += callchain_node__count_rows(node);
 121         }
 122
 123         return n;
 124 }
 125
 126 static bool map_symbol__toggle_fold(struct map_symbol *self)
 127 {
 128         if (!self->has_children)
 129                 return false;
 130
 131         self->unfolded = !self->unfolded;
 132         return true;
 133 }
 134
 135 static void callchain_node__init_have_children_rb_tree(struct callchain_node *self)
 136 {
 137         struct rb_node *nd = rb_first(&self->rb_root);
 138
 139         for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
 140                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 141                 struct callchain_list *chain;
 142                 bool first = true;
 143
 144                 list_for_each_entry(chain, &child->val, list) {
 145                         if (first) {
 146                                 first = false;
 147                                 chain->ms.has_children = chain->list.next != &child->val ||
 148                                                          !RB_EMPTY_ROOT(&child->rb_root);
 149                         } else
 150                                 chain->ms.has_children = chain->list.next == &child->val &&
 151                                                          !RB_EMPTY_ROOT(&child->rb_root);
 152                 }
 153
 154                 callchain_node__init_have_children_rb_tree(child);
 155         }
 156 }
 157
 158 static void callchain_node__init_have_children(struct callchain_node *self)
 159 {
 160         struct callchain_list *chain;
 161
 162         list_for_each_entry(chain, &self->val, list)
 163                 chain->ms.has_children = !RB_EMPTY_ROOT(&self->rb_root);
 164
 165         callchain_node__init_have_children_rb_tree(self);
 166 }
 167
 168 static void callchain__init_have_children(struct rb_root *self)
 169 {
 170         struct rb_node *nd;
 171
 172         for (nd = rb_first(self); nd; nd = rb_next(nd)) {
 173                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 174                 callchain_node__init_have_children(node);
 175         }
 176 }
 177
 178 static void hist_entry__init_have_children(struct hist_entry *self)
 179 {
 180         if (!self->init_have_children) {
 181                 self->ms.has_children = !RB_EMPTY_ROOT(&self->sorted_chain);
 182                 callchain__init_have_children(&self->sorted_chain);
 183                 self->init_have_children = true;
 184         }
 185 }
 186
 187 static bool hist_browser__toggle_fold(struct hist_browser *self)
 188 {
 189         if (map_symbol__toggle_fold(self->selection)) {
 190                 struct hist_entry *he = self->he_selection;
 191
 192                 hist_entry__init_have_children(he);
 193                 self->hists->nr_entries -= he->nr_rows;
 194
 195                 if (he->ms.unfolded)
 196                         he->nr_rows = callchain__count_rows(&he->sorted_chain);
 197                 else
 198                         he->nr_rows = 0;
 199                 self->hists->nr_entries += he->nr_rows;
 200                 self->b.nr_entries = self->hists->nr_entries;
 201
 202                 return true;
 203         }
 204
 205         /* If it doesn't have children, no toggling performed */
 206         return false;
 207 }
 208
 209 static int callchain_node__set_folding_rb_tree(struct callchain_node *self, bool unfold)
 210 {
 211         int n = 0;
 212         struct rb_node *nd;
 213
 214         for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
 215                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 216                 struct callchain_list *chain;
 217                 bool has_children = false;
 218
 219                 list_for_each_entry(chain, &child->val, list) {
 220                         ++n;
 221                         map_symbol__set_folding(&chain->ms, unfold);
 222                         has_children = chain->ms.has_children;
 223                 }
 224
 225                 if (has_children)
 226                         n += callchain_node__set_folding_rb_tree(child, unfold);
 227         }
 228
 229         return n;
 230 }
 231
 232 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
 233 {
 234         struct callchain_list *chain;
 235         bool has_children = false;
 236         int n = 0;
 237
 238         list_for_each_entry(chain, &node->val, list) {
 239                 ++n;
 240                 map_symbol__set_folding(&chain->ms, unfold);
 241                 has_children = chain->ms.has_children;
 242         }
 243
 244         if (has_children)
 245                 n += callchain_node__set_folding_rb_tree(node, unfold);
 246
 247         return n;
 248 }
 249
 250 static int callchain__set_folding(struct rb_root *chain, bool unfold)
 251 {
 252         struct rb_node *nd;
 253         int n = 0;
 254
 255         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 256                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 257                 n += callchain_node__set_folding(node, unfold);
 258         }
 259
 260         return n;
 261 }
 262
 263 static void hist_entry__set_folding(struct hist_entry *self, bool unfold)
 264 {
 265         hist_entry__init_have_children(self);
 266         map_symbol__set_folding(&self->ms, unfold);
 267
 268         if (self->ms.has_children) {
 269                 int n = callchain__set_folding(&self->sorted_chain, unfold);
 270                 self->nr_rows = unfold ? n : 0;
 271         } else
 272                 self->nr_rows = 0;
 273 }
 274
 275 static void hists__set_folding(struct hists *self, bool unfold)
 276 {
 277         struct rb_node *nd;
 278
 279         self->nr_entries = 0;
 280
 281         for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
 282                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
 283                 hist_entry__set_folding(he, unfold);
 284                 self->nr_entries += 1 + he->nr_rows;
 285         }
 286 }
 287
 288 static void hist_browser__set_folding(struct hist_browser *self, bool unfold)
 289 {
 290         hists__set_folding(self->hists, unfold);
 291         self->b.nr_entries = self->hists->nr_entries;
 292         /* Go to the start, we may be way after valid entries after a collapse */
 293         ui_browser__reset_index(&self->b);
 294 }
 295
 296 static void ui_browser__warn_lost_events(struct ui_browser *browser)
 297 {
 298         ui_browser__warning(browser, 4,
 299                 "Events are being lost, check IO/CPU overload!\n\n"
 300                 "You may want to run 'perf' using a RT scheduler policy:\n\n"
 301                 " perf top -r 80\n\n"
 302                 "Or reduce the sampling frequency.");
 303 }
 304
 305 static int hist_browser__run(struct hist_browser *self, const char *ev_name,
 306                              void(*timer)(void *arg), void *arg, int delay_secs)
 307 {
 308         int key;
 309         char title[160];
 310
 311         self->b.entries = &self->hists->entries;
 312         self->b.nr_entries = self->hists->nr_entries;
 313
 314         hist_browser__refresh_dimensions(self);
 315         hists__browser_title(self->hists, title, sizeof(title), ev_name);
 316
 317         if (ui_browser__show(&self->b, title,
 318                              "Press '?' for help on key bindings") < 0)
 319                 return -1;
 320
 321         while (1) {
 322                 key = ui_browser__run(&self->b, delay_secs);
 323
 324                 switch (key) {
 325                 case K_TIMER:
 326                         timer(arg);
 327                         ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
 328
 329                         if (self->hists->stats.nr_lost_warned !=
 330                             self->hists->stats.nr_events[PERF_RECORD_LOST]) {
 331                                 self->hists->stats.nr_lost_warned =
 332                                         self->hists->stats.nr_events[PERF_RECORD_LOST];
 333                                 ui_browser__warn_lost_events(&self->b);
 334                         }
 335
 336                         hists__browser_title(self->hists, title, sizeof(title), ev_name);
 337                         ui_browser__show_title(&self->b, title);
 338                         continue;
 339                 case 'D': { /* Debug */
 340                         static int seq;
 341                         struct hist_entry *h = rb_entry(self->b.top,
 342                                                         struct hist_entry, rb_node);
 343                         ui_helpline__pop();
 344                         ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
 345                                            seq++, self->b.nr_entries,
 346                                            self->hists->nr_entries,
 347                                            self->b.height,
 348                                            self->b.index,
 349                                            self->b.top_idx,
 350                                            h->row_offset, h->nr_rows);
 351                 }
 352                         break;
 353                 case 'C':
 354                         /* Collapse the whole world. */
 355                         hist_browser__set_folding(self, false);
 356                         break;
 357                 case 'E':
 358                         /* Expand the whole world. */
 359                         hist_browser__set_folding(self, true);
 360                         break;
 361                 case K_ENTER:
 362                         if (hist_browser__toggle_fold(self))
 363                                 break;
 364                         /* fall thru */
 365                 default:
 366                         goto out;
 367                 }
 368         }
 369 out:
 370         ui_browser__hide(&self->b);
 371         return key;
 372 }
 373
 374 static char *callchain_list__sym_name(struct callchain_list *self,
 375                                       char *bf, size_t bfsize)
 376 {
 377         if (self->ms.sym)
 378                 return self->ms.sym->name;
 379
 380         snprintf(bf, bfsize, "%#" PRIx64, self->ip);
 381         return bf;
 382 }
 383
 384 #define LEVEL_OFFSET_STEP 3
 385
 386 static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
 387                                                      struct callchain_node *chain_node,
 388                                                      u64 total, int level,
 389                                                      unsigned short row,
 390                                                      off_t *row_offset,
 391                                                      bool *is_current_entry)
 392 {
 393         struct rb_node *node;
 394         int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
 395         u64 new_total, remaining;
 396
 397         if (callchain_param.mode == CHAIN_GRAPH_REL)
 398                 new_total = chain_node->children_hit;
 399         else
 400                 new_total = total;
 401
 402         remaining = new_total;
 403         node = rb_first(&chain_node->rb_root);
 404         while (node) {
 405                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 406                 struct rb_node *next = rb_next(node);
 407                 u64 cumul = callchain_cumul_hits(child);
 408                 struct callchain_list *chain;
 409                 char folded_sign = ' ';
 410                 int first = true;
 411                 int extra_offset = 0;
 412
 413                 remaining -= cumul;
 414
 415                 list_for_each_entry(chain, &child->val, list) {
 416                         char ipstr[BITS_PER_LONG / 4 + 1], *alloc_str;
 417                         const char *str;
 418                         int color;
 419                         bool was_first = first;
 420
 421                         if (first)
 422                                 first = false;
 423                         else
 424                                 extra_offset = LEVEL_OFFSET_STEP;
 425
 426                         folded_sign = callchain_list__folded(chain);
 427                         if (*row_offset != 0) {
 428                                 --*row_offset;
 429                                 goto do_next;
 430                         }
 431
 432                         alloc_str = NULL;
 433                         str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
 434                         if (was_first) {
 435                                 double percent = cumul * 100.0 / new_total;
 436
 437                                 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
 438                                         str = "Not enough memory!";
 439                                 else
 440                                         str = alloc_str;
 441                         }
 442
 443                         color = HE_COLORSET_NORMAL;
 444                         width = self->b.width - (offset + extra_offset + 2);
 445                         if (ui_browser__is_current_entry(&self->b, row)) {
 446                                 self->selection = &chain->ms;
 447                                 color = HE_COLORSET_SELECTED;
 448                                 *is_current_entry = true;
 449                         }
 450
 451                         ui_browser__set_color(&self->b, color);
 452                         ui_browser__gotorc(&self->b, row, 0);
 453                         slsmg_write_nstring(" ", offset + extra_offset);
 454                         slsmg_printf("%c ", folded_sign);
 455                         slsmg_write_nstring(str, width);
 456                         free(alloc_str);
 457
 458                         if (++row == self->b.height)
 459                                 goto out;
 460 do_next:
 461                         if (folded_sign == '+')
 462                                 break;
 463                 }
 464
 465                 if (folded_sign == '-') {
 466                         const int new_level = level + (extra_offset ? 2 : 1);
 467                         row += hist_browser__show_callchain_node_rb_tree(self, child, new_total,
 468                                                                          new_level, row, row_offset,
 469                                                                          is_current_entry);
 470                 }
 471                 if (row == self->b.height)
 472                         goto out;
 473                 node = next;
 474         }
 475 out:
 476         return row - first_row;
 477 }
 478
 479 static int hist_browser__show_callchain_node(struct hist_browser *self,
 480                                              struct callchain_node *node,
 481                                              int level, unsigned short row,
 482                                              off_t *row_offset,
 483                                              bool *is_current_entry)
 484 {
 485         struct callchain_list *chain;
 486         int first_row = row,
 487              offset = level * LEVEL_OFFSET_STEP,
 488              width = self->b.width - offset;
 489         char folded_sign = ' ';
 490
 491         list_for_each_entry(chain, &node->val, list) {
 492                 char ipstr[BITS_PER_LONG / 4 + 1], *s;
 493                 int color;
 494
 495                 folded_sign = callchain_list__folded(chain);
 496
 497                 if (*row_offset != 0) {
 498                         --*row_offset;
 499                         continue;
 500                 }
 501
 502                 color = HE_COLORSET_NORMAL;
 503                 if (ui_browser__is_current_entry(&self->b, row)) {
 504                         self->selection = &chain->ms;
 505                         color = HE_COLORSET_SELECTED;
 506                         *is_current_entry = true;
 507                 }
 508
 509                 s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
 510                 ui_browser__gotorc(&self->b, row, 0);
 511                 ui_browser__set_color(&self->b, color);
 512                 slsmg_write_nstring(" ", offset);
 513                 slsmg_printf("%c ", folded_sign);
 514                 slsmg_write_nstring(s, width - 2);
 515
 516                 if (++row == self->b.height)
 517                         goto out;
 518         }
 519
 520         if (folded_sign == '-')
 521                 row += hist_browser__show_callchain_node_rb_tree(self, node,
 522                                                                  self->hists->stats.total_period,
 523                                                                  level + 1, row,
 524                                                                  row_offset,
 525                                                                  is_current_entry);
 526 out:
 527         return row - first_row;
 528 }
 529
 530 static int hist_browser__show_callchain(struct hist_browser *self,
 531                                         struct rb_root *chain,
 532                                         int level, unsigned short row,
 533                                         off_t *row_offset,
 534                                         bool *is_current_entry)
 535 {
 536         struct rb_node *nd;
 537         int first_row = row;
 538
 539         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 540                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 541
 542                 row += hist_browser__show_callchain_node(self, node, level,
 543                                                          row, row_offset,
 544                                                          is_current_entry);
 545                 if (row == self->b.height)
 546                         break;
 547         }
 548
 549         return row - first_row;
 550 }
 551
 552 static int hist_browser__show_entry(struct hist_browser *self,
 553                                     struct hist_entry *entry,
 554                                     unsigned short row)
 555 {
 556         char s[256];
 557         double percent;
 558         int printed = 0;
 559         int width = self->b.width - 6; /* The percentage */
 560         char folded_sign = ' ';
 561         bool current_entry = ui_browser__is_current_entry(&self->b, row);
 562         off_t row_offset = entry->row_offset;
 563
 564         if (current_entry) {
 565                 self->he_selection = entry;
 566                 self->selection = &entry->ms;
 567         }
 568
 569         if (symbol_conf.use_callchain) {
 570                 hist_entry__init_have_children(entry);
 571                 folded_sign = hist_entry__folded(entry);
 572         }
 573
 574         if (row_offset == 0) {
 575                 hist_entry__snprintf(entry, s, sizeof(s), self->hists);
 576                 percent = (entry->period * 100.0) / self->hists->stats.total_period;
 577
 578                 ui_browser__set_percent_color(&self->b, percent, current_entry);
 579                 ui_browser__gotorc(&self->b, row, 0);
 580                 if (symbol_conf.use_callchain) {
 581                         slsmg_printf("%c ", folded_sign);
 582                         width -= 2;
 583                 }
 584
 585                 slsmg_printf(" %5.2f%%", percent);
 586
 587                 /* The scroll bar isn't being used */
 588                 if (!self->b.navkeypressed)
 589                         width += 1;
 590
 591                 if (!current_entry || !self->b.navkeypressed)
 592                         ui_browser__set_color(&self->b, HE_COLORSET_NORMAL);
 593
 594                 if (symbol_conf.show_nr_samples) {
 595                         slsmg_printf(" %11u", entry->nr_events);
 596                         width -= 12;
 597                 }
 598
 599                 if (symbol_conf.show_total_period) {
 600                         slsmg_printf(" %12" PRIu64, entry->period);
 601                         width -= 13;
 602                 }
 603
 604                 slsmg_write_nstring(s, width);
 605                 ++row;
 606                 ++printed;
 607         } else
 608                 --row_offset;
 609
 610         if (folded_sign == '-' && row != self->b.height) {
 611                 printed += hist_browser__show_callchain(self, &entry->sorted_chain,
 612                                                         1, row, &row_offset,
 613                                                         &current_entry);
 614                 if (current_entry)
 615                         self->he_selection = entry;
 616         }
 617
 618         return printed;
 619 }
 620
 621 static void ui_browser__hists_init_top(struct ui_browser *browser)
 622 {
 623         if (browser->top == NULL) {
 624                 struct hist_browser *hb;
 625
 626                 hb = container_of(browser, struct hist_browser, b);
 627                 browser->top = rb_first(&hb->hists->entries);
 628         }
 629 }
 630
 631 static unsigned int hist_browser__refresh(struct ui_browser *self)
 632 {
 633         unsigned row = 0;
 634         struct rb_node *nd;
 635         struct hist_browser *hb = container_of(self, struct hist_browser, b);
 636
 637         ui_browser__hists_init_top(self);
 638
 639         for (nd = self->top; nd; nd = rb_next(nd)) {
 640                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 641
 642                 if (h->filtered)
 643                         continue;
 644
 645                 row += hist_browser__show_entry(hb, h, row);
 646                 if (row == self->height)
 647                         break;
 648         }
 649
 650         return row;
 651 }
 652
 653 static struct rb_node *hists__filter_entries(struct rb_node *nd)
 654 {
 655         while (nd != NULL) {
 656                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 657                 if (!h->filtered)
 658                         return nd;
 659
 660                 nd = rb_next(nd);
 661         }
 662
 663         return NULL;
 664 }
 665
 666 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
 667 {
 668         while (nd != NULL) {
 669                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 670                 if (!h->filtered)
 671                         return nd;
 672
 673                 nd = rb_prev(nd);
 674         }
 675
 676         return NULL;
 677 }
 678
 679 static void ui_browser__hists_seek(struct ui_browser *self,
 680                                    off_t offset, int whence)
 681 {
 682         struct hist_entry *h;
 683         struct rb_node *nd;
 684         bool first = true;
 685
 686         if (self->nr_entries == 0)
 687                 return;
 688
 689         ui_browser__hists_init_top(self);
 690
 691         switch (whence) {
 692         case SEEK_SET:
 693                 nd = hists__filter_entries(rb_first(self->entries));
 694                 break;
 695         case SEEK_CUR:
 696                 nd = self->top;
 697                 goto do_offset;
 698         case SEEK_END:
 699                 nd = hists__filter_prev_entries(rb_last(self->entries));
 700                 first = false;
 701                 break;
 702         default:
 703                 return;
 704         }
 705
 706         /*
 707          * Moves not relative to the first visible entry invalidates its
 708          * row_offset:
 709          */
 710         h = rb_entry(self->top, struct hist_entry, rb_node);
 711         h->row_offset = 0;
 712
 713         /*
 714          * Here we have to check if nd is expanded (+), if it is we can't go
 715          * the next top level hist_entry, instead we must compute an offset of
 716          * what _not_ to show and not change the first visible entry.
 717          *
 718          * This offset increments when we are going from top to bottom and
 719          * decreases when we're going from bottom to top.
 720          *
 721          * As we don't have backpointers to the top level in the callchains
 722          * structure, we need to always print the whole hist_entry callchain,
 723          * skipping the first ones that are before the first visible entry
 724          * and stop when we printed enough lines to fill the screen.
 725          */
 726 do_offset:
 727         if (offset > 0) {
 728                 do {
 729                         h = rb_entry(nd, struct hist_entry, rb_node);
 730                         if (h->ms.unfolded) {
 731                                 u16 remaining = h->nr_rows - h->row_offset;
 732                                 if (offset > remaining) {
 733                                         offset -= remaining;
 734                                         h->row_offset = 0;
 735                                 } else {
 736                                         h->row_offset += offset;
 737                                         offset = 0;
 738                                         self->top = nd;
 739                                         break;
 740                                 }
 741                         }
 742                         nd = hists__filter_entries(rb_next(nd));
 743                         if (nd == NULL)
 744                                 break;
 745                         --offset;
 746                         self->top = nd;
 747                 } while (offset != 0);
 748         } else if (offset < 0) {
 749                 while (1) {
 750                         h = rb_entry(nd, struct hist_entry, rb_node);
 751                         if (h->ms.unfolded) {
 752                                 if (first) {
 753                                         if (-offset > h->row_offset) {
 754                                                 offset += h->row_offset;
 755                                                 h->row_offset = 0;
 756                                         } else {
 757                                                 h->row_offset += offset;
 758                                                 offset = 0;
 759                                                 self->top = nd;
 760                                                 break;
 761                                         }
 762                                 } else {
 763                                         if (-offset > h->nr_rows) {
 764                                                 offset += h->nr_rows;
 765                                                 h->row_offset = 0;
 766                                         } else {
 767                                                 h->row_offset = h->nr_rows + offset;
 768                                                 offset = 0;
 769                                                 self->top = nd;
 770                                                 break;
 771                                         }
 772                                 }
 773                         }
 774
 775                         nd = hists__filter_prev_entries(rb_prev(nd));
 776                         if (nd == NULL)
 777                                 break;
 778                         ++offset;
 779                         self->top = nd;
 780                         if (offset == 0) {
 781                                 /*
 782                                  * Last unfiltered hist_entry, check if it is
 783                                  * unfolded, if it is then we should have
 784                                  * row_offset at its last entry.
 785                                  */
 786                                 h = rb_entry(nd, struct hist_entry, rb_node);
 787                                 if (h->ms.unfolded)
 788                                         h->row_offset = h->nr_rows;
 789                                 break;
 790                         }
 791                         first = false;
 792                 }
 793         } else {
 794                 self->top = nd;
 795                 h = rb_entry(nd, struct hist_entry, rb_node);
 796                 h->row_offset = 0;
 797         }
 798 }
 799
 800 static struct hist_browser *hist_browser__new(struct hists *hists)
 801 {
 802         struct hist_browser *self = zalloc(sizeof(*self));
 803
 804         if (self) {
 805                 self->hists = hists;
 806                 self->b.refresh = hist_browser__refresh;
 807                 self->b.seek = ui_browser__hists_seek;
 808                 self->b.use_navkeypressed = true;
 809                 if (sort__branch_mode == 1)
 810                         self->has_symbols = sort_sym_from.list.next != NULL;
 811                 else
 812                         self->has_symbols = sort_sym.list.next != NULL;
 813         }
 814
 815         return self;
 816 }
 817
 818 static void hist_browser__delete(struct hist_browser *self)
 819 {
 820         free(self);
 821 }
 822
 823 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
 824 {
 825         return self->he_selection;
 826 }
 827
 828 static struct thread *hist_browser__selected_thread(struct hist_browser *self)
 829 {
 830         return self->he_selection->thread;
 831 }
 832
 833 static int hists__browser_title(struct hists *self, char *bf, size_t size,
 834                                 const char *ev_name)
 835 {
 836         char unit;
 837         int printed;
 838         const struct dso *dso = self->dso_filter;
 839         const struct thread *thread = self->thread_filter;
 840         unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 841
 842         nr_events = convert_unit(nr_events, &unit);
 843         printed = scnprintf(bf, size, "Events: %lu%c %s", nr_events, unit, ev_name);
 844
 845         if (self->uid_filter_str)
 846                 printed += snprintf(bf + printed, size - printed,
 847                                     ", UID: %s", self->uid_filter_str);
 848         if (thread)
 849                 printed += scnprintf(bf + printed, size - printed,
 850                                     ", Thread: %s(%d)",
 851                                     (thread->comm_set ? thread->comm : ""),
 852                                     thread->pid);
 853         if (dso)
 854                 printed += scnprintf(bf + printed, size - printed,
 855                                     ", DSO: %s", dso->short_name);
 856         return printed;
 857 }
 858
 859 static inline void free_popup_options(char **options, int n)
 860 {
 861         int i;
 862
 863         for (i = 0; i < n; ++i) {
 864                 free(options[i]);
 865                 options[i] = NULL;
 866         }
 867 }
 868
 869 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 870                                     const char *helpline, const char *ev_name,
 871                                     bool left_exits,
 872                                     void(*timer)(void *arg), void *arg,
 873                                     int delay_secs)
 874 {
 875         struct hists *self = &evsel->hists;
 876         struct hist_browser *browser = hist_browser__new(self);
 877         struct branch_info *bi;
 878         struct pstack *fstack;
 879         char *options[16];
 880         int nr_options = 0;
 881         int key = -1;
 882
 883         if (browser == NULL)
 884                 return -1;
 885
 886         fstack = pstack__new(2);
 887         if (fstack == NULL)
 888                 goto out;
 889
 890         ui_helpline__push(helpline);
 891
 892         memset(options, 0, sizeof(options));
 893
 894         while (1) {
 895                 const struct thread *thread = NULL;
 896                 const struct dso *dso = NULL;
 897                 int choice = 0,
 898                     annotate = -2, zoom_dso = -2, zoom_thread = -2,
 899                     annotate_f = -2, annotate_t = -2, browse_map = -2;
 900
 901                 nr_options = 0;
 902
 903                 key = hist_browser__run(browser, ev_name, timer, arg, delay_secs);
 904
 905                 if (browser->he_selection != NULL) {
 906                         thread = hist_browser__selected_thread(browser);
 907                         dso = browser->selection->map ? browser->selection->map->dso : NULL;
 908                 }
 909                 switch (key) {
 910                 case K_TAB:
 911                 case K_UNTAB:
 912                         if (nr_events == 1)
 913                                 continue;
 914                         /*
 915                          * Exit the browser, let hists__browser_tree
 916                          * go to the next or previous
 917                          */
 918                         goto out_free_stack;
 919                 case 'a':
 920                         if (!browser->has_symbols) {
 921                                 ui_browser__warning(&browser->b, delay_secs * 2,
 922                         "Annotation is only available for symbolic views, "
 923                         "include \"sym*\" in --sort to use it.");
 924                                 continue;
 925                         }
 926
 927                         if (browser->selection == NULL ||
 928                             browser->selection->sym == NULL ||
 929                             browser->selection->map->dso->annotate_warned)
 930                                 continue;
 931                         goto do_annotate;
 932                 case 'd':
 933                         goto zoom_dso;
 934                 case 't':
 935                         goto zoom_thread;
 936                 case K_F1:
 937                 case 'h':
 938                 case '?':
 939                         ui_browser__help_window(&browser->b,
 940                                         "h/?/F1        Show this window\n"
 941                                         "UP/DOWN/PGUP\n"
 942                                         "PGDN/SPACE    Navigate\n"
 943                                         "q/ESC/CTRL+C  Exit browser\n\n"
 944                                         "For multiple event sessions:\n\n"
 945                                         "TAB/UNTAB Switch events\n\n"
 946                                         "For symbolic views (--sort has sym):\n\n"
 947                                         "->            Zoom into DSO/Threads & Annotate current symbol\n"
 948                                         "<-            Zoom out\n"
 949                                         "a             Annotate current symbol\n"
 950                                         "C             Collapse all callchains\n"
 951                                         "E             Expand all callchains\n"
 952                                         "d             Zoom into current DSO\n"
 953                                         "t             Zoom into current Thread");
 954                         continue;
 955                 case K_ENTER:
 956                 case K_RIGHT:
 957                         /* menu */
 958                         break;
 959                 case K_LEFT: {
 960                         const void *top;
 961
 962                         if (pstack__empty(fstack)) {
 963                                 /*
 964                                  * Go back to the perf_evsel_menu__run or other user
 965                                  */
 966                                 if (left_exits)
 967                                         goto out_free_stack;
 968                                 continue;
 969                         }
 970                         top = pstack__pop(fstack);
 971                         if (top == &browser->hists->dso_filter)
 972                                 goto zoom_out_dso;
 973                         if (top == &browser->hists->thread_filter)
 974                                 goto zoom_out_thread;
 975                         continue;
 976                 }
 977                 case K_ESC:
 978                         if (!left_exits &&
 979                             !ui_browser__dialog_yesno(&browser->b,
 980                                                "Do you really want to exit?"))
 981                                 continue;
 982                         /* Fall thru */
 983                 case 'q':
 984                 case CTRL('c'):
 985                         goto out_free_stack;
 986                 default:
 987                         continue;
 988                 }
 989
 990                 if (!browser->has_symbols)
 991                         goto add_exit_option;
 992
 993                 if (sort__branch_mode == 1) {
 994                         bi = browser->he_selection->branch_info;
 995                         if (browser->selection != NULL &&
 996                             bi &&
 997                             bi->from.sym != NULL &&
 998                             !bi->from.map->dso->annotate_warned &&
 999                                 asprintf(&options[nr_options], "Annotate %s",
1000                                          bi->from.sym->name) > 0)
1001                                 annotate_f = nr_options++;
1002
1003                         if (browser->selection != NULL &&
1004                             bi &&
1005                             bi->to.sym != NULL &&
1006                             !bi->to.map->dso->annotate_warned &&
1007                             (bi->to.sym != bi->from.sym ||
1008                              bi->to.map->dso != bi->from.map->dso) &&
1009                                 asprintf(&options[nr_options], "Annotate %s",
1010                                          bi->to.sym->name) > 0)
1011                                 annotate_t = nr_options++;
1012                 } else {
1013
1014                         if (browser->selection != NULL &&
1015                             browser->selection->sym != NULL &&
1016                             !browser->selection->map->dso->annotate_warned &&
1017                                 asprintf(&options[nr_options], "Annotate %s",
1018                                          browser->selection->sym->name) > 0)
1019                                 annotate = nr_options++;
1020                 }
1021
1022                 if (thread != NULL &&
1023                     asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
1024                              (browser->hists->thread_filter ? "out of" : "into"),
1025                              (thread->comm_set ? thread->comm : ""),
1026                              thread->pid) > 0)
1027                         zoom_thread = nr_options++;
1028
1029                 if (dso != NULL &&
1030                     asprintf(&options[nr_options], "Zoom %s %s DSO",
1031                              (browser->hists->dso_filter ? "out of" : "into"),
1032                              (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
1033                         zoom_dso = nr_options++;
1034
1035                 if (browser->selection != NULL &&
1036                     browser->selection->map != NULL &&
1037                     asprintf(&options[nr_options], "Browse map details") > 0)
1038                         browse_map = nr_options++;
1039 add_exit_option:
1040                 options[nr_options++] = (char *)"Exit";
1041 retry_popup_menu:
1042                 choice = ui__popup_menu(nr_options, options);
1043
1044                 if (choice == nr_options - 1)
1045                         break;
1046
1047                 if (choice == -1) {
1048                         free_popup_options(options, nr_options - 1);
1049                         continue;
1050                 }
1051
1052                 if (choice == annotate || choice == annotate_t || choice == annotate_f) {
1053                         struct hist_entry *he;
1054                         int err;
1055 do_annotate:
1056                         he = hist_browser__selected_entry(browser);
1057                         if (he == NULL)
1058                                 continue;
1059
1060                         /*
1061                          * we stash the branch_info symbol + map into the
1062                          * the ms so we don't have to rewrite all the annotation
1063                          * code to use branch_info.
1064                          * in branch mode, the ms struct is not used
1065                          */
1066                         if (choice == annotate_f) {
1067                                 he->ms.sym = he->branch_info->from.sym;
1068                                 he->ms.map = he->branch_info->from.map;
1069                         }  else if (choice == annotate_t) {
1070                                 he->ms.sym = he->branch_info->to.sym;
1071                                 he->ms.map = he->branch_info->to.map;
1072                         }
1073
1074                         /*
1075                          * Don't let this be freed, say, by hists__decay_entry.
1076                          */
1077                         he->used = true;
1078                         err = hist_entry__tui_annotate(he, evsel->idx,
1079                                                        timer, arg, delay_secs);
1080                         he->used = false;
1081                         /*
1082                          * offer option to annotate the other branch source or target
1083                          * (if they exists) when returning from annotate
1084                          */
1085                         if ((err == 'q' || err == CTRL('c'))
1086                             && annotate_t != -2 && annotate_f != -2)
1087                                 goto retry_popup_menu;
1088
1089                         ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
1090                         if (err)
1091                                 ui_browser__handle_resize(&browser->b);
1092
1093                 } else if (choice == browse_map)
1094                         map__browse(browser->selection->map);
1095                 else if (choice == zoom_dso) {
1096 zoom_dso:
1097                         if (browser->hists->dso_filter) {
1098                                 pstack__remove(fstack, &browser->hists->dso_filter);
1099 zoom_out_dso:
1100                                 ui_helpline__pop();
1101                                 browser->hists->dso_filter = NULL;
1102                                 sort_dso.elide = false;
1103                         } else {
1104                                 if (dso == NULL)
1105                                         continue;
1106                                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1107                                                    dso->kernel ? "the Kernel" : dso->short_name);
1108                                 browser->hists->dso_filter = dso;
1109                                 sort_dso.elide = true;
1110                                 pstack__push(fstack, &browser->hists->dso_filter);
1111                         }
1112                         hists__filter_by_dso(self);
1113                         hist_browser__reset(browser);
1114                 } else if (choice == zoom_thread) {
1115 zoom_thread:
1116                         if (browser->hists->thread_filter) {
1117                                 pstack__remove(fstack, &browser->hists->thread_filter);
1118 zoom_out_thread:
1119                                 ui_helpline__pop();
1120                                 browser->hists->thread_filter = NULL;
1121                                 sort_thread.elide = false;
1122                         } else {
1123                                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1124                                                    thread->comm_set ? thread->comm : "",
1125                                                    thread->pid);
1126                                 browser->hists->thread_filter = thread;
1127                                 sort_thread.elide = true;
1128                                 pstack__push(fstack, &browser->hists->thread_filter);
1129                         }
1130                         hists__filter_by_thread(self);
1131                         hist_browser__reset(browser);
1132                 }
1133         }
1134 out_free_stack:
1135         pstack__delete(fstack);
1136 out:
1137         hist_browser__delete(browser);
1138         free_popup_options(options, nr_options - 1);
1139         return key;
1140 }
1141
1142 struct perf_evsel_menu {
1143         struct ui_browser b;
1144         struct perf_evsel *selection;
1145         bool lost_events, lost_events_warned;
1146 };
1147
1148 static void perf_evsel_menu__write(struct ui_browser *browser,
1149                                    void *entry, int row)
1150 {
1151         struct perf_evsel_menu *menu = container_of(browser,
1152                                                     struct perf_evsel_menu, b);
1153         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
1154         bool current_entry = ui_browser__is_current_entry(browser, row);
1155         unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
1156         const char *ev_name = event_name(evsel);
1157         char bf[256], unit;
1158         const char *warn = " ";
1159         size_t printed;
1160
1161         ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
1162                                                        HE_COLORSET_NORMAL);
1163
1164         nr_events = convert_unit(nr_events, &unit);
1165         printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
1166                            unit, unit == ' ' ? "" : " ", ev_name);
1167         slsmg_printf("%s", bf);
1168
1169         nr_events = evsel->hists.stats.nr_events[PERF_RECORD_LOST];
1170         if (nr_events != 0) {
1171                 menu->lost_events = true;
1172                 if (!current_entry)
1173                         ui_browser__set_color(browser, HE_COLORSET_TOP);
1174                 nr_events = convert_unit(nr_events, &unit);
1175                 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
1176                                      nr_events, unit, unit == ' ' ? "" : " ");
1177                 warn = bf;
1178         }
1179
1180         slsmg_write_nstring(warn, browser->width - printed);
1181
1182         if (current_entry)
1183                 menu->selection = evsel;
1184 }
1185
1186 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
1187                                 int nr_events, const char *help,
1188                                 void(*timer)(void *arg), void *arg, int delay_secs)
1189 {
1190         struct perf_evlist *evlist = menu->b.priv;
1191         struct perf_evsel *pos;
1192         const char *ev_name, *title = "Available samples";
1193         int key;
1194
1195         if (ui_browser__show(&menu->b, title,
1196                              "ESC: exit, ENTER|->: Browse histograms") < 0)
1197                 return -1;
1198
1199         while (1) {
1200                 key = ui_browser__run(&menu->b, delay_secs);
1201
1202                 switch (key) {
1203                 case K_TIMER:
1204                         timer(arg);
1205
1206                         if (!menu->lost_events_warned && menu->lost_events) {
1207                                 ui_browser__warn_lost_events(&menu->b);
1208                                 menu->lost_events_warned = true;
1209                         }
1210                         continue;
1211                 case K_RIGHT:
1212                 case K_ENTER:
1213                         if (!menu->selection)
1214                                 continue;
1215                         pos = menu->selection;
1216 browse_hists:
1217                         perf_evlist__set_selected(evlist, pos);
1218                         /*
1219                          * Give the calling tool a chance to populate the non
1220                          * default evsel resorted hists tree.
1221                          */
1222                         if (timer)
1223                                 timer(arg);
1224                         ev_name = event_name(pos);
1225                         key = perf_evsel__hists_browse(pos, nr_events, help,
1226                                                        ev_name, true, timer,
1227                                                        arg, delay_secs);
1228                         ui_browser__show_title(&menu->b, title);
1229                         switch (key) {
1230                         case K_TAB:
1231                                 if (pos->node.next == &evlist->entries)
1232                                         pos = list_entry(evlist->entries.next, struct perf_evsel, node);
1233                                 else
1234                                         pos = list_entry(pos->node.next, struct perf_evsel, node);
1235                                 goto browse_hists;
1236                         case K_UNTAB:
1237                                 if (pos->node.prev == &evlist->entries)
1238                                         pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
1239                                 else
1240                                         pos = list_entry(pos->node.prev, struct perf_evsel, node);
1241                                 goto browse_hists;
1242                         case K_ESC:
1243                                 if (!ui_browser__dialog_yesno(&menu->b,
1244                                                 "Do you really want to exit?"))
1245                                         continue;
1246                                 /* Fall thru */
1247                         case 'q':
1248                         case CTRL('c'):
1249                                 goto out;
1250                         default:
1251                                 continue;
1252                         }
1253                 case K_LEFT:
1254                         continue;
1255                 case K_ESC:
1256                         if (!ui_browser__dialog_yesno(&menu->b,
1257                                                "Do you really want to exit?"))
1258                                 continue;
1259                         /* Fall thru */
1260                 case 'q':
1261                 case CTRL('c'):
1262                         goto out;
1263                 default:
1264                         continue;
1265                 }
1266         }
1267
1268 out:
1269         ui_browser__hide(&menu->b);
1270         return key;
1271 }
1272
1273 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
1274                                            const char *help,
1275                                            void(*timer)(void *arg), void *arg,
1276                                            int delay_secs)
1277 {
1278         struct perf_evsel *pos;
1279         struct perf_evsel_menu menu = {
1280                 .b = {
1281                         .entries    = &evlist->entries,
1282                         .refresh    = ui_browser__list_head_refresh,
1283                         .seek       = ui_browser__list_head_seek,
1284                         .write      = perf_evsel_menu__write,
1285                         .nr_entries = evlist->nr_entries,
1286                         .priv       = evlist,
1287                 },
1288         };
1289
1290         ui_helpline__push("Press ESC to exit");
1291
1292         list_for_each_entry(pos, &evlist->entries, node) {
1293                 const char *ev_name = event_name(pos);
1294                 size_t line_len = strlen(ev_name) + 7;
1295
1296                 if (menu.b.width < line_len)
1297                         menu.b.width = line_len;
1298                 /*
1299                  * Cache the evsel name, tracepoints have a _high_ cost per
1300                  * event_name() call.
1301                  */
1302                 if (pos->name == NULL)
1303                         pos->name = strdup(ev_name);
1304         }
1305
1306         return perf_evsel_menu__run(&menu, evlist->nr_entries, help, timer,
1307                                     arg, delay_secs);
1308 }
1309
1310 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
1311                                   void(*timer)(void *arg), void *arg,
1312                                   int delay_secs)
1313 {
1314
1315         if (evlist->nr_entries == 1) {
1316                 struct perf_evsel *first = list_entry(evlist->entries.next,
1317                                                       struct perf_evsel, node);
1318                 const char *ev_name = event_name(first);
1319                 return perf_evsel__hists_browse(first, evlist->nr_entries, help,
1320                                                 ev_name, false, timer, arg,
1321                                                 delay_secs);
1322         }
1323
1324         return __perf_evlist__tui_browse_hists(evlist, help,
1325                                                timer, arg, delay_secs);
1326 }