]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - tools/perf/ui/browsers/hists.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf tools: Remove dependency on libnewt
[mirror_ubuntu-artful-kernel.git] / tools / perf / ui / browsers / hists.c
1 #include <stdio.h>
2 #include "../libslang.h"
3 #include <stdlib.h>
4 #include <string.h>
5 #include <linux/rbtree.h>
6
7 #include "../../util/evsel.h"
8 #include "../../util/evlist.h"
9 #include "../../util/hist.h"
10 #include "../../util/pstack.h"
11 #include "../../util/sort.h"
12 #include "../../util/util.h"
13 #include "../../arch/common.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 int print_seq;
27 bool show_dso;
28 bool has_symbols;
29 };
30
31 extern void hist_browser__init_hpp(void);
32
33 static int hists__browser_title(struct hists *hists, char *bf, size_t size,
34 const char *ev_name);
35
36 static void hist_browser__refresh_dimensions(struct hist_browser *browser)
37 {
38 /* 3 == +/- toggle symbol before actual hist_entry rendering */
39 browser->b.width = 3 + (hists__sort_list_width(browser->hists) +
40 sizeof("[k]"));
41 }
42
43 static void hist_browser__reset(struct hist_browser *browser)
44 {
45 browser->b.nr_entries = browser->hists->nr_entries;
46 hist_browser__refresh_dimensions(browser);
47 ui_browser__reset_index(&browser->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 *ms)
56 {
57 return ms->has_children ? tree__folded_sign(ms->unfolded) : ' ';
58 }
59
60 static char hist_entry__folded(const struct hist_entry *he)
61 {
62 return map_symbol__folded(&he->ms);
63 }
64
65 static char callchain_list__folded(const struct callchain_list *cl)
66 {
67 return map_symbol__folded(&cl->ms);
68 }
69
70 static void map_symbol__set_folding(struct map_symbol *ms, bool unfold)
71 {
72 ms->unfolded = unfold ? ms->has_children : false;
73 }
74
75 static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
76 {
77 int n = 0;
78 struct rb_node *nd;
79
80 for (nd = rb_first(&node->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 *ms)
131 {
132 if (!ms)
133 return false;
134
135 if (!ms->has_children)
136 return false;
137
138 ms->unfolded = !ms->unfolded;
139 return true;
140 }
141
142 static void callchain_node__init_have_children_rb_tree(struct callchain_node *node)
143 {
144 struct rb_node *nd = rb_first(&node->rb_root);
145
146 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
147 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
148 struct callchain_list *chain;
149 bool first = true;
150
151 list_for_each_entry(chain, &child->val, list) {
152 if (first) {
153 first = false;
154 chain->ms.has_children = chain->list.next != &child->val ||
155 !RB_EMPTY_ROOT(&child->rb_root);
156 } else
157 chain->ms.has_children = chain->list.next == &child->val &&
158 !RB_EMPTY_ROOT(&child->rb_root);
159 }
160
161 callchain_node__init_have_children_rb_tree(child);
162 }
163 }
164
165 static void callchain_node__init_have_children(struct callchain_node *node)
166 {
167 struct callchain_list *chain;
168
169 list_for_each_entry(chain, &node->val, list)
170 chain->ms.has_children = !RB_EMPTY_ROOT(&node->rb_root);
171
172 callchain_node__init_have_children_rb_tree(node);
173 }
174
175 static void callchain__init_have_children(struct rb_root *root)
176 {
177 struct rb_node *nd;
178
179 for (nd = rb_first(root); nd; nd = rb_next(nd)) {
180 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
181 callchain_node__init_have_children(node);
182 }
183 }
184
185 static void hist_entry__init_have_children(struct hist_entry *he)
186 {
187 if (!he->init_have_children) {
188 he->ms.has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
189 callchain__init_have_children(&he->sorted_chain);
190 he->init_have_children = true;
191 }
192 }
193
194 static bool hist_browser__toggle_fold(struct hist_browser *browser)
195 {
196 if (map_symbol__toggle_fold(browser->selection)) {
197 struct hist_entry *he = browser->he_selection;
198
199 hist_entry__init_have_children(he);
200 browser->hists->nr_entries -= he->nr_rows;
201
202 if (he->ms.unfolded)
203 he->nr_rows = callchain__count_rows(&he->sorted_chain);
204 else
205 he->nr_rows = 0;
206 browser->hists->nr_entries += he->nr_rows;
207 browser->b.nr_entries = browser->hists->nr_entries;
208
209 return true;
210 }
211
212 /* If it doesn't have children, no toggling performed */
213 return false;
214 }
215
216 static int callchain_node__set_folding_rb_tree(struct callchain_node *node, bool unfold)
217 {
218 int n = 0;
219 struct rb_node *nd;
220
221 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
222 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
223 struct callchain_list *chain;
224 bool has_children = false;
225
226 list_for_each_entry(chain, &child->val, list) {
227 ++n;
228 map_symbol__set_folding(&chain->ms, unfold);
229 has_children = chain->ms.has_children;
230 }
231
232 if (has_children)
233 n += callchain_node__set_folding_rb_tree(child, unfold);
234 }
235
236 return n;
237 }
238
239 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
240 {
241 struct callchain_list *chain;
242 bool has_children = false;
243 int n = 0;
244
245 list_for_each_entry(chain, &node->val, list) {
246 ++n;
247 map_symbol__set_folding(&chain->ms, unfold);
248 has_children = chain->ms.has_children;
249 }
250
251 if (has_children)
252 n += callchain_node__set_folding_rb_tree(node, unfold);
253
254 return n;
255 }
256
257 static int callchain__set_folding(struct rb_root *chain, bool unfold)
258 {
259 struct rb_node *nd;
260 int n = 0;
261
262 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
263 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
264 n += callchain_node__set_folding(node, unfold);
265 }
266
267 return n;
268 }
269
270 static void hist_entry__set_folding(struct hist_entry *he, bool unfold)
271 {
272 hist_entry__init_have_children(he);
273 map_symbol__set_folding(&he->ms, unfold);
274
275 if (he->ms.has_children) {
276 int n = callchain__set_folding(&he->sorted_chain, unfold);
277 he->nr_rows = unfold ? n : 0;
278 } else
279 he->nr_rows = 0;
280 }
281
282 static void hists__set_folding(struct hists *hists, bool unfold)
283 {
284 struct rb_node *nd;
285
286 hists->nr_entries = 0;
287
288 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
289 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
290 hist_entry__set_folding(he, unfold);
291 hists->nr_entries += 1 + he->nr_rows;
292 }
293 }
294
295 static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
296 {
297 hists__set_folding(browser->hists, unfold);
298 browser->b.nr_entries = browser->hists->nr_entries;
299 /* Go to the start, we may be way after valid entries after a collapse */
300 ui_browser__reset_index(&browser->b);
301 }
302
303 static void ui_browser__warn_lost_events(struct ui_browser *browser)
304 {
305 ui_browser__warning(browser, 4,
306 "Events are being lost, check IO/CPU overload!\n\n"
307 "You may want to run 'perf' using a RT scheduler policy:\n\n"
308 " perf top -r 80\n\n"
309 "Or reduce the sampling frequency.");
310 }
311
312 static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
313 struct hist_browser_timer *hbt)
314 {
315 int key;
316 char title[160];
317 int delay_secs = hbt ? hbt->refresh : 0;
318
319 browser->b.entries = &browser->hists->entries;
320 browser->b.nr_entries = browser->hists->nr_entries;
321
322 hist_browser__refresh_dimensions(browser);
323 hists__browser_title(browser->hists, title, sizeof(title), ev_name);
324
325 if (ui_browser__show(&browser->b, title,
326 "Press '?' for help on key bindings") < 0)
327 return -1;
328
329 while (1) {
330 key = ui_browser__run(&browser->b, delay_secs);
331
332 switch (key) {
333 case K_TIMER:
334 hbt->timer(hbt->arg);
335 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
336
337 if (browser->hists->stats.nr_lost_warned !=
338 browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
339 browser->hists->stats.nr_lost_warned =
340 browser->hists->stats.nr_events[PERF_RECORD_LOST];
341 ui_browser__warn_lost_events(&browser->b);
342 }
343
344 hists__browser_title(browser->hists, title, sizeof(title), ev_name);
345 ui_browser__show_title(&browser->b, title);
346 continue;
347 case 'D': { /* Debug */
348 static int seq;
349 struct hist_entry *h = rb_entry(browser->b.top,
350 struct hist_entry, rb_node);
351 ui_helpline__pop();
352 ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
353 seq++, browser->b.nr_entries,
354 browser->hists->nr_entries,
355 browser->b.height,
356 browser->b.index,
357 browser->b.top_idx,
358 h->row_offset, h->nr_rows);
359 }
360 break;
361 case 'C':
362 /* Collapse the whole world. */
363 hist_browser__set_folding(browser, false);
364 break;
365 case 'E':
366 /* Expand the whole world. */
367 hist_browser__set_folding(browser, true);
368 break;
369 case K_ENTER:
370 if (hist_browser__toggle_fold(browser))
371 break;
372 /* fall thru */
373 default:
374 goto out;
375 }
376 }
377 out:
378 ui_browser__hide(&browser->b);
379 return key;
380 }
381
382 static char *callchain_list__sym_name(struct callchain_list *cl,
383 char *bf, size_t bfsize, bool show_dso)
384 {
385 int printed;
386
387 if (cl->ms.sym)
388 printed = scnprintf(bf, bfsize, "%s", cl->ms.sym->name);
389 else
390 printed = scnprintf(bf, bfsize, "%#" PRIx64, cl->ip);
391
392 if (show_dso)
393 scnprintf(bf + printed, bfsize - printed, " %s",
394 cl->ms.map ? cl->ms.map->dso->short_name : "unknown");
395
396 return bf;
397 }
398
399 #define LEVEL_OFFSET_STEP 3
400
401 static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browser,
402 struct callchain_node *chain_node,
403 u64 total, int level,
404 unsigned short row,
405 off_t *row_offset,
406 bool *is_current_entry)
407 {
408 struct rb_node *node;
409 int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
410 u64 new_total, remaining;
411
412 if (callchain_param.mode == CHAIN_GRAPH_REL)
413 new_total = chain_node->children_hit;
414 else
415 new_total = total;
416
417 remaining = new_total;
418 node = rb_first(&chain_node->rb_root);
419 while (node) {
420 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
421 struct rb_node *next = rb_next(node);
422 u64 cumul = callchain_cumul_hits(child);
423 struct callchain_list *chain;
424 char folded_sign = ' ';
425 int first = true;
426 int extra_offset = 0;
427
428 remaining -= cumul;
429
430 list_for_each_entry(chain, &child->val, list) {
431 char bf[1024], *alloc_str;
432 const char *str;
433 int color;
434 bool was_first = first;
435
436 if (first)
437 first = false;
438 else
439 extra_offset = LEVEL_OFFSET_STEP;
440
441 folded_sign = callchain_list__folded(chain);
442 if (*row_offset != 0) {
443 --*row_offset;
444 goto do_next;
445 }
446
447 alloc_str = NULL;
448 str = callchain_list__sym_name(chain, bf, sizeof(bf),
449 browser->show_dso);
450 if (was_first) {
451 double percent = cumul * 100.0 / new_total;
452
453 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
454 str = "Not enough memory!";
455 else
456 str = alloc_str;
457 }
458
459 color = HE_COLORSET_NORMAL;
460 width = browser->b.width - (offset + extra_offset + 2);
461 if (ui_browser__is_current_entry(&browser->b, row)) {
462 browser->selection = &chain->ms;
463 color = HE_COLORSET_SELECTED;
464 *is_current_entry = true;
465 }
466
467 ui_browser__set_color(&browser->b, color);
468 ui_browser__gotorc(&browser->b, row, 0);
469 slsmg_write_nstring(" ", offset + extra_offset);
470 slsmg_printf("%c ", folded_sign);
471 slsmg_write_nstring(str, width);
472 free(alloc_str);
473
474 if (++row == browser->b.height)
475 goto out;
476 do_next:
477 if (folded_sign == '+')
478 break;
479 }
480
481 if (folded_sign == '-') {
482 const int new_level = level + (extra_offset ? 2 : 1);
483 row += hist_browser__show_callchain_node_rb_tree(browser, child, new_total,
484 new_level, row, row_offset,
485 is_current_entry);
486 }
487 if (row == browser->b.height)
488 goto out;
489 node = next;
490 }
491 out:
492 return row - first_row;
493 }
494
495 static int hist_browser__show_callchain_node(struct hist_browser *browser,
496 struct callchain_node *node,
497 int level, unsigned short row,
498 off_t *row_offset,
499 bool *is_current_entry)
500 {
501 struct callchain_list *chain;
502 int first_row = row,
503 offset = level * LEVEL_OFFSET_STEP,
504 width = browser->b.width - offset;
505 char folded_sign = ' ';
506
507 list_for_each_entry(chain, &node->val, list) {
508 char bf[1024], *s;
509 int color;
510
511 folded_sign = callchain_list__folded(chain);
512
513 if (*row_offset != 0) {
514 --*row_offset;
515 continue;
516 }
517
518 color = HE_COLORSET_NORMAL;
519 if (ui_browser__is_current_entry(&browser->b, row)) {
520 browser->selection = &chain->ms;
521 color = HE_COLORSET_SELECTED;
522 *is_current_entry = true;
523 }
524
525 s = callchain_list__sym_name(chain, bf, sizeof(bf),
526 browser->show_dso);
527 ui_browser__gotorc(&browser->b, row, 0);
528 ui_browser__set_color(&browser->b, color);
529 slsmg_write_nstring(" ", offset);
530 slsmg_printf("%c ", folded_sign);
531 slsmg_write_nstring(s, width - 2);
532
533 if (++row == browser->b.height)
534 goto out;
535 }
536
537 if (folded_sign == '-')
538 row += hist_browser__show_callchain_node_rb_tree(browser, node,
539 browser->hists->stats.total_period,
540 level + 1, row,
541 row_offset,
542 is_current_entry);
543 out:
544 return row - first_row;
545 }
546
547 static int hist_browser__show_callchain(struct hist_browser *browser,
548 struct rb_root *chain,
549 int level, unsigned short row,
550 off_t *row_offset,
551 bool *is_current_entry)
552 {
553 struct rb_node *nd;
554 int first_row = row;
555
556 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
557 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
558
559 row += hist_browser__show_callchain_node(browser, node, level,
560 row, row_offset,
561 is_current_entry);
562 if (row == browser->b.height)
563 break;
564 }
565
566 return row - first_row;
567 }
568
569 struct hpp_arg {
570 struct ui_browser *b;
571 char folded_sign;
572 bool current_entry;
573 };
574
575 static int __hpp__color_callchain(struct hpp_arg *arg)
576 {
577 if (!symbol_conf.use_callchain)
578 return 0;
579
580 slsmg_printf("%c ", arg->folded_sign);
581 return 2;
582 }
583
584 static int __hpp__color_fmt(struct perf_hpp *hpp, struct hist_entry *he,
585 u64 (*get_field)(struct hist_entry *),
586 int (*callchain_cb)(struct hpp_arg *))
587 {
588 int ret = 0;
589 double percent = 0.0;
590 struct hists *hists = he->hists;
591 struct hpp_arg *arg = hpp->ptr;
592
593 if (hists->stats.total_period)
594 percent = 100.0 * get_field(he) / hists->stats.total_period;
595
596 ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
597
598 if (callchain_cb)
599 ret += callchain_cb(arg);
600
601 ret += scnprintf(hpp->buf, hpp->size, "%6.2f%%", percent);
602 slsmg_printf("%s", hpp->buf);
603
604 if (symbol_conf.event_group) {
605 int prev_idx, idx_delta;
606 struct perf_evsel *evsel = hists_to_evsel(hists);
607 struct hist_entry *pair;
608 int nr_members = evsel->nr_members;
609
610 if (nr_members <= 1)
611 goto out;
612
613 prev_idx = perf_evsel__group_idx(evsel);
614
615 list_for_each_entry(pair, &he->pairs.head, pairs.node) {
616 u64 period = get_field(pair);
617 u64 total = pair->hists->stats.total_period;
618
619 if (!total)
620 continue;
621
622 evsel = hists_to_evsel(pair->hists);
623 idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
624
625 while (idx_delta--) {
626 /*
627 * zero-fill group members in the middle which
628 * have no sample
629 */
630 ui_browser__set_percent_color(arg->b, 0.0,
631 arg->current_entry);
632 ret += scnprintf(hpp->buf, hpp->size,
633 " %6.2f%%", 0.0);
634 slsmg_printf("%s", hpp->buf);
635 }
636
637 percent = 100.0 * period / total;
638 ui_browser__set_percent_color(arg->b, percent,
639 arg->current_entry);
640 ret += scnprintf(hpp->buf, hpp->size,
641 " %6.2f%%", percent);
642 slsmg_printf("%s", hpp->buf);
643
644 prev_idx = perf_evsel__group_idx(evsel);
645 }
646
647 idx_delta = nr_members - prev_idx - 1;
648
649 while (idx_delta--) {
650 /*
651 * zero-fill group members at last which have no sample
652 */
653 ui_browser__set_percent_color(arg->b, 0.0,
654 arg->current_entry);
655 ret += scnprintf(hpp->buf, hpp->size,
656 " %6.2f%%", 0.0);
657 slsmg_printf("%s", hpp->buf);
658 }
659 }
660 out:
661 if (!arg->current_entry || !arg->b->navkeypressed)
662 ui_browser__set_color(arg->b, HE_COLORSET_NORMAL);
663
664 return ret;
665 }
666
667 #define __HPP_COLOR_PERCENT_FN(_type, _field, _cb) \
668 static u64 __hpp_get_##_field(struct hist_entry *he) \
669 { \
670 return he->stat._field; \
671 } \
672 \
673 static int hist_browser__hpp_color_##_type(struct perf_hpp *hpp, \
674 struct hist_entry *he) \
675 { \
676 return __hpp__color_fmt(hpp, he, __hpp_get_##_field, _cb); \
677 }
678
679 __HPP_COLOR_PERCENT_FN(overhead, period, __hpp__color_callchain)
680 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys, NULL)
681 __HPP_COLOR_PERCENT_FN(overhead_us, period_us, NULL)
682 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys, NULL)
683 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us, NULL)
684
685 #undef __HPP_COLOR_PERCENT_FN
686
687 void hist_browser__init_hpp(void)
688 {
689 perf_hpp__column_enable(PERF_HPP__OVERHEAD);
690
691 perf_hpp__init();
692
693 perf_hpp__format[PERF_HPP__OVERHEAD].color =
694 hist_browser__hpp_color_overhead;
695 perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
696 hist_browser__hpp_color_overhead_sys;
697 perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
698 hist_browser__hpp_color_overhead_us;
699 perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
700 hist_browser__hpp_color_overhead_guest_sys;
701 perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
702 hist_browser__hpp_color_overhead_guest_us;
703 }
704
705 static int hist_browser__show_entry(struct hist_browser *browser,
706 struct hist_entry *entry,
707 unsigned short row)
708 {
709 char s[256];
710 int printed = 0;
711 int width = browser->b.width;
712 char folded_sign = ' ';
713 bool current_entry = ui_browser__is_current_entry(&browser->b, row);
714 off_t row_offset = entry->row_offset;
715 bool first = true;
716 struct perf_hpp_fmt *fmt;
717
718 if (current_entry) {
719 browser->he_selection = entry;
720 browser->selection = &entry->ms;
721 }
722
723 if (symbol_conf.use_callchain) {
724 hist_entry__init_have_children(entry);
725 folded_sign = hist_entry__folded(entry);
726 }
727
728 if (row_offset == 0) {
729 struct hpp_arg arg = {
730 .b = &browser->b,
731 .folded_sign = folded_sign,
732 .current_entry = current_entry,
733 };
734 struct perf_hpp hpp = {
735 .buf = s,
736 .size = sizeof(s),
737 .ptr = &arg,
738 };
739
740 ui_browser__gotorc(&browser->b, row, 0);
741
742 perf_hpp__for_each_format(fmt) {
743 if (!first) {
744 slsmg_printf(" ");
745 width -= 2;
746 }
747 first = false;
748
749 if (fmt->color) {
750 width -= fmt->color(&hpp, entry);
751 } else {
752 width -= fmt->entry(&hpp, entry);
753 slsmg_printf("%s", s);
754 }
755 }
756
757 /* The scroll bar isn't being used */
758 if (!browser->b.navkeypressed)
759 width += 1;
760
761 hist_entry__sort_snprintf(entry, s, sizeof(s), browser->hists);
762 slsmg_write_nstring(s, width);
763 ++row;
764 ++printed;
765 } else
766 --row_offset;
767
768 if (folded_sign == '-' && row != browser->b.height) {
769 printed += hist_browser__show_callchain(browser, &entry->sorted_chain,
770 1, row, &row_offset,
771 &current_entry);
772 if (current_entry)
773 browser->he_selection = entry;
774 }
775
776 return printed;
777 }
778
779 static void ui_browser__hists_init_top(struct ui_browser *browser)
780 {
781 if (browser->top == NULL) {
782 struct hist_browser *hb;
783
784 hb = container_of(browser, struct hist_browser, b);
785 browser->top = rb_first(&hb->hists->entries);
786 }
787 }
788
789 static unsigned int hist_browser__refresh(struct ui_browser *browser)
790 {
791 unsigned row = 0;
792 struct rb_node *nd;
793 struct hist_browser *hb = container_of(browser, struct hist_browser, b);
794
795 ui_browser__hists_init_top(browser);
796
797 for (nd = browser->top; nd; nd = rb_next(nd)) {
798 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
799
800 if (h->filtered)
801 continue;
802
803 row += hist_browser__show_entry(hb, h, row);
804 if (row == browser->height)
805 break;
806 }
807
808 return row;
809 }
810
811 static struct rb_node *hists__filter_entries(struct rb_node *nd)
812 {
813 while (nd != NULL) {
814 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
815 if (!h->filtered)
816 return nd;
817
818 nd = rb_next(nd);
819 }
820
821 return NULL;
822 }
823
824 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
825 {
826 while (nd != NULL) {
827 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
828 if (!h->filtered)
829 return nd;
830
831 nd = rb_prev(nd);
832 }
833
834 return NULL;
835 }
836
837 static void ui_browser__hists_seek(struct ui_browser *browser,
838 off_t offset, int whence)
839 {
840 struct hist_entry *h;
841 struct rb_node *nd;
842 bool first = true;
843
844 if (browser->nr_entries == 0)
845 return;
846
847 ui_browser__hists_init_top(browser);
848
849 switch (whence) {
850 case SEEK_SET:
851 nd = hists__filter_entries(rb_first(browser->entries));
852 break;
853 case SEEK_CUR:
854 nd = browser->top;
855 goto do_offset;
856 case SEEK_END:
857 nd = hists__filter_prev_entries(rb_last(browser->entries));
858 first = false;
859 break;
860 default:
861 return;
862 }
863
864 /*
865 * Moves not relative to the first visible entry invalidates its
866 * row_offset:
867 */
868 h = rb_entry(browser->top, struct hist_entry, rb_node);
869 h->row_offset = 0;
870
871 /*
872 * Here we have to check if nd is expanded (+), if it is we can't go
873 * the next top level hist_entry, instead we must compute an offset of
874 * what _not_ to show and not change the first visible entry.
875 *
876 * This offset increments when we are going from top to bottom and
877 * decreases when we're going from bottom to top.
878 *
879 * As we don't have backpointers to the top level in the callchains
880 * structure, we need to always print the whole hist_entry callchain,
881 * skipping the first ones that are before the first visible entry
882 * and stop when we printed enough lines to fill the screen.
883 */
884 do_offset:
885 if (offset > 0) {
886 do {
887 h = rb_entry(nd, struct hist_entry, rb_node);
888 if (h->ms.unfolded) {
889 u16 remaining = h->nr_rows - h->row_offset;
890 if (offset > remaining) {
891 offset -= remaining;
892 h->row_offset = 0;
893 } else {
894 h->row_offset += offset;
895 offset = 0;
896 browser->top = nd;
897 break;
898 }
899 }
900 nd = hists__filter_entries(rb_next(nd));
901 if (nd == NULL)
902 break;
903 --offset;
904 browser->top = nd;
905 } while (offset != 0);
906 } else if (offset < 0) {
907 while (1) {
908 h = rb_entry(nd, struct hist_entry, rb_node);
909 if (h->ms.unfolded) {
910 if (first) {
911 if (-offset > h->row_offset) {
912 offset += h->row_offset;
913 h->row_offset = 0;
914 } else {
915 h->row_offset += offset;
916 offset = 0;
917 browser->top = nd;
918 break;
919 }
920 } else {
921 if (-offset > h->nr_rows) {
922 offset += h->nr_rows;
923 h->row_offset = 0;
924 } else {
925 h->row_offset = h->nr_rows + offset;
926 offset = 0;
927 browser->top = nd;
928 break;
929 }
930 }
931 }
932
933 nd = hists__filter_prev_entries(rb_prev(nd));
934 if (nd == NULL)
935 break;
936 ++offset;
937 browser->top = nd;
938 if (offset == 0) {
939 /*
940 * Last unfiltered hist_entry, check if it is
941 * unfolded, if it is then we should have
942 * row_offset at its last entry.
943 */
944 h = rb_entry(nd, struct hist_entry, rb_node);
945 if (h->ms.unfolded)
946 h->row_offset = h->nr_rows;
947 break;
948 }
949 first = false;
950 }
951 } else {
952 browser->top = nd;
953 h = rb_entry(nd, struct hist_entry, rb_node);
954 h->row_offset = 0;
955 }
956 }
957
958 static int hist_browser__fprintf_callchain_node_rb_tree(struct hist_browser *browser,
959 struct callchain_node *chain_node,
960 u64 total, int level,
961 FILE *fp)
962 {
963 struct rb_node *node;
964 int offset = level * LEVEL_OFFSET_STEP;
965 u64 new_total, remaining;
966 int printed = 0;
967
968 if (callchain_param.mode == CHAIN_GRAPH_REL)
969 new_total = chain_node->children_hit;
970 else
971 new_total = total;
972
973 remaining = new_total;
974 node = rb_first(&chain_node->rb_root);
975 while (node) {
976 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
977 struct rb_node *next = rb_next(node);
978 u64 cumul = callchain_cumul_hits(child);
979 struct callchain_list *chain;
980 char folded_sign = ' ';
981 int first = true;
982 int extra_offset = 0;
983
984 remaining -= cumul;
985
986 list_for_each_entry(chain, &child->val, list) {
987 char bf[1024], *alloc_str;
988 const char *str;
989 bool was_first = first;
990
991 if (first)
992 first = false;
993 else
994 extra_offset = LEVEL_OFFSET_STEP;
995
996 folded_sign = callchain_list__folded(chain);
997
998 alloc_str = NULL;
999 str = callchain_list__sym_name(chain, bf, sizeof(bf),
1000 browser->show_dso);
1001 if (was_first) {
1002 double percent = cumul * 100.0 / new_total;
1003
1004 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
1005 str = "Not enough memory!";
1006 else
1007 str = alloc_str;
1008 }
1009
1010 printed += fprintf(fp, "%*s%c %s\n", offset + extra_offset, " ", folded_sign, str);
1011 free(alloc_str);
1012 if (folded_sign == '+')
1013 break;
1014 }
1015
1016 if (folded_sign == '-') {
1017 const int new_level = level + (extra_offset ? 2 : 1);
1018 printed += hist_browser__fprintf_callchain_node_rb_tree(browser, child, new_total,
1019 new_level, fp);
1020 }
1021
1022 node = next;
1023 }
1024
1025 return printed;
1026 }
1027
1028 static int hist_browser__fprintf_callchain_node(struct hist_browser *browser,
1029 struct callchain_node *node,
1030 int level, FILE *fp)
1031 {
1032 struct callchain_list *chain;
1033 int offset = level * LEVEL_OFFSET_STEP;
1034 char folded_sign = ' ';
1035 int printed = 0;
1036
1037 list_for_each_entry(chain, &node->val, list) {
1038 char bf[1024], *s;
1039
1040 folded_sign = callchain_list__folded(chain);
1041 s = callchain_list__sym_name(chain, bf, sizeof(bf), browser->show_dso);
1042 printed += fprintf(fp, "%*s%c %s\n", offset, " ", folded_sign, s);
1043 }
1044
1045 if (folded_sign == '-')
1046 printed += hist_browser__fprintf_callchain_node_rb_tree(browser, node,
1047 browser->hists->stats.total_period,
1048 level + 1, fp);
1049 return printed;
1050 }
1051
1052 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
1053 struct rb_root *chain, int level, FILE *fp)
1054 {
1055 struct rb_node *nd;
1056 int printed = 0;
1057
1058 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
1059 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
1060
1061 printed += hist_browser__fprintf_callchain_node(browser, node, level, fp);
1062 }
1063
1064 return printed;
1065 }
1066
1067 static int hist_browser__fprintf_entry(struct hist_browser *browser,
1068 struct hist_entry *he, FILE *fp)
1069 {
1070 char s[8192];
1071 double percent;
1072 int printed = 0;
1073 char folded_sign = ' ';
1074
1075 if (symbol_conf.use_callchain)
1076 folded_sign = hist_entry__folded(he);
1077
1078 hist_entry__sort_snprintf(he, s, sizeof(s), browser->hists);
1079 percent = (he->stat.period * 100.0) / browser->hists->stats.total_period;
1080
1081 if (symbol_conf.use_callchain)
1082 printed += fprintf(fp, "%c ", folded_sign);
1083
1084 printed += fprintf(fp, " %5.2f%%", percent);
1085
1086 if (symbol_conf.show_nr_samples)
1087 printed += fprintf(fp, " %11u", he->stat.nr_events);
1088
1089 if (symbol_conf.show_total_period)
1090 printed += fprintf(fp, " %12" PRIu64, he->stat.period);
1091
1092 printed += fprintf(fp, "%s\n", rtrim(s));
1093
1094 if (folded_sign == '-')
1095 printed += hist_browser__fprintf_callchain(browser, &he->sorted_chain, 1, fp);
1096
1097 return printed;
1098 }
1099
1100 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
1101 {
1102 struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries));
1103 int printed = 0;
1104
1105 while (nd) {
1106 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1107
1108 printed += hist_browser__fprintf_entry(browser, h, fp);
1109 nd = hists__filter_entries(rb_next(nd));
1110 }
1111
1112 return printed;
1113 }
1114
1115 static int hist_browser__dump(struct hist_browser *browser)
1116 {
1117 char filename[64];
1118 FILE *fp;
1119
1120 while (1) {
1121 scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
1122 if (access(filename, F_OK))
1123 break;
1124 /*
1125 * XXX: Just an arbitrary lazy upper limit
1126 */
1127 if (++browser->print_seq == 8192) {
1128 ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
1129 return -1;
1130 }
1131 }
1132
1133 fp = fopen(filename, "w");
1134 if (fp == NULL) {
1135 char bf[64];
1136 const char *err = strerror_r(errno, bf, sizeof(bf));
1137 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
1138 return -1;
1139 }
1140
1141 ++browser->print_seq;
1142 hist_browser__fprintf(browser, fp);
1143 fclose(fp);
1144 ui_helpline__fpush("%s written!", filename);
1145
1146 return 0;
1147 }
1148
1149 static struct hist_browser *hist_browser__new(struct hists *hists)
1150 {
1151 struct hist_browser *browser = zalloc(sizeof(*browser));
1152
1153 if (browser) {
1154 browser->hists = hists;
1155 browser->b.refresh = hist_browser__refresh;
1156 browser->b.seek = ui_browser__hists_seek;
1157 browser->b.use_navkeypressed = true;
1158 if (sort__branch_mode == 1)
1159 browser->has_symbols = sort_sym_from.list.next != NULL;
1160 else
1161 browser->has_symbols = sort_sym.list.next != NULL;
1162 }
1163
1164 return browser;
1165 }
1166
1167 static void hist_browser__delete(struct hist_browser *browser)
1168 {
1169 free(browser);
1170 }
1171
1172 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
1173 {
1174 return browser->he_selection;
1175 }
1176
1177 static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
1178 {
1179 return browser->he_selection->thread;
1180 }
1181
1182 static int hists__browser_title(struct hists *hists, char *bf, size_t size,
1183 const char *ev_name)
1184 {
1185 char unit;
1186 int printed;
1187 const struct dso *dso = hists->dso_filter;
1188 const struct thread *thread = hists->thread_filter;
1189 unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
1190 u64 nr_events = hists->stats.total_period;
1191 struct perf_evsel *evsel = hists_to_evsel(hists);
1192 char buf[512];
1193 size_t buflen = sizeof(buf);
1194
1195 if (perf_evsel__is_group_event(evsel)) {
1196 struct perf_evsel *pos;
1197
1198 perf_evsel__group_desc(evsel, buf, buflen);
1199 ev_name = buf;
1200
1201 for_each_group_member(pos, evsel) {
1202 nr_samples += pos->hists.stats.nr_events[PERF_RECORD_SAMPLE];
1203 nr_events += pos->hists.stats.total_period;
1204 }
1205 }
1206
1207 nr_samples = convert_unit(nr_samples, &unit);
1208 printed = scnprintf(bf, size,
1209 "Samples: %lu%c of event '%s', Event count (approx.): %lu",
1210 nr_samples, unit, ev_name, nr_events);
1211
1212
1213 if (hists->uid_filter_str)
1214 printed += snprintf(bf + printed, size - printed,
1215 ", UID: %s", hists->uid_filter_str);
1216 if (thread)
1217 printed += scnprintf(bf + printed, size - printed,
1218 ", Thread: %s(%d)",
1219 (thread->comm_set ? thread->comm : ""),
1220 thread->pid);
1221 if (dso)
1222 printed += scnprintf(bf + printed, size - printed,
1223 ", DSO: %s", dso->short_name);
1224 return printed;
1225 }
1226
1227 static inline void free_popup_options(char **options, int n)
1228 {
1229 int i;
1230
1231 for (i = 0; i < n; ++i) {
1232 free(options[i]);
1233 options[i] = NULL;
1234 }
1235 }
1236
1237 /* Check whether the browser is for 'top' or 'report' */
1238 static inline bool is_report_browser(void *timer)
1239 {
1240 return timer == NULL;
1241 }
1242
1243 /*
1244 * Only runtime switching of perf data file will make "input_name" point
1245 * to a malloced buffer. So add "is_input_name_malloced" flag to decide
1246 * whether we need to call free() for current "input_name" during the switch.
1247 */
1248 static bool is_input_name_malloced = false;
1249
1250 static int switch_data_file(void)
1251 {
1252 char *pwd, *options[32], *abs_path[32], *tmp;
1253 DIR *pwd_dir;
1254 int nr_options = 0, choice = -1, ret = -1;
1255 struct dirent *dent;
1256
1257 pwd = getenv("PWD");
1258 if (!pwd)
1259 return ret;
1260
1261 pwd_dir = opendir(pwd);
1262 if (!pwd_dir)
1263 return ret;
1264
1265 memset(options, 0, sizeof(options));
1266 memset(options, 0, sizeof(abs_path));
1267
1268 while ((dent = readdir(pwd_dir))) {
1269 char path[PATH_MAX];
1270 u64 magic;
1271 char *name = dent->d_name;
1272 FILE *file;
1273
1274 if (!(dent->d_type == DT_REG))
1275 continue;
1276
1277 snprintf(path, sizeof(path), "%s/%s", pwd, name);
1278
1279 file = fopen(path, "r");
1280 if (!file)
1281 continue;
1282
1283 if (fread(&magic, 1, 8, file) < 8)
1284 goto close_file_and_continue;
1285
1286 if (is_perf_magic(magic)) {
1287 options[nr_options] = strdup(name);
1288 if (!options[nr_options])
1289 goto close_file_and_continue;
1290
1291 abs_path[nr_options] = strdup(path);
1292 if (!abs_path[nr_options]) {
1293 free(options[nr_options]);
1294 ui__warning("Can't search all data files due to memory shortage.\n");
1295 fclose(file);
1296 break;
1297 }
1298
1299 nr_options++;
1300 }
1301
1302 close_file_and_continue:
1303 fclose(file);
1304 if (nr_options >= 32) {
1305 ui__warning("Too many perf data files in PWD!\n"
1306 "Only the first 32 files will be listed.\n");
1307 break;
1308 }
1309 }
1310 closedir(pwd_dir);
1311
1312 if (nr_options) {
1313 choice = ui__popup_menu(nr_options, options);
1314 if (choice < nr_options && choice >= 0) {
1315 tmp = strdup(abs_path[choice]);
1316 if (tmp) {
1317 if (is_input_name_malloced)
1318 free((void *)input_name);
1319 input_name = tmp;
1320 is_input_name_malloced = true;
1321 ret = 0;
1322 } else
1323 ui__warning("Data switch failed due to memory shortage!\n");
1324 }
1325 }
1326
1327 free_popup_options(options, nr_options);
1328 free_popup_options(abs_path, nr_options);
1329 return ret;
1330 }
1331
1332
1333 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
1334 const char *helpline, const char *ev_name,
1335 bool left_exits,
1336 struct hist_browser_timer *hbt,
1337 struct perf_session_env *env)
1338 {
1339 struct hists *hists = &evsel->hists;
1340 struct hist_browser *browser = hist_browser__new(hists);
1341 struct branch_info *bi;
1342 struct pstack *fstack;
1343 char *options[16];
1344 int nr_options = 0;
1345 int key = -1;
1346 char buf[64];
1347 char script_opt[64];
1348 int delay_secs = hbt ? hbt->refresh : 0;
1349
1350 if (browser == NULL)
1351 return -1;
1352
1353 fstack = pstack__new(2);
1354 if (fstack == NULL)
1355 goto out;
1356
1357 ui_helpline__push(helpline);
1358
1359 memset(options, 0, sizeof(options));
1360
1361 while (1) {
1362 const struct thread *thread = NULL;
1363 const struct dso *dso = NULL;
1364 int choice = 0,
1365 annotate = -2, zoom_dso = -2, zoom_thread = -2,
1366 annotate_f = -2, annotate_t = -2, browse_map = -2;
1367 int scripts_comm = -2, scripts_symbol = -2,
1368 scripts_all = -2, switch_data = -2;
1369
1370 nr_options = 0;
1371
1372 key = hist_browser__run(browser, ev_name, hbt);
1373
1374 if (browser->he_selection != NULL) {
1375 thread = hist_browser__selected_thread(browser);
1376 dso = browser->selection->map ? browser->selection->map->dso : NULL;
1377 }
1378 switch (key) {
1379 case K_TAB:
1380 case K_UNTAB:
1381 if (nr_events == 1)
1382 continue;
1383 /*
1384 * Exit the browser, let hists__browser_tree
1385 * go to the next or previous
1386 */
1387 goto out_free_stack;
1388 case 'a':
1389 if (!browser->has_symbols) {
1390 ui_browser__warning(&browser->b, delay_secs * 2,
1391 "Annotation is only available for symbolic views, "
1392 "include \"sym*\" in --sort to use it.");
1393 continue;
1394 }
1395
1396 if (browser->selection == NULL ||
1397 browser->selection->sym == NULL ||
1398 browser->selection->map->dso->annotate_warned)
1399 continue;
1400 goto do_annotate;
1401 case 'P':
1402 hist_browser__dump(browser);
1403 continue;
1404 case 'd':
1405 goto zoom_dso;
1406 case 'V':
1407 browser->show_dso = !browser->show_dso;
1408 continue;
1409 case 't':
1410 goto zoom_thread;
1411 case '/':
1412 if (ui_browser__input_window("Symbol to show",
1413 "Please enter the name of symbol you want to see",
1414 buf, "ENTER: OK, ESC: Cancel",
1415 delay_secs * 2) == K_ENTER) {
1416 hists->symbol_filter_str = *buf ? buf : NULL;
1417 hists__filter_by_symbol(hists);
1418 hist_browser__reset(browser);
1419 }
1420 continue;
1421 case 'r':
1422 if (is_report_browser(hbt))
1423 goto do_scripts;
1424 continue;
1425 case 's':
1426 if (is_report_browser(hbt))
1427 goto do_data_switch;
1428 continue;
1429 case K_F1:
1430 case 'h':
1431 case '?':
1432 ui_browser__help_window(&browser->b,
1433 "h/?/F1 Show this window\n"
1434 "UP/DOWN/PGUP\n"
1435 "PGDN/SPACE Navigate\n"
1436 "q/ESC/CTRL+C Exit browser\n\n"
1437 "For multiple event sessions:\n\n"
1438 "TAB/UNTAB Switch events\n\n"
1439 "For symbolic views (--sort has sym):\n\n"
1440 "-> Zoom into DSO/Threads & Annotate current symbol\n"
1441 "<- Zoom out\n"
1442 "a Annotate current symbol\n"
1443 "C Collapse all callchains\n"
1444 "E Expand all callchains\n"
1445 "d Zoom into current DSO\n"
1446 "t Zoom into current Thread\n"
1447 "r Run available scripts('perf report' only)\n"
1448 "s Switch to another data file in PWD ('perf report' only)\n"
1449 "P Print histograms to perf.hist.N\n"
1450 "V Verbose (DSO names in callchains, etc)\n"
1451 "/ Filter symbol by name");
1452 continue;
1453 case K_ENTER:
1454 case K_RIGHT:
1455 /* menu */
1456 break;
1457 case K_LEFT: {
1458 const void *top;
1459
1460 if (pstack__empty(fstack)) {
1461 /*
1462 * Go back to the perf_evsel_menu__run or other user
1463 */
1464 if (left_exits)
1465 goto out_free_stack;
1466 continue;
1467 }
1468 top = pstack__pop(fstack);
1469 if (top == &browser->hists->dso_filter)
1470 goto zoom_out_dso;
1471 if (top == &browser->hists->thread_filter)
1472 goto zoom_out_thread;
1473 continue;
1474 }
1475 case K_ESC:
1476 if (!left_exits &&
1477 !ui_browser__dialog_yesno(&browser->b,
1478 "Do you really want to exit?"))
1479 continue;
1480 /* Fall thru */
1481 case 'q':
1482 case CTRL('c'):
1483 goto out_free_stack;
1484 default:
1485 continue;
1486 }
1487
1488 if (!browser->has_symbols)
1489 goto add_exit_option;
1490
1491 if (sort__branch_mode == 1) {
1492 bi = browser->he_selection->branch_info;
1493 if (browser->selection != NULL &&
1494 bi &&
1495 bi->from.sym != NULL &&
1496 !bi->from.map->dso->annotate_warned &&
1497 asprintf(&options[nr_options], "Annotate %s",
1498 bi->from.sym->name) > 0)
1499 annotate_f = nr_options++;
1500
1501 if (browser->selection != NULL &&
1502 bi &&
1503 bi->to.sym != NULL &&
1504 !bi->to.map->dso->annotate_warned &&
1505 (bi->to.sym != bi->from.sym ||
1506 bi->to.map->dso != bi->from.map->dso) &&
1507 asprintf(&options[nr_options], "Annotate %s",
1508 bi->to.sym->name) > 0)
1509 annotate_t = nr_options++;
1510 } else {
1511
1512 if (browser->selection != NULL &&
1513 browser->selection->sym != NULL &&
1514 !browser->selection->map->dso->annotate_warned &&
1515 asprintf(&options[nr_options], "Annotate %s",
1516 browser->selection->sym->name) > 0)
1517 annotate = nr_options++;
1518 }
1519
1520 if (thread != NULL &&
1521 asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
1522 (browser->hists->thread_filter ? "out of" : "into"),
1523 (thread->comm_set ? thread->comm : ""),
1524 thread->pid) > 0)
1525 zoom_thread = nr_options++;
1526
1527 if (dso != NULL &&
1528 asprintf(&options[nr_options], "Zoom %s %s DSO",
1529 (browser->hists->dso_filter ? "out of" : "into"),
1530 (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
1531 zoom_dso = nr_options++;
1532
1533 if (browser->selection != NULL &&
1534 browser->selection->map != NULL &&
1535 asprintf(&options[nr_options], "Browse map details") > 0)
1536 browse_map = nr_options++;
1537
1538 /* perf script support */
1539 if (browser->he_selection) {
1540 struct symbol *sym;
1541
1542 if (asprintf(&options[nr_options], "Run scripts for samples of thread [%s]",
1543 browser->he_selection->thread->comm) > 0)
1544 scripts_comm = nr_options++;
1545
1546 sym = browser->he_selection->ms.sym;
1547 if (sym && sym->namelen &&
1548 asprintf(&options[nr_options], "Run scripts for samples of symbol [%s]",
1549 sym->name) > 0)
1550 scripts_symbol = nr_options++;
1551 }
1552
1553 if (asprintf(&options[nr_options], "Run scripts for all samples") > 0)
1554 scripts_all = nr_options++;
1555
1556 if (is_report_browser(hbt) && asprintf(&options[nr_options],
1557 "Switch to another data file in PWD") > 0)
1558 switch_data = nr_options++;
1559 add_exit_option:
1560 options[nr_options++] = (char *)"Exit";
1561 retry_popup_menu:
1562 choice = ui__popup_menu(nr_options, options);
1563
1564 if (choice == nr_options - 1)
1565 break;
1566
1567 if (choice == -1) {
1568 free_popup_options(options, nr_options - 1);
1569 continue;
1570 }
1571
1572 if (choice == annotate || choice == annotate_t || choice == annotate_f) {
1573 struct hist_entry *he;
1574 int err;
1575 do_annotate:
1576 if (!objdump_path && perf_session_env__lookup_objdump(env))
1577 continue;
1578
1579 he = hist_browser__selected_entry(browser);
1580 if (he == NULL)
1581 continue;
1582
1583 /*
1584 * we stash the branch_info symbol + map into the
1585 * the ms so we don't have to rewrite all the annotation
1586 * code to use branch_info.
1587 * in branch mode, the ms struct is not used
1588 */
1589 if (choice == annotate_f) {
1590 he->ms.sym = he->branch_info->from.sym;
1591 he->ms.map = he->branch_info->from.map;
1592 } else if (choice == annotate_t) {
1593 he->ms.sym = he->branch_info->to.sym;
1594 he->ms.map = he->branch_info->to.map;
1595 }
1596
1597 /*
1598 * Don't let this be freed, say, by hists__decay_entry.
1599 */
1600 he->used = true;
1601 err = hist_entry__tui_annotate(he, evsel, hbt);
1602 he->used = false;
1603 /*
1604 * offer option to annotate the other branch source or target
1605 * (if they exists) when returning from annotate
1606 */
1607 if ((err == 'q' || err == CTRL('c'))
1608 && annotate_t != -2 && annotate_f != -2)
1609 goto retry_popup_menu;
1610
1611 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
1612 if (err)
1613 ui_browser__handle_resize(&browser->b);
1614
1615 } else if (choice == browse_map)
1616 map__browse(browser->selection->map);
1617 else if (choice == zoom_dso) {
1618 zoom_dso:
1619 if (browser->hists->dso_filter) {
1620 pstack__remove(fstack, &browser->hists->dso_filter);
1621 zoom_out_dso:
1622 ui_helpline__pop();
1623 browser->hists->dso_filter = NULL;
1624 sort_dso.elide = false;
1625 } else {
1626 if (dso == NULL)
1627 continue;
1628 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1629 dso->kernel ? "the Kernel" : dso->short_name);
1630 browser->hists->dso_filter = dso;
1631 sort_dso.elide = true;
1632 pstack__push(fstack, &browser->hists->dso_filter);
1633 }
1634 hists__filter_by_dso(hists);
1635 hist_browser__reset(browser);
1636 } else if (choice == zoom_thread) {
1637 zoom_thread:
1638 if (browser->hists->thread_filter) {
1639 pstack__remove(fstack, &browser->hists->thread_filter);
1640 zoom_out_thread:
1641 ui_helpline__pop();
1642 browser->hists->thread_filter = NULL;
1643 sort_thread.elide = false;
1644 } else {
1645 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1646 thread->comm_set ? thread->comm : "",
1647 thread->pid);
1648 browser->hists->thread_filter = thread;
1649 sort_thread.elide = true;
1650 pstack__push(fstack, &browser->hists->thread_filter);
1651 }
1652 hists__filter_by_thread(hists);
1653 hist_browser__reset(browser);
1654 }
1655 /* perf scripts support */
1656 else if (choice == scripts_all || choice == scripts_comm ||
1657 choice == scripts_symbol) {
1658 do_scripts:
1659 memset(script_opt, 0, 64);
1660
1661 if (choice == scripts_comm)
1662 sprintf(script_opt, " -c %s ", browser->he_selection->thread->comm);
1663
1664 if (choice == scripts_symbol)
1665 sprintf(script_opt, " -S %s ", browser->he_selection->ms.sym->name);
1666
1667 script_browse(script_opt);
1668 }
1669 /* Switch to another data file */
1670 else if (choice == switch_data) {
1671 do_data_switch:
1672 if (!switch_data_file()) {
1673 key = K_SWITCH_INPUT_DATA;
1674 break;
1675 } else
1676 ui__warning("Won't switch the data files due to\n"
1677 "no valid data file get selected!\n");
1678 }
1679 }
1680 out_free_stack:
1681 pstack__delete(fstack);
1682 out:
1683 hist_browser__delete(browser);
1684 free_popup_options(options, nr_options - 1);
1685 return key;
1686 }
1687
1688 struct perf_evsel_menu {
1689 struct ui_browser b;
1690 struct perf_evsel *selection;
1691 bool lost_events, lost_events_warned;
1692 struct perf_session_env *env;
1693 };
1694
1695 static void perf_evsel_menu__write(struct ui_browser *browser,
1696 void *entry, int row)
1697 {
1698 struct perf_evsel_menu *menu = container_of(browser,
1699 struct perf_evsel_menu, b);
1700 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
1701 bool current_entry = ui_browser__is_current_entry(browser, row);
1702 unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
1703 const char *ev_name = perf_evsel__name(evsel);
1704 char bf[256], unit;
1705 const char *warn = " ";
1706 size_t printed;
1707
1708 ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
1709 HE_COLORSET_NORMAL);
1710
1711 if (perf_evsel__is_group_event(evsel)) {
1712 struct perf_evsel *pos;
1713
1714 ev_name = perf_evsel__group_name(evsel);
1715
1716 for_each_group_member(pos, evsel) {
1717 nr_events += pos->hists.stats.nr_events[PERF_RECORD_SAMPLE];
1718 }
1719 }
1720
1721 nr_events = convert_unit(nr_events, &unit);
1722 printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
1723 unit, unit == ' ' ? "" : " ", ev_name);
1724 slsmg_printf("%s", bf);
1725
1726 nr_events = evsel->hists.stats.nr_events[PERF_RECORD_LOST];
1727 if (nr_events != 0) {
1728 menu->lost_events = true;
1729 if (!current_entry)
1730 ui_browser__set_color(browser, HE_COLORSET_TOP);
1731 nr_events = convert_unit(nr_events, &unit);
1732 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
1733 nr_events, unit, unit == ' ' ? "" : " ");
1734 warn = bf;
1735 }
1736
1737 slsmg_write_nstring(warn, browser->width - printed);
1738
1739 if (current_entry)
1740 menu->selection = evsel;
1741 }
1742
1743 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
1744 int nr_events, const char *help,
1745 struct hist_browser_timer *hbt)
1746 {
1747 struct perf_evlist *evlist = menu->b.priv;
1748 struct perf_evsel *pos;
1749 const char *ev_name, *title = "Available samples";
1750 int delay_secs = hbt ? hbt->refresh : 0;
1751 int key;
1752
1753 if (ui_browser__show(&menu->b, title,
1754 "ESC: exit, ENTER|->: Browse histograms") < 0)
1755 return -1;
1756
1757 while (1) {
1758 key = ui_browser__run(&menu->b, delay_secs);
1759
1760 switch (key) {
1761 case K_TIMER:
1762 hbt->timer(hbt->arg);
1763
1764 if (!menu->lost_events_warned && menu->lost_events) {
1765 ui_browser__warn_lost_events(&menu->b);
1766 menu->lost_events_warned = true;
1767 }
1768 continue;
1769 case K_RIGHT:
1770 case K_ENTER:
1771 if (!menu->selection)
1772 continue;
1773 pos = menu->selection;
1774 browse_hists:
1775 perf_evlist__set_selected(evlist, pos);
1776 /*
1777 * Give the calling tool a chance to populate the non
1778 * default evsel resorted hists tree.
1779 */
1780 if (hbt)
1781 hbt->timer(hbt->arg);
1782 ev_name = perf_evsel__name(pos);
1783 key = perf_evsel__hists_browse(pos, nr_events, help,
1784 ev_name, true, hbt,
1785 menu->env);
1786 ui_browser__show_title(&menu->b, title);
1787 switch (key) {
1788 case K_TAB:
1789 if (pos->node.next == &evlist->entries)
1790 pos = list_entry(evlist->entries.next, struct perf_evsel, node);
1791 else
1792 pos = list_entry(pos->node.next, struct perf_evsel, node);
1793 goto browse_hists;
1794 case K_UNTAB:
1795 if (pos->node.prev == &evlist->entries)
1796 pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
1797 else
1798 pos = list_entry(pos->node.prev, struct perf_evsel, node);
1799 goto browse_hists;
1800 case K_ESC:
1801 if (!ui_browser__dialog_yesno(&menu->b,
1802 "Do you really want to exit?"))
1803 continue;
1804 /* Fall thru */
1805 case K_SWITCH_INPUT_DATA:
1806 case 'q':
1807 case CTRL('c'):
1808 goto out;
1809 default:
1810 continue;
1811 }
1812 case K_LEFT:
1813 continue;
1814 case K_ESC:
1815 if (!ui_browser__dialog_yesno(&menu->b,
1816 "Do you really want to exit?"))
1817 continue;
1818 /* Fall thru */
1819 case 'q':
1820 case CTRL('c'):
1821 goto out;
1822 default:
1823 continue;
1824 }
1825 }
1826
1827 out:
1828 ui_browser__hide(&menu->b);
1829 return key;
1830 }
1831
1832 static bool filter_group_entries(struct ui_browser *self __maybe_unused,
1833 void *entry)
1834 {
1835 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
1836
1837 if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
1838 return true;
1839
1840 return false;
1841 }
1842
1843 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
1844 int nr_entries, const char *help,
1845 struct hist_browser_timer *hbt,
1846 struct perf_session_env *env)
1847 {
1848 struct perf_evsel *pos;
1849 struct perf_evsel_menu menu = {
1850 .b = {
1851 .entries = &evlist->entries,
1852 .refresh = ui_browser__list_head_refresh,
1853 .seek = ui_browser__list_head_seek,
1854 .write = perf_evsel_menu__write,
1855 .filter = filter_group_entries,
1856 .nr_entries = nr_entries,
1857 .priv = evlist,
1858 },
1859 .env = env,
1860 };
1861
1862 ui_helpline__push("Press ESC to exit");
1863
1864 list_for_each_entry(pos, &evlist->entries, node) {
1865 const char *ev_name = perf_evsel__name(pos);
1866 size_t line_len = strlen(ev_name) + 7;
1867
1868 if (menu.b.width < line_len)
1869 menu.b.width = line_len;
1870 }
1871
1872 return perf_evsel_menu__run(&menu, nr_entries, help, hbt);
1873 }
1874
1875 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
1876 struct hist_browser_timer *hbt,
1877 struct perf_session_env *env)
1878 {
1879 int nr_entries = evlist->nr_entries;
1880
1881 single_entry:
1882 if (nr_entries == 1) {
1883 struct perf_evsel *first = list_entry(evlist->entries.next,
1884 struct perf_evsel, node);
1885 const char *ev_name = perf_evsel__name(first);
1886
1887 return perf_evsel__hists_browse(first, nr_entries, help,
1888 ev_name, false, hbt, env);
1889 }
1890
1891 if (symbol_conf.event_group) {
1892 struct perf_evsel *pos;
1893
1894 nr_entries = 0;
1895 list_for_each_entry(pos, &evlist->entries, node)
1896 if (perf_evsel__is_group_leader(pos))
1897 nr_entries++;
1898
1899 if (nr_entries == 1)
1900 goto single_entry;
1901 }
1902
1903 return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
1904 hbt, env);
1905 }
Ubuntu Artful kernel mirror