Release 4.10 tools/perf/builtin-report.c

/*
 * builtin-report.c
 *
 * Builtin report command: Analyze the perf.data input file,
 * look up and read DSOs and symbol information and display
 * a histogram of results, along various sorting keys.
 */
#include "builtin.h"

#include "util/util.h"
#include "util/config.h"

#include "util/annotate.h"
#include "util/color.h"
#include <linux/list.h>
#include <linux/rbtree.h>
#include "util/symbol.h"
#include "util/callchain.h"
#include "util/strlist.h"
#include "util/values.h"

#include "perf.h"
#include "util/debug.h"
#include "util/evlist.h"
#include "util/evsel.h"
#include "util/header.h"
#include "util/session.h"
#include "util/tool.h"

#include <subcmd/parse-options.h>
#include <subcmd/exec-cmd.h>
#include "util/parse-events.h"

#include "util/thread.h"
#include "util/sort.h"
#include "util/hist.h"
#include "util/data.h"
#include "arch/common.h"
#include "util/time-utils.h"
#include "util/auxtrace.h"

#include <dlfcn.h>
#include <linux/bitmap.h>
#include <linux/stringify.h>


struct report {
	
struct perf_tool	tool;
	
struct perf_session	*session;
	


bool			use_tui, use_gtk, use_stdio;
	
bool			show_full_info;
	
bool			show_threads;
	
bool			inverted_callchain;
	
bool			mem_mode;
	
bool			header;
	
bool			header_only;
	
bool			nonany_branch_mode;
	
int			max_stack;
	
struct perf_read_values	show_threads_values;
	
const char		*pretty_printing_style;
	
const char		*cpu_list;
	
const char		*symbol_filter_str;
	
const char		*time_str;
	
struct perf_time_interval ptime;
	
float			min_percent;
	
u64			nr_entries;
	
u64			queue_size;
	
int			socket_filter;
	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
};



static int report__config(const char *var, const char *value, void *cb)
{
	struct report *rep = cb;

	if (!strcmp(var, "report.group")) {
		symbol_conf.event_group = perf_config_bool(var, value);
		return 0;
	}
	if (!strcmp(var, "report.percent-limit")) {
		double pcnt = strtof(value, NULL);

		rep->min_percent = pcnt;
		callchain_param.min_percent = pcnt;
		return 0;
	}
	if (!strcmp(var, "report.children")) {
		symbol_conf.cumulate_callchain = perf_config_bool(var, value);
		return 0;
	}
	if (!strcmp(var, "report.queue-size")) {
		rep->queue_size = perf_config_u64(var, value);
		return 0;
	}
	if (!strcmp(var, "report.sort_order")) {
		default_sort_order = strdup(value);
		return 0;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
namhyung kim
namhyung kim
86
51.50%
4
44.44%
jiri olsa
jiri olsa
33
19.76%
1
11.11%
stephane eranian
stephane eranian
24
14.37%
1
11.11%
arnaldo carvalho de melo
arnaldo carvalho de melo
23
13.77%
2
22.22%
wang nan
wang nan
1
0.60%
1
11.11%
Total
167
100.00%
9
100.00%



static int hist_iter__report_callback(struct hist_entry_iter *iter,
				      struct addr_location *al, bool single,
				      void *arg)
{
	int err = 0;
	struct report *rep = arg;
	struct hist_entry *he = iter->he;
	struct perf_evsel *evsel = iter->evsel;
	struct mem_info *mi;
	struct branch_info *bi;

	if (!ui__has_annotation())
		return 0;

	hist__account_cycles(iter->sample->branch_stack, al, iter->sample,
			     rep->nonany_branch_mode);

	if (sort__mode == SORT_MODE__BRANCH) {
		bi = he->branch_info;
		err = addr_map_symbol__inc_samples(&bi->from, evsel->idx);
		if (err)
			goto out;

		err = addr_map_symbol__inc_samples(&bi->to, evsel->idx);

	} else if (rep->mem_mode) {
		mi = he->mem_info;
		err = addr_map_symbol__inc_samples(&mi->daddr, evsel->idx);
		if (err)
			goto out;

		err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);

	} else if (symbol_conf.cumulate_callchain) {
		if (single)
			err = hist_entry__inc_addr_samples(he, evsel->idx,
							   al->addr);
	} else {
		err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
	}

out:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
namhyung kim
namhyung kim
223
92.15%
1
50.00%
andi kleen
andi kleen
19
7.85%
1
50.00%
Total
242
100.00%
2
100.00%



static int process_sample_event(struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct perf_evsel *evsel,
				struct machine *machine)
{
	struct report *rep = container_of(tool, struct report, tool);
	struct addr_location al;
	struct hist_entry_iter iter = {
		.evsel 			= evsel,
		.sample 		= sample,
		.hide_unresolved 	= symbol_conf.hide_unresolved,
		.add_entry_cb 		= hist_iter__report_callback,
        };
	int ret = 0;

	if (perf_time__skip_sample(&rep->ptime, sample->time))
		return 0;

	if (machine__resolve(machine, &al, sample) < 0) {
		pr_debug("problem processing %d event, skipping it.\n",
			 event->header.type);
		return -1;
	}

	if (symbol_conf.hide_unresolved && al.sym == NULL)
		goto out_put;

	if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
		goto out_put;

	if (sort__mode == SORT_MODE__BRANCH) {
		/*
                 * A non-synthesized event might not have a branch stack if
                 * branch stacks have been synthesized (using itrace options).
                 */
		if (!sample->branch_stack)
			goto out_put;
		iter.ops = &hist_iter_branch;
	} else if (rep->mem_mode) {
		iter.ops = &hist_iter_mem;
	} else if (symbol_conf.cumulate_callchain) {
		iter.ops = &hist_iter_cumulative;
	} else {
		iter.ops = &hist_iter_normal;
	}

	if (al.map != NULL)
		al.map->dso->hit = 1;

	ret = hist_entry_iter__add(&iter, &al, rep->max_stack, rep);
	if (ret < 0)
		pr_debug("problem adding hist entry, skipping event\n");
out_put:
	addr_location__put(&al);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
116
39.73%
21
51.22%
namhyung kim
namhyung kim
86
29.45%
8
19.51%
ingo molnar
ingo molnar
21
7.19%
3
7.32%
adrian hunter
adrian hunter
19
6.51%
1
2.44%
david ahern
david ahern
17
5.82%
1
2.44%
anton blanchard
anton blanchard
14
4.79%
1
2.44%
stephane eranian
stephane eranian
10
3.42%
2
4.88%
roberto agostino vitillo
roberto agostino vitillo
6
2.05%
1
2.44%
eric b munson
eric b munson
1
0.34%
1
2.44%
peter zijlstra
peter zijlstra
1
0.34%
1
2.44%
hirofumi ogawa
hirofumi ogawa
1
0.34%
1
2.44%
Total
292
100.00%
41
100.00%



static int process_read_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample __maybe_unused,
			      struct perf_evsel *evsel,
			      struct machine *machine __maybe_unused)
{
	struct report *rep = container_of(tool, struct report, tool);

	if (rep->show_threads) {
		const char *name = evsel ? perf_evsel__name(evsel) : "unknown";
		int err = perf_read_values_add_value(&rep->show_threads_values,
					   event->read.pid, event->read.tid,
					   event->read.id,
					   name,
					   event->read.value);

		if (err)
			return err;
	}

	dump_printf(": %d %d %s %" PRIu64 "\n", event->read.pid, event->read.tid,
		    evsel ? perf_evsel__name(evsel) : "FAIL",
		    event->read.value);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
60
39.74%
13
65.00%
brice goglin
brice goglin
47
31.13%
1
5.00%
peter zijlstra
peter zijlstra
38
25.17%
2
10.00%
ingo molnar
ingo molnar
3
1.99%
2
10.00%
irina tirdea
irina tirdea
2
1.32%
1
5.00%
frederic weisbecker
frederic weisbecker
1
0.66%
1
5.00%
Total
151
100.00%
20
100.00%

/* For pipe mode, sample_type is not currently set */


static int report__setup_sample_type(struct report *rep)
{
	struct perf_session *session = rep->session;
	u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
	bool is_pipe = perf_data_file__is_pipe(session->file);

	if (session->itrace_synth_opts->callchain ||
	    (!is_pipe &&
	     perf_header__has_feat(&session->header, HEADER_AUXTRACE) &&
	     !session->itrace_synth_opts->set))
		sample_type |= PERF_SAMPLE_CALLCHAIN;

	if (session->itrace_synth_opts->last_branch)
		sample_type |= PERF_SAMPLE_BRANCH_STACK;

	if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
		if (perf_hpp_list.parent) {
			ui__error("Selected --sort parent, but no "
				    "callchain data. Did you call "
				    "'perf record' without -g?\n");
			return -EINVAL;
		}
		if (symbol_conf.use_callchain) {
			ui__error("Selected -g or --branch-history but no "
				  "callchain data. Did\n"
				  "you call 'perf record' without -g?\n");
			return -1;
		}
	} else if (!callchain_param.enabled &&
		   callchain_param.mode != CHAIN_NONE &&
		   !symbol_conf.use_callchain) {
			symbol_conf.use_callchain = true;
			if (callchain_register_param(&callchain_param) < 0) {
				ui__error("Can't register callchain params.\n");
				return -EINVAL;
			}
	}

	if (symbol_conf.cumulate_callchain) {
		/* Silently ignore if callchain is missing */
		if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
			symbol_conf.cumulate_callchain = false;
			perf_hpp__cancel_cumulate();
		}
	}

	if (sort__mode == SORT_MODE__BRANCH) {
		if (!is_pipe &&
		    !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
			ui__error("Selected -b but no branch data. "
				  "Did you call perf record without -b?\n");
			return -1;
		}
	}

	if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
		if ((sample_type & PERF_SAMPLE_REGS_USER) &&
		    (sample_type & PERF_SAMPLE_STACK_USER))
			callchain_param.record_mode = CALLCHAIN_DWARF;
		else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
			callchain_param.record_mode = CALLCHAIN_LBR;
		else
			callchain_param.record_mode = CALLCHAIN_FP;
	}

	/* ??? handle more cases than just ANY? */
	if (!(perf_evlist__combined_branch_type(session->evlist) &
				PERF_SAMPLE_BRANCH_ANY))
		rep->nonany_branch_mode = true;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
namhyung kim
namhyung kim
77
23.84%
4
12.12%
frederic weisbecker
frederic weisbecker
48
14.86%
2
6.06%
adrian hunter
adrian hunter
47
14.55%
3
9.09%
arnaldo carvalho de melo
arnaldo carvalho de melo
45
13.93%
10
30.30%
andi kleen
andi kleen
23
7.12%
2
6.06%
roberto agostino vitillo
roberto agostino vitillo
23
7.12%
1
3.03%
ingo molnar
ingo molnar
19
5.88%
2
6.06%
jiri olsa
jiri olsa
14
4.33%
2
6.06%
kan liang
kan liang
13
4.02%
1
3.03%
peter zijlstra
peter zijlstra
9
2.79%
4
12.12%
david ahern
david ahern
4
1.24%
1
3.03%
stephane eranian
stephane eranian
1
0.31%
1
3.03%
Total
323
100.00%
33
100.00%



static void sig_handler(int sig __maybe_unused)
{
	session_done = 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tom zanussi
tom zanussi
11
78.57%
1
33.33%
arnaldo carvalho de melo
arnaldo carvalho de melo
2
14.29%
1
33.33%
irina tirdea
irina tirdea
1
7.14%
1
33.33%
Total
14
100.00%
3
100.00%



static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report *rep,
					      const char *evname, FILE *fp)
{
	size_t ret;
	char unit;
	unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
	u64 nr_events = hists->stats.total_period;
	struct perf_evsel *evsel = hists_to_evsel(hists);
	char buf[512];
	size_t size = sizeof(buf);
	int socked_id = hists->socket_filter;

	if (symbol_conf.filter_relative) {
		nr_samples = hists->stats.nr_non_filtered_samples;
		nr_events = hists->stats.total_non_filtered_period;
	}

	if (perf_evsel__is_group_event(evsel)) {
		struct perf_evsel *pos;

		perf_evsel__group_desc(evsel, buf, size);
		evname = buf;

		for_each_group_member(pos, evsel) {
			const struct hists *pos_hists = evsel__hists(pos);

			if (symbol_conf.filter_relative) {
				nr_samples += pos_hists->stats.nr_non_filtered_samples;
				nr_events += pos_hists->stats.total_non_filtered_period;
			} else {
				nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
				nr_events += pos_hists->stats.total_period;
			}
		}
	}

	nr_samples = convert_unit(nr_samples, &unit);
	ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);
	if (evname != NULL)
		ret += fprintf(fp, " of event '%s'", evname);

	if (symbol_conf.show_ref_callgraph &&
	    strstr(evname, "call-graph=no")) {
		ret += fprintf(fp, ", show reference callgraph");
	}

	if (rep->mem_mode) {
		ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
		ret += fprintf(fp, "\n# Sort order   : %s", sort_order ? : default_mem_sort_order);
	} else
		ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);

	if (socked_id > -1)
		ret += fprintf(fp, "\n# Processor Socket: %d", socked_id);

	return ret + fprintf(fp, "\n#\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
namhyung kim
namhyung kim
124
36.58%
3
21.43%
arnaldo carvalho de melo
arnaldo carvalho de melo
103
30.38%
4
28.57%
kan liang
kan liang
49
14.45%
3
21.43%
stephane eranian
stephane eranian
35
10.32%
1
7.14%
ashay rane
ashay rane
23
6.78%
1
7.14%
yunlong song
yunlong song
3
0.88%
1
7.14%
jiri olsa
jiri olsa
2
0.59%
1
7.14%
Total
339
100.00%
14
100.00%



static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
					 struct report *rep,
					 const char *help)
{
	struct perf_evsel *pos;

	fprintf(stdout, "#\n# Total Lost Samples: %" PRIu64 "\n#\n", evlist->stats.total_lost_samples);
	evlist__for_each_entry(evlist, pos) {
		struct hists *hists = evsel__hists(pos);
		const char *evname = perf_evsel__name(pos);

		if (symbol_conf.event_group &&
		    !perf_evsel__is_group_leader(pos))
			continue;

		hists__fprintf_nr_sample_events(hists, rep, evname, stdout);
		hists__fprintf(hists, true, 0, 0, rep->min_percent, stdout,
			       symbol_conf.use_callchain);
		fprintf(stdout, "\n\n");
	}

	if (sort_order == NULL &&
	    parent_pattern == default_parent_pattern)
		fprintf(stdout, "#\n# (%s)\n#\n", help);

	if (rep->show_threads) {
		bool style = !strcmp(rep->pretty_printing_style, "raw");
		perf_read_values_display(stdout, &rep->show_threads_values,
					 style);
		perf_read_values_destroy(&rep->show_threads_values);
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
147
79.89%
12
66.67%
namhyung kim
namhyung kim
18
9.78%
3
16.67%
kan liang
kan liang
12
6.52%
1
5.56%
jiri olsa
jiri olsa
4
2.17%
1
5.56%
he kuang
he kuang
3
1.63%
1
5.56%
Total
184
100.00%
18
100.00%



static void report__warn_kptr_restrict(const struct report *rep)
{
	struct map *kernel_map = machine__kernel_map(&rep->session->machines.host);
	struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;

	if (kernel_map == NULL ||
	    (kernel_map->dso->hit &&
	     (kernel_kmap->ref_reloc_sym == NULL ||
	      kernel_kmap->ref_reloc_sym->addr == 0))) {
		const char *desc =
		    "As no suitable kallsyms nor vmlinux was found, kernel samples\n"
		    "can't be resolved.";

		if (kernel_map) {
			const struct dso *kdso = kernel_map->dso;
			if (!RB_EMPTY_ROOT(&kdso->symbols[MAP__FUNCTION])) {
				desc = "If some relocation was applied (e.g. "
				       "kexec) symbols may be misresolved.";
			}
		}

		ui__warning(
"Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"
"Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"
"Samples in kernel modules can't be resolved as well.\n\n",
		desc);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
125
96.90%
2
66.67%
wang nan
wang nan
4
3.10%
1
33.33%
Total
129
100.00%
3
100.00%



static int report__gtk_browse_hists(struct report *rep, const char *help)
{
	int (*hist_browser)(struct perf_evlist *evlist, const char *help,
			    struct hist_browser_timer *timer, float min_pcnt);

	hist_browser = dlsym(perf_gtk_handle, "perf_evlist__gtk_browse_hists");

	if (hist_browser == NULL) {
		ui__error("GTK browser not found!\n");
		return -1;
	}

	return hist_browser(rep->session->evlist, help, NULL, rep->min_percent);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
85
100.00%
1
100.00%
Total
85
100.00%
1
100.00%



static int report__browse_hists(struct report *rep)
{
	int ret;
	struct perf_session *session = rep->session;
	struct perf_evlist *evlist = session->evlist;
	const char *help = perf_tip(system_path(TIPDIR));

	if (help == NULL) {
		/* fallback for people who don't install perf ;-) */
		help = perf_tip(DOCDIR);
		if (help == NULL)
			help = "Cannot load tips.txt file, please install perf!";
	}

	switch (use_browser) {
	case 1:
		ret = perf_evlist__tui_browse_hists(evlist, help, NULL,
						    rep->min_percent,
						    &session->header.env);
		/*
                 * Usually "ret" is the last pressed key, and we only
                 * care if the key notifies us to switch data file.
                 */
		if (ret != K_SWITCH_INPUT_DATA)
			ret = 0;
		break;
	case 2:
		ret = report__gtk_browse_hists(rep, help);
		break;
	default:
		ret = perf_evlist__tty_browse_hists(evlist, rep, help);
		break;
	}

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
110
76.92%
1
33.33%
namhyung kim
namhyung kim
33
23.08%
2
66.67%
Total
143
100.00%
3
100.00%



static int report__collapse_hists(struct report *rep)
{
	struct ui_progress prog;
	struct perf_evsel *pos;
	int ret = 0;

	ui_progress__init(&prog, rep->nr_entries, "Merging related events...");

	evlist__for_each_entry(rep->session->evlist, pos) {
		struct hists *hists = evsel__hists(pos);

		if (pos->idx == 0)
			hists->symbol_filter_str = rep->symbol_filter_str;

		hists->socket_filter = rep->socket_filter;

		ret = hists__collapse_resort(hists, &prog);
		if (ret < 0)
			break;

		/* Non-group events are considered as leader */
		if (symbol_conf.event_group &&
		    !perf_evsel__is_group_leader(pos)) {
			struct hists *leader_hists = evsel__hists(pos->leader);

			hists__match(leader_hists, hists);
			hists__link(leader_hists, hists);
		}
	}

	ui_progress__finish();
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
114
79.72%
4
57.14%
namhyung kim
namhyung kim
21
14.69%
2
28.57%
kan liang
kan liang
8
5.59%
1
14.29%
Total
143
100.00%
7
100.00%



static void report__output_resort(struct report *rep)
{
	struct ui_progress prog;
	struct perf_evsel *pos;

	ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");

	evlist__for_each_entry(rep->session->evlist, pos)
		perf_evsel__output_resort(pos, &prog);

	ui_progress__finish();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
namhyung kim
namhyung kim
47
95.92%
1
33.33%
jiri olsa
jiri olsa
1
2.04%
1
33.33%
arnaldo carvalho de melo
arnaldo carvalho de melo
1
2.04%
1
33.33%
Total
49
100.00%
3
100.00%



static int __cmd_report(struct report *rep)
{
	int ret;
	struct perf_session *session = rep->session;
	struct perf_evsel *pos;
	struct perf_data_file *file = session->file;

	signal(SIGINT, sig_handler);

	if (rep->cpu_list) {
		ret = perf_session__cpu_bitmap(session, rep->cpu_list,
					       rep->cpu_bitmap);
		if (ret) {
			ui__error("failed to set cpu bitmap\n");
			return ret;
		}
	}

	if (rep->show_threads) {
		ret = perf_read_values_init(&rep->show_threads_values);
		if (ret)
			return ret;
	}

	ret = report__setup_sample_type(rep);
	if (ret) {
		/* report__setup_sample_type() already showed error message */
		return ret;
	}

	ret = perf_session__process_events(session);
	if (ret) {
		ui__error("failed to process sample\n");
		return ret;
	}

	report__warn_kptr_restrict(rep);

	evlist__for_each_entry(session->evlist, pos)
		rep->nr_entries += evsel__hists(pos)->nr_entries;

	if (use_browser == 0) {
		if (verbose > 3)
			perf_session__fprintf(session, stdout);

		if (verbose > 2)
			perf_session__fprintf_dsos(session, stdout);

		if (dump_trace) {
			perf_session__fprintf_nr_events(session, stdout);
			perf_evlist__fprintf_nr_events(session->evlist, stdout);
			return 0;
		}
	}

	ret = report__collapse_hists(rep);
	if (ret) {
		ui__error("failed to process hist entry\n");
		return ret;
	}

	if (session_done())
		return 0;

	/*
         * recalculate number of entries after collapsing since it
         * might be changed during the collapse phase.
         */
	rep->nr_entries = 0;
	evlist__for_each_entry(session->evlist, pos)
		rep->nr_entries += evsel__hists(pos)->nr_entries;

	if (rep->nr_entries == 0) {
		ui__error("The %s file has no samples!\n", file->path);
		return 0;
	}

	report__output_resort(rep);

	return report__browse_hists(rep);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
103
33.12%
23
44.23%
namhyung kim
namhyung kim
94
30.23%
11
21.15%
jiri olsa
jiri olsa
36
11.58%
3
5.77%
ingo molnar
ingo molnar
23
7.40%
5
9.62%
anton blanchard
anton blanchard
21
6.75%
1
1.92%
frederic weisbecker
frederic weisbecker
9
2.89%
1
1.92%
tom zanussi
tom zanussi
7
2.25%
1
1.92%
eric b munson
eric b munson
6
1.93%
1
1.92%
stephane eranian
stephane eranian
4
1.29%
1
1.92%
peter zijlstra
peter zijlstra
4
1.29%
2
3.85%
yanmin zhang
yanmin zhang
2
0.64%
1
1.92%
brice goglin
brice goglin
1
0.32%
1
1.92%
david ahern
david ahern
1
0.32%
1
1.92%
Total
311
100.00%
52
100.00%


static int

report_parse_callchain_opt(const struct option *opt, const char *arg, int unset)
{
	struct callchain_param *callchain = opt->value;

	callchain->