blob: 90345223908ca074984bae6714355533de34fda2 [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 Melo94c744b2009-12-11 21:24:02 -020020#include "util/session.h"
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020021#include "util/symbol.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020022
Peter Zijlstra97124d52009-06-02 15:52:24 +020023#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020024#include <sched.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020025
Peter Zijlstrade9ac072009-04-08 15:01:31 +020026static int fd[MAX_NR_CPUS][MAX_COUNTERS];
Ingo Molnara21ca2c2009-06-06 09:58:57 +020027
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +020028static long default_interval = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020029
Ingo Molnar42e59d72009-10-06 15:14:21 +020030static int nr_cpus = 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020031static unsigned int page_size;
Ingo Molnar42e59d72009-10-06 15:14:21 +020032static unsigned int mmap_pages = 128;
33static int freq = 1000;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020034static int output;
Ingo Molnar23ac9cb2009-05-27 09:33:18 +020035static const char *output_name = "perf.data";
Ingo Molnar42e59d72009-10-06 15:14:21 +020036static int group = 0;
37static unsigned int realtime_prio = 0;
38static int raw_samples = 0;
39static int system_wide = 0;
40static int profile_cpu = -1;
41static pid_t target_pid = -1;
42static pid_t child_pid = -1;
43static int inherit = 1;
44static int force = 0;
45static int append_file = 0;
46static int call_graph = 0;
47static int inherit_stat = 0;
48static int no_samples = 0;
49static int sample_address = 0;
50static int multiplex = 0;
51static int multiplex_fd = -1;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020052
Ingo Molnar42e59d72009-10-06 15:14:21 +020053static long samples = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020054static struct timeval last_read;
55static struct timeval this_read;
56
Ingo Molnar42e59d72009-10-06 15:14:21 +020057static u64 bytes_written = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020058
59static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
60
Ingo Molnar42e59d72009-10-06 15:14:21 +020061static int nr_poll = 0;
62static int nr_cpu = 0;
Ingo Molnara21ca2c2009-06-06 09:58:57 +020063
Ingo Molnar42e59d72009-10-06 15:14:21 +020064static int file_new = 1;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020065
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020066static struct perf_session *session;
Peter Zijlstraf5970552009-06-18 23:22:55 +020067
Ingo Molnara21ca2c2009-06-06 09:58:57 +020068struct mmap_data {
69 int counter;
70 void *base;
71 unsigned int mask;
72 unsigned int prev;
73};
74
75static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
76
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020077static unsigned long mmap_read_head(struct mmap_data *md)
Peter Zijlstrade9ac072009-04-08 15:01:31 +020078{
Ingo Molnarcdd6c482009-09-21 12:02:48 +020079 struct perf_event_mmap_page *pc = md->base;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020080 long head;
Peter Zijlstrade9ac072009-04-08 15:01:31 +020081
82 head = pc->data_head;
83 rmb();
84
85 return head;
86}
87
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020088static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
89{
Ingo Molnarcdd6c482009-09-21 12:02:48 +020090 struct perf_event_mmap_page *pc = md->base;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +020091
92 /*
93 * ensure all reads are done before we write the tail out.
94 */
95 /* mb(); */
96 pc->data_tail = tail;
97}
98
Peter Zijlstraf5970552009-06-18 23:22:55 +020099static void write_output(void *buf, size_t size)
100{
101 while (size) {
102 int ret = write(output, buf, size);
103
104 if (ret < 0)
105 die("failed to write");
106
107 size -= ret;
108 buf += ret;
109
110 bytes_written += ret;
111 }
112}
113
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200114static void write_event(event_t *buf, size_t size)
115{
Arnaldo Carvalho de Melof5a2c3d2010-01-15 18:08:26 -0200116 size_t processed_size = buf->header.size;
117 event_t *ev = buf;
118
119 do {
120 /*
121 * Add it to the list of DSOs, so that when we finish this
122 * record session we can pick the available build-ids.
123 */
124 if (ev->header.type == PERF_RECORD_MMAP) {
125 struct list_head *head = &dsos__user;
126 if (ev->header.misc == 1)
127 head = &dsos__kernel;
128 __dsos__findnew(head, ev->mmap.filename);
129 }
130
131 ev = ((void *)ev) + ev->header.size;
132 processed_size += ev->header.size;
133 } while (processed_size < size);
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200134
135 write_output(buf, size);
136}
137
Arnaldo Carvalho de Melod8f66242009-12-13 19:50:24 -0200138static int process_synthesized_event(event_t *event,
139 struct perf_session *self __used)
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200140{
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200141 write_event(event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200142 return 0;
143}
144
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200145static void mmap_read(struct mmap_data *md)
146{
147 unsigned int head = mmap_read_head(md);
148 unsigned int old = md->prev;
149 unsigned char *data = md->base + page_size;
150 unsigned long size;
151 void *buf;
152 int diff;
153
154 gettimeofday(&this_read, NULL);
155
156 /*
157 * If we're further behind than half the buffer, there's a chance
Ingo Molnar2debbc82009-06-05 14:29:10 +0200158 * the writer will bite our tail and mess up the samples under us.
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200159 *
160 * If we somehow ended up ahead of the head, we got messed up.
161 *
162 * In either case, truncate and restart at head.
163 */
164 diff = head - old;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +0200165 if (diff < 0) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200166 struct timeval iv;
167 unsigned long msecs;
168
169 timersub(&this_read, &last_read, &iv);
170 msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
171
172 fprintf(stderr, "WARNING: failed to keep up with mmap data."
173 " Last read %lu msecs ago.\n", msecs);
174
175 /*
176 * head points to a known good entry, start there.
177 */
178 old = head;
179 }
180
181 last_read = this_read;
182
183 if (old != head)
Ingo Molnar2debbc82009-06-05 14:29:10 +0200184 samples++;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200185
186 size = head - old;
187
188 if ((old & md->mask) + size != (head & md->mask)) {
189 buf = &data[old & md->mask];
190 size = md->mask + 1 - (old & md->mask);
191 old += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200192
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200193 write_event(buf, size);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200194 }
195
196 buf = &data[old & md->mask];
197 size = head - old;
198 old += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200199
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -0200200 write_event(buf, size);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200201
202 md->prev = old;
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +0200203 mmap_write_tail(md, old);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200204}
205
206static volatile int done = 0;
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200207static volatile int signr = -1;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200208
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200209static void sig_handler(int sig)
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200210{
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200211 done = 1;
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200212 signr = sig;
213}
214
215static void sig_atexit(void)
216{
Chris Wilson933da832009-10-04 01:35:01 +0100217 if (child_pid != -1)
218 kill(child_pid, SIGTERM);
219
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200220 if (signr == -1)
221 return;
222
223 signal(signr, SIG_DFL);
224 kill(getpid(), signr);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200225}
226
Ingo Molnarf250c0302009-06-05 13:18:41 +0200227static int group_fd;
228
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200229static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr)
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200230{
231 struct perf_header_attr *h_attr;
232
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200233 if (nr < session->header.attrs) {
234 h_attr = session->header.attr[nr];
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200235 } else {
236 h_attr = perf_header_attr__new(a);
Arnaldo Carvalho de Melodc79c0f2009-11-16 19:30:26 -0200237 if (h_attr != NULL)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200238 if (perf_header__add_attr(&session->header, h_attr) < 0) {
Arnaldo Carvalho de Melo11deb1f2009-11-17 01:18:09 -0200239 perf_header_attr__delete(h_attr);
240 h_attr = NULL;
241 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200242 }
243
244 return h_attr;
245}
246
Ingo Molnarf250c0302009-06-05 13:18:41 +0200247static void create_counter(int counter, int cpu, pid_t pid)
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200248{
Li Zefanc171b552009-10-15 11:22:07 +0800249 char *filter = filters[counter];
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200250 struct perf_event_attr *attr = attrs + counter;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200251 struct perf_header_attr *h_attr;
252 int track = !counter; /* only the first counter needs these */
Li Zefanc171b552009-10-15 11:22:07 +0800253 int ret;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200254 struct {
255 u64 count;
256 u64 time_enabled;
257 u64 time_running;
258 u64 id;
259 } read_data;
260
261 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
262 PERF_FORMAT_TOTAL_TIME_RUNNING |
263 PERF_FORMAT_ID;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200264
Frederic Weisbecker3a9f1312009-08-13 10:27:18 +0200265 attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200266
Ingo Molnar1dba15e2009-06-05 18:37:22 +0200267 if (freq) {
Peter Zijlstraea1900e2009-06-10 21:45:22 +0200268 attr->sample_type |= PERF_SAMPLE_PERIOD;
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200269 attr->freq = 1;
270 attr->sample_freq = freq;
Ingo Molnar1dba15e2009-06-05 18:37:22 +0200271 }
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200272
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200273 if (no_samples)
274 attr->sample_freq = 0;
275
276 if (inherit_stat)
277 attr->inherit_stat = 1;
278
Anton Blanchard4bba8282009-07-16 15:44:29 +0200279 if (sample_address)
280 attr->sample_type |= PERF_SAMPLE_ADDR;
281
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200282 if (call_graph)
283 attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
284
Ingo Molnarcd6feee2009-09-02 20:20:38 +0200285 if (raw_samples) {
Ingo Molnar6ddf2592009-09-03 12:00:22 +0200286 attr->sample_type |= PERF_SAMPLE_TIME;
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +0200287 attr->sample_type |= PERF_SAMPLE_RAW;
Ingo Molnarcd6feee2009-09-02 20:20:38 +0200288 attr->sample_type |= PERF_SAMPLE_CPU;
289 }
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200290
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200291 attr->mmap = track;
292 attr->comm = track;
Peter Zijlstra60ab2712009-12-16 17:55:56 +0100293 attr->inherit = inherit;
Peter Zijlstra4502d772009-06-10 15:03:06 +0200294 attr->disabled = 1;
Ingo Molnarf250c0302009-06-05 13:18:41 +0200295
Ingo Molnar3da297a2009-06-07 17:39:02 +0200296try_again:
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200297 fd[nr_cpu][counter] = sys_perf_event_open(attr, pid, cpu, group_fd, 0);
Ingo Molnarf250c0302009-06-05 13:18:41 +0200298
299 if (fd[nr_cpu][counter] < 0) {
300 int err = errno;
301
Pekka Enbergc10edee2009-11-08 18:01:06 +0200302 if (err == EPERM || err == EACCES)
Ingo Molnar3da297a2009-06-07 17:39:02 +0200303 die("Permission error - are you root?\n");
Jens Axboe0a5ac842009-08-12 11:18:01 +0200304 else if (err == ENODEV && profile_cpu != -1)
305 die("No such device - did you specify an out-of-range profile CPU?\n");
Ingo Molnar3da297a2009-06-07 17:39:02 +0200306
307 /*
308 * If it's cycles then fall back to hrtimer
309 * based cpu-clock-tick sw counter, which
310 * is always available even if no PMU support:
311 */
312 if (attr->type == PERF_TYPE_HARDWARE
Peter Zijlstraf4dbfa82009-06-11 14:06:28 +0200313 && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200314
315 if (verbose)
316 warning(" ... trying to fall back to cpu-clock-ticks\n");
317 attr->type = PERF_TYPE_SOFTWARE;
Peter Zijlstraf4dbfa82009-06-11 14:06:28 +0200318 attr->config = PERF_COUNT_SW_CPU_CLOCK;
Ingo Molnar3da297a2009-06-07 17:39:02 +0200319 goto try_again;
320 }
Ingo Molnar30c806a2009-06-07 17:46:24 +0200321 printf("\n");
322 error("perfcounter syscall returned with %d (%s)\n",
323 fd[nr_cpu][counter], strerror(err));
Simon Kaempfleinbfd45112009-11-16 15:25:53 +1000324
325#if defined(__i386__) || defined(__x86_64__)
326 if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
327 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");
328#endif
329
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200330 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
Ingo Molnarf250c0302009-06-05 13:18:41 +0200331 exit(-1);
332 }
Ingo Molnar3da297a2009-06-07 17:39:02 +0200333
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200334 h_attr = get_header_attr(attr, counter);
Arnaldo Carvalho de Melodc79c0f2009-11-16 19:30:26 -0200335 if (h_attr == NULL)
336 die("nomem\n");
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200337
338 if (!file_new) {
339 if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
340 fprintf(stderr, "incompatible append\n");
341 exit(-1);
342 }
343 }
344
Frederic Weisbecker3928ddb2009-06-25 22:21:27 +0200345 if (read(fd[nr_cpu][counter], &read_data, sizeof(read_data)) == -1) {
346 perror("Unable to read perf file descriptor\n");
347 exit(-1);
348 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200349
Arnaldo Carvalho de Melo58754122009-11-17 01:18:10 -0200350 if (perf_header_attr__add_id(h_attr, read_data.id) < 0) {
351 pr_warning("Not enough memory to add id\n");
352 exit(-1);
353 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200354
Ingo Molnarf250c0302009-06-05 13:18:41 +0200355 assert(fd[nr_cpu][counter] >= 0);
356 fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
357
358 /*
359 * First counter acts as the group leader:
360 */
361 if (group && group_fd == -1)
362 group_fd = fd[nr_cpu][counter];
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200363 if (multiplex && multiplex_fd == -1)
364 multiplex_fd = fd[nr_cpu][counter];
Ingo Molnarf250c0302009-06-05 13:18:41 +0200365
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200366 if (multiplex && fd[nr_cpu][counter] != multiplex_fd) {
Ingo Molnarf250c0302009-06-05 13:18:41 +0200367
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200368 ret = ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_SET_OUTPUT, multiplex_fd);
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200369 assert(ret != -1);
370 } else {
371 event_array[nr_poll].fd = fd[nr_cpu][counter];
372 event_array[nr_poll].events = POLLIN;
373 nr_poll++;
374
375 mmap_array[nr_cpu][counter].counter = counter;
376 mmap_array[nr_cpu][counter].prev = 0;
377 mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1;
378 mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
379 PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter], 0);
380 if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
381 error("failed to mmap with %d (%s)\n", errno, strerror(errno));
382 exit(-1);
383 }
Ingo Molnarf250c0302009-06-05 13:18:41 +0200384 }
Peter Zijlstra4502d772009-06-10 15:03:06 +0200385
Li Zefanc171b552009-10-15 11:22:07 +0800386 if (filter != NULL) {
387 ret = ioctl(fd[nr_cpu][counter],
388 PERF_EVENT_IOC_SET_FILTER, filter);
389 if (ret) {
390 error("failed to set filter with %d (%s)\n", errno,
391 strerror(errno));
392 exit(-1);
393 }
394 }
395
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200396 ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_ENABLE);
Ingo Molnarf250c0302009-06-05 13:18:41 +0200397}
398
399static void open_counters(int cpu, pid_t pid)
400{
401 int counter;
402
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200403 group_fd = -1;
Ingo Molnarf250c0302009-06-05 13:18:41 +0200404 for (counter = 0; counter < nr_counters; counter++)
405 create_counter(counter, cpu, pid);
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200406
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200407 nr_cpu++;
408}
409
Peter Zijlstraf5970552009-06-18 23:22:55 +0200410static void atexit_header(void)
411{
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200412 session->header.data_size += bytes_written;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200413
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200414 perf_header__write(&session->header, output, true);
Peter Zijlstraf5970552009-06-18 23:22:55 +0200415}
416
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200417static int __cmd_record(int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200418{
419 int i, counter;
Peter Zijlstra97124d52009-06-02 15:52:24 +0200420 struct stat st;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200421 pid_t pid = 0;
Ingo Molnarabaff322009-06-02 22:59:57 +0200422 int flags;
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200423 int err;
Peter Zijlstra8b412662009-09-17 19:59:05 +0200424 unsigned long waking = 0;
Peter Zijlstra856e9662009-12-16 17:55:55 +0100425 int child_ready_pipe[2], go_pipe[2];
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200426 const bool forks = target_pid == -1 && argc > 0;
Peter Zijlstra856e9662009-12-16 17:55:55 +0100427 char buf;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200428
429 page_size = sysconf(_SC_PAGE_SIZE);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200430 nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
431 assert(nr_cpus <= MAX_NR_CPUS);
432 assert(nr_cpus >= 0);
433
Peter Zijlstraf5970552009-06-18 23:22:55 +0200434 atexit(sig_atexit);
435 signal(SIGCHLD, sig_handler);
436 signal(SIGINT, sig_handler);
437
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200438 if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
Peter Zijlstra856e9662009-12-16 17:55:55 +0100439 perror("failed to create pipes");
440 exit(-1);
441 }
442
Pierre Habouzit266e0e22009-08-07 14:16:01 +0200443 if (!stat(output_name, &st) && st.st_size) {
Arnaldo Carvalho de Melob38d3462009-12-14 20:09:30 -0200444 if (!force) {
445 if (!append_file) {
446 pr_err("Error, output file %s exists, use -A "
447 "to append or -f to overwrite.\n",
448 output_name);
449 exit(-1);
450 }
451 } else {
452 char oldname[PATH_MAX];
453 snprintf(oldname, sizeof(oldname), "%s.old",
454 output_name);
455 unlink(oldname);
456 rename(output_name, oldname);
Pierre Habouzit266e0e22009-08-07 14:16:01 +0200457 }
458 } else {
459 append_file = 0;
Peter Zijlstra97124d52009-06-02 15:52:24 +0200460 }
461
Ingo Molnarabaff322009-06-02 22:59:57 +0200462 flags = O_CREAT|O_RDWR;
463 if (append_file)
Peter Zijlstraf5970552009-06-18 23:22:55 +0200464 file_new = 0;
Ingo Molnarabaff322009-06-02 22:59:57 +0200465 else
466 flags |= O_TRUNC;
467
468 output = open(output_name, flags, S_IRUSR|S_IWUSR);
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200469 if (output < 0) {
470 perror("failed to create output file");
471 exit(-1);
472 }
473
Arnaldo Carvalho de Melo75be6cf2009-12-15 20:04:39 -0200474 session = perf_session__new(output_name, O_WRONLY, force);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200475 if (session == NULL) {
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -0200476 pr_err("Not enough memory for reading perf file header\n");
477 return -1;
478 }
479
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200480 if (!file_new) {
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200481 err = perf_header__read(&session->header, output);
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200482 if (err < 0)
483 return err;
484 }
485
Frederic Weisbecker9df37dd2009-08-17 23:07:50 +0200486 if (raw_samples) {
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200487 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
Frederic Weisbecker9df37dd2009-08-17 23:07:50 +0200488 } else {
489 for (i = 0; i < nr_counters; i++) {
490 if (attrs[i].sample_type & PERF_SAMPLE_RAW) {
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200491 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
Frederic Weisbecker9df37dd2009-08-17 23:07:50 +0200492 break;
493 }
494 }
495 }
Frederic Weisbecker03456a12009-10-06 23:36:47 +0200496
Peter Zijlstraf5970552009-06-18 23:22:55 +0200497 atexit(atexit_header);
498
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200499 if (forks) {
Peter Zijlstra856e9662009-12-16 17:55:55 +0100500 pid = fork();
501 if (pid < 0) {
502 perror("failed to fork");
503 exit(-1);
Jens Axboe0a5ac842009-08-12 11:18:01 +0200504 }
Peter Zijlstra856e9662009-12-16 17:55:55 +0100505
506 if (!pid) {
507 close(child_ready_pipe[0]);
508 close(go_pipe[1]);
509 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
510
511 /*
512 * Do a dummy execvp to get the PLT entry resolved,
513 * so we avoid the resolver overhead on the real
514 * execvp call.
515 */
516 execvp("", (char **)argv);
517
518 /*
519 * Tell the parent we're ready to go
520 */
521 close(child_ready_pipe[1]);
522
523 /*
524 * Wait until the parent tells us to go.
525 */
526 if (read(go_pipe[0], &buf, 1) == -1)
527 perror("unable to read pipe");
528
529 execvp(argv[0], (char **)argv);
530
531 perror(argv[0]);
532 exit(-1);
533 }
534
535 child_pid = pid;
536
537 if (!system_wide)
538 target_pid = pid;
539
540 close(child_ready_pipe[1]);
541 close(go_pipe[0]);
542 /*
543 * wait for child to settle
544 */
545 if (read(child_ready_pipe[0], &buf, 1) == -1) {
546 perror("unable to read pipe");
547 exit(-1);
548 }
549 close(child_ready_pipe[0]);
550 }
551
552
Peter Zijlstra60ab2712009-12-16 17:55:56 +0100553 if ((!system_wide && !inherit) || profile_cpu != -1) {
Peter Zijlstra856e9662009-12-16 17:55:55 +0100554 open_counters(profile_cpu, target_pid);
555 } else {
556 for (i = 0; i < nr_cpus; i++)
557 open_counters(i, target_pid);
Jens Axboe0a5ac842009-08-12 11:18:01 +0200558 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200559
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200560 if (file_new) {
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200561 err = perf_header__write(&session->header, output, false);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200562 if (err < 0)
563 return err;
564 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200565
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -0200566 err = event__synthesize_kernel_mmap(process_synthesized_event,
567 session, "_text");
568 if (err < 0) {
569 pr_err("Couldn't record kernel reference relocation symbol.\n");
570 return err;
571 }
572
Arnaldo Carvalho de Melob7cece72010-01-13 13:22:17 -0200573 err = event__synthesize_modules(process_synthesized_event, session);
574 if (err < 0) {
575 pr_err("Couldn't record kernel reference relocation symbol.\n");
576 return err;
577 }
578
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200579 if (!system_wide && profile_cpu == -1)
Arnaldo Carvalho de Melod8f66242009-12-13 19:50:24 -0200580 event__synthesize_thread(pid, process_synthesized_event,
581 session);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200582 else
Arnaldo Carvalho de Melod8f66242009-12-13 19:50:24 -0200583 event__synthesize_threads(process_synthesized_event, session);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200584
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200585 if (realtime_prio) {
586 struct sched_param param;
587
588 param.sched_priority = realtime_prio;
589 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -0200590 pr_err("Could not set realtime priority.\n");
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200591 exit(-1);
592 }
593 }
594
Peter Zijlstra856e9662009-12-16 17:55:55 +0100595 /*
596 * Let the child rip
597 */
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200598 if (forks)
599 close(go_pipe[1]);
Peter Zijlstra856e9662009-12-16 17:55:55 +0100600
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200601 for (;;) {
Ingo Molnar2debbc82009-06-05 14:29:10 +0200602 int hits = samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200603
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200604 for (i = 0; i < nr_cpu; i++) {
Ingo Molnarea57c4f2009-09-13 18:15:54 +0200605 for (counter = 0; counter < nr_counters; counter++) {
606 if (mmap_array[i][counter].base)
607 mmap_read(&mmap_array[i][counter]);
608 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200609 }
610
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200611 if (hits == samples) {
612 if (done)
613 break;
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -0200614 err = poll(event_array, nr_poll, -1);
Peter Zijlstra8b412662009-09-17 19:59:05 +0200615 waking++;
616 }
617
618 if (done) {
619 for (i = 0; i < nr_cpu; i++) {
620 for (counter = 0; counter < nr_counters; counter++)
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200621 ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE);
Peter Zijlstra8b412662009-09-17 19:59:05 +0200622 }
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200623 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200624 }
625
Peter Zijlstra8b412662009-09-17 19:59:05 +0200626 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
627
Ingo Molnar021e9f42009-06-03 19:27:19 +0200628 /*
629 * Approximate RIP event size: 24 bytes.
630 */
631 fprintf(stderr,
Ingo Molnar2debbc82009-06-05 14:29:10 +0200632 "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n",
Ingo Molnar021e9f42009-06-03 19:27:19 +0200633 (double)bytes_written / 1024.0 / 1024.0,
634 output_name,
635 bytes_written / 24);
Ingo Molnaraddc2782009-06-02 23:43:11 +0200636
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200637 return 0;
638}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200639
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200640static const char * const record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +0200641 "perf record [<options>] [<command>]",
642 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200643 NULL
644};
645
Ingo Molnar52425192009-05-26 09:17:18 +0200646static const struct option options[] = {
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200647 OPT_CALLBACK('e', "event", NULL, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +0200648 "event selector. use 'perf list' to list available events",
649 parse_events),
Li Zefanc171b552009-10-15 11:22:07 +0800650 OPT_CALLBACK(0, "filter", NULL, "filter",
651 "event filter", parse_filter),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200652 OPT_INTEGER('p', "pid", &target_pid,
653 "record events on existing pid"),
654 OPT_INTEGER('r', "realtime", &realtime_prio,
655 "collect data with this RT SCHED_FIFO priority"),
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +0200656 OPT_BOOLEAN('R', "raw-samples", &raw_samples,
657 "collect raw sample records from all opened counters"),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200658 OPT_BOOLEAN('a', "all-cpus", &system_wide,
659 "system-wide collection from all CPUs"),
Ingo Molnarabaff322009-06-02 22:59:57 +0200660 OPT_BOOLEAN('A', "append", &append_file,
661 "append to the output file to do incremental profiling"),
Jens Axboe0a5ac842009-08-12 11:18:01 +0200662 OPT_INTEGER('C', "profile_cpu", &profile_cpu,
663 "CPU to profile on"),
Peter Zijlstra97124d52009-06-02 15:52:24 +0200664 OPT_BOOLEAN('f', "force", &force,
665 "overwrite existing data file"),
Peter Zijlstrae61078a2009-06-03 11:24:33 +0200666 OPT_LONG('c', "count", &default_interval,
Ingo Molnarabaff322009-06-02 22:59:57 +0200667 "event period to sample"),
668 OPT_STRING('o', "output", &output_name, "file",
669 "output file name"),
670 OPT_BOOLEAN('i', "inherit", &inherit,
671 "child tasks inherit counters"),
Ingo Molnarcf1f4572009-06-05 13:27:02 +0200672 OPT_INTEGER('F', "freq", &freq,
673 "profile at this frequency"),
Ingo Molnarabaff322009-06-02 22:59:57 +0200674 OPT_INTEGER('m', "mmap-pages", &mmap_pages,
675 "number of mmap data pages"),
Ingo Molnar3efa1cc92009-06-14 15:04:15 +0200676 OPT_BOOLEAN('g', "call-graph", &call_graph,
677 "do call-graph (stack chain/backtrace) recording"),
Ingo Molnar3da297a2009-06-07 17:39:02 +0200678 OPT_BOOLEAN('v', "verbose", &verbose,
679 "be more verbose (show counter open errors, etc)"),
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200680 OPT_BOOLEAN('s', "stat", &inherit_stat,
681 "per thread counts"),
Anton Blanchard4bba8282009-07-16 15:44:29 +0200682 OPT_BOOLEAN('d', "data", &sample_address,
683 "Sample addresses"),
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200684 OPT_BOOLEAN('n', "no-samples", &no_samples,
685 "don't sample"),
Frederic Weisbeckerd1302522009-09-14 08:57:15 +0200686 OPT_BOOLEAN('M', "multiplex", &multiplex,
687 "multiplex counter output in a single channel"),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200688 OPT_END()
689};
690
Ingo Molnarf37a2912009-07-01 12:37:06 +0200691int cmd_record(int argc, const char **argv, const char *prefix __used)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200692{
693 int counter;
694
Anton Blancharda0541232009-07-22 23:04:12 +1000695 argc = parse_options(argc, argv, options, record_usage,
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -0200696 PARSE_OPT_STOP_AT_NON_OPTION);
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200697 if (!argc && target_pid == -1 && !system_wide && profile_cpu == -1)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200698 usage_with_options(record_usage, options);
699
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -0200700 symbol__init();
701
Peter Zijlstrabbd36e52009-06-11 23:11:50 +0200702 if (!nr_counters) {
703 nr_counters = 1;
704 attrs[0].type = PERF_TYPE_HARDWARE;
705 attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
706 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200707
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +0200708 /*
709 * User specified count overrides default frequency.
710 */
711 if (default_interval)
712 freq = 0;
713 else if (freq) {
714 default_interval = freq;
715 } else {
716 fprintf(stderr, "frequency and count are zero, aborting\n");
717 exit(EXIT_FAILURE);
718 }
719
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200720 for (counter = 0; counter < nr_counters; counter++) {
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200721 if (attrs[counter].sample_period)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200722 continue;
723
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200724 attrs[counter].sample_period = default_interval;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +0200725 }
726
727 return __cmd_record(argc, argv);
728}