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