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