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