static int perf_session__open(struct perf_session *self, bool force) { struct stat input_stat; self->fd = open(self->filename, O_RDONLY); if (self->fd < 0) { pr_err("failed to open file: %s", self->filename); if (!strcmp(self->filename, "perf.data")) pr_err(" (try 'perf record' first)"); pr_err("\n"); return -errno; } if (fstat(self->fd, &input_stat) < 0) goto out_close; if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) { pr_err("file %s not owned by current user or root\n", self->filename); goto out_close; } if (!input_stat.st_size) { pr_info("zero-sized file (%s), nothing to do!\n", self->filename); goto out_close; } if (perf_header__read(&self->header, self->fd) < 0) { pr_err("incompatible file format"); goto out_close; } self->size = input_stat.st_size; return 0; out_close: close(self->fd); self->fd = -1; return -1; }
static int __cmd_record(int argc, const char **argv) { int i, counter; struct stat st; pid_t pid = 0; int flags; int err; unsigned long waking = 0; page_size = sysconf(_SC_PAGE_SIZE); nr_cpus = sysconf(_SC_NPROCESSORS_ONLN); assert(nr_cpus <= MAX_NR_CPUS); assert(nr_cpus >= 0); atexit(sig_atexit); signal(SIGCHLD, sig_handler); signal(SIGINT, sig_handler); if (!stat(output_name, &st) && st.st_size) { if (!force && !append_file) { fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n", output_name); exit(-1); } } else { append_file = 0; } flags = O_CREAT|O_RDWR; if (append_file) file_new = 0; else flags |= O_TRUNC; output = open(output_name, flags, S_IRUSR|S_IWUSR); if (output < 0) { perror("failed to create output file"); exit(-1); } session = perf_session__new(output_name, O_WRONLY, force); if (session == NULL) { pr_err("Not enough memory for reading perf file header\n"); return -1; } if (!file_new) { err = perf_header__read(&session->header, output); if (err < 0) return err; } if (raw_samples) { perf_header__set_feat(&session->header, HEADER_TRACE_INFO); } else { for (i = 0; i < nr_counters; i++) { if (attrs[i].sample_type & PERF_SAMPLE_RAW) { perf_header__set_feat(&session->header, HEADER_TRACE_INFO); break; } } } atexit(atexit_header); if (!system_wide) { pid = target_pid; if (pid == -1) pid = getpid(); open_counters(profile_cpu, pid); } else { if (profile_cpu != -1) { open_counters(profile_cpu, target_pid); } else { for (i = 0; i < nr_cpus; i++) open_counters(i, target_pid); } } if (file_new) { err = perf_header__write(&session->header, output, false); if (err < 0) return err; } if (!system_wide) event__synthesize_thread(pid, process_synthesized_event); else event__synthesize_threads(process_synthesized_event); if (target_pid == -1 && argc) { pid = fork(); if (pid < 0) die("failed to fork"); if (!pid) { if (execvp(argv[0], (char **)argv)) { perror(argv[0]); exit(-1); } } else { /* * Wait a bit for the execv'ed child to appear * and be updated in /proc * FIXME: Do you know a less heuristical solution? */ usleep(1000); event__synthesize_thread(pid, process_synthesized_event); } child_pid = pid; } if (realtime_prio) { struct sched_param param; param.sched_priority = realtime_prio; if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { pr_err("Could not set realtime priority.\n"); exit(-1); } } for (;;) { int hits = samples; for (i = 0; i < nr_cpu; i++) { for (counter = 0; counter < nr_counters; counter++) { if (mmap_array[i][counter].base) mmap_read(&mmap_array[i][counter]); } } if (hits == samples) { if (done) break; err = poll(event_array, nr_poll, -1); waking++; } if (done) { for (i = 0; i < nr_cpu; i++) { for (counter = 0; counter < nr_counters; counter++) ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE); } } } fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking); /* * Approximate RIP event size: 24 bytes. */ fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n", (double)bytes_written / 1024.0 / 1024.0, output_name, bytes_written / 24); return 0; }
static int __cmd_record(int argc, const char **argv) { int i, counter; struct stat st; pid_t pid = 0; int flags; int ret; unsigned long waking = 0; page_size = sysconf(_SC_PAGE_SIZE); nr_cpus = sysconf(_SC_NPROCESSORS_ONLN); assert(nr_cpus <= MAX_NR_CPUS); assert(nr_cpus >= 0); atexit(sig_atexit); signal(SIGCHLD, sig_handler); signal(SIGINT, sig_handler); if (!stat(output_name, &st) && st.st_size) { if (!force && !append_file) { fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n", output_name); exit(-1); } } else { append_file = 0; } flags = O_CREAT|O_RDWR; if (append_file) file_new = 0; else flags |= O_TRUNC; output = open(output_name, flags, S_IRUSR|S_IWUSR); if (output < 0) { perror("failed to create output file"); exit(-1); } if (!file_new) header = perf_header__read(output); else header = perf_header__new(); if (raw_samples) { read_tracing_data(attrs, nr_counters); } else { for (i = 0; i < nr_counters; i++) { if (attrs[i].sample_type & PERF_SAMPLE_RAW) { read_tracing_data(attrs, nr_counters); break; } } } atexit(atexit_header); if (!system_wide) { pid = target_pid; if (pid == -1) pid = getpid(); open_counters(profile_cpu, pid); } else { if (profile_cpu != -1) { open_counters(profile_cpu, target_pid); } else { for (i = 0; i < nr_cpus; i++) open_counters(i, target_pid); } } if (file_new) perf_header__write(header, output); if (!system_wide) { pid_t tgid = pid_synthesize_comm_event(pid, 0); pid_synthesize_mmap_samples(pid, tgid); } else synthesize_all(); if (target_pid == -1 && argc) { pid = fork(); if (pid < 0) perror("failed to fork"); if (!pid) { if (execvp(argv[0], (char **)argv)) { perror(argv[0]); exit(-1); } } child_pid = pid; } if (realtime_prio) { struct sched_param param; param.sched_priority = realtime_prio; if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { printf("Could not set realtime priority.\n"); exit(-1); } } for (;;) { int hits = samples; for (i = 0; i < nr_cpu; i++) { for (counter = 0; counter < nr_counters; counter++) { if (mmap_array[i][counter].base) mmap_read(&mmap_array[i][counter]); } } if (hits == samples) { if (done) break; ret = poll(event_array, nr_poll, -1); waking++; } if (done) { for (i = 0; i < nr_cpu; i++) { for (counter = 0; counter < nr_counters; counter++) ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE); } } } fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking); /* * Approximate RIP event size: 24 bytes. */ fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n", (double)bytes_written / 1024.0 / 1024.0, output_name, bytes_written / 24); return 0; }
static int __cmd_trace(void) { int ret, rc = EXIT_FAILURE; unsigned long offset = 0; unsigned long head = 0; struct stat perf_stat; event_t *event; uint32_t size; char *buf; trace_report(); register_idle_thread(&threads, &last_match); input = open(input_name, O_RDONLY); if (input < 0) { perror("failed to open file"); exit(-1); } ret = fstat(input, &perf_stat); if (ret < 0) { perror("failed to stat file"); exit(-1); } if (!perf_stat.st_size) { fprintf(stderr, "zero-sized file, nothing to do!\n"); exit(0); } header = perf_header__read(input); head = header->data_offset; sample_type = perf_header__sample_type(header); if (!(sample_type & PERF_SAMPLE_RAW)) die("No trace sample to read. Did you call perf record " "without -R?"); if (load_kernel() < 0) { perror("failed to load kernel symbols"); return EXIT_FAILURE; } remap: buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ, MAP_SHARED, input, offset); if (buf == MAP_FAILED) { perror("failed to mmap file"); exit(-1); } more: event = (event_t *)(buf + head); if (head + event->header.size >= page_size * mmap_window) { unsigned long shift = page_size * (head / page_size); int res; res = munmap(buf, page_size * mmap_window); assert(res == 0); offset += shift; head -= shift; goto remap; } size = event->header.size; if (!size || process_event(event, offset, head) < 0) { /* * assume we lost track of the stream, check alignment, and * increment a single u64 in the hope to catch on again 'soon'. */ if (unlikely(head & 7)) head &= ~7ULL; size = 8; } head += size; if (offset + head < (unsigned long)perf_stat.st_size) goto more; rc = EXIT_SUCCESS; close(input); return rc; }