blob: 0e519c667e3ac47f8fe9576575f62dc7b1991d83 [file] [log] [blame]
Ingo Molnarabaff322009-06-02 22:59:57 +02001/*
Ingo Molnarbf9e1872009-06-02 23:37:05 +02002 * builtin-record.c
3 *
4 * Builtin record command: Record the profile of a workload
5 * (or a CPU, or a PID) into the perf.data output file - for
6 * later analysis via perf report.
Ingo Molnarabaff322009-06-02 22:59:57 +02007 */
Ingo Molnar16f762a2009-05-27 09:10:38 +02008#include "builtin.h"
Ingo Molnarbf9e1872009-06-02 23:37:05 +02009
10#include "perf.h"
11
Thomas Gleixner6eda5832009-05-01 18:29:57 +020012#include "util/util.h"
Ingo Molnar0e9b20b2009-05-26 09:17:18 +020013#include "util/parse-options.h"
Ingo Molnar8ad8db32009-05-26 11:10:09 +020014#include "util/parse-events.h"
Arnaldo Carvalho de Meloa0055ae2009-06-01 17:50:19 -030015#include "util/string.h"
Thomas Gleixner6eda5832009-05-01 18:29:57 +020016
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020017#include "util/header.h"
Frederic Weisbecker66e274f2009-08-12 11:07:25 +020018#include "util/event.h"
Frederic Weisbecker8f288272009-08-16 22:05:48 +020019#include "util/debug.h"
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020020#include "util/symbol.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020021
Peter Zijlstra97124d52009-06-02 15:52:24 +020022#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020023#include <sched.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020024
Peter Zijlstrade9ac072009-04-08 15:01:31 +020025static int fd[MAX_NR_CPUS][MAX_COUNTERS];
Ingo Molnara21ca2c2009-06-06 09:58:57 +020026
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +020027static long default_interval = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020028
Ingo Molnar42e59d72009-10-06 15:14:21 +020029static int nr_cpus = 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020030static unsigned int page_size;
Ingo Molnar42e59d72009-10-06 15:14:21 +020031static unsigned int mmap_pages = 128;
32static int freq = 1000;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020033static int output;
Ingo Molnar23ac9cb2009-05-27 09:33:18 +020034static const char *output_name = "perf.data";
Ingo Molnar42e59d72009-10-06 15:14:21 +020035static int group = 0;
36static unsigned int realtime_prio = 0;
37static int raw_samples = 0;
38static int system_wide = 0;
39static int profile_cpu = -1;
40static pid_t target_pid = -1;
41static pid_t child_pid = -1;
42static int inherit = 1;
43static int force = 0;
44static int append_file = 0;
45static int call_graph = 0;
46static int inherit_stat = 0;
47static int no_samples = 0;
48static int sample_address = 0;
49static int multiplex = 0;
50static int multiplex_fd = -1;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020051
Ingo Molnar42e59d72009-10-06 15:14:21 +020052static long samples = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020053static struct timeval last_read;
54static struct timeval this_read;
55
Ingo Molnar42e59d72009-10-06 15:14:21 +020056static u64 bytes_written = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020057
58static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
59
Ingo Molnar42e59d72009-10-06 15:14:21 +020060static int nr_poll = 0;
61static int nr_cpu = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020062
Ingo Molnar42e59d72009-10-06 15:14:21 +020063static int file_new = 1;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020064
Ingo Molnar42e59d72009-10-06 15:14:21 +020065struct perf_header *header = NULL;
Peter Zijlstraf5970552009-06-18 23:22:55 +020066
Ingo Molnara21ca2c2009-06-06 09:58:57 +020067struct mmap_data {
68 int counter;
69 void *base;
70 unsigned int mask;
71 unsigned int prev;
72};
73
74static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
75
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020076static unsigned long mmap_read_head(struct mmap_data *md)
Peter Zijlstrade9ac072009-04-08 15:01:31 +020077{
Ingo Molnarcdd6c482009-09-21 12:02:48 +020078 struct perf_event_mmap_page *pc = md->base;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020079 long head;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020080
81 head = pc->data_head;
82 rmb();
83
84 return head;
85}
86
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020087static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
88{
Ingo Molnarcdd6c482009-09-21 12:02:48 +020089 struct perf_event_mmap_page *pc = md->base;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020090
91 /*
92 * ensure all reads are done before we write the tail out.
93 */
94 /* mb(); */
95 pc->data_tail = tail;
96}
97
Peter Zijlstraf5970552009-06-18 23:22:55 +020098static void write_output(void *buf, size_t size)
99{
100 while (size) {
101 int ret = write(output, buf, size);
102
103 if (ret < 0)
104 die("failed to write");
105
106 size -= ret;
107 buf += ret;
108
109 bytes_written += ret;
110 }
111}
112
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200113static void write_event(event_t *buf, size_t size)
114{
115 /*
116 * Add it to the list of DSOs, so that when we finish this
117 * record session we can pick the available build-ids.
118 */
119 if (buf->header.type == PERF_RECORD_MMAP)
120 dsos__findnew(buf->mmap.filename);
121
122 write_output(buf, size);
123}
124
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200125static int process_synthesized_event(event_t *event)
126{
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200127 write_event(event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200128 return 0;
129}
130
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200131static void mmap_read(struct mmap_data *md)
132{
133 unsigned int head = mmap_read_head(md);
134 unsigned int old = md->prev;
135 unsigned char *data = md->base + page_size;
136 unsigned long size;
137 void *buf;
138 int diff;
139
140 gettimeofday(&this_read, NULL);
141
142 /*
143 * If we're further behind than half the buffer, there's a chance
Ingo Molnar2debbc82009-06-05 14:29:10 +0200144 * the writer will bite our tail and mess up the samples under us.
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200145 *
146 * If we somehow ended up ahead of the head, we got messed up.
147 *
148 * In either case, truncate and restart at head.
149 */
150 diff = head - old;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +0200151 if (diff < 0) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200152 struct timeval iv;
153 unsigned long msecs;
154
155 timersub(&this_read, &last_read, &iv);
156 msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
157
158 fprintf(stderr, "WARNING: failed to keep up with mmap data."
159 " Last read %lu msecs ago.\n", msecs);
160
161 /*
162 * head points to a known good entry, start there.
163 */
164 old = head;
165 }
166
167 last_read = this_read;
168
169 if (old != head)
Ingo Molnar2debbc82009-06-05 14:29:10 +0200170 samples++;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200171
172 size = head - old;
173
174 if ((old & md->mask) + size != (head & md->mask)) {
175 buf = &data[old & md->mask];
176 size = md->mask + 1 - (old & md->mask);
177 old += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200178
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200179 write_event(buf, size);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200180 }
181
182 buf = &data[old & md->mask];
183 size = head - old;
184 old += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200185
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200186 write_event(buf, size);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200187
188 md->prev = old;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +0200189 mmap_write_tail(md, old);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200190}
191
192static volatile int done = 0;
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200193static volatile int signr = -1;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200194
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200195static void sig_handler(int sig)
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200196{
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200197 done = 1;
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200198 signr = sig;
199}
200
201static void sig_atexit(void)
202{
Chris Wilson933da832009-10-04 01:35:01 +0100203 if (child_pid != -1)
204 kill(child_pid, SIGTERM);
205
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200206 if (signr == -1)
207 return;
208
209 signal(signr, SIG_DFL);
210 kill(getpid(), signr);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200211}
212
Ingo Molnarf250c0302009-06-05 13:18:41 +0200213static int group_fd;
214
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200215static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr)
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200216{
217 struct perf_header_attr *h_attr;
218
219 if (nr < header->attrs) {
220 h_attr = header->attr[nr];
221 } else {
222 h_attr = perf_header_attr__new(a);
Arnaldo Carvalho de Melodc79c0f2009-11-16 19:30:26 -0200223 if (h_attr != NULL)
Arnaldo Carvalho de Melo11deb1f2009-11-17 01:18:09 -0200224 if (perf_header__add_attr(header, h_attr) < 0) {
225 perf_header_attr__delete(h_attr);
226 h_attr = NULL;
227 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200228 }
229
230 return h_attr;
231}
232
Ingo Molnarf250c0302009-06-05 13:18:41 +0200233static void create_counter(int counter, int cpu, pid_t pid)
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200234{
Li Zefanc171b552009-10-15 11:22:07 +0800235 char *filter = filters[counter];
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200236 struct perf_event_attr *attr = attrs + counter;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200237 struct perf_header_attr *h_attr;
238 int track = !counter; /* only the first counter needs these */
Li Zefanc171b552009-10-15 11:22:07 +0800239 int ret;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200240 struct {
241 u64 count;
242 u64 time_enabled;
243 u64 time_running;
244 u64 id;
245 } read_data;
246
247 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
248 PERF_FORMAT_TOTAL_TIME_RUNNING |
249 PERF_FORMAT_ID;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200250
Frederic Weisbecker3a9f1312009-08-13 10:27:18 +0200251 attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200252
Ingo Molnar1dba15e2009-06-05 18:37:22 +0200253 if (freq) {
Peter Zijlstraea1900e2009-06-10 21:45:22 +0200254 attr->sample_type |= PERF_SAMPLE_PERIOD;
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200255 attr->freq = 1;
256 attr->sample_freq = freq;
Ingo Molnar1dba15e2009-06-05 18:37:22 +0200257 }
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200258
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200259 if (no_samples)
260 attr->sample_freq = 0;
261
262 if (inherit_stat)
263 attr->inherit_stat = 1;
264
Anton Blanchard4bba8282009-07-16 15:44:29 +0200265 if (sample_address)
266 attr->sample_type |= PERF_SAMPLE_ADDR;
267
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200268 if (call_graph)
269 attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
270
Ingo Molnarcd6feee2009-09-02 20:20:38 +0200271 if (raw_samples) {
Ingo Molnar6ddf2592009-09-03 12:00:22 +0200272 attr->sample_type |= PERF_SAMPLE_TIME;
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +0200273 attr->sample_type |= PERF_SAMPLE_RAW;
Ingo Molnarcd6feee2009-09-02 20:20:38 +0200274 attr->sample_type |= PERF_SAMPLE_CPU;
275 }
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200276
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200277 attr->mmap = track;
278 attr->comm = track;
279 attr->inherit = (cpu < 0) && inherit;
Peter Zijlstra4502d772009-06-10 15:03:06 +0200280 attr->disabled = 1;
Ingo Molnarf250c0302009-06-05 13:18:41 +0200281
Ingo Molnar3da297a2009-06-07 17:39:02 +0200282try_again:
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200283 fd[nr_cpu][counter] = sys_perf_event_open(attr, pid, cpu, group_fd, 0);
Ingo Molnarf250c0302009-06-05 13:18:41 +0200284
285 if (fd[nr_cpu][counter] < 0) {
286 int err = errno;
287
Pekka Enbergc10edee2009-11-08 18:01:06 +0200288 if (err == EPERM || err == EACCES)
Ingo Molnar3da297a2009-06-07 17:39:02 +0200289 die("Permission error - are you root?\n");
Jens Axboe0a5ac842009-08-12 11:18:01 +0200290 else if (err == ENODEV && profile_cpu != -1)
291 die("No such device - did you specify an out-of-range profile CPU?\n");
Ingo Molnar3da297a2009-06-07 17:39:02 +0200292
293 /*
294 * If it's cycles then fall back to hrtimer
295 * based cpu-clock-tick sw counter, which
296 * is always available even if no PMU support:
297 */
298 if (attr->type == PERF_TYPE_HARDWARE
Peter Zijlstraf4dbfa82009-06-11 14:06:28 +0200299 && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200300
301 if (verbose)
302 warning(" ... trying to fall back to cpu-clock-ticks\n");
303 attr->type = PERF_TYPE_SOFTWARE;
Peter Zijlstraf4dbfa82009-06-11 14:06:28 +0200304 attr->config = PERF_COUNT_SW_CPU_CLOCK;
Ingo Molnar3da297a2009-06-07 17:39:02 +0200305 goto try_again;
306 }
Ingo Molnar30c806a2009-06-07 17:46:24 +0200307 printf("\n");
308 error("perfcounter syscall returned with %d (%s)\n",
309 fd[nr_cpu][counter], strerror(err));
Simon Kaempfleinbfd45112009-11-16 15:25:53 +1000310
311#if defined(__i386__) || defined(__x86_64__)
312 if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
313 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");
314#endif
315
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200316 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
Ingo Molnarf250c0302009-06-05 13:18:41 +0200317 exit(-1);
318 }
Ingo Molnar3da297a2009-06-07 17:39:02 +0200319
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200320 h_attr = get_header_attr(attr, counter);
Arnaldo Carvalho de Melodc79c0f2009-11-16 19:30:26 -0200321 if (h_attr == NULL)
322 die("nomem\n");
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200323
324 if (!file_new) {
325 if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
326 fprintf(stderr, "incompatible append\n");
327 exit(-1);
328 }
329 }
330
Frederic Weisbecker3928ddb2009-06-25 22:21:27 +0200331 if (read(fd[nr_cpu][counter], &read_data, sizeof(read_data)) == -1) {
332 perror("Unable to read perf file descriptor\n");
333 exit(-1);
334 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200335
Arnaldo Carvalho de Melo58754122009-11-17 01:18:10 -0200336 if (perf_header_attr__add_id(h_attr, read_data.id) < 0) {
337 pr_warning("Not enough memory to add id\n");
338 exit(-1);
339 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200340
Ingo Molnarf250c0302009-06-05 13:18:41 +0200341 assert(fd[nr_cpu][counter] >= 0);
342 fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
343
344 /*
345 * First counter acts as the group leader:
346 */
347 if (group && group_fd == -1)
348 group_fd = fd[nr_cpu][counter];
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200349 if (multiplex && multiplex_fd == -1)
350 multiplex_fd = fd[nr_cpu][counter];
Ingo Molnarf250c0302009-06-05 13:18:41 +0200351
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200352 if (multiplex && fd[nr_cpu][counter] != multiplex_fd) {
Ingo Molnarf250c0302009-06-05 13:18:41 +0200353
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200354 ret = ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_SET_OUTPUT, multiplex_fd);
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200355 assert(ret != -1);
356 } else {
357 event_array[nr_poll].fd = fd[nr_cpu][counter];
358 event_array[nr_poll].events = POLLIN;
359 nr_poll++;
360
361 mmap_array[nr_cpu][counter].counter = counter;
362 mmap_array[nr_cpu][counter].prev = 0;
363 mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1;
364 mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
365 PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter], 0);
366 if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
367 error("failed to mmap with %d (%s)\n", errno, strerror(errno));
368 exit(-1);
369 }
Ingo Molnarf250c0302009-06-05 13:18:41 +0200370 }
Peter Zijlstra4502d772009-06-10 15:03:06 +0200371
Li Zefanc171b552009-10-15 11:22:07 +0800372 if (filter != NULL) {
373 ret = ioctl(fd[nr_cpu][counter],
374 PERF_EVENT_IOC_SET_FILTER, filter);
375 if (ret) {
376 error("failed to set filter with %d (%s)\n", errno,
377 strerror(errno));
378 exit(-1);
379 }
380 }
381
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200382 ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_ENABLE);
Ingo Molnarf250c0302009-06-05 13:18:41 +0200383}
384
385static void open_counters(int cpu, pid_t pid)
386{
387 int counter;
388
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200389 group_fd = -1;
Ingo Molnarf250c0302009-06-05 13:18:41 +0200390 for (counter = 0; counter < nr_counters; counter++)
391 create_counter(counter, cpu, pid);
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200392
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200393 nr_cpu++;
394}
395
Peter Zijlstraf5970552009-06-18 23:22:55 +0200396static void atexit_header(void)
397{
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200398 header->data_size += bytes_written;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200399
Frederic Weisbecker8671dab2009-11-11 04:51:03 +0100400 perf_header__write(header, output, true);
Peter Zijlstraf5970552009-06-18 23:22:55 +0200401}
402
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200403static int __cmd_record(int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200404{
405 int i, counter;
Peter Zijlstra97124d52009-06-02 15:52:24 +0200406 struct stat st;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200407 pid_t pid = 0;
Ingo Molnarabaff322009-06-02 22:59:57 +0200408 int flags;
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200409 int err;
Peter Zijlstra8b412662009-09-17 19:59:05 +0200410 unsigned long waking = 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200411
412 page_size = sysconf(_SC_PAGE_SIZE);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200413 nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
414 assert(nr_cpus <= MAX_NR_CPUS);
415 assert(nr_cpus >= 0);
416
Peter Zijlstraf5970552009-06-18 23:22:55 +0200417 atexit(sig_atexit);
418 signal(SIGCHLD, sig_handler);
419 signal(SIGINT, sig_handler);
420
Pierre Habouzit266e0e22009-08-07 14:16:01 +0200421 if (!stat(output_name, &st) && st.st_size) {
422 if (!force && !append_file) {
423 fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n",
424 output_name);
425 exit(-1);
426 }
427 } else {
428 append_file = 0;
Peter Zijlstra97124d52009-06-02 15:52:24 +0200429 }
430
Ingo Molnarabaff322009-06-02 22:59:57 +0200431 flags = O_CREAT|O_RDWR;
432 if (append_file)
Peter Zijlstraf5970552009-06-18 23:22:55 +0200433 file_new = 0;
Ingo Molnarabaff322009-06-02 22:59:57 +0200434 else
435 flags |= O_TRUNC;
436
437 output = open(output_name, flags, S_IRUSR|S_IWUSR);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200438 if (output < 0) {
439 perror("failed to create output file");
440 exit(-1);
441 }
442
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200443 header = perf_header__new();
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -0200444 if (header == NULL) {
445 pr_err("Not enough memory for reading perf file header\n");
446 return -1;
447 }
448
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200449 if (!file_new) {
450 err = perf_header__read(header, output);
451 if (err < 0)
452 return err;
453 }
454
Frederic Weisbecker9df37dd2009-08-17 23:07:50 +0200455 if (raw_samples) {
Frederic Weisbecker3e13ab22009-11-11 04:51:06 +0100456 perf_header__set_feat(header, HEADER_TRACE_INFO);
Frederic Weisbecker9df37dd2009-08-17 23:07:50 +0200457 } else {
458 for (i = 0; i < nr_counters; i++) {
459 if (attrs[i].sample_type & PERF_SAMPLE_RAW) {
Frederic Weisbecker3e13ab22009-11-11 04:51:06 +0100460 perf_header__set_feat(header, HEADER_TRACE_INFO);
Frederic Weisbecker9df37dd2009-08-17 23:07:50 +0200461 break;
462 }
463 }
464 }
Frederic Weisbecker03456a12009-10-06 23:36:47 +0200465
Peter Zijlstraf5970552009-06-18 23:22:55 +0200466 atexit(atexit_header);
467
Arnaldo Carvalho de Melo1a853e32009-05-14 22:50:46 -0300468 if (!system_wide) {
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200469 pid = target_pid;
470 if (pid == -1)
471 pid = getpid();
472
Jens Axboe0a5ac842009-08-12 11:18:01 +0200473 open_counters(profile_cpu, pid);
474 } else {
475 if (profile_cpu != -1) {
476 open_counters(profile_cpu, target_pid);
477 } else {
478 for (i = 0; i < nr_cpus; i++)
479 open_counters(i, target_pid);
480 }
481 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200482
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200483 if (file_new) {
484 err = perf_header__write(header, output, false);
485 if (err < 0)
486 return err;
487 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200488
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200489 if (!system_wide)
490 event__synthesize_thread(pid, process_synthesized_event);
491 else
492 event__synthesize_threads(process_synthesized_event);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200493
Mike Galbraithef65b2a2009-05-27 10:10:51 +0200494 if (target_pid == -1 && argc) {
Arnaldo Carvalho de Melo1a853e32009-05-14 22:50:46 -0300495 pid = fork();
496 if (pid < 0)
Frederic Weisbeckerde896722009-11-11 04:51:02 +0100497 die("failed to fork");
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200498
Arnaldo Carvalho de Melo1a853e32009-05-14 22:50:46 -0300499 if (!pid) {
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200500 if (execvp(argv[0], (char **)argv)) {
Arnaldo Carvalho de Melo1a853e32009-05-14 22:50:46 -0300501 perror(argv[0]);
502 exit(-1);
503 }
Frederic Weisbeckerde896722009-11-11 04:51:02 +0100504 } else {
505 /*
506 * Wait a bit for the execv'ed child to appear
507 * and be updated in /proc
508 * FIXME: Do you know a less heuristical solution?
509 */
510 usleep(1000);
511 event__synthesize_thread(pid,
512 process_synthesized_event);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200513 }
Chris Wilson933da832009-10-04 01:35:01 +0100514
515 child_pid = pid;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200516 }
517
518 if (realtime_prio) {
519 struct sched_param param;
520
521 param.sched_priority = realtime_prio;
522 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -0200523 pr_err("Could not set realtime priority.\n");
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200524 exit(-1);
525 }
526 }
527
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200528 for (;;) {
Ingo Molnar2debbc82009-06-05 14:29:10 +0200529 int hits = samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200530
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200531 for (i = 0; i < nr_cpu; i++) {
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200532 for (counter = 0; counter < nr_counters; counter++) {
533 if (mmap_array[i][counter].base)
534 mmap_read(&mmap_array[i][counter]);
535 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200536 }
537
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200538 if (hits == samples) {
539 if (done)
540 break;
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200541 err = poll(event_array, nr_poll, -1);
Peter Zijlstra8b412662009-09-17 19:59:05 +0200542 waking++;
543 }
544
545 if (done) {
546 for (i = 0; i < nr_cpu; i++) {
547 for (counter = 0; counter < nr_counters; counter++)
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200548 ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE);
Peter Zijlstra8b412662009-09-17 19:59:05 +0200549 }
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200550 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200551 }
552
Peter Zijlstra8b412662009-09-17 19:59:05 +0200553 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
554
Ingo Molnar021e9f42009-06-03 19:27:19 +0200555 /*
556 * Approximate RIP event size: 24 bytes.
557 */
558 fprintf(stderr,
Ingo Molnar2debbc82009-06-05 14:29:10 +0200559 "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n",
Ingo Molnar021e9f42009-06-03 19:27:19 +0200560 (double)bytes_written / 1024.0 / 1024.0,
561 output_name,
562 bytes_written / 24);
Ingo Molnaraddc2782009-06-02 23:43:11 +0200563
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200564 return 0;
565}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200566
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200567static const char * const record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +0200568 "perf record [<options>] [<command>]",
569 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200570 NULL
571};
572
Ingo Molnar52425192009-05-26 09:17:18 +0200573static const struct option options[] = {
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200574 OPT_CALLBACK('e', "event", NULL, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +0200575 "event selector. use 'perf list' to list available events",
576 parse_events),
Li Zefanc171b552009-10-15 11:22:07 +0800577 OPT_CALLBACK(0, "filter", NULL, "filter",
578 "event filter", parse_filter),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200579 OPT_INTEGER('p', "pid", &target_pid,
580 "record events on existing pid"),
581 OPT_INTEGER('r', "realtime", &realtime_prio,
582 "collect data with this RT SCHED_FIFO priority"),
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +0200583 OPT_BOOLEAN('R', "raw-samples", &raw_samples,
584 "collect raw sample records from all opened counters"),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200585 OPT_BOOLEAN('a', "all-cpus", &system_wide,
586 "system-wide collection from all CPUs"),
Ingo Molnarabaff322009-06-02 22:59:57 +0200587 OPT_BOOLEAN('A', "append", &append_file,
588 "append to the output file to do incremental profiling"),
Jens Axboe0a5ac842009-08-12 11:18:01 +0200589 OPT_INTEGER('C', "profile_cpu", &profile_cpu,
590 "CPU to profile on"),
Peter Zijlstra97124d52009-06-02 15:52:24 +0200591 OPT_BOOLEAN('f', "force", &force,
592 "overwrite existing data file"),
Peter Zijlstrae61078a2009-06-03 11:24:33 +0200593 OPT_LONG('c', "count", &default_interval,
Ingo Molnarabaff322009-06-02 22:59:57 +0200594 "event period to sample"),
595 OPT_STRING('o', "output", &output_name, "file",
596 "output file name"),
597 OPT_BOOLEAN('i', "inherit", &inherit,
598 "child tasks inherit counters"),
Ingo Molnarcf1f4572009-06-05 13:27:02 +0200599 OPT_INTEGER('F', "freq", &freq,
600 "profile at this frequency"),
Ingo Molnarabaff322009-06-02 22:59:57 +0200601 OPT_INTEGER('m', "mmap-pages", &mmap_pages,
602 "number of mmap data pages"),
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200603 OPT_BOOLEAN('g', "call-graph", &call_graph,
604 "do call-graph (stack chain/backtrace) recording"),
Ingo Molnar3da297a2009-06-07 17:39:02 +0200605 OPT_BOOLEAN('v', "verbose", &verbose,
606 "be more verbose (show counter open errors, etc)"),
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200607 OPT_BOOLEAN('s', "stat", &inherit_stat,
608 "per thread counts"),
Anton Blanchard4bba8282009-07-16 15:44:29 +0200609 OPT_BOOLEAN('d', "data", &sample_address,
610 "Sample addresses"),
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200611 OPT_BOOLEAN('n', "no-samples", &no_samples,
612 "don't sample"),
Frederic Weisbeckerd1302522009-09-14 08:57:15 +0200613 OPT_BOOLEAN('M', "multiplex", &multiplex,
614 "multiplex counter output in a single channel"),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200615 OPT_END()
616};
617
Ingo Molnarf37a2912009-07-01 12:37:06 +0200618int cmd_record(int argc, const char **argv, const char *prefix __used)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200619{
620 int counter;
621
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200622 symbol__init(0);
623
Anton Blancharda0541232009-07-22 23:04:12 +1000624 argc = parse_options(argc, argv, options, record_usage,
625 PARSE_OPT_STOP_AT_NON_OPTION);
Mike Galbraithef65b2a2009-05-27 10:10:51 +0200626 if (!argc && target_pid == -1 && !system_wide)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200627 usage_with_options(record_usage, options);
628
Peter Zijlstrabbd36e52009-06-11 23:11:50 +0200629 if (!nr_counters) {
630 nr_counters = 1;
631 attrs[0].type = PERF_TYPE_HARDWARE;
632 attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
633 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200634
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +0200635 /*
636 * User specified count overrides default frequency.
637 */
638 if (default_interval)
639 freq = 0;
640 else if (freq) {
641 default_interval = freq;
642 } else {
643 fprintf(stderr, "frequency and count are zero, aborting\n");
644 exit(EXIT_FAILURE);
645 }
646
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200647 for (counter = 0; counter < nr_counters; counter++) {
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200648 if (attrs[counter].sample_period)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200649 continue;
650
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200651 attrs[counter].sample_period = default_interval;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200652 }
653
654 return __cmd_record(argc, argv);
655}