1 /* 2 * 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. 7 */ 8 #include "builtin.h" 9 10 #include "perf.h" 11 12 #include "util/util.h" 13 #include "util/parse-options.h" 14 #include "util/parse-events.h" 15 #include "util/string.h" 16 17 #include <unistd.h> 18 #include <sched.h> 19 20 #define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1) 21 #define __ALIGN_MASK(x, mask) (((x)+(mask))&~(mask)) 22 23 static int fd[MAX_NR_CPUS][MAX_COUNTERS]; 24 25 static long default_interval = 100000; 26 27 static int nr_cpus = 0; 28 static unsigned int page_size; 29 static unsigned int mmap_pages = 128; 30 static int freq = 0; 31 static int output; 32 static const char *output_name = "perf.data"; 33 static int group = 0; 34 static unsigned int realtime_prio = 0; 35 static int system_wide = 0; 36 static pid_t target_pid = -1; 37 static int inherit = 1; 38 static int force = 0; 39 static int append_file = 0; 40 static int verbose = 0; 41 42 static long samples; 43 static struct timeval last_read; 44 static struct timeval this_read; 45 46 static __u64 bytes_written; 47 48 static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS]; 49 50 static int nr_poll; 51 static int nr_cpu; 52 53 struct mmap_event { 54 struct perf_event_header header; 55 __u32 pid; 56 __u32 tid; 57 __u64 start; 58 __u64 len; 59 __u64 pgoff; 60 char filename[PATH_MAX]; 61 }; 62 63 struct comm_event { 64 struct perf_event_header header; 65 __u32 pid; 66 __u32 tid; 67 char comm[16]; 68 }; 69 70 71 struct mmap_data { 72 int counter; 73 void *base; 74 unsigned int mask; 75 unsigned int prev; 76 }; 77 78 static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS]; 79 80 static unsigned int mmap_read_head(struct mmap_data *md) 81 { 82 struct perf_counter_mmap_page *pc = md->base; 83 int head; 84 85 head = pc->data_head; 86 rmb(); 87 88 return head; 89 } 90 91 static void mmap_read(struct mmap_data *md) 92 { 93 unsigned int head = mmap_read_head(md); 94 unsigned int old = md->prev; 95 unsigned char *data = md->base + page_size; 96 unsigned long size; 97 void *buf; 98 int diff; 99 100 gettimeofday(&this_read, NULL); 101 102 /* 103 * If we're further behind than half the buffer, there's a chance 104 * the writer will bite our tail and mess up the samples under us. 105 * 106 * If we somehow ended up ahead of the head, we got messed up. 107 * 108 * In either case, truncate and restart at head. 109 */ 110 diff = head - old; 111 if (diff > md->mask / 2 || diff < 0) { 112 struct timeval iv; 113 unsigned long msecs; 114 115 timersub(&this_read, &last_read, &iv); 116 msecs = iv.tv_sec*1000 + iv.tv_usec/1000; 117 118 fprintf(stderr, "WARNING: failed to keep up with mmap data." 119 " Last read %lu msecs ago.\n", msecs); 120 121 /* 122 * head points to a known good entry, start there. 123 */ 124 old = head; 125 } 126 127 last_read = this_read; 128 129 if (old != head) 130 samples++; 131 132 size = head - old; 133 134 if ((old & md->mask) + size != (head & md->mask)) { 135 buf = &data[old & md->mask]; 136 size = md->mask + 1 - (old & md->mask); 137 old += size; 138 139 while (size) { 140 int ret = write(output, buf, size); 141 142 if (ret < 0) 143 die("failed to write"); 144 145 size -= ret; 146 buf += ret; 147 148 bytes_written += ret; 149 } 150 } 151 152 buf = &data[old & md->mask]; 153 size = head - old; 154 old += size; 155 156 while (size) { 157 int ret = write(output, buf, size); 158 159 if (ret < 0) 160 die("failed to write"); 161 162 size -= ret; 163 buf += ret; 164 165 bytes_written += ret; 166 } 167 168 md->prev = old; 169 } 170 171 static volatile int done = 0; 172 static volatile int signr = -1; 173 174 static void sig_handler(int sig) 175 { 176 done = 1; 177 signr = sig; 178 } 179 180 static void sig_atexit(void) 181 { 182 if (signr == -1) 183 return; 184 185 signal(signr, SIG_DFL); 186 kill(getpid(), signr); 187 } 188 189 static void pid_synthesize_comm_event(pid_t pid, int full) 190 { 191 struct comm_event comm_ev; 192 char filename[PATH_MAX]; 193 char bf[BUFSIZ]; 194 int fd, ret; 195 size_t size; 196 char *field, *sep; 197 DIR *tasks; 198 struct dirent dirent, *next; 199 200 snprintf(filename, sizeof(filename), "/proc/%d/stat", pid); 201 202 fd = open(filename, O_RDONLY); 203 if (fd < 0) { 204 fprintf(stderr, "couldn't open %s\n", filename); 205 exit(EXIT_FAILURE); 206 } 207 if (read(fd, bf, sizeof(bf)) < 0) { 208 fprintf(stderr, "couldn't read %s\n", filename); 209 exit(EXIT_FAILURE); 210 } 211 close(fd); 212 213 /* 9027 (cat) R 6747 9027 6747 34816 9027 ... */ 214 memset(&comm_ev, 0, sizeof(comm_ev)); 215 field = strchr(bf, '('); 216 if (field == NULL) 217 goto out_failure; 218 sep = strchr(++field, ')'); 219 if (sep == NULL) 220 goto out_failure; 221 size = sep - field; 222 memcpy(comm_ev.comm, field, size++); 223 224 comm_ev.pid = pid; 225 comm_ev.header.type = PERF_EVENT_COMM; 226 size = ALIGN(size, sizeof(__u64)); 227 comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size); 228 229 if (!full) { 230 comm_ev.tid = pid; 231 232 ret = write(output, &comm_ev, comm_ev.header.size); 233 if (ret < 0) { 234 perror("failed to write"); 235 exit(-1); 236 } 237 return; 238 } 239 240 snprintf(filename, sizeof(filename), "/proc/%d/task", pid); 241 242 tasks = opendir(filename); 243 while (!readdir_r(tasks, &dirent, &next) && next) { 244 char *end; 245 pid = strtol(dirent.d_name, &end, 10); 246 if (*end) 247 continue; 248 249 comm_ev.tid = pid; 250 251 ret = write(output, &comm_ev, comm_ev.header.size); 252 if (ret < 0) { 253 perror("failed to write"); 254 exit(-1); 255 } 256 } 257 closedir(tasks); 258 return; 259 260 out_failure: 261 fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n", 262 filename); 263 exit(EXIT_FAILURE); 264 } 265 266 static void pid_synthesize_mmap_samples(pid_t pid) 267 { 268 char filename[PATH_MAX]; 269 FILE *fp; 270 271 snprintf(filename, sizeof(filename), "/proc/%d/maps", pid); 272 273 fp = fopen(filename, "r"); 274 if (fp == NULL) { 275 fprintf(stderr, "couldn't open %s\n", filename); 276 exit(EXIT_FAILURE); 277 } 278 while (1) { 279 char bf[BUFSIZ], *pbf = bf; 280 struct mmap_event mmap_ev = { 281 .header.type = PERF_EVENT_MMAP, 282 }; 283 int n; 284 size_t size; 285 if (fgets(bf, sizeof(bf), fp) == NULL) 286 break; 287 288 /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */ 289 n = hex2u64(pbf, &mmap_ev.start); 290 if (n < 0) 291 continue; 292 pbf += n + 1; 293 n = hex2u64(pbf, &mmap_ev.len); 294 if (n < 0) 295 continue; 296 pbf += n + 3; 297 if (*pbf == 'x') { /* vm_exec */ 298 char *execname = strrchr(bf, ' '); 299 300 if (execname == NULL || execname[1] != '/') 301 continue; 302 303 execname += 1; 304 size = strlen(execname); 305 execname[size - 1] = '\0'; /* Remove \n */ 306 memcpy(mmap_ev.filename, execname, size); 307 size = ALIGN(size, sizeof(__u64)); 308 mmap_ev.len -= mmap_ev.start; 309 mmap_ev.header.size = (sizeof(mmap_ev) - 310 (sizeof(mmap_ev.filename) - size)); 311 mmap_ev.pid = pid; 312 mmap_ev.tid = pid; 313 314 if (write(output, &mmap_ev, mmap_ev.header.size) < 0) { 315 perror("failed to write"); 316 exit(-1); 317 } 318 } 319 } 320 321 fclose(fp); 322 } 323 324 static void synthesize_samples(void) 325 { 326 DIR *proc; 327 struct dirent dirent, *next; 328 329 proc = opendir("/proc"); 330 331 while (!readdir_r(proc, &dirent, &next) && next) { 332 char *end; 333 pid_t pid; 334 335 pid = strtol(dirent.d_name, &end, 10); 336 if (*end) /* only interested in proper numerical dirents */ 337 continue; 338 339 pid_synthesize_comm_event(pid, 1); 340 pid_synthesize_mmap_samples(pid); 341 } 342 343 closedir(proc); 344 } 345 346 static int group_fd; 347 348 static void create_counter(int counter, int cpu, pid_t pid) 349 { 350 struct perf_counter_attr *attr = attrs + counter; 351 int track = 1; 352 353 attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID; 354 if (freq) { 355 attr->sample_type |= PERF_SAMPLE_PERIOD; 356 attr->freq = 1; 357 attr->sample_freq = freq; 358 } 359 attr->mmap = track; 360 attr->comm = track; 361 attr->inherit = (cpu < 0) && inherit; 362 attr->disabled = 1; 363 364 track = 0; /* only the first counter needs these */ 365 366 try_again: 367 fd[nr_cpu][counter] = sys_perf_counter_open(attr, pid, cpu, group_fd, 0); 368 369 if (fd[nr_cpu][counter] < 0) { 370 int err = errno; 371 372 if (err == EPERM) 373 die("Permission error - are you root?\n"); 374 375 /* 376 * If it's cycles then fall back to hrtimer 377 * based cpu-clock-tick sw counter, which 378 * is always available even if no PMU support: 379 */ 380 if (attr->type == PERF_TYPE_HARDWARE 381 && attr->config == PERF_COUNT_HW_CPU_CYCLES) { 382 383 if (verbose) 384 warning(" ... trying to fall back to cpu-clock-ticks\n"); 385 attr->type = PERF_TYPE_SOFTWARE; 386 attr->config = PERF_COUNT_SW_CPU_CLOCK; 387 goto try_again; 388 } 389 printf("\n"); 390 error("perfcounter syscall returned with %d (%s)\n", 391 fd[nr_cpu][counter], strerror(err)); 392 die("No CONFIG_PERF_COUNTERS=y kernel support configured?\n"); 393 exit(-1); 394 } 395 396 assert(fd[nr_cpu][counter] >= 0); 397 fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK); 398 399 /* 400 * First counter acts as the group leader: 401 */ 402 if (group && group_fd == -1) 403 group_fd = fd[nr_cpu][counter]; 404 405 event_array[nr_poll].fd = fd[nr_cpu][counter]; 406 event_array[nr_poll].events = POLLIN; 407 nr_poll++; 408 409 mmap_array[nr_cpu][counter].counter = counter; 410 mmap_array[nr_cpu][counter].prev = 0; 411 mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1; 412 mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size, 413 PROT_READ, MAP_SHARED, fd[nr_cpu][counter], 0); 414 if (mmap_array[nr_cpu][counter].base == MAP_FAILED) { 415 error("failed to mmap with %d (%s)\n", errno, strerror(errno)); 416 exit(-1); 417 } 418 419 ioctl(fd[nr_cpu][counter], PERF_COUNTER_IOC_ENABLE); 420 } 421 422 static void open_counters(int cpu, pid_t pid) 423 { 424 int counter; 425 426 if (pid > 0) { 427 pid_synthesize_comm_event(pid, 0); 428 pid_synthesize_mmap_samples(pid); 429 } 430 431 group_fd = -1; 432 for (counter = 0; counter < nr_counters; counter++) 433 create_counter(counter, cpu, pid); 434 435 nr_cpu++; 436 } 437 438 static int __cmd_record(int argc, const char **argv) 439 { 440 int i, counter; 441 struct stat st; 442 pid_t pid; 443 int flags; 444 int ret; 445 446 page_size = sysconf(_SC_PAGE_SIZE); 447 nr_cpus = sysconf(_SC_NPROCESSORS_ONLN); 448 assert(nr_cpus <= MAX_NR_CPUS); 449 assert(nr_cpus >= 0); 450 451 if (!stat(output_name, &st) && !force && !append_file) { 452 fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n", 453 output_name); 454 exit(-1); 455 } 456 457 flags = O_CREAT|O_RDWR; 458 if (append_file) 459 flags |= O_APPEND; 460 else 461 flags |= O_TRUNC; 462 463 output = open(output_name, flags, S_IRUSR|S_IWUSR); 464 if (output < 0) { 465 perror("failed to create output file"); 466 exit(-1); 467 } 468 469 if (!system_wide) { 470 open_counters(-1, target_pid != -1 ? target_pid : getpid()); 471 } else for (i = 0; i < nr_cpus; i++) 472 open_counters(i, target_pid); 473 474 atexit(sig_atexit); 475 signal(SIGCHLD, sig_handler); 476 signal(SIGINT, sig_handler); 477 478 if (target_pid == -1 && argc) { 479 pid = fork(); 480 if (pid < 0) 481 perror("failed to fork"); 482 483 if (!pid) { 484 if (execvp(argv[0], (char **)argv)) { 485 perror(argv[0]); 486 exit(-1); 487 } 488 } 489 } 490 491 if (realtime_prio) { 492 struct sched_param param; 493 494 param.sched_priority = realtime_prio; 495 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 496 printf("Could not set realtime priority.\n"); 497 exit(-1); 498 } 499 } 500 501 if (system_wide) 502 synthesize_samples(); 503 504 while (!done) { 505 int hits = samples; 506 507 for (i = 0; i < nr_cpu; i++) { 508 for (counter = 0; counter < nr_counters; counter++) 509 mmap_read(&mmap_array[i][counter]); 510 } 511 512 if (hits == samples) 513 ret = poll(event_array, nr_poll, 100); 514 } 515 516 /* 517 * Approximate RIP event size: 24 bytes. 518 */ 519 fprintf(stderr, 520 "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n", 521 (double)bytes_written / 1024.0 / 1024.0, 522 output_name, 523 bytes_written / 24); 524 525 return 0; 526 } 527 528 static const char * const record_usage[] = { 529 "perf record [<options>] [<command>]", 530 "perf record [<options>] -- <command> [<options>]", 531 NULL 532 }; 533 534 static const struct option options[] = { 535 OPT_CALLBACK('e', "event", NULL, "event", 536 "event selector. use 'perf list' to list available events", 537 parse_events), 538 OPT_INTEGER('p', "pid", &target_pid, 539 "record events on existing pid"), 540 OPT_INTEGER('r', "realtime", &realtime_prio, 541 "collect data with this RT SCHED_FIFO priority"), 542 OPT_BOOLEAN('a', "all-cpus", &system_wide, 543 "system-wide collection from all CPUs"), 544 OPT_BOOLEAN('A', "append", &append_file, 545 "append to the output file to do incremental profiling"), 546 OPT_BOOLEAN('f', "force", &force, 547 "overwrite existing data file"), 548 OPT_LONG('c', "count", &default_interval, 549 "event period to sample"), 550 OPT_STRING('o', "output", &output_name, "file", 551 "output file name"), 552 OPT_BOOLEAN('i', "inherit", &inherit, 553 "child tasks inherit counters"), 554 OPT_INTEGER('F', "freq", &freq, 555 "profile at this frequency"), 556 OPT_INTEGER('m', "mmap-pages", &mmap_pages, 557 "number of mmap data pages"), 558 OPT_BOOLEAN('v', "verbose", &verbose, 559 "be more verbose (show counter open errors, etc)"), 560 OPT_END() 561 }; 562 563 int cmd_record(int argc, const char **argv, const char *prefix) 564 { 565 int counter; 566 567 argc = parse_options(argc, argv, options, record_usage, 0); 568 if (!argc && target_pid == -1 && !system_wide) 569 usage_with_options(record_usage, options); 570 571 if (!nr_counters) 572 nr_counters = 1; 573 574 for (counter = 0; counter < nr_counters; counter++) { 575 if (attrs[counter].sample_period) 576 continue; 577 578 attrs[counter].sample_period = default_interval; 579 } 580 581 return __cmd_record(argc, argv); 582 } 583