int perf_event__synthesize_threads(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine, bool mmap_data, unsigned int proc_map_timeout) { DIR *proc; char proc_path[PATH_MAX]; struct dirent *dirent; union perf_event *comm_event, *mmap_event, *fork_event; int err = -1; if (machine__is_default_guest(machine)) return 0; comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); if (comm_event == NULL) goto out; mmap_event = malloc(sizeof(mmap_event->mmap2) + machine->id_hdr_size); if (mmap_event == NULL) goto out_free_comm; fork_event = malloc(sizeof(fork_event->fork) + machine->id_hdr_size); if (fork_event == NULL) goto out_free_mmap; snprintf(proc_path, sizeof(proc_path), "%s/proc", machine->root_dir); proc = opendir(proc_path); if (proc == NULL) goto out_free_fork; while ((dirent = readdir(proc)) != NULL) { char *end; pid_t pid = strtol(dirent->d_name, &end, 10); if (*end) /* only interested in proper numerical dirents */ continue; /* * We may race with exiting thread, so don't stop just because * one thread couldn't be synthesized. */ __event__synthesize_thread(comm_event, mmap_event, fork_event, pid, 1, process, tool, machine, mmap_data, proc_map_timeout); } err = 0; closedir(proc); out_free_fork: free(fork_event); out_free_mmap: free(mmap_event); out_free_comm: free(comm_event); out: return err; }
int event__synthesize_kernel_mmap(event__handler_t process, struct perf_session *session, struct machine *machine, const char *symbol_name) { size_t size; const char *filename, *mmap_name; char path[PATH_MAX]; char name_buff[PATH_MAX]; struct map *map; event_t ev = { .header = { .type = PERF_RECORD_MMAP, }, }; /* * We should get this from /sys/kernel/sections/.text, but till that is * available use this, and after it is use this as a fallback for older * kernels. */ struct process_symbol_args args = { .name = symbol_name, }; mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff)); if (machine__is_host(machine)) { /* * kernel uses PERF_RECORD_MISC_USER for user space maps, * see kernel/perf_event.c __perf_event_mmap */ ev.header.misc = PERF_RECORD_MISC_KERNEL; filename = "/proc/kallsyms"; } else { ev.header.misc = PERF_RECORD_MISC_GUEST_KERNEL; if (machine__is_default_guest(machine)) filename = (char *) symbol_conf.default_guest_kallsyms; else { sprintf(path, "%s/proc/kallsyms", machine->root_dir); filename = path; } } if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0) return -ENOENT; map = machine->vmlinux_maps[MAP__FUNCTION]; size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename), "%s%s", mmap_name, symbol_name) + 1; size = ALIGN(size, sizeof(u64)); ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size)); ev.mmap.pgoff = args.start; ev.mmap.start = map->start; ev.mmap.len = map->end - ev.mmap.start; ev.mmap.pid = machine->pid; return process(&ev, session); }
static int __event__synthesize_thread(union perf_event *comm_event, union perf_event *mmap_event, union perf_event *fork_event, pid_t pid, int full, perf_event__handler_t process, struct perf_tool *tool, struct machine *machine, bool mmap_data, unsigned int proc_map_timeout) { char filename[PATH_MAX]; DIR *tasks; struct dirent *dirent; pid_t tgid, ppid; int rc = 0; /* special case: only send one comm event using passed in pid */ if (!full) { tgid = perf_event__synthesize_comm(tool, comm_event, pid, process, machine); if (tgid == -1) return -1; return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, process, machine, mmap_data, proc_map_timeout); } if (machine__is_default_guest(machine)) return 0; snprintf(filename, sizeof(filename), "%s/proc/%d/task", machine->root_dir, pid); tasks = opendir(filename); if (tasks == NULL) { pr_debug("couldn't open %s\n", filename); return 0; } while ((dirent = readdir(tasks)) != NULL) { char *end; pid_t _pid; _pid = strtol(dirent->d_name, &end, 10); if (*end) continue; rc = -1; if (perf_event__prepare_comm(comm_event, _pid, machine, &tgid, &ppid) != 0) break; if (perf_event__synthesize_fork(tool, fork_event, _pid, tgid, ppid, process, machine) < 0) break; /* * Send the prepared comm event */ if (perf_tool__process_synth_event(tool, comm_event, machine, process) != 0) break; rc = 0; if (_pid == pid) { /* process the parent's maps too */ rc = perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, process, machine, mmap_data, proc_map_timeout); if (rc) break; } } closedir(tasks); return rc; }
int perf_event__synthesize_mmap_events(struct perf_tool *tool, union perf_event *event, pid_t pid, pid_t tgid, perf_event__handler_t process, struct machine *machine, bool mmap_data, unsigned int proc_map_timeout) { char filename[PATH_MAX]; FILE *fp; unsigned long long t; bool truncation = false; unsigned long long timeout = proc_map_timeout * 1000000ULL; int rc = 0; if (machine__is_default_guest(machine)) return 0; snprintf(filename, sizeof(filename), "%s/proc/%d/maps", machine->root_dir, pid); fp = fopen(filename, "r"); if (fp == NULL) { /* * We raced with a task exiting - just return: */ pr_debug("couldn't open %s\n", filename); return -1; } event->header.type = PERF_RECORD_MMAP2; t = rdclock(); while (1) { char bf[BUFSIZ]; char prot[5]; char execname[PATH_MAX]; char anonstr[] = "//anon"; unsigned int ino; size_t size; ssize_t n; if (fgets(bf, sizeof(bf), fp) == NULL) break; if ((rdclock() - t) > timeout) { pr_warning("Reading %s time out. " "You may want to increase " "the time limit by --proc-map-timeout\n", filename); truncation = true; goto out; } /* ensure null termination since stack will be reused. */ strcpy(execname, ""); /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */ n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %x:%x %u %[^\n]\n", &event->mmap2.start, &event->mmap2.len, prot, &event->mmap2.pgoff, &event->mmap2.maj, &event->mmap2.min, &ino, execname); /* * Anon maps don't have the execname. */ if (n < 7) continue; event->mmap2.ino = (u64)ino; /* * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c */ if (machine__is_host(machine)) event->header.misc = PERF_RECORD_MISC_USER; else event->header.misc = PERF_RECORD_MISC_GUEST_USER; /* map protection and flags bits */ event->mmap2.prot = 0; event->mmap2.flags = 0; if (prot[0] == 'r') event->mmap2.prot |= PROT_READ; if (prot[1] == 'w') event->mmap2.prot |= PROT_WRITE; if (prot[2] == 'x') event->mmap2.prot |= PROT_EXEC; if (prot[3] == 's') event->mmap2.flags |= MAP_SHARED; else event->mmap2.flags |= MAP_PRIVATE; if (prot[2] != 'x') { if (!mmap_data || prot[0] != 'r') continue; event->header.misc |= PERF_RECORD_MISC_MMAP_DATA; } out: if (truncation) event->header.misc |= PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT; if (!strcmp(execname, "")) strcpy(execname, anonstr); size = strlen(execname) + 1; memcpy(event->mmap2.filename, execname, size); size = PERF_ALIGN(size, sizeof(u64)); event->mmap2.len -= event->mmap.start; event->mmap2.header.size = (sizeof(event->mmap2) - (sizeof(event->mmap2.filename) - size)); memset(event->mmap2.filename + size, 0, machine->id_hdr_size); event->mmap2.header.size += machine->id_hdr_size; event->mmap2.pid = tgid; event->mmap2.tid = pid; if (perf_tool__process_synth_event(tool, event, machine, process) != 0) { rc = -1; break; } if (truncation) break; } fclose(fp); return rc; }
int perf_event__synthesize_kernel_mmap(perf_event__handler_t process, struct perf_session *session, struct machine *machine, const char *symbol_name) { size_t size; const char *filename, *mmap_name; char path[PATH_MAX]; char name_buff[PATH_MAX]; struct map *map; int err; /* * We should get this from /sys/kernel/sections/.text, but till that is * available use this, and after it is use this as a fallback for older * kernels. */ struct process_symbol_args args = { .name = symbol_name, }; union perf_event *event = zalloc((sizeof(event->mmap) + session->id_hdr_size)); if (event == NULL) { pr_debug("Not enough memory synthesizing mmap event " "for kernel modules\n"); return -1; } mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff)); if (machine__is_host(machine)) { /* * kernel uses PERF_RECORD_MISC_USER for user space maps, * see kernel/perf_event.c __perf_event_mmap */ event->header.misc = PERF_RECORD_MISC_KERNEL; filename = "/proc/kallsyms"; } else { event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; if (machine__is_default_guest(machine)) filename = (char *) symbol_conf.default_guest_kallsyms; else { sprintf(path, "%s/proc/kallsyms", machine->root_dir); filename = path; } } if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0) return -ENOENT; map = machine->vmlinux_maps[MAP__FUNCTION]; size = snprintf(event->mmap.filename, sizeof(event->mmap.filename), "%s%s", mmap_name, symbol_name) + 1; size = ALIGN(size, sizeof(u64)); event->mmap.header.type = PERF_RECORD_MMAP; event->mmap.header.size = (sizeof(event->mmap) - (sizeof(event->mmap.filename) - size) + session->id_hdr_size); event->mmap.pgoff = args.start; event->mmap.start = map->start; event->mmap.len = map->end - event->mmap.start; event->mmap.pid = machine->pid; err = process(event, &synth_sample, session); free(event); return err; }
static pid_t perf_event__synthesize_comm(struct perf_tool *tool, union perf_event *event, pid_t pid, int full, perf_event__handler_t process, struct machine *machine) { char filename[PATH_MAX]; size_t size; DIR *tasks; struct dirent dirent, *next; pid_t tgid; memset(&event->comm, 0, sizeof(event->comm)); if (machine__is_host(machine)) tgid = perf_event__get_comm_tgid(pid, event->comm.comm, sizeof(event->comm.comm)); else tgid = machine->pid; if (tgid < 0) goto out; event->comm.pid = tgid; event->comm.header.type = PERF_RECORD_COMM; size = strlen(event->comm.comm) + 1; size = PERF_ALIGN(size, sizeof(u64)); memset(event->comm.comm + size, 0, machine->id_hdr_size); event->comm.header.size = (sizeof(event->comm) - (sizeof(event->comm.comm) - size) + machine->id_hdr_size); if (!full) { event->comm.tid = pid; if (process(tool, event, &synth_sample, machine) != 0) return -1; goto out; } if (machine__is_default_guest(machine)) return 0; snprintf(filename, sizeof(filename), "%s/proc/%d/task", machine->root_dir, pid); tasks = opendir(filename); if (tasks == NULL) { pr_debug("couldn't open %s\n", filename); return 0; } while (!readdir_r(tasks, &dirent, &next) && next) { char *end; pid = strtol(dirent.d_name, &end, 10); if (*end) continue; /* already have tgid; jut want to update the comm */ (void) perf_event__get_comm_tgid(pid, event->comm.comm, sizeof(event->comm.comm)); size = strlen(event->comm.comm) + 1; size = PERF_ALIGN(size, sizeof(u64)); memset(event->comm.comm + size, 0, machine->id_hdr_size); event->comm.header.size = (sizeof(event->comm) - (sizeof(event->comm.comm) - size) + machine->id_hdr_size); event->comm.tid = pid; if (process(tool, event, &synth_sample, machine) != 0) { tgid = -1; break; } } closedir(tasks); out: return tgid; }
int perf_event__synthesize_mmap_events(struct perf_tool *tool, union perf_event *event, pid_t pid, pid_t tgid, perf_event__handler_t process, struct machine *machine, bool mmap_data) { char filename[PATH_MAX]; FILE *fp; int rc = 0; if (machine__is_default_guest(machine)) return 0; snprintf(filename, sizeof(filename), "%s/proc/%d/maps", machine->root_dir, pid); fp = fopen(filename, "r"); if (fp == NULL) { /* * We raced with a task exiting - just return: */ pr_debug("couldn't open %s\n", filename); return -1; } event->header.type = PERF_RECORD_MMAP; while (1) { char bf[BUFSIZ]; char prot[5]; char execname[PATH_MAX]; char anonstr[] = "//anon"; size_t size; ssize_t n; if (fgets(bf, sizeof(bf), fp) == NULL) break; /* ensure null termination since stack will be reused. */ strcpy(execname, ""); /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */ n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %*x:%*x %*u %s\n", &event->mmap.start, &event->mmap.len, prot, &event->mmap.pgoff, execname); /* * Anon maps don't have the execname. */ if (n < 4) continue; /* * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c */ if (machine__is_host(machine)) event->header.misc = PERF_RECORD_MISC_USER; else event->header.misc = PERF_RECORD_MISC_GUEST_USER; if (prot[2] != 'x') { if (!mmap_data || prot[0] != 'r') continue; event->header.misc |= PERF_RECORD_MISC_MMAP_DATA; } if (!strcmp(execname, "")) strcpy(execname, anonstr); size = strlen(execname) + 1; memcpy(event->mmap.filename, execname, size); size = PERF_ALIGN(size, sizeof(u64)); event->mmap.len -= event->mmap.start; event->mmap.header.size = (sizeof(event->mmap) - (sizeof(event->mmap.filename) - size)); memset(event->mmap.filename + size, 0, machine->id_hdr_size); event->mmap.header.size += machine->id_hdr_size; event->mmap.pid = tgid; event->mmap.tid = pid; if (process(tool, event, &synth_sample, machine) != 0) { rc = -1; break; } } fclose(fp); return rc; }
int perf_event__synthesize_threads(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine, bool mmap_data, unsigned int nr_threads_synthesize) { struct synthesize_threads_arg *args = NULL; pthread_t *synthesize_threads = NULL; char proc_path[PATH_MAX]; struct dirent **dirent; int num_per_thread; int m, n, i, j; int thread_nr; int base = 0; int err = -1; if (machine__is_default_guest(machine)) return 0; snprintf(proc_path, sizeof(proc_path), "%s/proc", machine->root_dir); n = scandir(proc_path, &dirent, 0, alphasort); if (n < 0) return err; if (nr_threads_synthesize == UINT_MAX) thread_nr = sysconf(_SC_NPROCESSORS_ONLN); else thread_nr = nr_threads_synthesize; if (thread_nr <= 1) { err = __perf_event__synthesize_threads(tool, process, machine, mmap_data, dirent, base, n); goto free_dirent; } if (thread_nr > n) thread_nr = n; synthesize_threads = calloc(sizeof(pthread_t), thread_nr); if (synthesize_threads == NULL) goto free_dirent; args = calloc(sizeof(*args), thread_nr); if (args == NULL) goto free_threads; num_per_thread = n / thread_nr; m = n % thread_nr; for (i = 0; i < thread_nr; i++) { args[i].tool = tool; args[i].process = process; args[i].machine = machine; args[i].mmap_data = mmap_data; args[i].dirent = dirent; } for (i = 0; i < m; i++) { args[i].num = num_per_thread + 1; args[i].start = i * args[i].num; } if (i != 0) base = args[i-1].start + args[i-1].num; for (j = i; j < thread_nr; j++) { args[j].num = num_per_thread; args[j].start = base + (j - i) * args[i].num; } for (i = 0; i < thread_nr; i++) { if (pthread_create(&synthesize_threads[i], NULL, synthesize_threads_worker, &args[i])) goto out_join; } err = 0; out_join: for (i = 0; i < thread_nr; i++) pthread_join(synthesize_threads[i], NULL); free(args); free_threads: free(synthesize_threads); free_dirent: for (i = 0; i < n; i++) free(dirent[i]); free(dirent); return err; }
static int event__process_kernel_mmap(event_t *self, struct perf_session *session) { struct map *map; char kmmap_prefix[PATH_MAX]; struct machine *machine; enum dso_kernel_type kernel_type; bool is_kernel_mmap; machine = perf_session__findnew_machine(session, self->mmap.pid); if (!machine) { pr_err("Can't find id %d's machine\n", self->mmap.pid); goto out_problem; } machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix)); if (machine__is_host(machine)) kernel_type = DSO_TYPE_KERNEL; else kernel_type = DSO_TYPE_GUEST_KERNEL; is_kernel_mmap = memcmp(self->mmap.filename, kmmap_prefix, strlen(kmmap_prefix)) == 0; if (self->mmap.filename[0] == '/' || (!is_kernel_mmap && self->mmap.filename[0] == '[')) { char short_module_name[1024]; char *name, *dot; if (self->mmap.filename[0] == '/') { name = strrchr(self->mmap.filename, '/'); if (name == NULL) goto out_problem; ++name; /* skip / */ dot = strrchr(name, '.'); if (dot == NULL) goto out_problem; snprintf(short_module_name, sizeof(short_module_name), "[%.*s]", (int)(dot - name), name); strxfrchar(short_module_name, '-', '_'); } else strcpy(short_module_name, self->mmap.filename); map = machine__new_module(machine, self->mmap.start, self->mmap.filename); if (map == NULL) goto out_problem; name = strdup(short_module_name); if (name == NULL) goto out_problem; map->dso->short_name = name; map->end = map->start + self->mmap.len; } else if (is_kernel_mmap) { const char *symbol_name = (self->mmap.filename + strlen(kmmap_prefix)); /* * Should be there already, from the build-id table in * the header. */ struct dso *kernel = __dsos__findnew(&machine->kernel_dsos, kmmap_prefix); if (kernel == NULL) goto out_problem; kernel->kernel = kernel_type; if (__machine__create_kernel_maps(machine, kernel) < 0) goto out_problem; event_set_kernel_mmap_len(machine->vmlinux_maps, self); perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, symbol_name, self->mmap.pgoff); if (machine__is_default_guest(machine)) { /* * preload dso of guest kernel and modules */ dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION], NULL); } } return 0; out_problem: return -1; }