Release 4.14 tools/perf/builtin-report.c
// SPDX-License-Identifier: GPL-2.0
/*
* 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/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 "util/units.h"
#include "util/branch.h"
#include <dlfcn.h>
#include <errno.h>
#include <inttypes.h>
#include <regex.h>
#include <signal.h>
#include <linux/bitmap.h>
#include <linux/stringify.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.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);
struct branch_type_stat brtype_stat;
};
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"))
return perf_config_u64(&rep->queue_size, var, value);
if (!strcmp(var, "report.sort_order")) {
default_sort_order = strdup(value);
return 0;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Namhyung Kim | 86 | 52.44% | 4 | 40.00% |
| Arnaldo Carvalho de Melo | 28 | 17.07% | 3 | 30.00% |
| Jiri Olsa | 25 | 15.24% | 1 | 10.00% |
| Stéphane Eranian | 24 | 14.63% | 1 | 10.00% |
| Wang Nan | 1 | 0.61% | 1 | 10.00% |
| Total | 164 | 100.00% | 10 | 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 perf_sample *sample = iter->sample;
struct mem_info *mi;
struct branch_info *bi;
if (!ui__has_annotation())
return 0;
hist__account_cycles(sample->branch_stack, al, sample,
rep->nonany_branch_mode);
if (sort__mode == SORT_MODE__BRANCH) {
bi = he->branch_info;
err = addr_map_symbol__inc_samples(&bi->from, sample, evsel->idx);
if (err)
goto out;
err = addr_map_symbol__inc_samples(&bi->to, sample, evsel->idx);
} else if (rep->mem_mode) {
mi = he->mem_info;
err = addr_map_symbol__inc_samples(&mi->daddr, sample, evsel->idx);
if (err)
goto out;
err = hist_entry__inc_addr_samples(he, sample, evsel->idx, al->addr);
} else if (symbol_conf.cumulate_callchain) {
if (single)
err = hist_entry__inc_addr_samples(he, sample, evsel->idx,
al->addr);
} else {
err = hist_entry__inc_addr_samples(he, sample, evsel->idx, al->addr);
}
out:
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Namhyung Kim | 223 | 86.10% | 1 | 33.33% |
| Taeung Song | 21 | 8.11% | 1 | 33.33% |
| Andi Kleen | 15 | 5.79% | 1 | 33.33% |
| Total | 259 | 100.00% | 3 | 100.00% |
static int hist_iter__branch_callback(struct hist_entry_iter *iter,
struct addr_location *al __maybe_unused,
bool single __maybe_unused,
void *arg)
{
struct hist_entry *he = iter->he;
struct report *rep = arg;
struct branch_info *bi;
bi = he->branch_info;
branch_type_count(&rep->brtype_stat, &bi->flags,
bi->from.addr, bi->to.addr);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jin Yao | 80 | 100.00% | 1 | 100.00% |
| Total | 80 | 100.00% | 1 | 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.add_entry_cb = hist_iter__branch_callback;
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 | 117 | 39.26% | 22 | 51.16% |
| Namhyung Kim | 86 | 28.86% | 8 | 18.60% |
| Ingo Molnar | 20 | 6.71% | 3 | 6.98% |
| Adrian Hunter | 19 | 6.38% | 1 | 2.33% |
| David Ahern | 17 | 5.70% | 1 | 2.33% |
| Anton Blanchard | 14 | 4.70% | 1 | 2.33% |
| Stéphane Eranian | 10 | 3.36% | 2 | 4.65% |
| Jin Yao | 6 | 2.01% | 1 | 2.33% |
| Roberto Agostino Vitillo | 6 | 2.01% | 1 | 2.33% |
| Eric B Munson | 1 | 0.34% | 1 | 2.33% |
| Peter Zijlstra | 1 | 0.34% | 1 | 2.33% |
| Hirofumi Ogawa | 1 | 0.34% | 1 | 2.33% |
| Total | 298 | 100.00% | 43 | 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,
evsel->idx,
name,
event->read.value);
if (err)
return err;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Arnaldo Carvalho de Melo | 54 | 46.96% | 12 | 63.16% |
| Brice Goglin | 43 | 37.39% | 1 | 5.26% |
| Peter Zijlstra | 11 | 9.57% | 2 | 10.53% |
| Ingo Molnar | 3 | 2.61% | 2 | 10.53% |
| Jiri Olsa | 2 | 1.74% | 1 | 5.26% |
| Irina Tirdea | 2 | 1.74% | 1 | 5.26% |
| Total | 115 | 100.00% | 19 | 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 &&
!symbol_conf.show_branchflag_count) {
ui__error("Selected -g or --branch-history.\n"
"But no callchain or branch data.\n"
"Did you call 'perf record' without -g or -b?\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 | 77 | 23.48% | 4 | 12.12% |
| Frédéric Weisbecker | 48 | 14.63% | 2 | 6.06% |
| Adrian Hunter | 47 | 14.33% | 3 | 9.09% |
| Arnaldo Carvalho de Melo | 44 | 13.41% | 10 | 30.30% |
| Roberto Agostino Vitillo | 23 | 7.01% | 1 | 3.03% |
| Andi Kleen | 21 | 6.40% | 1 | 3.03% |
| Ingo Molnar | 19 | 5.79% | 2 | 6.06% |
| Jiri Olsa | 14 | 4.27% | 2 | 6.06% |
| Kan Liang | 13 | 3.96% | 1 | 3.03% |
| Peter Zijlstra | 9 | 2.74% | 4 | 12.12% |
| Jin Yao | 8 | 2.44% | 1 | 3.03% |
| David Ahern | 4 | 1.22% | 1 | 3.03% |
| Stéphane Eranian | 1 | 0.30% | 1 | 3.03% |
| Total | 328 | 100.00% | 33 | 100.00% |
static void sig_handler(int sig __maybe_unused)
{
session_done = 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Tom Zanussi | 11 | 78.57% | 1 | 33.33% |
| Arnaldo Carvalho de Melo | 2 | 14.29% | 1 | 33.33% |
| 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 (quiet)
return 0;
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 | 131 | 37.86% | 4 | 26.67% |
| Arnaldo Carvalho de Melo | 103 | 29.77% | 4 | 26.67% |
| Kan Liang | 49 | 14.16% | 3 | 20.00% |
| Stéphane Eranian | 35 | 10.12% | 1 | 6.67% |
| Ashay Rane | 23 | 6.65% | 1 | 6.67% |
| Yunlong Song | 3 | 0.87% | 1 | 6.67% |
| Jiri Olsa | 2 | 0.58% | 1 | 6.67% |
| Total | 346 | 100.00% | 15 | 100.00% |
static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
struct report *rep,
const char *help)
{
struct perf_evsel *pos;
if (!quiet) {
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, !quiet, 0, 0, rep->min_percent, stdout,
symbol_conf.use_callchain ||
symbol_conf.show_branchflag_count);
fprintf(stdout, "\n\n");
}
if (!quiet)
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);
}
if (sort__mode == SORT_MODE__BRANCH)
branch_type_stat_display(stdout, &rep->brtype_stat);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Arnaldo Carvalho de Melo | 140 | 67.63% | 12 | 57.14% |
| Namhyung Kim | 28 | 13.53% | 4 | 19.05% |
| Jin Yao | 20 | 9.66% | 2 | 9.52% |
| Kan Liang | 12 | 5.80% | 1 | 4.76% |
| Jiri Olsa | 4 | 1.93% | 1 | 4.76% |
| He Kuang | 3 | 1.45% | 1 | 4.76% |
| Total | 207 | 100.00% | 21 | 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 | 125 | 96.90% | 2 | 66.67% |
| 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 | 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 | 110 | 76.92% | 1 | 33.33% |
| 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 | 114 | 79.72% | 4 | 57.14% |
| Namhyung Kim | 21 | 14.69% | 2 | 28.57% |
| 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 | 47 | 95.92% | 1 | 33.33% |
| Jiri Olsa | 1 | 2.04% | 1 | 33.33% |
| 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;
}
session->itrace_synth_opts->cpu_bitmap = rep->cpu_bitmap;
}
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(