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