hists.c

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