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