?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
QE/FHCI: fixed the CONTROL bug
[zen-stable.git] / tools / perf / util / event.c
blob3c1b8a6321017efdb75fde50cbe5d1d520a62153
1 #include <linux/types.h>
2 #include "event.h"
3 #include "debug.h"
4 #include "session.h"
5 #include "sort.h"
6 #include "string.h"
7 #include "strlist.h"
8 #include "thread.h"
9 #include "thread_map.h"
10
11 static const char *perf_event__names[] = {
12 [0] = "TOTAL",
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",
27 };
28
29 const char *perf_event__name(unsigned int id)
30 {
31 if (id >= ARRAY_SIZE(perf_event__names))
32 return "INVALID";
33 if (!perf_event__names[id])
34 return "UNKNOWN";
35 return perf_event__names[id];
36 }
37
38 static struct perf_sample synth_sample = {
39 .pid = -1,
40 .tid = -1,
41 .time = -1,
42 .stream_id = -1,
43 .cpu = -1,
44 .period = 1,
45 };
46
47 static pid_t perf_event__synthesize_comm(union perf_event *event, pid_t pid,
48 int full, perf_event__handler_t process,
49 struct perf_session *session)
50 {
51 char filename[PATH_MAX];
52 char bf[BUFSIZ];
53 FILE *fp;
54 size_t size = 0;
55 DIR *tasks;
56 struct dirent dirent, *next;
57 pid_t tgid = 0;
58
59 snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
60
61 fp = fopen(filename, "r");
62 if (fp == NULL) {
63 out_race:
64 /*
65 * We raced with a task exiting - just return:
66 */
67 pr_debug("couldn't open %s\n", filename);
68 return 0;
69 }
70
71 memset(&event->comm, 0, sizeof(event->comm));
72
73 while (!event->comm.comm[0] || !event->comm.pid) {
74 if (fgets(bf, sizeof(bf), fp) == NULL) {
75 pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
76 goto out;
77 }
78
79 if (memcmp(bf, "Name:", 5) == 0) {
80 char *name = bf + 5;
81 while (*name && isspace(*name))
82 ++name;
83 size = strlen(name) - 1;
84 memcpy(event->comm.comm, name, size++);
85 } else if (memcmp(bf, "Tgid:", 5) == 0) {
86 char *tgids = bf + 5;
87 while (*tgids && isspace(*tgids))
88 ++tgids;
89 tgid = event->comm.pid = atoi(tgids);
90 }
91 }
92
93 event->comm.header.type = PERF_RECORD_COMM;
94 size = ALIGN(size, sizeof(u64));
95 memset(event->comm.comm + size, 0, session->id_hdr_size);
96 event->comm.header.size = (sizeof(event->comm) -
97 (sizeof(event->comm.comm) - size) +
98 session->id_hdr_size);
99 if (!full) {
100 event->comm.tid = pid;
101
102 process(event, &synth_sample, session);
103 goto out;
104 }
105
106 snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
107
108 tasks = opendir(filename);
109 if (tasks == NULL)
110 goto out_race;
111
112 while (!readdir_r(tasks, &dirent, &next) && next) {
113 char *end;
114 pid = strtol(dirent.d_name, &end, 10);
115 if (*end)
116 continue;
117
118 event->comm.tid = pid;
119
120 process(event, &synth_sample, session);
121 }
122
123 closedir(tasks);
124 out:
125 fclose(fp);
126
127 return tgid;
128 }
129
130 static int perf_event__synthesize_mmap_events(union perf_event *event,
131 pid_t pid, pid_t tgid,
132 perf_event__handler_t process,
133 struct perf_session *session)
134 {
135 char filename[PATH_MAX];
136 FILE *fp;
137
138 snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
139
140 fp = fopen(filename, "r");
141 if (fp == NULL) {
142 /*
143 * We raced with a task exiting - just return:
144 */
145 pr_debug("couldn't open %s\n", filename);
146 return -1;
147 }
148
149 event->header.type = PERF_RECORD_MMAP;
150 /*
151 * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
152 */
153 event->header.misc = PERF_RECORD_MISC_USER;
154
155 while (1) {
156 char bf[BUFSIZ], *pbf = bf;
157 int n;
158 size_t size;
159 if (fgets(bf, sizeof(bf), fp) == NULL)
160 break;
161
162 /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */
163 n = hex2u64(pbf, &event->mmap.start);
164 if (n < 0)
165 continue;
166 pbf += n + 1;
167 n = hex2u64(pbf, &event->mmap.len);
168 if (n < 0)
169 continue;
170 pbf += n + 3;
171 if (*pbf == 'x') { /* vm_exec */
172 char *execname = strchr(bf, '/');
173
174 /* Catch VDSO */
175 if (execname == NULL)
176 execname = strstr(bf, "[vdso]");
177
178 if (execname == NULL)
179 continue;
180
181 pbf += 3;
182 n = hex2u64(pbf, &event->mmap.pgoff);
183
184 size = strlen(execname);
185 execname[size - 1] = '\0'; /* Remove \n */
186 memcpy(event->mmap.filename, execname, size);
187 size = ALIGN(size, sizeof(u64));
188 event->mmap.len -= event->mmap.start;
189 event->mmap.header.size = (sizeof(event->mmap) -
190 (sizeof(event->mmap.filename) - size));
191 memset(event->mmap.filename + size, 0, session->id_hdr_size);
192 event->mmap.header.size += session->id_hdr_size;
193 event->mmap.pid = tgid;
194 event->mmap.tid = pid;
195
196 process(event, &synth_sample, session);
197 }
198 }
199
200 fclose(fp);
201 return 0;
202 }
203
204 int perf_event__synthesize_modules(perf_event__handler_t process,
205 struct perf_session *session,
206 struct machine *machine)
207 {
208 struct rb_node *nd;
209 struct map_groups *kmaps = &machine->kmaps;
210 union perf_event *event = zalloc((sizeof(event->mmap) +
211 session->id_hdr_size));
212 if (event == NULL) {
213 pr_debug("Not enough memory synthesizing mmap event "
214 "for kernel modules\n");
215 return -1;
216 }
217
218 event->header.type = PERF_RECORD_MMAP;
219
220 /*
221 * kernel uses 0 for user space maps, see kernel/perf_event.c
222 * __perf_event_mmap
223 */
224 if (machine__is_host(machine))
225 event->header.misc = PERF_RECORD_MISC_KERNEL;
226 else
227 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
228
229 for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]);
230 nd; nd = rb_next(nd)) {
231 size_t size;
232 struct map *pos = rb_entry(nd, struct map, rb_node);
233
234 if (pos->dso->kernel)
235 continue;
236
237 size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
238 event->mmap.header.type = PERF_RECORD_MMAP;
239 event->mmap.header.size = (sizeof(event->mmap) -
240 (sizeof(event->mmap.filename) - size));
241 memset(event->mmap.filename + size, 0, session->id_hdr_size);
242 event->mmap.header.size += session->id_hdr_size;
243 event->mmap.start = pos->start;
244 event->mmap.len = pos->end - pos->start;
245 event->mmap.pid = machine->pid;
246
247 memcpy(event->mmap.filename, pos->dso->long_name,
248 pos->dso->long_name_len + 1);
249 process(event, &synth_sample, session);
250 }
251
252 free(event);
253 return 0;
254 }
255
256 static int __event__synthesize_thread(union perf_event *comm_event,
257 union perf_event *mmap_event,
258 pid_t pid, perf_event__handler_t process,
259 struct perf_session *session)
260 {
261 pid_t tgid = perf_event__synthesize_comm(comm_event, pid, 1, process,
262 session);
263 if (tgid == -1)
264 return -1;
265 return perf_event__synthesize_mmap_events(mmap_event, pid, tgid,
266 process, session);
267 }
268
269 int perf_event__synthesize_thread_map(struct thread_map *threads,
270 perf_event__handler_t process,
271 struct perf_session *session)
272 {
273 union perf_event *comm_event, *mmap_event;
274 int err = -1, thread;
275
276 comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
277 if (comm_event == NULL)
278 goto out;
279
280 mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size);
281 if (mmap_event == NULL)
282 goto out_free_comm;
283
284 err = 0;
285 for (thread = 0; thread < threads->nr; ++thread) {
286 if (__event__synthesize_thread(comm_event, mmap_event,
287 threads->map[thread],
288 process, session)) {
289 err = -1;
290 break;
291 }
292 }
293 free(mmap_event);
294 out_free_comm:
295 free(comm_event);
296 out:
297 return err;
298 }
299
300 int perf_event__synthesize_threads(perf_event__handler_t process,
301 struct perf_session *session)
302 {
303 DIR *proc;
304 struct dirent dirent, *next;
305 union perf_event *comm_event, *mmap_event;
306 int err = -1;
307
308 comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
309 if (comm_event == NULL)
310 goto out;
311
312 mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size);
313 if (mmap_event == NULL)
314 goto out_free_comm;
315
316 proc = opendir("/proc");
317 if (proc == NULL)
318 goto out_free_mmap;
319
320 while (!readdir_r(proc, &dirent, &next) && next) {
321 char *end;
322 pid_t pid = strtol(dirent.d_name, &end, 10);
323
324 if (*end) /* only interested in proper numerical dirents */
325 continue;
326
327 __event__synthesize_thread(comm_event, mmap_event, pid,
328 process, session);
329 }
330
331 closedir(proc);
332 err = 0;
333 out_free_mmap:
334 free(mmap_event);
335 out_free_comm:
336 free(comm_event);
337 out:
338 return err;
339 }
340
341 struct process_symbol_args {
342 const char *name;
343 u64 start;
344 };
345
346 static int find_symbol_cb(void *arg, const char *name, char type,
347 u64 start, u64 end __used)
348 {
349 struct process_symbol_args *args = arg;
350
351 /*
352 * Must be a function or at least an alias, as in PARISC64, where "_text" is
353 * an 'A' to the same address as "_stext".
354 */
355 if (!(symbol_type__is_a(type, MAP__FUNCTION) ||
356 type == 'A') || strcmp(name, args->name))
357 return 0;
358
359 args->start = start;
360 return 1;
361 }
362
363 int perf_event__synthesize_kernel_mmap(perf_event__handler_t process,
364 struct perf_session *session,
365 struct machine *machine,
366 const char *symbol_name)
367 {
368 size_t size;
369 const char *filename, *mmap_name;
370 char path[PATH_MAX];
371 char name_buff[PATH_MAX];
372 struct map *map;
373 int err;
374 /*
375 * We should get this from /sys/kernel/sections/.text, but till that is
376 * available use this, and after it is use this as a fallback for older
377 * kernels.
378 */
379 struct process_symbol_args args = { .name = symbol_name, };
380 union perf_event *event = zalloc((sizeof(event->mmap) +
381 session->id_hdr_size));
382 if (event == NULL) {
383 pr_debug("Not enough memory synthesizing mmap event "
384 "for kernel modules\n");
385 return -1;
386 }
387
388 mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff));
389 if (machine__is_host(machine)) {
390 /*
391 * kernel uses PERF_RECORD_MISC_USER for user space maps,
392 * see kernel/perf_event.c __perf_event_mmap
393 */
394 event->header.misc = PERF_RECORD_MISC_KERNEL;
395 filename = "/proc/kallsyms";
396 } else {
397 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
398 if (machine__is_default_guest(machine))
399 filename = (char *) symbol_conf.default_guest_kallsyms;
400 else {
401 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
402 filename = path;
403 }
404 }
405
406 if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
407 return -ENOENT;
408
409 map = machine->vmlinux_maps[MAP__FUNCTION];
410 size = snprintf(event->mmap.filename, sizeof(event->mmap.filename),
411 "%s%s", mmap_name, symbol_name) + 1;
412 size = ALIGN(size, sizeof(u64));
413 event->mmap.header.type = PERF_RECORD_MMAP;
414 event->mmap.header.size = (sizeof(event->mmap) -
415 (sizeof(event->mmap.filename) - size) + session->id_hdr_size);
416 event->mmap.pgoff = args.start;
417 event->mmap.start = map->start;
418 event->mmap.len = map->end - event->mmap.start;
419 event->mmap.pid = machine->pid;
420
421 err = process(event, &synth_sample, session);
422 free(event);
423
424 return err;
425 }
426
427 int perf_event__process_comm(union perf_event *event,
428 struct perf_sample *sample __used,
429 struct perf_session *session)
430 {
431 struct thread *thread = perf_session__findnew(session, event->comm.tid);
432
433 dump_printf(": %s:%d\n", event->comm.comm, event->comm.tid);
434
435 if (thread == NULL || thread__set_comm(thread, event->comm.comm)) {
436 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
437 return -1;
438 }
439
440 return 0;
441 }
442
443 int perf_event__process_lost(union perf_event *event,
444 struct perf_sample *sample __used,
445 struct perf_session *session)
446 {
447 dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
448 event->lost.id, event->lost.lost);
449 session->hists.stats.total_lost += event->lost.lost;
450 return 0;
451 }
452
453 static void perf_event__set_kernel_mmap_len(union perf_event *event,
454 struct map **maps)
455 {
456 maps[MAP__FUNCTION]->start = event->mmap.start;
457 maps[MAP__FUNCTION]->end = event->mmap.start + event->mmap.len;
458 /*
459 * Be a bit paranoid here, some perf.data file came with
460 * a zero sized synthesized MMAP event for the kernel.
461 */
462 if (maps[MAP__FUNCTION]->end == 0)
463 maps[MAP__FUNCTION]->end = ~0ULL;
464 }
465
466 static int perf_event__process_kernel_mmap(union perf_event *event,
467 struct perf_session *session)
468 {
469 struct map *map;
470 char kmmap_prefix[PATH_MAX];
471 struct machine *machine;
472 enum dso_kernel_type kernel_type;
473 bool is_kernel_mmap;
474
475 machine = perf_session__findnew_machine(session, event->mmap.pid);
476 if (!machine) {
477 pr_err("Can't find id %d's machine\n", event->mmap.pid);
478 goto out_problem;
479 }
480
481 machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
482 if (machine__is_host(machine))
483 kernel_type = DSO_TYPE_KERNEL;
484 else
485 kernel_type = DSO_TYPE_GUEST_KERNEL;
486
487 is_kernel_mmap = memcmp(event->mmap.filename,
488 kmmap_prefix,
489 strlen(kmmap_prefix)) == 0;
490 if (event->mmap.filename[0] == '/' ||
491 (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
492
493 char short_module_name[1024];
494 char *name, *dot;
495
496 if (event->mmap.filename[0] == '/') {
497 name = strrchr(event->mmap.filename, '/');
498 if (name == NULL)
499 goto out_problem;
500
501 ++name; /* skip / */
502 dot = strrchr(name, '.');
503 if (dot == NULL)
504 goto out_problem;
505 snprintf(short_module_name, sizeof(short_module_name),
506 "[%.*s]", (int)(dot - name), name);
507 strxfrchar(short_module_name, '-', '_');
508 } else
509 strcpy(short_module_name, event->mmap.filename);
510
511 map = machine__new_module(machine, event->mmap.start,
512 event->mmap.filename);
513 if (map == NULL)
514 goto out_problem;
515
516 name = strdup(short_module_name);
517 if (name == NULL)
518 goto out_problem;
519
520 map->dso->short_name = name;
521 map->dso->sname_alloc = 1;
522 map->end = map->start + event->mmap.len;
523 } else if (is_kernel_mmap) {
524 const char *symbol_name = (event->mmap.filename +
525 strlen(kmmap_prefix));
526 /*
527 * Should be there already, from the build-id table in
528 * the header.
529 */
530 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
531 kmmap_prefix);
532 if (kernel == NULL)
533 goto out_problem;
534
535 kernel->kernel = kernel_type;
536 if (__machine__create_kernel_maps(machine, kernel) < 0)
537 goto out_problem;
538
539 perf_event__set_kernel_mmap_len(event, machine->vmlinux_maps);
540
541 /*
542 * Avoid using a zero address (kptr_restrict) for the ref reloc
543 * symbol. Effectively having zero here means that at record
544 * time /proc/sys/kernel/kptr_restrict was non zero.
545 */
546 if (event->mmap.pgoff != 0) {
547 perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
548 symbol_name,
549 event->mmap.pgoff);
550 }
551
552 if (machine__is_default_guest(machine)) {
553 /*
554 * preload dso of guest kernel and modules
555 */
556 dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
557 NULL);
558 }
559 }
560 return 0;
561 out_problem:
562 return -1;
563 }
564
565 int perf_event__process_mmap(union perf_event *event,
566 struct perf_sample *sample __used,
567 struct perf_session *session)
568 {
569 struct machine *machine;
570 struct thread *thread;
571 struct map *map;
572 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
573 int ret = 0;
574
575 dump_printf(" %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %s\n",
576 event->mmap.pid, event->mmap.tid, event->mmap.start,
577 event->mmap.len, event->mmap.pgoff, event->mmap.filename);
578
579 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
580 cpumode == PERF_RECORD_MISC_KERNEL) {
581 ret = perf_event__process_kernel_mmap(event, session);
582 if (ret < 0)
583 goto out_problem;
584 return 0;
585 }
586
587 machine = perf_session__find_host_machine(session);
588 if (machine == NULL)
589 goto out_problem;
590 thread = perf_session__findnew(session, event->mmap.pid);
591 if (thread == NULL)
592 goto out_problem;
593 map = map__new(&machine->user_dsos, event->mmap.start,
594 event->mmap.len, event->mmap.pgoff,
595 event->mmap.pid, event->mmap.filename,
596 MAP__FUNCTION);
597 if (map == NULL)
598 goto out_problem;
599
600 thread__insert_map(thread, map);
601 return 0;
602
603 out_problem:
604 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
605 return 0;
606 }
607
608 int perf_event__process_task(union perf_event *event,
609 struct perf_sample *sample __used,
610 struct perf_session *session)
611 {
612 struct thread *thread = perf_session__findnew(session, event->fork.tid);
613 struct thread *parent = perf_session__findnew(session, event->fork.ptid);
614
615 dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
616 event->fork.ppid, event->fork.ptid);
617
618 if (event->header.type == PERF_RECORD_EXIT) {
619 perf_session__remove_thread(session, thread);
620 return 0;
621 }
622
623 if (thread == NULL || parent == NULL ||
624 thread__fork(thread, parent) < 0) {
625 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
626 return -1;
627 }
628
629 return 0;
630 }
631
632 int perf_event__process(union perf_event *event, struct perf_sample *sample,
633 struct perf_session *session)
634 {
635 switch (event->header.type) {
636 case PERF_RECORD_COMM:
637 perf_event__process_comm(event, sample, session);
638 break;
639 case PERF_RECORD_MMAP:
640 perf_event__process_mmap(event, sample, session);
641 break;
642 case PERF_RECORD_FORK:
643 case PERF_RECORD_EXIT:
644 perf_event__process_task(event, sample, session);
645 break;
646 case PERF_RECORD_LOST:
647 perf_event__process_lost(event, sample, session);
648 default:
649 break;
650 }
651
652 return 0;
653 }
654
655 void thread__find_addr_map(struct thread *self,
656 struct perf_session *session, u8 cpumode,
657 enum map_type type, pid_t pid, u64 addr,
658 struct addr_location *al)
659 {
660 struct map_groups *mg = &self->mg;
661 struct machine *machine = NULL;
662
663 al->thread = self;
664 al->addr = addr;
665 al->cpumode = cpumode;
666 al->filtered = false;
667
668 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
669 al->level = 'k';
670 machine = perf_session__find_host_machine(session);
671 if (machine == NULL) {
672 al->map = NULL;
673 return;
674 }
675 mg = &machine->kmaps;
676 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
677 al->level = '.';
678 machine = perf_session__find_host_machine(session);
679 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
680 al->level = 'g';
681 machine = perf_session__find_machine(session, pid);
682 if (machine == NULL) {
683 al->map = NULL;
684 return;
685 }
686 mg = &machine->kmaps;
687 } else {
688 /*
689 * 'u' means guest os user space.
690 * TODO: We don't support guest user space. Might support late.
691 */
692 if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest)
693 al->level = 'u';
694 else
695 al->level = 'H';
696 al->map = NULL;
697
698 if ((cpumode == PERF_RECORD_MISC_GUEST_USER ||
699 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) &&
700 !perf_guest)
701 al->filtered = true;
702 if ((cpumode == PERF_RECORD_MISC_USER ||
703 cpumode == PERF_RECORD_MISC_KERNEL) &&
704 !perf_host)
705 al->filtered = true;
706
707 return;
708 }
709 try_again:
710 al->map = map_groups__find(mg, type, al->addr);
711 if (al->map == NULL) {
712 /*
713 * If this is outside of all known maps, and is a negative
714 * address, try to look it up in the kernel dso, as it might be
715 * a vsyscall or vdso (which executes in user-mode).
716 *
717 * XXX This is nasty, we should have a symbol list in the
718 * "[vdso]" dso, but for now lets use the old trick of looking
719 * in the whole kernel symbol list.
720 */
721 if ((long long)al->addr < 0 &&
722 cpumode == PERF_RECORD_MISC_USER &&
723 machine && mg != &machine->kmaps) {
724 mg = &machine->kmaps;
725 goto try_again;
726 }
727 } else
728 al->addr = al->map->map_ip(al->map, al->addr);
729 }
730
731 void thread__find_addr_location(struct thread *self,
732 struct perf_session *session, u8 cpumode,
733 enum map_type type, pid_t pid, u64 addr,
734 struct addr_location *al,
735 symbol_filter_t filter)
736 {
737 thread__find_addr_map(self, session, cpumode, type, pid, addr, al);
738 if (al->map != NULL)
739 al->sym = map__find_symbol(al->map, al->addr, filter);
740 else
741 al->sym = NULL;
742 }
743
744 int perf_event__preprocess_sample(const union perf_event *event,
745 struct perf_session *session,
746 struct addr_location *al,
747 struct perf_sample *sample,
748 symbol_filter_t filter)
749 {
750 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
751 struct thread *thread = perf_session__findnew(session, event->ip.pid);
752
753 if (thread == NULL)
754 return -1;
755
756 if (symbol_conf.comm_list &&
757 !strlist__has_entry(symbol_conf.comm_list, thread->comm))
758 goto out_filtered;
759
760 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
761 /*
762 * Have we already created the kernel maps for the host machine?
763 *
764 * This should have happened earlier, when we processed the kernel MMAP
765 * events, but for older perf.data files there was no such thing, so do
766 * it now.
767 */
768 if (cpumode == PERF_RECORD_MISC_KERNEL &&
769 session->host_machine.vmlinux_maps[MAP__FUNCTION] == NULL)
770 machine__create_kernel_maps(&session->host_machine);
771
772 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
773 event->ip.pid, event->ip.ip, al);
774 dump_printf(" ...... dso: %s\n",
775 al->map ? al->map->dso->long_name :
776 al->level == 'H' ? "[hypervisor]" : "<not found>");
777 al->sym = NULL;
778 al->cpu = sample->cpu;
779
780 if (al->map) {
781 if (symbol_conf.dso_list &&
782 (!al->map || !al->map->dso ||
783 !(strlist__has_entry(symbol_conf.dso_list,
784 al->map->dso->short_name) ||
785 (al->map->dso->short_name != al->map->dso->long_name &&
786 strlist__has_entry(symbol_conf.dso_list,
787 al->map->dso->long_name)))))
788 goto out_filtered;
789
790 al->sym = map__find_symbol(al->map, al->addr, filter);
791 }
792
793 if (symbol_conf.sym_list && al->sym &&
794 !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
795 goto out_filtered;
796
797 return 0;
798
799 out_filtered:
800 al->filtered = true;
801 return 0;
802 }