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