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