2009-06-02 14:37:05 -07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-05-27 00:10:38 -07:00
|
|
|
#include "builtin.h"
|
2009-05-26 00:17:18 -07:00
|
|
|
|
2009-06-02 14:37:05 -07:00
|
|
|
#include "util/util.h"
|
|
|
|
|
2009-06-04 06:19:47 -07:00
|
|
|
#include "util/color.h"
|
2009-07-01 10:46:08 -07:00
|
|
|
#include <linux/list.h>
|
2009-05-27 00:50:13 -07:00
|
|
|
#include "util/cache.h"
|
2009-07-01 08:28:37 -07:00
|
|
|
#include <linux/rbtree.h>
|
2009-05-28 10:55:04 -07:00
|
|
|
#include "util/symbol.h"
|
2009-06-26 07:28:01 -07:00
|
|
|
#include "util/callchain.h"
|
2009-06-30 15:01:20 -07:00
|
|
|
#include "util/strlist.h"
|
2009-08-07 04:55:24 -07:00
|
|
|
#include "util/values.h"
|
2009-05-18 08:45:42 -07:00
|
|
|
|
2009-05-26 00:17:18 -07:00
|
|
|
#include "perf.h"
|
2009-08-16 13:05:48 -07:00
|
|
|
#include "util/debug.h"
|
2009-06-25 08:05:54 -07:00
|
|
|
#include "util/header.h"
|
2009-12-11 16:24:02 -07:00
|
|
|
#include "util/session.h"
|
2009-05-26 00:17:18 -07:00
|
|
|
|
|
|
|
#include "util/parse-options.h"
|
|
|
|
#include "util/parse-events.h"
|
|
|
|
|
2009-08-14 03:21:53 -07:00
|
|
|
#include "util/thread.h"
|
2009-09-24 09:02:49 -07:00
|
|
|
#include "util/sort.h"
|
2009-09-28 06:32:55 -07:00
|
|
|
#include "util/hist.h"
|
2009-08-14 03:21:53 -07:00
|
|
|
|
2009-05-27 00:33:18 -07:00
|
|
|
static char const *input_name = "perf.data";
|
2009-06-04 05:13:04 -07:00
|
|
|
|
2010-04-13 01:37:33 -07:00
|
|
|
static bool force;
|
2009-12-28 17:48:34 -07:00
|
|
|
static bool hide_unresolved;
|
2010-01-05 06:54:45 -07:00
|
|
|
static bool dont_use_callchains;
|
2009-05-26 09:48:58 -07:00
|
|
|
|
2010-04-13 01:37:33 -07:00
|
|
|
static bool show_threads;
|
2009-08-07 04:55:24 -07:00
|
|
|
static struct perf_read_values show_threads_values;
|
|
|
|
|
2009-08-10 06:26:32 -07:00
|
|
|
static char default_pretty_printing_style[] = "normal";
|
|
|
|
static char *pretty_printing_style = default_pretty_printing_style;
|
|
|
|
|
2009-07-04 22:39:21 -07:00
|
|
|
static char callchain_default_opt[] = "fractal,0.5";
|
|
|
|
|
2010-03-05 08:51:09 -07:00
|
|
|
static struct event_stat_id *get_stats(struct perf_session *self,
|
|
|
|
u64 event_stream, u32 type, u64 config)
|
|
|
|
{
|
|
|
|
struct rb_node **p = &self->stats_by_id.rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct event_stat_id *iter, *new;
|
|
|
|
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
iter = rb_entry(parent, struct event_stat_id, rb_node);
|
|
|
|
if (iter->config == config)
|
|
|
|
return iter;
|
|
|
|
|
|
|
|
|
|
|
|
if (config > iter->config)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
}
|
|
|
|
|
|
|
|
new = malloc(sizeof(struct event_stat_id));
|
|
|
|
if (new == NULL)
|
|
|
|
return NULL;
|
|
|
|
memset(new, 0, sizeof(struct event_stat_id));
|
|
|
|
new->event_stream = event_stream;
|
|
|
|
new->config = config;
|
|
|
|
new->type = type;
|
|
|
|
rb_link_node(&new->rb_node, parent, p);
|
|
|
|
rb_insert_color(&new->rb_node, &self->stats_by_id);
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
2009-12-14 08:10:39 -07:00
|
|
|
static int perf_session__add_hist_entry(struct perf_session *self,
|
|
|
|
struct addr_location *al,
|
2010-03-05 08:51:09 -07:00
|
|
|
struct sample_data *data)
|
2009-05-18 08:45:42 -07:00
|
|
|
{
|
2010-03-24 12:40:18 -07:00
|
|
|
struct map_symbol *syms = NULL;
|
|
|
|
struct symbol *parent = NULL;
|
2009-10-03 06:42:45 -07:00
|
|
|
bool hit;
|
2010-03-22 09:09:33 -07:00
|
|
|
int err;
|
2009-05-27 11:20:24 -07:00
|
|
|
struct hist_entry *he;
|
2010-03-05 08:51:09 -07:00
|
|
|
struct event_stat_id *stats;
|
|
|
|
struct perf_event_attr *attr;
|
2009-05-27 11:20:24 -07:00
|
|
|
|
2010-04-02 06:04:18 -07:00
|
|
|
if ((sort__has_parent || symbol_conf.use_callchain) && data->callchain) {
|
2009-12-14 09:22:59 -07:00
|
|
|
syms = perf_session__resolve_callchain(self, al->thread,
|
2010-03-05 08:51:09 -07:00
|
|
|
data->callchain, &parent);
|
2010-04-02 06:04:18 -07:00
|
|
|
if (syms == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-03-05 08:51:09 -07:00
|
|
|
|
|
|
|
attr = perf_header__find_attr(data->id, &self->header);
|
|
|
|
if (attr)
|
|
|
|
stats = get_stats(self, data->id, attr->type, attr->config);
|
|
|
|
else
|
|
|
|
stats = get_stats(self, data->id, 0, 0);
|
|
|
|
if (stats == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
he = __perf_session__add_hist_entry(&stats->hists, al, parent,
|
|
|
|
data->period, &hit);
|
2009-10-03 06:42:45 -07:00
|
|
|
if (he == NULL)
|
|
|
|
return -ENOMEM;
|
2009-05-27 11:20:24 -07:00
|
|
|
|
2009-10-03 06:42:45 -07:00
|
|
|
if (hit)
|
2010-03-05 08:51:09 -07:00
|
|
|
he->count += data->period;
|
2009-05-27 11:20:24 -07:00
|
|
|
|
2009-12-15 15:04:42 -07:00
|
|
|
if (symbol_conf.use_callchain) {
|
2009-10-03 06:42:45 -07:00
|
|
|
if (!hit)
|
2010-04-02 05:50:42 -07:00
|
|
|
callchain_init(he->callchain);
|
|
|
|
err = append_chain(he->callchain, data->callchain, syms);
|
2009-06-30 20:35:14 -07:00
|
|
|
free(syms);
|
2010-03-22 09:09:33 -07:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
2009-06-26 07:28:01 -07:00
|
|
|
}
|
2009-05-27 11:20:24 -07:00
|
|
|
|
|
|
|
return 0;
|
2009-05-18 08:45:42 -07:00
|
|
|
}
|
|
|
|
|
2009-06-18 13:20:45 -07:00
|
|
|
static int validate_chain(struct ip_callchain *chain, event_t *event)
|
2009-06-17 23:00:17 -07:00
|
|
|
{
|
|
|
|
unsigned int chain_size;
|
|
|
|
|
|
|
|
chain_size = event->header.size;
|
|
|
|
chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
|
|
|
|
|
perf_counter tools: Define and use our own u64, s64 etc. definitions
On 64-bit powerpc, __u64 is defined to be unsigned long rather than
unsigned long long. This causes compiler warnings every time we
print a __u64 value with %Lx.
Rather than changing __u64, we define our own u64 to be unsigned long
long on all architectures, and similarly s64 as signed long long.
For consistency we also define u32, s32, u16, s16, u8 and s8. These
definitions are put in a new header, types.h, because these definitions
are needed in util/string.h and util/symbol.h.
The main change here is the mechanical change of __[us]{64,32,16,8}
to remove the "__". The other changes are:
* Create types.h
* Include types.h in perf.h, util/string.h and util/symbol.h
* Add types.h to the LIB_H definition in Makefile
* Added (u64) casts in process_overflow_event() and print_sym_table()
to kill two remaining warnings.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: benh@kernel.crashing.org
LKML-Reference: <19003.33494.495844.956580@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-06-19 05:21:42 -07:00
|
|
|
if (chain->nr*sizeof(u64) > chain_size)
|
2009-06-17 23:00:17 -07:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-05 08:51:09 -07:00
|
|
|
static int add_event_total(struct perf_session *session,
|
|
|
|
struct sample_data *data,
|
|
|
|
struct perf_event_attr *attr)
|
|
|
|
{
|
|
|
|
struct event_stat_id *stats;
|
|
|
|
|
|
|
|
if (attr)
|
|
|
|
stats = get_stats(session, data->id, attr->type, attr->config);
|
|
|
|
else
|
|
|
|
stats = get_stats(session, data->id, 0, 0);
|
|
|
|
|
|
|
|
if (!stats)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
stats->stats.total += data->period;
|
|
|
|
session->events_stats.total += data->period;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-13 14:50:28 -07:00
|
|
|
static int process_sample_event(event_t *event, struct perf_session *session)
|
2009-06-03 14:14:49 -07:00
|
|
|
{
|
2009-12-15 15:04:41 -07:00
|
|
|
struct sample_data data = { .period = 1, };
|
perf tools: Consolidate symbol resolving across all tools
Now we have a very high level routine for simple tools to
process IP sample events:
int event__preprocess_sample(const event_t *self,
struct addr_location *al,
symbol_filter_t filter)
It receives the event itself and will insert new threads in the
global threads list and resolve the map and symbol, filling all
this info into the new addr_location struct, so that tools like
annotate and report can further process the event by creating
hist_entries in their specific way (with or without callgraphs,
etc).
It in turn uses the new next layer function:
void thread__find_addr_location(struct thread *self, u8 cpumode,
enum map_type type, u64 addr,
struct addr_location *al,
symbol_filter_t filter)
This one will, given a thread (userspace or the kernel kthread
one), will find the given type (MAP__FUNCTION now, MAP__VARIABLE
too in the near future) at the given cpumode, taking vdsos into
account (userspace hit, but kernel symbol) and will fill all
these details in the addr_location given.
Tools that need a more compact API for plain function
resolution, like 'kmem', can use this other one:
struct symbol *thread__find_function(struct thread *self, u64 addr,
symbol_filter_t filter)
So, to resolve a kernel symbol, that is all the 'kmem' tool
needs, its just a matter of calling:
sym = thread__find_function(kthread, addr, NULL);
The 'filter' parameter is needed because we do lazy
parsing/loading of ELF symtabs or /proc/kallsyms.
With this we remove more code duplication all around, which is
always good, huh? :-)
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1259346563-12568-12-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-27 11:29:23 -07:00
|
|
|
struct addr_location al;
|
2010-03-05 08:51:09 -07:00
|
|
|
struct perf_event_attr *attr;
|
2009-12-06 04:08:24 -07:00
|
|
|
|
2009-12-14 09:23:00 -07:00
|
|
|
event__parse_sample(event, session->sample_type, &data);
|
2009-06-10 12:45:22 -07:00
|
|
|
|
2010-01-14 07:23:09 -07:00
|
|
|
dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
|
|
|
|
data.pid, data.tid, data.ip, data.period);
|
2009-06-03 14:14:49 -07:00
|
|
|
|
2009-12-14 09:23:00 -07:00
|
|
|
if (session->sample_type & PERF_SAMPLE_CALLCHAIN) {
|
2009-07-01 03:37:06 -07:00
|
|
|
unsigned int i;
|
2009-06-14 06:04:15 -07:00
|
|
|
|
2009-12-06 04:08:24 -07:00
|
|
|
dump_printf("... chain: nr:%Lu\n", data.callchain->nr);
|
2009-06-14 06:04:15 -07:00
|
|
|
|
2009-12-06 04:08:24 -07:00
|
|
|
if (validate_chain(data.callchain, event) < 0) {
|
2009-10-21 12:34:06 -07:00
|
|
|
pr_debug("call-chain problem with event, "
|
|
|
|
"skipping it.\n");
|
2009-06-17 23:00:17 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dump_trace) {
|
2009-12-06 04:08:24 -07:00
|
|
|
for (i = 0; i < data.callchain->nr; i++)
|
|
|
|
dump_printf("..... %2d: %016Lx\n",
|
|
|
|
i, data.callchain->ips[i]);
|
2009-06-14 06:04:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-15 15:04:41 -07:00
|
|
|
if (event__preprocess_sample(event, session, &al, NULL) < 0) {
|
|
|
|
fprintf(stderr, "problem processing %d event, skipping it.\n",
|
2009-06-03 14:14:49 -07:00
|
|
|
event->header.type);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-05-27 11:20:24 -07:00
|
|
|
|
2009-12-28 17:48:34 -07:00
|
|
|
if (al.filtered || (hide_unresolved && al.sym == NULL))
|
2009-10-03 16:30:48 -07:00
|
|
|
return 0;
|
2009-06-30 15:01:22 -07:00
|
|
|
|
2010-03-05 08:51:09 -07:00
|
|
|
if (perf_session__add_hist_entry(session, &al, &data)) {
|
2009-10-21 12:34:06 -07:00
|
|
|
pr_debug("problem incrementing symbol count, skipping event\n");
|
2009-10-03 16:30:48 -07:00
|
|
|
return -1;
|
2009-05-18 08:45:42 -07:00
|
|
|
}
|
2009-10-03 16:30:48 -07:00
|
|
|
|
2010-03-05 08:51:09 -07:00
|
|
|
attr = perf_header__find_attr(data.id, &session->header);
|
|
|
|
|
|
|
|
if (add_event_total(session, &data, attr)) {
|
|
|
|
pr_debug("problem adding event count\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-06-03 14:14:49 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2009-06-03 00:38:58 -07:00
|
|
|
|
2009-12-13 14:50:24 -07:00
|
|
|
static int process_read_event(event_t *event, struct perf_session *session __used)
|
2009-06-24 13:46:04 -07:00
|
|
|
{
|
perf: Do the big rename: Performance Counters -> Performance Events
Bye-bye Performance Counters, welcome Performance Events!
In the past few months the perfcounters subsystem has grown out its
initial role of counting hardware events, and has become (and is
becoming) a much broader generic event enumeration, reporting, logging,
monitoring, analysis facility.
Naming its core object 'perf_counter' and naming the subsystem
'perfcounters' has become more and more of a misnomer. With pending
code like hw-breakpoints support the 'counter' name is less and
less appropriate.
All in one, we've decided to rename the subsystem to 'performance
events' and to propagate this rename through all fields, variables
and API names. (in an ABI compatible fashion)
The word 'event' is also a bit shorter than 'counter' - which makes
it slightly more convenient to write/handle as well.
Thanks goes to Stephane Eranian who first observed this misnomer and
suggested a rename.
User-space tooling and ABI compatibility is not affected - this patch
should be function-invariant. (Also, defconfigs were not touched to
keep the size down.)
This patch has been generated via the following script:
FILES=$(find * -type f | grep -vE 'oprofile|[^K]config')
sed -i \
-e 's/PERF_EVENT_/PERF_RECORD_/g' \
-e 's/PERF_COUNTER/PERF_EVENT/g' \
-e 's/perf_counter/perf_event/g' \
-e 's/nb_counters/nb_events/g' \
-e 's/swcounter/swevent/g' \
-e 's/tpcounter_event/tp_event/g' \
$FILES
for N in $(find . -name perf_counter.[ch]); do
M=$(echo $N | sed 's/perf_counter/perf_event/g')
mv $N $M
done
FILES=$(find . -name perf_event.*)
sed -i \
-e 's/COUNTER_MASK/REG_MASK/g' \
-e 's/COUNTER/EVENT/g' \
-e 's/\<event\>/event_id/g' \
-e 's/counter/event/g' \
-e 's/Counter/Event/g' \
$FILES
... to keep it as correct as possible. This script can also be
used by anyone who has pending perfcounters patches - it converts
a Linux kernel tree over to the new naming. We tried to time this
change to the point in time where the amount of pending patches
is the smallest: the end of the merge window.
Namespace clashes were fixed up in a preparatory patch - and some
stylistic fallout will be fixed up in a subsequent patch.
( NOTE: 'counters' are still the proper terminology when we deal
with hardware registers - and these sed scripts are a bit
over-eager in renaming them. I've undone some of that, but
in case there's something left where 'counter' would be
better than 'event' we can undo that on an individual basis
instead of touching an otherwise nicely automated patch. )
Suggested-by: Stephane Eranian <eranian@google.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Paul Mackerras <paulus@samba.org>
Reviewed-by: Arjan van de Ven <arjan@linux.intel.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: <linux-arch@vger.kernel.org>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-21 03:02:48 -07:00
|
|
|
struct perf_event_attr *attr;
|
2009-08-16 11:56:37 -07:00
|
|
|
|
2009-12-11 16:24:02 -07:00
|
|
|
attr = perf_header__find_attr(event->read.id, &session->header);
|
2009-08-06 10:40:28 -07:00
|
|
|
|
2009-08-07 04:55:24 -07:00
|
|
|
if (show_threads) {
|
2009-08-15 03:26:57 -07:00
|
|
|
const char *name = attr ? __event_name(attr->type, attr->config)
|
2009-08-07 04:55:24 -07:00
|
|
|
: "unknown";
|
|
|
|
perf_read_values_add_value(&show_threads_values,
|
|
|
|
event->read.pid, event->read.tid,
|
|
|
|
event->read.id,
|
|
|
|
name,
|
|
|
|
event->read.value);
|
|
|
|
}
|
|
|
|
|
2009-11-27 11:29:22 -07:00
|
|
|
dump_printf(": %d %d %s %Lu\n", event->read.pid, event->read.tid,
|
|
|
|
attr ? __event_name(attr->type, attr->config) : "FAIL",
|
|
|
|
event->read.value);
|
2009-06-24 13:46:04 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-27 16:37:02 -07:00
|
|
|
static int perf_session__setup_sample_type(struct perf_session *self)
|
2009-06-03 14:14:49 -07:00
|
|
|
{
|
2009-12-27 16:37:02 -07:00
|
|
|
if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
|
2009-07-04 22:39:17 -07:00
|
|
|
if (sort__has_parent) {
|
|
|
|
fprintf(stderr, "selected --sort parent, but no"
|
|
|
|
" callchain data. Did you call"
|
|
|
|
" perf record without -g?\n");
|
2009-12-27 16:37:02 -07:00
|
|
|
return -EINVAL;
|
2009-07-04 22:39:17 -07:00
|
|
|
}
|
2009-12-15 15:04:42 -07:00
|
|
|
if (symbol_conf.use_callchain) {
|
2009-08-17 14:07:48 -07:00
|
|
|
fprintf(stderr, "selected -g but no callchain data."
|
2009-07-04 22:39:17 -07:00
|
|
|
" Did you call perf record without"
|
|
|
|
" -g?\n");
|
2009-10-07 03:47:31 -07:00
|
|
|
return -1;
|
2009-07-04 22:39:17 -07:00
|
|
|
}
|
2010-01-05 06:54:45 -07:00
|
|
|
} else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
|
|
|
|
!symbol_conf.use_callchain) {
|
2009-12-15 15:04:42 -07:00
|
|
|
symbol_conf.use_callchain = true;
|
2009-08-07 17:16:24 -07:00
|
|
|
if (register_callchain_param(&callchain_param) < 0) {
|
|
|
|
fprintf(stderr, "Can't register callchain"
|
|
|
|
" params\n");
|
2009-12-27 16:37:02 -07:00
|
|
|
return -EINVAL;
|
2009-08-07 17:16:24 -07:00
|
|
|
}
|
2009-06-18 14:22:55 -07:00
|
|
|
}
|
|
|
|
|
2009-10-07 03:47:31 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2009-05-26 11:51:47 -07:00
|
|
|
|
2009-12-13 14:50:25 -07:00
|
|
|
static struct perf_event_ops event_ops = {
|
2009-12-27 16:37:05 -07:00
|
|
|
.sample = process_sample_event,
|
|
|
|
.mmap = event__process_mmap,
|
|
|
|
.comm = event__process_comm,
|
|
|
|
.exit = event__process_task,
|
|
|
|
.fork = event__process_task,
|
|
|
|
.lost = event__process_lost,
|
|
|
|
.read = process_read_event,
|
2010-04-01 21:59:19 -07:00
|
|
|
.attr = event__process_attr,
|
2010-04-01 21:59:20 -07:00
|
|
|
.event_type = event__process_event_type,
|
2010-04-01 21:59:21 -07:00
|
|
|
.tracing_data = event__process_tracing_data,
|
2010-04-01 21:59:22 -07:00
|
|
|
.build_id = event__process_build_id,
|
2009-10-07 03:47:31 -07:00
|
|
|
};
|
2009-05-26 11:51:47 -07:00
|
|
|
|
2010-04-01 21:59:17 -07:00
|
|
|
extern volatile int session_done;
|
|
|
|
|
|
|
|
static void sig_handler(int sig __attribute__((__unused__)))
|
|
|
|
{
|
|
|
|
session_done = 1;
|
|
|
|
}
|
|
|
|
|
2009-10-07 03:47:31 -07:00
|
|
|
static int __cmd_report(void)
|
|
|
|
{
|
2009-12-27 16:37:02 -07:00
|
|
|
int ret = -EINVAL;
|
2009-12-13 14:50:24 -07:00
|
|
|
struct perf_session *session;
|
2010-03-05 08:51:09 -07:00
|
|
|
struct rb_node *next;
|
2010-03-11 16:12:44 -07:00
|
|
|
const char *help = "For a higher level overview, try: perf report --sort comm,dso";
|
2009-05-18 08:45:42 -07:00
|
|
|
|
2010-04-01 21:59:17 -07:00
|
|
|
signal(SIGINT, sig_handler);
|
|
|
|
|
2009-12-15 15:04:39 -07:00
|
|
|
session = perf_session__new(input_name, O_RDONLY, force);
|
2009-12-11 16:24:02 -07:00
|
|
|
if (session == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-10-07 03:47:31 -07:00
|
|
|
if (show_threads)
|
|
|
|
perf_read_values_init(&show_threads_values);
|
2009-06-18 14:22:55 -07:00
|
|
|
|
2009-12-27 16:37:02 -07:00
|
|
|
ret = perf_session__setup_sample_type(session);
|
|
|
|
if (ret)
|
|
|
|
goto out_delete;
|
|
|
|
|
2009-12-13 14:50:27 -07:00
|
|
|
ret = perf_session__process_events(session, &event_ops);
|
2009-10-07 03:47:31 -07:00
|
|
|
if (ret)
|
2009-12-11 16:24:02 -07:00
|
|
|
goto out_delete;
|
2009-05-26 09:48:58 -07:00
|
|
|
|
2009-11-27 11:29:22 -07:00
|
|
|
if (dump_trace) {
|
|
|
|
event__print_totals();
|
2009-12-11 16:24:02 -07:00
|
|
|
goto out_delete;
|
2009-11-27 11:29:22 -07:00
|
|
|
}
|
2009-05-26 09:48:58 -07:00
|
|
|
|
2009-10-07 06:49:00 -07:00
|
|
|
if (verbose > 3)
|
2009-12-13 14:50:28 -07:00
|
|
|
perf_session__fprintf(session, stdout);
|
2009-06-04 09:54:00 -07:00
|
|
|
|
2009-10-07 06:49:00 -07:00
|
|
|
if (verbose > 2)
|
2009-05-27 00:10:38 -07:00
|
|
|
dsos__fprintf(stdout);
|
|
|
|
|
2010-03-05 08:51:09 -07:00
|
|
|
next = rb_first(&session->stats_by_id);
|
|
|
|
while (next) {
|
|
|
|
struct event_stat_id *stats;
|
2010-03-26 17:16:22 -07:00
|
|
|
u64 nr_hists;
|
2010-03-05 08:51:09 -07:00
|
|
|
|
|
|
|
stats = rb_entry(next, struct event_stat_id, rb_node);
|
|
|
|
perf_session__collapse_resort(&stats->hists);
|
2010-03-26 17:16:22 -07:00
|
|
|
nr_hists = perf_session__output_resort(&stats->hists,
|
|
|
|
stats->stats.total);
|
2010-03-11 16:12:44 -07:00
|
|
|
if (use_browser)
|
2010-03-26 17:16:22 -07:00
|
|
|
perf_session__browse_hists(&stats->hists, nr_hists,
|
2010-04-03 07:54:35 -07:00
|
|
|
stats->stats.total, help,
|
|
|
|
input_name);
|
2010-03-11 16:12:44 -07:00
|
|
|
else {
|
|
|
|
if (rb_first(&session->stats_by_id) ==
|
|
|
|
rb_last(&session->stats_by_id))
|
|
|
|
fprintf(stdout, "# Samples: %Ld\n#\n",
|
|
|
|
stats->stats.total);
|
|
|
|
else
|
|
|
|
fprintf(stdout, "# Samples: %Ld %s\n#\n",
|
|
|
|
stats->stats.total,
|
|
|
|
__event_name(stats->type, stats->config));
|
|
|
|
|
|
|
|
perf_session__fprintf_hists(&stats->hists, NULL, false, stdout,
|
2010-03-05 08:51:09 -07:00
|
|
|
stats->stats.total);
|
2010-03-11 16:12:44 -07:00
|
|
|
fprintf(stdout, "\n\n");
|
|
|
|
}
|
|
|
|
|
2010-03-05 08:51:09 -07:00
|
|
|
next = rb_next(&stats->rb_node);
|
|
|
|
}
|
|
|
|
|
2010-03-11 16:12:44 -07:00
|
|
|
if (!use_browser && sort_order == default_sort_order &&
|
|
|
|
parent_pattern == default_parent_pattern) {
|
|
|
|
fprintf(stdout, "#\n# (%s)\n#\n", help);
|
2009-12-16 07:27:10 -07:00
|
|
|
|
2010-03-11 16:12:44 -07:00
|
|
|
if (show_threads) {
|
|
|
|
bool style = !strcmp(pretty_printing_style, "raw");
|
|
|
|
perf_read_values_display(stdout, &show_threads_values,
|
|
|
|
style);
|
|
|
|
perf_read_values_destroy(&show_threads_values);
|
|
|
|
}
|
2009-12-15 15:04:42 -07:00
|
|
|
}
|
2009-12-11 16:24:02 -07:00
|
|
|
out_delete:
|
|
|
|
perf_session__delete(session);
|
2009-10-07 03:47:31 -07:00
|
|
|
return ret;
|
2009-05-18 08:45:42 -07:00
|
|
|
}
|
|
|
|
|
2009-07-02 08:58:21 -07:00
|
|
|
static int
|
|
|
|
parse_callchain_opt(const struct option *opt __used, const char *arg,
|
2010-01-05 06:54:45 -07:00
|
|
|
int unset)
|
2009-07-02 08:58:21 -07:00
|
|
|
{
|
2009-07-02 11:14:33 -07:00
|
|
|
char *tok;
|
|
|
|
char *endptr;
|
|
|
|
|
2010-01-05 06:54:45 -07:00
|
|
|
/*
|
|
|
|
* --no-call-graph
|
|
|
|
*/
|
|
|
|
if (unset) {
|
|
|
|
dont_use_callchains = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-15 15:04:42 -07:00
|
|
|
symbol_conf.use_callchain = true;
|
2009-07-02 08:58:21 -07:00
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
return 0;
|
|
|
|
|
2009-07-02 11:14:33 -07:00
|
|
|
tok = strtok((char *)arg, ",");
|
|
|
|
if (!tok)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* get the output mode */
|
|
|
|
if (!strncmp(tok, "graph", strlen(arg)))
|
2009-07-04 22:39:21 -07:00
|
|
|
callchain_param.mode = CHAIN_GRAPH_ABS;
|
2009-07-02 08:58:21 -07:00
|
|
|
|
2009-07-02 11:14:33 -07:00
|
|
|
else if (!strncmp(tok, "flat", strlen(arg)))
|
2009-07-04 22:39:21 -07:00
|
|
|
callchain_param.mode = CHAIN_FLAT;
|
|
|
|
|
|
|
|
else if (!strncmp(tok, "fractal", strlen(arg)))
|
|
|
|
callchain_param.mode = CHAIN_GRAPH_REL;
|
|
|
|
|
2009-08-07 17:16:24 -07:00
|
|
|
else if (!strncmp(tok, "none", strlen(arg))) {
|
|
|
|
callchain_param.mode = CHAIN_NONE;
|
2010-01-21 18:47:50 -07:00
|
|
|
symbol_conf.use_callchain = false;
|
2009-08-07 17:16:24 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-02 08:58:21 -07:00
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
|
2009-07-02 11:14:33 -07:00
|
|
|
/* get the min percentage */
|
|
|
|
tok = strtok(NULL, ",");
|
|
|
|
if (!tok)
|
2009-07-04 22:39:21 -07:00
|
|
|
goto setup;
|
2009-07-02 11:14:33 -07:00
|
|
|
|
2009-07-04 22:39:21 -07:00
|
|
|
callchain_param.min_percent = strtod(tok, &endptr);
|
2009-07-02 11:14:33 -07:00
|
|
|
if (tok == endptr)
|
|
|
|
return -1;
|
|
|
|
|
2009-07-04 22:39:21 -07:00
|
|
|
setup:
|
|
|
|
if (register_callchain_param(&callchain_param) < 0) {
|
|
|
|
fprintf(stderr, "Can't register callchain params\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-02 08:58:21 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-18 11:35:58 -07:00
|
|
|
static const char * const report_usage[] = {
|
2009-05-26 00:17:18 -07:00
|
|
|
"perf report [<options>] <command>",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct option options[] = {
|
|
|
|
OPT_STRING('i', "input", &input_name, "file",
|
|
|
|
"input file name"),
|
2010-04-13 01:37:33 -07:00
|
|
|
OPT_INCR('v', "verbose", &verbose,
|
2009-05-26 15:46:14 -07:00
|
|
|
"be more verbose (show symbol address, etc)"),
|
2009-05-26 09:48:58 -07:00
|
|
|
OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
|
|
|
|
"dump raw trace in ASCII"),
|
2009-11-24 07:05:15 -07:00
|
|
|
OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
|
|
|
|
"file", "vmlinux pathname"),
|
2009-08-19 02:18:26 -07:00
|
|
|
OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
|
2009-11-24 07:05:15 -07:00
|
|
|
OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
|
2009-07-01 23:09:46 -07:00
|
|
|
"load module symbols - WARNING: use only with -k and LIVE kernel"),
|
2009-12-15 15:04:42 -07:00
|
|
|
OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
|
2009-07-11 08:18:37 -07:00
|
|
|
"Show a column with the number of samples"),
|
2009-08-07 04:55:24 -07:00
|
|
|
OPT_BOOLEAN('T', "threads", &show_threads,
|
|
|
|
"Show per-thread event counters"),
|
2009-08-10 06:26:32 -07:00
|
|
|
OPT_STRING(0, "pretty", &pretty_printing_style, "key",
|
|
|
|
"pretty printing style key: normal raw"),
|
2009-05-28 01:52:00 -07:00
|
|
|
OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
|
2009-06-17 22:01:03 -07:00
|
|
|
"sort by key(s): pid, comm, dso, symbol, parent"),
|
2009-12-27 16:37:04 -07:00
|
|
|
OPT_BOOLEAN('P', "full-paths", &symbol_conf.full_paths,
|
2009-05-29 09:48:59 -07:00
|
|
|
"Don't shorten the pathnames taking into account the cwd"),
|
2009-06-17 22:01:03 -07:00
|
|
|
OPT_STRING('p', "parent", &parent_pattern, "regex",
|
|
|
|
"regex filter to identify parent, see: '--sort parent'"),
|
2009-12-15 15:04:42 -07:00
|
|
|
OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
|
2009-06-18 05:32:19 -07:00
|
|
|
"Only display entries with parent-match"),
|
2009-07-16 06:44:29 -07:00
|
|
|
OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
|
2009-07-02 11:14:33 -07:00
|
|
|
"Display callchains using output_type and min percent threshold. "
|
2009-07-16 06:44:29 -07:00
|
|
|
"Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
|
2009-12-15 15:04:40 -07:00
|
|
|
OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
|
2009-06-30 15:01:20 -07:00
|
|
|
"only consider symbols in these dsos"),
|
2009-12-15 15:04:40 -07:00
|
|
|
OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
|
2009-06-30 15:01:21 -07:00
|
|
|
"only consider symbols in these comms"),
|
2009-12-15 15:04:40 -07:00
|
|
|
OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
|
2009-06-30 15:01:22 -07:00
|
|
|
"only consider these symbols"),
|
2009-12-15 15:04:40 -07:00
|
|
|
OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
|
2009-07-10 18:47:28 -07:00
|
|
|
"width[,width...]",
|
|
|
|
"don't try to adjust column width, use these fixed values"),
|
2009-12-15 15:04:41 -07:00
|
|
|
OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
|
2009-07-10 18:47:28 -07:00
|
|
|
"separator for columns, no spaces will be added between "
|
|
|
|
"columns '.' is reserved."),
|
2009-12-28 17:48:34 -07:00
|
|
|
OPT_BOOLEAN('U', "hide-unresolved", &hide_unresolved,
|
|
|
|
"Only display entries resolved to a symbol"),
|
2009-05-26 00:17:18 -07:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2009-07-01 03:37:06 -07:00
|
|
|
int cmd_report(int argc, const char **argv, const char *prefix __used)
|
2009-05-26 00:17:18 -07:00
|
|
|
{
|
2009-12-15 15:04:40 -07:00
|
|
|
argc = parse_options(argc, argv, options, report_usage, 0);
|
|
|
|
|
2010-04-01 21:59:17 -07:00
|
|
|
if (strcmp(input_name, "-") != 0)
|
|
|
|
setup_browser();
|
2009-12-15 15:04:40 -07:00
|
|
|
|
2009-12-15 15:04:39 -07:00
|
|
|
if (symbol__init() < 0)
|
2009-11-24 07:05:15 -07:00
|
|
|
return -1;
|
2009-05-26 00:17:18 -07:00
|
|
|
|
2009-12-14 15:09:29 -07:00
|
|
|
setup_sorting(report_usage, options);
|
2009-05-27 11:20:25 -07:00
|
|
|
|
2009-07-11 08:18:35 -07:00
|
|
|
if (parent_pattern != default_parent_pattern) {
|
2010-04-02 08:30:57 -07:00
|
|
|
if (sort_dimension__add("parent") < 0)
|
|
|
|
return -1;
|
2009-07-11 08:18:35 -07:00
|
|
|
sort_parent.elide = 1;
|
|
|
|
} else
|
2009-12-15 15:04:42 -07:00
|
|
|
symbol_conf.exclude_other = false;
|
2009-06-18 05:32:19 -07:00
|
|
|
|
2009-06-04 07:24:37 -07:00
|
|
|
/*
|
|
|
|
* Any (unrecognized) arguments left?
|
|
|
|
*/
|
|
|
|
if (argc)
|
|
|
|
usage_with_options(report_usage, options);
|
|
|
|
|
2009-12-15 15:04:40 -07:00
|
|
|
sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
|
|
|
|
sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
|
|
|
|
sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
|
2009-06-30 15:01:20 -07:00
|
|
|
|
2009-05-26 00:17:18 -07:00
|
|
|
return __cmd_report();
|
|
|
|
}
|