2009-06-02 14:59:57 -06:00
|
|
|
/*
|
2009-06-02 15:37:05 -06: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 14:59:57 -06:00
|
|
|
*/
|
2009-05-27 01:10:38 -06:00
|
|
|
#include "builtin.h"
|
2009-06-02 15:37:05 -06:00
|
|
|
|
|
|
|
#include "perf.h"
|
|
|
|
|
2009-05-01 10:29:57 -06:00
|
|
|
#include "util/util.h"
|
2009-05-26 01:17:18 -06:00
|
|
|
#include "util/parse-options.h"
|
2009-05-26 03:10:09 -06:00
|
|
|
#include "util/parse-events.h"
|
2009-06-01 14:50:19 -06:00
|
|
|
#include "util/string.h"
|
2009-05-01 10:29:57 -06:00
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
#include "util/header.h"
|
|
|
|
|
2009-06-02 07:52:24 -06:00
|
|
|
#include <unistd.h>
|
2009-04-08 07:01:31 -06:00
|
|
|
#include <sched.h>
|
|
|
|
|
2009-05-26 01:17:18 -06:00
|
|
|
#define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1)
|
|
|
|
#define __ALIGN_MASK(x, mask) (((x)+(mask))&~(mask))
|
2009-05-14 19:50:46 -06:00
|
|
|
|
2009-04-08 07:01:31 -06:00
|
|
|
static int fd[MAX_NR_CPUS][MAX_COUNTERS];
|
2009-06-06 01:58:57 -06:00
|
|
|
|
|
|
|
static long default_interval = 100000;
|
|
|
|
|
2009-06-02 15:02:59 -06:00
|
|
|
static int nr_cpus = 0;
|
2009-04-08 07:01:31 -06:00
|
|
|
static unsigned int page_size;
|
2009-06-02 15:02:59 -06:00
|
|
|
static unsigned int mmap_pages = 128;
|
2009-06-05 05:27:02 -06:00
|
|
|
static int freq = 0;
|
2009-04-08 07:01:31 -06:00
|
|
|
static int output;
|
2009-05-27 01:33:18 -06:00
|
|
|
static const char *output_name = "perf.data";
|
2009-04-08 07:01:31 -06:00
|
|
|
static int group = 0;
|
2009-05-05 09:50:27 -06:00
|
|
|
static unsigned int realtime_prio = 0;
|
2009-08-13 02:27:19 -06:00
|
|
|
static int raw_samples = 0;
|
2009-05-05 09:50:27 -06:00
|
|
|
static int system_wide = 0;
|
2009-08-12 03:18:01 -06:00
|
|
|
static int profile_cpu = -1;
|
2009-05-14 19:50:46 -06:00
|
|
|
static pid_t target_pid = -1;
|
2009-05-05 09:50:27 -06:00
|
|
|
static int inherit = 1;
|
2009-06-02 07:52:24 -06:00
|
|
|
static int force = 0;
|
2009-06-02 14:59:57 -06:00
|
|
|
static int append_file = 0;
|
2009-06-14 07:04:15 -06:00
|
|
|
static int call_graph = 0;
|
2009-06-07 09:39:02 -06:00
|
|
|
static int verbose = 0;
|
2009-06-24 13:12:48 -06:00
|
|
|
static int inherit_stat = 0;
|
|
|
|
static int no_samples = 0;
|
2009-07-16 07:44:29 -06:00
|
|
|
static int sample_address = 0;
|
2009-04-08 07:01:31 -06:00
|
|
|
|
2009-06-06 01:58:57 -06:00
|
|
|
static long samples;
|
|
|
|
static struct timeval last_read;
|
|
|
|
static struct timeval this_read;
|
|
|
|
|
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 06:21:42 -06:00
|
|
|
static u64 bytes_written;
|
2009-06-06 01:58:57 -06:00
|
|
|
|
|
|
|
static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
|
|
|
|
|
|
|
|
static int nr_poll;
|
|
|
|
static int nr_cpu;
|
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
static int file_new = 1;
|
2009-06-25 09:05:54 -06:00
|
|
|
|
|
|
|
struct perf_header *header;
|
2009-06-18 15:22:55 -06:00
|
|
|
|
2009-06-06 01:58:57 -06:00
|
|
|
struct mmap_event {
|
|
|
|
struct perf_event_header header;
|
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 06:21:42 -06:00
|
|
|
u32 pid;
|
|
|
|
u32 tid;
|
|
|
|
u64 start;
|
|
|
|
u64 len;
|
|
|
|
u64 pgoff;
|
2009-06-06 01:58:57 -06:00
|
|
|
char filename[PATH_MAX];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct comm_event {
|
|
|
|
struct perf_event_header header;
|
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 06:21:42 -06:00
|
|
|
u32 pid;
|
|
|
|
u32 tid;
|
2009-06-06 01:58:57 -06:00
|
|
|
char comm[16];
|
2009-04-08 07:01:31 -06:00
|
|
|
};
|
|
|
|
|
2009-06-06 01:58:57 -06:00
|
|
|
|
2009-04-08 07:01:31 -06:00
|
|
|
struct mmap_data {
|
2009-06-06 01:58:57 -06:00
|
|
|
int counter;
|
|
|
|
void *base;
|
|
|
|
unsigned int mask;
|
|
|
|
unsigned int prev;
|
2009-04-08 07:01:31 -06:00
|
|
|
};
|
|
|
|
|
2009-06-06 01:58:57 -06:00
|
|
|
static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
|
|
|
|
|
2009-06-18 03:40:28 -06:00
|
|
|
static unsigned long mmap_read_head(struct mmap_data *md)
|
2009-04-08 07:01:31 -06:00
|
|
|
{
|
|
|
|
struct perf_counter_mmap_page *pc = md->base;
|
2009-06-18 03:40:28 -06:00
|
|
|
long head;
|
2009-04-08 07:01:31 -06:00
|
|
|
|
|
|
|
head = pc->data_head;
|
|
|
|
rmb();
|
|
|
|
|
|
|
|
return head;
|
|
|
|
}
|
|
|
|
|
2009-06-18 03:40:28 -06:00
|
|
|
static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
|
|
|
|
{
|
|
|
|
struct perf_counter_mmap_page *pc = md->base;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ensure all reads are done before we write the tail out.
|
|
|
|
*/
|
|
|
|
/* mb(); */
|
|
|
|
pc->data_tail = tail;
|
|
|
|
}
|
|
|
|
|
2009-06-18 15:22:55 -06: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-08 07:01:31 -06:00
|
|
|
static void mmap_read(struct mmap_data *md)
|
|
|
|
{
|
|
|
|
unsigned int head = mmap_read_head(md);
|
|
|
|
unsigned int old = md->prev;
|
|
|
|
unsigned char *data = md->base + page_size;
|
|
|
|
unsigned long size;
|
|
|
|
void *buf;
|
|
|
|
int diff;
|
|
|
|
|
|
|
|
gettimeofday(&this_read, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're further behind than half the buffer, there's a chance
|
2009-06-05 06:29:10 -06:00
|
|
|
* the writer will bite our tail and mess up the samples under us.
|
2009-04-08 07:01:31 -06:00
|
|
|
*
|
|
|
|
* If we somehow ended up ahead of the head, we got messed up.
|
|
|
|
*
|
|
|
|
* In either case, truncate and restart at head.
|
|
|
|
*/
|
|
|
|
diff = head - old;
|
2009-06-18 03:40:28 -06:00
|
|
|
if (diff < 0) {
|
2009-04-08 07:01:31 -06:00
|
|
|
struct timeval iv;
|
|
|
|
unsigned long msecs;
|
|
|
|
|
|
|
|
timersub(&this_read, &last_read, &iv);
|
|
|
|
msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
|
|
|
|
|
|
|
|
fprintf(stderr, "WARNING: failed to keep up with mmap data."
|
|
|
|
" Last read %lu msecs ago.\n", msecs);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* head points to a known good entry, start there.
|
|
|
|
*/
|
|
|
|
old = head;
|
|
|
|
}
|
|
|
|
|
|
|
|
last_read = this_read;
|
|
|
|
|
|
|
|
if (old != head)
|
2009-06-05 06:29:10 -06:00
|
|
|
samples++;
|
2009-04-08 07:01:31 -06: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 11:27:19 -06:00
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
write_output(buf, size);
|
2009-04-08 07:01:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
buf = &data[old & md->mask];
|
|
|
|
size = head - old;
|
|
|
|
old += size;
|
2009-06-03 11:27:19 -06:00
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
write_output(buf, size);
|
2009-04-08 07:01:31 -06:00
|
|
|
|
|
|
|
md->prev = old;
|
2009-06-18 03:40:28 -06:00
|
|
|
mmap_write_tail(md, old);
|
2009-04-08 07:01:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static volatile int done = 0;
|
2009-06-10 07:55:59 -06:00
|
|
|
static volatile int signr = -1;
|
2009-04-08 07:01:31 -06:00
|
|
|
|
2009-05-05 09:50:27 -06:00
|
|
|
static void sig_handler(int sig)
|
2009-04-08 07:01:31 -06:00
|
|
|
{
|
2009-05-05 09:50:27 -06:00
|
|
|
done = 1;
|
2009-06-10 07:55:59 -06:00
|
|
|
signr = sig;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sig_atexit(void)
|
|
|
|
{
|
|
|
|
if (signr == -1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
signal(signr, SIG_DFL);
|
|
|
|
kill(getpid(), signr);
|
2009-04-08 07:01:31 -06:00
|
|
|
}
|
|
|
|
|
2009-08-11 13:22:00 -06:00
|
|
|
static pid_t pid_synthesize_comm_event(pid_t pid, int full)
|
2009-05-14 19:50:46 -06:00
|
|
|
{
|
2009-05-27 01:10:38 -06:00
|
|
|
struct comm_event comm_ev;
|
2009-05-14 19:50:46 -06:00
|
|
|
char filename[PATH_MAX];
|
|
|
|
char bf[BUFSIZ];
|
2009-08-11 13:22:00 -06:00
|
|
|
FILE *fp;
|
|
|
|
size_t size = 0;
|
2009-06-02 06:13:24 -06:00
|
|
|
DIR *tasks;
|
|
|
|
struct dirent dirent, *next;
|
2009-08-11 13:22:00 -06:00
|
|
|
pid_t tgid = 0;
|
2009-05-14 19:50:46 -06:00
|
|
|
|
2009-08-11 13:22:00 -06:00
|
|
|
snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
|
2009-05-14 19:50:46 -06:00
|
|
|
|
2009-08-11 13:22:00 -06:00
|
|
|
fp = fopen(filename, "r");
|
2009-08-14 12:26:32 -06:00
|
|
|
if (fp == NULL) {
|
2009-06-15 00:17:12 -06:00
|
|
|
/*
|
|
|
|
* We raced with a task exiting - just return:
|
|
|
|
*/
|
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "couldn't open %s\n", filename);
|
2009-08-11 13:22:00 -06:00
|
|
|
return 0;
|
2009-05-14 19:50:46 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(&comm_ev, 0, sizeof(comm_ev));
|
2009-08-11 13:22:00 -06:00
|
|
|
while (!comm_ev.comm[0] || !comm_ev.pid) {
|
|
|
|
if (fgets(bf, sizeof(bf), fp) == NULL)
|
|
|
|
goto out_failure;
|
|
|
|
|
|
|
|
if (memcmp(bf, "Name:", 5) == 0) {
|
|
|
|
char *name = bf + 5;
|
|
|
|
while (*name && isspace(*name))
|
|
|
|
++name;
|
|
|
|
size = strlen(name) - 1;
|
|
|
|
memcpy(comm_ev.comm, name, size++);
|
|
|
|
} else if (memcmp(bf, "Tgid:", 5) == 0) {
|
|
|
|
char *tgids = bf + 5;
|
|
|
|
while (*tgids && isspace(*tgids))
|
|
|
|
++tgids;
|
|
|
|
tgid = comm_ev.pid = atoi(tgids);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-14 19:50:46 -06:00
|
|
|
comm_ev.header.type = PERF_EVENT_COMM;
|
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 06:21:42 -06:00
|
|
|
size = ALIGN(size, sizeof(u64));
|
2009-05-14 19:50:46 -06:00
|
|
|
comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
|
2009-05-27 01:10:38 -06:00
|
|
|
|
2009-06-02 06:13:24 -06:00
|
|
|
if (!full) {
|
|
|
|
comm_ev.tid = pid;
|
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
write_output(&comm_ev, comm_ev.header.size);
|
2009-08-11 13:22:00 -06:00
|
|
|
goto out_fclose;
|
2009-06-02 06:13:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
|
|
|
|
|
|
|
|
tasks = opendir(filename);
|
|
|
|
while (!readdir_r(tasks, &dirent, &next) && next) {
|
|
|
|
char *end;
|
|
|
|
pid = strtol(dirent.d_name, &end, 10);
|
|
|
|
if (*end)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
comm_ev.tid = pid;
|
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
write_output(&comm_ev, comm_ev.header.size);
|
2009-05-14 19:50:46 -06:00
|
|
|
}
|
2009-06-02 06:13:24 -06:00
|
|
|
closedir(tasks);
|
2009-08-11 13:22:00 -06:00
|
|
|
|
|
|
|
out_fclose:
|
|
|
|
fclose(fp);
|
|
|
|
return tgid;
|
2009-06-02 06:13:24 -06:00
|
|
|
|
2009-06-01 14:50:19 -06:00
|
|
|
out_failure:
|
|
|
|
fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n",
|
|
|
|
filename);
|
|
|
|
exit(EXIT_FAILURE);
|
2009-05-14 19:50:46 -06:00
|
|
|
}
|
|
|
|
|
2009-08-11 13:22:00 -06:00
|
|
|
static void pid_synthesize_mmap_samples(pid_t pid, pid_t tgid)
|
2009-05-14 19:50:46 -06:00
|
|
|
{
|
|
|
|
char filename[PATH_MAX];
|
|
|
|
FILE *fp;
|
|
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
|
|
|
|
|
|
|
|
fp = fopen(filename, "r");
|
|
|
|
if (fp == NULL) {
|
2009-06-15 00:17:12 -06:00
|
|
|
/*
|
|
|
|
* We raced with a task exiting - just return:
|
|
|
|
*/
|
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "couldn't open %s\n", filename);
|
|
|
|
return;
|
2009-05-14 19:50:46 -06:00
|
|
|
}
|
|
|
|
while (1) {
|
2009-06-01 14:50:19 -06:00
|
|
|
char bf[BUFSIZ], *pbf = bf;
|
2009-05-14 19:50:46 -06:00
|
|
|
struct mmap_event mmap_ev = {
|
2009-07-01 04:37:06 -06:00
|
|
|
.header = { .type = PERF_EVENT_MMAP },
|
2009-05-14 19:50:46 -06:00
|
|
|
};
|
2009-06-01 14:50:19 -06:00
|
|
|
int n;
|
2009-05-14 19:50:46 -06:00
|
|
|
size_t size;
|
|
|
|
if (fgets(bf, sizeof(bf), fp) == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */
|
2009-06-01 14:50:19 -06:00
|
|
|
n = hex2u64(pbf, &mmap_ev.start);
|
|
|
|
if (n < 0)
|
|
|
|
continue;
|
|
|
|
pbf += n + 1;
|
|
|
|
n = hex2u64(pbf, &mmap_ev.len);
|
|
|
|
if (n < 0)
|
|
|
|
continue;
|
|
|
|
pbf += n + 3;
|
|
|
|
if (*pbf == 'x') { /* vm_exec */
|
2009-06-24 13:08:36 -06:00
|
|
|
char *execname = strchr(bf, '/');
|
2009-05-14 19:50:46 -06:00
|
|
|
|
2009-07-16 07:44:29 -06:00
|
|
|
/* Catch VDSO */
|
|
|
|
if (execname == NULL)
|
|
|
|
execname = strstr(bf, "[vdso]");
|
|
|
|
|
2009-06-24 13:08:36 -06:00
|
|
|
if (execname == NULL)
|
2009-05-14 19:50:46 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
size = strlen(execname);
|
|
|
|
execname[size - 1] = '\0'; /* Remove \n */
|
|
|
|
memcpy(mmap_ev.filename, execname, size);
|
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 06:21:42 -06:00
|
|
|
size = ALIGN(size, sizeof(u64));
|
2009-05-14 19:50:46 -06:00
|
|
|
mmap_ev.len -= mmap_ev.start;
|
|
|
|
mmap_ev.header.size = (sizeof(mmap_ev) -
|
|
|
|
(sizeof(mmap_ev.filename) - size));
|
2009-08-11 13:22:00 -06:00
|
|
|
mmap_ev.pid = tgid;
|
2009-05-14 19:50:46 -06:00
|
|
|
mmap_ev.tid = pid;
|
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
write_output(&mmap_ev, mmap_ev.header.size);
|
2009-05-14 19:50:46 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
}
|
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
static void synthesize_all(void)
|
2009-06-02 06:13:24 -06:00
|
|
|
{
|
|
|
|
DIR *proc;
|
|
|
|
struct dirent dirent, *next;
|
|
|
|
|
|
|
|
proc = opendir("/proc");
|
|
|
|
|
|
|
|
while (!readdir_r(proc, &dirent, &next) && next) {
|
|
|
|
char *end;
|
2009-08-11 13:22:00 -06:00
|
|
|
pid_t pid, tgid;
|
2009-06-02 06:13:24 -06:00
|
|
|
|
|
|
|
pid = strtol(dirent.d_name, &end, 10);
|
|
|
|
if (*end) /* only interested in proper numerical dirents */
|
|
|
|
continue;
|
|
|
|
|
2009-08-11 13:22:00 -06:00
|
|
|
tgid = pid_synthesize_comm_event(pid, 1);
|
|
|
|
pid_synthesize_mmap_samples(pid, tgid);
|
2009-06-02 06:13:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
closedir(proc);
|
|
|
|
}
|
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
static int group_fd;
|
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
static struct perf_header_attr *get_header_attr(struct perf_counter_attr *a, int nr)
|
|
|
|
{
|
|
|
|
struct perf_header_attr *h_attr;
|
|
|
|
|
|
|
|
if (nr < header->attrs) {
|
|
|
|
h_attr = header->attr[nr];
|
|
|
|
} else {
|
|
|
|
h_attr = perf_header_attr__new(a);
|
|
|
|
perf_header__add_attr(header, h_attr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return h_attr;
|
|
|
|
}
|
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
static void create_counter(int counter, int cpu, pid_t pid)
|
2009-04-08 07:01:31 -06:00
|
|
|
{
|
2009-06-06 01:58:57 -06:00
|
|
|
struct perf_counter_attr *attr = attrs + counter;
|
2009-06-25 09:05:54 -06:00
|
|
|
struct perf_header_attr *h_attr;
|
|
|
|
int track = !counter; /* only the first counter needs these */
|
|
|
|
struct {
|
|
|
|
u64 count;
|
|
|
|
u64 time_enabled;
|
|
|
|
u64 time_running;
|
|
|
|
u64 id;
|
|
|
|
} read_data;
|
|
|
|
|
|
|
|
attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
|
|
|
|
PERF_FORMAT_TOTAL_TIME_RUNNING |
|
|
|
|
PERF_FORMAT_ID;
|
2009-05-05 09:50:27 -06:00
|
|
|
|
2009-08-13 02:27:18 -06:00
|
|
|
attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
|
2009-06-14 07:04:15 -06:00
|
|
|
|
2009-06-05 10:37:22 -06:00
|
|
|
if (freq) {
|
2009-06-10 13:45:22 -06:00
|
|
|
attr->sample_type |= PERF_SAMPLE_PERIOD;
|
2009-06-06 01:58:57 -06:00
|
|
|
attr->freq = 1;
|
|
|
|
attr->sample_freq = freq;
|
2009-06-05 10:37:22 -06:00
|
|
|
}
|
2009-06-14 07:04:15 -06:00
|
|
|
|
2009-06-24 13:12:48 -06:00
|
|
|
if (no_samples)
|
|
|
|
attr->sample_freq = 0;
|
|
|
|
|
|
|
|
if (inherit_stat)
|
|
|
|
attr->inherit_stat = 1;
|
|
|
|
|
2009-07-16 07:44:29 -06:00
|
|
|
if (sample_address)
|
|
|
|
attr->sample_type |= PERF_SAMPLE_ADDR;
|
|
|
|
|
2009-06-14 07:04:15 -06:00
|
|
|
if (call_graph)
|
|
|
|
attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
|
|
|
|
|
2009-08-13 02:27:19 -06:00
|
|
|
if (raw_samples)
|
|
|
|
attr->sample_type |= PERF_SAMPLE_RAW;
|
2009-08-06 17:25:54 -06:00
|
|
|
|
2009-06-06 01:58:57 -06:00
|
|
|
attr->mmap = track;
|
|
|
|
attr->comm = track;
|
|
|
|
attr->inherit = (cpu < 0) && inherit;
|
2009-06-10 07:03:06 -06:00
|
|
|
attr->disabled = 1;
|
2009-05-05 09:50:27 -06:00
|
|
|
|
2009-06-07 09:39:02 -06:00
|
|
|
try_again:
|
2009-06-06 01:58:57 -06:00
|
|
|
fd[nr_cpu][counter] = sys_perf_counter_open(attr, pid, cpu, group_fd, 0);
|
2009-05-05 09:50:27 -06:00
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
if (fd[nr_cpu][counter] < 0) {
|
|
|
|
int err = errno;
|
2009-05-05 09:50:27 -06:00
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
if (err == EPERM)
|
2009-06-07 09:39:02 -06:00
|
|
|
die("Permission error - are you root?\n");
|
2009-08-12 03:18:01 -06:00
|
|
|
else if (err == ENODEV && profile_cpu != -1)
|
|
|
|
die("No such device - did you specify an out-of-range profile CPU?\n");
|
2009-06-07 09:39:02 -06: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
|
2009-06-11 06:06:28 -06:00
|
|
|
&& attr->config == PERF_COUNT_HW_CPU_CYCLES) {
|
2009-06-07 09:39:02 -06:00
|
|
|
|
|
|
|
if (verbose)
|
|
|
|
warning(" ... trying to fall back to cpu-clock-ticks\n");
|
|
|
|
attr->type = PERF_TYPE_SOFTWARE;
|
2009-06-11 06:06:28 -06:00
|
|
|
attr->config = PERF_COUNT_SW_CPU_CLOCK;
|
2009-06-07 09:39:02 -06:00
|
|
|
goto try_again;
|
|
|
|
}
|
2009-06-07 09:46:24 -06:00
|
|
|
printf("\n");
|
|
|
|
error("perfcounter syscall returned with %d (%s)\n",
|
|
|
|
fd[nr_cpu][counter], strerror(err));
|
|
|
|
die("No CONFIG_PERF_COUNTERS=y kernel support configured?\n");
|
2009-06-05 05:18:41 -06:00
|
|
|
exit(-1);
|
|
|
|
}
|
2009-06-07 09:39:02 -06:00
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
h_attr = get_header_attr(attr, counter);
|
|
|
|
|
|
|
|
if (!file_new) {
|
|
|
|
if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
|
|
|
|
fprintf(stderr, "incompatible append\n");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-25 14:21:27 -06:00
|
|
|
if (read(fd[nr_cpu][counter], &read_data, sizeof(read_data)) == -1) {
|
|
|
|
perror("Unable to read perf file descriptor\n");
|
|
|
|
exit(-1);
|
|
|
|
}
|
2009-06-25 09:05:54 -06:00
|
|
|
|
|
|
|
perf_header_attr__add_id(h_attr, read_data.id);
|
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
assert(fd[nr_cpu][counter] >= 0);
|
|
|
|
fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
|
2009-05-05 09:50:27 -06:00
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
/*
|
|
|
|
* First counter acts as the group leader:
|
|
|
|
*/
|
|
|
|
if (group && group_fd == -1)
|
|
|
|
group_fd = fd[nr_cpu][counter];
|
|
|
|
|
|
|
|
event_array[nr_poll].fd = fd[nr_cpu][counter];
|
|
|
|
event_array[nr_poll].events = POLLIN;
|
|
|
|
nr_poll++;
|
|
|
|
|
|
|
|
mmap_array[nr_cpu][counter].counter = counter;
|
|
|
|
mmap_array[nr_cpu][counter].prev = 0;
|
|
|
|
mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1;
|
|
|
|
mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
|
2009-06-18 03:40:28 -06:00
|
|
|
PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter], 0);
|
2009-06-05 05:18:41 -06:00
|
|
|
if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
|
|
|
|
error("failed to mmap with %d (%s)\n", errno, strerror(errno));
|
|
|
|
exit(-1);
|
|
|
|
}
|
2009-06-10 07:03:06 -06:00
|
|
|
|
|
|
|
ioctl(fd[nr_cpu][counter], PERF_COUNTER_IOC_ENABLE);
|
2009-06-05 05:18:41 -06:00
|
|
|
}
|
2009-06-03 11:17:25 -06:00
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
static void open_counters(int cpu, pid_t pid)
|
|
|
|
{
|
|
|
|
int counter;
|
2009-05-05 09:50:27 -06:00
|
|
|
|
2009-06-05 05:18:41 -06:00
|
|
|
group_fd = -1;
|
|
|
|
for (counter = 0; counter < nr_counters; counter++)
|
|
|
|
create_counter(counter, cpu, pid);
|
|
|
|
|
2009-05-05 09:50:27 -06:00
|
|
|
nr_cpu++;
|
|
|
|
}
|
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
static void atexit_header(void)
|
|
|
|
{
|
2009-06-25 09:05:54 -06:00
|
|
|
header->data_size += bytes_written;
|
2009-06-18 15:22:55 -06:00
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
perf_header__write(header, output);
|
2009-06-18 15:22:55 -06:00
|
|
|
}
|
|
|
|
|
2009-05-26 01:17:18 -06:00
|
|
|
static int __cmd_record(int argc, const char **argv)
|
2009-05-05 09:50:27 -06:00
|
|
|
{
|
|
|
|
int i, counter;
|
2009-06-02 14:59:57 -06:00
|
|
|
struct stat st;
|
2009-06-25 09:05:54 -06:00
|
|
|
pid_t pid = 0;
|
2009-06-02 14:59:57 -06:00
|
|
|
int flags;
|
2009-04-08 07:01:31 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
page_size = sysconf(_SC_PAGE_SIZE);
|
|
|
|
nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
|
|
|
|
assert(nr_cpus <= MAX_NR_CPUS);
|
|
|
|
assert(nr_cpus >= 0);
|
|
|
|
|
2009-06-18 15:22:55 -06:00
|
|
|
atexit(sig_atexit);
|
|
|
|
signal(SIGCHLD, sig_handler);
|
|
|
|
signal(SIGINT, sig_handler);
|
|
|
|
|
2009-08-07 06:16:01 -06:00
|
|
|
if (!stat(output_name, &st) && st.st_size) {
|
|
|
|
if (!force && !append_file) {
|
|
|
|
fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n",
|
|
|
|
output_name);
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
append_file = 0;
|
2009-06-02 07:52:24 -06:00
|
|
|
}
|
|
|
|
|
2009-06-02 14:59:57 -06:00
|
|
|
flags = O_CREAT|O_RDWR;
|
|
|
|
if (append_file)
|
2009-06-18 15:22:55 -06:00
|
|
|
file_new = 0;
|
2009-06-02 14:59:57 -06:00
|
|
|
else
|
|
|
|
flags |= O_TRUNC;
|
|
|
|
|
|
|
|
output = open(output_name, flags, S_IRUSR|S_IWUSR);
|
2009-04-08 07:01:31 -06:00
|
|
|
if (output < 0) {
|
|
|
|
perror("failed to create output file");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
if (!file_new)
|
|
|
|
header = perf_header__read(output);
|
|
|
|
else
|
|
|
|
header = perf_header__new();
|
2009-06-18 15:22:55 -06:00
|
|
|
|
|
|
|
atexit(atexit_header);
|
|
|
|
|
2009-05-14 19:50:46 -06:00
|
|
|
if (!system_wide) {
|
2009-06-25 09:05:54 -06:00
|
|
|
pid = target_pid;
|
|
|
|
if (pid == -1)
|
|
|
|
pid = getpid();
|
|
|
|
|
2009-08-12 03:18:01 -06:00
|
|
|
open_counters(profile_cpu, pid);
|
|
|
|
} else {
|
|
|
|
if (profile_cpu != -1) {
|
|
|
|
open_counters(profile_cpu, target_pid);
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < nr_cpus; i++)
|
|
|
|
open_counters(i, target_pid);
|
|
|
|
}
|
|
|
|
}
|
2009-04-08 07:01:31 -06:00
|
|
|
|
2009-06-25 09:05:54 -06:00
|
|
|
if (file_new)
|
|
|
|
perf_header__write(header, output);
|
|
|
|
|
|
|
|
if (!system_wide) {
|
2009-08-11 13:22:00 -06:00
|
|
|
pid_t tgid = pid_synthesize_comm_event(pid, 0);
|
|
|
|
pid_synthesize_mmap_samples(pid, tgid);
|
2009-06-25 09:05:54 -06:00
|
|
|
} else
|
|
|
|
synthesize_all();
|
|
|
|
|
2009-05-27 02:10:51 -06:00
|
|
|
if (target_pid == -1 && argc) {
|
2009-05-14 19:50:46 -06:00
|
|
|
pid = fork();
|
|
|
|
if (pid < 0)
|
|
|
|
perror("failed to fork");
|
2009-04-08 07:01:31 -06:00
|
|
|
|
2009-05-14 19:50:46 -06:00
|
|
|
if (!pid) {
|
2009-05-26 01:17:18 -06:00
|
|
|
if (execvp(argv[0], (char **)argv)) {
|
2009-05-14 19:50:46 -06:00
|
|
|
perror(argv[0]);
|
|
|
|
exit(-1);
|
|
|
|
}
|
2009-04-08 07:01:31 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (realtime_prio) {
|
|
|
|
struct sched_param param;
|
|
|
|
|
|
|
|
param.sched_priority = realtime_prio;
|
|
|
|
if (sched_setscheduler(0, SCHED_FIFO, ¶m)) {
|
|
|
|
printf("Could not set realtime priority.\n");
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-24 13:12:48 -06:00
|
|
|
for (;;) {
|
2009-06-05 06:29:10 -06:00
|
|
|
int hits = samples;
|
2009-04-08 07:01:31 -06:00
|
|
|
|
2009-05-05 09:50:27 -06:00
|
|
|
for (i = 0; i < nr_cpu; i++) {
|
2009-04-08 07:01:31 -06:00
|
|
|
for (counter = 0; counter < nr_counters; counter++)
|
|
|
|
mmap_read(&mmap_array[i][counter]);
|
|
|
|
}
|
|
|
|
|
2009-06-24 13:12:48 -06:00
|
|
|
if (hits == samples) {
|
|
|
|
if (done)
|
|
|
|
break;
|
2009-04-08 07:01:31 -06:00
|
|
|
ret = poll(event_array, nr_poll, 100);
|
2009-06-24 13:12:48 -06:00
|
|
|
}
|
2009-04-08 07:01:31 -06:00
|
|
|
}
|
|
|
|
|
2009-06-03 11:27:19 -06:00
|
|
|
/*
|
|
|
|
* Approximate RIP event size: 24 bytes.
|
|
|
|
*/
|
|
|
|
fprintf(stderr,
|
2009-06-05 06:29:10 -06:00
|
|
|
"[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n",
|
2009-06-03 11:27:19 -06:00
|
|
|
(double)bytes_written / 1024.0 / 1024.0,
|
|
|
|
output_name,
|
|
|
|
bytes_written / 24);
|
2009-06-02 15:43:11 -06:00
|
|
|
|
2009-04-08 07:01:31 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2009-05-26 01:17:18 -06:00
|
|
|
|
|
|
|
static const char * const record_usage[] = {
|
2009-05-28 08:25:34 -06:00
|
|
|
"perf record [<options>] [<command>]",
|
|
|
|
"perf record [<options>] -- <command> [<options>]",
|
2009-05-26 01:17:18 -06:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2009-05-26 01:17:18 -06:00
|
|
|
static const struct option options[] = {
|
2009-05-26 01:17:18 -06:00
|
|
|
OPT_CALLBACK('e', "event", NULL, "event",
|
2009-06-06 04:24:17 -06:00
|
|
|
"event selector. use 'perf list' to list available events",
|
|
|
|
parse_events),
|
2009-05-26 01:17:18 -06:00
|
|
|
OPT_INTEGER('p', "pid", &target_pid,
|
|
|
|
"record events on existing pid"),
|
|
|
|
OPT_INTEGER('r', "realtime", &realtime_prio,
|
|
|
|
"collect data with this RT SCHED_FIFO priority"),
|
2009-08-13 02:27:19 -06:00
|
|
|
OPT_BOOLEAN('R', "raw-samples", &raw_samples,
|
|
|
|
"collect raw sample records from all opened counters"),
|
2009-05-26 01:17:18 -06:00
|
|
|
OPT_BOOLEAN('a', "all-cpus", &system_wide,
|
|
|
|
"system-wide collection from all CPUs"),
|
2009-06-02 14:59:57 -06:00
|
|
|
OPT_BOOLEAN('A', "append", &append_file,
|
|
|
|
"append to the output file to do incremental profiling"),
|
2009-08-12 03:18:01 -06:00
|
|
|
OPT_INTEGER('C', "profile_cpu", &profile_cpu,
|
|
|
|
"CPU to profile on"),
|
2009-06-02 07:52:24 -06:00
|
|
|
OPT_BOOLEAN('f', "force", &force,
|
|
|
|
"overwrite existing data file"),
|
2009-06-03 03:24:33 -06:00
|
|
|
OPT_LONG('c', "count", &default_interval,
|
2009-06-02 14:59:57 -06:00
|
|
|
"event period to sample"),
|
|
|
|
OPT_STRING('o', "output", &output_name, "file",
|
|
|
|
"output file name"),
|
|
|
|
OPT_BOOLEAN('i', "inherit", &inherit,
|
|
|
|
"child tasks inherit counters"),
|
2009-06-05 05:27:02 -06:00
|
|
|
OPT_INTEGER('F', "freq", &freq,
|
|
|
|
"profile at this frequency"),
|
2009-06-02 14:59:57 -06:00
|
|
|
OPT_INTEGER('m', "mmap-pages", &mmap_pages,
|
|
|
|
"number of mmap data pages"),
|
2009-06-14 07:04:15 -06:00
|
|
|
OPT_BOOLEAN('g', "call-graph", &call_graph,
|
|
|
|
"do call-graph (stack chain/backtrace) recording"),
|
2009-06-07 09:39:02 -06:00
|
|
|
OPT_BOOLEAN('v', "verbose", &verbose,
|
|
|
|
"be more verbose (show counter open errors, etc)"),
|
2009-06-24 13:12:48 -06:00
|
|
|
OPT_BOOLEAN('s', "stat", &inherit_stat,
|
|
|
|
"per thread counts"),
|
2009-07-16 07:44:29 -06:00
|
|
|
OPT_BOOLEAN('d', "data", &sample_address,
|
|
|
|
"Sample addresses"),
|
2009-06-24 13:12:48 -06:00
|
|
|
OPT_BOOLEAN('n', "no-samples", &no_samples,
|
|
|
|
"don't sample"),
|
2009-05-26 01:17:18 -06:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2009-07-01 04:37:06 -06:00
|
|
|
int cmd_record(int argc, const char **argv, const char *prefix __used)
|
2009-05-26 01:17:18 -06:00
|
|
|
{
|
|
|
|
int counter;
|
|
|
|
|
2009-07-22 07:04:12 -06:00
|
|
|
argc = parse_options(argc, argv, options, record_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
2009-05-27 02:10:51 -06:00
|
|
|
if (!argc && target_pid == -1 && !system_wide)
|
2009-05-26 01:17:18 -06:00
|
|
|
usage_with_options(record_usage, options);
|
|
|
|
|
2009-06-11 15:11:50 -06:00
|
|
|
if (!nr_counters) {
|
|
|
|
nr_counters = 1;
|
|
|
|
attrs[0].type = PERF_TYPE_HARDWARE;
|
|
|
|
attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
|
|
|
|
}
|
2009-05-26 01:17:18 -06:00
|
|
|
|
|
|
|
for (counter = 0; counter < nr_counters; counter++) {
|
2009-06-06 01:58:57 -06:00
|
|
|
if (attrs[counter].sample_period)
|
2009-05-26 01:17:18 -06:00
|
|
|
continue;
|
|
|
|
|
2009-06-06 01:58:57 -06:00
|
|
|
attrs[counter].sample_period = default_interval;
|
2009-05-26 01:17:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return __cmd_record(argc, argv);
|
|
|
|
}
|