2 #include "../libslang.h"
6 #include <linux/rbtree.h>
8 #include "../../evsel.h"
9 #include "../../evlist.h"
10 #include "../../hist.h"
11 #include "../../pstack.h"
12 #include "../../sort.h"
13 #include "../../util.h"
15 #include "../browser.h"
16 #include "../helpline.h"
24 struct hist_entry *he_selection;
25 struct map_symbol *selection;
29 static int hists__browser_title(struct hists *self, char *bf, size_t size,
32 static void hist_browser__refresh_dimensions(struct hist_browser *self)
34 /* 3 == +/- toggle symbol before actual hist_entry rendering */
35 self->b.width = 3 + (hists__sort_list_width(self->hists) +
39 static void hist_browser__reset(struct hist_browser *self)
41 self->b.nr_entries = self->hists->nr_entries;
42 hist_browser__refresh_dimensions(self);
43 ui_browser__reset_index(&self->b);
46 static char tree__folded_sign(bool unfolded)
48 return unfolded ? '-' : '+';
51 static char map_symbol__folded(const struct map_symbol *self)
53 return self->has_children ? tree__folded_sign(self->unfolded) : ' ';
56 static char hist_entry__folded(const struct hist_entry *self)
58 return map_symbol__folded(&self->ms);
61 static char callchain_list__folded(const struct callchain_list *self)
63 return map_symbol__folded(&self->ms);
66 static void map_symbol__set_folding(struct map_symbol *self, bool unfold)
68 self->unfolded = unfold ? self->has_children : false;
71 static int callchain_node__count_rows_rb_tree(struct callchain_node *self)
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 */
81 list_for_each_entry(chain, &child->val, list) {
83 /* We need this because we may not have children */
84 folded_sign = callchain_list__folded(chain);
85 if (folded_sign == '+')
89 if (folded_sign == '-') /* Have children and they're unfolded */
90 n += callchain_node__count_rows_rb_tree(child);
96 static int callchain_node__count_rows(struct callchain_node *node)
98 struct callchain_list *chain;
99 bool unfolded = false;
102 list_for_each_entry(chain, &node->val, list) {
104 unfolded = chain->ms.unfolded;
108 n += callchain_node__count_rows_rb_tree(node);
113 static int callchain__count_rows(struct rb_root *chain)
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);
126 static bool map_symbol__toggle_fold(struct map_symbol *self)
131 if (!self->has_children)
134 self->unfolded = !self->unfolded;
138 static void callchain_node__init_have_children_rb_tree(struct callchain_node *self)
140 struct rb_node *nd = rb_first(&self->rb_root);
142 for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
143 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
144 struct callchain_list *chain;
147 list_for_each_entry(chain, &child->val, list) {
150 chain->ms.has_children = chain->list.next != &child->val ||
151 !RB_EMPTY_ROOT(&child->rb_root);
153 chain->ms.has_children = chain->list.next == &child->val &&
154 !RB_EMPTY_ROOT(&child->rb_root);
157 callchain_node__init_have_children_rb_tree(child);
161 static void callchain_node__init_have_children(struct callchain_node *self)
163 struct callchain_list *chain;
165 list_for_each_entry(chain, &self->val, list)
166 chain->ms.has_children = !RB_EMPTY_ROOT(&self->rb_root);
168 callchain_node__init_have_children_rb_tree(self);
171 static void callchain__init_have_children(struct rb_root *self)
175 for (nd = rb_first(self); nd; nd = rb_next(nd)) {
176 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
177 callchain_node__init_have_children(node);
181 static void hist_entry__init_have_children(struct hist_entry *self)
183 if (!self->init_have_children) {
184 self->ms.has_children = !RB_EMPTY_ROOT(&self->sorted_chain);
185 callchain__init_have_children(&self->sorted_chain);
186 self->init_have_children = true;
190 static bool hist_browser__toggle_fold(struct hist_browser *self)
192 if (map_symbol__toggle_fold(self->selection)) {
193 struct hist_entry *he = self->he_selection;
195 hist_entry__init_have_children(he);
196 self->hists->nr_entries -= he->nr_rows;
199 he->nr_rows = callchain__count_rows(&he->sorted_chain);
202 self->hists->nr_entries += he->nr_rows;
203 self->b.nr_entries = self->hists->nr_entries;
208 /* If it doesn't have children, no toggling performed */
212 static int callchain_node__set_folding_rb_tree(struct callchain_node *self, bool unfold)
217 for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
218 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
219 struct callchain_list *chain;
220 bool has_children = false;
222 list_for_each_entry(chain, &child->val, list) {
224 map_symbol__set_folding(&chain->ms, unfold);
225 has_children = chain->ms.has_children;
229 n += callchain_node__set_folding_rb_tree(child, unfold);
235 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
237 struct callchain_list *chain;
238 bool has_children = false;
241 list_for_each_entry(chain, &node->val, list) {
243 map_symbol__set_folding(&chain->ms, unfold);
244 has_children = chain->ms.has_children;
248 n += callchain_node__set_folding_rb_tree(node, unfold);
253 static int callchain__set_folding(struct rb_root *chain, bool unfold)
258 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
259 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
260 n += callchain_node__set_folding(node, unfold);
266 static void hist_entry__set_folding(struct hist_entry *self, bool unfold)
268 hist_entry__init_have_children(self);
269 map_symbol__set_folding(&self->ms, unfold);
271 if (self->ms.has_children) {
272 int n = callchain__set_folding(&self->sorted_chain, unfold);
273 self->nr_rows = unfold ? n : 0;
278 static void hists__set_folding(struct hists *self, bool unfold)
282 self->nr_entries = 0;
284 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
285 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
286 hist_entry__set_folding(he, unfold);
287 self->nr_entries += 1 + he->nr_rows;
291 static void hist_browser__set_folding(struct hist_browser *self, bool unfold)
293 hists__set_folding(self->hists, unfold);
294 self->b.nr_entries = self->hists->nr_entries;
295 /* Go to the start, we may be way after valid entries after a collapse */
296 ui_browser__reset_index(&self->b);
299 static void ui_browser__warn_lost_events(struct ui_browser *browser)
301 ui_browser__warning(browser, 4,
302 "Events are being lost, check IO/CPU overload!\n\n"
303 "You may want to run 'perf' using a RT scheduler policy:\n\n"
304 " perf top -r 80\n\n"
305 "Or reduce the sampling frequency.");
308 static int hist_browser__run(struct hist_browser *self, const char *ev_name,
309 void(*timer)(void *arg), void *arg, int delay_secs)
314 self->b.entries = &self->hists->entries;
315 self->b.nr_entries = self->hists->nr_entries;
317 hist_browser__refresh_dimensions(self);
318 hists__browser_title(self->hists, title, sizeof(title), ev_name);
320 if (ui_browser__show(&self->b, title,
321 "Press '?' for help on key bindings") < 0)
325 key = ui_browser__run(&self->b, delay_secs);
330 ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
332 if (self->hists->stats.nr_lost_warned !=
333 self->hists->stats.nr_events[PERF_RECORD_LOST]) {
334 self->hists->stats.nr_lost_warned =
335 self->hists->stats.nr_events[PERF_RECORD_LOST];
336 ui_browser__warn_lost_events(&self->b);
339 hists__browser_title(self->hists, title, sizeof(title), ev_name);
340 ui_browser__show_title(&self->b, title);
342 case 'D': { /* Debug */
344 struct hist_entry *h = rb_entry(self->b.top,
345 struct hist_entry, rb_node);
347 ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
348 seq++, self->b.nr_entries,
349 self->hists->nr_entries,
353 h->row_offset, h->nr_rows);
357 /* Collapse the whole world. */
358 hist_browser__set_folding(self, false);
361 /* Expand the whole world. */
362 hist_browser__set_folding(self, true);
365 if (hist_browser__toggle_fold(self))
373 ui_browser__hide(&self->b);
377 static char *callchain_list__sym_name(struct callchain_list *self,
378 char *bf, size_t bfsize)
381 return self->ms.sym->name;
383 snprintf(bf, bfsize, "%#" PRIx64, self->ip);
387 #define LEVEL_OFFSET_STEP 3
389 static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
390 struct callchain_node *chain_node,
391 u64 total, int level,
394 bool *is_current_entry)
396 struct rb_node *node;
397 int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
398 u64 new_total, remaining;
400 if (callchain_param.mode == CHAIN_GRAPH_REL)
401 new_total = chain_node->children_hit;
405 remaining = new_total;
406 node = rb_first(&chain_node->rb_root);
408 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
409 struct rb_node *next = rb_next(node);
410 u64 cumul = callchain_cumul_hits(child);
411 struct callchain_list *chain;
412 char folded_sign = ' ';
414 int extra_offset = 0;
418 list_for_each_entry(chain, &child->val, list) {
419 char ipstr[BITS_PER_LONG / 4 + 1], *alloc_str;
422 bool was_first = first;
427 extra_offset = LEVEL_OFFSET_STEP;
429 folded_sign = callchain_list__folded(chain);
430 if (*row_offset != 0) {
436 str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
438 double percent = cumul * 100.0 / new_total;
440 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
441 str = "Not enough memory!";
446 color = HE_COLORSET_NORMAL;
447 width = self->b.width - (offset + extra_offset + 2);
448 if (ui_browser__is_current_entry(&self->b, row)) {
449 self->selection = &chain->ms;
450 color = HE_COLORSET_SELECTED;
451 *is_current_entry = true;
454 ui_browser__set_color(&self->b, color);
455 ui_browser__gotorc(&self->b, row, 0);
456 slsmg_write_nstring(" ", offset + extra_offset);
457 slsmg_printf("%c ", folded_sign);
458 slsmg_write_nstring(str, width);
461 if (++row == self->b.height)
464 if (folded_sign == '+')
468 if (folded_sign == '-') {
469 const int new_level = level + (extra_offset ? 2 : 1);
470 row += hist_browser__show_callchain_node_rb_tree(self, child, new_total,
471 new_level, row, row_offset,
474 if (row == self->b.height)
479 return row - first_row;
482 static int hist_browser__show_callchain_node(struct hist_browser *self,
483 struct callchain_node *node,
484 int level, unsigned short row,
486 bool *is_current_entry)
488 struct callchain_list *chain;
490 offset = level * LEVEL_OFFSET_STEP,
491 width = self->b.width - offset;
492 char folded_sign = ' ';
494 list_for_each_entry(chain, &node->val, list) {
495 char ipstr[BITS_PER_LONG / 4 + 1], *s;
498 folded_sign = callchain_list__folded(chain);
500 if (*row_offset != 0) {
505 color = HE_COLORSET_NORMAL;
506 if (ui_browser__is_current_entry(&self->b, row)) {
507 self->selection = &chain->ms;
508 color = HE_COLORSET_SELECTED;
509 *is_current_entry = true;
512 s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
513 ui_browser__gotorc(&self->b, row, 0);
514 ui_browser__set_color(&self->b, color);
515 slsmg_write_nstring(" ", offset);
516 slsmg_printf("%c ", folded_sign);
517 slsmg_write_nstring(s, width - 2);
519 if (++row == self->b.height)
523 if (folded_sign == '-')
524 row += hist_browser__show_callchain_node_rb_tree(self, node,
525 self->hists->stats.total_period,
530 return row - first_row;
533 static int hist_browser__show_callchain(struct hist_browser *self,
534 struct rb_root *chain,
535 int level, unsigned short row,
537 bool *is_current_entry)
542 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
543 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
545 row += hist_browser__show_callchain_node(self, node, level,
548 if (row == self->b.height)
552 return row - first_row;
555 static int hist_browser__show_entry(struct hist_browser *self,
556 struct hist_entry *entry,
562 int width = self->b.width - 6; /* The percentage */
563 char folded_sign = ' ';
564 bool current_entry = ui_browser__is_current_entry(&self->b, row);
565 off_t row_offset = entry->row_offset;
568 self->he_selection = entry;
569 self->selection = &entry->ms;
572 if (symbol_conf.use_callchain) {
573 hist_entry__init_have_children(entry);
574 folded_sign = hist_entry__folded(entry);
577 if (row_offset == 0) {
578 hist_entry__snprintf(entry, s, sizeof(s), self->hists);
579 percent = (entry->period * 100.0) / self->hists->stats.total_period;
581 ui_browser__set_percent_color(&self->b, percent, current_entry);
582 ui_browser__gotorc(&self->b, row, 0);
583 if (symbol_conf.use_callchain) {
584 slsmg_printf("%c ", folded_sign);
588 slsmg_printf(" %5.2f%%", percent);
590 /* The scroll bar isn't being used */
591 if (!self->b.navkeypressed)
594 if (!current_entry || !self->b.navkeypressed)
595 ui_browser__set_color(&self->b, HE_COLORSET_NORMAL);
597 if (symbol_conf.show_nr_samples) {
598 slsmg_printf(" %11u", entry->nr_events);
602 if (symbol_conf.show_total_period) {
603 slsmg_printf(" %12" PRIu64, entry->period);
607 slsmg_write_nstring(s, width);
613 if (folded_sign == '-' && row != self->b.height) {
614 printed += hist_browser__show_callchain(self, &entry->sorted_chain,
618 self->he_selection = entry;
624 static void ui_browser__hists_init_top(struct ui_browser *browser)
626 if (browser->top == NULL) {
627 struct hist_browser *hb;
629 hb = container_of(browser, struct hist_browser, b);
630 browser->top = rb_first(&hb->hists->entries);
634 static unsigned int hist_browser__refresh(struct ui_browser *self)
638 struct hist_browser *hb = container_of(self, struct hist_browser, b);
640 ui_browser__hists_init_top(self);
642 for (nd = self->top; nd; nd = rb_next(nd)) {
643 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
648 row += hist_browser__show_entry(hb, h, row);
649 if (row == self->height)
656 static struct rb_node *hists__filter_entries(struct rb_node *nd)
659 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
669 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
672 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
682 static void ui_browser__hists_seek(struct ui_browser *self,
683 off_t offset, int whence)
685 struct hist_entry *h;
689 if (self->nr_entries == 0)
692 ui_browser__hists_init_top(self);
696 nd = hists__filter_entries(rb_first(self->entries));
702 nd = hists__filter_prev_entries(rb_last(self->entries));
710 * Moves not relative to the first visible entry invalidates its
713 h = rb_entry(self->top, struct hist_entry, rb_node);
717 * Here we have to check if nd is expanded (+), if it is we can't go
718 * the next top level hist_entry, instead we must compute an offset of
719 * what _not_ to show and not change the first visible entry.
721 * This offset increments when we are going from top to bottom and
722 * decreases when we're going from bottom to top.
724 * As we don't have backpointers to the top level in the callchains
725 * structure, we need to always print the whole hist_entry callchain,
726 * skipping the first ones that are before the first visible entry
727 * and stop when we printed enough lines to fill the screen.
732 h = rb_entry(nd, struct hist_entry, rb_node);
733 if (h->ms.unfolded) {
734 u16 remaining = h->nr_rows - h->row_offset;
735 if (offset > remaining) {
739 h->row_offset += offset;
745 nd = hists__filter_entries(rb_next(nd));
750 } while (offset != 0);
751 } else if (offset < 0) {
753 h = rb_entry(nd, struct hist_entry, rb_node);
754 if (h->ms.unfolded) {
756 if (-offset > h->row_offset) {
757 offset += h->row_offset;
760 h->row_offset += offset;
766 if (-offset > h->nr_rows) {
767 offset += h->nr_rows;
770 h->row_offset = h->nr_rows + offset;
778 nd = hists__filter_prev_entries(rb_prev(nd));
785 * Last unfiltered hist_entry, check if it is
786 * unfolded, if it is then we should have
787 * row_offset at its last entry.
789 h = rb_entry(nd, struct hist_entry, rb_node);
791 h->row_offset = h->nr_rows;
798 h = rb_entry(nd, struct hist_entry, rb_node);
803 static struct hist_browser *hist_browser__new(struct hists *hists)
805 struct hist_browser *self = zalloc(sizeof(*self));
809 self->b.refresh = hist_browser__refresh;
810 self->b.seek = ui_browser__hists_seek;
811 self->b.use_navkeypressed = true;
812 if (sort__branch_mode == 1)
813 self->has_symbols = sort_sym_from.list.next != NULL;
815 self->has_symbols = sort_sym.list.next != NULL;
821 static void hist_browser__delete(struct hist_browser *self)
826 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
828 return self->he_selection;
831 static struct thread *hist_browser__selected_thread(struct hist_browser *self)
833 return self->he_selection->thread;
836 static int hists__browser_title(struct hists *self, char *bf, size_t size,
841 const struct dso *dso = self->dso_filter;
842 const struct thread *thread = self->thread_filter;
843 unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
845 nr_events = convert_unit(nr_events, &unit);
846 printed = scnprintf(bf, size, "Events: %lu%c %s", nr_events, unit, ev_name);
848 if (self->uid_filter_str)
849 printed += snprintf(bf + printed, size - printed,
850 ", UID: %s", self->uid_filter_str);
852 printed += scnprintf(bf + printed, size - printed,
854 (thread->comm_set ? thread->comm : ""),
857 printed += scnprintf(bf + printed, size - printed,
858 ", DSO: %s", dso->short_name);
862 static inline void free_popup_options(char **options, int n)
866 for (i = 0; i < n; ++i) {
872 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
873 const char *helpline, const char *ev_name,
875 void(*timer)(void *arg), void *arg,
878 struct hists *self = &evsel->hists;
879 struct hist_browser *browser = hist_browser__new(self);
880 struct branch_info *bi;
881 struct pstack *fstack;
890 fstack = pstack__new(2);
894 ui_helpline__push(helpline);
896 memset(options, 0, sizeof(options));
899 const struct thread *thread = NULL;
900 const struct dso *dso = NULL;
902 annotate = -2, zoom_dso = -2, zoom_thread = -2,
903 annotate_f = -2, annotate_t = -2, browse_map = -2;
907 key = hist_browser__run(browser, ev_name, timer, arg, delay_secs);
909 if (browser->he_selection != NULL) {
910 thread = hist_browser__selected_thread(browser);
911 dso = browser->selection->map ? browser->selection->map->dso : NULL;
919 * Exit the browser, let hists__browser_tree
920 * go to the next or previous
924 if (!browser->has_symbols) {
925 ui_browser__warning(&browser->b, delay_secs * 2,
926 "Annotation is only available for symbolic views, "
927 "include \"sym*\" in --sort to use it.");
931 if (browser->selection == NULL ||
932 browser->selection->sym == NULL ||
933 browser->selection->map->dso->annotate_warned)
941 if (ui_browser__input_window("Symbol to show",
942 "Please enter the name of symbol you want to see",
943 buf, "ENTER: OK, ESC: Cancel",
944 delay_secs * 2) == K_ENTER) {
945 self->symbol_filter_str = *buf ? buf : NULL;
946 hists__filter_by_symbol(self);
947 hist_browser__reset(browser);
953 ui_browser__help_window(&browser->b,
954 "h/?/F1 Show this window\n"
956 "PGDN/SPACE Navigate\n"
957 "q/ESC/CTRL+C Exit browser\n\n"
958 "For multiple event sessions:\n\n"
959 "TAB/UNTAB Switch events\n\n"
960 "For symbolic views (--sort has sym):\n\n"
961 "-> Zoom into DSO/Threads & Annotate current symbol\n"
963 "a Annotate current symbol\n"
964 "C Collapse all callchains\n"
965 "E Expand all callchains\n"
966 "d Zoom into current DSO\n"
967 "t Zoom into current Thread\n"
968 "s Filter symbol by name");
977 if (pstack__empty(fstack)) {
979 * Go back to the perf_evsel_menu__run or other user
985 top = pstack__pop(fstack);
986 if (top == &browser->hists->dso_filter)
988 if (top == &browser->hists->thread_filter)
989 goto zoom_out_thread;
994 !ui_browser__dialog_yesno(&browser->b,
995 "Do you really want to exit?"))
1000 goto out_free_stack;
1005 if (!browser->has_symbols)
1006 goto add_exit_option;
1008 if (sort__branch_mode == 1) {
1009 bi = browser->he_selection->branch_info;
1010 if (browser->selection != NULL &&
1012 bi->from.sym != NULL &&
1013 !bi->from.map->dso->annotate_warned &&
1014 asprintf(&options[nr_options], "Annotate %s",
1015 bi->from.sym->name) > 0)
1016 annotate_f = nr_options++;
1018 if (browser->selection != NULL &&
1020 bi->to.sym != NULL &&
1021 !bi->to.map->dso->annotate_warned &&
1022 (bi->to.sym != bi->from.sym ||
1023 bi->to.map->dso != bi->from.map->dso) &&
1024 asprintf(&options[nr_options], "Annotate %s",
1025 bi->to.sym->name) > 0)
1026 annotate_t = nr_options++;
1029 if (browser->selection != NULL &&
1030 browser->selection->sym != NULL &&
1031 !browser->selection->map->dso->annotate_warned &&
1032 asprintf(&options[nr_options], "Annotate %s",
1033 browser->selection->sym->name) > 0)
1034 annotate = nr_options++;
1037 if (thread != NULL &&
1038 asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
1039 (browser->hists->thread_filter ? "out of" : "into"),
1040 (thread->comm_set ? thread->comm : ""),
1042 zoom_thread = nr_options++;
1045 asprintf(&options[nr_options], "Zoom %s %s DSO",
1046 (browser->hists->dso_filter ? "out of" : "into"),
1047 (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
1048 zoom_dso = nr_options++;
1050 if (browser->selection != NULL &&
1051 browser->selection->map != NULL &&
1052 asprintf(&options[nr_options], "Browse map details") > 0)
1053 browse_map = nr_options++;
1055 options[nr_options++] = (char *)"Exit";
1057 choice = ui__popup_menu(nr_options, options);
1059 if (choice == nr_options - 1)
1063 free_popup_options(options, nr_options - 1);
1067 if (choice == annotate || choice == annotate_t || choice == annotate_f) {
1068 struct hist_entry *he;
1071 he = hist_browser__selected_entry(browser);
1076 * we stash the branch_info symbol + map into the
1077 * the ms so we don't have to rewrite all the annotation
1078 * code to use branch_info.
1079 * in branch mode, the ms struct is not used
1081 if (choice == annotate_f) {
1082 he->ms.sym = he->branch_info->from.sym;
1083 he->ms.map = he->branch_info->from.map;
1084 } else if (choice == annotate_t) {
1085 he->ms.sym = he->branch_info->to.sym;
1086 he->ms.map = he->branch_info->to.map;
1090 * Don't let this be freed, say, by hists__decay_entry.
1093 err = hist_entry__tui_annotate(he, evsel->idx,
1094 timer, arg, delay_secs);
1097 * offer option to annotate the other branch source or target
1098 * (if they exists) when returning from annotate
1100 if ((err == 'q' || err == CTRL('c'))
1101 && annotate_t != -2 && annotate_f != -2)
1102 goto retry_popup_menu;
1104 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
1106 ui_browser__handle_resize(&browser->b);
1108 } else if (choice == browse_map)
1109 map__browse(browser->selection->map);
1110 else if (choice == zoom_dso) {
1112 if (browser->hists->dso_filter) {
1113 pstack__remove(fstack, &browser->hists->dso_filter);
1116 browser->hists->dso_filter = NULL;
1117 sort_dso.elide = false;
1121 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1122 dso->kernel ? "the Kernel" : dso->short_name);
1123 browser->hists->dso_filter = dso;
1124 sort_dso.elide = true;
1125 pstack__push(fstack, &browser->hists->dso_filter);
1127 hists__filter_by_dso(self);
1128 hist_browser__reset(browser);
1129 } else if (choice == zoom_thread) {
1131 if (browser->hists->thread_filter) {
1132 pstack__remove(fstack, &browser->hists->thread_filter);
1135 browser->hists->thread_filter = NULL;
1136 sort_thread.elide = false;
1138 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1139 thread->comm_set ? thread->comm : "",
1141 browser->hists->thread_filter = thread;
1142 sort_thread.elide = true;
1143 pstack__push(fstack, &browser->hists->thread_filter);
1145 hists__filter_by_thread(self);
1146 hist_browser__reset(browser);
1150 pstack__delete(fstack);
1152 hist_browser__delete(browser);
1153 free_popup_options(options, nr_options - 1);
1157 struct perf_evsel_menu {
1158 struct ui_browser b;
1159 struct perf_evsel *selection;
1160 bool lost_events, lost_events_warned;
1163 static void perf_evsel_menu__write(struct ui_browser *browser,
1164 void *entry, int row)
1166 struct perf_evsel_menu *menu = container_of(browser,
1167 struct perf_evsel_menu, b);
1168 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
1169 bool current_entry = ui_browser__is_current_entry(browser, row);
1170 unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
1171 const char *ev_name = event_name(evsel);
1173 const char *warn = " ";
1176 ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
1177 HE_COLORSET_NORMAL);
1179 nr_events = convert_unit(nr_events, &unit);
1180 printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
1181 unit, unit == ' ' ? "" : " ", ev_name);
1182 slsmg_printf("%s", bf);
1184 nr_events = evsel->hists.stats.nr_events[PERF_RECORD_LOST];
1185 if (nr_events != 0) {
1186 menu->lost_events = true;
1188 ui_browser__set_color(browser, HE_COLORSET_TOP);
1189 nr_events = convert_unit(nr_events, &unit);
1190 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
1191 nr_events, unit, unit == ' ' ? "" : " ");
1195 slsmg_write_nstring(warn, browser->width - printed);
1198 menu->selection = evsel;
1201 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
1202 int nr_events, const char *help,
1203 void(*timer)(void *arg), void *arg, int delay_secs)
1205 struct perf_evlist *evlist = menu->b.priv;
1206 struct perf_evsel *pos;
1207 const char *ev_name, *title = "Available samples";
1210 if (ui_browser__show(&menu->b, title,
1211 "ESC: exit, ENTER|->: Browse histograms") < 0)
1215 key = ui_browser__run(&menu->b, delay_secs);
1221 if (!menu->lost_events_warned && menu->lost_events) {
1222 ui_browser__warn_lost_events(&menu->b);
1223 menu->lost_events_warned = true;
1228 if (!menu->selection)
1230 pos = menu->selection;
1232 perf_evlist__set_selected(evlist, pos);
1234 * Give the calling tool a chance to populate the non
1235 * default evsel resorted hists tree.
1239 ev_name = event_name(pos);
1240 key = perf_evsel__hists_browse(pos, nr_events, help,
1241 ev_name, true, timer,
1243 ui_browser__show_title(&menu->b, title);
1246 if (pos->node.next == &evlist->entries)
1247 pos = list_entry(evlist->entries.next, struct perf_evsel, node);
1249 pos = list_entry(pos->node.next, struct perf_evsel, node);
1252 if (pos->node.prev == &evlist->entries)
1253 pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
1255 pos = list_entry(pos->node.prev, struct perf_evsel, node);
1258 if (!ui_browser__dialog_yesno(&menu->b,
1259 "Do you really want to exit?"))
1271 if (!ui_browser__dialog_yesno(&menu->b,
1272 "Do you really want to exit?"))
1284 ui_browser__hide(&menu->b);
1288 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
1290 void(*timer)(void *arg), void *arg,
1293 struct perf_evsel *pos;
1294 struct perf_evsel_menu menu = {
1296 .entries = &evlist->entries,
1297 .refresh = ui_browser__list_head_refresh,
1298 .seek = ui_browser__list_head_seek,
1299 .write = perf_evsel_menu__write,
1300 .nr_entries = evlist->nr_entries,
1305 ui_helpline__push("Press ESC to exit");
1307 list_for_each_entry(pos, &evlist->entries, node) {
1308 const char *ev_name = event_name(pos);
1309 size_t line_len = strlen(ev_name) + 7;
1311 if (menu.b.width < line_len)
1312 menu.b.width = line_len;
1314 * Cache the evsel name, tracepoints have a _high_ cost per
1315 * event_name() call.
1317 if (pos->name == NULL)
1318 pos->name = strdup(ev_name);
1321 return perf_evsel_menu__run(&menu, evlist->nr_entries, help, timer,
1325 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
1326 void(*timer)(void *arg), void *arg,
1330 if (evlist->nr_entries == 1) {
1331 struct perf_evsel *first = list_entry(evlist->entries.next,
1332 struct perf_evsel, node);
1333 const char *ev_name = event_name(first);
1334 return perf_evsel__hists_browse(first, evlist->nr_entries, help,
1335 ev_name, false, timer, arg,
1339 return __perf_evlist__tui_browse_hists(evlist, help,
1340 timer, arg, delay_secs);