int perf_event__synthesize_thread_map(struct perf_tool *tool, struct thread_map *threads, perf_event__handler_t process, struct machine *machine, bool mmap_data) { union perf_event *comm_event, *mmap_event; int err = -1, thread, j; comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); if (comm_event == NULL) goto out; mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size); if (mmap_event == NULL) goto out_free_comm; err = 0; for (thread = 0; thread < threads->nr; ++thread) { if (__event__synthesize_thread(comm_event, mmap_event, threads->map[thread], 0, process, tool, machine, mmap_data)) { err = -1; break; } /* * comm.pid is set to thread group id by * perf_event__synthesize_comm */ if ((int) comm_event->comm.pid != threads->map[thread]) { bool need_leader = true; /* is thread group leader in thread_map? */ for (j = 0; j < threads->nr; ++j) { if ((int) comm_event->comm.pid == threads->map[j]) { need_leader = false; break; } } /* if not, generate events for it */ if (need_leader && __event__synthesize_thread(comm_event, mmap_event, comm_event->comm.pid, 0, process, tool, machine, mmap_data)) { err = -1; break; } } } free(mmap_event); out_free_comm: free(comm_event); out: return err; }
int perf_event__synthesize_thread_map(struct thread_map *threads, perf_event__handler_t process, struct perf_session *session) { union perf_event *comm_event, *mmap_event; int err = -1, thread; comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size); if (comm_event == NULL) goto out; mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size); if (mmap_event == NULL) goto out_free_comm; err = 0; for (thread = 0; thread < threads->nr; ++thread) { if (__event__synthesize_thread(comm_event, mmap_event, threads->map[thread], process, session)) { err = -1; break; } } free(mmap_event); out_free_comm: free(comm_event); out: return err; }
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 perf_event__synthesize_threads(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine) { DIR *proc; struct dirent dirent, *next; union perf_event *comm_event, *mmap_event; int err = -1; comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); if (comm_event == NULL) goto out; mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size); if (mmap_event == NULL) goto out_free_comm; proc = opendir("/proc"); if (proc == NULL) goto out_free_mmap; while (!readdir_r(proc, &dirent, &next) && next) { 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, pid, 1, process, tool, machine); } err = 0; closedir(proc); out_free_mmap: free(mmap_event); out_free_comm: free(comm_event); out: return err; }
int perf_event__synthesize_threads(perf_event__handler_t process, struct perf_session *session) { DIR *proc; struct dirent dirent, *next; union perf_event *comm_event, *mmap_event; int err = -1; comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size); if (comm_event == NULL) goto out; mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size); if (mmap_event == NULL) goto out_free_comm; proc = opendir("/proc"); if (proc == NULL) goto out_free_mmap; while (!readdir_r(proc, &dirent, &next) && next) { char *end; pid_t pid = strtol(dirent.d_name, &end, 10); if (*end) /* only interested in proper numerical dirents */ continue; __event__synthesize_thread(comm_event, mmap_event, pid, process, session); } closedir(proc); err = 0; out_free_mmap: free(mmap_event); out_free_comm: free(comm_event); out: return err; }
int event__synthesize_thread(pid_t pid, event__handler_t process, struct perf_session *session) { event_t *comm_event, *mmap_event; int err = -1; comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size); if (comm_event == NULL) goto out; mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size); if (mmap_event == NULL) goto out_free_comm; err = __event__synthesize_thread(comm_event, mmap_event, pid, process, session); free(mmap_event); out_free_comm: free(comm_event); out: return err; }
static int __perf_event__synthesize_threads(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine, bool mmap_data, struct dirent **dirent, int start, int num) { union perf_event *comm_event, *mmap_event, *fork_event; union perf_event *namespaces_event; int err = -1; char *end; pid_t pid; int i; 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; namespaces_event = malloc(sizeof(namespaces_event->namespaces) + (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) + machine->id_hdr_size); if (namespaces_event == NULL) goto out_free_fork; for (i = start; i < start + num; i++) { if (!isdigit(dirent[i]->d_name[0])) continue; pid = (pid_t)strtol(dirent[i]->d_name, &end, 10); /* only interested in proper numerical dirents */ if (*end) 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, namespaces_event, pid, 1, process, tool, machine, mmap_data); } err = 0; free(namespaces_event); out_free_fork: free(fork_event); out_free_mmap: free(mmap_event); out_free_comm: free(comm_event); out: return err; }
int perf_event__synthesize_thread_map(struct perf_tool *tool, struct thread_map *threads, perf_event__handler_t process, struct machine *machine, bool mmap_data) { union perf_event *comm_event, *mmap_event, *fork_event; union perf_event *namespaces_event; int err = -1, thread, j; 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; namespaces_event = malloc(sizeof(namespaces_event->namespaces) + (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) + machine->id_hdr_size); if (namespaces_event == NULL) goto out_free_fork; err = 0; for (thread = 0; thread < threads->nr; ++thread) { if (__event__synthesize_thread(comm_event, mmap_event, fork_event, namespaces_event, thread_map__pid(threads, thread), 0, process, tool, machine, mmap_data)) { err = -1; break; } /* * comm.pid is set to thread group id by * perf_event__synthesize_comm */ if ((int) comm_event->comm.pid != thread_map__pid(threads, thread)) { bool need_leader = true; /* is thread group leader in thread_map? */ for (j = 0; j < threads->nr; ++j) { if ((int) comm_event->comm.pid == thread_map__pid(threads, j)) { need_leader = false; break; } } /* if not, generate events for it */ if (need_leader && __event__synthesize_thread(comm_event, mmap_event, fork_event, namespaces_event, comm_event->comm.pid, 0, process, tool, machine, mmap_data)) { err = -1; break; } } } free(namespaces_event); out_free_fork: free(fork_event); out_free_mmap: free(mmap_event); out_free_comm: free(comm_event); out: return err; }