projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf tools: Remove hist_entry->fmt field
[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
4b3a3212 340 if (node->val.next != node->val.prev) {
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';
1610 rtrim(dummy_hpp.buf);
1611
1612 start = ltrim(dummy_hpp.buf);
1613 ret = strlen(start);
1614
1615 if (start != dummy_hpp.buf)
1616 memmove(dummy_hpp.buf, start, ret + 1);
1617
1618 if (advance_hpp_check(&dummy_hpp, ret))
1619 break;
1620 }
d8b92400
NK		 1621 }
1622
1623 return ret;
1624}
1625
025bf7ea
ACM		 1626static void hist_browser__show_headers(struct hist_browser *browser)
1627{
81a888fe
JO		 1628 char headers[1024];
1629
d8b92400
NK		 1630 if (symbol_conf.report_hierarchy)
1631 hists_browser__scnprintf_hierarchy_headers(browser, headers,
1632 sizeof(headers));
1633 else
1634 hists_browser__scnprintf_headers(browser, headers,
1635 sizeof(headers));
025bf7ea
ACM		 1636 ui_browser__gotorc(&browser->b, 0, 0);
1637 ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
26270a00 1638 ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
025bf7ea
ACM		 1639}
1640
437cfe7a
ACM		 1641static void ui_browser__hists_init_top(struct ui_browser *browser)
1642{
1643 if (browser->top == NULL) {
1644 struct hist_browser *hb;
1645
1646 hb = container_of(browser, struct hist_browser, b);
1647 browser->top = rb_first(&hb->hists->entries);
1648 }
1649}
1650
05e8b080 1651static unsigned int hist_browser__refresh(struct ui_browser *browser)
d1b4f249
ACM		 1652{
1653 unsigned row = 0;
025bf7ea 1654 u16 header_offset = 0;
d1b4f249 1655 struct rb_node *nd;
05e8b080 1656 struct hist_browser *hb = container_of(browser, struct hist_browser, b);
d1b4f249 1657
025bf7ea
ACM		 1658 if (hb->show_headers) {
1659 hist_browser__show_headers(hb);
1660 header_offset = 1;
1661 }
1662
05e8b080 1663 ui_browser__hists_init_top(browser);
979d2cac
WN		 1664 hb->he_selection = NULL;
1665 hb->selection = NULL;
d1b4f249 1666
d0506edb 1667 for (nd = browser->top; nd; nd = rb_hierarchy_next(nd)) {
d1b4f249 1668 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
14135663 1669 float percent;
d1b4f249 1670
d0506edb
NK		 1671 if (h->filtered) {
1672 /* let it move to sibling */
1673 h->unfolded = false;
d1b4f249 1674 continue;
d0506edb 1675 }
d1b4f249 1676
14135663 1677 percent = hist_entry__get_percent_limit(h);
064f1981
NK		 1678 if (percent < hb->min_pcnt)
1679 continue;
1680
d0506edb
NK		 1681 if (symbol_conf.report_hierarchy) {
1682 row += hist_browser__show_hierarchy_entry(hb, h, row,
2dbbe9f2 1683 h->depth);
79dded87
NK		 1684 if (row == browser->rows)
1685 break;
1686
1687 if (h->has_no_entry) {
a61a22f6 1688 hist_browser__show_no_entry(hb, row, h->depth + 1);
79dded87
NK		 1689 row++;
1690 }
d0506edb
NK		 1691 } else {
1692 row += hist_browser__show_entry(hb, h, row);
1693 }
1694
62c95ae3 1695 if (row == browser->rows)
d1b4f249
ACM		 1696 break;
1697 }
1698
025bf7ea 1699 return row + header_offset;
d1b4f249
ACM		 1700}
1701
064f1981 1702static struct rb_node *hists__filter_entries(struct rb_node *nd,
064f1981 1703 float min_pcnt)
d1b4f249
ACM		 1704{
1705 while (nd != NULL) {
1706 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
14135663 1707 float percent = hist_entry__get_percent_limit(h);
064f1981 1708
c0f1527b 1709 if (!h->filtered && percent >= min_pcnt)
d1b4f249
ACM		 1710 return nd;
1711
d0506edb
NK		 1712 /*
1713 * If it's filtered, its all children also were filtered.
1714 * So move to sibling node.
1715 */
1716 if (rb_next(nd))
1717 nd = rb_next(nd);
1718 else
1719 nd = rb_hierarchy_next(nd);
d1b4f249
ACM		 1720 }
1721
1722 return NULL;
1723}
1724
064f1981 1725static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
064f1981 1726 float min_pcnt)
d1b4f249
ACM		 1727{
1728 while (nd != NULL) {
1729 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
14135663 1730 float percent = hist_entry__get_percent_limit(h);
064f1981
NK		 1731
1732 if (!h->filtered && percent >= min_pcnt)
d1b4f249
ACM		 1733 return nd;
1734
d0506edb 1735 nd = rb_hierarchy_prev(nd);
d1b4f249
ACM		 1736 }
1737
1738 return NULL;
1739}
1740
05e8b080 1741static void ui_browser__hists_seek(struct ui_browser *browser,
d1b4f249
ACM		 1742 off_t offset, int whence)
1743{
1744 struct hist_entry *h;
1745 struct rb_node *nd;
1746 bool first = true;
064f1981
NK		 1747 struct hist_browser *hb;
1748
1749 hb = container_of(browser, struct hist_browser, b);
d1b4f249 1750
05e8b080 1751 if (browser->nr_entries == 0)
60098917
ACM		 1752 return;
1753
05e8b080 1754 ui_browser__hists_init_top(browser);
437cfe7a 1755
d1b4f249
ACM		 1756 switch (whence) {
1757 case SEEK_SET:
064f1981 1758 nd = hists__filter_entries(rb_first(browser->entries),
14135663 1759 hb->min_pcnt);
d1b4f249
ACM		 1760 break;
1761 case SEEK_CUR:
05e8b080 1762 nd = browser->top;
d1b4f249
ACM		 1763 goto do_offset;
1764 case SEEK_END:
d0506edb
NK		 1765 nd = rb_hierarchy_last(rb_last(browser->entries));
1766 nd = hists__filter_prev_entries(nd, hb->min_pcnt);
d1b4f249
ACM		 1767 first = false;
1768 break;
1769 default:
1770 return;
1771 }
1772
1773 /*
1774 * Moves not relative to the first visible entry invalidates its
1775 * row_offset:
1776 */
05e8b080 1777 h = rb_entry(browser->top, struct hist_entry, rb_node);
d1b4f249
ACM		 1778 h->row_offset = 0;
1779
1780 /*
1781 * Here we have to check if nd is expanded (+), if it is we can't go
1782 * the next top level hist_entry, instead we must compute an offset of
1783 * what _not_ to show and not change the first visible entry.
1784 *
1785 * This offset increments when we are going from top to bottom and
1786 * decreases when we're going from bottom to top.
1787 *
1788 * As we don't have backpointers to the top level in the callchains
1789 * structure, we need to always print the whole hist_entry callchain,
1790 * skipping the first ones that are before the first visible entry
1791 * and stop when we printed enough lines to fill the screen.
1792 */
1793do_offset:
837eeb75
WN		 1794 if (!nd)
1795 return;
1796
d1b4f249
ACM		 1797 if (offset > 0) {
1798 do {
1799 h = rb_entry(nd, struct hist_entry, rb_node);
d0506edb 1800 if (h->unfolded && h->leaf) {
d1b4f249
ACM		 1801 u16 remaining = h->nr_rows - h->row_offset;
1802 if (offset > remaining) {
1803 offset -= remaining;
1804 h->row_offset = 0;
1805 } else {
1806 h->row_offset += offset;
1807 offset = 0;
05e8b080 1808 browser->top = nd;
d1b4f249
ACM		 1809 break;
1810 }
1811 }
d0506edb
NK		 1812 nd = hists__filter_entries(rb_hierarchy_next(nd),
1813 hb->min_pcnt);
d1b4f249
ACM		 1814 if (nd == NULL)
1815 break;
1816 --offset;
05e8b080 1817 browser->top = nd;
d1b4f249
ACM		 1818 } while (offset != 0);
1819 } else if (offset < 0) {
1820 while (1) {
1821 h = rb_entry(nd, struct hist_entry, rb_node);
d0506edb 1822 if (h->unfolded && h->leaf) {
d1b4f249
ACM		 1823 if (first) {
1824 if (-offset > h->row_offset) {
1825 offset += h->row_offset;
1826 h->row_offset = 0;
1827 } else {
1828 h->row_offset += offset;
1829 offset = 0;
05e8b080 1830 browser->top = nd;
d1b4f249
ACM		 1831 break;
1832 }
1833 } else {
1834 if (-offset > h->nr_rows) {
1835 offset += h->nr_rows;
1836 h->row_offset = 0;
1837 } else {
1838 h->row_offset = h->nr_rows + offset;
1839 offset = 0;
05e8b080 1840 browser->top = nd;
d1b4f249
ACM		 1841 break;
1842 }
1843 }
1844 }
1845
d0506edb 1846 nd = hists__filter_prev_entries(rb_hierarchy_prev(nd),
064f1981 1847 hb->min_pcnt);
d1b4f249
ACM		 1848 if (nd == NULL)
1849 break;
1850 ++offset;
05e8b080 1851 browser->top = nd;
d1b4f249
ACM		 1852 if (offset == 0) {
1853 /*
1854 * Last unfiltered hist_entry, check if it is
1855 * unfolded, if it is then we should have
1856 * row_offset at its last entry.
1857 */
1858 h = rb_entry(nd, struct hist_entry, rb_node);
d0506edb 1859 if (h->unfolded && h->leaf)
d1b4f249
ACM		 1860 h->row_offset = h->nr_rows;
1861 break;
1862 }
1863 first = false;
1864 }
1865 } else {
05e8b080 1866 browser->top = nd;
d1b4f249
ACM		 1867 h = rb_entry(nd, struct hist_entry, rb_node);
1868 h->row_offset = 0;
1869 }
1870}
1871
aff3f3f6 1872static int hist_browser__fprintf_callchain(struct hist_browser *browser,
d0506edb
NK		 1873 struct hist_entry *he, FILE *fp,
1874 int level)
aff3f3f6 1875{
39ee533f
NK		 1876 struct callchain_print_arg arg = {
1877 .fp = fp,
1878 };
aff3f3f6 1879
d0506edb 1880 hist_browser__show_callchain(browser, he, level, 0,
39ee533f
NK		 1881 hist_browser__fprintf_callchain_entry, &arg,
1882 hist_browser__check_dump_full);
1883 return arg.printed;
aff3f3f6
ACM		 1884}
1885
1886static int hist_browser__fprintf_entry(struct hist_browser *browser,
1887 struct hist_entry *he, FILE *fp)
1888{
1889 char s[8192];
aff3f3f6
ACM		 1890 int printed = 0;
1891 char folded_sign = ' ';
26d8b338
NK		 1892 struct perf_hpp hpp = {
1893 .buf = s,
1894 .size = sizeof(s),
1895 };
1896 struct perf_hpp_fmt *fmt;
1897 bool first = true;
1898 int ret;
aff3f3f6
ACM		 1899
1900 if (symbol_conf.use_callchain)
1901 folded_sign = hist_entry__folded(he);
1902
aff3f3f6
ACM		 1903 if (symbol_conf.use_callchain)
1904 printed += fprintf(fp, "%c ", folded_sign);
1905
f0786af5 1906 hists__for_each_format(browser->hists, fmt) {
361459f1 1907 if (perf_hpp__should_skip(fmt, he->hists))
e67d49a7
NK		 1908 continue;
1909
26d8b338
NK		 1910 if (!first) {
1911 ret = scnprintf(hpp.buf, hpp.size, " ");
1912 advance_hpp(&hpp, ret);
1913 } else
1914 first = false;
aff3f3f6 1915
26d8b338 1916 ret = fmt->entry(fmt, &hpp, he);
89fee709 1917 ret = hist_entry__snprintf_alignment(he, &hpp, fmt, ret);
26d8b338
NK		 1918 advance_hpp(&hpp, ret);
1919 }
89fee709 1920 printed += fprintf(fp, "%s\n", s);
aff3f3f6
ACM		 1921
1922 if (folded_sign == '-')
d0506edb
NK		 1923 printed += hist_browser__fprintf_callchain(browser, he, fp, 1);
1924
1925 return printed;
1926}
1927
1928
1929static int hist_browser__fprintf_hierarchy_entry(struct hist_browser *browser,
1930 struct hist_entry *he,
1931 FILE *fp, int level,
1932 int nr_sort_keys)
1933{
1934 char s[8192];
1935 int printed = 0;
1936 char folded_sign = ' ';
1937 struct perf_hpp hpp = {
1938 .buf = s,
1939 .size = sizeof(s),
1940 };
1941 struct perf_hpp_fmt *fmt;
1942 bool first = true;
1943 int ret;
1b2dbbf4 1944 int hierarchy_indent = nr_sort_keys * HIERARCHY_INDENT;
d0506edb
NK		 1945
1946 printed = fprintf(fp, "%*s", level * HIERARCHY_INDENT, "");
1947
1948 folded_sign = hist_entry__folded(he);
1949 printed += fprintf(fp, "%c", folded_sign);
1950
1951 hists__for_each_format(he->hists, fmt) {
1952 if (perf_hpp__should_skip(fmt, he->hists))
1953 continue;
1954
1955 if (perf_hpp__is_sort_entry(fmt) ||
1956 perf_hpp__is_dynamic_entry(fmt))
1957 break;
1958
1959 if (!first) {
1960 ret = scnprintf(hpp.buf, hpp.size, " ");
1961 advance_hpp(&hpp, ret);
1962 } else
1963 first = false;
1964
1965 ret = fmt->entry(fmt, &hpp, he);
1966 advance_hpp(&hpp, ret);
1967 }
1968
1969 ret = scnprintf(hpp.buf, hpp.size, "%*s", hierarchy_indent, "");
1970 advance_hpp(&hpp, ret);
1971
1b2dbbf4
NK		 1972 perf_hpp_list__for_each_format(he->hpp_list, fmt) {
1973 ret = scnprintf(hpp.buf, hpp.size, " ");
1974 advance_hpp(&hpp, ret);
1975
1976 ret = fmt->entry(fmt, &hpp, he);
1977 advance_hpp(&hpp, ret);
1978 }
d0506edb
NK		 1979
1980 printed += fprintf(fp, "%s\n", rtrim(s));
1981
1982 if (he->leaf && folded_sign == '-') {
1983 printed += hist_browser__fprintf_callchain(browser, he, fp,
1984 he->depth + 1);
1985 }
aff3f3f6
ACM		 1986
1987 return printed;
1988}
1989
1990static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
1991{
064f1981 1992 struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
064f1981 1993 browser->min_pcnt);
aff3f3f6 1994 int printed = 0;
d3a72fd8 1995 int nr_sort = browser->hists->nr_sort_keys;
aff3f3f6
ACM		 1996
1997 while (nd) {
1998 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1999
d0506edb
NK		 2000 if (symbol_conf.report_hierarchy) {
2001 printed += hist_browser__fprintf_hierarchy_entry(browser,
2002 h, fp,
2003 h->depth,
2004 nr_sort);
2005 } else {
2006 printed += hist_browser__fprintf_entry(browser, h, fp);
2007 }
2008
2009 nd = hists__filter_entries(rb_hierarchy_next(nd),
2010 browser->min_pcnt);
aff3f3f6
ACM		 2011 }
2012
2013 return printed;
2014}
2015
2016static int hist_browser__dump(struct hist_browser *browser)
2017{
2018 char filename[64];
2019 FILE *fp;
2020
2021 while (1) {
2022 scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
2023 if (access(filename, F_OK))
2024 break;
2025 /*
2026 * XXX: Just an arbitrary lazy upper limit
2027 */
2028 if (++browser->print_seq == 8192) {
2029 ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
2030 return -1;
2031 }
2032 }
2033
2034 fp = fopen(filename, "w");
2035 if (fp == NULL) {
2036 char bf[64];
4cc49d4d
KS		 2037 const char *err = strerror_r(errno, bf, sizeof(bf));
2038 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
aff3f3f6
ACM		 2039 return -1;
2040 }
2041
2042 ++browser->print_seq;
2043 hist_browser__fprintf(browser, fp);
2044 fclose(fp);
2045 ui_helpline__fpush("%s written!", filename);
2046
2047 return 0;
2048}
2049
c2a51ab8 2050static struct hist_browser *hist_browser__new(struct hists *hists,
b1a9ceef 2051 struct hist_browser_timer *hbt,
ce80d3be 2052 struct perf_env *env)
d1b4f249 2053{
05e8b080 2054 struct hist_browser *browser = zalloc(sizeof(*browser));
d1b4f249 2055
05e8b080
ACM		 2056 if (browser) {
2057 browser->hists = hists;
2058 browser->b.refresh = hist_browser__refresh;
357cfff1 2059 browser->b.refresh_dimensions = hist_browser__refresh_dimensions;
05e8b080
ACM		 2060 browser->b.seek = ui_browser__hists_seek;
2061 browser->b.use_navkeypressed = true;
c8302367 2062 browser->show_headers = symbol_conf.show_hist_headers;
c2a51ab8 2063 browser->hbt = hbt;
b1a9ceef 2064 browser->env = env;
d1b4f249
ACM		 2065 }
2066
05e8b080 2067 return browser;
d1b4f249
ACM		 2068}
2069
05e8b080 2070static void hist_browser__delete(struct hist_browser *browser)
d1b4f249 2071{
05e8b080 2072 free(browser);
d1b4f249
ACM		 2073}
2074
05e8b080 2075static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
d1b4f249 2076{
05e8b080 2077 return browser->he_selection;
d1b4f249
ACM		 2078}
2079
05e8b080 2080static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
d1b4f249 2081{
05e8b080 2082 return browser->he_selection->thread;
d1b4f249
ACM		 2083}
2084
1e378ebd
TS		 2085/* Check whether the browser is for 'top' or 'report' */
2086static inline bool is_report_browser(void *timer)
2087{
2088 return timer == NULL;
2089}
2090
2091static int hists__browser_title(struct hists *hists,
2092 struct hist_browser_timer *hbt,
2093 char *bf, size_t size)
d1b4f249 2094{
469917ce
ACM		 2095 char unit;
2096 int printed;
05e8b080
ACM		 2097 const struct dso *dso = hists->dso_filter;
2098 const struct thread *thread = hists->thread_filter;
84734b06 2099 int socket_id = hists->socket_filter;
05e8b080
ACM		 2100 unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
2101 u64 nr_events = hists->stats.total_period;
717e263f 2102 struct perf_evsel *evsel = hists_to_evsel(hists);
dd00d486 2103 const char *ev_name = perf_evsel__name(evsel);
717e263f
NK		 2104 char buf[512];
2105 size_t buflen = sizeof(buf);
9e207ddf
KL		 2106 char ref[30] = " show reference callgraph, ";
2107 bool enable_ref = false;
717e263f 2108
f2148330
NK		 2109 if (symbol_conf.filter_relative) {
2110 nr_samples = hists->stats.nr_non_filtered_samples;
2111 nr_events = hists->stats.total_non_filtered_period;
2112 }
2113
759ff497 2114 if (perf_evsel__is_group_event(evsel)) {
717e263f
NK		 2115 struct perf_evsel *pos;
2116
2117 perf_evsel__group_desc(evsel, buf, buflen);
2118 ev_name = buf;
2119
2120 for_each_group_member(pos, evsel) {
4ea062ed
ACM		 2121 struct hists *pos_hists = evsel__hists(pos);
2122
f2148330 2123 if (symbol_conf.filter_relative) {
4ea062ed
ACM		 2124 nr_samples += pos_hists->stats.nr_non_filtered_samples;
2125 nr_events += pos_hists->stats.total_non_filtered_period;
f2148330 2126 } else {
4ea062ed
ACM		 2127 nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
2128 nr_events += pos_hists->stats.total_period;
f2148330 2129 }
717e263f
NK		 2130 }
2131 }
cc686280 2132
9e207ddf
KL		 2133 if (symbol_conf.show_ref_callgraph &&
2134 strstr(ev_name, "call-graph=no"))
2135 enable_ref = true;
cc686280
AR		 2136 nr_samples = convert_unit(nr_samples, &unit);
2137 printed = scnprintf(bf, size,
9e207ddf
KL		 2138 "Samples: %lu%c of event '%s',%sEvent count (approx.): %" PRIu64,
2139 nr_samples, unit, ev_name, enable_ref ? ref : " ", nr_events);
469917ce 2140
d1b4f249 2141
05e8b080 2142 if (hists->uid_filter_str)
0d37aa34 2143 printed += snprintf(bf + printed, size - printed,
05e8b080 2144 ", UID: %s", hists->uid_filter_str);
d1b4f249 2145 if (thread)
e7f01d1e 2146 printed += scnprintf(bf + printed, size - printed,
469917ce 2147 ", Thread: %s(%d)",
b9c5143a 2148 (thread->comm_set ? thread__comm_str(thread) : ""),
38051234 2149 thread->tid);
d1b4f249 2150 if (dso)
e7f01d1e 2151 printed += scnprintf(bf + printed, size - printed,
469917ce 2152 ", DSO: %s", dso->short_name);
84734b06 2153 if (socket_id > -1)
21394d94 2154 printed += scnprintf(bf + printed, size - printed,
84734b06 2155 ", Processor Socket: %d", socket_id);
1e378ebd
TS		 2156 if (!is_report_browser(hbt)) {
2157 struct perf_top *top = hbt->arg;
2158
2159 if (top->zero)
2160 printed += scnprintf(bf + printed, size - printed, " [z]");
2161 }
2162
469917ce 2163 return printed;
d1b4f249
ACM		 2164}
2165
24bff2dc
SE		 2166static inline void free_popup_options(char **options, int n)
2167{
2168 int i;
2169
04662523
ACM		 2170 for (i = 0; i < n; ++i)
2171 zfree(&options[i]);
24bff2dc
SE		 2172}
2173
341487ab
FT		 2174/*
2175 * Only runtime switching of perf data file will make "input_name" point
2176 * to a malloced buffer. So add "is_input_name_malloced" flag to decide
2177 * whether we need to call free() for current "input_name" during the switch.
2178 */
2179static bool is_input_name_malloced = false;
2180
2181static int switch_data_file(void)
2182{
2183 char *pwd, *options[32], *abs_path[32], *tmp;
2184 DIR *pwd_dir;
2185 int nr_options = 0, choice = -1, ret = -1;
2186 struct dirent *dent;
2187
2188 pwd = getenv("PWD");
2189 if (!pwd)
2190 return ret;
2191
2192 pwd_dir = opendir(pwd);
2193 if (!pwd_dir)
2194 return ret;
2195
2196 memset(options, 0, sizeof(options));
2197 memset(options, 0, sizeof(abs_path));
2198
2199 while ((dent = readdir(pwd_dir))) {
2200 char path[PATH_MAX];
2201 u64 magic;
2202 char *name = dent->d_name;
2203 FILE *file;
2204
2205 if (!(dent->d_type == DT_REG))
2206 continue;
2207
2208 snprintf(path, sizeof(path), "%s/%s", pwd, name);
2209
2210 file = fopen(path, "r");
2211 if (!file)
2212 continue;
2213
2214 if (fread(&magic, 1, 8, file) < 8)
2215 goto close_file_and_continue;
2216
2217 if (is_perf_magic(magic)) {
2218 options[nr_options] = strdup(name);
2219 if (!options[nr_options])
2220 goto close_file_and_continue;
2221
2222 abs_path[nr_options] = strdup(path);
2223 if (!abs_path[nr_options]) {
74cf249d 2224 zfree(&options[nr_options]);
341487ab
FT		 2225 ui__warning("Can't search all data files due to memory shortage.\n");
2226 fclose(file);
2227 break;
2228 }
2229
2230 nr_options++;
2231 }
2232
2233close_file_and_continue:
2234 fclose(file);
2235 if (nr_options >= 32) {
2236 ui__warning("Too many perf data files in PWD!\n"
2237 "Only the first 32 files will be listed.\n");
2238 break;
2239 }
2240 }
2241 closedir(pwd_dir);
2242
2243 if (nr_options) {
2244 choice = ui__popup_menu(nr_options, options);
2245 if (choice < nr_options && choice >= 0) {
2246 tmp = strdup(abs_path[choice]);
2247 if (tmp) {
2248 if (is_input_name_malloced)
2249 free((void *)input_name);
2250 input_name = tmp;
2251 is_input_name_malloced = true;
2252 ret = 0;
2253 } else
2254 ui__warning("Data switch failed due to memory shortage!\n");
2255 }
2256 }
2257
2258 free_popup_options(options, nr_options);
2259 free_popup_options(abs_path, nr_options);
2260 return ret;
2261}
2262
ea7cd592
NK		 2263struct popup_action {
2264 struct thread *thread;
ea7cd592 2265 struct map_symbol ms;
84734b06 2266 int socket;
ea7cd592
NK		 2267
2268 int (*fn)(struct hist_browser *browser, struct popup_action *act);
2269};
2270
bc7cad42 2271static int
ea7cd592 2272do_annotate(struct hist_browser *browser, struct popup_action *act)
bc7cad42
NK		 2273{
2274 struct perf_evsel *evsel;
2275 struct annotation *notes;
2276 struct hist_entry *he;
2277 int err;
2278
eebd0bfc 2279 if (!objdump_path && perf_env__lookup_objdump(browser->env))
bc7cad42
NK		 2280 return 0;
2281
ea7cd592 2282 notes = symbol__annotation(act->ms.sym);
bc7cad42
NK		 2283 if (!notes->src)
2284 return 0;
2285
2286 evsel = hists_to_evsel(browser->hists);
ea7cd592 2287 err = map_symbol__tui_annotate(&act->ms, evsel, browser->hbt);
bc7cad42
NK		 2288 he = hist_browser__selected_entry(browser);
2289 /*
2290 * offer option to annotate the other branch source or target
2291 * (if they exists) when returning from annotate
2292 */
2293 if ((err == 'q' || err == CTRL('c')) && he->branch_info)
2294 return 1;
2295
2296 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
2297 if (err)
2298 ui_browser__handle_resize(&browser->b);
2299 return 0;
2300}
2301
2302static int
ea7cd592
NK		 2303add_annotate_opt(struct hist_browser *browser __maybe_unused,
2304 struct popup_action *act, char **optstr,
2305 struct map *map, struct symbol *sym)
bc7cad42 2306{
ea7cd592
NK		 2307 if (sym == NULL || map->dso->annotate_warned)
2308 return 0;
2309
2310 if (asprintf(optstr, "Annotate %s", sym->name) < 0)
2311 return 0;
2312
2313 act->ms.map = map;
2314 act->ms.sym = sym;
2315 act->fn = do_annotate;
2316 return 1;
2317}
2318
2319static int
2320do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
2321{
2322 struct thread *thread = act->thread;
2323
bc7cad42
NK		 2324 if (browser->hists->thread_filter) {
2325 pstack__remove(browser->pstack, &browser->hists->thread_filter);
2326 perf_hpp__set_elide(HISTC_THREAD, false);
2327 thread__zput(browser->hists->thread_filter);
2328 ui_helpline__pop();
2329 } else {
7727a925 2330 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s(%d) thread\"",
bc7cad42
NK		 2331 thread->comm_set ? thread__comm_str(thread) : "",
2332 thread->tid);
2333 browser->hists->thread_filter = thread__get(thread);
2334 perf_hpp__set_elide(HISTC_THREAD, false);
2335 pstack__push(browser->pstack, &browser->hists->thread_filter);
2336 }
2337
2338 hists__filter_by_thread(browser->hists);
2339 hist_browser__reset(browser);
2340 return 0;
2341}
2342
2343static int
ea7cd592
NK		 2344add_thread_opt(struct hist_browser *browser, struct popup_action *act,
2345 char **optstr, struct thread *thread)
2346{
2eafd410 2347 if (!sort__has_thread || thread == NULL)
ea7cd592
NK		 2348 return 0;
2349
2350 if (asprintf(optstr, "Zoom %s %s(%d) thread",
2351 browser->hists->thread_filter ? "out of" : "into",
2352 thread->comm_set ? thread__comm_str(thread) : "",
2353 thread->tid) < 0)
2354 return 0;
2355
2356 act->thread = thread;
2357 act->fn = do_zoom_thread;
2358 return 1;
2359}
2360
2361static int
2362do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
bc7cad42 2363{
045b80dd 2364 struct map *map = act->ms.map;
ea7cd592 2365
bc7cad42
NK		 2366 if (browser->hists->dso_filter) {
2367 pstack__remove(browser->pstack, &browser->hists->dso_filter);
2368 perf_hpp__set_elide(HISTC_DSO, false);
2369 browser->hists->dso_filter = NULL;
2370 ui_helpline__pop();
2371 } else {
045b80dd 2372 if (map == NULL)
bc7cad42 2373 return 0;
7727a925 2374 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s DSO\"",
045b80dd
ACM		 2375 __map__is_kernel(map) ? "the Kernel" : map->dso->short_name);
2376 browser->hists->dso_filter = map->dso;
bc7cad42
NK		 2377 perf_hpp__set_elide(HISTC_DSO, true);
2378 pstack__push(browser->pstack, &browser->hists->dso_filter);
2379 }
2380
2381 hists__filter_by_dso(browser->hists);
2382 hist_browser__reset(browser);
2383 return 0;
2384}
2385
2386static int
ea7cd592 2387add_dso_opt(struct hist_browser *browser, struct popup_action *act,
045b80dd 2388 char **optstr, struct map *map)
bc7cad42 2389{
b1447a54 2390 if (!sort__has_dso || map == NULL)
ea7cd592
NK		 2391 return 0;
2392
2393 if (asprintf(optstr, "Zoom %s %s DSO",
2394 browser->hists->dso_filter ? "out of" : "into",
045b80dd 2395 __map__is_kernel(map) ? "the Kernel" : map->dso->short_name) < 0)
ea7cd592
NK		 2396 return 0;
2397
045b80dd 2398 act->ms.map = map;
ea7cd592
NK		 2399 act->fn = do_zoom_dso;
2400 return 1;
2401}
2402
2403static int
2404do_browse_map(struct hist_browser *browser __maybe_unused,
2405 struct popup_action *act)
2406{
2407 map__browse(act->ms.map);
bc7cad42
NK		 2408 return 0;
2409}
2410
ea7cd592
NK		 2411static int
2412add_map_opt(struct hist_browser *browser __maybe_unused,
2413 struct popup_action *act, char **optstr, struct map *map)
2414{
b1447a54 2415 if (!sort__has_dso || map == NULL)
ea7cd592
NK		 2416 return 0;
2417
2418 if (asprintf(optstr, "Browse map details") < 0)
2419 return 0;
2420
2421 act->ms.map = map;
2422 act->fn = do_browse_map;
2423 return 1;
2424}
2425
bc7cad42
NK		 2426static int
2427do_run_script(struct hist_browser *browser __maybe_unused,
ea7cd592 2428 struct popup_action *act)
bc7cad42
NK		 2429{
2430 char script_opt[64];
2431 memset(script_opt, 0, sizeof(script_opt));
2432
ea7cd592 2433 if (act->thread) {
bc7cad42 2434 scnprintf(script_opt, sizeof(script_opt), " -c %s ",
ea7cd592
NK		 2435 thread__comm_str(act->thread));
2436 } else if (act->ms.sym) {
bc7cad42 2437 scnprintf(script_opt, sizeof(script_opt), " -S %s ",
ea7cd592 2438 act->ms.sym->name);
bc7cad42
NK		 2439 }
2440
2441 script_browse(script_opt);
2442 return 0;
2443}
2444
2445static int
ea7cd592
NK		 2446add_script_opt(struct hist_browser *browser __maybe_unused,
2447 struct popup_action *act, char **optstr,
2448 struct thread *thread, struct symbol *sym)
2449{
2450 if (thread) {
2451 if (asprintf(optstr, "Run scripts for samples of thread [%s]",
2452 thread__comm_str(thread)) < 0)
2453 return 0;
2454 } else if (sym) {
2455 if (asprintf(optstr, "Run scripts for samples of symbol [%s]",
2456 sym->name) < 0)
2457 return 0;
2458 } else {
2459 if (asprintf(optstr, "Run scripts for all samples") < 0)
2460 return 0;
2461 }
2462
2463 act->thread = thread;
2464 act->ms.sym = sym;
2465 act->fn = do_run_script;
2466 return 1;
2467}
2468
2469static int
2470do_switch_data(struct hist_browser *browser __maybe_unused,
2471 struct popup_action *act __maybe_unused)
bc7cad42
NK		 2472{
2473 if (switch_data_file()) {
2474 ui__warning("Won't switch the data files due to\n"
2475 "no valid data file get selected!\n");
ea7cd592 2476 return 0;
bc7cad42
NK		 2477 }
2478
2479 return K_SWITCH_INPUT_DATA;
2480}
2481
ea7cd592
NK		 2482static int
2483add_switch_opt(struct hist_browser *browser,
2484 struct popup_action *act, char **optstr)
2485{
2486 if (!is_report_browser(browser->hbt))
2487 return 0;
2488
2489 if (asprintf(optstr, "Switch to another data file in PWD") < 0)
2490 return 0;
2491
2492 act->fn = do_switch_data;
2493 return 1;
2494}
2495
2496static int
2497do_exit_browser(struct hist_browser *browser __maybe_unused,
2498 struct popup_action *act __maybe_unused)
2499{
2500 return 0;
2501}
2502
2503static int
2504add_exit_opt(struct hist_browser *browser __maybe_unused,
2505 struct popup_action *act, char **optstr)
2506{
2507 if (asprintf(optstr, "Exit") < 0)
2508 return 0;
2509
2510 act->fn = do_exit_browser;
2511 return 1;
2512}
2513
84734b06
KL		 2514static int
2515do_zoom_socket(struct hist_browser *browser, struct popup_action *act)
2516{
2517 if (browser->hists->socket_filter > -1) {
2518 pstack__remove(browser->pstack, &browser->hists->socket_filter);
2519 browser->hists->socket_filter = -1;
2520 perf_hpp__set_elide(HISTC_SOCKET, false);
2521 } else {
2522 browser->hists->socket_filter = act->socket;
2523 perf_hpp__set_elide(HISTC_SOCKET, true);
2524 pstack__push(browser->pstack, &browser->hists->socket_filter);
2525 }
2526
2527 hists__filter_by_socket(browser->hists);
2528 hist_browser__reset(browser);
2529 return 0;
2530}
2531
2532static int
2533add_socket_opt(struct hist_browser *browser, struct popup_action *act,
2534 char **optstr, int socket_id)
2535{
d9695d9f 2536 if (!sort__has_socket || socket_id < 0)
84734b06
KL		 2537 return 0;
2538
2539 if (asprintf(optstr, "Zoom %s Processor Socket %d",
2540 (browser->hists->socket_filter > -1) ? "out of" : "into",
2541 socket_id) < 0)
2542 return 0;
2543
2544 act->socket = socket_id;
2545 act->fn = do_zoom_socket;
2546 return 1;
2547}
2548
112f761f 2549static void hist_browser__update_nr_entries(struct hist_browser *hb)
064f1981
NK		 2550{
2551 u64 nr_entries = 0;
2552 struct rb_node *nd = rb_first(&hb->hists->entries);
2553
f5b763fe 2554 if (hb->min_pcnt == 0 && !symbol_conf.report_hierarchy) {
268397cb
NK		 2555 hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;
2556 return;
2557 }
2558
14135663 2559 while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
064f1981 2560 nr_entries++;
f5b763fe 2561 nd = rb_hierarchy_next(nd);
064f1981
NK		 2562 }
2563
112f761f 2564 hb->nr_non_filtered_entries = nr_entries;
f5b763fe 2565 hb->nr_hierarchy_entries = nr_entries;
064f1981 2566}
341487ab 2567
b62e8dfc
NK		 2568static void hist_browser__update_percent_limit(struct hist_browser *hb,
2569 double percent)
2570{
2571 struct hist_entry *he;
2572 struct rb_node *nd = rb_first(&hb->hists->entries);
2573 u64 total = hists__total_period(hb->hists);
2574 u64 min_callchain_hits = total * (percent / 100);
2575
2576 hb->min_pcnt = callchain_param.min_percent = percent;
2577
b62e8dfc
NK		 2578 while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
2579 he = rb_entry(nd, struct hist_entry, rb_node);
2580
79dded87
NK		 2581 if (he->has_no_entry) {
2582 he->has_no_entry = false;
2583 he->nr_rows = 0;
2584 }
2585
d0506edb
NK		 2586 if (!he->leaf || !symbol_conf.use_callchain)
2587 goto next;
2588
b62e8dfc
NK		 2589 if (callchain_param.mode == CHAIN_GRAPH_REL) {
2590 total = he->stat.period;
2591
2592 if (symbol_conf.cumulate_callchain)
2593 total = he->stat_acc->period;
2594
2595 min_callchain_hits = total * (percent / 100);
2596 }
2597
2598 callchain_param.sort(&he->sorted_chain, he->callchain,
2599 min_callchain_hits, &callchain_param);
2600
d0506edb 2601next:
201fde73 2602 nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
d0506edb 2603
b62e8dfc
NK		 2604 /* force to re-evaluate folding state of callchains */
2605 he->init_have_children = false;
492b1010 2606 hist_entry__set_folding(he, hb, false);
b62e8dfc
NK		 2607 }
2608}
2609
34958544 2610static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
dd00d486 2611 const char *helpline,
81cce8de 2612 bool left_exits,
68d80758 2613 struct hist_browser_timer *hbt,
064f1981 2614 float min_pcnt,
ce80d3be 2615 struct perf_env *env)
d1b4f249 2616{
4ea062ed 2617 struct hists *hists = evsel__hists(evsel);
b1a9ceef 2618 struct hist_browser *browser = hist_browser__new(hists, hbt, env);
a68c2c58 2619 struct branch_info *bi;
f2b487db
NK		 2620#define MAX_OPTIONS 16
2621 char *options[MAX_OPTIONS];
ea7cd592 2622 struct popup_action actions[MAX_OPTIONS];
24bff2dc 2623 int nr_options = 0;
d1b4f249 2624 int key = -1;
938a23ae 2625 char buf[64];
9783adf7 2626 int delay_secs = hbt ? hbt->refresh : 0;
59dc9f25 2627 struct perf_hpp_fmt *fmt;
d1b4f249 2628
e8e684a5
NK		 2629#define HIST_BROWSER_HELP_COMMON \
2630 "h/?/F1 Show this window\n" \
2631 "UP/DOWN/PGUP\n" \
2632 "PGDN/SPACE Navigate\n" \
2633 "q/ESC/CTRL+C Exit browser\n\n" \
2634 "For multiple event sessions:\n\n" \
2635 "TAB/UNTAB Switch events\n\n" \
2636 "For symbolic views (--sort has sym):\n\n" \
7727a925
ACM		 2637 "ENTER Zoom into DSO/Threads & Annotate current symbol\n" \
2638 "ESC Zoom out\n" \
e8e684a5
NK		 2639 "a Annotate current symbol\n" \
2640 "C Collapse all callchains\n" \
2641 "d Zoom into current DSO\n" \
2642 "E Expand all callchains\n" \
105eb30f 2643 "F Toggle percentage of filtered entries\n" \
025bf7ea 2644 "H Display column headers\n" \
b62e8dfc 2645 "L Change percent limit\n" \
31eb4360 2646 "m Display context menu\n" \
84734b06 2647 "S Zoom into current Processor Socket\n" \
e8e684a5
NK		 2648
2649 /* help messages are sorted by lexical order of the hotkey */
2650 const char report_help[] = HIST_BROWSER_HELP_COMMON
6dd60135 2651 "i Show header information\n"
e8e684a5
NK		 2652 "P Print histograms to perf.hist.N\n"
2653 "r Run available scripts\n"
2654 "s Switch to another data file in PWD\n"
2655 "t Zoom into current Thread\n"
2656 "V Verbose (DSO names in callchains, etc)\n"
2657 "/ Filter symbol by name";
2658 const char top_help[] = HIST_BROWSER_HELP_COMMON
2659 "P Print histograms to perf.hist.N\n"
2660 "t Zoom into current Thread\n"
2661 "V Verbose (DSO names in callchains, etc)\n"
42337a22 2662 "z Toggle zeroing of samples\n"
fbb7997e 2663 "f Enable/Disable events\n"
e8e684a5
NK		 2664 "/ Filter symbol by name";
2665
d1b4f249
ACM		 2666 if (browser == NULL)
2667 return -1;
2668
ed426915
NK		 2669 /* reset abort key so that it can get Ctrl-C as a key */
2670 SLang_reset_tty();
2671 SLang_init_tty(0, 0, 0);
2672
03905048 2673 if (min_pcnt)
064f1981 2674 browser->min_pcnt = min_pcnt;
03905048 2675 hist_browser__update_nr_entries(browser);
064f1981 2676
84734b06 2677 browser->pstack = pstack__new(3);
01f00a1c 2678 if (browser->pstack == NULL)
d1b4f249
ACM		 2679 goto out;
2680
2681 ui_helpline__push(helpline);
2682
24bff2dc 2683 memset(options, 0, sizeof(options));
ea7cd592 2684 memset(actions, 0, sizeof(actions));
24bff2dc 2685
f0786af5 2686 hists__for_each_format(browser->hists, fmt) {
59dc9f25 2687 perf_hpp__reset_width(fmt, hists);
c6c3c02d
ACM		 2688 /*
2689 * This is done just once, and activates the horizontal scrolling
2690 * code in the ui_browser code, it would be better to have a the
2691 * counter in the perf_hpp code, but I couldn't find doing it here
2692 * works, FIXME by setting this in hist_browser__new, for now, be
2693 * clever 8-)
2694 */
2695 ++browser->b.columns;
2696 }
59dc9f25 2697
5b591669
NK		 2698 if (symbol_conf.col_width_list_str)
2699 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
2700
d1b4f249 2701 while (1) {
f3b623b8 2702 struct thread *thread = NULL;
045b80dd 2703 struct map *map = NULL;
ea7cd592 2704 int choice = 0;
84734b06 2705 int socked_id = -1;
d1b4f249 2706
24bff2dc
SE		 2707 nr_options = 0;
2708
5f00b0f4 2709 key = hist_browser__run(browser, helpline);
d1b4f249 2710
60098917
ACM		 2711 if (browser->he_selection != NULL) {
2712 thread = hist_browser__selected_thread(browser);
045b80dd 2713 map = browser->selection->map;
84734b06 2714 socked_id = browser->he_selection->socket;
60098917 2715 }
b50e003d 2716 switch (key) {
cf958003
ACM		 2717 case K_TAB:
2718 case K_UNTAB:
e4419b8e
DA		 2719 if (nr_events == 1)
2720 continue;
b50e003d
ACM		 2721 /*
2722 * Exit the browser, let hists__browser_tree
2723 * go to the next or previous
2724 */
2725 goto out_free_stack;
2726 case 'a':
9c796ec8 2727 if (!sort__has_sym) {
7b27509f 2728 ui_browser__warning(&browser->b, delay_secs * 2,
a6e51f9f 2729 "Annotation is only available for symbolic views, "
a68c2c58 2730 "include \"sym*\" in --sort to use it.");
a6e51f9f
ACM		 2731 continue;
2732 }
2733
60098917 2734 if (browser->selection == NULL ||
db9a9cbc 2735 browser->selection->sym == NULL ||
b50e003d 2736 browser->selection->map->dso->annotate_warned)
d1b4f249 2737 continue;
bc7cad42 2738
ea7cd592
NK		 2739 actions->ms.map = browser->selection->map;
2740 actions->ms.sym = browser->selection->sym;
2741 do_annotate(browser, actions);
bc7cad42 2742 continue;
aff3f3f6
ACM		 2743 case 'P':
2744 hist_browser__dump(browser);
2745 continue;
b50e003d 2746 case 'd':
fae00650 2747 actions->ms.map = map;
ea7cd592 2748 do_zoom_dso(browser, actions);
bc7cad42 2749 continue;
a7cb8863
ACM		 2750 case 'V':
2751 browser->show_dso = !browser->show_dso;
2752 continue;
b50e003d 2753 case 't':
ea7cd592
NK		 2754 actions->thread = thread;
2755 do_zoom_thread(browser, actions);
bc7cad42 2756 continue;
84734b06
KL		 2757 case 'S':
2758 actions->socket = socked_id;
2759 do_zoom_socket(browser, actions);
2760 continue;
5a5626b1 2761 case '/':
938a23ae 2762 if (ui_browser__input_window("Symbol to show",
4aa8e454
ACM		 2763 "Please enter the name of symbol you want to see.\n"
2764 "To remove the filter later, press / + ENTER.",
938a23ae
NK		 2765 buf, "ENTER: OK, ESC: Cancel",
2766 delay_secs * 2) == K_ENTER) {
05e8b080
ACM		 2767 hists->symbol_filter_str = *buf ? buf : NULL;
2768 hists__filter_by_symbol(hists);
938a23ae
NK		 2769 hist_browser__reset(browser);
2770 }
2771 continue;
cdbab7c2 2772 case 'r':
ea7cd592
NK		 2773 if (is_report_browser(hbt)) {
2774 actions->thread = NULL;
2775 actions->ms.sym = NULL;
2776 do_run_script(browser, actions);
2777 }
c77d8d70 2778 continue;
341487ab 2779 case 's':
bc7cad42 2780 if (is_report_browser(hbt)) {
ea7cd592 2781 key = do_switch_data(browser, actions);
bc7cad42
NK		 2782 if (key == K_SWITCH_INPUT_DATA)
2783 goto out_free_stack;
2784 }
341487ab 2785 continue;
6dd60135
NK		 2786 case 'i':
2787 /* env->arch is NULL for live-mode (i.e. perf top) */
2788 if (env->arch)
2789 tui__header_window(env);
2790 continue;
105eb30f
NK		 2791 case 'F':
2792 symbol_conf.filter_relative ^= 1;
2793 continue;
42337a22
NK		 2794 case 'z':
2795 if (!is_report_browser(hbt)) {
2796 struct perf_top *top = hbt->arg;
2797
2798 top->zero = !top->zero;
2799 }
2800 continue;
b62e8dfc
NK		 2801 case 'L':
2802 if (ui_browser__input_window("Percent Limit",
2803 "Please enter the value you want to hide entries under that percent.",
2804 buf, "ENTER: OK, ESC: Cancel",
2805 delay_secs * 2) == K_ENTER) {
2806 char *end;
2807 double new_percent = strtod(buf, &end);
2808
2809 if (new_percent < 0 || new_percent > 100) {
2810 ui_browser__warning(&browser->b, delay_secs * 2,
2811 "Invalid percent: %.2f", new_percent);
2812 continue;
2813 }
2814
2815 hist_browser__update_percent_limit(browser, new_percent);
2816 hist_browser__reset(browser);
2817 }
2818 continue;
cf958003 2819 case K_F1:
b50e003d
ACM		 2820 case 'h':
2821 case '?':
4610e413 2822 ui_browser__help_window(&browser->b,
e8e684a5 2823 is_report_browser(hbt) ? report_help : top_help);
b50e003d 2824 continue;
cf958003
ACM		 2825 case K_ENTER:
2826 case K_RIGHT:
31eb4360 2827 case 'm':
b50e003d
ACM		 2828 /* menu */
2829 break;
63ab1749 2830 case K_ESC:
cf958003 2831 case K_LEFT: {
b50e003d 2832 const void *top;
d1b4f249 2833
01f00a1c 2834 if (pstack__empty(browser->pstack)) {
7f0030b2
ACM		 2835 /*
2836 * Go back to the perf_evsel_menu__run or other user
2837 */
2838 if (left_exits)
2839 goto out_free_stack;
63ab1749
ACM		 2840
2841 if (key == K_ESC &&
2842 ui_browser__dialog_yesno(&browser->b,
2843 "Do you really want to exit?"))
2844 goto out_free_stack;
2845
d1b4f249 2846 continue;
7f0030b2 2847 }
6422184b 2848 top = pstack__peek(browser->pstack);
bc7cad42 2849 if (top == &browser->hists->dso_filter) {
6422184b
NK		 2850 /*
2851 * No need to set actions->dso here since
2852 * it's just to remove the current filter.
2853 * Ditto for thread below.
2854 */
2855 do_zoom_dso(browser, actions);
84734b06 2856 } else if (top == &browser->hists->thread_filter) {
6422184b 2857 do_zoom_thread(browser, actions);
84734b06
KL		 2858 } else if (top == &browser->hists->socket_filter) {
2859 do_zoom_socket(browser, actions);
2860 }
b50e003d
ACM		 2861 continue;
2862 }
ed7e5662
ACM		 2863 case 'q':
2864 case CTRL('c'):
516e5368 2865 goto out_free_stack;
fbb7997e 2866 case 'f':
13d1e536
NK		 2867 if (!is_report_browser(hbt)) {
2868 struct perf_top *top = hbt->arg;
2869
2870 perf_evlist__toggle_enable(top->evlist);
2871 /*
2872 * No need to refresh, resort/decay histogram
2873 * entries if we are not collecting samples:
2874 */
2875 if (top->evlist->enabled) {
2876 helpline = "Press 'f' to disable the events or 'h' to see other hotkeys";
2877 hbt->refresh = delay_secs;
2878 } else {
2879 helpline = "Press 'f' again to re-enable the events";
2880 hbt->refresh = 0;
2881 }
2882 continue;
2883 }
3e323dc0 2884 /* Fall thru */
ed7e5662 2885 default:
3e323dc0 2886 helpline = "Press '?' for help on key bindings";
ed7e5662 2887 continue;
d1b4f249
ACM		 2888 }
2889
4056132e 2890 if (!sort__has_sym || browser->selection == NULL)
0ba332f7
ACM		 2891 goto skip_annotation;
2892
55369fc1 2893 if (sort__mode == SORT_MODE__BRANCH) {
a68c2c58 2894 bi = browser->he_selection->branch_info;
0ba332f7
ACM		 2895
2896 if (bi == NULL)
2897 goto skip_annotation;
2898
ea7cd592
NK		 2899 nr_options += add_annotate_opt(browser,
2900 &actions[nr_options],
2901 &options[nr_options],
2902 bi->from.map,
2903 bi->from.sym);
2904 if (bi->to.sym != bi->from.sym)
2905 nr_options += add_annotate_opt(browser,
2906 &actions[nr_options],
2907 &options[nr_options],
2908 bi->to.map,
2909 bi->to.sym);
a68c2c58 2910 } else {
ea7cd592
NK		 2911 nr_options += add_annotate_opt(browser,
2912 &actions[nr_options],
2913 &options[nr_options],
2914 browser->selection->map,
2915 browser->selection->sym);
a68c2c58 2916 }
0ba332f7 2917skip_annotation:
ea7cd592
NK		 2918 nr_options += add_thread_opt(browser, &actions[nr_options],
2919 &options[nr_options], thread);
2920 nr_options += add_dso_opt(browser, &actions[nr_options],
045b80dd 2921 &options[nr_options], map);
ea7cd592
NK		 2922 nr_options += add_map_opt(browser, &actions[nr_options],
2923 &options[nr_options],
bd315aab
WN		 2924 browser->selection ?
2925 browser->selection->map : NULL);
84734b06
KL		 2926 nr_options += add_socket_opt(browser, &actions[nr_options],
2927 &options[nr_options],
2928 socked_id);
cdbab7c2 2929 /* perf script support */
b1baae89
NK		 2930 if (!is_report_browser(hbt))
2931 goto skip_scripting;
2932
cdbab7c2 2933 if (browser->he_selection) {
2eafd410
NK		 2934 if (sort__has_thread && thread) {
2935 nr_options += add_script_opt(browser,
2936 &actions[nr_options],
2937 &options[nr_options],
2938 thread, NULL);
2939 }
bd315aab
WN		 2940 /*
2941 * Note that browser->selection != NULL
2942 * when browser->he_selection is not NULL,
2943 * so we don't need to check browser->selection
2944 * before fetching browser->selection->sym like what
2945 * we do before fetching browser->selection->map.
2946 *
2947 * See hist_browser__show_entry.
2948 */
c221acb0
NK		 2949 if (sort__has_sym && browser->selection->sym) {
2950 nr_options += add_script_opt(browser,
2951 &actions[nr_options],
2952 &options[nr_options],
2953 NULL, browser->selection->sym);
2954 }
cdbab7c2 2955 }
ea7cd592
NK		 2956 nr_options += add_script_opt(browser, &actions[nr_options],
2957 &options[nr_options], NULL, NULL);
2958 nr_options += add_switch_opt(browser, &actions[nr_options],
2959 &options[nr_options]);
b1baae89 2960skip_scripting:
ea7cd592
NK		 2961 nr_options += add_exit_opt(browser, &actions[nr_options],
2962 &options[nr_options]);
d1b4f249 2963
ea7cd592
NK		 2964 do {
2965 struct popup_action *act;
68d80758 2966
ea7cd592
NK		 2967 choice = ui__popup_menu(nr_options, options);
2968 if (choice == -1 || choice >= nr_options)
2969 break;
a68c2c58 2970
ea7cd592
NK		 2971 act = &actions[choice];
2972 key = act->fn(browser, act);
2973 } while (key == 1);
a68c2c58 2974
ea7cd592
NK		 2975 if (key == K_SWITCH_INPUT_DATA)
2976 break;
d1b4f249
ACM		 2977 }
2978out_free_stack:
01f00a1c 2979 pstack__delete(browser->pstack);
d1b4f249
ACM		 2980out:
2981 hist_browser__delete(browser);
f2b487db 2982 free_popup_options(options, MAX_OPTIONS);
d1b4f249
ACM		 2983 return key;
2984}
2985
7f0030b2
ACM		 2986struct perf_evsel_menu {
2987 struct ui_browser b;
2988 struct perf_evsel *selection;
7b27509f 2989 bool lost_events, lost_events_warned;
064f1981 2990 float min_pcnt;
ce80d3be 2991 struct perf_env *env;
7f0030b2
ACM		 2992};
2993
2994static void perf_evsel_menu__write(struct ui_browser *browser,
2995 void *entry, int row)
2996{
2997 struct perf_evsel_menu *menu = container_of(browser,
2998 struct perf_evsel_menu, b);
2999 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
4ea062ed 3000 struct hists *hists = evsel__hists(evsel);
7f0030b2 3001 bool current_entry = ui_browser__is_current_entry(browser, row);
4ea062ed 3002 unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
7289f83c 3003 const char *ev_name = perf_evsel__name(evsel);
7f0030b2 3004 char bf[256], unit;
7b27509f
ACM		 3005 const char *warn = " ";
3006 size_t printed;
7f0030b2
ACM		 3007
3008 ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
3009 HE_COLORSET_NORMAL);
3010
759ff497 3011 if (perf_evsel__is_group_event(evsel)) {
717e263f
NK		 3012 struct perf_evsel *pos;
3013
3014 ev_name = perf_evsel__group_name(evsel);
3015
3016 for_each_group_member(pos, evsel) {
4ea062ed
ACM		 3017 struct hists *pos_hists = evsel__hists(pos);
3018 nr_events += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
717e263f
NK		 3019 }
3020 }
3021
7f0030b2 3022 nr_events = convert_unit(nr_events, &unit);
e7f01d1e 3023 printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
7b27509f 3024 unit, unit == ' ' ? "" : " ", ev_name);
517dfdb3 3025 ui_browser__printf(browser, "%s", bf);
7b27509f 3026
4ea062ed 3027 nr_events = hists->stats.nr_events[PERF_RECORD_LOST];
7b27509f
ACM		 3028 if (nr_events != 0) {
3029 menu->lost_events = true;
3030 if (!current_entry)
3031 ui_browser__set_color(browser, HE_COLORSET_TOP);
3032 nr_events = convert_unit(nr_events, &unit);
e7f01d1e
ACM		 3033 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
3034 nr_events, unit, unit == ' ' ? "" : " ");
7b27509f
ACM		 3035 warn = bf;
3036 }
3037
26270a00 3038 ui_browser__write_nstring(browser, warn, browser->width - printed);
7f0030b2
ACM		 3039
3040 if (current_entry)
3041 menu->selection = evsel;
3042}
3043
34958544
ACM		 3044static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
3045 int nr_events, const char *help,
9783adf7 3046 struct hist_browser_timer *hbt)
d1b4f249 3047{
7f0030b2 3048 struct perf_evlist *evlist = menu->b.priv;
e248de33 3049 struct perf_evsel *pos;
dd00d486 3050 const char *title = "Available samples";
9783adf7 3051 int delay_secs = hbt ? hbt->refresh : 0;
7f0030b2 3052 int key;
d1b4f249 3053
7f0030b2
ACM		 3054 if (ui_browser__show(&menu->b, title,
3055 "ESC: exit, ENTER|->: Browse histograms") < 0)
3056 return -1;
3057
7f0030b2 3058 while (1) {
3af6e338 3059 key = ui_browser__run(&menu->b, delay_secs);
7f0030b2
ACM		 3060
3061 switch (key) {
cf958003 3062 case K_TIMER:
9783adf7 3063 hbt->timer(hbt->arg);
7b27509f
ACM		 3064
3065 if (!menu->lost_events_warned && menu->lost_events) {
3066 ui_browser__warn_lost_events(&menu->b);
3067 menu->lost_events_warned = true;
3068 }
81cce8de 3069 continue;
cf958003
ACM		 3070 case K_RIGHT:
3071 case K_ENTER:
7f0030b2
ACM		 3072 if (!menu->selection)
3073 continue;
3074 pos = menu->selection;
3075browse_hists:
18eaf0b8
ACM		 3076 perf_evlist__set_selected(evlist, pos);
3077 /*
3078 * Give the calling tool a chance to populate the non
3079 * default evsel resorted hists tree.
3080 */
9783adf7
NK		 3081 if (hbt)
3082 hbt->timer(hbt->arg);
34958544 3083 key = perf_evsel__hists_browse(pos, nr_events, help,
dd00d486 3084 true, hbt,
064f1981 3085 menu->min_pcnt,
68d80758 3086 menu->env);
7f0030b2 3087 ui_browser__show_title(&menu->b, title);
18eaf0b8 3088 switch (key) {
cf958003 3089 case K_TAB:
18eaf0b8 3090 if (pos->node.next == &evlist->entries)
9a354cdc 3091 pos = perf_evlist__first(evlist);
18eaf0b8 3092 else
9a354cdc 3093 pos = perf_evsel__next(pos);
18eaf0b8 3094 goto browse_hists;
cf958003 3095 case K_UNTAB:
18eaf0b8 3096 if (pos->node.prev == &evlist->entries)
9a354cdc 3097 pos = perf_evlist__last(evlist);
18eaf0b8 3098 else
d87fcb4a 3099 pos = perf_evsel__prev(pos);
18eaf0b8 3100 goto browse_hists;
341487ab 3101 case K_SWITCH_INPUT_DATA:
18eaf0b8
ACM		 3102 case 'q':
3103 case CTRL('c'):
3104 goto out;
63ab1749 3105 case K_ESC:
18eaf0b8
ACM		 3106 default:
3107 continue;
3108 }
cf958003 3109 case K_LEFT:
7f0030b2 3110 continue;
cf958003 3111 case K_ESC:
4610e413
ACM		 3112 if (!ui_browser__dialog_yesno(&menu->b,
3113 "Do you really want to exit?"))
ed7e5662
ACM		 3114 continue;
3115 /* Fall thru */
7f0030b2
ACM		 3116 case 'q':
3117 case CTRL('c'):
3118 goto out;
d1b4f249 3119 default:
18eaf0b8 3120 continue;
d1b4f249
ACM		 3121 }
3122 }
3123
7f0030b2
ACM		 3124out:
3125 ui_browser__hide(&menu->b);
3126 return key;
3127}
3128
316c7136 3129static bool filter_group_entries(struct ui_browser *browser __maybe_unused,
fc24d7c2
NK		 3130 void *entry)
3131{
3132 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
3133
3134 if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
3135 return true;
3136
3137 return false;
3138}
3139
7f0030b2 3140static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
fc24d7c2 3141 int nr_entries, const char *help,
68d80758 3142 struct hist_browser_timer *hbt,
064f1981 3143 float min_pcnt,
ce80d3be 3144 struct perf_env *env)
7f0030b2
ACM		 3145{
3146 struct perf_evsel *pos;
3147 struct perf_evsel_menu menu = {
3148 .b = {
3149 .entries = &evlist->entries,
3150 .refresh = ui_browser__list_head_refresh,
3151 .seek = ui_browser__list_head_seek,
3152 .write = perf_evsel_menu__write,
fc24d7c2
NK		 3153 .filter = filter_group_entries,
3154 .nr_entries = nr_entries,
7f0030b2
ACM		 3155 .priv = evlist,
3156 },
064f1981 3157 .min_pcnt = min_pcnt,
68d80758 3158 .env = env,
7f0030b2
ACM		 3159 };
3160
3161 ui_helpline__push("Press ESC to exit");
3162
0050f7aa 3163 evlist__for_each(evlist, pos) {
7289f83c 3164 const char *ev_name = perf_evsel__name(pos);
7f0030b2
ACM		 3165 size_t line_len = strlen(ev_name) + 7;
3166
3167 if (menu.b.width < line_len)
3168 menu.b.width = line_len;
7f0030b2
ACM		 3169 }
3170
fc24d7c2 3171 return perf_evsel_menu__run(&menu, nr_entries, help, hbt);
7f0030b2
ACM		 3172}
3173
81cce8de 3174int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
68d80758 3175 struct hist_browser_timer *hbt,
064f1981 3176 float min_pcnt,
ce80d3be 3177 struct perf_env *env)
7f0030b2 3178{
fc24d7c2
NK		 3179 int nr_entries = evlist->nr_entries;
3180
3181single_entry:
3182 if (nr_entries == 1) {
9a354cdc 3183 struct perf_evsel *first = perf_evlist__first(evlist);
fc24d7c2
NK		 3184
3185 return perf_evsel__hists_browse(first, nr_entries, help,
dd00d486 3186 false, hbt, min_pcnt,
064f1981 3187 env);
7f0030b2
ACM		 3188 }
3189
fc24d7c2
NK		 3190 if (symbol_conf.event_group) {
3191 struct perf_evsel *pos;
3192
3193 nr_entries = 0;
0050f7aa 3194 evlist__for_each(evlist, pos) {
fc24d7c2
NK		 3195 if (perf_evsel__is_group_leader(pos))
3196 nr_entries++;
0050f7aa 3197 }
fc24d7c2
NK		 3198
3199 if (nr_entries == 1)
3200 goto single_entry;
3201 }
3202
3203 return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
064f1981 3204 hbt, min_pcnt, env);
d1b4f249 3205}
Linux kernel - Deliverables
This page took 0.353038 seconds and 5 git commands to generate.