[linux-2.6-block.git] / Documentation / perf_counter / builtin-record.c



#include "perf.h"
#include "util/util.h"
#include "util/parse-options.h"
#include "util/exec_cmd.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <sched.h>
#include <pthread.h>

#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <sys/uio.h>
#include <sys/mman.h>

#include <linux/unistd.h>
#include <linux/types.h>


#define ALIGN(x, a)		__ALIGN_MASK(x, (typeof(x))(a)-1)
#define __ALIGN_MASK(x, mask)	(((x)+(mask))&~(mask))

static int			nr_counters			=  0;
static __u64			event_id[MAX_COUNTERS]		= { };
static int			default_interval = 100000;
static int			event_count[MAX_COUNTERS];
static int			fd[MAX_NR_CPUS][MAX_COUNTERS];
static int			nr_cpus				=  0;
static unsigned int		page_size;
static unsigned int		mmap_pages			= 16;
static int			output;
static const char		*output_name			= "output.perf";
static int			group				= 0;
static unsigned int		realtime_prio			= 0;
static int			system_wide			= 0;
static pid_t			target_pid			= -1;
static int			inherit				= 1;
static int			nmi				= 1;

const unsigned int default_count[] = {
	1000000,
	1000000,
	  10000,
	  10000,
	1000000,
	  10000,
};

struct mmap_data {
	int counter;
	void *base;
	unsigned int mask;
	unsigned int prev;
};

static unsigned int mmap_read_head(struct mmap_data *md)
{
	struct perf_counter_mmap_page *pc = md->base;
	int head;

	head = pc->data_head;
	rmb();

	return head;
}

static long events;
static struct timeval last_read, this_read;

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
	 * the writer will bite our tail and screw up the events under us.
	 *
	 * If we somehow ended up ahead of the head, we got messed up.
	 *
	 * In either case, truncate and restart at head.
	 */
	diff = head - old;
	if (diff > md->mask / 2 || diff < 0) {
		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)
		events++;

	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;
		while (size) {
			int ret = write(output, buf, size);
			if (ret < 0) {
				perror("failed to write");
				exit(-1);
			}
			size -= ret;
			buf += ret;
		}
	}

	buf = &data[old & md->mask];
	size = head - old;
	old += size;
	while (size) {
		int ret = write(output, buf, size);
		if (ret < 0) {
			perror("failed to write");
			exit(-1);
		}
		size -= ret;
		buf += ret;
	}

	md->prev = old;
}

static volatile int done = 0;

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

static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];

static int nr_poll;
static int nr_cpu;

struct mmap_event {
	struct perf_event_header header;
	__u32 pid, tid;
	__u64 start;
	__u64 len;
	__u64 pgoff;
	char filename[PATH_MAX];
};
struct comm_event {
	struct perf_event_header header;
	__u32 pid,tid;
	char comm[16];
};

static pid_t pid_synthesize_comm_event(pid_t pid)
{
	char filename[PATH_MAX];
	char bf[BUFSIZ];
	struct comm_event comm_ev;
	size_t size;
	int fd;

	snprintf(filename, sizeof(filename), "/proc/%d/stat", pid);

	fd = open(filename, O_RDONLY);
	if (fd < 0) {
		fprintf(stderr, "couldn't open %s\n", filename);
		exit(EXIT_FAILURE);
	}
	if (read(fd, bf, sizeof(bf)) < 0) {
		fprintf(stderr, "couldn't read %s\n", filename);
		exit(EXIT_FAILURE);
	}
	close(fd);

	pid_t spid, ppid;
	char state;
	char comm[18];

	memset(&comm_ev, 0, sizeof(comm_ev));
        int nr = sscanf(bf, "%d %s %c %d %d ",
			&spid, comm, &state, &ppid, &comm_ev.pid);
	if (nr != 5) {
		fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n",
			filename);
		exit(EXIT_FAILURE);
	}
	comm_ev.header.type = PERF_EVENT_COMM;
	comm_ev.tid = pid;
	size = strlen(comm);
	comm[--size] = '\0'; /* Remove the ')' at the end */
	--size; /* Remove the '(' at the begin */
	memcpy(comm_ev.comm, comm + 1, size);
	size = ALIGN(size, sizeof(uint64_t));
	comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
	int ret = write(output, &comm_ev, comm_ev.header.size);
	if (ret < 0) {
		perror("failed to write");
		exit(-1);
	}
	return comm_ev.pid;
}

static void pid_synthesize_mmap_events(pid_t pid, pid_t pgid)
{
	char filename[PATH_MAX];
	FILE *fp;

	snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);

	fp = fopen(filename, "r");
	if (fp == NULL) {
		fprintf(stderr, "couldn't open %s\n", filename);
		exit(EXIT_FAILURE);
	}
	while (1) {
		char bf[BUFSIZ];
		unsigned char vm_read, vm_write, vm_exec, vm_mayshare;
		struct mmap_event mmap_ev = {
			.header.type = PERF_EVENT_MMAP,
		};
		unsigned long ino;
		int major, minor;
		size_t size;
		if (fgets(bf, sizeof(bf), fp) == NULL)
			break;

		/* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
		sscanf(bf, "%llx-%llx %c%c%c%c %llx %x:%x %lu",
			&mmap_ev.start, &mmap_ev.len,
                        &vm_read, &vm_write, &vm_exec, &vm_mayshare,
                        &mmap_ev.pgoff, &major, &minor, &ino);
		if (vm_exec == 'x') {
			char *execname = strrchr(bf, ' ');

			if (execname == NULL || execname[1] != '/')
				continue;

			execname += 1;
			size = strlen(execname);
			execname[size - 1] = '\0'; /* Remove \n */
			memcpy(mmap_ev.filename, execname, size);
			size = ALIGN(size, sizeof(uint64_t));
			mmap_ev.len -= mmap_ev.start;
			mmap_ev.header.size = (sizeof(mmap_ev) -
					       (sizeof(mmap_ev.filename) - size));
			mmap_ev.pid = pgid;
			mmap_ev.tid = pid;

			if (write(output, &mmap_ev, mmap_ev.header.size) < 0) {
				perror("failed to write");
				exit(-1);
			}
		}
	}

	fclose(fp);
}

static void open_counters(int cpu, pid_t pid)
{
	struct perf_counter_hw_event hw_event;
	int counter, group_fd;
	int track = 1;

	if (pid > 0) {
		pid_t pgid = pid_synthesize_comm_event(pid);
		pid_synthesize_mmap_events(pid, pgid);
	}

	group_fd = -1;
	for (counter = 0; counter < nr_counters; counter++) {

		memset(&hw_event, 0, sizeof(hw_event));
		hw_event.config		= event_id[counter];
		hw_event.irq_period	= event_count[counter];
		hw_event.record_type	= PERF_RECORD_IP | PERF_RECORD_TID;
		hw_event.nmi		= nmi;
		hw_event.mmap		= track;
		hw_event.comm		= track;
		hw_event.inherit	= (cpu < 0) && inherit;

		track = 0; // only the first counter needs these

		fd[nr_cpu][counter] =
			sys_perf_counter_open(&hw_event, pid, cpu, group_fd, 0);

		if (fd[nr_cpu][counter] < 0) {
			int err = errno;
			printf("kerneltop error: syscall returned with %d (%s)\n",
					fd[nr_cpu][counter], strerror(err));
			if (err == EPERM)
				printf("Are you root?\n");
			exit(-1);
		}
		assert(fd[nr_cpu][counter] >= 0);
		fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);

		/*
		 * 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,
				PROT_READ, MAP_SHARED, fd[nr_cpu][counter], 0);
		if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
			printf("kerneltop error: failed to mmap with %d (%s)\n",
					errno, strerror(errno));
			exit(-1);
		}
	}
	nr_cpu++;
}

static int __cmd_record(int argc, const char **argv)
{
	int i, counter;
	pid_t pid;
	int ret;

	page_size = sysconf(_SC_PAGE_SIZE);
	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	assert(nr_cpus <= MAX_NR_CPUS);
	assert(nr_cpus >= 0);

	output = open(output_name, O_CREAT|O_RDWR, S_IRWXU);
	if (output < 0) {
		perror("failed to create output file");
		exit(-1);
	}

	if (!system_wide) {
		open_counters(-1, target_pid != -1 ? target_pid : 0);
	} else for (i = 0; i < nr_cpus; i++)
		open_counters(i, target_pid);

	signal(SIGCHLD, sig_handler);
	signal(SIGINT, sig_handler);

	if (target_pid == -1) {
		pid = fork();
		if (pid < 0)
			perror("failed to fork");

		if (!pid) {
			if (execvp(argv[0], (char **)argv)) {
				perror(argv[0]);
				exit(-1);
			}
		}
	}

	if (realtime_prio) {
		struct sched_param param;

		param.sched_priority = realtime_prio;
		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
			printf("Could not set realtime priority.\n");
			exit(-1);
		}
	}

	/*
	 * TODO: store the current /proc/$/maps information somewhere
	 */

	while (!done) {
		int hits = events;

		for (i = 0; i < nr_cpu; i++) {
			for (counter = 0; counter < nr_counters; counter++)
				mmap_read(&mmap_array[i][counter]);
		}

		if (hits == events)
			ret = poll(event_array, nr_poll, 100);
	}

	return 0;
}

struct event_symbol {
	__u64 event;
	char *symbol;
};

static struct event_symbol event_symbols[] = {
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES),		"cpu-cycles",		},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES),		"cycles",		},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_INSTRUCTIONS),		"instructions",		},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_REFERENCES),		"cache-references",	},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_MISSES),		"cache-misses",		},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_INSTRUCTIONS),	"branch-instructions",	},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_INSTRUCTIONS),	"branches",		},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_MISSES),		"branch-misses",	},
	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BUS_CYCLES),		"bus-cycles",		},

	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_CLOCK),			"cpu-clock",		},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK),		"task-clock",		},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS),		"page-faults",		},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS),		"faults",		},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS_MIN),		"minor-faults",		},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS_MAJ),		"major-faults",		},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES),		"context-switches",	},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES),		"cs",			},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS),		"cpu-migrations",	},
	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS),		"migrations",		},
};

/*
 * Each event can have multiple symbolic names.
 * Symbolic names are (almost) exactly matched.
 */
static __u64 match_event_symbols(const char *str)
{
	__u64 config, id;
	int type;
	unsigned int i;

	if (sscanf(str, "r%llx", &config) == 1)
		return config | PERF_COUNTER_RAW_MASK;

	if (sscanf(str, "%d:%llu", &type, &id) == 2)
		return EID(type, id);

	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
		if (!strncmp(str, event_symbols[i].symbol,
			     strlen(event_symbols[i].symbol)))
			return event_symbols[i].event;
	}

	return ~0ULL;
}

static int parse_events(const struct option *opt, const char *str, int unset)
{
	__u64 config;

again:
	if (nr_counters == MAX_COUNTERS)
		return -1;

	config = match_event_symbols(str);
	if (config == ~0ULL)
		return -1;

	event_id[nr_counters] = config;
	nr_counters++;

	str = strstr(str, ",");
	if (str) {
		str++;
		goto again;
	}

	return 0;
}

static char events_help[100000];

#define __PERF_COUNTER_FIELD(config, name) \
	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)

#define PERF_COUNTER_RAW(config)	__PERF_COUNTER_FIELD(config, RAW)
#define PERF_COUNTER_CONFIG(config)	__PERF_COUNTER_FIELD(config, CONFIG)
#define PERF_COUNTER_TYPE(config)	__PERF_COUNTER_FIELD(config, TYPE)
#define PERF_COUNTER_ID(config)		__PERF_COUNTER_FIELD(config, EVENT)


static void create_events_help(void)
{
	unsigned int i;
	char *str;
	__u64 e;

	str = events_help;

	str += sprintf(str,
	"event name: [");

	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
		int type, id;

		e = event_symbols[i].event;
		type = PERF_COUNTER_TYPE(e);
		id = PERF_COUNTER_ID(e);

		if (i)
			str += sprintf(str, "|");

		str += sprintf(str, "%s",
				event_symbols[i].symbol);
	}

	str += sprintf(str, "|rNNN]");
}

static const char * const record_usage[] = {
	"perf record [<options>] <command>",
	NULL
};

const struct option options[] = {
	OPT_CALLBACK('e', "event", NULL, "event",
		     events_help, parse_events),
	OPT_INTEGER('c', "count", &default_interval,
		    "event period to sample"),
	OPT_INTEGER('m', "mmap-pages", &mmap_pages,
		    "number of mmap data pages"),
	OPT_STRING('o', "output", &output_name, "file",
		    "output file name"),
	OPT_BOOLEAN('i', "inherit", &inherit,
		    "child tasks inherit counters"),
	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"),
	OPT_BOOLEAN('a', "all-cpus", &system_wide,
			    "system-wide collection from all CPUs"),
	OPT_END()
};

int cmd_record(int argc, const char **argv, const char *prefix)
{
	int counter;

	create_events_help();

	argc = parse_options(argc, argv, options, record_usage, 0);
	if (!argc)
		usage_with_options(record_usage, options);

	if (!nr_counters) {
		nr_counters = 1;
		event_id[0] = 0;
	}

	for (counter = 0; counter < nr_counters; counter++) {
		if (event_count[counter])
			continue;

		event_count[counter] = default_interval;
	}

	return __cmd_record(argc, argv);
}
Commit	Line	Data
de9ac07b PZ	1
de9ac07b PZ	2
1a482f38	3	#include "perf.h"
6eda5838	4	#include "util/util.h"
0e9b20b8 IM	5	#include "util/parse-options.h"
0e9b20b8 IM	6	#include "util/exec_cmd.h"
6eda5838	7
de9ac07b PZ	8	#include <sys/types.h>
	9	#include <sys/stat.h>
	10	#include <sys/time.h>
	11	#include <unistd.h>
	12	#include <stdint.h>
	13	#include <stdlib.h>
	14	#include <string.h>
	15	#include <limits.h>
de9ac07b PZ	16	#include <assert.h>
	17	#include <fcntl.h>
	18	#include <stdio.h>
	19	#include <errno.h>
de9ac07b PZ	20	#include <time.h>
	21	#include <sched.h>
	22	#include <pthread.h>
	23
	24	#include <sys/syscall.h>
	25	#include <sys/ioctl.h>
	26	#include <sys/poll.h>
	27	#include <sys/prctl.h>
	28	#include <sys/wait.h>
	29	#include <sys/uio.h>
	30	#include <sys/mman.h>
	31
	32	#include <linux/unistd.h>
	33	#include <linux/types.h>
	34
de9ac07b	35
de9ac07b	36
0e9b20b8 IM	37	#define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1)
0e9b20b8 IM	38	#define __ALIGN_MASK(x, mask) (((x)+(mask))&~(mask))
1a853e36	39
de9ac07b PZ	40	static int nr_counters = 0;
	41	static __u64 event_id[MAX_COUNTERS] = { };
	42	static int default_interval = 100000;
	43	static int event_count[MAX_COUNTERS];
	44	static int fd[MAX_NR_CPUS][MAX_COUNTERS];
	45	static int nr_cpus = 0;
	46	static unsigned int page_size;
	47	static unsigned int mmap_pages = 16;
	48	static int output;
0e9b20b8	49	static const char *output_name = "output.perf";
de9ac07b	50	static int group = 0;
16c8a109 PZ	51	static unsigned int realtime_prio = 0;
16c8a109 PZ	52	static int system_wide = 0;
1a853e36	53	static pid_t target_pid = -1;
16c8a109 PZ	54	static int inherit = 1;
16c8a109 PZ	55	static int nmi = 1;
de9ac07b PZ	56
	57	const unsigned int default_count[] = {
	58	1000000,
	59	1000000,
	60	10000,
	61	10000,
	62	1000000,
	63	10000,
	64	};
	65
de9ac07b PZ	66	struct mmap_data {
	67	int counter;
	68	void *base;
	69	unsigned int mask;
	70	unsigned int prev;
	71	};
	72
	73	static unsigned int mmap_read_head(struct mmap_data *md)
	74	{
	75	struct perf_counter_mmap_page *pc = md->base;
	76	int head;
	77
	78	head = pc->data_head;
	79	rmb();
	80
	81	return head;
	82	}
	83
	84	static long events;
	85	static struct timeval last_read, this_read;
	86
	87	static void mmap_read(struct mmap_data *md)
	88	{
	89	unsigned int head = mmap_read_head(md);
	90	unsigned int old = md->prev;
	91	unsigned char *data = md->base + page_size;
	92	unsigned long size;
	93	void *buf;
	94	int diff;
	95
	96	gettimeofday(&this_read, NULL);
	97
	98	/*
	99	* If we're further behind than half the buffer, there's a chance
	100	* the writer will bite our tail and screw up the events under us.
	101	*
	102	* If we somehow ended up ahead of the head, we got messed up.
	103	*
	104	* In either case, truncate and restart at head.
	105	*/
	106	diff = head - old;
	107	if (diff > md->mask / 2 \|\| diff < 0) {
	108	struct timeval iv;
	109	unsigned long msecs;
	110
	111	timersub(&this_read, &last_read, &iv);
	112	msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
	113
	114	fprintf(stderr, "WARNING: failed to keep up with mmap data."
	115	" Last read %lu msecs ago.\n", msecs);
	116
	117	/*
	118	* head points to a known good entry, start there.
	119	*/
	120	old = head;
	121	}
	122
	123	last_read = this_read;
	124
	125	if (old != head)
	126	events++;
	127
	128	size = head - old;
	129
130	if ((old & md->mask) + size != (head & md->mask)) {
131	buf = &data[old & md->mask];
132	size = md->mask + 1 - (old & md->mask);
133	old += size;
134	while (size) {
135	int ret = write(output, buf, size);
136	if (ret < 0) {
137	perror("failed to write");
138	exit(-1);
139	}
140	size -= ret;
141	buf += ret;
142	}
143	}
144
145	buf = &data[old & md->mask];
146	size = head - old;
147	old += size;
148	while (size) {
149	int ret = write(output, buf, size);
150	if (ret < 0) {
151	perror("failed to write");
152	exit(-1);
153	}
154	size -= ret;
155	buf += ret;
156	}
157
158	md->prev = old;
159	}
160
161	static volatile int done = 0;
162
16c8a109	163	static void sig_handler(int sig)
de9ac07b	164	{
16c8a109	165	done = 1;
de9ac07b PZ	166	}
de9ac07b PZ	167
16c8a109 PZ	168	static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
	169	static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
	170
	171	static int nr_poll;
	172	static int nr_cpu;
	173
1a853e36 ACM	174	struct mmap_event {
	175	struct perf_event_header header;
	176	__u32 pid, tid;
	177	__u64 start;
	178	__u64 len;
	179	__u64 pgoff;
	180	char filename[PATH_MAX];
	181	};
	182	struct comm_event {
	183	struct perf_event_header header;
	184	__u32 pid,tid;
	185	char comm[16];
	186	};
	187
	188	static pid_t pid_synthesize_comm_event(pid_t pid)
	189	{
	190	char filename[PATH_MAX];
	191	char bf[BUFSIZ];
	192	struct comm_event comm_ev;
	193	size_t size;
	194	int fd;
	195
	196	snprintf(filename, sizeof(filename), "/proc/%d/stat", pid);
	197
	198	fd = open(filename, O_RDONLY);
	199	if (fd < 0) {
	200	fprintf(stderr, "couldn't open %s\n", filename);
	201	exit(EXIT_FAILURE);
	202	}
	203	if (read(fd, bf, sizeof(bf)) < 0) {
	204	fprintf(stderr, "couldn't read %s\n", filename);
	205	exit(EXIT_FAILURE);
	206	}
	207	close(fd);
	208
	209	pid_t spid, ppid;
	210	char state;
	211	char comm[18];
	212
	213	memset(&comm_ev, 0, sizeof(comm_ev));
	214	int nr = sscanf(bf, "%d %s %c %d %d ",
	215	&spid, comm, &state, &ppid, &comm_ev.pid);
	216	if (nr != 5) {
	217	fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n",
	218	filename);
	219	exit(EXIT_FAILURE);
	220	}
	221	comm_ev.header.type = PERF_EVENT_COMM;
	222	comm_ev.tid = pid;
	223	size = strlen(comm);
	224	comm[--size] = '\0'; /* Remove the ')' at the end */
	225	--size; /* Remove the '(' at the begin */
	226	memcpy(comm_ev.comm, comm + 1, size);
	227	size = ALIGN(size, sizeof(uint64_t));
	228	comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
	229	int ret = write(output, &comm_ev, comm_ev.header.size);
	230	if (ret < 0) {
	231	perror("failed to write");
	232	exit(-1);
	233	}
	234	return comm_ev.pid;
	235	}
	236
	237	static void pid_synthesize_mmap_events(pid_t pid, pid_t pgid)
238	{
239	char filename[PATH_MAX];
240	FILE *fp;
241
242	snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
243
244	fp = fopen(filename, "r");
245	if (fp == NULL) {
246	fprintf(stderr, "couldn't open %s\n", filename);
247	exit(EXIT_FAILURE);
248	}
249	while (1) {
250	char bf[BUFSIZ];
251	unsigned char vm_read, vm_write, vm_exec, vm_mayshare;
252	struct mmap_event mmap_ev = {
253	.header.type = PERF_EVENT_MMAP,
254	};
255	unsigned long ino;
256	int major, minor;
257	size_t size;
258	if (fgets(bf, sizeof(bf), fp) == NULL)
259	break;
260
261	/* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */
262	sscanf(bf, "%llx-%llx %c%c%c%c %llx %x:%x %lu",
263	&mmap_ev.start, &mmap_ev.len,
264	&vm_read, &vm_write, &vm_exec, &vm_mayshare,
265	&mmap_ev.pgoff, &major, &minor, &ino);
266	if (vm_exec == 'x') {
267	char *execname = strrchr(bf, ' ');
268
269	if (execname == NULL \|\| execname[1] != '/')
270	continue;
271
272	execname += 1;
273	size = strlen(execname);
274	execname[size - 1] = '\0'; /* Remove \n */
275	memcpy(mmap_ev.filename, execname, size);
276	size = ALIGN(size, sizeof(uint64_t));
277	mmap_ev.len -= mmap_ev.start;
278	mmap_ev.header.size = (sizeof(mmap_ev) -
279	(sizeof(mmap_ev.filename) - size));
280	mmap_ev.pid = pgid;
281	mmap_ev.tid = pid;
282
283	if (write(output, &mmap_ev, mmap_ev.header.size) < 0) {
284	perror("failed to write");
285	exit(-1);
286	}
287	}
288	}
289
290	fclose(fp);
291	}
292
293	static void open_counters(int cpu, pid_t pid)
de9ac07b	294	{
de9ac07b	295	struct perf_counter_hw_event hw_event;
16c8a109 PZ	296	int counter, group_fd;
16c8a109 PZ	297	int track = 1;
16c8a109	298
1a853e36 ACM	299	if (pid > 0) {
	300	pid_t pgid = pid_synthesize_comm_event(pid);
	301	pid_synthesize_mmap_events(pid, pgid);
	302	}
16c8a109 PZ	303
	304	group_fd = -1;
	305	for (counter = 0; counter < nr_counters; counter++) {
	306
	307	memset(&hw_event, 0, sizeof(hw_event));
	308	hw_event.config = event_id[counter];
	309	hw_event.irq_period = event_count[counter];
	310	hw_event.record_type = PERF_RECORD_IP \| PERF_RECORD_TID;
	311	hw_event.nmi = nmi;
	312	hw_event.mmap = track;
	313	hw_event.comm = track;
	314	hw_event.inherit = (cpu < 0) && inherit;
	315
	316	track = 0; // only the first counter needs these
	317
	318	fd[nr_cpu][counter] =
	319	sys_perf_counter_open(&hw_event, pid, cpu, group_fd, 0);
	320
	321	if (fd[nr_cpu][counter] < 0) {
	322	int err = errno;
	323	printf("kerneltop error: syscall returned with %d (%s)\n",
	324	fd[nr_cpu][counter], strerror(err));
	325	if (err == EPERM)
	326	printf("Are you root?\n");
	327	exit(-1);
	328	}
	329	assert(fd[nr_cpu][counter] >= 0);
	330	fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
	331
	332	/*
	333	* First counter acts as the group leader:
	334	*/
	335	if (group && group_fd == -1)
	336	group_fd = fd[nr_cpu][counter];
	337
	338	event_array[nr_poll].fd = fd[nr_cpu][counter];
	339	event_array[nr_poll].events = POLLIN;
	340	nr_poll++;
	341
	342	mmap_array[nr_cpu][counter].counter = counter;
	343	mmap_array[nr_cpu][counter].prev = 0;
	344	mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1;
	345	mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
	346	PROT_READ, MAP_SHARED, fd[nr_cpu][counter], 0);
	347	if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
	348	printf("kerneltop error: failed to mmap with %d (%s)\n",
	349	errno, strerror(errno));
	350	exit(-1);
	351	}
	352	}
	353	nr_cpu++;
	354	}
	355
0e9b20b8	356	static int __cmd_record(int argc, const char **argv)
16c8a109 PZ	357	{
16c8a109 PZ	358	int i, counter;
de9ac07b PZ	359	pid_t pid;
	360	int ret;
	361
	362	page_size = sysconf(_SC_PAGE_SIZE);
de9ac07b PZ	363	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	364	assert(nr_cpus <= MAX_NR_CPUS);
	365	assert(nr_cpus >= 0);
	366
	367	output = open(output_name, O_CREAT\|O_RDWR, S_IRWXU);
	368	if (output < 0) {
	369	perror("failed to create output file");
	370	exit(-1);
	371	}
	372
1a853e36 ACM	373	if (!system_wide) {
	374	open_counters(-1, target_pid != -1 ? target_pid : 0);
	375	} else for (i = 0; i < nr_cpus; i++)
	376	open_counters(i, target_pid);
de9ac07b	377
16c8a109 PZ	378	signal(SIGCHLD, sig_handler);
16c8a109 PZ	379	signal(SIGINT, sig_handler);
de9ac07b	380
1a853e36 ACM	381	if (target_pid == -1) {
	382	pid = fork();
	383	if (pid < 0)
	384	perror("failed to fork");
de9ac07b	385
1a853e36	386	if (!pid) {
0e9b20b8	387	if (execvp(argv[0], (char **)argv)) {
1a853e36 ACM	388	perror(argv[0]);
	389	exit(-1);
	390	}
de9ac07b PZ	391	}
	392	}
	393
	394	if (realtime_prio) {
	395	struct sched_param param;
	396
	397	param.sched_priority = realtime_prio;
	398	if (sched_setscheduler(0, SCHED_FIFO, &param)) {
	399	printf("Could not set realtime priority.\n");
	400	exit(-1);
	401	}
	402	}
	403
	404	/*
	405	* TODO: store the current /proc/$/maps information somewhere
	406	*/
	407
	408	while (!done) {
	409	int hits = events;
	410
16c8a109	411	for (i = 0; i < nr_cpu; i++) {
de9ac07b PZ	412	for (counter = 0; counter < nr_counters; counter++)
	413	mmap_read(&mmap_array[i][counter]);
	414	}
	415
	416	if (hits == events)
	417	ret = poll(event_array, nr_poll, 100);
	418	}
	419
	420	return 0;
	421	}
0e9b20b8 IM	422
	423	struct event_symbol {
	424	__u64 event;
	425	char *symbol;
	426	};
	427
	428	static struct event_symbol event_symbols[] = {
	429	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES), "cpu-cycles", },
	430	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES), "cycles", },
	431	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_INSTRUCTIONS), "instructions", },
	432	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_REFERENCES), "cache-references", },
	433	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_MISSES), "cache-misses", },
	434	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_INSTRUCTIONS), "branch-instructions", },
	435	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_INSTRUCTIONS), "branches", },
	436	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_MISSES), "branch-misses", },
	437	{EID(PERF_TYPE_HARDWARE, PERF_COUNT_BUS_CYCLES), "bus-cycles", },
	438
	439	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_CLOCK), "cpu-clock", },
	440	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK), "task-clock", },
	441	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS), "page-faults", },
	442	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS), "faults", },
	443	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS_MIN), "minor-faults", },
	444	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS_MAJ), "major-faults", },
	445	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES), "context-switches", },
	446	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES), "cs", },
	447	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS), "cpu-migrations", },
	448	{EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS), "migrations", },
	449	};
	450
	451	/*
	452	* Each event can have multiple symbolic names.
	453	* Symbolic names are (almost) exactly matched.
	454	*/
	455	static __u64 match_event_symbols(const char *str)
	456	{
	457	__u64 config, id;
	458	int type;
	459	unsigned int i;
	460
	461	if (sscanf(str, "r%llx", &config) == 1)
	462	return config \| PERF_COUNTER_RAW_MASK;
	463
	464	if (sscanf(str, "%d:%llu", &type, &id) == 2)
	465	return EID(type, id);
	466
	467	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
	468	if (!strncmp(str, event_symbols[i].symbol,
	469	strlen(event_symbols[i].symbol)))
	470	return event_symbols[i].event;
	471	}
	472
	473	return ~0ULL;
	474	}
	475
	476	static int parse_events(const struct option opt, const char str, int unset)
	477	{
	478	__u64 config;
	479
	480	again:
	481	if (nr_counters == MAX_COUNTERS)
	482	return -1;
	483
	484	config = match_event_symbols(str);
	485	if (config == ~0ULL)
486	return -1;
487
488	event_id[nr_counters] = config;
489	nr_counters++;
490
491	str = strstr(str, ",");
492	if (str) {
493	str++;
494	goto again;
495	}
496
497	return 0;
498	}
499
500	static char events_help[100000];
501
502	#define __PERF_COUNTER_FIELD(config, name) \
503	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
504
505	#define PERF_COUNTER_RAW(config) __PERF_COUNTER_FIELD(config, RAW)
506	#define PERF_COUNTER_CONFIG(config) __PERF_COUNTER_FIELD(config, CONFIG)
507	#define PERF_COUNTER_TYPE(config) __PERF_COUNTER_FIELD(config, TYPE)
508	#define PERF_COUNTER_ID(config) __PERF_COUNTER_FIELD(config, EVENT)
509
510
511
512	static void create_events_help(void)
513	{
514	unsigned int i;
515	char *str;
516	__u64 e;
517
518	str = events_help;
519
520	str += sprintf(str,
521	"event name: [");
522
523	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
524	int type, id;
525
526	e = event_symbols[i].event;
527	type = PERF_COUNTER_TYPE(e);
528	id = PERF_COUNTER_ID(e);
529
530	if (i)
531	str += sprintf(str, "\|");
532
533	str += sprintf(str, "%s",
534	event_symbols[i].symbol);
535	}
536
537	str += sprintf(str, "\|rNNN]");
538	}
539
540	static const char * const record_usage[] = {
541	"perf record [<options>] <command>",
542	NULL
543	};
544
545	const struct option options[] = {
546	OPT_CALLBACK('e', "event", NULL, "event",
547	events_help, parse_events),
548	OPT_INTEGER('c', "count", &default_interval,
549	"event period to sample"),
550	OPT_INTEGER('m', "mmap-pages", &mmap_pages,
551	"number of mmap data pages"),
552	OPT_STRING('o', "output", &output_name, "file",
553	"output file name"),
554	OPT_BOOLEAN('i', "inherit", &inherit,
555	"child tasks inherit counters"),
556	OPT_INTEGER('p', "pid", &target_pid,
557	"record events on existing pid"),
558	OPT_INTEGER('r', "realtime", &realtime_prio,
559	"collect data with this RT SCHED_FIFO priority"),
560	OPT_BOOLEAN('a', "all-cpus", &system_wide,
561	"system-wide collection from all CPUs"),
562	OPT_END()
563	};
564
565	int cmd_record(int argc, const char *argv, const char prefix)
566	{
567	int counter;
568
569	create_events_help();
570
571	argc = parse_options(argc, argv, options, record_usage, 0);
572	if (!argc)
573	usage_with_options(record_usage, options);
574
575	if (!nr_counters) {
576	nr_counters = 1;
577	event_id[0] = 0;
578	}
579
580	for (counter = 0; counter < nr_counters; counter++) {
581	if (event_count[counter])
582	continue;
583
584	event_count[counter] = default_interval;
585	}
586
587	return __cmd_record(argc, argv);
588	}