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