2009-06-02 13:59:57 -07:00
|
|
|
/*
|
2009-06-02 14:37:05 -07:00
|
|
|
* builtin-record.c
|
|
|
|
*
|
|
|
|
* Builtin record command: Record the profile of a workload
|
|
|
|
* (or a CPU, or a PID) into the perf.data output file - for
|
|
|
|
* later analysis via perf report.
|
2009-06-02 13:59:57 -07:00
|
|
|
*/
|
2010-02-02 20:53:14 -07:00
|
|
|
#define _FILE_OFFSET_BITS 64
|
|
|
|
|
2009-05-27 00:10:38 -07:00
|
|
|
#include "builtin.h"
|
2009-06-02 14:37:05 -07:00
|
|
|
|
|
|
|
#include "perf.h"
|
|
|
|
|
2010-02-03 11:52:05 -07:00
|
|
|
#include "util/build-id.h"
|
2009-05-01 09:29:57 -07:00
|
|
|
#include "util/util.h"
|
2009-05-26 00:17:18 -07:00
|
|
|
#include "util/parse-options.h"
|
2009-05-26 02:10:09 -07:00
|
|
|
#include "util/parse-events.h"
|
2009-05-01 09:29:57 -07:00
|
|
|
|
2009-06-25 08:05:54 -07:00
|
|
|
#include "util/header.h"
|
2009-08-12 02:07:25 -07:00
|
|
|
#include "util/event.h"
|
2011-01-11 15:56:53 -07:00
|
|
|
#include "util/evlist.h"
|
2011-01-03 11:39:04 -07:00
|
|
|
#include "util/evsel.h"
|
2009-08-16 13:05:48 -07:00
|
|
|
#include "util/debug.h"
|
2009-12-11 16:24:02 -07:00
|
|
|
#include "util/session.h"
|
perf symbols: Use the buildids if present
With this change 'perf record' will intercept PERF_RECORD_MMAP
calls, creating a linked list of DSOs, then when the session
finishes, it will traverse this list and read the buildids,
stashing them at the end of the file and will set up a new
feature bit in the header bitmask.
'perf report' will then notice this feature and populate the
'dsos' list and set the build ids.
When reading the symtabs it will refuse to load from a file that
doesn't have the same build id. This improves the
reliability of the profiler output, as symbols and profiling
data is more guaranteed to match.
Example:
[root@doppio ~]# perf report | head
/home/acme/bin/perf with build id b1ea544ac3746e7538972548a09aadecc5753868 not found, continuing without symbols
# Samples: 2621434559
#
# Overhead Command Shared Object Symbol
# ........ ............... ............................. ......
#
7.91% init [kernel] [k] read_hpet
7.64% init [kernel] [k] mwait_idle_with_hints
7.60% swapper [kernel] [k] read_hpet
7.60% swapper [kernel] [k] mwait_idle_with_hints
3.65% init [kernel] [k] 0xffffffffa02339d9
[root@doppio ~]#
In this case the 'perf' binary was an older one, vanished,
so its symbols probably wouldn't match or would cause subtly
different (and misleading) output.
Next patches will support the kernel as well, reading the build
id notes for it and the modules from /sys.
Another patch should also introduce a new plumbing command:
'perf list-buildids'
that will then be used in porcelain that is distro specific to
fetch -debuginfo packages where such buildids are present. This
will in turn allow for one to run 'perf record' in one machine
and 'perf report' in another.
Future work on having the buildid sent directly from the kernel
in the PERF_RECORD_MMAP event is needed to close races, as the
DSO can be changed during a 'perf record' session, but this
patch at least helps with non-corner cases and current/older
kernels.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Frank Ch. Eigler <fche@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Jim Keniston <jkenisto@us.ibm.com>
Cc: K. Prasad <prasad@linux.vnet.ibm.com>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roland McGrath <roland@redhat.com>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
LKML-Reference: <1257367843-26224-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-04 13:50:43 -07:00
|
|
|
#include "util/symbol.h"
|
perf tools: Fix sparse CPU numbering related bugs
At present, the perf subcommands that do system-wide monitoring
(perf stat, perf record and perf top) don't work properly unless
the online cpus are numbered 0, 1, ..., N-1. These tools ask
for the number of online cpus with sysconf(_SC_NPROCESSORS_ONLN)
and then try to create events for cpus 0, 1, ..., N-1.
This creates problems for systems where the online cpus are
numbered sparsely. For example, a POWER6 system in
single-threaded mode (i.e. only running 1 hardware thread per
core) will have only even-numbered cpus online.
This fixes the problem by reading the /sys/devices/system/cpu/online
file to find out which cpus are online. The code that does that is in
tools/perf/util/cpumap.[ch], and consists of a read_cpu_map()
function that sets up a cpumap[] array and returns the number of
online cpus. If /sys/devices/system/cpu/online can't be read or
can't be parsed successfully, it falls back to using sysconf to
ask how many cpus are online and sets up an identity map in cpumap[].
The perf record, perf stat and perf top code then calls
read_cpu_map() in the system-wide monitoring case (instead of
sysconf) and uses cpumap[] to get the cpu numbers to pass to
perf_event_open.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Cc: Anton Blanchard <anton@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@infradead.org>
LKML-Reference: <20100310093609.GA3959@brick.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-03-10 02:36:09 -07:00
|
|
|
#include "util/cpumap.h"
|
2011-01-18 10:15:24 -07:00
|
|
|
#include "util/thread_map.h"
|
2009-06-25 08:05:54 -07:00
|
|
|
|
2009-06-02 06:52:24 -07:00
|
|
|
#include <unistd.h>
|
2009-04-08 06:01:31 -07:00
|
|
|
#include <sched.h>
|
2010-05-18 14:29:23 -07:00
|
|
|
#include <sys/mman.h>
|
2009-04-08 06:01:31 -07:00
|
|
|
|
2011-01-03 11:39:04 -07:00
|
|
|
#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
|
|
|
|
|
2010-04-14 10:42:07 -07:00
|
|
|
enum write_mode_t {
|
|
|
|
WRITE_FORCE,
|
|
|
|
WRITE_APPEND
|
|
|
|
};
|
|
|
|
|
2010-05-17 08:20:43 -07:00
|
|
|
static u64 user_interval = ULLONG_MAX;
|
|
|
|
static u64 default_interval = 0;
|
2009-06-06 00:58:57 -07:00
|
|
|
|
2009-04-08 06:01:31 -07:00
|
|
|
static unsigned int page_size;
|
2011-03-30 18:35:24 -07:00
|
|
|
static unsigned int mmap_pages = UINT_MAX;
|
2010-04-14 13:09:02 -07:00
|
|
|
static unsigned int user_freq = UINT_MAX;
|
2009-10-06 06:14:21 -07:00
|
|
|
static int freq = 1000;
|
2009-04-08 06:01:31 -07:00
|
|
|
static int output;
|
2010-04-01 21:59:16 -07:00
|
|
|
static int pipe_output = 0;
|
2011-01-16 09:14:45 -07:00
|
|
|
static const char *output_name = NULL;
|
2009-10-06 06:14:21 -07:00
|
|
|
static int group = 0;
|
2010-05-17 11:39:16 -07:00
|
|
|
static int realtime_prio = 0;
|
perf record: Add "nodelay" mode, disabled by default
Sometimes there is a need to use perf in "live-log" mode. The problem
is, for seldom events, actual info output is largely delayed because
perf-record reads sample data in whole pages.
So for such scenarious, add flag for perf-record to go in "nodelay"
mode. To track e.g. what's going on in icmp_rcv while ping is running
Use it with something like this:
(1) $ perf probe -L icmp_rcv | grep -U8 '^ *43\>'
goto error;
}
38 if (!pskb_pull(skb, sizeof(*icmph)))
goto error;
icmph = icmp_hdr(skb);
43 ICMPMSGIN_INC_STATS_BH(net, icmph->type);
/*
* 18 is the highest 'known' ICMP type. Anything else is a mystery
*
* RFC 1122: 3.2.2 Unknown ICMP messages types MUST be silently
* discarded.
*/
50 if (icmph->type > NR_ICMP_TYPES)
goto error;
$ perf probe icmp_rcv:43 'type=icmph->type'
(2) $ cat trace-icmp.py
[...]
def trace_begin():
print "in trace_begin"
def trace_end():
print "in trace_end"
def probe__icmp_rcv(event_name, context, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
__probe_ip, type):
print_header(event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)
print "__probe_ip=%u, type=%u\n" % \
(__probe_ip, type),
[...]
(3) $ perf record -a -D -e probe:icmp_rcv -o - | \
perf script -i - -s trace-icmp.py
Thanks to Peter Zijlstra for pointing how to do it.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>, Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <20110112140613.GA11698@tugrik.mns.mnsspb.ru>
Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-01-12 07:59:36 -07:00
|
|
|
static bool nodelay = false;
|
2010-04-13 01:37:33 -07:00
|
|
|
static bool raw_samples = false;
|
2010-12-02 05:25:28 -07:00
|
|
|
static bool sample_id_all_avail = true;
|
2010-04-13 01:37:33 -07:00
|
|
|
static bool system_wide = false;
|
2009-10-06 06:14:21 -07:00
|
|
|
static pid_t target_pid = -1;
|
2010-03-18 07:36:05 -07:00
|
|
|
static pid_t target_tid = -1;
|
2009-10-06 06:14:21 -07:00
|
|
|
static pid_t child_pid = -1;
|
2010-05-12 01:40:01 -07:00
|
|
|
static bool no_inherit = false;
|
2010-04-14 10:42:07 -07:00
|
|
|
static enum write_mode_t write_mode = WRITE_FORCE;
|
2010-04-13 01:37:33 -07:00
|
|
|
static bool call_graph = false;
|
|
|
|
static bool inherit_stat = false;
|
|
|
|
static bool no_samples = false;
|
|
|
|
static bool sample_address = false;
|
2010-12-02 05:25:28 -07:00
|
|
|
static bool sample_time = false;
|
2010-06-17 02:39:01 -07:00
|
|
|
static bool no_buildid = false;
|
2010-11-26 14:39:15 -07:00
|
|
|
static bool no_buildid_cache = false;
|
2011-01-11 15:56:53 -07:00
|
|
|
static struct perf_evlist *evsel_list;
|
2009-10-06 06:14:21 -07:00
|
|
|
|
|
|
|
static long samples = 0;
|
|
|
|
static u64 bytes_written = 0;
|
2009-06-06 00:58:57 -07:00
|
|
|
|
2009-10-06 06:14:21 -07:00
|
|
|
static int file_new = 1;
|
2010-02-03 11:52:05 -07:00
|
|
|
static off_t post_processing_offset;
|
2009-06-25 08:05:54 -07:00
|
|
|
|
2009-12-11 16:24:02 -07:00
|
|
|
static struct perf_session *session;
|
2010-05-28 03:00:01 -07:00
|
|
|
static const char *cpu_list;
|
2009-06-18 14:22:55 -07:00
|
|
|
|
2010-04-01 21:59:21 -07:00
|
|
|
static void advance_output(size_t size)
|
|
|
|
{
|
|
|
|
bytes_written += size;
|
|
|
|
}
|
|
|
|
|
2009-06-18 14:22:55 -07:00
|
|
|
static void write_output(void *buf, size_t size)
|
|
|
|
{
|
|
|
|
while (size) {
|
|
|
|
int ret = write(output, buf, size);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
die("failed to write");
|
|
|
|
|
|
|
|
size -= ret;
|
|
|
|
buf += ret;
|
|
|
|
|
|
|
|
bytes_written += ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-29 09:01:45 -07:00
|
|
|
static int process_synthesized_event(union perf_event *event,
|
2011-01-29 08:02:00 -07:00
|
|
|
struct perf_sample *sample __used,
|
2009-12-13 14:50:24 -07:00
|
|
|
struct perf_session *self __used)
|
2009-10-26 14:23:18 -07:00
|
|
|
{
|
2010-02-03 11:52:05 -07:00
|
|
|
write_output(event, event->header.size);
|
2009-10-26 14:23:18 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-12 12:07:28 -07:00
|
|
|
static void mmap_read(struct perf_mmap *md)
|
2009-04-08 06:01:31 -07:00
|
|
|
{
|
2011-01-12 12:07:28 -07:00
|
|
|
unsigned int head = perf_mmap__read_head(md);
|
2009-04-08 06:01:31 -07:00
|
|
|
unsigned int old = md->prev;
|
|
|
|
unsigned char *data = md->base + page_size;
|
|
|
|
unsigned long size;
|
|
|
|
void *buf;
|
|
|
|
|
2011-01-28 09:49:19 -07:00
|
|
|
if (old == head)
|
|
|
|
return;
|
|
|
|
|
|
|
|
samples++;
|
2009-04-08 06:01:31 -07:00
|
|
|
|
|
|
|
size = head - old;
|
|
|
|
|
|
|
|
if ((old & md->mask) + size != (head & md->mask)) {
|
|
|
|
buf = &data[old & md->mask];
|
|
|
|
size = md->mask + 1 - (old & md->mask);
|
|
|
|
old += size;
|
2009-06-03 10:27:19 -07:00
|
|
|
|
2010-02-03 11:52:05 -07:00
|
|
|
write_output(buf, size);
|
2009-04-08 06:01:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
buf = &data[old & md->mask];
|
|
|
|
size = head - old;
|
|
|
|
old += size;
|
2009-06-03 10:27:19 -07:00
|
|
|
|
2010-02-03 11:52:05 -07:00
|
|
|
write_output(buf, size);
|
2009-04-08 06:01:31 -07:00
|
|
|
|
|
|
|
md->prev = old;
|
2011-01-12 12:11:53 -07:00
|
|
|
perf_mmap__write_tail(md, old);
|
2009-04-08 06:01:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static volatile int done = 0;
|
2009-06-10 06:55:59 -07:00
|
|
|
static volatile int signr = -1;
|
2009-04-08 06:01:31 -07:00
|
|
|
|
2009-05-05 08:50:27 -07:00
|
|
|
static void sig_handler(int sig)
|
2009-04-08 06:01:31 -07:00
|
|
|
{
|
2009-05-05 08:50:27 -07:00
|
|
|
done = 1;
|
2009-06-10 06:55:59 -07:00
|
|
|
signr = sig;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sig_atexit(void)
|
|
|
|
{
|
perf record: prevent kill(0, SIGTERM);
At exit, perf record will kill the process it was profiling by sending a
SIGTERM to child_pid (if it had been initialised), but in certain situations
child_pid may be 0 and perf would mistakenly kill more processes than intended.
child_pid is set to the return of fork() to either 0 or the pid of the child.
Ordinarily this would not present an issue as the child calls execvp to spawn
the process to be profiled and would therefore never run it's sig_atexit and
never attempt to kill pid 0.
However, if a nonexistant binary had been passed in to perf record the call to
execvp would fail and child_pid would be left set to 0. The child would then
exit and it's atexit handler, finding that child_pid was initialised to 0,
would call kill(0, SIGTERM), resulting in every process within it's process
group being killed.
In the case that perf was being run directly from the shell this typically
would not be an issue as the shell isolates the process. However, if perf was
being called from another program it could kill unexpected processes, which may
even include X.
This patch changes the logic of the test for whether child_pid was initialised
to only consider positive pids as valid, thereby never attempting to kill pid
0.
Cc: David S. Miller <davem@davemloft.net>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <1276072680-17378-1-git-send-email-imunsie@au1.ibm.com>
Signed-off-by: Ian Munsie <imunsie@au1.ibm.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-06-09 01:38:00 -07:00
|
|
|
if (child_pid > 0)
|
2009-10-03 17:35:01 -07:00
|
|
|
kill(child_pid, SIGTERM);
|
|
|
|
|
2010-12-06 10:13:38 -07:00
|
|
|
if (signr == -1 || signr == SIGUSR1)
|
2009-06-10 06:55:59 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
signal(signr, SIG_DFL);
|
|
|
|
kill(getpid(), signr);
|
2009-04-08 06:01:31 -07:00
|
|
|
}
|
|
|
|
|
2011-01-12 09:28:51 -07:00
|
|
|
static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist)
|
|
|
|
{
|
|
|
|
struct perf_event_attr *attr = &evsel->attr;
|
|
|
|
int track = !evsel->idx; /* only the first counter needs these */
|
2009-06-25 08:05:54 -07:00
|
|
|
|
2011-04-14 07:20:14 -07:00
|
|
|
attr->inherit = !no_inherit;
|
2009-06-25 08:05:54 -07:00
|
|
|
attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
|
|
|
|
PERF_FORMAT_TOTAL_TIME_RUNNING |
|
|
|
|
PERF_FORMAT_ID;
|
2009-05-05 08:50:27 -07:00
|
|
|
|
2009-08-13 01:27:18 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
|
2009-06-14 06:04:15 -07:00
|
|
|
|
2011-01-11 15:56:53 -07:00
|
|
|
if (evlist->nr_entries > 1)
|
2010-03-05 08:51:05 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_ID;
|
|
|
|
|
2010-04-14 13:09:02 -07:00
|
|
|
/*
|
|
|
|
* We default some events to a 1 default interval. But keep
|
|
|
|
* it a weak assumption overridable by the user.
|
|
|
|
*/
|
|
|
|
if (!attr->sample_period || (user_freq != UINT_MAX &&
|
2010-05-17 08:20:43 -07:00
|
|
|
user_interval != ULLONG_MAX)) {
|
2010-04-14 13:09:02 -07:00
|
|
|
if (freq) {
|
|
|
|
attr->sample_type |= PERF_SAMPLE_PERIOD;
|
|
|
|
attr->freq = 1;
|
|
|
|
attr->sample_freq = freq;
|
|
|
|
} else {
|
|
|
|
attr->sample_period = default_interval;
|
|
|
|
}
|
2009-06-05 09:37:22 -07:00
|
|
|
}
|
2009-06-14 06:04:15 -07:00
|
|
|
|
2009-06-24 12:12:48 -07:00
|
|
|
if (no_samples)
|
|
|
|
attr->sample_freq = 0;
|
|
|
|
|
|
|
|
if (inherit_stat)
|
|
|
|
attr->inherit_stat = 1;
|
|
|
|
|
2010-05-18 07:30:49 -07:00
|
|
|
if (sample_address) {
|
2009-07-16 06:44:29 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_ADDR;
|
2010-05-18 07:30:49 -07:00
|
|
|
attr->mmap_data = track;
|
|
|
|
}
|
2009-07-16 06:44:29 -07:00
|
|
|
|
2009-06-14 06:04:15 -07:00
|
|
|
if (call_graph)
|
|
|
|
attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
|
|
|
|
|
2010-06-04 07:27:10 -07:00
|
|
|
if (system_wide)
|
|
|
|
attr->sample_type |= PERF_SAMPLE_CPU;
|
|
|
|
|
2010-12-25 07:12:25 -07:00
|
|
|
if (sample_id_all_avail &&
|
|
|
|
(sample_time || system_wide || !no_inherit || cpu_list))
|
2010-12-02 05:25:28 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_TIME;
|
|
|
|
|
2009-09-02 11:20:38 -07:00
|
|
|
if (raw_samples) {
|
2009-09-03 03:00:22 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_TIME;
|
2009-08-13 01:27:19 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_RAW;
|
2009-09-02 11:20:38 -07:00
|
|
|
attr->sample_type |= PERF_SAMPLE_CPU;
|
|
|
|
}
|
2009-08-06 16:25:54 -07:00
|
|
|
|
perf record: Add "nodelay" mode, disabled by default
Sometimes there is a need to use perf in "live-log" mode. The problem
is, for seldom events, actual info output is largely delayed because
perf-record reads sample data in whole pages.
So for such scenarious, add flag for perf-record to go in "nodelay"
mode. To track e.g. what's going on in icmp_rcv while ping is running
Use it with something like this:
(1) $ perf probe -L icmp_rcv | grep -U8 '^ *43\>'
goto error;
}
38 if (!pskb_pull(skb, sizeof(*icmph)))
goto error;
icmph = icmp_hdr(skb);
43 ICMPMSGIN_INC_STATS_BH(net, icmph->type);
/*
* 18 is the highest 'known' ICMP type. Anything else is a mystery
*
* RFC 1122: 3.2.2 Unknown ICMP messages types MUST be silently
* discarded.
*/
50 if (icmph->type > NR_ICMP_TYPES)
goto error;
$ perf probe icmp_rcv:43 'type=icmph->type'
(2) $ cat trace-icmp.py
[...]
def trace_begin():
print "in trace_begin"
def trace_end():
print "in trace_end"
def probe__icmp_rcv(event_name, context, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
__probe_ip, type):
print_header(event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)
print "__probe_ip=%u, type=%u\n" % \
(__probe_ip, type),
[...]
(3) $ perf record -a -D -e probe:icmp_rcv -o - | \
perf script -i - -s trace-icmp.py
Thanks to Peter Zijlstra for pointing how to do it.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>, Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <20110112140613.GA11698@tugrik.mns.mnsspb.ru>
Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-01-12 07:59:36 -07:00
|
|
|
if (nodelay) {
|
|
|
|
attr->watermark = 0;
|
|
|
|
attr->wakeup_events = 1;
|
|
|
|
}
|
|
|
|
|
2009-06-06 00:58:57 -07:00
|
|
|
attr->mmap = track;
|
|
|
|
attr->comm = track;
|
2011-01-12 09:28:51 -07:00
|
|
|
|
2010-05-12 01:40:01 -07:00
|
|
|
if (target_pid == -1 && target_tid == -1 && !system_wide) {
|
2010-03-18 07:36:04 -07:00
|
|
|
attr->disabled = 1;
|
2010-03-15 07:46:57 -07:00
|
|
|
attr->enable_on_exec = 1;
|
2010-03-18 07:36:04 -07:00
|
|
|
}
|
2011-01-12 09:28:51 -07:00
|
|
|
}
|
2010-03-15 07:46:57 -07:00
|
|
|
|
2011-03-10 07:15:54 -07:00
|
|
|
static bool perf_evlist__equal(struct perf_evlist *evlist,
|
|
|
|
struct perf_evlist *other)
|
|
|
|
{
|
|
|
|
struct perf_evsel *pos, *pair;
|
|
|
|
|
|
|
|
if (evlist->nr_entries != other->nr_entries)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
pair = list_entry(other->entries.next, struct perf_evsel, node);
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &evlist->entries, node) {
|
|
|
|
if (memcmp(&pos->attr, &pair->attr, sizeof(pos->attr) != 0))
|
|
|
|
return false;
|
|
|
|
pair = list_entry(pair->node.next, struct perf_evsel, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-01-12 09:28:51 -07:00
|
|
|
static void open_counters(struct perf_evlist *evlist)
|
|
|
|
{
|
|
|
|
struct perf_evsel *pos;
|
|
|
|
|
2011-04-14 07:20:14 -07:00
|
|
|
if (evlist->cpus->map[0] < 0)
|
|
|
|
no_inherit = true;
|
|
|
|
|
2011-01-12 09:28:51 -07:00
|
|
|
list_for_each_entry(pos, &evlist->entries, node) {
|
|
|
|
struct perf_event_attr *attr = &pos->attr;
|
|
|
|
/*
|
|
|
|
* Check if parse_single_tracepoint_event has already asked for
|
|
|
|
* PERF_SAMPLE_TIME.
|
|
|
|
*
|
|
|
|
* XXX this is kludgy but short term fix for problems introduced by
|
|
|
|
* eac23d1c that broke 'perf script' by having different sample_types
|
|
|
|
* when using multiple tracepoint events when we use a perf binary
|
|
|
|
* that tries to use sample_id_all on an older kernel.
|
|
|
|
*
|
|
|
|
* We need to move counter creation to perf_session, support
|
|
|
|
* different sample_types, etc.
|
|
|
|
*/
|
|
|
|
bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
|
2010-03-18 07:36:05 -07:00
|
|
|
|
2011-01-12 09:28:51 -07:00
|
|
|
config_attr(pos, evlist);
|
|
|
|
retry_sample_id:
|
|
|
|
attr->sample_id_all = sample_id_all_avail ? 1 : 0;
|
|
|
|
try_again:
|
2011-04-14 07:20:14 -07:00
|
|
|
if (perf_evsel__open(pos, evlist->cpus, evlist->threads, group) < 0) {
|
2010-03-18 07:36:05 -07:00
|
|
|
int err = errno;
|
|
|
|
|
2011-03-28 05:50:11 -07:00
|
|
|
if (err == EPERM || err == EACCES) {
|
|
|
|
ui__warning_paranoid();
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
} else if (err == ENODEV && cpu_list) {
|
2010-03-18 07:36:05 -07:00
|
|
|
die("No such device - did you specify"
|
|
|
|
" an out-of-range profile CPU?\n");
|
2010-12-02 05:25:28 -07:00
|
|
|
} else if (err == EINVAL && sample_id_all_avail) {
|
|
|
|
/*
|
|
|
|
* Old kernel, no attr->sample_id_type_all field
|
|
|
|
*/
|
|
|
|
sample_id_all_avail = false;
|
2010-12-25 07:12:25 -07:00
|
|
|
if (!sample_time && !raw_samples && !time_needed)
|
2010-12-08 22:33:53 -07:00
|
|
|
attr->sample_type &= ~PERF_SAMPLE_TIME;
|
|
|
|
|
2010-12-02 05:25:28 -07:00
|
|
|
goto retry_sample_id;
|
2010-03-18 07:36:05 -07:00
|
|
|
}
|
2009-06-07 08:39:02 -07:00
|
|
|
|
2010-03-18 07:36:05 -07:00
|
|
|
/*
|
|
|
|
* If it's cycles then fall back to hrtimer
|
|
|
|
* based cpu-clock-tick sw counter, which
|
|
|
|
* is always available even if no PMU support:
|
|
|
|
*/
|
|
|
|
if (attr->type == PERF_TYPE_HARDWARE
|
|
|
|
&& attr->config == PERF_COUNT_HW_CPU_CYCLES) {
|
|
|
|
|
|
|
|
if (verbose)
|
2011-03-25 12:11:11 -07:00
|
|
|
ui__warning("The cycles event is not supported, "
|
|
|
|
"trying to fall back to cpu-clock-ticks\n");
|
2010-03-18 07:36:05 -07:00
|
|
|
attr->type = PERF_TYPE_SOFTWARE;
|
|
|
|
attr->config = PERF_COUNT_SW_CPU_CLOCK;
|
|
|
|
goto try_again;
|
|
|
|
}
|
2011-03-25 12:11:11 -07:00
|
|
|
|
|
|
|
if (err == ENOENT) {
|
|
|
|
ui__warning("The %s event is not supported.\n",
|
|
|
|
event_name(pos));
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2010-03-18 07:36:05 -07:00
|
|
|
printf("\n");
|
2010-11-19 18:37:24 -07:00
|
|
|
error("sys_perf_event_open() syscall returned with %d (%s). /bin/dmesg may provide additional information.\n",
|
2011-01-12 09:28:51 -07:00
|
|
|
err, strerror(err));
|
2009-11-15 22:25:53 -07:00
|
|
|
|
|
|
|
#if defined(__i386__) || defined(__x86_64__)
|
2010-03-18 07:36:05 -07:00
|
|
|
if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
|
|
|
|
die("No hardware sampling interrupt available."
|
|
|
|
" No APIC? If so then you can boot the kernel"
|
|
|
|
" with the \"lapic\" boot parameter to"
|
|
|
|
" force-enable it.\n");
|
2009-11-15 22:25:53 -07:00
|
|
|
#endif
|
|
|
|
|
2010-03-18 07:36:05 -07:00
|
|
|
die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
|
2009-10-14 20:22:07 -07:00
|
|
|
}
|
|
|
|
}
|
2010-12-25 07:12:25 -07:00
|
|
|
|
2011-02-25 20:51:54 -07:00
|
|
|
if (perf_evlist__set_filters(evlist)) {
|
|
|
|
error("failed to set filter with %d (%s)\n", errno,
|
|
|
|
strerror(errno));
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2011-01-30 06:59:43 -07:00
|
|
|
if (perf_evlist__mmap(evlist, mmap_pages, false) < 0)
|
2011-01-14 10:50:51 -07:00
|
|
|
die("failed to mmap with %d (%s)\n", errno, strerror(errno));
|
|
|
|
|
2011-03-10 07:15:54 -07:00
|
|
|
if (file_new)
|
|
|
|
session->evlist = evlist;
|
|
|
|
else {
|
|
|
|
if (!perf_evlist__equal(session->evlist, evlist)) {
|
|
|
|
fprintf(stderr, "incompatible append\n");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
perf_session__update_sample_type(session);
|
2009-05-05 08:50:27 -07:00
|
|
|
}
|
|
|
|
|
2010-02-03 11:52:05 -07:00
|
|
|
static int process_buildids(void)
|
|
|
|
{
|
|
|
|
u64 size = lseek(output, 0, SEEK_CUR);
|
|
|
|
|
2010-03-11 11:53:11 -07:00
|
|
|
if (size == 0)
|
|
|
|
return 0;
|
|
|
|
|
2010-02-03 11:52:05 -07:00
|
|
|
session->fd = output;
|
|
|
|
return __perf_session__process_events(session, post_processing_offset,
|
|
|
|
size - post_processing_offset,
|
|
|
|
size, &build_id__mark_dso_hit_ops);
|
|
|
|
}
|
|
|
|
|
2009-06-18 14:22:55 -07:00
|
|
|
static void atexit_header(void)
|
|
|
|
{
|
2010-04-01 21:59:22 -07:00
|
|
|
if (!pipe_output) {
|
|
|
|
session->header.data_size += bytes_written;
|
2009-06-18 14:22:55 -07:00
|
|
|
|
2010-11-26 14:39:15 -07:00
|
|
|
if (!no_buildid)
|
|
|
|
process_buildids();
|
2011-03-10 07:15:54 -07:00
|
|
|
perf_session__write_header(session, evsel_list, output, true);
|
2010-07-29 10:08:55 -07:00
|
|
|
perf_session__delete(session);
|
2011-01-11 15:56:53 -07:00
|
|
|
perf_evlist__delete(evsel_list);
|
2010-07-30 14:31:28 -07:00
|
|
|
symbol__exit();
|
2010-04-01 21:59:22 -07:00
|
|
|
}
|
2009-06-18 14:22:55 -07:00
|
|
|
}
|
|
|
|
|
2011-01-29 09:01:45 -07:00
|
|
|
static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
|
2010-04-18 22:32:50 -07:00
|
|
|
{
|
|
|
|
int err;
|
2010-04-27 17:17:50 -07:00
|
|
|
struct perf_session *psession = data;
|
2010-04-18 22:32:50 -07:00
|
|
|
|
2010-04-27 17:17:50 -07:00
|
|
|
if (machine__is_host(machine))
|
2010-04-18 22:32:50 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
*As for guest kernel when processing subcommand record&report,
|
|
|
|
*we arrange module mmap prior to guest kernel mmap and trigger
|
|
|
|
*a preload dso because default guest module symbols are loaded
|
|
|
|
*from guest kallsyms instead of /lib/modules/XXX/XXX. This
|
|
|
|
*method is used to avoid symbol missing when the first addr is
|
|
|
|
*in module instead of in guest kernel.
|
|
|
|
*/
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_modules(process_synthesized_event,
|
|
|
|
psession, machine);
|
2010-04-18 22:32:50 -07:00
|
|
|
if (err < 0)
|
|
|
|
pr_err("Couldn't record guest kernel [%d]'s reference"
|
2010-04-27 17:17:50 -07:00
|
|
|
" relocation symbol.\n", machine->pid);
|
2010-04-18 22:32:50 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We use _stext for guest kernel because guest kernel's /proc/kallsyms
|
|
|
|
* have no _text sometimes.
|
|
|
|
*/
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
|
|
|
|
psession, machine, "_text");
|
2010-04-18 22:32:50 -07:00
|
|
|
if (err < 0)
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
|
|
|
|
psession, machine,
|
|
|
|
"_stext");
|
2010-04-18 22:32:50 -07:00
|
|
|
if (err < 0)
|
|
|
|
pr_err("Couldn't record guest kernel [%d]'s reference"
|
2010-04-27 17:17:50 -07:00
|
|
|
" relocation symbol.\n", machine->pid);
|
2010-04-18 22:32:50 -07:00
|
|
|
}
|
|
|
|
|
2010-05-02 13:05:29 -07:00
|
|
|
static struct perf_event_header finished_round_event = {
|
|
|
|
.size = sizeof(struct perf_event_header),
|
|
|
|
.type = PERF_RECORD_FINISHED_ROUND,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void mmap_read_all(void)
|
|
|
|
{
|
2010-05-20 05:45:26 -07:00
|
|
|
int i;
|
2010-05-02 13:05:29 -07:00
|
|
|
|
perf evlist: Fix per thread mmap setup
The PERF_EVENT_IOC_SET_OUTPUT ioctl was returning -EINVAL when using
--pid when monitoring multithreaded apps, as we can only share a ring
buffer for events on the same thread if not doing per cpu.
Fix it by using per thread ring buffers.
Tested with:
[root@felicio ~]# tuna -t 26131 -CP | nl
1 thread ctxt_switches
2 pid SCHED_ rtpri affinity voluntary nonvoluntary cmd
3 26131 OTHER 0 0,1 10814276 2397830 chromium-browse
4 642 OTHER 0 0,1 14688 0 chromium-browse
5 26148 OTHER 0 0,1 713602 115479 chromium-browse
6 26149 OTHER 0 0,1 801958 2262 chromium-browse
7 26150 OTHER 0 0,1 1271128 248 chromium-browse
8 26151 OTHER 0 0,1 3 0 chromium-browse
9 27049 OTHER 0 0,1 36796 9 chromium-browse
10 618 OTHER 0 0,1 14711 0 chromium-browse
11 661 OTHER 0 0,1 14593 0 chromium-browse
12 29048 OTHER 0 0,1 28125 0 chromium-browse
13 26143 OTHER 0 0,1 2202789 781 chromium-browse
[root@felicio ~]#
So 11 threads under pid 26131, then:
[root@felicio ~]# perf record -F 50000 --pid 26131
[root@felicio ~]# grep perf_event /proc/`pidof perf`/maps | nl
1 7fa4a2538000-7fa4a25b9000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
2 7fa4a25b9000-7fa4a263a000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
3 7fa4a263a000-7fa4a26bb000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
4 7fa4a26bb000-7fa4a273c000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
5 7fa4a273c000-7fa4a27bd000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
6 7fa4a27bd000-7fa4a283e000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
7 7fa4a283e000-7fa4a28bf000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
8 7fa4a28bf000-7fa4a2940000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
9 7fa4a2940000-7fa4a29c1000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
10 7fa4a29c1000-7fa4a2a42000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
11 7fa4a2a42000-7fa4a2ac3000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
[root@felicio ~]#
11 mmaps, one per thread since we didn't specify any CPU list, so we need one
mmap per thread and:
[root@felicio ~]# perf record -F 50000 --pid 26131
^M
^C[ perf record: Woken up 79 times to write data ]
[ perf record: Captured and wrote 20.614 MB perf.data (~900639 samples) ]
[root@felicio ~]# perf report -D | grep PERF_RECORD_SAMPLE | cut -d/ -f2 | cut -d: -f1 | sort -n | uniq -c | sort -nr | nl
1 371310 26131
2 96516 26148
3 95694 26149
4 95203 26150
5 7291 26143
6 87 27049
7 76 661
8 60 29048
9 47 618
10 43 642
[root@felicio ~]#
Ok, one of the threads, 26151 was quiescent, so no samples there, but all the
others are there.
Then, if I specify one CPU:
[root@felicio ~]# perf record -F 50000 --pid 26131 --cpu 1
^C[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.680 MB perf.data (~29730 samples) ]
[root@felicio ~]# perf report -D | grep PERF_RECORD_SAMPLE | cut -d/ -f2 | cut -d: -f1 | sort -n | uniq -c | sort -nr | nl
1 8444 26131
2 2584 26149
3 2518 26148
4 2324 26150
5 123 26143
6 9 661
7 9 29048
[root@felicio ~]#
This machine has two cores, so fewer threads appeared on the radar, and:
[root@felicio ~]# grep perf_event /proc/`pidof perf`/maps | nl
1 7f484b922000-7f484b9a3000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
[root@felicio ~]#
Just one mmap, as now we can use just one per-cpu buffer instead of the
per-thread needed in the previous case.
For global profiling:
[root@felicio ~]# perf record -F 50000 -a
^C[ perf record: Woken up 26 times to write data ]
[ perf record: Captured and wrote 7.128 MB perf.data (~311412 samples) ]
[root@felicio ~]# grep perf_event /proc/`pidof perf`/maps | nl
1 7fb49b435000-7fb49b4b6000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
2 7fb49b4b6000-7fb49b537000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
[root@felicio ~]#
It uses per-cpu buffers.
For just one thread:
[root@felicio ~]# perf record -F 50000 --tid 26148
^C[ perf record: Woken up 2 times to write data ]
[ perf record: Captured and wrote 0.330 MB perf.data (~14426 samples) ]
[root@felicio ~]# perf report -D | grep PERF_RECORD_SAMPLE | cut -d/ -f2 | cut -d: -f1 | sort -n | uniq -c | sort -nr | nl
1 9969 26148
[root@felicio ~]#
[root@felicio ~]# grep perf_event /proc/`pidof perf`/maps | nl
1 7f286a51b000-7f286a59c000 rwxs 00000000 00:09 4064 anon_inode:[perf_event]
[root@felicio ~]#
Tested-by: David Ahern <dsahern@gmail.com>
Tested-by: Lin Ming <ming.m.lin@intel.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Link: http://lkml.kernel.org/r/20110426204401.GB1746@ghostprotocols.net
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-05-15 05:39:00 -07:00
|
|
|
for (i = 0; i < evsel_list->nr_mmaps; i++) {
|
2011-01-14 10:50:51 -07:00
|
|
|
if (evsel_list->mmap[i].base)
|
|
|
|
mmap_read(&evsel_list->mmap[i]);
|
2010-05-02 13:05:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
|
|
|
|
write_output(&finished_round_event, sizeof(finished_round_event));
|
|
|
|
}
|
|
|
|
|
2009-12-27 16:36:57 -07:00
|
|
|
static int __cmd_record(int argc, const char **argv)
|
2009-05-05 08:50:27 -07:00
|
|
|
{
|
2011-01-03 11:39:04 -07:00
|
|
|
int i;
|
2009-06-02 13:59:57 -07:00
|
|
|
struct stat st;
|
|
|
|
int flags;
|
2009-11-19 09:55:55 -07:00
|
|
|
int err;
|
2009-09-17 10:59:05 -07:00
|
|
|
unsigned long waking = 0;
|
2009-12-16 09:55:55 -07:00
|
|
|
int child_ready_pipe[2], go_pipe[2];
|
2010-03-18 07:36:04 -07:00
|
|
|
const bool forks = argc > 0;
|
2009-12-16 09:55:55 -07:00
|
|
|
char buf;
|
2010-04-27 17:17:50 -07:00
|
|
|
struct machine *machine;
|
2009-04-08 06:01:31 -07:00
|
|
|
|
|
|
|
page_size = sysconf(_SC_PAGE_SIZE);
|
|
|
|
|
2009-06-18 14:22:55 -07:00
|
|
|
atexit(sig_atexit);
|
|
|
|
signal(SIGCHLD, sig_handler);
|
|
|
|
signal(SIGINT, sig_handler);
|
2010-12-06 10:13:38 -07:00
|
|
|
signal(SIGUSR1, sig_handler);
|
2009-06-18 14:22:55 -07:00
|
|
|
|
2009-12-27 16:36:57 -07:00
|
|
|
if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
|
2009-12-16 09:55:55 -07:00
|
|
|
perror("failed to create pipes");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2011-01-16 09:14:45 -07:00
|
|
|
if (!output_name) {
|
|
|
|
if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
|
|
|
|
pipe_output = 1;
|
|
|
|
else
|
|
|
|
output_name = "perf.data";
|
|
|
|
}
|
|
|
|
if (output_name) {
|
|
|
|
if (!strcmp(output_name, "-"))
|
|
|
|
pipe_output = 1;
|
|
|
|
else if (!stat(output_name, &st) && st.st_size) {
|
|
|
|
if (write_mode == WRITE_FORCE) {
|
|
|
|
char oldname[PATH_MAX];
|
|
|
|
snprintf(oldname, sizeof(oldname), "%s.old",
|
|
|
|
output_name);
|
|
|
|
unlink(oldname);
|
|
|
|
rename(output_name, oldname);
|
|
|
|
}
|
|
|
|
} else if (write_mode == WRITE_APPEND) {
|
|
|
|
write_mode = WRITE_FORCE;
|
2009-08-07 05:16:01 -07:00
|
|
|
}
|
2009-06-02 06:52:24 -07:00
|
|
|
}
|
|
|
|
|
2010-02-04 01:46:42 -07:00
|
|
|
flags = O_CREAT|O_RDWR;
|
2010-04-14 10:42:07 -07:00
|
|
|
if (write_mode == WRITE_APPEND)
|
2009-06-18 14:22:55 -07:00
|
|
|
file_new = 0;
|
2009-06-02 13:59:57 -07:00
|
|
|
else
|
|
|
|
flags |= O_TRUNC;
|
|
|
|
|
2010-04-01 21:59:16 -07:00
|
|
|
if (pipe_output)
|
|
|
|
output = STDOUT_FILENO;
|
|
|
|
else
|
|
|
|
output = open(output_name, flags, S_IRUSR | S_IWUSR);
|
2009-04-08 06:01:31 -07:00
|
|
|
if (output < 0) {
|
|
|
|
perror("failed to create output file");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2010-04-14 10:42:07 -07:00
|
|
|
session = perf_session__new(output_name, O_WRONLY,
|
2010-12-09 20:09:16 -07:00
|
|
|
write_mode == WRITE_FORCE, false, NULL);
|
2009-12-11 16:24:02 -07:00
|
|
|
if (session == NULL) {
|
2009-11-16 20:18:11 -07:00
|
|
|
pr_err("Not enough memory for reading perf file header\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-11-26 14:39:15 -07:00
|
|
|
if (!no_buildid)
|
|
|
|
perf_header__set_feat(&session->header, HEADER_BUILD_ID);
|
|
|
|
|
2009-11-19 09:55:55 -07:00
|
|
|
if (!file_new) {
|
2011-03-10 07:15:54 -07:00
|
|
|
err = perf_session__read_header(session, output);
|
2009-11-19 09:55:55 -07:00
|
|
|
if (err < 0)
|
2010-07-29 10:08:55 -07:00
|
|
|
goto out_delete_session;
|
2009-11-19 09:55:55 -07:00
|
|
|
}
|
|
|
|
|
2011-01-11 15:56:53 -07:00
|
|
|
if (have_tracepoints(&evsel_list->entries))
|
2009-12-11 16:24:02 -07:00
|
|
|
perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
|
2009-10-06 14:36:47 -07:00
|
|
|
|
2011-03-30 18:35:24 -07:00
|
|
|
/* 512 kiB: default amount of unprivileged mlocked memory */
|
|
|
|
if (mmap_pages == UINT_MAX)
|
|
|
|
mmap_pages = (512 * 1024) / page_size;
|
|
|
|
|
2009-12-27 16:36:57 -07:00
|
|
|
if (forks) {
|
2010-03-18 07:36:04 -07:00
|
|
|
child_pid = fork();
|
2010-05-31 14:18:18 -07:00
|
|
|
if (child_pid < 0) {
|
2009-12-16 09:55:55 -07:00
|
|
|
perror("failed to fork");
|
|
|
|
exit(-1);
|
|
|
|
}
|
2009-06-25 08:05:54 -07:00
|
|
|
|
2010-03-18 07:36:04 -07:00
|
|
|
if (!child_pid) {
|
2010-04-01 21:59:16 -07:00
|
|
|
if (pipe_output)
|
|
|
|
dup2(2, 1);
|
2009-12-16 09:55:55 -07:00
|
|
|
close(child_ready_pipe[0]);
|
|
|
|
close(go_pipe[1]);
|
|
|
|
fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a dummy execvp to get the PLT entry resolved,
|
|
|
|
* so we avoid the resolver overhead on the real
|
|
|
|
* execvp call.
|
|
|
|
*/
|
|
|
|
execvp("", (char **)argv);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell the parent we're ready to go
|
|
|
|
*/
|
|
|
|
close(child_ready_pipe[1]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait until the parent tells us to go.
|
|
|
|
*/
|
|
|
|
if (read(go_pipe[0], &buf, 1) == -1)
|
|
|
|
perror("unable to read pipe");
|
|
|
|
|
|
|
|
execvp(argv[0], (char **)argv);
|
|
|
|
|
|
|
|
perror(argv[0]);
|
2010-12-06 10:13:38 -07:00
|
|
|
kill(getppid(), SIGUSR1);
|
2009-12-16 09:55:55 -07:00
|
|
|
exit(-1);
|
2009-08-12 02:18:01 -07:00
|
|
|
}
|
2009-12-16 09:55:55 -07:00
|
|
|
|
2010-03-18 07:36:05 -07:00
|
|
|
if (!system_wide && target_tid == -1 && target_pid == -1)
|
2011-01-30 06:59:43 -07:00
|
|
|
evsel_list->threads->map[0] = child_pid;
|
2010-03-18 07:36:05 -07:00
|
|
|
|
2009-12-16 09:55:55 -07:00
|
|
|
close(child_ready_pipe[1]);
|
|
|
|
close(go_pipe[0]);
|
|
|
|
/*
|
|
|
|
* wait for child to settle
|
|
|
|
*/
|
|
|
|
if (read(child_ready_pipe[0], &buf, 1) == -1) {
|
|
|
|
perror("unable to read pipe");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
close(child_ready_pipe[0]);
|
|
|
|
}
|
|
|
|
|
2011-01-12 09:28:51 -07:00
|
|
|
open_counters(evsel_list);
|
2009-04-08 06:01:31 -07:00
|
|
|
|
2011-02-17 07:18:42 -07:00
|
|
|
/*
|
|
|
|
* perf_session__delete(session) will be called at atexit_header()
|
|
|
|
*/
|
|
|
|
atexit(atexit_header);
|
|
|
|
|
2010-04-01 21:59:16 -07:00
|
|
|
if (pipe_output) {
|
|
|
|
err = perf_header__write_pipe(output);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
} else if (file_new) {
|
2011-03-10 07:15:54 -07:00
|
|
|
err = perf_session__write_header(session, evsel_list,
|
|
|
|
output, false);
|
2009-11-19 09:55:56 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2010-01-05 11:50:31 -07:00
|
|
|
}
|
|
|
|
|
2010-02-03 11:52:05 -07:00
|
|
|
post_processing_offset = lseek(output, 0, SEEK_CUR);
|
|
|
|
|
2010-04-01 21:59:19 -07:00
|
|
|
if (pipe_output) {
|
2011-03-10 07:15:54 -07:00
|
|
|
err = perf_session__synthesize_attrs(session,
|
|
|
|
process_synthesized_event);
|
2010-04-01 21:59:19 -07:00
|
|
|
if (err < 0) {
|
|
|
|
pr_err("Couldn't synthesize attrs.\n");
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-01 21:59:20 -07:00
|
|
|
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_event_types(process_synthesized_event,
|
|
|
|
session);
|
2010-04-01 21:59:20 -07:00
|
|
|
if (err < 0) {
|
|
|
|
pr_err("Couldn't synthesize event_types.\n");
|
|
|
|
return err;
|
|
|
|
}
|
2010-04-01 21:59:21 -07:00
|
|
|
|
2011-01-11 15:56:53 -07:00
|
|
|
if (have_tracepoints(&evsel_list->entries)) {
|
2010-05-02 22:14:48 -07:00
|
|
|
/*
|
|
|
|
* FIXME err <= 0 here actually means that
|
|
|
|
* there were no tracepoints so its not really
|
|
|
|
* an error, just that we don't need to
|
|
|
|
* synthesize anything. We really have to
|
|
|
|
* return this more properly and also
|
|
|
|
* propagate errors that now are calling die()
|
|
|
|
*/
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_tracing_data(output, evsel_list,
|
|
|
|
process_synthesized_event,
|
|
|
|
session);
|
2010-05-02 22:14:48 -07:00
|
|
|
if (err <= 0) {
|
|
|
|
pr_err("Couldn't record tracing data.\n");
|
|
|
|
return err;
|
|
|
|
}
|
2010-05-02 09:37:24 -07:00
|
|
|
advance_output(err);
|
2010-05-02 22:14:48 -07:00
|
|
|
}
|
2010-04-01 21:59:19 -07:00
|
|
|
}
|
|
|
|
|
2010-04-27 17:17:50 -07:00
|
|
|
machine = perf_session__find_host_machine(session);
|
|
|
|
if (!machine) {
|
2010-04-18 22:32:50 -07:00
|
|
|
pr_err("Couldn't find native kernel information.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
|
|
|
|
session, machine, "_text");
|
2010-03-30 14:27:39 -07:00
|
|
|
if (err < 0)
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
|
|
|
|
session, machine, "_stext");
|
2010-11-22 09:01:55 -07:00
|
|
|
if (err < 0)
|
|
|
|
pr_err("Couldn't record kernel reference relocation symbol\n"
|
|
|
|
"Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
|
|
|
|
"Check /proc/kallsyms permission or run as root.\n");
|
perf tools: Encode kernel module mappings in perf.data
We were always looking at the running machine /proc/modules,
even when processing a perf.data file, which only makes sense
when we're doing 'perf record' and 'perf report' on the same
machine, and in close sucession, or if we don't use modules at
all, right Peter? ;-)
Now, at 'perf record' time we read /proc/modules, find the long
path for modules, and put them as PERF_MMAP events, just like we
did to encode the reloc reference symbol for vmlinux. Talking
about that now it is encoded in .pgoff, so that we can use
.{start,len} to store the address boundaries for the kernel so
that when we reconstruct the kmaps tree we can do lookups right
away, without having to fixup the end of the kernel maps like we
did in the past (and now only in perf record).
One more step in the 'perf archive' direction when we'll finally
be able to collect data in one machine and analyse in another.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1263396139-4798-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-01-13 08:22:17 -07:00
|
|
|
|
2011-01-29 09:01:45 -07:00
|
|
|
err = perf_event__synthesize_modules(process_synthesized_event,
|
|
|
|
session, machine);
|
2010-11-22 09:01:55 -07:00
|
|
|
if (err < 0)
|
|
|
|
pr_err("Couldn't record kernel module information.\n"
|
|
|
|
"Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
|
|
|
|
"Check /proc/modules permission or run as root.\n");
|
|
|
|
|
2010-04-18 22:32:50 -07:00
|
|
|
if (perf_guest)
|
2011-01-29 09:01:45 -07:00
|
|
|
perf_session__process_machines(session,
|
|
|
|
perf_event__synthesize_guest_os);
|
2009-06-25 08:05:54 -07:00
|
|
|
|
2010-06-16 11:59:01 -07:00
|
|
|
if (!system_wide)
|
2011-02-11 06:45:54 -07:00
|
|
|
perf_event__synthesize_thread_map(evsel_list->threads,
|
|
|
|
process_synthesized_event,
|
|
|
|
session);
|
2009-10-26 14:23:18 -07:00
|
|
|
else
|
2011-01-29 09:01:45 -07:00
|
|
|
perf_event__synthesize_threads(process_synthesized_event,
|
|
|
|
session);
|
2009-06-25 08:05:54 -07:00
|
|
|
|
2009-04-08 06:01:31 -07:00
|
|
|
if (realtime_prio) {
|
|
|
|
struct sched_param param;
|
|
|
|
|
|
|
|
param.sched_priority = realtime_prio;
|
|
|
|
if (sched_setscheduler(0, SCHED_FIFO, ¶m)) {
|
2009-10-21 12:34:06 -07:00
|
|
|
pr_err("Could not set realtime priority.\n");
|
2009-04-08 06:01:31 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-16 09:55:55 -07:00
|
|
|
/*
|
|
|
|
* Let the child rip
|
|
|
|
*/
|
2009-12-27 16:36:57 -07:00
|
|
|
if (forks)
|
|
|
|
close(go_pipe[1]);
|
2009-12-16 09:55:55 -07:00
|
|
|
|
2009-06-24 12:12:48 -07:00
|
|
|
for (;;) {
|
2009-06-05 05:29:10 -07:00
|
|
|
int hits = samples;
|
2010-03-18 07:36:05 -07:00
|
|
|
int thread;
|
2009-04-08 06:01:31 -07:00
|
|
|
|
2010-05-02 13:05:29 -07:00
|
|
|
mmap_read_all();
|
2009-04-08 06:01:31 -07:00
|
|
|
|
2009-06-24 12:12:48 -07:00
|
|
|
if (hits == samples) {
|
|
|
|
if (done)
|
|
|
|
break;
|
2011-01-11 17:30:02 -07:00
|
|
|
err = poll(evsel_list->pollfd, evsel_list->nr_fds, -1);
|
2009-09-17 10:59:05 -07:00
|
|
|
waking++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (done) {
|
2011-01-30 06:59:43 -07:00
|
|
|
for (i = 0; i < evsel_list->cpus->nr; i++) {
|
2011-01-03 11:39:04 -07:00
|
|
|
struct perf_evsel *pos;
|
|
|
|
|
2011-01-11 15:56:53 -07:00
|
|
|
list_for_each_entry(pos, &evsel_list->entries, node) {
|
2010-03-18 07:36:05 -07:00
|
|
|
for (thread = 0;
|
2011-01-30 06:59:43 -07:00
|
|
|
thread < evsel_list->threads->nr;
|
2010-03-18 07:36:05 -07:00
|
|
|
thread++)
|
2011-01-03 11:39:04 -07:00
|
|
|
ioctl(FD(pos, i, thread),
|
2010-03-18 07:36:05 -07:00
|
|
|
PERF_EVENT_IOC_DISABLE);
|
|
|
|
}
|
2009-09-17 10:59:05 -07:00
|
|
|
}
|
2009-06-24 12:12:48 -07:00
|
|
|
}
|
2009-04-08 06:01:31 -07:00
|
|
|
}
|
|
|
|
|
2010-12-06 10:13:38 -07:00
|
|
|
if (quiet || signr == SIGUSR1)
|
2010-10-26 10:20:09 -07:00
|
|
|
return 0;
|
|
|
|
|
2009-09-17 10:59:05 -07:00
|
|
|
fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
|
|
|
|
|
2009-06-03 10:27:19 -07:00
|
|
|
/*
|
|
|
|
* Approximate RIP event size: 24 bytes.
|
|
|
|
*/
|
|
|
|
fprintf(stderr,
|
2011-01-22 15:37:02 -07:00
|
|
|
"[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
|
2009-06-03 10:27:19 -07:00
|
|
|
(double)bytes_written / 1024.0 / 1024.0,
|
|
|
|
output_name,
|
|
|
|
bytes_written / 24);
|
2009-06-02 14:43:11 -07:00
|
|
|
|
2009-04-08 06:01:31 -07:00
|
|
|
return 0;
|
2010-07-29 10:08:55 -07:00
|
|
|
|
|
|
|
out_delete_session:
|
|
|
|
perf_session__delete(session);
|
|
|
|
return err;
|
2009-04-08 06:01:31 -07:00
|
|
|
}
|
2009-05-26 00:17:18 -07:00
|
|
|
|
|
|
|
static const char * const record_usage[] = {
|
2009-05-28 07:25:34 -07:00
|
|
|
"perf record [<options>] [<command>]",
|
|
|
|
"perf record [<options>] -- <command> [<options>]",
|
2009-05-26 00:17:18 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2010-04-14 10:42:07 -07:00
|
|
|
static bool force, append_file;
|
|
|
|
|
2010-11-10 07:11:30 -07:00
|
|
|
const struct option record_options[] = {
|
2011-01-11 15:56:53 -07:00
|
|
|
OPT_CALLBACK('e', "event", &evsel_list, "event",
|
2009-06-06 03:24:17 -07:00
|
|
|
"event selector. use 'perf list' to list available events",
|
|
|
|
parse_events),
|
2011-01-11 15:56:53 -07:00
|
|
|
OPT_CALLBACK(0, "filter", &evsel_list, "filter",
|
2009-10-14 20:22:07 -07:00
|
|
|
"event filter", parse_filter),
|
2009-05-26 00:17:18 -07:00
|
|
|
OPT_INTEGER('p', "pid", &target_pid,
|
2010-03-18 07:36:05 -07:00
|
|
|
"record events on existing process id"),
|
|
|
|
OPT_INTEGER('t', "tid", &target_tid,
|
|
|
|
"record events on existing thread id"),
|
2009-05-26 00:17:18 -07:00
|
|
|
OPT_INTEGER('r', "realtime", &realtime_prio,
|
|
|
|
"collect data with this RT SCHED_FIFO priority"),
|
perf record: Add "nodelay" mode, disabled by default
Sometimes there is a need to use perf in "live-log" mode. The problem
is, for seldom events, actual info output is largely delayed because
perf-record reads sample data in whole pages.
So for such scenarious, add flag for perf-record to go in "nodelay"
mode. To track e.g. what's going on in icmp_rcv while ping is running
Use it with something like this:
(1) $ perf probe -L icmp_rcv | grep -U8 '^ *43\>'
goto error;
}
38 if (!pskb_pull(skb, sizeof(*icmph)))
goto error;
icmph = icmp_hdr(skb);
43 ICMPMSGIN_INC_STATS_BH(net, icmph->type);
/*
* 18 is the highest 'known' ICMP type. Anything else is a mystery
*
* RFC 1122: 3.2.2 Unknown ICMP messages types MUST be silently
* discarded.
*/
50 if (icmph->type > NR_ICMP_TYPES)
goto error;
$ perf probe icmp_rcv:43 'type=icmph->type'
(2) $ cat trace-icmp.py
[...]
def trace_begin():
print "in trace_begin"
def trace_end():
print "in trace_end"
def probe__icmp_rcv(event_name, context, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
__probe_ip, type):
print_header(event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)
print "__probe_ip=%u, type=%u\n" % \
(__probe_ip, type),
[...]
(3) $ perf record -a -D -e probe:icmp_rcv -o - | \
perf script -i - -s trace-icmp.py
Thanks to Peter Zijlstra for pointing how to do it.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>, Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <20110112140613.GA11698@tugrik.mns.mnsspb.ru>
Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-01-12 07:59:36 -07:00
|
|
|
OPT_BOOLEAN('D', "no-delay", &nodelay,
|
|
|
|
"collect data without buffering"),
|
2009-08-13 01:27:19 -07:00
|
|
|
OPT_BOOLEAN('R', "raw-samples", &raw_samples,
|
|
|
|
"collect raw sample records from all opened counters"),
|
2009-05-26 00:17:18 -07:00
|
|
|
OPT_BOOLEAN('a', "all-cpus", &system_wide,
|
|
|
|
"system-wide collection from all CPUs"),
|
2009-06-02 13:59:57 -07:00
|
|
|
OPT_BOOLEAN('A', "append", &append_file,
|
|
|
|
"append to the output file to do incremental profiling"),
|
2010-05-28 03:00:01 -07:00
|
|
|
OPT_STRING('C', "cpu", &cpu_list, "cpu",
|
|
|
|
"list of cpus to monitor"),
|
2009-06-02 06:52:24 -07:00
|
|
|
OPT_BOOLEAN('f', "force", &force,
|
2010-04-14 10:42:07 -07:00
|
|
|
"overwrite existing data file (deprecated)"),
|
2010-05-17 08:20:43 -07:00
|
|
|
OPT_U64('c', "count", &user_interval, "event period to sample"),
|
2009-06-02 13:59:57 -07:00
|
|
|
OPT_STRING('o', "output", &output_name, "file",
|
|
|
|
"output file name"),
|
2010-05-12 01:40:01 -07:00
|
|
|
OPT_BOOLEAN('i', "no-inherit", &no_inherit,
|
|
|
|
"child tasks do not inherit counters"),
|
2010-05-17 11:39:16 -07:00
|
|
|
OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
|
|
|
|
OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
|
2009-06-14 06:04:15 -07:00
|
|
|
OPT_BOOLEAN('g', "call-graph", &call_graph,
|
|
|
|
"do call-graph (stack chain/backtrace) recording"),
|
2010-04-13 01:37:33 -07:00
|
|
|
OPT_INCR('v', "verbose", &verbose,
|
2009-06-07 08:39:02 -07:00
|
|
|
"be more verbose (show counter open errors, etc)"),
|
2010-10-26 10:20:09 -07:00
|
|
|
OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
|
2009-06-24 12:12:48 -07:00
|
|
|
OPT_BOOLEAN('s', "stat", &inherit_stat,
|
|
|
|
"per thread counts"),
|
2009-07-16 06:44:29 -07:00
|
|
|
OPT_BOOLEAN('d', "data", &sample_address,
|
|
|
|
"Sample addresses"),
|
2010-12-02 05:25:28 -07:00
|
|
|
OPT_BOOLEAN('T', "timestamp", &sample_time, "Sample timestamps"),
|
2009-06-24 12:12:48 -07:00
|
|
|
OPT_BOOLEAN('n', "no-samples", &no_samples,
|
|
|
|
"don't sample"),
|
2010-11-26 14:39:15 -07:00
|
|
|
OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
|
2010-06-17 02:39:01 -07:00
|
|
|
"do not update the buildid cache"),
|
2010-11-26 14:39:15 -07:00
|
|
|
OPT_BOOLEAN('B', "no-buildid", &no_buildid,
|
|
|
|
"do not collect buildids in perf.data"),
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 02:20:01 -07:00
|
|
|
OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
|
|
|
|
"monitor event in cgroup name only",
|
|
|
|
parse_cgroups),
|
2009-05-26 00:17:18 -07:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2009-07-01 03:37:06 -07:00
|
|
|
int cmd_record(int argc, const char **argv, const char *prefix __used)
|
2009-05-26 00:17:18 -07:00
|
|
|
{
|
2011-01-03 11:39:04 -07:00
|
|
|
int err = -ENOMEM;
|
|
|
|
struct perf_evsel *pos;
|
2009-05-26 00:17:18 -07:00
|
|
|
|
2011-01-30 06:59:43 -07:00
|
|
|
evsel_list = perf_evlist__new(NULL, NULL);
|
2011-01-11 15:56:53 -07:00
|
|
|
if (evsel_list == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-11-10 07:11:30 -07:00
|
|
|
argc = parse_options(argc, argv, record_options, record_usage,
|
2009-12-15 15:04:40 -07:00
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
2010-03-18 07:36:05 -07:00
|
|
|
if (!argc && target_pid == -1 && target_tid == -1 &&
|
2010-05-28 03:00:01 -07:00
|
|
|
!system_wide && !cpu_list)
|
2010-11-10 07:11:30 -07:00
|
|
|
usage_with_options(record_usage, record_options);
|
2009-05-26 00:17:18 -07:00
|
|
|
|
2010-04-14 10:42:07 -07:00
|
|
|
if (force && append_file) {
|
|
|
|
fprintf(stderr, "Can't overwrite and append at the same time."
|
|
|
|
" You need to choose between -f and -A");
|
2010-11-10 07:11:30 -07:00
|
|
|
usage_with_options(record_usage, record_options);
|
2010-04-14 10:42:07 -07:00
|
|
|
} else if (append_file) {
|
|
|
|
write_mode = WRITE_APPEND;
|
|
|
|
} else {
|
|
|
|
write_mode = WRITE_FORCE;
|
|
|
|
}
|
|
|
|
|
perf tool: Add cgroup support
This patch adds the ability to filter monitoring based on container groups
(cgroups) for both perf stat and perf record. It is possible to monitor
multiple cgroup in parallel. There is one cgroup per event. The cgroups to
monitor are passed via a new -G option followed by a comma separated list of
cgroup names.
The cgroup filesystem has to be mounted. Given a cgroup name, the perf tool
finds the corresponding directory in the cgroup filesystem and opens it. It
then passes that file descriptor to the kernel.
Example:
$ perf stat -B -a -e cycles:u,cycles:u,cycles:u -G test1,,test2 -- sleep 1
Performance counter stats for 'sleep 1':
2,368,667,414 cycles test1
2,369,661,459 cycles
<not counted> cycles test2
1.001856890 seconds time elapsed
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <4d590290.825bdf0a.7d0a.4890@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2011-02-14 02:20:01 -07:00
|
|
|
if (nr_cgroups && !system_wide) {
|
|
|
|
fprintf(stderr, "cgroup monitoring only available in"
|
|
|
|
" system-wide mode\n");
|
|
|
|
usage_with_options(record_usage, record_options);
|
|
|
|
}
|
|
|
|
|
2009-12-15 15:04:40 -07:00
|
|
|
symbol__init();
|
2010-11-26 14:39:15 -07:00
|
|
|
|
perf symbols: Handle /proc/sys/kernel/kptr_restrict
Perf uses /proc/modules to figure out where kernel modules are loaded.
With the advent of kptr_restrict, non root users get zeroes for all module
start addresses.
So check if kptr_restrict is non zero and don't generate the syntethic
PERF_RECORD_MMAP events for them.
Warn the user about it in perf record and in perf report.
In perf report the reference relocation symbol being zero means that
kptr_restrict was set, thus /proc/kallsyms has only zeroed addresses, so don't
use it to fixup symbol addresses when using a valid kallsyms (in the buildid
cache) or vmlinux (in the vmlinux path) build-id located automatically or
specified by the user.
Provide an explanation about it in 'perf report' if kernel samples were taken,
checking if a suitable vmlinux or kallsyms was found/specified.
Restricted /proc/kallsyms don't go to the buildid cache anymore.
Example:
[acme@emilia ~]$ perf record -F 100000 sleep 1
WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted, check
/proc/sys/kernel/kptr_restrict.
Samples in kernel functions may not be resolved if a suitable vmlinux file is
not found in the buildid cache or in the vmlinux path.
Samples in kernel modules won't be resolved at all.
If some relocation was applied (e.g. kexec) symbols may be misresolved even
with a suitable vmlinux or kallsyms file.
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.005 MB perf.data (~231 samples) ]
[acme@emilia ~]$
[acme@emilia ~]$ perf report --stdio
Kernel address maps (/proc/{kallsyms,modules}) were restricted,
check /proc/sys/kernel/kptr_restrict before running 'perf record'.
If some relocation was applied (e.g. kexec) symbols may be misresolved.
Samples in kernel modules can't be resolved as well.
# Events: 13 cycles
#
# Overhead Command Shared Object Symbol
# ........ ....... ................. .....................
#
20.24% sleep [kernel.kallsyms] [k] page_fault
20.04% sleep [kernel.kallsyms] [k] filemap_fault
19.78% sleep [kernel.kallsyms] [k] __lru_cache_add
19.69% sleep ld-2.12.so [.] memcpy
14.71% sleep [kernel.kallsyms] [k] dput
4.70% sleep [kernel.kallsyms] [k] flush_signal_handlers
0.73% sleep [kernel.kallsyms] [k] perf_event_comm
0.11% sleep [kernel.kallsyms] [k] native_write_msr_safe
#
# (For a higher level overview, try: perf report --sort comm,dso)
#
[acme@emilia ~]$
This is because it found a suitable vmlinux (build-id checked) in
/lib/modules/2.6.39-rc7+/build/vmlinux (use -v in perf report to see the long
file name).
If we remove that file from the vmlinux path:
[root@emilia ~]# mv /lib/modules/2.6.39-rc7+/build/vmlinux \
/lib/modules/2.6.39-rc7+/build/vmlinux.OFF
[acme@emilia ~]$ perf report --stdio
[kernel.kallsyms] with build id 57298cdbe0131f6871667ec0eaab4804dcf6f562
not found, continuing without symbols
Kernel address maps (/proc/{kallsyms,modules}) were restricted, check
/proc/sys/kernel/kptr_restrict before running 'perf record'.
As no suitable kallsyms nor vmlinux was found, kernel samples can't be
resolved.
Samples in kernel modules can't be resolved as well.
# Events: 13 cycles
#
# Overhead Command Shared Object Symbol
# ........ ....... ................. ......
#
80.31% sleep [kernel.kallsyms] [k] 0xffffffff8103425a
19.69% sleep ld-2.12.so [.] memcpy
#
# (For a higher level overview, try: perf report --sort comm,dso)
#
[acme@emilia ~]$
Reported-by: Stephane Eranian <eranian@google.com>
Suggested-by: David Miller <davem@davemloft.net>
Cc: Dave Jones <davej@redhat.com>
Cc: David Miller <davem@davemloft.net>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Kees Cook <kees.cook@canonical.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Link: http://lkml.kernel.org/n/tip-mt512joaxxbhhp1odop04yit@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-05-26 05:53:51 -07:00
|
|
|
if (symbol_conf.kptr_restrict)
|
2011-05-27 07:00:41 -07:00
|
|
|
pr_warning(
|
|
|
|
"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
|
|
|
|
"check /proc/sys/kernel/kptr_restrict.\n\n"
|
|
|
|
"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
|
|
|
|
"file is not found in the buildid cache or in the vmlinux path.\n\n"
|
|
|
|
"Samples in kernel modules won't be resolved at all.\n\n"
|
|
|
|
"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
|
|
|
|
"even with a suitable vmlinux or kallsyms file.\n\n");
|
perf symbols: Handle /proc/sys/kernel/kptr_restrict
Perf uses /proc/modules to figure out where kernel modules are loaded.
With the advent of kptr_restrict, non root users get zeroes for all module
start addresses.
So check if kptr_restrict is non zero and don't generate the syntethic
PERF_RECORD_MMAP events for them.
Warn the user about it in perf record and in perf report.
In perf report the reference relocation symbol being zero means that
kptr_restrict was set, thus /proc/kallsyms has only zeroed addresses, so don't
use it to fixup symbol addresses when using a valid kallsyms (in the buildid
cache) or vmlinux (in the vmlinux path) build-id located automatically or
specified by the user.
Provide an explanation about it in 'perf report' if kernel samples were taken,
checking if a suitable vmlinux or kallsyms was found/specified.
Restricted /proc/kallsyms don't go to the buildid cache anymore.
Example:
[acme@emilia ~]$ perf record -F 100000 sleep 1
WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted, check
/proc/sys/kernel/kptr_restrict.
Samples in kernel functions may not be resolved if a suitable vmlinux file is
not found in the buildid cache or in the vmlinux path.
Samples in kernel modules won't be resolved at all.
If some relocation was applied (e.g. kexec) symbols may be misresolved even
with a suitable vmlinux or kallsyms file.
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.005 MB perf.data (~231 samples) ]
[acme@emilia ~]$
[acme@emilia ~]$ perf report --stdio
Kernel address maps (/proc/{kallsyms,modules}) were restricted,
check /proc/sys/kernel/kptr_restrict before running 'perf record'.
If some relocation was applied (e.g. kexec) symbols may be misresolved.
Samples in kernel modules can't be resolved as well.
# Events: 13 cycles
#
# Overhead Command Shared Object Symbol
# ........ ....... ................. .....................
#
20.24% sleep [kernel.kallsyms] [k] page_fault
20.04% sleep [kernel.kallsyms] [k] filemap_fault
19.78% sleep [kernel.kallsyms] [k] __lru_cache_add
19.69% sleep ld-2.12.so [.] memcpy
14.71% sleep [kernel.kallsyms] [k] dput
4.70% sleep [kernel.kallsyms] [k] flush_signal_handlers
0.73% sleep [kernel.kallsyms] [k] perf_event_comm
0.11% sleep [kernel.kallsyms] [k] native_write_msr_safe
#
# (For a higher level overview, try: perf report --sort comm,dso)
#
[acme@emilia ~]$
This is because it found a suitable vmlinux (build-id checked) in
/lib/modules/2.6.39-rc7+/build/vmlinux (use -v in perf report to see the long
file name).
If we remove that file from the vmlinux path:
[root@emilia ~]# mv /lib/modules/2.6.39-rc7+/build/vmlinux \
/lib/modules/2.6.39-rc7+/build/vmlinux.OFF
[acme@emilia ~]$ perf report --stdio
[kernel.kallsyms] with build id 57298cdbe0131f6871667ec0eaab4804dcf6f562
not found, continuing without symbols
Kernel address maps (/proc/{kallsyms,modules}) were restricted, check
/proc/sys/kernel/kptr_restrict before running 'perf record'.
As no suitable kallsyms nor vmlinux was found, kernel samples can't be
resolved.
Samples in kernel modules can't be resolved as well.
# Events: 13 cycles
#
# Overhead Command Shared Object Symbol
# ........ ....... ................. ......
#
80.31% sleep [kernel.kallsyms] [k] 0xffffffff8103425a
19.69% sleep ld-2.12.so [.] memcpy
#
# (For a higher level overview, try: perf report --sort comm,dso)
#
[acme@emilia ~]$
Reported-by: Stephane Eranian <eranian@google.com>
Suggested-by: David Miller <davem@davemloft.net>
Cc: Dave Jones <davej@redhat.com>
Cc: David Miller <davem@davemloft.net>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Kees Cook <kees.cook@canonical.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Link: http://lkml.kernel.org/n/tip-mt512joaxxbhhp1odop04yit@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-05-26 05:53:51 -07:00
|
|
|
|
2010-11-26 14:39:15 -07:00
|
|
|
if (no_buildid_cache || no_buildid)
|
2010-06-17 02:39:01 -07:00
|
|
|
disable_buildid_cache();
|
2009-12-15 15:04:40 -07:00
|
|
|
|
2011-01-11 15:56:53 -07:00
|
|
|
if (evsel_list->nr_entries == 0 &&
|
|
|
|
perf_evlist__add_default(evsel_list) < 0) {
|
2011-01-03 11:39:04 -07:00
|
|
|
pr_err("Not enough memory for event selector list\n");
|
|
|
|
goto out_symbol_exit;
|
2009-06-11 14:11:50 -07:00
|
|
|
}
|
2009-05-26 00:17:18 -07:00
|
|
|
|
2011-01-03 12:53:33 -07:00
|
|
|
if (target_pid != -1)
|
2010-03-18 07:36:05 -07:00
|
|
|
target_tid = target_pid;
|
|
|
|
|
2011-01-30 06:59:43 -07:00
|
|
|
if (perf_evlist__create_maps(evsel_list, target_pid,
|
|
|
|
target_tid, cpu_list) < 0)
|
2011-01-12 09:28:51 -07:00
|
|
|
usage_with_options(record_usage, record_options);
|
2011-01-03 11:39:04 -07:00
|
|
|
|
2011-01-11 15:56:53 -07:00
|
|
|
list_for_each_entry(pos, &evsel_list->entries, node) {
|
2011-01-30 06:59:43 -07:00
|
|
|
if (perf_evsel__alloc_fd(pos, evsel_list->cpus->nr,
|
|
|
|
evsel_list->threads->nr) < 0)
|
2011-01-03 11:39:04 -07:00
|
|
|
goto out_free_fd;
|
2011-01-17 13:28:13 -07:00
|
|
|
if (perf_header__push_event(pos->attr.config, event_name(pos)))
|
|
|
|
goto out_free_fd;
|
2010-03-18 07:36:05 -07:00
|
|
|
}
|
2011-01-11 17:30:02 -07:00
|
|
|
|
2011-01-30 06:59:43 -07:00
|
|
|
if (perf_evlist__alloc_pollfd(evsel_list) < 0)
|
2010-07-29 10:08:55 -07:00
|
|
|
goto out_free_fd;
|
2010-03-18 07:36:05 -07:00
|
|
|
|
2010-05-17 08:20:43 -07:00
|
|
|
if (user_interval != ULLONG_MAX)
|
2010-04-14 13:09:02 -07:00
|
|
|
default_interval = user_interval;
|
|
|
|
if (user_freq != UINT_MAX)
|
|
|
|
freq = user_freq;
|
|
|
|
|
2009-10-11 22:56:03 -07:00
|
|
|
/*
|
|
|
|
* User specified count overrides default frequency.
|
|
|
|
*/
|
|
|
|
if (default_interval)
|
|
|
|
freq = 0;
|
|
|
|
else if (freq) {
|
|
|
|
default_interval = freq;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "frequency and count are zero, aborting\n");
|
2010-07-29 10:08:55 -07:00
|
|
|
err = -EINVAL;
|
2011-01-11 17:30:02 -07:00
|
|
|
goto out_free_fd;
|
2009-10-11 22:56:03 -07:00
|
|
|
}
|
|
|
|
|
2010-07-29 10:08:55 -07:00
|
|
|
err = __cmd_record(argc, argv);
|
|
|
|
out_free_fd:
|
2011-01-30 06:59:43 -07:00
|
|
|
perf_evlist__delete_maps(evsel_list);
|
2010-07-30 14:31:28 -07:00
|
|
|
out_symbol_exit:
|
|
|
|
symbol__exit();
|
2010-07-29 10:08:55 -07:00
|
|
|
return err;
|
2009-05-26 00:17:18 -07:00
|
|
|
}
|