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