static int perf_event__synthesize_fork(struct perf_tool *tool, union perf_event *event, pid_t pid, pid_t tgid, pid_t ppid, perf_event__handler_t process, struct machine *machine) { memset(&event->fork, 0, sizeof(event->fork) + machine->id_hdr_size); /* * for main thread set parent to ppid from status file. For other * threads set parent pid to main thread. ie., assume main thread * spawns all threads in a process */ if (tgid == pid) { event->fork.ppid = ppid; event->fork.ptid = ppid; } else { event->fork.ppid = tgid; event->fork.ptid = tgid; } event->fork.pid = tgid; event->fork.tid = pid; event->fork.header.type = PERF_RECORD_FORK; event->fork.header.size = (sizeof(event->fork) + machine->id_hdr_size); if (perf_tool__process_synth_event(tool, event, machine, process) != 0) return -1; return 0; }
int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine) { size_t size; const char *mmap_name; char name_buff[PATH_MAX]; struct map *map = machine__kernel_map(machine); struct kmap *kmap; int err; union perf_event *event; if (symbol_conf.kptr_restrict) return -1; if (map == NULL) return -1; /* * 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. */ event = zalloc((sizeof(event->mmap) + machine->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; } else { event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; } kmap = map__kmap(map); size = snprintf(event->mmap.filename, sizeof(event->mmap.filename), "%s%s", mmap_name, kmap->ref_reloc_sym->name) + 1; size = PERF_ALIGN(size, sizeof(u64)); event->mmap.header.type = PERF_RECORD_MMAP; event->mmap.header.size = (sizeof(event->mmap) - (sizeof(event->mmap.filename) - size) + machine->id_hdr_size); event->mmap.pgoff = kmap->ref_reloc_sym->addr; event->mmap.start = map->start; event->mmap.len = map->end - event->mmap.start; event->mmap.pid = machine->pid; err = perf_tool__process_synth_event(tool, event, machine, process); free(event); return err; }
int perf_event__synthesize_modules(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine) { int rc = 0; struct map *pos; struct map_groups *kmaps = &machine->kmaps; struct maps *maps = &kmaps->maps[MAP__FUNCTION]; union perf_event *event = zalloc((sizeof(event->mmap) + machine->id_hdr_size)); if (event == NULL) { pr_debug("Not enough memory synthesizing mmap event " "for kernel modules\n"); return -1; } event->header.type = PERF_RECORD_MMAP; /* * kernel uses 0 for user space maps, see kernel/perf_event.c * __perf_event_mmap */ if (machine__is_host(machine)) event->header.misc = PERF_RECORD_MISC_KERNEL; else event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; for (pos = maps__first(maps); pos; pos = map__next(pos)) { size_t size; if (__map__is_kernel(pos)) continue; size = PERF_ALIGN(pos->dso->long_name_len + 1, sizeof(u64)); event->mmap.header.type = PERF_RECORD_MMAP; 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.start = pos->start; event->mmap.len = pos->end - pos->start; event->mmap.pid = machine->pid; memcpy(event->mmap.filename, pos->dso->long_name, pos->dso->long_name_len + 1); if (perf_tool__process_synth_event(tool, event, machine, process) != 0) { rc = -1; break; } } free(event); return rc; }
pid_t perf_event__synthesize_comm(struct perf_tool *tool, union perf_event *event, pid_t pid, perf_event__handler_t process, struct machine *machine) { pid_t tgid, ppid; if (perf_event__prepare_comm(event, pid, machine, &tgid, &ppid) != 0) return -1; if (perf_tool__process_synth_event(tool, event, machine, process) != 0) return -1; return tgid; }
int perf_event__synthesize_namespaces(struct perf_tool *tool, union perf_event *event, pid_t pid, pid_t tgid, perf_event__handler_t process, struct machine *machine) { u32 idx; struct perf_ns_link_info *ns_link_info; if (!tool || !tool->namespace_events) return 0; memset(&event->namespaces, 0, (sizeof(event->namespaces) + (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) + machine->id_hdr_size)); event->namespaces.pid = tgid; event->namespaces.tid = pid; event->namespaces.nr_namespaces = NR_NAMESPACES; ns_link_info = event->namespaces.link_info; for (idx = 0; idx < event->namespaces.nr_namespaces; idx++) perf_event__get_ns_link_info(pid, perf_ns__name(idx), &ns_link_info[idx]); event->namespaces.header.type = PERF_RECORD_NAMESPACES; event->namespaces.header.size = (sizeof(event->namespaces) + (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) + machine->id_hdr_size); if (perf_tool__process_synth_event(tool, event, machine, process) != 0) return -1; return 0; }
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; }