1 #include <linux/types.h>
9 #include "thread_map.h"
11 static const char *perf_event__names[] = {
13 [PERF_RECORD_MMAP] = "MMAP",
14 [PERF_RECORD_LOST] = "LOST",
15 [PERF_RECORD_COMM] = "COMM",
16 [PERF_RECORD_EXIT] = "EXIT",
17 [PERF_RECORD_THROTTLE] = "THROTTLE",
18 [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
19 [PERF_RECORD_FORK] = "FORK",
20 [PERF_RECORD_READ] = "READ",
21 [PERF_RECORD_SAMPLE] = "SAMPLE",
22 [PERF_RECORD_HEADER_ATTR] = "ATTR",
23 [PERF_RECORD_HEADER_EVENT_TYPE] = "EVENT_TYPE",
24 [PERF_RECORD_HEADER_TRACING_DATA] = "TRACING_DATA",
25 [PERF_RECORD_HEADER_BUILD_ID] = "BUILD_ID",
26 [PERF_RECORD_FINISHED_ROUND] = "FINISHED_ROUND",
29 const char *perf_event__name(unsigned int id)
31 if (id >= ARRAY_SIZE(perf_event__names))
33 if (!perf_event__names[id])
35 return perf_event__names[id];
38 static struct perf_sample synth_sample = {
47 static pid_t perf_event__synthesize_comm(struct perf_event_ops *ops,
48 union perf_event *event, pid_t pid,
49 int full, perf_event__handler_t process,
50 struct perf_session *session)
52 char filename[PATH_MAX];
57 struct dirent dirent, *next;
60 snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
62 fp = fopen(filename, "r");
66 * We raced with a task exiting - just return:
68 pr_debug("couldn't open %s\n", filename);
72 memset(&event->comm, 0, sizeof(event->comm));
74 while (!event->comm.comm[0] || !event->comm.pid) {
75 if (fgets(bf, sizeof(bf), fp) == NULL) {
76 pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
80 if (memcmp(bf, "Name:", 5) == 0) {
82 while (*name && isspace(*name))
84 size = strlen(name) - 1;
85 memcpy(event->comm.comm, name, size++);
86 } else if (memcmp(bf, "Tgid:", 5) == 0) {
88 while (*tgids && isspace(*tgids))
90 tgid = event->comm.pid = atoi(tgids);
94 event->comm.header.type = PERF_RECORD_COMM;
95 size = ALIGN(size, sizeof(u64));
96 memset(event->comm.comm + size, 0, session->id_hdr_size);
97 event->comm.header.size = (sizeof(event->comm) -
98 (sizeof(event->comm.comm) - size) +
99 session->id_hdr_size);
101 event->comm.tid = pid;
103 process(ops, event, &synth_sample, session);
107 snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
109 tasks = opendir(filename);
113 while (!readdir_r(tasks, &dirent, &next) && next) {
115 pid = strtol(dirent.d_name, &end, 10);
119 event->comm.tid = pid;
121 process(ops, event, &synth_sample, session);
131 static int perf_event__synthesize_mmap_events(struct perf_event_ops *ops,
132 union perf_event *event,
133 pid_t pid, pid_t tgid,
134 perf_event__handler_t process,
135 struct perf_session *session)
137 char filename[PATH_MAX];
140 snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
142 fp = fopen(filename, "r");
145 * We raced with a task exiting - just return:
147 pr_debug("couldn't open %s\n", filename);
151 event->header.type = PERF_RECORD_MMAP;
153 * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
155 event->header.misc = PERF_RECORD_MISC_USER;
158 char bf[BUFSIZ], *pbf = bf;
161 if (fgets(bf, sizeof(bf), fp) == NULL)
164 /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */
165 n = hex2u64(pbf, &event->mmap.start);
169 n = hex2u64(pbf, &event->mmap.len);
173 if (*pbf == 'x') { /* vm_exec */
174 char anonstr[] = "//anon\n";
175 char *execname = strchr(bf, '/');
178 if (execname == NULL)
179 execname = strstr(bf, "[vdso]");
181 /* Catch anonymous mmaps */
182 if ((execname == NULL) && !strstr(bf, "["))
185 if (execname == NULL)
189 n = hex2u64(pbf, &event->mmap.pgoff);
191 size = strlen(execname);
192 execname[size - 1] = '\0'; /* Remove \n */
193 memcpy(event->mmap.filename, execname, size);
194 size = ALIGN(size, sizeof(u64));
195 event->mmap.len -= event->mmap.start;
196 event->mmap.header.size = (sizeof(event->mmap) -
197 (sizeof(event->mmap.filename) - size));
198 memset(event->mmap.filename + size, 0, session->id_hdr_size);
199 event->mmap.header.size += session->id_hdr_size;
200 event->mmap.pid = tgid;
201 event->mmap.tid = pid;
203 process(ops, event, &synth_sample, session);
211 int perf_event__synthesize_modules(struct perf_event_ops *ops,
212 perf_event__handler_t process,
213 struct perf_session *session,
214 struct machine *machine)
217 struct map_groups *kmaps = &machine->kmaps;
218 union perf_event *event = zalloc((sizeof(event->mmap) +
219 session->id_hdr_size));
221 pr_debug("Not enough memory synthesizing mmap event "
222 "for kernel modules\n");
226 event->header.type = PERF_RECORD_MMAP;
229 * kernel uses 0 for user space maps, see kernel/perf_event.c
232 if (machine__is_host(machine))
233 event->header.misc = PERF_RECORD_MISC_KERNEL;
235 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
237 for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]);
238 nd; nd = rb_next(nd)) {
240 struct map *pos = rb_entry(nd, struct map, rb_node);
242 if (pos->dso->kernel)
245 size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
246 event->mmap.header.type = PERF_RECORD_MMAP;
247 event->mmap.header.size = (sizeof(event->mmap) -
248 (sizeof(event->mmap.filename) - size));
249 memset(event->mmap.filename + size, 0, session->id_hdr_size);
250 event->mmap.header.size += session->id_hdr_size;
251 event->mmap.start = pos->start;
252 event->mmap.len = pos->end - pos->start;
253 event->mmap.pid = machine->pid;
255 memcpy(event->mmap.filename, pos->dso->long_name,
256 pos->dso->long_name_len + 1);
257 process(ops, event, &synth_sample, session);
264 static int __event__synthesize_thread(union perf_event *comm_event,
265 union perf_event *mmap_event,
266 pid_t pid, perf_event__handler_t process,
267 struct perf_event_ops *ops,
268 struct perf_session *session)
270 pid_t tgid = perf_event__synthesize_comm(ops, comm_event, pid, 1, process,
274 return perf_event__synthesize_mmap_events(ops, mmap_event, pid, tgid,
278 int perf_event__synthesize_thread_map(struct perf_event_ops *ops,
279 struct thread_map *threads,
280 perf_event__handler_t process,
281 struct perf_session *session)
283 union perf_event *comm_event, *mmap_event;
284 int err = -1, thread;
286 comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
287 if (comm_event == NULL)
290 mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size);
291 if (mmap_event == NULL)
295 for (thread = 0; thread < threads->nr; ++thread) {
296 if (__event__synthesize_thread(comm_event, mmap_event,
297 threads->map[thread],
298 process, ops, session)) {
310 int perf_event__synthesize_threads(struct perf_event_ops *ops,
311 perf_event__handler_t process,
312 struct perf_session *session)
315 struct dirent dirent, *next;
316 union perf_event *comm_event, *mmap_event;
319 comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
320 if (comm_event == NULL)
323 mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size);
324 if (mmap_event == NULL)
327 proc = opendir("/proc");
331 while (!readdir_r(proc, &dirent, &next) && next) {
333 pid_t pid = strtol(dirent.d_name, &end, 10);
335 if (*end) /* only interested in proper numerical dirents */
338 __event__synthesize_thread(comm_event, mmap_event, pid,
339 process, ops, session);
352 struct process_symbol_args {
357 static int find_symbol_cb(void *arg, const char *name, char type,
358 u64 start, u64 end __used)
360 struct process_symbol_args *args = arg;
363 * Must be a function or at least an alias, as in PARISC64, where "_text" is
364 * an 'A' to the same address as "_stext".
366 if (!(symbol_type__is_a(type, MAP__FUNCTION) ||
367 type == 'A') || strcmp(name, args->name))
374 int perf_event__synthesize_kernel_mmap(struct perf_event_ops *ops,
375 perf_event__handler_t process,
376 struct perf_session *session,
377 struct machine *machine,
378 const char *symbol_name)
381 const char *filename, *mmap_name;
383 char name_buff[PATH_MAX];
387 * We should get this from /sys/kernel/sections/.text, but till that is
388 * available use this, and after it is use this as a fallback for older
391 struct process_symbol_args args = { .name = symbol_name, };
392 union perf_event *event = zalloc((sizeof(event->mmap) +
393 session->id_hdr_size));
395 pr_debug("Not enough memory synthesizing mmap event "
396 "for kernel modules\n");
400 mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff));
401 if (machine__is_host(machine)) {
403 * kernel uses PERF_RECORD_MISC_USER for user space maps,
404 * see kernel/perf_event.c __perf_event_mmap
406 event->header.misc = PERF_RECORD_MISC_KERNEL;
407 filename = "/proc/kallsyms";
409 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
410 if (machine__is_default_guest(machine))
411 filename = (char *) symbol_conf.default_guest_kallsyms;
413 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
418 if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
421 map = machine->vmlinux_maps[MAP__FUNCTION];
422 size = snprintf(event->mmap.filename, sizeof(event->mmap.filename),
423 "%s%s", mmap_name, symbol_name) + 1;
424 size = ALIGN(size, sizeof(u64));
425 event->mmap.header.type = PERF_RECORD_MMAP;
426 event->mmap.header.size = (sizeof(event->mmap) -
427 (sizeof(event->mmap.filename) - size) + session->id_hdr_size);
428 event->mmap.pgoff = args.start;
429 event->mmap.start = map->start;
430 event->mmap.len = map->end - event->mmap.start;
431 event->mmap.pid = machine->pid;
433 err = process(ops, event, &synth_sample, session);
439 int perf_event__process_comm(struct perf_event_ops *ops __used,
440 union perf_event *event,
441 struct perf_sample *sample __used,
442 struct perf_session *session)
444 struct thread *thread = perf_session__findnew(session, event->comm.tid);
446 dump_printf(": %s:%d\n", event->comm.comm, event->comm.tid);
448 if (thread == NULL || thread__set_comm(thread, event->comm.comm)) {
449 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
456 int perf_event__process_lost(struct perf_event_ops *ops __used,
457 union perf_event *event,
458 struct perf_sample *sample __used,
459 struct perf_session *session)
461 dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
462 event->lost.id, event->lost.lost);
463 session->hists.stats.total_lost += event->lost.lost;
467 static void perf_event__set_kernel_mmap_len(union perf_event *event,
470 maps[MAP__FUNCTION]->start = event->mmap.start;
471 maps[MAP__FUNCTION]->end = event->mmap.start + event->mmap.len;
473 * Be a bit paranoid here, some perf.data file came with
474 * a zero sized synthesized MMAP event for the kernel.
476 if (maps[MAP__FUNCTION]->end == 0)
477 maps[MAP__FUNCTION]->end = ~0ULL;
480 static int perf_event__process_kernel_mmap(struct perf_event_ops *ops __used,
481 union perf_event *event,
482 struct perf_session *session)
485 char kmmap_prefix[PATH_MAX];
486 struct machine *machine;
487 enum dso_kernel_type kernel_type;
490 machine = perf_session__findnew_machine(session, event->mmap.pid);
492 pr_err("Can't find id %d's machine\n", event->mmap.pid);
496 machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
497 if (machine__is_host(machine))
498 kernel_type = DSO_TYPE_KERNEL;
500 kernel_type = DSO_TYPE_GUEST_KERNEL;
502 is_kernel_mmap = memcmp(event->mmap.filename,
504 strlen(kmmap_prefix)) == 0;
505 if (event->mmap.filename[0] == '/' ||
506 (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
508 char short_module_name[1024];
511 if (event->mmap.filename[0] == '/') {
512 name = strrchr(event->mmap.filename, '/');
517 dot = strrchr(name, '.');
520 snprintf(short_module_name, sizeof(short_module_name),
521 "[%.*s]", (int)(dot - name), name);
522 strxfrchar(short_module_name, '-', '_');
524 strcpy(short_module_name, event->mmap.filename);
526 map = machine__new_module(machine, event->mmap.start,
527 event->mmap.filename);
531 name = strdup(short_module_name);
535 map->dso->short_name = name;
536 map->dso->sname_alloc = 1;
537 map->end = map->start + event->mmap.len;
538 } else if (is_kernel_mmap) {
539 const char *symbol_name = (event->mmap.filename +
540 strlen(kmmap_prefix));
542 * Should be there already, from the build-id table in
545 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
550 kernel->kernel = kernel_type;
551 if (__machine__create_kernel_maps(machine, kernel) < 0)
554 perf_event__set_kernel_mmap_len(event, machine->vmlinux_maps);
557 * Avoid using a zero address (kptr_restrict) for the ref reloc
558 * symbol. Effectively having zero here means that at record
559 * time /proc/sys/kernel/kptr_restrict was non zero.
561 if (event->mmap.pgoff != 0) {
562 perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
567 if (machine__is_default_guest(machine)) {
569 * preload dso of guest kernel and modules
571 dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
580 int perf_event__process_mmap(struct perf_event_ops *ops,
581 union perf_event *event,
582 struct perf_sample *sample __used,
583 struct perf_session *session)
585 struct machine *machine;
586 struct thread *thread;
588 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
591 dump_printf(" %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %s\n",
592 event->mmap.pid, event->mmap.tid, event->mmap.start,
593 event->mmap.len, event->mmap.pgoff, event->mmap.filename);
595 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
596 cpumode == PERF_RECORD_MISC_KERNEL) {
597 ret = perf_event__process_kernel_mmap(ops, event, session);
603 machine = perf_session__find_host_machine(session);
606 thread = perf_session__findnew(session, event->mmap.pid);
609 map = map__new(&machine->user_dsos, event->mmap.start,
610 event->mmap.len, event->mmap.pgoff,
611 event->mmap.pid, event->mmap.filename,
616 thread__insert_map(thread, map);
620 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
624 int perf_event__process_task(struct perf_event_ops *ops __used,
625 union perf_event *event,
626 struct perf_sample *sample __used,
627 struct perf_session *session)
629 struct thread *thread = perf_session__findnew(session, event->fork.tid);
630 struct thread *parent = perf_session__findnew(session, event->fork.ptid);
632 dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
633 event->fork.ppid, event->fork.ptid);
635 if (event->header.type == PERF_RECORD_EXIT) {
636 perf_session__remove_thread(session, thread);
640 if (thread == NULL || parent == NULL ||
641 thread__fork(thread, parent) < 0) {
642 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
649 int perf_event__process(struct perf_event_ops *ops, union perf_event *event,
650 struct perf_sample *sample, struct perf_session *session)
652 switch (event->header.type) {
653 case PERF_RECORD_COMM:
654 perf_event__process_comm(ops, event, sample, session);
656 case PERF_RECORD_MMAP:
657 perf_event__process_mmap(ops, event, sample, session);
659 case PERF_RECORD_FORK:
660 case PERF_RECORD_EXIT:
661 perf_event__process_task(ops, event, sample, session);
663 case PERF_RECORD_LOST:
664 perf_event__process_lost(ops, event, sample, session);
672 void thread__find_addr_map(struct thread *self,
673 struct perf_session *session, u8 cpumode,
674 enum map_type type, pid_t pid, u64 addr,
675 struct addr_location *al)
677 struct map_groups *mg = &self->mg;
678 struct machine *machine = NULL;
682 al->cpumode = cpumode;
683 al->filtered = false;
685 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
687 machine = perf_session__find_host_machine(session);
688 if (machine == NULL) {
692 mg = &machine->kmaps;
693 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
695 machine = perf_session__find_host_machine(session);
696 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
698 machine = perf_session__find_machine(session, pid);
699 if (machine == NULL) {
703 mg = &machine->kmaps;
706 * 'u' means guest os user space.
707 * TODO: We don't support guest user space. Might support late.
709 if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest)
715 if ((cpumode == PERF_RECORD_MISC_GUEST_USER ||
716 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) &&
719 if ((cpumode == PERF_RECORD_MISC_USER ||
720 cpumode == PERF_RECORD_MISC_KERNEL) &&
727 al->map = map_groups__find(mg, type, al->addr);
728 if (al->map == NULL) {
730 * If this is outside of all known maps, and is a negative
731 * address, try to look it up in the kernel dso, as it might be
732 * a vsyscall or vdso (which executes in user-mode).
734 * XXX This is nasty, we should have a symbol list in the
735 * "[vdso]" dso, but for now lets use the old trick of looking
736 * in the whole kernel symbol list.
738 if ((long long)al->addr < 0 &&
739 cpumode == PERF_RECORD_MISC_USER &&
740 machine && mg != &machine->kmaps) {
741 mg = &machine->kmaps;
745 al->addr = al->map->map_ip(al->map, al->addr);
748 void thread__find_addr_location(struct thread *self,
749 struct perf_session *session, u8 cpumode,
750 enum map_type type, pid_t pid, u64 addr,
751 struct addr_location *al,
752 symbol_filter_t filter)
754 thread__find_addr_map(self, session, cpumode, type, pid, addr, al);
756 al->sym = map__find_symbol(al->map, al->addr, filter);
761 int perf_event__preprocess_sample(const union perf_event *event,
762 struct perf_session *session,
763 struct addr_location *al,
764 struct perf_sample *sample,
765 symbol_filter_t filter)
767 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
768 struct thread *thread = perf_session__findnew(session, event->ip.pid);
773 if (symbol_conf.comm_list &&
774 !strlist__has_entry(symbol_conf.comm_list, thread->comm))
777 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
779 * Have we already created the kernel maps for the host machine?
781 * This should have happened earlier, when we processed the kernel MMAP
782 * events, but for older perf.data files there was no such thing, so do
785 if (cpumode == PERF_RECORD_MISC_KERNEL &&
786 session->host_machine.vmlinux_maps[MAP__FUNCTION] == NULL)
787 machine__create_kernel_maps(&session->host_machine);
789 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
790 event->ip.pid, event->ip.ip, al);
791 dump_printf(" ...... dso: %s\n",
792 al->map ? al->map->dso->long_name :
793 al->level == 'H' ? "[hypervisor]" : "<not found>");
795 al->cpu = sample->cpu;
798 if (symbol_conf.dso_list &&
799 (!al->map || !al->map->dso ||
800 !(strlist__has_entry(symbol_conf.dso_list,
801 al->map->dso->short_name) ||
802 (al->map->dso->short_name != al->map->dso->long_name &&
803 strlist__has_entry(symbol_conf.dso_list,
804 al->map->dso->long_name)))))
807 al->sym = map__find_symbol(al->map, al->addr, filter);
810 if (symbol_conf.sym_list && al->sym &&
811 !strlist__has_entry(symbol_conf.sym_list, al->sym->name))