[linux-2.6-block.git] / tools / perf / util / newt.c

#define _GNU_SOURCE
#include <stdio.h>
#undef _GNU_SOURCE

#include <stdlib.h>
#include <newt.h>
#include <sys/ttydefaults.h>

#include "cache.h"
#include "hist.h"
#include "session.h"
#include "sort.h"
#include "symbol.h"

struct ui_progress {
	newtComponent form, scale;
};

struct ui_progress *ui_progress__new(const char *title, u64 total)
{
	struct ui_progress *self = malloc(sizeof(*self));

	if (self != NULL) {
		int cols;
		newtGetScreenSize(&cols, NULL);
		cols -= 4;
		newtCenteredWindow(cols, 1, title);
		self->form  = newtForm(NULL, NULL, 0);
		if (self->form == NULL)
			goto out_free_self;
		self->scale = newtScale(0, 0, cols, total);
		if (self->scale == NULL)
			goto out_free_form;
		newtFormAddComponent(self->form, self->scale);
		newtRefresh();
	}

	return self;

out_free_form:
	newtFormDestroy(self->form);
out_free_self:
	free(self);
	return NULL;
}

void ui_progress__update(struct ui_progress *self, u64 curr)
{
	newtScaleSet(self->scale, curr);
	newtRefresh();
}

void ui_progress__delete(struct ui_progress *self)
{
	newtFormDestroy(self->form);
	newtPopWindow();
	free(self);
}

static char browser__last_msg[1024];

int browser__show_help(const char *format, va_list ap)
{
	int ret;
	static int backlog;

        ret = vsnprintf(browser__last_msg + backlog,
			sizeof(browser__last_msg) - backlog, format, ap);
	backlog += ret;

	if (browser__last_msg[backlog - 1] == '\n') {
		newtPopHelpLine();
		newtPushHelpLine(browser__last_msg);
		newtRefresh();
		backlog = 0;
	}

	return ret;
}

static void newt_form__set_exit_keys(newtComponent self)
{
	newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
	newtFormAddHotKey(self, 'Q');
	newtFormAddHotKey(self, 'q');
	newtFormAddHotKey(self, CTRL('c'));
}

static newtComponent newt_form__new(void)
{
	newtComponent self = newtForm(NULL, NULL, 0);
	if (self)
		newt_form__set_exit_keys(self);
	return self;
}

static int popup_menu(int argc, char * const argv[])
{
	struct newtExitStruct es;
	int i, rc = -1, max_len = 5;
	newtComponent listbox, form = newt_form__new();

	if (form == NULL)
		return -1;

	listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
	if (listbox == NULL)
		goto out_destroy_form;

	newtFormAddComponent(form, listbox);

	for (i = 0; i < argc; ++i) {
		int len = strlen(argv[i]);
		if (len > max_len)
			max_len = len;
		if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
			goto out_destroy_form;
	}

	newtCenteredWindow(max_len, argc, NULL);
	newtFormRun(form, &es);
	rc = newtListboxGetCurrent(listbox) - NULL;
	if (es.reason == NEWT_EXIT_HOTKEY)
		rc = -1;
	newtPopWindow();
out_destroy_form:
	newtFormDestroy(form);
	return rc;
}

static bool dialog_yesno(const char *msg)
{
	/* newtWinChoice should really be accepting const char pointers... */
	char yes[] = "Yes", no[] = "No";
	return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
}

/*
 * When debugging newt problems it was useful to be able to "unroll"
 * the calls to newtCheckBoxTreeAdd{Array,Item}, so that we can generate
 * a source file with the sequence of calls to these methods, to then
 * tweak the arrays to get the intended results, so I'm keeping this code
 * here, may be useful again in the future.
 */
#undef NEWT_DEBUG

static void newt_checkbox_tree__add(newtComponent tree, const char *str,
				    void *priv, int *indexes)
{
#ifdef NEWT_DEBUG
	/* Print the newtCheckboxTreeAddArray to tinker with its index arrays */
	int i = 0, len = 40 - strlen(str);

	fprintf(stderr,
		"\tnewtCheckboxTreeAddItem(tree, %*.*s\"%s\", (void *)%p, 0, ",
		len, len, " ", str, priv);
	while (indexes[i] != NEWT_ARG_LAST) {
		if (indexes[i] != NEWT_ARG_APPEND)
			fprintf(stderr, " %d,", indexes[i]);
		else
			fprintf(stderr, " %s,", "NEWT_ARG_APPEND");
		++i;
	}
	fprintf(stderr, " %s", " NEWT_ARG_LAST);\n");
	fflush(stderr);
#endif
	newtCheckboxTreeAddArray(tree, str, priv, 0, indexes);
}

static char *callchain_list__sym_name(struct callchain_list *self,
				      char *bf, size_t bfsize)
{
	if (self->ms.sym)
		return self->ms.sym->name;

	snprintf(bf, bfsize, "%#Lx", self->ip);
	return bf;
}

static void __callchain__append_graph_browser(struct callchain_node *self,
					      newtComponent tree, u64 total,
					      int *indexes, int depth)
{
	struct rb_node *node;
	u64 new_total, remaining;
	int idx = 0;

	if (callchain_param.mode == CHAIN_GRAPH_REL)
		new_total = self->children_hit;
	else
		new_total = total;

	remaining = new_total;
	node = rb_first(&self->rb_root);
	while (node) {
		struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
		struct rb_node *next = rb_next(node);
		u64 cumul = cumul_hits(child);
		struct callchain_list *chain;
		int first = true, printed = 0;
		int chain_idx = -1;
		remaining -= cumul;

		indexes[depth] = NEWT_ARG_APPEND;
		indexes[depth + 1] = NEWT_ARG_LAST;

		list_for_each_entry(chain, &child->val, list) {
			char ipstr[BITS_PER_LONG / 4 + 1],
			     *alloc_str = NULL;
			const char *str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));

			if (first) {
				double percent = cumul * 100.0 / new_total;

				first = false;
				if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
					str = "Not enough memory!";
				else
					str = alloc_str;
			} else {
				indexes[depth] = idx;
				indexes[depth + 1] = NEWT_ARG_APPEND;
				indexes[depth + 2] = NEWT_ARG_LAST;
				++chain_idx;
			}
			newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
			free(alloc_str);
			++printed;
		}

		indexes[depth] = idx;
		if (chain_idx != -1)
			indexes[depth + 1] = chain_idx;
		if (printed != 0)
			++idx;
		__callchain__append_graph_browser(child, tree, new_total, indexes,
						  depth + (chain_idx != -1 ? 2 : 1));
		node = next;
	}
}

static void callchain__append_graph_browser(struct callchain_node *self,
					    newtComponent tree, u64 total,
					    int *indexes, int parent_idx)
{
	struct callchain_list *chain;
	int i = 0;

	indexes[1] = NEWT_ARG_APPEND;
	indexes[2] = NEWT_ARG_LAST;

	list_for_each_entry(chain, &self->val, list) {
		char ipstr[BITS_PER_LONG / 4 + 1], *str;

		if (chain->ip >= PERF_CONTEXT_MAX)
			continue;

		if (!i++ && sort__first_dimension == SORT_SYM)
			continue;

		str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
		newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
	}

	indexes[1] = parent_idx;
	indexes[2] = NEWT_ARG_APPEND;
	indexes[3] = NEWT_ARG_LAST;
	__callchain__append_graph_browser(self, tree, total, indexes, 2);
}

static void hist_entry__append_callchain_browser(struct hist_entry *self,
						 newtComponent tree, u64 total, int parent_idx)
{
	struct rb_node *rb_node;
	int indexes[1024] = { [0] = parent_idx, };
	int idx = 0;
	struct callchain_node *chain;

	rb_node = rb_first(&self->sorted_chain);
	while (rb_node) {
		chain = rb_entry(rb_node, struct callchain_node, rb_node);
		switch (callchain_param.mode) {
		case CHAIN_FLAT:
			break;
		case CHAIN_GRAPH_ABS: /* falldown */
		case CHAIN_GRAPH_REL:
			callchain__append_graph_browser(chain, tree, total, indexes, idx++);
			break;
		case CHAIN_NONE:
		default:
			break;
		}
		rb_node = rb_next(rb_node);
	}
}

static size_t hist_entry__append_browser(struct hist_entry *self,
					 newtComponent tree, u64 total)
{
	char s[256];
	size_t ret;

	if (symbol_conf.exclude_other && !self->parent)
		return 0;

	ret = hist_entry__snprintf(self, s, sizeof(s), NULL,
				   false, 0, false, total);
	if (symbol_conf.use_callchain) {
		int indexes[2];

		indexes[0] = NEWT_ARG_APPEND;
		indexes[1] = NEWT_ARG_LAST;
		newt_checkbox_tree__add(tree, s, &self->ms, indexes);
	} else
		newtListboxAppendEntry(tree, s, &self->ms);

	return ret;
}

static void map_symbol__annotate_browser(const struct map_symbol *self,
					 const char *input_name)
{
	FILE *fp;
	int cols, rows;
	newtComponent form, tree;
	struct newtExitStruct es;
	char *str;
	size_t line_len, max_line_len = 0;
	size_t max_usable_width;
	char *line = NULL;

	if (self->sym == NULL)
		return;

	if (asprintf(&str, "perf annotate -i \"%s\" -d \"%s\" %s 2>&1 | expand",
		     input_name, self->map->dso->name, self->sym->name) < 0)
		return;

	fp = popen(str, "r");
	if (fp == NULL)
		goto out_free_str;

	newtPushHelpLine("Press ESC to exit");
	newtGetScreenSize(&cols, &rows);
	tree = newtListbox(0, 0, rows - 5, NEWT_FLAG_SCROLL);

	while (!feof(fp)) {
		if (getline(&line, &line_len, fp) < 0 || !line_len)
			break;
		while (line_len != 0 && isspace(line[line_len - 1]))
			line[--line_len] = '\0';

		if (line_len > max_line_len)
			max_line_len = line_len;
		newtListboxAppendEntry(tree, line, NULL);
	}
	fclose(fp);
	free(line);

	max_usable_width = cols - 22;
	if (max_line_len > max_usable_width)
		max_line_len = max_usable_width;

	newtListboxSetWidth(tree, max_line_len);

	newtCenteredWindow(max_line_len + 2, rows - 5, self->sym->name);
	form = newt_form__new();
	newtFormAddComponent(form, tree);

	newtFormRun(form, &es);
	newtFormDestroy(form);
	newtPopWindow();
	newtPopHelpLine();
out_free_str:
	free(str);
}

static const void *newt__symbol_tree_get_current(newtComponent self)
{
	if (symbol_conf.use_callchain)
		return newtCheckboxTreeGetCurrent(self);
	return newtListboxGetCurrent(self);
}

static void hist_browser__selection(newtComponent self, void *data)
{
	const struct map_symbol **symbol_ptr = data;
	*symbol_ptr = newt__symbol_tree_get_current(self);
}

struct hist_browser {
	newtComponent		form, tree;
	const struct map_symbol *selection;
};

static struct hist_browser *hist_browser__new(void)
{
	struct hist_browser *self = malloc(sizeof(*self));

	if (self != NULL)
		self->form = NULL;

	return self;
}

static void hist_browser__delete(struct hist_browser *self)
{
	newtFormDestroy(self->form);
	newtPopWindow();
	free(self);
}

static int hist_browser__populate(struct hist_browser *self, struct hists *hists,
				  const char *title)
{
	int max_len = 0, idx, cols, rows;
	struct ui_progress *progress;
	struct rb_node *nd;
	u64 curr_hist = 0;
	char seq[] = ".";
	char str[256];

	if (self->form) {
		newtFormDestroy(self->form);
		newtPopWindow();
	}

	snprintf(str, sizeof(str), "Samples: %Ld                            ",
		 hists->stats.total);
	newtDrawRootText(0, 0, str);

	newtGetScreenSize(NULL, &rows);

	if (symbol_conf.use_callchain)
		self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
						   NEWT_FLAG_SCROLL);
	else
		self->tree = newtListbox(0, 0, rows - 5,
					(NEWT_FLAG_SCROLL |
					 NEWT_FLAG_RETURNEXIT));

	newtComponentAddCallback(self->tree, hist_browser__selection,
				 &self->selection);

	progress = ui_progress__new("Adding entries to the browser...",
				    hists->nr_entries);
	if (progress == NULL)
		return -1;

	idx = 0;
	for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
		int len;

		if (h->filtered)
			continue;

		len = hist_entry__append_browser(h, self->tree, hists->stats.total);
		if (len > max_len)
			max_len = len;
		if (symbol_conf.use_callchain)
			hist_entry__append_callchain_browser(h, self->tree,
							     hists->stats.total, idx++);
		++curr_hist;
		if (curr_hist % 5)
			ui_progress__update(progress, curr_hist);
	}

	ui_progress__delete(progress);

	newtGetScreenSize(&cols, &rows);

	if (max_len > cols)
		max_len = cols - 3;

	if (!symbol_conf.use_callchain)
		newtListboxSetWidth(self->tree, max_len);

	newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
			   rows - 5, title);
	self->form = newt_form__new();
	if (self->form == NULL)
		return -1;

	newtFormAddHotKey(self->form, 'A');
	newtFormAddHotKey(self->form, 'a');
	newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
	newtFormAddComponents(self->form, self->tree, NULL);
	self->selection = newt__symbol_tree_get_current(self->tree);

	return 0;
}

static struct thread *hist_browser__selected_thread(struct hist_browser *self)
{
	int *indexes;

	if (!symbol_conf.use_callchain)
		goto out;

	indexes = newtCheckboxTreeFindItem(self->tree, (void *)self->selection);
	if (indexes) {
		bool is_hist_entry = indexes[1] == NEWT_ARG_LAST;
		free(indexes);
		if (is_hist_entry)
			goto out;
	}
	return NULL;
out:
	return *(struct thread **)(self->selection + 1);
}

static int hist_browser__title(char *bf, size_t size, const char *input_name,
			       const struct dso *dso, const struct thread *thread)
{
	int printed = 0;

	if (thread)
		printed += snprintf(bf + printed, size - printed,
				    "Thread: %s(%d)",
				    (thread->comm_set ?  thread->comm : ""),
				    thread->pid);
	if (dso)
		printed += snprintf(bf + printed, size - printed,
				    "%sDSO: %s", thread ? " " : "",
				    dso->short_name);
	return printed ?: snprintf(bf, size, "Report: %s", input_name);
}

int hists__browse(struct hists *self, const char *helpline, const char *input_name)
{
	struct hist_browser *browser = hist_browser__new();
	const struct thread *thread_filter = NULL;
	const struct dso *dso_filter = NULL;
	struct newtExitStruct es;
	char msg[160];
	int err = -1;

	if (browser == NULL)
		return -1;

	newtPushHelpLine(helpline);

	hist_browser__title(msg, sizeof(msg), input_name,
			    dso_filter, thread_filter);
	if (hist_browser__populate(browser, self, msg) < 0)
		goto out;

	while (1) {
		const struct thread *thread;
		const struct dso *dso;
		char *options[16];
		int nr_options = 0, choice = 0, i,
		    annotate = -2, zoom_dso = -2, zoom_thread = -2;

		newtFormRun(browser->form, &es);
		if (es.reason == NEWT_EXIT_HOTKEY) {
			if (toupper(es.u.key) == 'A')
				goto do_annotate;
			if (es.u.key == NEWT_KEY_ESCAPE ||
			    toupper(es.u.key) == 'Q' ||
			    es.u.key == CTRL('c')) {
				if (dialog_yesno("Do you really want to exit?"))
					break;
				else
					continue;
			}
		}

		if (browser->selection->sym != NULL &&
		    asprintf(&options[nr_options], "Annotate %s",
			     browser->selection->sym->name) > 0)
			annotate = nr_options++;

		thread = hist_browser__selected_thread(browser);
		if (thread != NULL &&
		    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
			     (thread_filter ? "out of" : "into"),
			     (thread->comm_set ? thread->comm : ""),
			     thread->pid) > 0)
			zoom_thread = nr_options++;

		dso = browser->selection->map ? browser->selection->map->dso : NULL;
		if (dso != NULL &&
		    asprintf(&options[nr_options], "Zoom %s %s DSO",
			     (dso_filter ? "out of" : "into"),
			     (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
			zoom_dso = nr_options++;

		options[nr_options++] = (char *)"Exit";

		choice = popup_menu(nr_options, options);

		for (i = 0; i < nr_options - 1; ++i)
			free(options[i]);

		if (choice == nr_options - 1)
			break;

		if (choice == -1)
			continue;
do_annotate:
		if (choice == annotate) {
			if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
				newtPopHelpLine();
				newtPushHelpLine("No vmlinux file found, can't "
						 "annotate with just a "
						 "kallsyms file");
				continue;
			}
			map_symbol__annotate_browser(browser->selection, input_name);
		} else if (choice == zoom_dso) {
			if (dso_filter) {
				newtPopHelpLine();
				dso_filter = NULL;
			} else {
				snprintf(msg, sizeof(msg),
					 "To zoom out press -> + \"Zoom out of %s DSO\"",
					 dso->kernel ? "the Kernel" : dso->short_name);
				newtPushHelpLine(msg);
				dso_filter = dso;
			}
			hists__filter_by_dso(self, dso_filter);
			hist_browser__title(msg, sizeof(msg), input_name,
					    dso_filter, thread_filter);
			if (hist_browser__populate(browser, self, msg) < 0)
				goto out;
		} else if (choice == zoom_thread) {
			if (thread_filter) {
				newtPopHelpLine();
				thread_filter = NULL;
			} else {
				snprintf(msg, sizeof(msg),
					 "To zoom out press -> + \"Zoom out of %s(%d) thread\"",
					 (thread->comm_set ? thread->comm : ""),
					 thread->pid);
				newtPushHelpLine(msg);
				thread_filter = thread;
			}
			hists__filter_by_thread(self, thread_filter);
			hist_browser__title(msg, sizeof(msg), input_name,
					    dso_filter, thread_filter);
			if (hist_browser__populate(browser, self, msg) < 0)
				goto out;
		}
	}
	err = 0;
out:
	hist_browser__delete(browser);
	return err;
}

void setup_browser(void)
{
	if (!isatty(1))
		return;

	use_browser = true;
	newtInit();
	newtCls();
	newtPushHelpLine(" ");
}

void exit_browser(bool wait_for_ok)
{
	if (use_browser) {
		if (wait_for_ok) {
			char title[] = "Fatal Error", ok[] = "Ok";
			newtWinMessage(title, ok, browser__last_msg);
		}
		newtFinished();
	}
}
Commit	Line	Data
f9224c5c ACM	1	#define _GNU_SOURCE
	2	#include <stdio.h>
	3	#undef _GNU_SOURCE
	4
	5	#include <stdlib.h>
	6	#include <newt.h>
7081e087	7	#include <sys/ttydefaults.h>
f9224c5c ACM	8
	9	#include "cache.h"
	10	#include "hist.h"
	11	#include "session.h"
	12	#include "sort.h"
	13	#include "symbol.h"
	14
5f4d3f88 ACM	15	struct ui_progress {
	16	newtComponent form, scale;
	17	};
	18
	19	struct ui_progress ui_progress__new(const char title, u64 total)
	20	{
	21	struct ui_progress self = malloc(sizeof(self));
	22
	23	if (self != NULL) {
	24	int cols;
	25	newtGetScreenSize(&cols, NULL);
	26	cols -= 4;
	27	newtCenteredWindow(cols, 1, title);
	28	self->form = newtForm(NULL, NULL, 0);
	29	if (self->form == NULL)
	30	goto out_free_self;
	31	self->scale = newtScale(0, 0, cols, total);
	32	if (self->scale == NULL)
	33	goto out_free_form;
7f826453	34	newtFormAddComponent(self->form, self->scale);
5f4d3f88 ACM	35	newtRefresh();
	36	}
	37
	38	return self;
	39
	40	out_free_form:
	41	newtFormDestroy(self->form);
	42	out_free_self:
	43	free(self);
	44	return NULL;
	45	}
	46
	47	void ui_progress__update(struct ui_progress *self, u64 curr)
	48	{
	49	newtScaleSet(self->scale, curr);
	50	newtRefresh();
	51	}
	52
	53	void ui_progress__delete(struct ui_progress *self)
	54	{
	55	newtFormDestroy(self->form);
	56	newtPopWindow();
	57	free(self);
	58	}
	59
	60	static char browser__last_msg[1024];
	61
	62	int browser__show_help(const char *format, va_list ap)
	63	{
	64	int ret;
	65	static int backlog;
	66
	67	ret = vsnprintf(browser__last_msg + backlog,
	68	sizeof(browser__last_msg) - backlog, format, ap);
	69	backlog += ret;
	70
	71	if (browser__last_msg[backlog - 1] == '\n') {
	72	newtPopHelpLine();
	73	newtPushHelpLine(browser__last_msg);
	74	newtRefresh();
	75	backlog = 0;
	76	}
	77
	78	return ret;
	79	}
	80
7081e087 ACM	81	static void newt_form__set_exit_keys(newtComponent self)
	82	{
	83	newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
	84	newtFormAddHotKey(self, 'Q');
	85	newtFormAddHotKey(self, 'q');
	86	newtFormAddHotKey(self, CTRL('c'));
	87	}
	88
	89	static newtComponent newt_form__new(void)
	90	{
	91	newtComponent self = newtForm(NULL, NULL, 0);
	92	if (self)
	93	newt_form__set_exit_keys(self);
	94	return self;
	95	}
	96
83753190	97	static int popup_menu(int argc, char * const argv[])
53c54019 ACM	98	{
	99	struct newtExitStruct es;
	100	int i, rc = -1, max_len = 5;
	101	newtComponent listbox, form = newt_form__new();
	102
	103	if (form == NULL)
	104	return -1;
	105
	106	listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
	107	if (listbox == NULL)
	108	goto out_destroy_form;
	109
7f826453	110	newtFormAddComponent(form, listbox);
53c54019 ACM	111
	112	for (i = 0; i < argc; ++i) {
	113	int len = strlen(argv[i]);
	114	if (len > max_len)
	115	max_len = len;
	116	if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
	117	goto out_destroy_form;
	118	}
	119
	120	newtCenteredWindow(max_len, argc, NULL);
	121	newtFormRun(form, &es);
	122	rc = newtListboxGetCurrent(listbox) - NULL;
	123	if (es.reason == NEWT_EXIT_HOTKEY)
	124	rc = -1;
	125	newtPopWindow();
	126	out_destroy_form:
	127	newtFormDestroy(form);
	128	return rc;
	129	}
	130
	131	static bool dialog_yesno(const char *msg)
	132	{
	133	/* newtWinChoice should really be accepting const char pointers... */
	134	char yes[] = "Yes", no[] = "No";
c0ed55d2	135	return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
53c54019 ACM	136	}
53c54019 ACM	137
4ded2b25 ACM	138	/*
	139	* When debugging newt problems it was useful to be able to "unroll"
	140	* the calls to newtCheckBoxTreeAdd{Array,Item}, so that we can generate
	141	* a source file with the sequence of calls to these methods, to then
	142	* tweak the arrays to get the intended results, so I'm keeping this code
	143	* here, may be useful again in the future.
	144	*/
	145	#undef NEWT_DEBUG
	146
	147	static void newt_checkbox_tree__add(newtComponent tree, const char *str,
	148	void priv, int indexes)
	149	{
	150	#ifdef NEWT_DEBUG
	151	/* Print the newtCheckboxTreeAddArray to tinker with its index arrays */
	152	int i = 0, len = 40 - strlen(str);
	153
	154	fprintf(stderr,
	155	"\tnewtCheckboxTreeAddItem(tree, %.s\"%s\", (void *)%p, 0, ",
	156	len, len, " ", str, priv);
	157	while (indexes[i] != NEWT_ARG_LAST) {
	158	if (indexes[i] != NEWT_ARG_APPEND)
	159	fprintf(stderr, " %d,", indexes[i]);
	160	else
	161	fprintf(stderr, " %s,", "NEWT_ARG_APPEND");
	162	++i;
	163	}
	164	fprintf(stderr, " %s", " NEWT_ARG_LAST);\n");
	165	fflush(stderr);
	166	#endif
	167	newtCheckboxTreeAddArray(tree, str, priv, 0, indexes);
	168	}
	169
	170	static char callchain_list__sym_name(struct callchain_list self,
	171	char *bf, size_t bfsize)
	172	{
b3c9ac08 ACM	173	if (self->ms.sym)
b3c9ac08 ACM	174	return self->ms.sym->name;
4ded2b25 ACM	175
	176	snprintf(bf, bfsize, "%#Lx", self->ip);
	177	return bf;
	178	}
	179
	180	static void __callchain__append_graph_browser(struct callchain_node *self,
	181	newtComponent tree, u64 total,
	182	int *indexes, int depth)
	183	{
	184	struct rb_node *node;
	185	u64 new_total, remaining;
	186	int idx = 0;
	187
	188	if (callchain_param.mode == CHAIN_GRAPH_REL)
	189	new_total = self->children_hit;
	190	else
	191	new_total = total;
	192
	193	remaining = new_total;
	194	node = rb_first(&self->rb_root);
	195	while (node) {
	196	struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
	197	struct rb_node *next = rb_next(node);
	198	u64 cumul = cumul_hits(child);
	199	struct callchain_list *chain;
	200	int first = true, printed = 0;
	201	int chain_idx = -1;
	202	remaining -= cumul;
	203
	204	indexes[depth] = NEWT_ARG_APPEND;
	205	indexes[depth + 1] = NEWT_ARG_LAST;
	206
	207	list_for_each_entry(chain, &child->val, list) {
	208	char ipstr[BITS_PER_LONG / 4 + 1],
	209	*alloc_str = NULL;
	210	const char *str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
	211
	212	if (first) {
	213	double percent = cumul * 100.0 / new_total;
	214
	215	first = false;
	216	if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
	217	str = "Not enough memory!";
	218	else
	219	str = alloc_str;
	220	} else {
	221	indexes[depth] = idx;
	222	indexes[depth + 1] = NEWT_ARG_APPEND;
	223	indexes[depth + 2] = NEWT_ARG_LAST;
	224	++chain_idx;
	225	}
d5679ae4	226	newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
4ded2b25 ACM	227	free(alloc_str);
	228	++printed;
	229	}
	230
	231	indexes[depth] = idx;
	232	if (chain_idx != -1)
	233	indexes[depth + 1] = chain_idx;
	234	if (printed != 0)
	235	++idx;
	236	__callchain__append_graph_browser(child, tree, new_total, indexes,
	237	depth + (chain_idx != -1 ? 2 : 1));
	238	node = next;
	239	}
	240	}
	241
	242	static void callchain__append_graph_browser(struct callchain_node *self,
	243	newtComponent tree, u64 total,
	244	int *indexes, int parent_idx)
	245	{
	246	struct callchain_list *chain;
	247	int i = 0;
	248
	249	indexes[1] = NEWT_ARG_APPEND;
	250	indexes[2] = NEWT_ARG_LAST;
	251
	252	list_for_each_entry(chain, &self->val, list) {
	253	char ipstr[BITS_PER_LONG / 4 + 1], *str;
	254
	255	if (chain->ip >= PERF_CONTEXT_MAX)
	256	continue;
	257
	258	if (!i++ && sort__first_dimension == SORT_SYM)
	259	continue;
	260
	261	str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
d5679ae4	262	newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
4ded2b25 ACM	263	}
	264
	265	indexes[1] = parent_idx;
	266	indexes[2] = NEWT_ARG_APPEND;
	267	indexes[3] = NEWT_ARG_LAST;
	268	__callchain__append_graph_browser(self, tree, total, indexes, 2);
	269	}
	270
	271	static void hist_entry__append_callchain_browser(struct hist_entry *self,
	272	newtComponent tree, u64 total, int parent_idx)
	273	{
	274	struct rb_node *rb_node;
	275	int indexes[1024] = { [0] = parent_idx, };
	276	int idx = 0;
	277	struct callchain_node *chain;
	278
	279	rb_node = rb_first(&self->sorted_chain);
	280	while (rb_node) {
	281	chain = rb_entry(rb_node, struct callchain_node, rb_node);
	282	switch (callchain_param.mode) {
	283	case CHAIN_FLAT:
	284	break;
	285	case CHAIN_GRAPH_ABS: /* falldown */
	286	case CHAIN_GRAPH_REL:
	287	callchain__append_graph_browser(chain, tree, total, indexes, idx++);
	288	break;
	289	case CHAIN_NONE:
	290	default:
	291	break;
	292	}
	293	rb_node = rb_next(rb_node);
	294	}
	295	}
	296
f9224c5c	297	static size_t hist_entry__append_browser(struct hist_entry *self,
4ded2b25	298	newtComponent tree, u64 total)
f9224c5c	299	{
a4e3b956 ACM	300	char s[256];
a4e3b956 ACM	301	size_t ret;
f9224c5c ACM	302
	303	if (symbol_conf.exclude_other && !self->parent)
	304	return 0;
	305
a4e3b956 ACM	306	ret = hist_entry__snprintf(self, s, sizeof(s), NULL,
a4e3b956 ACM	307	false, 0, false, total);
4ded2b25 ACM	308	if (symbol_conf.use_callchain) {
	309	int indexes[2];
	310
	311	indexes[0] = NEWT_ARG_APPEND;
	312	indexes[1] = NEWT_ARG_LAST;
d5679ae4	313	newt_checkbox_tree__add(tree, s, &self->ms, indexes);
4ded2b25	314	} else
d5679ae4	315	newtListboxAppendEntry(tree, s, &self->ms);
4ded2b25	316
a4e3b956	317	return ret;
f9224c5c ACM	318	}
f9224c5c ACM	319
533c46c3 ACM	320	static void map_symbol__annotate_browser(const struct map_symbol *self,
533c46c3 ACM	321	const char *input_name)
f9224c5c ACM	322	{
f9224c5c ACM	323	FILE *fp;
cb7afb70	324	int cols, rows;
4ded2b25	325	newtComponent form, tree;
f9224c5c ACM	326	struct newtExitStruct es;
	327	char *str;
	328	size_t line_len, max_line_len = 0;
	329	size_t max_usable_width;
	330	char *line = NULL;
	331
d5679ae4	332	if (self->sym == NULL)
f9224c5c ACM	333	return;
f9224c5c ACM	334
533c46c3 ACM	335	if (asprintf(&str, "perf annotate -i \"%s\" -d \"%s\" %s 2>&1 \| expand",
533c46c3 ACM	336	input_name, self->map->dso->name, self->sym->name) < 0)
f9224c5c ACM	337	return;
	338
	339	fp = popen(str, "r");
	340	if (fp == NULL)
	341	goto out_free_str;
	342
	343	newtPushHelpLine("Press ESC to exit");
cb7afb70	344	newtGetScreenSize(&cols, &rows);
4ded2b25	345	tree = newtListbox(0, 0, rows - 5, NEWT_FLAG_SCROLL);
f9224c5c ACM	346
	347	while (!feof(fp)) {
	348	if (getline(&line, &line_len, fp) < 0 \|\| !line_len)
	349	break;
	350	while (line_len != 0 && isspace(line[line_len - 1]))
	351	line[--line_len] = '\0';
	352
	353	if (line_len > max_line_len)
	354	max_line_len = line_len;
4ded2b25	355	newtListboxAppendEntry(tree, line, NULL);
f9224c5c ACM	356	}
	357	fclose(fp);
	358	free(line);
	359
cb7afb70	360	max_usable_width = cols - 22;
f9224c5c ACM	361	if (max_line_len > max_usable_width)
	362	max_line_len = max_usable_width;
	363
4ded2b25	364	newtListboxSetWidth(tree, max_line_len);
f9224c5c	365
d5679ae4	366	newtCenteredWindow(max_line_len + 2, rows - 5, self->sym->name);
7081e087	367	form = newt_form__new();
7f826453	368	newtFormAddComponent(form, tree);
f9224c5c ACM	369
	370	newtFormRun(form, &es);
	371	newtFormDestroy(form);
	372	newtPopWindow();
	373	newtPopHelpLine();
	374	out_free_str:
	375	free(str);
	376	}
	377
53c54019 ACM	378	static const void *newt__symbol_tree_get_current(newtComponent self)
	379	{
	380	if (symbol_conf.use_callchain)
	381	return newtCheckboxTreeGetCurrent(self);
	382	return newtListboxGetCurrent(self);
	383	}
	384
e65713ea	385	static void hist_browser__selection(newtComponent self, void *data)
53c54019	386	{
d5679ae4	387	const struct map_symbol **symbol_ptr = data;
53c54019 ACM	388	*symbol_ptr = newt__symbol_tree_get_current(self);
	389	}
	390
e65713ea ACM	391	struct hist_browser {
	392	newtComponent form, tree;
	393	const struct map_symbol *selection;
	394	};
	395
	396	static struct hist_browser *hist_browser__new(void)
	397	{
	398	struct hist_browser self = malloc(sizeof(self));
	399
83753190 ACM	400	if (self != NULL)
83753190 ACM	401	self->form = NULL;
e65713ea ACM	402
	403	return self;
	404	}
	405
	406	static void hist_browser__delete(struct hist_browser *self)
	407	{
	408	newtFormDestroy(self->form);
	409	newtPopWindow();
	410	free(self);
	411	}
	412
b09e0190 ACM	413	static int hist_browser__populate(struct hist_browser self, struct hists hists,
b09e0190 ACM	414	const char *title)
f9224c5c	415	{
e65713ea ACM	416	int max_len = 0, idx, cols, rows;
e65713ea ACM	417	struct ui_progress *progress;
f9224c5c	418	struct rb_node *nd;
5f4d3f88	419	u64 curr_hist = 0;
83753190 ACM	420	char seq[] = ".";
	421	char str[256];
	422
	423	if (self->form) {
	424	newtFormDestroy(self->form);
	425	newtPopWindow();
	426	}
	427
	428	snprintf(str, sizeof(str), "Samples: %Ld ",
b09e0190	429	hists->stats.total);
83753190 ACM	430	newtDrawRootText(0, 0, str);
	431
	432	newtGetScreenSize(NULL, &rows);
	433
	434	if (symbol_conf.use_callchain)
	435	self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
	436	NEWT_FLAG_SCROLL);
	437	else
	438	self->tree = newtListbox(0, 0, rows - 5,
	439	(NEWT_FLAG_SCROLL \|
	440	NEWT_FLAG_RETURNEXIT));
	441
	442	newtComponentAddCallback(self->tree, hist_browser__selection,
	443	&self->selection);
5f4d3f88	444
b09e0190 ACM	445	progress = ui_progress__new("Adding entries to the browser...",
b09e0190 ACM	446	hists->nr_entries);
5f4d3f88 ACM	447	if (progress == NULL)
5f4d3f88 ACM	448	return -1;
f9224c5c	449
4ded2b25	450	idx = 0;
b09e0190	451	for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
f9224c5c	452	struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
83753190 ACM	453	int len;
	454
	455	if (h->filtered)
	456	continue;
	457
b09e0190	458	len = hist_entry__append_browser(h, self->tree, hists->stats.total);
f9224c5c ACM	459	if (len > max_len)
f9224c5c ACM	460	max_len = len;
d5679ae4	461	if (symbol_conf.use_callchain)
e65713ea	462	hist_entry__append_callchain_browser(h, self->tree,
b09e0190	463	hists->stats.total, idx++);
5f4d3f88 ACM	464	++curr_hist;
	465	if (curr_hist % 5)
	466	ui_progress__update(progress, curr_hist);
f9224c5c ACM	467	}
f9224c5c ACM	468
5f4d3f88 ACM	469	ui_progress__delete(progress);
5f4d3f88 ACM	470
e65713ea ACM	471	newtGetScreenSize(&cols, &rows);
e65713ea ACM	472
4ded2b25 ACM	473	if (max_len > cols)
	474	max_len = cols - 3;
	475
	476	if (!symbol_conf.use_callchain)
e65713ea	477	newtListboxSetWidth(self->tree, max_len);
4ded2b25 ACM	478
4ded2b25 ACM	479	newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
6e7ab4c6	480	rows - 5, title);
e65713ea	481	self->form = newt_form__new();
83753190 ACM	482	if (self->form == NULL)
	483	return -1;
	484
e65713ea ACM	485	newtFormAddHotKey(self->form, 'A');
	486	newtFormAddHotKey(self->form, 'a');
	487	newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
	488	newtFormAddComponents(self->form, self->tree, NULL);
	489	self->selection = newt__symbol_tree_get_current(self->tree);
	490
	491	return 0;
	492	}
	493
a5e29aca ACM	494	static struct thread hist_browser__selected_thread(struct hist_browser self)
	495	{
	496	int *indexes;
	497
	498	if (!symbol_conf.use_callchain)
	499	goto out;
	500
	501	indexes = newtCheckboxTreeFindItem(self->tree, (void *)self->selection);
	502	if (indexes) {
	503	bool is_hist_entry = indexes[1] == NEWT_ARG_LAST;
	504	free(indexes);
	505	if (is_hist_entry)
	506	goto out;
	507	}
	508	return NULL;
	509	out:
	510	return (struct thread *)(self->selection + 1);
	511	}
	512
6e7ab4c6 ACM	513	static int hist_browser__title(char bf, size_t size, const char input_name,
	514	const struct dso dso, const struct thread thread)
	515	{
	516	int printed = 0;
	517
	518	if (thread)
	519	printed += snprintf(bf + printed, size - printed,
	520	"Thread: %s(%d)",
	521	(thread->comm_set ? thread->comm : ""),
	522	thread->pid);
	523	if (dso)
	524	printed += snprintf(bf + printed, size - printed,
	525	"%sDSO: %s", thread ? " " : "",
	526	dso->short_name);
	527	return printed ?: snprintf(bf, size, "Report: %s", input_name);
	528	}
	529
b09e0190	530	int hists__browse(struct hists self, const char helpline, const char *input_name)
e65713ea	531	{
6e7ab4c6 ACM	532	struct hist_browser *browser = hist_browser__new();
	533	const struct thread *thread_filter = NULL;
	534	const struct dso *dso_filter = NULL;
e65713ea	535	struct newtExitStruct es;
6e7ab4c6	536	char msg[160];
e65713ea	537	int err = -1;
e65713ea ACM	538
	539	if (browser == NULL)
	540	return -1;
	541
e65713ea ACM	542	newtPushHelpLine(helpline);
e65713ea ACM	543
6e7ab4c6 ACM	544	hist_browser__title(msg, sizeof(msg), input_name,
6e7ab4c6 ACM	545	dso_filter, thread_filter);
b09e0190	546	if (hist_browser__populate(browser, self, msg) < 0)
e65713ea	547	goto out;
f9224c5c ACM	548
f9224c5c ACM	549	while (1) {
a5e29aca	550	const struct thread *thread;
6e7ab4c6	551	const struct dso *dso;
83753190 ACM	552	char *options[16];
83753190 ACM	553	int nr_options = 0, choice = 0, i,
a5e29aca	554	annotate = -2, zoom_dso = -2, zoom_thread = -2;
f9224c5c	555
e65713ea	556	newtFormRun(browser->form, &es);
53c54019	557	if (es.reason == NEWT_EXIT_HOTKEY) {
d5679ae4 ACM	558	if (toupper(es.u.key) == 'A')
d5679ae4 ACM	559	goto do_annotate;
53c54019 ACM	560	if (es.u.key == NEWT_KEY_ESCAPE \|\|
	561	toupper(es.u.key) == 'Q' \|\|
	562	es.u.key == CTRL('c')) {
	563	if (dialog_yesno("Do you really want to exit?"))
	564	break;
	565	else
	566	continue;
	567	}
	568	}
	569
83753190 ACM	570	if (browser->selection->sym != NULL &&
	571	asprintf(&options[nr_options], "Annotate %s",
	572	browser->selection->sym->name) > 0)
	573	annotate = nr_options++;
	574
a5e29aca ACM	575	thread = hist_browser__selected_thread(browser);
	576	if (thread != NULL &&
	577	asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
6e7ab4c6 ACM	578	(thread_filter ? "out of" : "into"),
	579	(thread->comm_set ? thread->comm : ""),
	580	thread->pid) > 0)
a5e29aca ACM	581	zoom_thread = nr_options++;
a5e29aca ACM	582
6e7ab4c6 ACM	583	dso = browser->selection->map ? browser->selection->map->dso : NULL;
	584	if (dso != NULL &&
	585	asprintf(&options[nr_options], "Zoom %s %s DSO",
	586	(dso_filter ? "out of" : "into"),
	587	(dso->kernel ? "the Kernel" : dso->short_name)) > 0)
	588	zoom_dso = nr_options++;
	589
83753190	590	options[nr_options++] = (char *)"Exit";
53c54019	591
53c54019	592	choice = popup_menu(nr_options, options);
83753190 ACM	593
	594	for (i = 0; i < nr_options - 1; ++i)
	595	free(options[i]);
	596
53c54019	597	if (choice == nr_options - 1)
f9224c5c	598	break;
a5e29aca ACM	599
	600	if (choice == -1)
	601	continue;
d5679ae4	602	do_annotate:
83753190	603	if (choice == annotate) {
e65713ea	604	if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
d5679ae4 ACM	605	newtPopHelpLine();
	606	newtPushHelpLine("No vmlinux file found, can't "
	607	"annotate with just a "
	608	"kallsyms file");
	609	continue;
	610	}
6e7ab4c6	611	map_symbol__annotate_browser(browser->selection, input_name);
a5e29aca	612	} else if (choice == zoom_dso) {
6e7ab4c6 ACM	613	if (dso_filter) {
	614	newtPopHelpLine();
	615	dso_filter = NULL;
	616	} else {
	617	snprintf(msg, sizeof(msg),
	618	"To zoom out press -> + \"Zoom out of %s DSO\"",
	619	dso->kernel ? "the Kernel" : dso->short_name);
	620	newtPushHelpLine(msg);
	621	dso_filter = dso;
	622	}
b09e0190	623	hists__filter_by_dso(self, dso_filter);
6e7ab4c6 ACM	624	hist_browser__title(msg, sizeof(msg), input_name,
6e7ab4c6 ACM	625	dso_filter, thread_filter);
b09e0190	626	if (hist_browser__populate(browser, self, msg) < 0)
83753190	627	goto out;
a5e29aca	628	} else if (choice == zoom_thread) {
6e7ab4c6 ACM	629	if (thread_filter) {
	630	newtPopHelpLine();
	631	thread_filter = NULL;
	632	} else {
	633	snprintf(msg, sizeof(msg),
	634	"To zoom out press -> + \"Zoom out of %s(%d) thread\"",
	635	(thread->comm_set ? thread->comm : ""),
	636	thread->pid);
	637	newtPushHelpLine(msg);
	638	thread_filter = thread;
	639	}
b09e0190	640	hists__filter_by_thread(self, thread_filter);
6e7ab4c6 ACM	641	hist_browser__title(msg, sizeof(msg), input_name,
6e7ab4c6 ACM	642	dso_filter, thread_filter);
b09e0190	643	if (hist_browser__populate(browser, self, msg) < 0)
a5e29aca	644	goto out;
d5679ae4	645	}
f9224c5c	646	}
e65713ea ACM	647	err = 0;
	648	out:
	649	hist_browser__delete(browser);
	650	return err;
f9224c5c ACM	651	}
f9224c5c ACM	652
f9224c5c ACM	653	void setup_browser(void)
	654	{
	655	if (!isatty(1))
	656	return;
	657
	658	use_browser = true;
	659	newtInit();
	660	newtCls();
	661	newtPushHelpLine(" ");
	662	}
	663
f3a1f0ea	664	void exit_browser(bool wait_for_ok)
f9224c5c	665	{
f3a1f0ea ACM	666	if (use_browser) {
	667	if (wait_for_ok) {
	668	char title[] = "Fatal Error", ok[] = "Ok";
	669	newtWinMessage(title, ok, browser__last_msg);
	670	}
f9224c5c	671	newtFinished();
f3a1f0ea	672	}
f9224c5c	673	}