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