]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - tools/perf/ui/browsers/hists.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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