]> git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - tools/perf/ui/browsers/hists.c
projects / mirror_ubuntu-kernels.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branches 'for-5.1/upstream-fixes', 'for-5.2/core', 'for-5.2/ish', 'for-5.2...
[mirror_ubuntu-kernels.git] / tools / perf / ui / browsers / hists.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <dirent.h>
3 #include <errno.h>
4 #include <inttypes.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <linux/rbtree.h>
9 #include <sys/ttydefaults.h>
10 #include <linux/time64.h>
11
12 #include "../../util/callchain.h"
13 #include "../../util/evsel.h"
14 #include "../../util/evlist.h"
15 #include "../../util/hist.h"
16 #include "../../util/map.h"
17 #include "../../util/symbol.h"
18 #include "../../util/pstack.h"
19 #include "../../util/sort.h"
20 #include "../../util/util.h"
21 #include "../../util/top.h"
22 #include "../../util/thread.h"
23 #include "../../arch/common.h"
24
25 #include "../browsers/hists.h"
26 #include "../helpline.h"
27 #include "../util.h"
28 #include "../ui.h"
29 #include "map.h"
30 #include "annotate.h"
31 #include "srcline.h"
32 #include "string2.h"
33 #include "units.h"
34 #include "time-utils.h"
35
36 #include "sane_ctype.h"
37
38 extern void hist_browser__init_hpp(void);
39
40 static int hists_browser__scnprintf_title(struct hist_browser *browser, char *bf, size_t size);
41 static void hist_browser__update_nr_entries(struct hist_browser *hb);
42
43 static struct rb_node *hists__filter_entries(struct rb_node *nd,
44 float min_pcnt);
45
46 static bool hist_browser__has_filter(struct hist_browser *hb)
47 {
48 return hists__has_filter(hb->hists) || hb->min_pcnt || symbol_conf.has_filter || hb->c2c_filter;
49 }
50
51 static int hist_browser__get_folding(struct hist_browser *browser)
52 {
53 struct rb_node *nd;
54 struct hists *hists = browser->hists;
55 int unfolded_rows = 0;
56
57 for (nd = rb_first_cached(&hists->entries);
58 (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
59 nd = rb_hierarchy_next(nd)) {
60 struct hist_entry *he =
61 rb_entry(nd, struct hist_entry, rb_node);
62
63 if (he->leaf && he->unfolded)
64 unfolded_rows += he->nr_rows;
65 }
66 return unfolded_rows;
67 }
68
69 static void hist_browser__set_title_space(struct hist_browser *hb)
70 {
71 struct ui_browser *browser = &hb->b;
72 struct hists *hists = hb->hists;
73 struct perf_hpp_list *hpp_list = hists->hpp_list;
74
75 browser->extra_title_lines = hb->show_headers ? hpp_list->nr_header_lines : 0;
76 }
77
78 static u32 hist_browser__nr_entries(struct hist_browser *hb)
79 {
80 u32 nr_entries;
81
82 if (symbol_conf.report_hierarchy)
83 nr_entries = hb->nr_hierarchy_entries;
84 else if (hist_browser__has_filter(hb))
85 nr_entries = hb->nr_non_filtered_entries;
86 else
87 nr_entries = hb->hists->nr_entries;
88
89 hb->nr_callchain_rows = hist_browser__get_folding(hb);
90 return nr_entries + hb->nr_callchain_rows;
91 }
92
93 static void hist_browser__update_rows(struct hist_browser *hb)
94 {
95 struct ui_browser *browser = &hb->b;
96 struct hists *hists = hb->hists;
97 struct perf_hpp_list *hpp_list = hists->hpp_list;
98 u16 index_row;
99
100 if (!hb->show_headers) {
101 browser->rows += browser->extra_title_lines;
102 browser->extra_title_lines = 0;
103 return;
104 }
105
106 browser->extra_title_lines = hpp_list->nr_header_lines;
107 browser->rows -= browser->extra_title_lines;
108 /*
109 * Verify if we were at the last line and that line isn't
110 * visibe because we now show the header line(s).
111 */
112 index_row = browser->index - browser->top_idx;
113 if (index_row >= browser->rows)
114 browser->index -= index_row - browser->rows + 1;
115 }
116
117 static void hist_browser__refresh_dimensions(struct ui_browser *browser)
118 {
119 struct hist_browser *hb = container_of(browser, struct hist_browser, b);
120
121 /* 3 == +/- toggle symbol before actual hist_entry rendering */
122 browser->width = 3 + (hists__sort_list_width(hb->hists) + sizeof("[k]"));
123 /*
124 * FIXME: Just keeping existing behaviour, but this really should be
125 * before updating browser->width, as it will invalidate the
126 * calculation above. Fix this and the fallout in another
127 * changeset.
128 */
129 ui_browser__refresh_dimensions(browser);
130 }
131
132 static void hist_browser__reset(struct hist_browser *browser)
133 {
134 /*
135 * The hists__remove_entry_filter() already folds non-filtered
136 * entries so we can assume it has 0 callchain rows.
137 */
138 browser->nr_callchain_rows = 0;
139
140 hist_browser__update_nr_entries(browser);
141 browser->b.nr_entries = hist_browser__nr_entries(browser);
142 hist_browser__refresh_dimensions(&browser->b);
143 ui_browser__reset_index(&browser->b);
144 }
145
146 static char tree__folded_sign(bool unfolded)
147 {
148 return unfolded ? '-' : '+';
149 }
150
151 static char hist_entry__folded(const struct hist_entry *he)
152 {
153 return he->has_children ? tree__folded_sign(he->unfolded) : ' ';
154 }
155
156 static char callchain_list__folded(const struct callchain_list *cl)
157 {
158 return cl->has_children ? tree__folded_sign(cl->unfolded) : ' ';
159 }
160
161 static void callchain_list__set_folding(struct callchain_list *cl, bool unfold)
162 {
163 cl->unfolded = unfold ? cl->has_children : false;
164 }
165
166 static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
167 {
168 int n = 0;
169 struct rb_node *nd;
170
171 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
172 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
173 struct callchain_list *chain;
174 char folded_sign = ' '; /* No children */
175
176 list_for_each_entry(chain, &child->val, list) {
177 ++n;
178
179 /* We need this because we may not have children */
180 folded_sign = callchain_list__folded(chain);
181 if (folded_sign == '+')
182 break;
183 }
184
185 if (folded_sign == '-') /* Have children and they're unfolded */
186 n += callchain_node__count_rows_rb_tree(child);
187 }
188
189 return n;
190 }
191
192 static int callchain_node__count_flat_rows(struct callchain_node *node)
193 {
194 struct callchain_list *chain;
195 char folded_sign = 0;
196 int n = 0;
197
198 list_for_each_entry(chain, &node->parent_val, list) {
199 if (!folded_sign) {
200 /* only check first chain list entry */
201 folded_sign = callchain_list__folded(chain);
202 if (folded_sign == '+')
203 return 1;
204 }
205 n++;
206 }
207
208 list_for_each_entry(chain, &node->val, list) {
209 if (!folded_sign) {
210 /* node->parent_val list might be empty */
211 folded_sign = callchain_list__folded(chain);
212 if (folded_sign == '+')
213 return 1;
214 }
215 n++;
216 }
217
218 return n;
219 }
220
221 static int callchain_node__count_folded_rows(struct callchain_node *node __maybe_unused)
222 {
223 return 1;
224 }
225
226 static int callchain_node__count_rows(struct callchain_node *node)
227 {
228 struct callchain_list *chain;
229 bool unfolded = false;
230 int n = 0;
231
232 if (callchain_param.mode == CHAIN_FLAT)
233 return callchain_node__count_flat_rows(node);
234 else if (callchain_param.mode == CHAIN_FOLDED)
235 return callchain_node__count_folded_rows(node);
236
237 list_for_each_entry(chain, &node->val, list) {
238 ++n;
239
240 unfolded = chain->unfolded;
241 }
242
243 if (unfolded)
244 n += callchain_node__count_rows_rb_tree(node);
245
246 return n;
247 }
248
249 static int callchain__count_rows(struct rb_root *chain)
250 {
251 struct rb_node *nd;
252 int n = 0;
253
254 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
255 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
256 n += callchain_node__count_rows(node);
257 }
258
259 return n;
260 }
261
262 static int hierarchy_count_rows(struct hist_browser *hb, struct hist_entry *he,
263 bool include_children)
264 {
265 int count = 0;
266 struct rb_node *node;
267 struct hist_entry *child;
268
269 if (he->leaf)
270 return callchain__count_rows(&he->sorted_chain);
271
272 if (he->has_no_entry)
273 return 1;
274
275 node = rb_first_cached(&he->hroot_out);
276 while (node) {
277 float percent;
278
279 child = rb_entry(node, struct hist_entry, rb_node);
280 percent = hist_entry__get_percent_limit(child);
281
282 if (!child->filtered && percent >= hb->min_pcnt) {
283 count++;
284
285 if (include_children && child->unfolded)
286 count += hierarchy_count_rows(hb, child, true);
287 }
288
289 node = rb_next(node);
290 }
291 return count;
292 }
293
294 static bool hist_entry__toggle_fold(struct hist_entry *he)
295 {
296 if (!he)
297 return false;
298
299 if (!he->has_children)
300 return false;
301
302 he->unfolded = !he->unfolded;
303 return true;
304 }
305
306 static bool callchain_list__toggle_fold(struct callchain_list *cl)
307 {
308 if (!cl)
309 return false;
310
311 if (!cl->has_children)
312 return false;
313
314 cl->unfolded = !cl->unfolded;
315 return true;
316 }
317
318 static void callchain_node__init_have_children_rb_tree(struct callchain_node *node)
319 {
320 struct rb_node *nd = rb_first(&node->rb_root);
321
322 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
323 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
324 struct callchain_list *chain;
325 bool first = true;
326
327 list_for_each_entry(chain, &child->val, list) {
328 if (first) {
329 first = false;
330 chain->has_children = chain->list.next != &child->val ||
331 !RB_EMPTY_ROOT(&child->rb_root);
332 } else
333 chain->has_children = chain->list.next == &child->val &&
334 !RB_EMPTY_ROOT(&child->rb_root);
335 }
336
337 callchain_node__init_have_children_rb_tree(child);
338 }
339 }
340
341 static void callchain_node__init_have_children(struct callchain_node *node,
342 bool has_sibling)
343 {
344 struct callchain_list *chain;
345
346 chain = list_entry(node->val.next, struct callchain_list, list);
347 chain->has_children = has_sibling;
348
349 if (!list_empty(&node->val)) {
350 chain = list_entry(node->val.prev, struct callchain_list, list);
351 chain->has_children = !RB_EMPTY_ROOT(&node->rb_root);
352 }
353
354 callchain_node__init_have_children_rb_tree(node);
355 }
356
357 static void callchain__init_have_children(struct rb_root *root)
358 {
359 struct rb_node *nd = rb_first(root);
360 bool has_sibling = nd && rb_next(nd);
361
362 for (nd = rb_first(root); nd; nd = rb_next(nd)) {
363 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
364 callchain_node__init_have_children(node, has_sibling);
365 if (callchain_param.mode == CHAIN_FLAT ||
366 callchain_param.mode == CHAIN_FOLDED)
367 callchain_node__make_parent_list(node);
368 }
369 }
370
371 static void hist_entry__init_have_children(struct hist_entry *he)
372 {
373 if (he->init_have_children)
374 return;
375
376 if (he->leaf) {
377 he->has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
378 callchain__init_have_children(&he->sorted_chain);
379 } else {
380 he->has_children = !RB_EMPTY_ROOT(&he->hroot_out.rb_root);
381 }
382
383 he->init_have_children = true;
384 }
385
386 static bool hist_browser__toggle_fold(struct hist_browser *browser)
387 {
388 struct hist_entry *he = browser->he_selection;
389 struct map_symbol *ms = browser->selection;
390 struct callchain_list *cl = container_of(ms, struct callchain_list, ms);
391 bool has_children;
392
393 if (!he || !ms)
394 return false;
395
396 if (ms == &he->ms)
397 has_children = hist_entry__toggle_fold(he);
398 else
399 has_children = callchain_list__toggle_fold(cl);
400
401 if (has_children) {
402 int child_rows = 0;
403
404 hist_entry__init_have_children(he);
405 browser->b.nr_entries -= he->nr_rows;
406
407 if (he->leaf)
408 browser->nr_callchain_rows -= he->nr_rows;
409 else
410 browser->nr_hierarchy_entries -= he->nr_rows;
411
412 if (symbol_conf.report_hierarchy)
413 child_rows = hierarchy_count_rows(browser, he, true);
414
415 if (he->unfolded) {
416 if (he->leaf)
417 he->nr_rows = callchain__count_rows(
418 &he->sorted_chain);
419 else
420 he->nr_rows = hierarchy_count_rows(browser, he, false);
421
422 /* account grand children */
423 if (symbol_conf.report_hierarchy)
424 browser->b.nr_entries += child_rows - he->nr_rows;
425
426 if (!he->leaf && he->nr_rows == 0) {
427 he->has_no_entry = true;
428 he->nr_rows = 1;
429 }
430 } else {
431 if (symbol_conf.report_hierarchy)
432 browser->b.nr_entries -= child_rows - he->nr_rows;
433
434 if (he->has_no_entry)
435 he->has_no_entry = false;
436
437 he->nr_rows = 0;
438 }
439
440 browser->b.nr_entries += he->nr_rows;
441
442 if (he->leaf)
443 browser->nr_callchain_rows += he->nr_rows;
444 else
445 browser->nr_hierarchy_entries += he->nr_rows;
446
447 return true;
448 }
449
450 /* If it doesn't have children, no toggling performed */
451 return false;
452 }
453
454 static int callchain_node__set_folding_rb_tree(struct callchain_node *node, bool unfold)
455 {
456 int n = 0;
457 struct rb_node *nd;
458
459 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
460 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
461 struct callchain_list *chain;
462 bool has_children = false;
463
464 list_for_each_entry(chain, &child->val, list) {
465 ++n;
466 callchain_list__set_folding(chain, unfold);
467 has_children = chain->has_children;
468 }
469
470 if (has_children)
471 n += callchain_node__set_folding_rb_tree(child, unfold);
472 }
473
474 return n;
475 }
476
477 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
478 {
479 struct callchain_list *chain;
480 bool has_children = false;
481 int n = 0;
482
483 list_for_each_entry(chain, &node->val, list) {
484 ++n;
485 callchain_list__set_folding(chain, unfold);
486 has_children = chain->has_children;
487 }
488
489 if (has_children)
490 n += callchain_node__set_folding_rb_tree(node, unfold);
491
492 return n;
493 }
494
495 static int callchain__set_folding(struct rb_root *chain, bool unfold)
496 {
497 struct rb_node *nd;
498 int n = 0;
499
500 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
501 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
502 n += callchain_node__set_folding(node, unfold);
503 }
504
505 return n;
506 }
507
508 static int hierarchy_set_folding(struct hist_browser *hb, struct hist_entry *he,
509 bool unfold __maybe_unused)
510 {
511 float percent;
512 struct rb_node *nd;
513 struct hist_entry *child;
514 int n = 0;
515
516 for (nd = rb_first_cached(&he->hroot_out); nd; nd = rb_next(nd)) {
517 child = rb_entry(nd, struct hist_entry, rb_node);
518 percent = hist_entry__get_percent_limit(child);
519 if (!child->filtered && percent >= hb->min_pcnt)
520 n++;
521 }
522
523 return n;
524 }
525
526 static void __hist_entry__set_folding(struct hist_entry *he,
527 struct hist_browser *hb, bool unfold)
528 {
529 hist_entry__init_have_children(he);
530 he->unfolded = unfold ? he->has_children : false;
531
532 if (he->has_children) {
533 int n;
534
535 if (he->leaf)
536 n = callchain__set_folding(&he->sorted_chain, unfold);
537 else
538 n = hierarchy_set_folding(hb, he, unfold);
539
540 he->nr_rows = unfold ? n : 0;
541 } else
542 he->nr_rows = 0;
543 }
544
545 static void hist_entry__set_folding(struct hist_entry *he,
546 struct hist_browser *browser, bool unfold)
547 {
548 double percent;
549
550 percent = hist_entry__get_percent_limit(he);
551 if (he->filtered || percent < browser->min_pcnt)
552 return;
553
554 __hist_entry__set_folding(he, browser, unfold);
555
556 if (!he->depth || unfold)
557 browser->nr_hierarchy_entries++;
558 if (he->leaf)
559 browser->nr_callchain_rows += he->nr_rows;
560 else if (unfold && !hist_entry__has_hierarchy_children(he, browser->min_pcnt)) {
561 browser->nr_hierarchy_entries++;
562 he->has_no_entry = true;
563 he->nr_rows = 1;
564 } else
565 he->has_no_entry = false;
566 }
567
568 static void
569 __hist_browser__set_folding(struct hist_browser *browser, bool unfold)
570 {
571 struct rb_node *nd;
572 struct hist_entry *he;
573
574 nd = rb_first_cached(&browser->hists->entries);
575 while (nd) {
576 he = rb_entry(nd, struct hist_entry, rb_node);
577
578 /* set folding state even if it's currently folded */
579 nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
580
581 hist_entry__set_folding(he, browser, unfold);
582 }
583 }
584
585 static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
586 {
587 browser->nr_hierarchy_entries = 0;
588 browser->nr_callchain_rows = 0;
589 __hist_browser__set_folding(browser, unfold);
590
591 browser->b.nr_entries = hist_browser__nr_entries(browser);
592 /* Go to the start, we may be way after valid entries after a collapse */
593 ui_browser__reset_index(&browser->b);
594 }
595
596 static void hist_browser__set_folding_selected(struct hist_browser *browser, bool unfold)
597 {
598 if (!browser->he_selection)
599 return;
600
601 hist_entry__set_folding(browser->he_selection, browser, unfold);
602 browser->b.nr_entries = hist_browser__nr_entries(browser);
603 }
604
605 static void ui_browser__warn_lost_events(struct ui_browser *browser)
606 {
607 ui_browser__warning(browser, 4,
608 "Events are being lost, check IO/CPU overload!\n\n"
609 "You may want to run 'perf' using a RT scheduler policy:\n\n"
610 " perf top -r 80\n\n"
611 "Or reduce the sampling frequency.");
612 }
613
614 static int hist_browser__title(struct hist_browser *browser, char *bf, size_t size)
615 {
616 return browser->title ? browser->title(browser, bf, size) : 0;
617 }
618
619 int hist_browser__run(struct hist_browser *browser, const char *help,
620 bool warn_lost_event)
621 {
622 int key;
623 char title[160];
624 struct hist_browser_timer *hbt = browser->hbt;
625 int delay_secs = hbt ? hbt->refresh : 0;
626
627 browser->b.entries = &browser->hists->entries;
628 browser->b.nr_entries = hist_browser__nr_entries(browser);
629
630 hist_browser__title(browser, title, sizeof(title));
631
632 if (ui_browser__show(&browser->b, title, "%s", help) < 0)
633 return -1;
634
635 while (1) {
636 key = ui_browser__run(&browser->b, delay_secs);
637
638 switch (key) {
639 case K_TIMER: {
640 u64 nr_entries;
641 hbt->timer(hbt->arg);
642
643 if (hist_browser__has_filter(browser) ||
644 symbol_conf.report_hierarchy)
645 hist_browser__update_nr_entries(browser);
646
647 nr_entries = hist_browser__nr_entries(browser);
648 ui_browser__update_nr_entries(&browser->b, nr_entries);
649
650 if (warn_lost_event &&
651 (browser->hists->stats.nr_lost_warned !=
652 browser->hists->stats.nr_events[PERF_RECORD_LOST])) {
653 browser->hists->stats.nr_lost_warned =
654 browser->hists->stats.nr_events[PERF_RECORD_LOST];
655 ui_browser__warn_lost_events(&browser->b);
656 }
657
658 hist_browser__title(browser, title, sizeof(title));
659 ui_browser__show_title(&browser->b, title);
660 continue;
661 }
662 case 'D': { /* Debug */
663 static int seq;
664 struct hist_entry *h = rb_entry(browser->b.top,
665 struct hist_entry, rb_node);
666 ui_helpline__pop();
667 ui_helpline__fpush("%d: nr_ent=(%d,%d), etl: %d, rows=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
668 seq++, browser->b.nr_entries,
669 browser->hists->nr_entries,
670 browser->b.extra_title_lines,
671 browser->b.rows,
672 browser->b.index,
673 browser->b.top_idx,
674 h->row_offset, h->nr_rows);
675 }
676 break;
677 case 'C':
678 /* Collapse the whole world. */
679 hist_browser__set_folding(browser, false);
680 break;
681 case 'c':
682 /* Collapse the selected entry. */
683 hist_browser__set_folding_selected(browser, false);
684 break;
685 case 'E':
686 /* Expand the whole world. */
687 hist_browser__set_folding(browser, true);
688 break;
689 case 'e':
690 /* Expand the selected entry. */
691 hist_browser__set_folding_selected(browser, true);
692 break;
693 case 'H':
694 browser->show_headers = !browser->show_headers;
695 hist_browser__update_rows(browser);
696 break;
697 case K_ENTER:
698 if (hist_browser__toggle_fold(browser))
699 break;
700 /* fall thru */
701 default:
702 goto out;
703 }
704 }
705 out:
706 ui_browser__hide(&browser->b);
707 return key;
708 }
709
710 struct callchain_print_arg {
711 /* for hists browser */
712 off_t row_offset;
713 bool is_current_entry;
714
715 /* for file dump */
716 FILE *fp;
717 int printed;
718 };
719
720 typedef void (*print_callchain_entry_fn)(struct hist_browser *browser,
721 struct callchain_list *chain,
722 const char *str, int offset,
723 unsigned short row,
724 struct callchain_print_arg *arg);
725
726 static void hist_browser__show_callchain_entry(struct hist_browser *browser,
727 struct callchain_list *chain,
728 const char *str, int offset,
729 unsigned short row,
730 struct callchain_print_arg *arg)
731 {
732 int color, width;
733 char folded_sign = callchain_list__folded(chain);
734 bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;
735
736 color = HE_COLORSET_NORMAL;
737 width = browser->b.width - (offset + 2);
738 if (ui_browser__is_current_entry(&browser->b, row)) {
739 browser->selection = &chain->ms;
740 color = HE_COLORSET_SELECTED;
741 arg->is_current_entry = true;
742 }
743
744 ui_browser__set_color(&browser->b, color);
745 ui_browser__gotorc(&browser->b, row, 0);
746 ui_browser__write_nstring(&browser->b, " ", offset);
747 ui_browser__printf(&browser->b, "%c", folded_sign);
748 ui_browser__write_graph(&browser->b, show_annotated ? SLSMG_RARROW_CHAR : ' ');
749 ui_browser__write_nstring(&browser->b, str, width);
750 }
751
752 static void hist_browser__fprintf_callchain_entry(struct hist_browser *b __maybe_unused,
753 struct callchain_list *chain,
754 const char *str, int offset,
755 unsigned short row __maybe_unused,
756 struct callchain_print_arg *arg)
757 {
758 char folded_sign = callchain_list__folded(chain);
759
760 arg->printed += fprintf(arg->fp, "%*s%c %s\n", offset, " ",
761 folded_sign, str);
762 }
763
764 typedef bool (*check_output_full_fn)(struct hist_browser *browser,
765 unsigned short row);
766
767 static bool hist_browser__check_output_full(struct hist_browser *browser,
768 unsigned short row)
769 {
770 return browser->b.rows == row;
771 }
772
773 static bool hist_browser__check_dump_full(struct hist_browser *browser __maybe_unused,
774 unsigned short row __maybe_unused)
775 {
776 return false;
777 }
778
779 #define LEVEL_OFFSET_STEP 3
780
781 static int hist_browser__show_callchain_list(struct hist_browser *browser,
782 struct callchain_node *node,
783 struct callchain_list *chain,
784 unsigned short row, u64 total,
785 bool need_percent, int offset,
786 print_callchain_entry_fn print,
787 struct callchain_print_arg *arg)
788 {
789 char bf[1024], *alloc_str;
790 char buf[64], *alloc_str2;
791 const char *str;
792 int ret = 1;
793
794 if (arg->row_offset != 0) {
795 arg->row_offset--;
796 return 0;
797 }
798
799 alloc_str = NULL;
800 alloc_str2 = NULL;
801
802 str = callchain_list__sym_name(chain, bf, sizeof(bf),
803 browser->show_dso);
804
805 if (symbol_conf.show_branchflag_count) {
806 callchain_list_counts__printf_value(chain, NULL,
807 buf, sizeof(buf));
808
809 if (asprintf(&alloc_str2, "%s%s", str, buf) < 0)
810 str = "Not enough memory!";
811 else
812 str = alloc_str2;
813 }
814
815 if (need_percent) {
816 callchain_node__scnprintf_value(node, buf, sizeof(buf),
817 total);
818
819 if (asprintf(&alloc_str, "%s %s", buf, str) < 0)
820 str = "Not enough memory!";
821 else
822 str = alloc_str;
823 }
824
825 print(browser, chain, str, offset, row, arg);
826 free(alloc_str);
827 free(alloc_str2);
828
829 return ret;
830 }
831
832 static bool check_percent_display(struct rb_node *node, u64 parent_total)
833 {
834 struct callchain_node *child;
835
836 if (node == NULL)
837 return false;
838
839 if (rb_next(node))
840 return true;
841
842 child = rb_entry(node, struct callchain_node, rb_node);
843 return callchain_cumul_hits(child) != parent_total;
844 }
845
846 static int hist_browser__show_callchain_flat(struct hist_browser *browser,
847 struct rb_root *root,
848 unsigned short row, u64 total,
849 u64 parent_total,
850 print_callchain_entry_fn print,
851 struct callchain_print_arg *arg,
852 check_output_full_fn is_output_full)
853 {
854 struct rb_node *node;
855 int first_row = row, offset = LEVEL_OFFSET_STEP;
856 bool need_percent;
857
858 node = rb_first(root);
859 need_percent = check_percent_display(node, parent_total);
860
861 while (node) {
862 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
863 struct rb_node *next = rb_next(node);
864 struct callchain_list *chain;
865 char folded_sign = ' ';
866 int first = true;
867 int extra_offset = 0;
868
869 list_for_each_entry(chain, &child->parent_val, list) {
870 bool was_first = first;
871
872 if (first)
873 first = false;
874 else if (need_percent)
875 extra_offset = LEVEL_OFFSET_STEP;
876
877 folded_sign = callchain_list__folded(chain);
878
879 row += hist_browser__show_callchain_list(browser, child,
880 chain, row, total,
881 was_first && need_percent,
882 offset + extra_offset,
883 print, arg);
884
885 if (is_output_full(browser, row))
886 goto out;
887
888 if (folded_sign == '+')
889 goto next;
890 }
891
892 list_for_each_entry(chain, &child->val, list) {
893 bool was_first = first;
894
895 if (first)
896 first = false;
897 else if (need_percent)
898 extra_offset = LEVEL_OFFSET_STEP;
899
900 folded_sign = callchain_list__folded(chain);
901
902 row += hist_browser__show_callchain_list(browser, child,
903 chain, row, total,
904 was_first && need_percent,
905 offset + extra_offset,
906 print, arg);
907
908 if (is_output_full(browser, row))
909 goto out;
910
911 if (folded_sign == '+')
912 break;
913 }
914
915 next:
916 if (is_output_full(browser, row))
917 break;
918 node = next;
919 }
920 out:
921 return row - first_row;
922 }
923
924 static char *hist_browser__folded_callchain_str(struct hist_browser *browser,
925 struct callchain_list *chain,
926 char *value_str, char *old_str)
927 {
928 char bf[1024];
929 const char *str;
930 char *new;
931
932 str = callchain_list__sym_name(chain, bf, sizeof(bf),
933 browser->show_dso);
934 if (old_str) {
935 if (asprintf(&new, "%s%s%s", old_str,
936 symbol_conf.field_sep ?: ";", str) < 0)
937 new = NULL;
938 } else {
939 if (value_str) {
940 if (asprintf(&new, "%s %s", value_str, str) < 0)
941 new = NULL;
942 } else {
943 if (asprintf(&new, "%s", str) < 0)
944 new = NULL;
945 }
946 }
947 return new;
948 }
949
950 static int hist_browser__show_callchain_folded(struct hist_browser *browser,
951 struct rb_root *root,
952 unsigned short row, u64 total,
953 u64 parent_total,
954 print_callchain_entry_fn print,
955 struct callchain_print_arg *arg,
956 check_output_full_fn is_output_full)
957 {
958 struct rb_node *node;
959 int first_row = row, offset = LEVEL_OFFSET_STEP;
960 bool need_percent;
961
962 node = rb_first(root);
963 need_percent = check_percent_display(node, parent_total);
964
965 while (node) {
966 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
967 struct rb_node *next = rb_next(node);
968 struct callchain_list *chain, *first_chain = NULL;
969 int first = true;
970 char *value_str = NULL, *value_str_alloc = NULL;
971 char *chain_str = NULL, *chain_str_alloc = NULL;
972
973 if (arg->row_offset != 0) {
974 arg->row_offset--;
975 goto next;
976 }
977
978 if (need_percent) {
979 char buf[64];
980
981 callchain_node__scnprintf_value(child, buf, sizeof(buf), total);
982 if (asprintf(&value_str, "%s", buf) < 0) {
983 value_str = (char *)"<...>";
984 goto do_print;
985 }
986 value_str_alloc = value_str;
987 }
988
989 list_for_each_entry(chain, &child->parent_val, list) {
990 chain_str = hist_browser__folded_callchain_str(browser,
991 chain, value_str, chain_str);
992 if (first) {
993 first = false;
994 first_chain = chain;
995 }
996
997 if (chain_str == NULL) {
998 chain_str = (char *)"Not enough memory!";
999 goto do_print;
1000 }
1001
1002 chain_str_alloc = chain_str;
1003 }
1004
1005 list_for_each_entry(chain, &child->val, list) {
1006 chain_str = hist_browser__folded_callchain_str(browser,
1007 chain, value_str, chain_str);
1008 if (first) {
1009 first = false;
1010 first_chain = chain;
1011 }
1012
1013 if (chain_str == NULL) {
1014 chain_str = (char *)"Not enough memory!";
1015 goto do_print;
1016 }
1017
1018 chain_str_alloc = chain_str;
1019 }
1020
1021 do_print:
1022 print(browser, first_chain, chain_str, offset, row++, arg);
1023 free(value_str_alloc);
1024 free(chain_str_alloc);
1025
1026 next:
1027 if (is_output_full(browser, row))
1028 break;
1029 node = next;
1030 }
1031
1032 return row - first_row;
1033 }
1034
1035 static int hist_browser__show_callchain_graph(struct hist_browser *browser,
1036 struct rb_root *root, int level,
1037 unsigned short row, u64 total,
1038 u64 parent_total,
1039 print_callchain_entry_fn print,
1040 struct callchain_print_arg *arg,
1041 check_output_full_fn is_output_full)
1042 {
1043 struct rb_node *node;
1044 int first_row = row, offset = level * LEVEL_OFFSET_STEP;
1045 bool need_percent;
1046 u64 percent_total = total;
1047
1048 if (callchain_param.mode == CHAIN_GRAPH_REL)
1049 percent_total = parent_total;
1050
1051 node = rb_first(root);
1052 need_percent = check_percent_display(node, parent_total);
1053
1054 while (node) {
1055 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
1056 struct rb_node *next = rb_next(node);
1057 struct callchain_list *chain;
1058 char folded_sign = ' ';
1059 int first = true;
1060 int extra_offset = 0;
1061
1062 list_for_each_entry(chain, &child->val, list) {
1063 bool was_first = first;
1064
1065 if (first)
1066 first = false;
1067 else if (need_percent)
1068 extra_offset = LEVEL_OFFSET_STEP;
1069
1070 folded_sign = callchain_list__folded(chain);
1071
1072 row += hist_browser__show_callchain_list(browser, child,
1073 chain, row, percent_total,
1074 was_first && need_percent,
1075 offset + extra_offset,
1076 print, arg);
1077
1078 if (is_output_full(browser, row))
1079 goto out;
1080
1081 if (folded_sign == '+')
1082 break;
1083 }
1084
1085 if (folded_sign == '-') {
1086 const int new_level = level + (extra_offset ? 2 : 1);
1087
1088 row += hist_browser__show_callchain_graph(browser, &child->rb_root,
1089 new_level, row, total,
1090 child->children_hit,
1091 print, arg, is_output_full);
1092 }
1093 if (is_output_full(browser, row))
1094 break;
1095 node = next;
1096 }
1097 out:
1098 return row - first_row;
1099 }
1100
1101 static int hist_browser__show_callchain(struct hist_browser *browser,
1102 struct hist_entry *entry, int level,
1103 unsigned short row,
1104 print_callchain_entry_fn print,
1105 struct callchain_print_arg *arg,
1106 check_output_full_fn is_output_full)
1107 {
1108 u64 total = hists__total_period(entry->hists);
1109 u64 parent_total;
1110 int printed;
1111
1112 if (symbol_conf.cumulate_callchain)
1113 parent_total = entry->stat_acc->period;
1114 else
1115 parent_total = entry->stat.period;
1116
1117 if (callchain_param.mode == CHAIN_FLAT) {
1118 printed = hist_browser__show_callchain_flat(browser,
1119 &entry->sorted_chain, row,
1120 total, parent_total, print, arg,
1121 is_output_full);
1122 } else if (callchain_param.mode == CHAIN_FOLDED) {
1123 printed = hist_browser__show_callchain_folded(browser,
1124 &entry->sorted_chain, row,
1125 total, parent_total, print, arg,
1126 is_output_full);
1127 } else {
1128 printed = hist_browser__show_callchain_graph(browser,
1129 &entry->sorted_chain, level, row,
1130 total, parent_total, print, arg,
1131 is_output_full);
1132 }
1133
1134 if (arg->is_current_entry)
1135 browser->he_selection = entry;
1136
1137 return printed;
1138 }
1139
1140 struct hpp_arg {
1141 struct ui_browser *b;
1142 char folded_sign;
1143 bool current_entry;
1144 };
1145
1146 int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
1147 {
1148 struct hpp_arg *arg = hpp->ptr;
1149 int ret, len;
1150 va_list args;
1151 double percent;
1152
1153 va_start(args, fmt);
1154 len = va_arg(args, int);
1155 percent = va_arg(args, double);
1156 va_end(args);
1157
1158 ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
1159
1160 ret = scnprintf(hpp->buf, hpp->size, fmt, len, percent);
1161 ui_browser__printf(arg->b, "%s", hpp->buf);
1162
1163 return ret;
1164 }
1165
1166 #define __HPP_COLOR_PERCENT_FN(_type, _field) \
1167 static u64 __hpp_get_##_field(struct hist_entry *he) \
1168 { \
1169 return he->stat._field; \
1170 } \
1171 \
1172 static int \
1173 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt, \
1174 struct perf_hpp *hpp, \
1175 struct hist_entry *he) \
1176 { \
1177 return hpp__fmt(fmt, hpp, he, __hpp_get_##_field, " %*.2f%%", \
1178 __hpp__slsmg_color_printf, true); \
1179 }
1180
1181 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \
1182 static u64 __hpp_get_acc_##_field(struct hist_entry *he) \
1183 { \
1184 return he->stat_acc->_field; \
1185 } \
1186 \
1187 static int \
1188 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt, \
1189 struct perf_hpp *hpp, \
1190 struct hist_entry *he) \
1191 { \
1192 if (!symbol_conf.cumulate_callchain) { \
1193 struct hpp_arg *arg = hpp->ptr; \
1194 int len = fmt->user_len ?: fmt->len; \
1195 int ret = scnprintf(hpp->buf, hpp->size, \
1196 "%*s", len, "N/A"); \
1197 ui_browser__printf(arg->b, "%s", hpp->buf); \
1198 \
1199 return ret; \
1200 } \
1201 return hpp__fmt(fmt, hpp, he, __hpp_get_acc_##_field, \
1202 " %*.2f%%", __hpp__slsmg_color_printf, true); \
1203 }
1204
1205 __HPP_COLOR_PERCENT_FN(overhead, period)
1206 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
1207 __HPP_COLOR_PERCENT_FN(overhead_us, period_us)
1208 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
1209 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
1210 __HPP_COLOR_ACC_PERCENT_FN(overhead_acc, period)
1211
1212 #undef __HPP_COLOR_PERCENT_FN
1213 #undef __HPP_COLOR_ACC_PERCENT_FN
1214
1215 void hist_browser__init_hpp(void)
1216 {
1217 perf_hpp__format[PERF_HPP__OVERHEAD].color =
1218 hist_browser__hpp_color_overhead;
1219 perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
1220 hist_browser__hpp_color_overhead_sys;
1221 perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
1222 hist_browser__hpp_color_overhead_us;
1223 perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
1224 hist_browser__hpp_color_overhead_guest_sys;
1225 perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
1226 hist_browser__hpp_color_overhead_guest_us;
1227 perf_hpp__format[PERF_HPP__OVERHEAD_ACC].color =
1228 hist_browser__hpp_color_overhead_acc;
1229
1230 res_sample_init();
1231 }
1232
1233 static int hist_browser__show_entry(struct hist_browser *browser,
1234 struct hist_entry *entry,
1235 unsigned short row)
1236 {
1237 int printed = 0;
1238 int width = browser->b.width;
1239 char folded_sign = ' ';
1240 bool current_entry = ui_browser__is_current_entry(&browser->b, row);
1241 bool use_callchain = hist_entry__has_callchains(entry) && symbol_conf.use_callchain;
1242 off_t row_offset = entry->row_offset;
1243 bool first = true;
1244 struct perf_hpp_fmt *fmt;
1245
1246 if (current_entry) {
1247 browser->he_selection = entry;
1248 browser->selection = &entry->ms;
1249 }
1250
1251 if (use_callchain) {
1252 hist_entry__init_have_children(entry);
1253 folded_sign = hist_entry__folded(entry);
1254 }
1255
1256 if (row_offset == 0) {
1257 struct hpp_arg arg = {
1258 .b = &browser->b,
1259 .folded_sign = folded_sign,
1260 .current_entry = current_entry,
1261 };
1262 int column = 0;
1263
1264 ui_browser__gotorc(&browser->b, row, 0);
1265
1266 hists__for_each_format(browser->hists, fmt) {
1267 char s[2048];
1268 struct perf_hpp hpp = {
1269 .buf = s,
1270 .size = sizeof(s),
1271 .ptr = &arg,
1272 };
1273
1274 if (perf_hpp__should_skip(fmt, entry->hists) ||
1275 column++ < browser->b.horiz_scroll)
1276 continue;
1277
1278 if (current_entry && browser->b.navkeypressed) {
1279 ui_browser__set_color(&browser->b,
1280 HE_COLORSET_SELECTED);
1281 } else {
1282 ui_browser__set_color(&browser->b,
1283 HE_COLORSET_NORMAL);
1284 }
1285
1286 if (first) {
1287 if (use_callchain) {
1288 ui_browser__printf(&browser->b, "%c ", folded_sign);
1289 width -= 2;
1290 }
1291 first = false;
1292 } else {
1293 ui_browser__printf(&browser->b, " ");
1294 width -= 2;
1295 }
1296
1297 if (fmt->color) {
1298 int ret = fmt->color(fmt, &hpp, entry);
1299 hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
1300 /*
1301 * fmt->color() already used ui_browser to
1302 * print the non alignment bits, skip it (+ret):
1303 */
1304 ui_browser__printf(&browser->b, "%s", s + ret);
1305 } else {
1306 hist_entry__snprintf_alignment(entry, &hpp, fmt, fmt->entry(fmt, &hpp, entry));
1307 ui_browser__printf(&browser->b, "%s", s);
1308 }
1309 width -= hpp.buf - s;
1310 }
1311
1312 /* The scroll bar isn't being used */
1313 if (!browser->b.navkeypressed)
1314 width += 1;
1315
1316 ui_browser__write_nstring(&browser->b, "", width);
1317
1318 ++row;
1319 ++printed;
1320 } else
1321 --row_offset;
1322
1323 if (folded_sign == '-' && row != browser->b.rows) {
1324 struct callchain_print_arg arg = {
1325 .row_offset = row_offset,
1326 .is_current_entry = current_entry,
1327 };
1328
1329 printed += hist_browser__show_callchain(browser,
1330 entry, 1, row,
1331 hist_browser__show_callchain_entry,
1332 &arg,
1333 hist_browser__check_output_full);
1334 }
1335
1336 return printed;
1337 }
1338
1339 static int hist_browser__show_hierarchy_entry(struct hist_browser *browser,
1340 struct hist_entry *entry,
1341 unsigned short row,
1342 int level)
1343 {
1344 int printed = 0;
1345 int width = browser->b.width;
1346 char folded_sign = ' ';
1347 bool current_entry = ui_browser__is_current_entry(&browser->b, row);
1348 off_t row_offset = entry->row_offset;
1349 bool first = true;
1350 struct perf_hpp_fmt *fmt;
1351 struct perf_hpp_list_node *fmt_node;
1352 struct hpp_arg arg = {
1353 .b = &browser->b,
1354 .current_entry = current_entry,
1355 };
1356 int column = 0;
1357 int hierarchy_indent = (entry->hists->nr_hpp_node - 2) * HIERARCHY_INDENT;
1358
1359 if (current_entry) {
1360 browser->he_selection = entry;
1361 browser->selection = &entry->ms;
1362 }
1363
1364 hist_entry__init_have_children(entry);
1365 folded_sign = hist_entry__folded(entry);
1366 arg.folded_sign = folded_sign;
1367
1368 if (entry->leaf && row_offset) {
1369 row_offset--;
1370 goto show_callchain;
1371 }
1372
1373 ui_browser__gotorc(&browser->b, row, 0);
1374
1375 if (current_entry && browser->b.navkeypressed)
1376 ui_browser__set_color(&browser->b, HE_COLORSET_SELECTED);
1377 else
1378 ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
1379
1380 ui_browser__write_nstring(&browser->b, "", level * HIERARCHY_INDENT);
1381 width -= level * HIERARCHY_INDENT;
1382
1383 /* the first hpp_list_node is for overhead columns */
1384 fmt_node = list_first_entry(&entry->hists->hpp_formats,
1385 struct perf_hpp_list_node, list);
1386 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1387 char s[2048];
1388 struct perf_hpp hpp = {
1389 .buf = s,
1390 .size = sizeof(s),
1391 .ptr = &arg,
1392 };
1393
1394 if (perf_hpp__should_skip(fmt, entry->hists) ||
1395 column++ < browser->b.horiz_scroll)
1396 continue;
1397
1398 if (current_entry && browser->b.navkeypressed) {
1399 ui_browser__set_color(&browser->b,
1400 HE_COLORSET_SELECTED);
1401 } else {
1402 ui_browser__set_color(&browser->b,
1403 HE_COLORSET_NORMAL);
1404 }
1405
1406 if (first) {
1407 ui_browser__printf(&browser->b, "%c ", folded_sign);
1408 width -= 2;
1409 first = false;
1410 } else {
1411 ui_browser__printf(&browser->b, " ");
1412 width -= 2;
1413 }
1414
1415 if (fmt->color) {
1416 int ret = fmt->color(fmt, &hpp, entry);
1417 hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
1418 /*
1419 * fmt->color() already used ui_browser to
1420 * print the non alignment bits, skip it (+ret):
1421 */
1422 ui_browser__printf(&browser->b, "%s", s + ret);
1423 } else {
1424 int ret = fmt->entry(fmt, &hpp, entry);
1425 hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
1426 ui_browser__printf(&browser->b, "%s", s);
1427 }
1428 width -= hpp.buf - s;
1429 }
1430
1431 if (!first) {
1432 ui_browser__write_nstring(&browser->b, "", hierarchy_indent);
1433 width -= hierarchy_indent;
1434 }
1435
1436 if (column >= browser->b.horiz_scroll) {
1437 char s[2048];
1438 struct perf_hpp hpp = {
1439 .buf = s,
1440 .size = sizeof(s),
1441 .ptr = &arg,
1442 };
1443
1444 if (current_entry && browser->b.navkeypressed) {
1445 ui_browser__set_color(&browser->b,
1446 HE_COLORSET_SELECTED);
1447 } else {
1448 ui_browser__set_color(&browser->b,
1449 HE_COLORSET_NORMAL);
1450 }
1451
1452 perf_hpp_list__for_each_format(entry->hpp_list, fmt) {
1453 if (first) {
1454 ui_browser__printf(&browser->b, "%c ", folded_sign);
1455 first = false;
1456 } else {
1457 ui_browser__write_nstring(&browser->b, "", 2);
1458 }
1459
1460 width -= 2;
1461
1462 /*
1463 * No need to call hist_entry__snprintf_alignment()
1464 * since this fmt is always the last column in the
1465 * hierarchy mode.
1466 */
1467 if (fmt->color) {
1468 width -= fmt->color(fmt, &hpp, entry);
1469 } else {
1470 int i = 0;
1471
1472 width -= fmt->entry(fmt, &hpp, entry);
1473 ui_browser__printf(&browser->b, "%s", ltrim(s));
1474
1475 while (isspace(s[i++]))
1476 width++;
1477 }
1478 }
1479 }
1480
1481 /* The scroll bar isn't being used */
1482 if (!browser->b.navkeypressed)
1483 width += 1;
1484
1485 ui_browser__write_nstring(&browser->b, "", width);
1486
1487 ++row;
1488 ++printed;
1489
1490 show_callchain:
1491 if (entry->leaf && folded_sign == '-' && row != browser->b.rows) {
1492 struct callchain_print_arg carg = {
1493 .row_offset = row_offset,
1494 };
1495
1496 printed += hist_browser__show_callchain(browser, entry,
1497 level + 1, row,
1498 hist_browser__show_callchain_entry, &carg,
1499 hist_browser__check_output_full);
1500 }
1501
1502 return printed;
1503 }
1504
1505 static int hist_browser__show_no_entry(struct hist_browser *browser,
1506 unsigned short row, int level)
1507 {
1508 int width = browser->b.width;
1509 bool current_entry = ui_browser__is_current_entry(&browser->b, row);
1510 bool first = true;
1511 int column = 0;
1512 int ret;
1513 struct perf_hpp_fmt *fmt;
1514 struct perf_hpp_list_node *fmt_node;
1515 int indent = browser->hists->nr_hpp_node - 2;
1516
1517 if (current_entry) {
1518 browser->he_selection = NULL;
1519 browser->selection = NULL;
1520 }
1521
1522 ui_browser__gotorc(&browser->b, row, 0);
1523
1524 if (current_entry && browser->b.navkeypressed)
1525 ui_browser__set_color(&browser->b, HE_COLORSET_SELECTED);
1526 else
1527 ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
1528
1529 ui_browser__write_nstring(&browser->b, "", level * HIERARCHY_INDENT);
1530 width -= level * HIERARCHY_INDENT;
1531
1532 /* the first hpp_list_node is for overhead columns */
1533 fmt_node = list_first_entry(&browser->hists->hpp_formats,
1534 struct perf_hpp_list_node, list);
1535 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1536 if (perf_hpp__should_skip(fmt, browser->hists) ||
1537 column++ < browser->b.horiz_scroll)
1538 continue;
1539
1540 ret = fmt->width(fmt, NULL, browser->hists);
1541
1542 if (first) {
1543 /* for folded sign */
1544 first = false;
1545 ret++;
1546 } else {
1547 /* space between columns */
1548 ret += 2;
1549 }
1550
1551 ui_browser__write_nstring(&browser->b, "", ret);
1552 width -= ret;
1553 }
1554
1555 ui_browser__write_nstring(&browser->b, "", indent * HIERARCHY_INDENT);
1556 width -= indent * HIERARCHY_INDENT;
1557
1558 if (column >= browser->b.horiz_scroll) {
1559 char buf[32];
1560
1561 ret = snprintf(buf, sizeof(buf), "no entry >= %.2f%%", browser->min_pcnt);
1562 ui_browser__printf(&browser->b, " %s", buf);
1563 width -= ret + 2;
1564 }
1565
1566 /* The scroll bar isn't being used */
1567 if (!browser->b.navkeypressed)
1568 width += 1;
1569
1570 ui_browser__write_nstring(&browser->b, "", width);
1571 return 1;
1572 }
1573
1574 static int advance_hpp_check(struct perf_hpp *hpp, int inc)
1575 {
1576 advance_hpp(hpp, inc);
1577 return hpp->size <= 0;
1578 }
1579
1580 static int
1581 hists_browser__scnprintf_headers(struct hist_browser *browser, char *buf,
1582 size_t size, int line)
1583 {
1584 struct hists *hists = browser->hists;
1585 struct perf_hpp dummy_hpp = {
1586 .buf = buf,
1587 .size = size,
1588 };
1589 struct perf_hpp_fmt *fmt;
1590 size_t ret = 0;
1591 int column = 0;
1592 int span = 0;
1593
1594 if (hists__has_callchains(hists) && symbol_conf.use_callchain) {
1595 ret = scnprintf(buf, size, " ");
1596 if (advance_hpp_check(&dummy_hpp, ret))
1597 return ret;
1598 }
1599
1600 hists__for_each_format(browser->hists, fmt) {
1601 if (perf_hpp__should_skip(fmt, hists) || column++ < browser->b.horiz_scroll)
1602 continue;
1603
1604 ret = fmt->header(fmt, &dummy_hpp, hists, line, &span);
1605 if (advance_hpp_check(&dummy_hpp, ret))
1606 break;
1607
1608 if (span)
1609 continue;
1610
1611 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, " ");
1612 if (advance_hpp_check(&dummy_hpp, ret))
1613 break;
1614 }
1615
1616 return ret;
1617 }
1618
1619 static int hists_browser__scnprintf_hierarchy_headers(struct hist_browser *browser, char *buf, size_t size)
1620 {
1621 struct hists *hists = browser->hists;
1622 struct perf_hpp dummy_hpp = {
1623 .buf = buf,
1624 .size = size,
1625 };
1626 struct perf_hpp_fmt *fmt;
1627 struct perf_hpp_list_node *fmt_node;
1628 size_t ret = 0;
1629 int column = 0;
1630 int indent = hists->nr_hpp_node - 2;
1631 bool first_node, first_col;
1632
1633 ret = scnprintf(buf, size, " ");
1634 if (advance_hpp_check(&dummy_hpp, ret))
1635 return ret;
1636
1637 first_node = true;
1638 /* the first hpp_list_node is for overhead columns */
1639 fmt_node = list_first_entry(&hists->hpp_formats,
1640 struct perf_hpp_list_node, list);
1641 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1642 if (column++ < browser->b.horiz_scroll)
1643 continue;
1644
1645 ret = fmt->header(fmt, &dummy_hpp, hists, 0, NULL);
1646 if (advance_hpp_check(&dummy_hpp, ret))
1647 break;
1648
1649 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, " ");
1650 if (advance_hpp_check(&dummy_hpp, ret))
1651 break;
1652
1653 first_node = false;
1654 }
1655
1656 if (!first_node) {
1657 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "%*s",
1658 indent * HIERARCHY_INDENT, "");
1659 if (advance_hpp_check(&dummy_hpp, ret))
1660 return ret;
1661 }
1662
1663 first_node = true;
1664 list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
1665 if (!first_node) {
1666 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, " / ");
1667 if (advance_hpp_check(&dummy_hpp, ret))
1668 break;
1669 }
1670 first_node = false;
1671
1672 first_col = true;
1673 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
1674 char *start;
1675
1676 if (perf_hpp__should_skip(fmt, hists))
1677 continue;
1678
1679 if (!first_col) {
1680 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "+");
1681 if (advance_hpp_check(&dummy_hpp, ret))
1682 break;
1683 }
1684 first_col = false;
1685
1686 ret = fmt->header(fmt, &dummy_hpp, hists, 0, NULL);
1687 dummy_hpp.buf[ret] = '\0';
1688
1689 start = trim(dummy_hpp.buf);
1690 ret = strlen(start);
1691
1692 if (start != dummy_hpp.buf)
1693 memmove(dummy_hpp.buf, start, ret + 1);
1694
1695 if (advance_hpp_check(&dummy_hpp, ret))
1696 break;
1697 }
1698 }
1699
1700 return ret;
1701 }
1702
1703 static void hists_browser__hierarchy_headers(struct hist_browser *browser)
1704 {
1705 char headers[1024];
1706
1707 hists_browser__scnprintf_hierarchy_headers(browser, headers,
1708 sizeof(headers));
1709
1710 ui_browser__gotorc(&browser->b, 0, 0);
1711 ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
1712 ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
1713 }
1714
1715 static void hists_browser__headers(struct hist_browser *browser)
1716 {
1717 struct hists *hists = browser->hists;
1718 struct perf_hpp_list *hpp_list = hists->hpp_list;
1719
1720 int line;
1721
1722 for (line = 0; line < hpp_list->nr_header_lines; line++) {
1723 char headers[1024];
1724
1725 hists_browser__scnprintf_headers(browser, headers,
1726 sizeof(headers), line);
1727
1728 ui_browser__gotorc_title(&browser->b, line, 0);
1729 ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
1730 ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
1731 }
1732 }
1733
1734 static void hist_browser__show_headers(struct hist_browser *browser)
1735 {
1736 if (symbol_conf.report_hierarchy)
1737 hists_browser__hierarchy_headers(browser);
1738 else
1739 hists_browser__headers(browser);
1740 }
1741
1742 static void ui_browser__hists_init_top(struct ui_browser *browser)
1743 {
1744 if (browser->top == NULL) {
1745 struct hist_browser *hb;
1746
1747 hb = container_of(browser, struct hist_browser, b);
1748 browser->top = rb_first_cached(&hb->hists->entries);
1749 }
1750 }
1751
1752 static unsigned int hist_browser__refresh(struct ui_browser *browser)
1753 {
1754 unsigned row = 0;
1755 struct rb_node *nd;
1756 struct hist_browser *hb = container_of(browser, struct hist_browser, b);
1757
1758 if (hb->show_headers)
1759 hist_browser__show_headers(hb);
1760
1761 ui_browser__hists_init_top(browser);
1762 hb->he_selection = NULL;
1763 hb->selection = NULL;
1764
1765 for (nd = browser->top; nd; nd = rb_hierarchy_next(nd)) {
1766 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1767 float percent;
1768
1769 if (h->filtered) {
1770 /* let it move to sibling */
1771 h->unfolded = false;
1772 continue;
1773 }
1774
1775 percent = hist_entry__get_percent_limit(h);
1776 if (percent < hb->min_pcnt)
1777 continue;
1778
1779 if (symbol_conf.report_hierarchy) {
1780 row += hist_browser__show_hierarchy_entry(hb, h, row,
1781 h->depth);
1782 if (row == browser->rows)
1783 break;
1784
1785 if (h->has_no_entry) {
1786 hist_browser__show_no_entry(hb, row, h->depth + 1);
1787 row++;
1788 }
1789 } else {
1790 row += hist_browser__show_entry(hb, h, row);
1791 }
1792
1793 if (row == browser->rows)
1794 break;
1795 }
1796
1797 return row;
1798 }
1799
1800 static struct rb_node *hists__filter_entries(struct rb_node *nd,
1801 float min_pcnt)
1802 {
1803 while (nd != NULL) {
1804 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1805 float percent = hist_entry__get_percent_limit(h);
1806
1807 if (!h->filtered && percent >= min_pcnt)
1808 return nd;
1809
1810 /*
1811 * If it's filtered, its all children also were filtered.
1812 * So move to sibling node.
1813 */
1814 if (rb_next(nd))
1815 nd = rb_next(nd);
1816 else
1817 nd = rb_hierarchy_next(nd);
1818 }
1819
1820 return NULL;
1821 }
1822
1823 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
1824 float min_pcnt)
1825 {
1826 while (nd != NULL) {
1827 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1828 float percent = hist_entry__get_percent_limit(h);
1829
1830 if (!h->filtered && percent >= min_pcnt)
1831 return nd;
1832
1833 nd = rb_hierarchy_prev(nd);
1834 }
1835
1836 return NULL;
1837 }
1838
1839 static void ui_browser__hists_seek(struct ui_browser *browser,
1840 off_t offset, int whence)
1841 {
1842 struct hist_entry *h;
1843 struct rb_node *nd;
1844 bool first = true;
1845 struct hist_browser *hb;
1846
1847 hb = container_of(browser, struct hist_browser, b);
1848
1849 if (browser->nr_entries == 0)
1850 return;
1851
1852 ui_browser__hists_init_top(browser);
1853
1854 switch (whence) {
1855 case SEEK_SET:
1856 nd = hists__filter_entries(rb_first(browser->entries),
1857 hb->min_pcnt);
1858 break;
1859 case SEEK_CUR:
1860 nd = browser->top;
1861 goto do_offset;
1862 case SEEK_END:
1863 nd = rb_hierarchy_last(rb_last(browser->entries));
1864 nd = hists__filter_prev_entries(nd, hb->min_pcnt);
1865 first = false;
1866 break;
1867 default:
1868 return;
1869 }
1870
1871 /*
1872 * Moves not relative to the first visible entry invalidates its
1873 * row_offset:
1874 */
1875 h = rb_entry(browser->top, struct hist_entry, rb_node);
1876 h->row_offset = 0;
1877
1878 /*
1879 * Here we have to check if nd is expanded (+), if it is we can't go
1880 * the next top level hist_entry, instead we must compute an offset of
1881 * what _not_ to show and not change the first visible entry.
1882 *
1883 * This offset increments when we are going from top to bottom and
1884 * decreases when we're going from bottom to top.
1885 *
1886 * As we don't have backpointers to the top level in the callchains
1887 * structure, we need to always print the whole hist_entry callchain,
1888 * skipping the first ones that are before the first visible entry
1889 * and stop when we printed enough lines to fill the screen.
1890 */
1891 do_offset:
1892 if (!nd)
1893 return;
1894
1895 if (offset > 0) {
1896 do {
1897 h = rb_entry(nd, struct hist_entry, rb_node);
1898 if (h->unfolded && h->leaf) {
1899 u16 remaining = h->nr_rows - h->row_offset;
1900 if (offset > remaining) {
1901 offset -= remaining;
1902 h->row_offset = 0;
1903 } else {
1904 h->row_offset += offset;
1905 offset = 0;
1906 browser->top = nd;
1907 break;
1908 }
1909 }
1910 nd = hists__filter_entries(rb_hierarchy_next(nd),
1911 hb->min_pcnt);
1912 if (nd == NULL)
1913 break;
1914 --offset;
1915 browser->top = nd;
1916 } while (offset != 0);
1917 } else if (offset < 0) {
1918 while (1) {
1919 h = rb_entry(nd, struct hist_entry, rb_node);
1920 if (h->unfolded && h->leaf) {
1921 if (first) {
1922 if (-offset > h->row_offset) {
1923 offset += h->row_offset;
1924 h->row_offset = 0;
1925 } else {
1926 h->row_offset += offset;
1927 offset = 0;
1928 browser->top = nd;
1929 break;
1930 }
1931 } else {
1932 if (-offset > h->nr_rows) {
1933 offset += h->nr_rows;
1934 h->row_offset = 0;
1935 } else {
1936 h->row_offset = h->nr_rows + offset;
1937 offset = 0;
1938 browser->top = nd;
1939 break;
1940 }
1941 }
1942 }
1943
1944 nd = hists__filter_prev_entries(rb_hierarchy_prev(nd),
1945 hb->min_pcnt);
1946 if (nd == NULL)
1947 break;
1948 ++offset;
1949 browser->top = nd;
1950 if (offset == 0) {
1951 /*
1952 * Last unfiltered hist_entry, check if it is
1953 * unfolded, if it is then we should have
1954 * row_offset at its last entry.
1955 */
1956 h = rb_entry(nd, struct hist_entry, rb_node);
1957 if (h->unfolded && h->leaf)
1958 h->row_offset = h->nr_rows;
1959 break;
1960 }
1961 first = false;
1962 }
1963 } else {
1964 browser->top = nd;
1965 h = rb_entry(nd, struct hist_entry, rb_node);
1966 h->row_offset = 0;
1967 }
1968 }
1969
1970 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
1971 struct hist_entry *he, FILE *fp,
1972 int level)
1973 {
1974 struct callchain_print_arg arg = {
1975 .fp = fp,
1976 };
1977
1978 hist_browser__show_callchain(browser, he, level, 0,
1979 hist_browser__fprintf_callchain_entry, &arg,
1980 hist_browser__check_dump_full);
1981 return arg.printed;
1982 }
1983
1984 static int hist_browser__fprintf_entry(struct hist_browser *browser,
1985 struct hist_entry *he, FILE *fp)
1986 {
1987 char s[8192];
1988 int printed = 0;
1989 char folded_sign = ' ';
1990 struct perf_hpp hpp = {
1991 .buf = s,
1992 .size = sizeof(s),
1993 };
1994 struct perf_hpp_fmt *fmt;
1995 bool first = true;
1996 int ret;
1997
1998 if (hist_entry__has_callchains(he) && symbol_conf.use_callchain) {
1999 folded_sign = hist_entry__folded(he);
2000 printed += fprintf(fp, "%c ", folded_sign);
2001 }
2002
2003 hists__for_each_format(browser->hists, fmt) {
2004 if (perf_hpp__should_skip(fmt, he->hists))
2005 continue;
2006
2007 if (!first) {
2008 ret = scnprintf(hpp.buf, hpp.size, " ");
2009 advance_hpp(&hpp, ret);
2010 } else
2011 first = false;
2012
2013 ret = fmt->entry(fmt, &hpp, he);
2014 ret = hist_entry__snprintf_alignment(he, &hpp, fmt, ret);
2015 advance_hpp(&hpp, ret);
2016 }
2017 printed += fprintf(fp, "%s\n", s);
2018
2019 if (folded_sign == '-')
2020 printed += hist_browser__fprintf_callchain(browser, he, fp, 1);
2021
2022 return printed;
2023 }
2024
2025
2026 static int hist_browser__fprintf_hierarchy_entry(struct hist_browser *browser,
2027 struct hist_entry *he,
2028 FILE *fp, int level)
2029 {
2030 char s[8192];
2031 int printed = 0;
2032 char folded_sign = ' ';
2033 struct perf_hpp hpp = {
2034 .buf = s,
2035 .size = sizeof(s),
2036 };
2037 struct perf_hpp_fmt *fmt;
2038 struct perf_hpp_list_node *fmt_node;
2039 bool first = true;
2040 int ret;
2041 int hierarchy_indent = (he->hists->nr_hpp_node - 2) * HIERARCHY_INDENT;
2042
2043 printed = fprintf(fp, "%*s", level * HIERARCHY_INDENT, "");
2044
2045 folded_sign = hist_entry__folded(he);
2046 printed += fprintf(fp, "%c", folded_sign);
2047
2048 /* the first hpp_list_node is for overhead columns */
2049 fmt_node = list_first_entry(&he->hists->hpp_formats,
2050 struct perf_hpp_list_node, list);
2051 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
2052 if (!first) {
2053 ret = scnprintf(hpp.buf, hpp.size, " ");
2054 advance_hpp(&hpp, ret);
2055 } else
2056 first = false;
2057
2058 ret = fmt->entry(fmt, &hpp, he);
2059 advance_hpp(&hpp, ret);
2060 }
2061
2062 ret = scnprintf(hpp.buf, hpp.size, "%*s", hierarchy_indent, "");
2063 advance_hpp(&hpp, ret);
2064
2065 perf_hpp_list__for_each_format(he->hpp_list, fmt) {
2066 ret = scnprintf(hpp.buf, hpp.size, " ");
2067 advance_hpp(&hpp, ret);
2068
2069 ret = fmt->entry(fmt, &hpp, he);
2070 advance_hpp(&hpp, ret);
2071 }
2072
2073 printed += fprintf(fp, "%s\n", rtrim(s));
2074
2075 if (he->leaf && folded_sign == '-') {
2076 printed += hist_browser__fprintf_callchain(browser, he, fp,
2077 he->depth + 1);
2078 }
2079
2080 return printed;
2081 }
2082
2083 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
2084 {
2085 struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
2086 browser->min_pcnt);
2087 int printed = 0;
2088
2089 while (nd) {
2090 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
2091
2092 if (symbol_conf.report_hierarchy) {
2093 printed += hist_browser__fprintf_hierarchy_entry(browser,
2094 h, fp,
2095 h->depth);
2096 } else {
2097 printed += hist_browser__fprintf_entry(browser, h, fp);
2098 }
2099
2100 nd = hists__filter_entries(rb_hierarchy_next(nd),
2101 browser->min_pcnt);
2102 }
2103
2104 return printed;
2105 }
2106
2107 static int hist_browser__dump(struct hist_browser *browser)
2108 {
2109 char filename[64];
2110 FILE *fp;
2111
2112 while (1) {
2113 scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
2114 if (access(filename, F_OK))
2115 break;
2116 /*
2117 * XXX: Just an arbitrary lazy upper limit
2118 */
2119 if (++browser->print_seq == 8192) {
2120 ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
2121 return -1;
2122 }
2123 }
2124
2125 fp = fopen(filename, "w");
2126 if (fp == NULL) {
2127 char bf[64];
2128 const char *err = str_error_r(errno, bf, sizeof(bf));
2129 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
2130 return -1;
2131 }
2132
2133 ++browser->print_seq;
2134 hist_browser__fprintf(browser, fp);
2135 fclose(fp);
2136 ui_helpline__fpush("%s written!", filename);
2137
2138 return 0;
2139 }
2140
2141 void hist_browser__init(struct hist_browser *browser,
2142 struct hists *hists)
2143 {
2144 struct perf_hpp_fmt *fmt;
2145
2146 browser->hists = hists;
2147 browser->b.refresh = hist_browser__refresh;
2148 browser->b.refresh_dimensions = hist_browser__refresh_dimensions;
2149 browser->b.seek = ui_browser__hists_seek;
2150 browser->b.use_navkeypressed = true;
2151 browser->show_headers = symbol_conf.show_hist_headers;
2152 hist_browser__set_title_space(browser);
2153
2154 if (symbol_conf.report_hierarchy) {
2155 struct perf_hpp_list_node *fmt_node;
2156
2157 /* count overhead columns (in the first node) */
2158 fmt_node = list_first_entry(&hists->hpp_formats,
2159 struct perf_hpp_list_node, list);
2160 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt)
2161 ++browser->b.columns;
2162
2163 /* add a single column for whole hierarchy sort keys*/
2164 ++browser->b.columns;
2165 } else {
2166 hists__for_each_format(hists, fmt)
2167 ++browser->b.columns;
2168 }
2169
2170 hists__reset_column_width(hists);
2171 }
2172
2173 struct hist_browser *hist_browser__new(struct hists *hists)
2174 {
2175 struct hist_browser *browser = zalloc(sizeof(*browser));
2176
2177 if (browser)
2178 hist_browser__init(browser, hists);
2179
2180 return browser;
2181 }
2182
2183 static struct hist_browser *
2184 perf_evsel_browser__new(struct perf_evsel *evsel,
2185 struct hist_browser_timer *hbt,
2186 struct perf_env *env,
2187 struct annotation_options *annotation_opts)
2188 {
2189 struct hist_browser *browser = hist_browser__new(evsel__hists(evsel));
2190
2191 if (browser) {
2192 browser->hbt = hbt;
2193 browser->env = env;
2194 browser->title = hists_browser__scnprintf_title;
2195 browser->annotation_opts = annotation_opts;
2196 }
2197 return browser;
2198 }
2199
2200 void hist_browser__delete(struct hist_browser *browser)
2201 {
2202 free(browser);
2203 }
2204
2205 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
2206 {
2207 return browser->he_selection;
2208 }
2209
2210 static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
2211 {
2212 return browser->he_selection->thread;
2213 }
2214
2215 /* Check whether the browser is for 'top' or 'report' */
2216 static inline bool is_report_browser(void *timer)
2217 {
2218 return timer == NULL;
2219 }
2220
2221 static int hists_browser__scnprintf_title(struct hist_browser *browser, char *bf, size_t size)
2222 {
2223 struct hist_browser_timer *hbt = browser->hbt;
2224 int printed = __hists__scnprintf_title(browser->hists, bf, size, !is_report_browser(hbt));
2225
2226 if (!is_report_browser(hbt)) {
2227 struct perf_top *top = hbt->arg;
2228
2229 printed += scnprintf(bf + printed, size - printed,
2230 " lost: %" PRIu64 "/%" PRIu64,
2231 top->lost, top->lost_total);
2232
2233 printed += scnprintf(bf + printed, size - printed,
2234 " drop: %" PRIu64 "/%" PRIu64,
2235 top->drop, top->drop_total);
2236
2237 if (top->zero)
2238 printed += scnprintf(bf + printed, size - printed, " [z]");
2239
2240 perf_top__reset_sample_counters(top);
2241 }
2242
2243
2244 return printed;
2245 }
2246
2247 static inline void free_popup_options(char **options, int n)
2248 {
2249 int i;
2250
2251 for (i = 0; i < n; ++i)
2252 zfree(&options[i]);
2253 }
2254
2255 /*
2256 * Only runtime switching of perf data file will make "input_name" point
2257 * to a malloced buffer. So add "is_input_name_malloced" flag to decide
2258 * whether we need to call free() for current "input_name" during the switch.
2259 */
2260 static bool is_input_name_malloced = false;
2261
2262 static int switch_data_file(void)
2263 {
2264 char *pwd, *options[32], *abs_path[32], *tmp;
2265 DIR *pwd_dir;
2266 int nr_options = 0, choice = -1, ret = -1;
2267 struct dirent *dent;
2268
2269 pwd = getenv("PWD");
2270 if (!pwd)
2271 return ret;
2272
2273 pwd_dir = opendir(pwd);
2274 if (!pwd_dir)
2275 return ret;
2276
2277 memset(options, 0, sizeof(options));
2278 memset(abs_path, 0, sizeof(abs_path));
2279
2280 while ((dent = readdir(pwd_dir))) {
2281 char path[PATH_MAX];
2282 u64 magic;
2283 char *name = dent->d_name;
2284 FILE *file;
2285
2286 if (!(dent->d_type == DT_REG))
2287 continue;
2288
2289 snprintf(path, sizeof(path), "%s/%s", pwd, name);
2290
2291 file = fopen(path, "r");
2292 if (!file)
2293 continue;
2294
2295 if (fread(&magic, 1, 8, file) < 8)
2296 goto close_file_and_continue;
2297
2298 if (is_perf_magic(magic)) {
2299 options[nr_options] = strdup(name);
2300 if (!options[nr_options])
2301 goto close_file_and_continue;
2302
2303 abs_path[nr_options] = strdup(path);
2304 if (!abs_path[nr_options]) {
2305 zfree(&options[nr_options]);
2306 ui__warning("Can't search all data files due to memory shortage.\n");
2307 fclose(file);
2308 break;
2309 }
2310
2311 nr_options++;
2312 }
2313
2314 close_file_and_continue:
2315 fclose(file);
2316 if (nr_options >= 32) {
2317 ui__warning("Too many perf data files in PWD!\n"
2318 "Only the first 32 files will be listed.\n");
2319 break;
2320 }
2321 }
2322 closedir(pwd_dir);
2323
2324 if (nr_options) {
2325 choice = ui__popup_menu(nr_options, options);
2326 if (choice < nr_options && choice >= 0) {
2327 tmp = strdup(abs_path[choice]);
2328 if (tmp) {
2329 if (is_input_name_malloced)
2330 free((void *)input_name);
2331 input_name = tmp;
2332 is_input_name_malloced = true;
2333 ret = 0;
2334 } else
2335 ui__warning("Data switch failed due to memory shortage!\n");
2336 }
2337 }
2338
2339 free_popup_options(options, nr_options);
2340 free_popup_options(abs_path, nr_options);
2341 return ret;
2342 }
2343
2344 struct popup_action {
2345 unsigned long time;
2346 struct thread *thread;
2347 struct map_symbol ms;
2348 int socket;
2349 struct perf_evsel *evsel;
2350 enum rstype rstype;
2351
2352 int (*fn)(struct hist_browser *browser, struct popup_action *act);
2353 };
2354
2355 static int
2356 do_annotate(struct hist_browser *browser, struct popup_action *act)
2357 {
2358 struct perf_evsel *evsel;
2359 struct annotation *notes;
2360 struct hist_entry *he;
2361 int err;
2362
2363 if (!browser->annotation_opts->objdump_path &&
2364 perf_env__lookup_objdump(browser->env, &browser->annotation_opts->objdump_path))
2365 return 0;
2366
2367 notes = symbol__annotation(act->ms.sym);
2368 if (!notes->src)
2369 return 0;
2370
2371 evsel = hists_to_evsel(browser->hists);
2372 err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt,
2373 browser->annotation_opts);
2374 he = hist_browser__selected_entry(browser);
2375 /*
2376 * offer option to annotate the other branch source or target
2377 * (if they exists) when returning from annotate
2378 */
2379 if ((err == 'q' || err == CTRL('c')) && he->branch_info)
2380 return 1;
2381
2382 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
2383 if (err)
2384 ui_browser__handle_resize(&browser->b);
2385 return 0;
2386 }
2387
2388 static int
2389 add_annotate_opt(struct hist_browser *browser __maybe_unused,
2390 struct popup_action *act, char **optstr,
2391 struct map *map, struct symbol *sym)
2392 {
2393 if (sym == NULL || map->dso->annotate_warned)
2394 return 0;
2395
2396 if (asprintf(optstr, "Annotate %s", sym->name) < 0)
2397 return 0;
2398
2399 act->ms.map = map;
2400 act->ms.sym = sym;
2401 act->fn = do_annotate;
2402 return 1;
2403 }
2404
2405 static int
2406 do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
2407 {
2408 struct thread *thread = act->thread;
2409
2410 if ((!hists__has(browser->hists, thread) &&
2411 !hists__has(browser->hists, comm)) || thread == NULL)
2412 return 0;
2413
2414 if (browser->hists->thread_filter) {
2415 pstack__remove(browser->pstack, &browser->hists->thread_filter);
2416 perf_hpp__set_elide(HISTC_THREAD, false);
2417 thread__zput(browser->hists->thread_filter);
2418 ui_helpline__pop();
2419 } else {
2420 if (hists__has(browser->hists, thread)) {
2421 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s(%d) thread\"",
2422 thread->comm_set ? thread__comm_str(thread) : "",
2423 thread->tid);
2424 } else {
2425 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s thread\"",
2426 thread->comm_set ? thread__comm_str(thread) : "");
2427 }
2428
2429 browser->hists->thread_filter = thread__get(thread);
2430 perf_hpp__set_elide(HISTC_THREAD, false);
2431 pstack__push(browser->pstack, &browser->hists->thread_filter);
2432 }
2433
2434 hists__filter_by_thread(browser->hists);
2435 hist_browser__reset(browser);
2436 return 0;
2437 }
2438
2439 static int
2440 add_thread_opt(struct hist_browser *browser, struct popup_action *act,
2441 char **optstr, struct thread *thread)
2442 {
2443 int ret;
2444
2445 if ((!hists__has(browser->hists, thread) &&
2446 !hists__has(browser->hists, comm)) || thread == NULL)
2447 return 0;
2448
2449 if (hists__has(browser->hists, thread)) {
2450 ret = asprintf(optstr, "Zoom %s %s(%d) thread",
2451 browser->hists->thread_filter ? "out of" : "into",
2452 thread->comm_set ? thread__comm_str(thread) : "",
2453 thread->tid);
2454 } else {
2455 ret = asprintf(optstr, "Zoom %s %s thread",
2456 browser->hists->thread_filter ? "out of" : "into",
2457 thread->comm_set ? thread__comm_str(thread) : "");
2458 }
2459 if (ret < 0)
2460 return 0;
2461
2462 act->thread = thread;
2463 act->fn = do_zoom_thread;
2464 return 1;
2465 }
2466
2467 static int
2468 do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
2469 {
2470 struct map *map = act->ms.map;
2471
2472 if (!hists__has(browser->hists, dso) || map == NULL)
2473 return 0;
2474
2475 if (browser->hists->dso_filter) {
2476 pstack__remove(browser->pstack, &browser->hists->dso_filter);
2477 perf_hpp__set_elide(HISTC_DSO, false);
2478 browser->hists->dso_filter = NULL;
2479 ui_helpline__pop();
2480 } else {
2481 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s DSO\"",
2482 __map__is_kernel(map) ? "the Kernel" : map->dso->short_name);
2483 browser->hists->dso_filter = map->dso;
2484 perf_hpp__set_elide(HISTC_DSO, true);
2485 pstack__push(browser->pstack, &browser->hists->dso_filter);
2486 }
2487
2488 hists__filter_by_dso(browser->hists);
2489 hist_browser__reset(browser);
2490 return 0;
2491 }
2492
2493 static int
2494 add_dso_opt(struct hist_browser *browser, struct popup_action *act,
2495 char **optstr, struct map *map)
2496 {
2497 if (!hists__has(browser->hists, dso) || map == NULL)
2498 return 0;
2499
2500 if (asprintf(optstr, "Zoom %s %s DSO",
2501 browser->hists->dso_filter ? "out of" : "into",
2502 __map__is_kernel(map) ? "the Kernel" : map->dso->short_name) < 0)
2503 return 0;
2504
2505 act->ms.map = map;
2506 act->fn = do_zoom_dso;
2507 return 1;
2508 }
2509
2510 static int
2511 do_browse_map(struct hist_browser *browser __maybe_unused,
2512 struct popup_action *act)
2513 {
2514 map__browse(act->ms.map);
2515 return 0;
2516 }
2517
2518 static int
2519 add_map_opt(struct hist_browser *browser,
2520 struct popup_action *act, char **optstr, struct map *map)
2521 {
2522 if (!hists__has(browser->hists, dso) || map == NULL)
2523 return 0;
2524
2525 if (asprintf(optstr, "Browse map details") < 0)
2526 return 0;
2527
2528 act->ms.map = map;
2529 act->fn = do_browse_map;
2530 return 1;
2531 }
2532
2533 static int
2534 do_run_script(struct hist_browser *browser __maybe_unused,
2535 struct popup_action *act)
2536 {
2537 char *script_opt;
2538 int len;
2539 int n = 0;
2540
2541 len = 100;
2542 if (act->thread)
2543 len += strlen(thread__comm_str(act->thread));
2544 else if (act->ms.sym)
2545 len += strlen(act->ms.sym->name);
2546 script_opt = malloc(len);
2547 if (!script_opt)
2548 return -1;
2549
2550 script_opt[0] = 0;
2551 if (act->thread) {
2552 n = scnprintf(script_opt, len, " -c %s ",
2553 thread__comm_str(act->thread));
2554 } else if (act->ms.sym) {
2555 n = scnprintf(script_opt, len, " -S %s ",
2556 act->ms.sym->name);
2557 }
2558
2559 if (act->time) {
2560 char start[32], end[32];
2561 unsigned long starttime = act->time;
2562 unsigned long endtime = act->time + symbol_conf.time_quantum;
2563
2564 if (starttime == endtime) { /* Display 1ms as fallback */
2565 starttime -= 1*NSEC_PER_MSEC;
2566 endtime += 1*NSEC_PER_MSEC;
2567 }
2568 timestamp__scnprintf_usec(starttime, start, sizeof start);
2569 timestamp__scnprintf_usec(endtime, end, sizeof end);
2570 n += snprintf(script_opt + n, len - n, " --time %s,%s", start, end);
2571 }
2572
2573 script_browse(script_opt, act->evsel);
2574 free(script_opt);
2575 return 0;
2576 }
2577
2578 static int
2579 do_res_sample_script(struct hist_browser *browser __maybe_unused,
2580 struct popup_action *act)
2581 {
2582 struct hist_entry *he;
2583
2584 he = hist_browser__selected_entry(browser);
2585 res_sample_browse(he->res_samples, he->num_res, act->evsel, act->rstype);
2586 return 0;
2587 }
2588
2589 static int
2590 add_script_opt_2(struct hist_browser *browser __maybe_unused,
2591 struct popup_action *act, char **optstr,
2592 struct thread *thread, struct symbol *sym,
2593 struct perf_evsel *evsel, const char *tstr)
2594 {
2595
2596 if (thread) {
2597 if (asprintf(optstr, "Run scripts for samples of thread [%s]%s",
2598 thread__comm_str(thread), tstr) < 0)
2599 return 0;
2600 } else if (sym) {
2601 if (asprintf(optstr, "Run scripts for samples of symbol [%s]%s",
2602 sym->name, tstr) < 0)
2603 return 0;
2604 } else {
2605 if (asprintf(optstr, "Run scripts for all samples%s", tstr) < 0)
2606 return 0;
2607 }
2608
2609 act->thread = thread;
2610 act->ms.sym = sym;
2611 act->evsel = evsel;
2612 act->fn = do_run_script;
2613 return 1;
2614 }
2615
2616 static int
2617 add_script_opt(struct hist_browser *browser,
2618 struct popup_action *act, char **optstr,
2619 struct thread *thread, struct symbol *sym,
2620 struct perf_evsel *evsel)
2621 {
2622 int n, j;
2623 struct hist_entry *he;
2624
2625 n = add_script_opt_2(browser, act, optstr, thread, sym, evsel, "");
2626
2627 he = hist_browser__selected_entry(browser);
2628 if (sort_order && strstr(sort_order, "time")) {
2629 char tstr[128];
2630
2631 optstr++;
2632 act++;
2633 j = sprintf(tstr, " in ");
2634 j += timestamp__scnprintf_usec(he->time, tstr + j,
2635 sizeof tstr - j);
2636 j += sprintf(tstr + j, "-");
2637 timestamp__scnprintf_usec(he->time + symbol_conf.time_quantum,
2638 tstr + j, sizeof tstr - j);
2639 n += add_script_opt_2(browser, act, optstr, thread, sym,
2640 evsel, tstr);
2641 act->time = he->time;
2642 }
2643 return n;
2644 }
2645
2646 static int
2647 add_res_sample_opt(struct hist_browser *browser __maybe_unused,
2648 struct popup_action *act, char **optstr,
2649 struct res_sample *res_sample,
2650 struct perf_evsel *evsel,
2651 enum rstype type)
2652 {
2653 if (!res_sample)
2654 return 0;
2655
2656 if (asprintf(optstr, "Show context for individual samples %s",
2657 type == A_ASM ? "with assembler" :
2658 type == A_SOURCE ? "with source" : "") < 0)
2659 return 0;
2660
2661 act->fn = do_res_sample_script;
2662 act->evsel = evsel;
2663 act->rstype = type;
2664 return 1;
2665 }
2666
2667 static int
2668 do_switch_data(struct hist_browser *browser __maybe_unused,
2669 struct popup_action *act __maybe_unused)
2670 {
2671 if (switch_data_file()) {
2672 ui__warning("Won't switch the data files due to\n"
2673 "no valid data file get selected!\n");
2674 return 0;
2675 }
2676
2677 return K_SWITCH_INPUT_DATA;
2678 }
2679
2680 static int
2681 add_switch_opt(struct hist_browser *browser,
2682 struct popup_action *act, char **optstr)
2683 {
2684 if (!is_report_browser(browser->hbt))
2685 return 0;
2686
2687 if (asprintf(optstr, "Switch to another data file in PWD") < 0)
2688 return 0;
2689
2690 act->fn = do_switch_data;
2691 return 1;
2692 }
2693
2694 static int
2695 do_exit_browser(struct hist_browser *browser __maybe_unused,
2696 struct popup_action *act __maybe_unused)
2697 {
2698 return 0;
2699 }
2700
2701 static int
2702 add_exit_opt(struct hist_browser *browser __maybe_unused,
2703 struct popup_action *act, char **optstr)
2704 {
2705 if (asprintf(optstr, "Exit") < 0)
2706 return 0;
2707
2708 act->fn = do_exit_browser;
2709 return 1;
2710 }
2711
2712 static int
2713 do_zoom_socket(struct hist_browser *browser, struct popup_action *act)
2714 {
2715 if (!hists__has(browser->hists, socket) || act->socket < 0)
2716 return 0;
2717
2718 if (browser->hists->socket_filter > -1) {
2719 pstack__remove(browser->pstack, &browser->hists->socket_filter);
2720 browser->hists->socket_filter = -1;
2721 perf_hpp__set_elide(HISTC_SOCKET, false);
2722 } else {
2723 browser->hists->socket_filter = act->socket;
2724 perf_hpp__set_elide(HISTC_SOCKET, true);
2725 pstack__push(browser->pstack, &browser->hists->socket_filter);
2726 }
2727
2728 hists__filter_by_socket(browser->hists);
2729 hist_browser__reset(browser);
2730 return 0;
2731 }
2732
2733 static int
2734 add_socket_opt(struct hist_browser *browser, struct popup_action *act,
2735 char **optstr, int socket_id)
2736 {
2737 if (!hists__has(browser->hists, socket) || socket_id < 0)
2738 return 0;
2739
2740 if (asprintf(optstr, "Zoom %s Processor Socket %d",
2741 (browser->hists->socket_filter > -1) ? "out of" : "into",
2742 socket_id) < 0)
2743 return 0;
2744
2745 act->socket = socket_id;
2746 act->fn = do_zoom_socket;
2747 return 1;
2748 }
2749
2750 static void hist_browser__update_nr_entries(struct hist_browser *hb)
2751 {
2752 u64 nr_entries = 0;
2753 struct rb_node *nd = rb_first_cached(&hb->hists->entries);
2754
2755 if (hb->min_pcnt == 0 && !symbol_conf.report_hierarchy) {
2756 hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;
2757 return;
2758 }
2759
2760 while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
2761 nr_entries++;
2762 nd = rb_hierarchy_next(nd);
2763 }
2764
2765 hb->nr_non_filtered_entries = nr_entries;
2766 hb->nr_hierarchy_entries = nr_entries;
2767 }
2768
2769 static void hist_browser__update_percent_limit(struct hist_browser *hb,
2770 double percent)
2771 {
2772 struct hist_entry *he;
2773 struct rb_node *nd = rb_first_cached(&hb->hists->entries);
2774 u64 total = hists__total_period(hb->hists);
2775 u64 min_callchain_hits = total * (percent / 100);
2776
2777 hb->min_pcnt = callchain_param.min_percent = percent;
2778
2779 while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
2780 he = rb_entry(nd, struct hist_entry, rb_node);
2781
2782 if (he->has_no_entry) {
2783 he->has_no_entry = false;
2784 he->nr_rows = 0;
2785 }
2786
2787 if (!he->leaf || !hist_entry__has_callchains(he) || !symbol_conf.use_callchain)
2788 goto next;
2789
2790 if (callchain_param.mode == CHAIN_GRAPH_REL) {
2791 total = he->stat.period;
2792
2793 if (symbol_conf.cumulate_callchain)
2794 total = he->stat_acc->period;
2795
2796 min_callchain_hits = total * (percent / 100);
2797 }
2798
2799 callchain_param.sort(&he->sorted_chain, he->callchain,
2800 min_callchain_hits, &callchain_param);
2801
2802 next:
2803 nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
2804
2805 /* force to re-evaluate folding state of callchains */
2806 he->init_have_children = false;
2807 hist_entry__set_folding(he, hb, false);
2808 }
2809 }
2810
2811 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
2812 const char *helpline,
2813 bool left_exits,
2814 struct hist_browser_timer *hbt,
2815 float min_pcnt,
2816 struct perf_env *env,
2817 bool warn_lost_event,
2818 struct annotation_options *annotation_opts)
2819 {
2820 struct hists *hists = evsel__hists(evsel);
2821 struct hist_browser *browser = perf_evsel_browser__new(evsel, hbt, env, annotation_opts);
2822 struct branch_info *bi;
2823 #define MAX_OPTIONS 16
2824 char *options[MAX_OPTIONS];
2825 struct popup_action actions[MAX_OPTIONS];
2826 int nr_options = 0;
2827 int key = -1;
2828 char buf[64];
2829 int delay_secs = hbt ? hbt->refresh : 0;
2830
2831 #define HIST_BROWSER_HELP_COMMON \
2832 "h/?/F1 Show this window\n" \
2833 "UP/DOWN/PGUP\n" \
2834 "PGDN/SPACE Navigate\n" \
2835 "q/ESC/CTRL+C Exit browser or go back to previous screen\n\n" \
2836 "For multiple event sessions:\n\n" \
2837 "TAB/UNTAB Switch events\n\n" \
2838 "For symbolic views (--sort has sym):\n\n" \
2839 "ENTER Zoom into DSO/Threads & Annotate current symbol\n" \
2840 "ESC Zoom out\n" \
2841 "a Annotate current symbol\n" \
2842 "C Collapse all callchains\n" \
2843 "d Zoom into current DSO\n" \
2844 "E Expand all callchains\n" \
2845 "F Toggle percentage of filtered entries\n" \
2846 "H Display column headers\n" \
2847 "L Change percent limit\n" \
2848 "m Display context menu\n" \
2849 "S Zoom into current Processor Socket\n" \
2850
2851 /* help messages are sorted by lexical order of the hotkey */
2852 static const char report_help[] = HIST_BROWSER_HELP_COMMON
2853 "i Show header information\n"
2854 "P Print histograms to perf.hist.N\n"
2855 "r Run available scripts\n"
2856 "s Switch to another data file in PWD\n"
2857 "t Zoom into current Thread\n"
2858 "V Verbose (DSO names in callchains, etc)\n"
2859 "/ Filter symbol by name";
2860 static const char top_help[] = HIST_BROWSER_HELP_COMMON
2861 "P Print histograms to perf.hist.N\n"
2862 "t Zoom into current Thread\n"
2863 "V Verbose (DSO names in callchains, etc)\n"
2864 "z Toggle zeroing of samples\n"
2865 "f Enable/Disable events\n"
2866 "/ Filter symbol by name";
2867
2868 if (browser == NULL)
2869 return -1;
2870
2871 /* reset abort key so that it can get Ctrl-C as a key */
2872 SLang_reset_tty();
2873 SLang_init_tty(0, 0, 0);
2874
2875 if (min_pcnt)
2876 browser->min_pcnt = min_pcnt;
2877 hist_browser__update_nr_entries(browser);
2878
2879 browser->pstack = pstack__new(3);
2880 if (browser->pstack == NULL)
2881 goto out;
2882
2883 ui_helpline__push(helpline);
2884
2885 memset(options, 0, sizeof(options));
2886 memset(actions, 0, sizeof(actions));
2887
2888 if (symbol_conf.col_width_list_str)
2889 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
2890
2891 while (1) {
2892 struct thread *thread = NULL;
2893 struct map *map = NULL;
2894 int choice = 0;
2895 int socked_id = -1;
2896
2897 nr_options = 0;
2898
2899 key = hist_browser__run(browser, helpline,
2900 warn_lost_event);
2901
2902 if (browser->he_selection != NULL) {
2903 thread = hist_browser__selected_thread(browser);
2904 map = browser->selection->map;
2905 socked_id = browser->he_selection->socket;
2906 }
2907 switch (key) {
2908 case K_TAB:
2909 case K_UNTAB:
2910 if (nr_events == 1)
2911 continue;
2912 /*
2913 * Exit the browser, let hists__browser_tree
2914 * go to the next or previous
2915 */
2916 goto out_free_stack;
2917 case 'a':
2918 if (!hists__has(hists, sym)) {
2919 ui_browser__warning(&browser->b, delay_secs * 2,
2920 "Annotation is only available for symbolic views, "
2921 "include \"sym*\" in --sort to use it.");
2922 continue;
2923 }
2924
2925 if (browser->selection == NULL ||
2926 browser->selection->sym == NULL ||
2927 browser->selection->map->dso->annotate_warned)
2928 continue;
2929
2930 actions->ms.map = browser->selection->map;
2931 actions->ms.sym = browser->selection->sym;
2932 do_annotate(browser, actions);
2933 continue;
2934 case 'P':
2935 hist_browser__dump(browser);
2936 continue;
2937 case 'd':
2938 actions->ms.map = map;
2939 do_zoom_dso(browser, actions);
2940 continue;
2941 case 'V':
2942 verbose = (verbose + 1) % 4;
2943 browser->show_dso = verbose > 0;
2944 ui_helpline__fpush("Verbosity level set to %d\n",
2945 verbose);
2946 continue;
2947 case 't':
2948 actions->thread = thread;
2949 do_zoom_thread(browser, actions);
2950 continue;
2951 case 'S':
2952 actions->socket = socked_id;
2953 do_zoom_socket(browser, actions);
2954 continue;
2955 case '/':
2956 if (ui_browser__input_window("Symbol to show",
2957 "Please enter the name of symbol you want to see.\n"
2958 "To remove the filter later, press / + ENTER.",
2959 buf, "ENTER: OK, ESC: Cancel",
2960 delay_secs * 2) == K_ENTER) {
2961 hists->symbol_filter_str = *buf ? buf : NULL;
2962 hists__filter_by_symbol(hists);
2963 hist_browser__reset(browser);
2964 }
2965 continue;
2966 case 'r':
2967 if (is_report_browser(hbt)) {
2968 actions->thread = NULL;
2969 actions->ms.sym = NULL;
2970 do_run_script(browser, actions);
2971 }
2972 continue;
2973 case 's':
2974 if (is_report_browser(hbt)) {
2975 key = do_switch_data(browser, actions);
2976 if (key == K_SWITCH_INPUT_DATA)
2977 goto out_free_stack;
2978 }
2979 continue;
2980 case 'i':
2981 /* env->arch is NULL for live-mode (i.e. perf top) */
2982 if (env->arch)
2983 tui__header_window(env);
2984 continue;
2985 case 'F':
2986 symbol_conf.filter_relative ^= 1;
2987 continue;
2988 case 'z':
2989 if (!is_report_browser(hbt)) {
2990 struct perf_top *top = hbt->arg;
2991
2992 top->zero = !top->zero;
2993 }
2994 continue;
2995 case 'L':
2996 if (ui_browser__input_window("Percent Limit",
2997 "Please enter the value you want to hide entries under that percent.",
2998 buf, "ENTER: OK, ESC: Cancel",
2999 delay_secs * 2) == K_ENTER) {
3000 char *end;
3001 double new_percent = strtod(buf, &end);
3002
3003 if (new_percent < 0 || new_percent > 100) {
3004 ui_browser__warning(&browser->b, delay_secs * 2,
3005 "Invalid percent: %.2f", new_percent);
3006 continue;
3007 }
3008
3009 hist_browser__update_percent_limit(browser, new_percent);
3010 hist_browser__reset(browser);
3011 }
3012 continue;
3013 case K_F1:
3014 case 'h':
3015 case '?':
3016 ui_browser__help_window(&browser->b,
3017 is_report_browser(hbt) ? report_help : top_help);
3018 continue;
3019 case K_ENTER:
3020 case K_RIGHT:
3021 case 'm':
3022 /* menu */
3023 break;
3024 case K_ESC:
3025 case K_LEFT: {
3026 const void *top;
3027
3028 if (pstack__empty(browser->pstack)) {
3029 /*
3030 * Go back to the perf_evsel_menu__run or other user
3031 */
3032 if (left_exits)
3033 goto out_free_stack;
3034
3035 if (key == K_ESC &&
3036 ui_browser__dialog_yesno(&browser->b,
3037 "Do you really want to exit?"))
3038 goto out_free_stack;
3039
3040 continue;
3041 }
3042 top = pstack__peek(browser->pstack);
3043 if (top == &browser->hists->dso_filter) {
3044 /*
3045 * No need to set actions->dso here since
3046 * it's just to remove the current filter.
3047 * Ditto for thread below.
3048 */
3049 do_zoom_dso(browser, actions);
3050 } else if (top == &browser->hists->thread_filter) {
3051 do_zoom_thread(browser, actions);
3052 } else if (top == &browser->hists->socket_filter) {
3053 do_zoom_socket(browser, actions);
3054 }
3055 continue;
3056 }
3057 case 'q':
3058 case CTRL('c'):
3059 goto out_free_stack;
3060 case 'f':
3061 if (!is_report_browser(hbt)) {
3062 struct perf_top *top = hbt->arg;
3063
3064 perf_evlist__toggle_enable(top->evlist);
3065 /*
3066 * No need to refresh, resort/decay histogram
3067 * entries if we are not collecting samples:
3068 */
3069 if (top->evlist->enabled) {
3070 helpline = "Press 'f' to disable the events or 'h' to see other hotkeys";
3071 hbt->refresh = delay_secs;
3072 } else {
3073 helpline = "Press 'f' again to re-enable the events";
3074 hbt->refresh = 0;
3075 }
3076 continue;
3077 }
3078 /* Fall thru */
3079 default:
3080 helpline = "Press '?' for help on key bindings";
3081 continue;
3082 }
3083
3084 if (!hists__has(hists, sym) || browser->selection == NULL)
3085 goto skip_annotation;
3086
3087 if (sort__mode == SORT_MODE__BRANCH) {
3088 bi = browser->he_selection->branch_info;
3089
3090 if (bi == NULL)
3091 goto skip_annotation;
3092
3093 nr_options += add_annotate_opt(browser,
3094 &actions[nr_options],
3095 &options[nr_options],
3096 bi->from.map,
3097 bi->from.sym);
3098 if (bi->to.sym != bi->from.sym)
3099 nr_options += add_annotate_opt(browser,
3100 &actions[nr_options],
3101 &options[nr_options],
3102 bi->to.map,
3103 bi->to.sym);
3104 } else {
3105 nr_options += add_annotate_opt(browser,
3106 &actions[nr_options],
3107 &options[nr_options],
3108 browser->selection->map,
3109 browser->selection->sym);
3110 }
3111 skip_annotation:
3112 nr_options += add_thread_opt(browser, &actions[nr_options],
3113 &options[nr_options], thread);
3114 nr_options += add_dso_opt(browser, &actions[nr_options],
3115 &options[nr_options], map);
3116 nr_options += add_map_opt(browser, &actions[nr_options],
3117 &options[nr_options],
3118 browser->selection ?
3119 browser->selection->map : NULL);
3120 nr_options += add_socket_opt(browser, &actions[nr_options],
3121 &options[nr_options],
3122 socked_id);
3123 /* perf script support */
3124 if (!is_report_browser(hbt))
3125 goto skip_scripting;
3126
3127 if (browser->he_selection) {
3128 if (hists__has(hists, thread) && thread) {
3129 nr_options += add_script_opt(browser,
3130 &actions[nr_options],
3131 &options[nr_options],
3132 thread, NULL, evsel);
3133 }
3134 /*
3135 * Note that browser->selection != NULL
3136 * when browser->he_selection is not NULL,
3137 * so we don't need to check browser->selection
3138 * before fetching browser->selection->sym like what
3139 * we do before fetching browser->selection->map.
3140 *
3141 * See hist_browser__show_entry.
3142 */
3143 if (hists__has(hists, sym) && browser->selection->sym) {
3144 nr_options += add_script_opt(browser,
3145 &actions[nr_options],
3146 &options[nr_options],
3147 NULL, browser->selection->sym,
3148 evsel);
3149 }
3150 }
3151 nr_options += add_script_opt(browser, &actions[nr_options],
3152 &options[nr_options], NULL, NULL, evsel);
3153 nr_options += add_res_sample_opt(browser, &actions[nr_options],
3154 &options[nr_options],
3155 hist_browser__selected_entry(browser)->res_samples,
3156 evsel, A_NORMAL);
3157 nr_options += add_res_sample_opt(browser, &actions[nr_options],
3158 &options[nr_options],
3159 hist_browser__selected_entry(browser)->res_samples,
3160 evsel, A_ASM);
3161 nr_options += add_res_sample_opt(browser, &actions[nr_options],
3162 &options[nr_options],
3163 hist_browser__selected_entry(browser)->res_samples,
3164 evsel, A_SOURCE);
3165 nr_options += add_switch_opt(browser, &actions[nr_options],
3166 &options[nr_options]);
3167 skip_scripting:
3168 nr_options += add_exit_opt(browser, &actions[nr_options],
3169 &options[nr_options]);
3170
3171 do {
3172 struct popup_action *act;
3173
3174 choice = ui__popup_menu(nr_options, options);
3175 if (choice == -1 || choice >= nr_options)
3176 break;
3177
3178 act = &actions[choice];
3179 key = act->fn(browser, act);
3180 } while (key == 1);
3181
3182 if (key == K_SWITCH_INPUT_DATA)
3183 break;
3184 }
3185 out_free_stack:
3186 pstack__delete(browser->pstack);
3187 out:
3188 hist_browser__delete(browser);
3189 free_popup_options(options, MAX_OPTIONS);
3190 return key;
3191 }
3192
3193 struct perf_evsel_menu {
3194 struct ui_browser b;
3195 struct perf_evsel *selection;
3196 struct annotation_options *annotation_opts;
3197 bool lost_events, lost_events_warned;
3198 float min_pcnt;
3199 struct perf_env *env;
3200 };
3201
3202 static void perf_evsel_menu__write(struct ui_browser *browser,
3203 void *entry, int row)
3204 {
3205 struct perf_evsel_menu *menu = container_of(browser,
3206 struct perf_evsel_menu, b);
3207 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
3208 struct hists *hists = evsel__hists(evsel);
3209 bool current_entry = ui_browser__is_current_entry(browser, row);
3210 unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
3211 const char *ev_name = perf_evsel__name(evsel);
3212 char bf[256], unit;
3213 const char *warn = " ";
3214 size_t printed;
3215
3216 ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
3217 HE_COLORSET_NORMAL);
3218
3219 if (perf_evsel__is_group_event(evsel)) {
3220 struct perf_evsel *pos;
3221
3222 ev_name = perf_evsel__group_name(evsel);
3223
3224 for_each_group_member(pos, evsel) {
3225 struct hists *pos_hists = evsel__hists(pos);
3226 nr_events += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
3227 }
3228 }
3229
3230 nr_events = convert_unit(nr_events, &unit);
3231 printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
3232 unit, unit == ' ' ? "" : " ", ev_name);
3233 ui_browser__printf(browser, "%s", bf);
3234
3235 nr_events = hists->stats.nr_events[PERF_RECORD_LOST];
3236 if (nr_events != 0) {
3237 menu->lost_events = true;
3238 if (!current_entry)
3239 ui_browser__set_color(browser, HE_COLORSET_TOP);
3240 nr_events = convert_unit(nr_events, &unit);
3241 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
3242 nr_events, unit, unit == ' ' ? "" : " ");
3243 warn = bf;
3244 }
3245
3246 ui_browser__write_nstring(browser, warn, browser->width - printed);
3247
3248 if (current_entry)
3249 menu->selection = evsel;
3250 }
3251
3252 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
3253 int nr_events, const char *help,
3254 struct hist_browser_timer *hbt,
3255 bool warn_lost_event)
3256 {
3257 struct perf_evlist *evlist = menu->b.priv;
3258 struct perf_evsel *pos;
3259 const char *title = "Available samples";
3260 int delay_secs = hbt ? hbt->refresh : 0;
3261 int key;
3262
3263 if (ui_browser__show(&menu->b, title,
3264 "ESC: exit, ENTER|->: Browse histograms") < 0)
3265 return -1;
3266
3267 while (1) {
3268 key = ui_browser__run(&menu->b, delay_secs);
3269
3270 switch (key) {
3271 case K_TIMER:
3272 hbt->timer(hbt->arg);
3273
3274 if (!menu->lost_events_warned &&
3275 menu->lost_events &&
3276 warn_lost_event) {
3277 ui_browser__warn_lost_events(&menu->b);
3278 menu->lost_events_warned = true;
3279 }
3280 continue;
3281 case K_RIGHT:
3282 case K_ENTER:
3283 if (!menu->selection)
3284 continue;
3285 pos = menu->selection;
3286 browse_hists:
3287 perf_evlist__set_selected(evlist, pos);
3288 /*
3289 * Give the calling tool a chance to populate the non
3290 * default evsel resorted hists tree.
3291 */
3292 if (hbt)
3293 hbt->timer(hbt->arg);
3294 key = perf_evsel__hists_browse(pos, nr_events, help,
3295 true, hbt,
3296 menu->min_pcnt,
3297 menu->env,
3298 warn_lost_event,
3299 menu->annotation_opts);
3300 ui_browser__show_title(&menu->b, title);
3301 switch (key) {
3302 case K_TAB:
3303 if (pos->node.next == &evlist->entries)
3304 pos = perf_evlist__first(evlist);
3305 else
3306 pos = perf_evsel__next(pos);
3307 goto browse_hists;
3308 case K_UNTAB:
3309 if (pos->node.prev == &evlist->entries)
3310 pos = perf_evlist__last(evlist);
3311 else
3312 pos = perf_evsel__prev(pos);
3313 goto browse_hists;
3314 case K_SWITCH_INPUT_DATA:
3315 case 'q':
3316 case CTRL('c'):
3317 goto out;
3318 case K_ESC:
3319 default:
3320 continue;
3321 }
3322 case K_LEFT:
3323 continue;
3324 case K_ESC:
3325 if (!ui_browser__dialog_yesno(&menu->b,
3326 "Do you really want to exit?"))
3327 continue;
3328 /* Fall thru */
3329 case 'q':
3330 case CTRL('c'):
3331 goto out;
3332 default:
3333 continue;
3334 }
3335 }
3336
3337 out:
3338 ui_browser__hide(&menu->b);
3339 return key;
3340 }
3341
3342 static bool filter_group_entries(struct ui_browser *browser __maybe_unused,
3343 void *entry)
3344 {
3345 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
3346
3347 if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
3348 return true;
3349
3350 return false;
3351 }
3352
3353 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
3354 int nr_entries, const char *help,
3355 struct hist_browser_timer *hbt,
3356 float min_pcnt,
3357 struct perf_env *env,
3358 bool warn_lost_event,
3359 struct annotation_options *annotation_opts)
3360 {
3361 struct perf_evsel *pos;
3362 struct perf_evsel_menu menu = {
3363 .b = {
3364 .entries = &evlist->entries,
3365 .refresh = ui_browser__list_head_refresh,
3366 .seek = ui_browser__list_head_seek,
3367 .write = perf_evsel_menu__write,
3368 .filter = filter_group_entries,
3369 .nr_entries = nr_entries,
3370 .priv = evlist,
3371 },
3372 .min_pcnt = min_pcnt,
3373 .env = env,
3374 .annotation_opts = annotation_opts,
3375 };
3376
3377 ui_helpline__push("Press ESC to exit");
3378
3379 evlist__for_each_entry(evlist, pos) {
3380 const char *ev_name = perf_evsel__name(pos);
3381 size_t line_len = strlen(ev_name) + 7;
3382
3383 if (menu.b.width < line_len)
3384 menu.b.width = line_len;
3385 }
3386
3387 return perf_evsel_menu__run(&menu, nr_entries, help,
3388 hbt, warn_lost_event);
3389 }
3390
3391 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
3392 struct hist_browser_timer *hbt,
3393 float min_pcnt,
3394 struct perf_env *env,
3395 bool warn_lost_event,
3396 struct annotation_options *annotation_opts)
3397 {
3398 int nr_entries = evlist->nr_entries;
3399
3400 single_entry:
3401 if (nr_entries == 1) {
3402 struct perf_evsel *first = perf_evlist__first(evlist);
3403
3404 return perf_evsel__hists_browse(first, nr_entries, help,
3405 false, hbt, min_pcnt,
3406 env, warn_lost_event,
3407 annotation_opts);
3408 }
3409
3410 if (symbol_conf.event_group) {
3411 struct perf_evsel *pos;
3412
3413 nr_entries = 0;
3414 evlist__for_each_entry(evlist, pos) {
3415 if (perf_evsel__is_group_leader(pos))
3416 nr_entries++;
3417 }
3418
3419 if (nr_entries == 1)
3420 goto single_entry;
3421 }
3422
3423 return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
3424 hbt, min_pcnt, env,
3425 warn_lost_event,
3426 annotation_opts);
3427 }
Ubuntu combined Linux kernel mirror