perf tools: Handle relocatable kernels

DSOs don't have this problem because the kernel emits a
PERF_MMAP for each new executable mapping it performs on
monitored threads.

To fix the kernel case we simulate the same behaviour, by having
'perf record' to synthesize a PERF_MMAP for the kernel, encoded
like this:

[root@doppio ~]# perf record -a -f sleep 1
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.344 MB perf.data (~15038 samples) ]
[root@doppio ~]# perf report -D | head -10

0xd0 [0x40]: event: 1
.
. ... raw event: size 64 bytes
.  0000:  01 00 00 00 00 00 40 00 00 00 00 00 00 00 00 00 ......@........
.  0010:  00 00 00 81 ff ff ff ff 00 00 00 00 00 00 00 00 ...............
.  0020:  00 00 00 00 00 00 00 00 5b 6b 65 72 6e 65 6c 2e ........  [kernel
.  0030:  6b 61 6c 6c 73 79 6d 73 2e 5f 74 65 78 74 5d 00  kallsyms._text]
.  0xd0
[0x40]: PERF_RECORD_MMAP 0/0: [0xffffffff81000000((nil)) @ (nil)]: [kernel.kallsyms._text]

I.e. we identify such event as having:

 .pid      = 0
 .filename = [kernel.kallsyms.REFNAME]
 .start    = REFNAME addr in /proc/kallsyms at 'perf record' time

and use now a hardcoded value of '.text' for REFNAME.

Then, later, in 'perf report', if there are any kernel hits and
thus we need to resolve kernel symbols, we search for REFNAME
and if its address changed, relocation happened and we thus must
change the kernel mapping routines to one that uses .pgoff as
the relocation to apply.

This way we use the same mechanism used for the other DSOs and
don't have to do a two pass in all the kernel symbols.

Reported-by: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
LKML-Reference: <1262717431-1246-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 61 insertions, 3 deletions

diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index bb0fd6da2d56..1a31feb9999f 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -189,6 +189,50 @@ void event__synthesize_threads(int (*process)(event_t *event,
         closedir(proc);
 }
 
+struct process_symbol_args {
+        const char *name;
+        u64        start;
+};
+
+static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
+{
+        struct process_symbol_args *args = arg;
+
+        if (!symbol_type__is_a(type, MAP__FUNCTION) || strcmp(name, args->name))
+                return 0;
+
+        args->start = start;
+        return 1;
+}
+
+int event__synthesize_kernel_mmap(int (*process)(event_t *event,
+                                                 struct perf_session *session),
+                                  struct perf_session *session,
+                                  const char *symbol_name)
+{
+        size_t size;
+        event_t ev = {
+                .header = { .type = PERF_RECORD_MMAP },
+        };
+        /*
+         * We should get this from /sys/kernel/sections/.text, but till that is
+         * available use this, and after it is use this as a fallback for older
+         * kernels.
+         */
+        struct process_symbol_args args = { .name = symbol_name, };
+
+        if (kallsyms__parse(&args, find_symbol_cb) <= 0)
+                return -ENOENT;
+
+        size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
+                        "[kernel.kallsyms.%s]", symbol_name) + 1;
+        size = ALIGN(size, sizeof(u64));
+        ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size));
+        ev.mmap.start = args.start;
+
+        return process(&ev, session);
+}
+
 static void thread__comm_adjust(struct thread *self)
 {
         char *comm = self->comm;
@@ -240,9 +284,9 @@ int event__process_lost(event_t *self, struct perf_session *session)
 
 int event__process_mmap(event_t *self, struct perf_session *session)
 {
-        struct thread *thread = perf_session__findnew(session, self->mmap.pid);
-        struct map *map = map__new(&self->mmap, MAP__FUNCTION,
-                                   session->cwd, session->cwdlen);
+        struct thread *thread;
+        struct map *map;
+        static const char kmmap_prefix[] = "[kernel.kallsyms.";
 
         dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n",
                     self->mmap.pid, self->mmap.tid,
@@ -251,6 +295,20 @@ int event__process_mmap(event_t *self, struct perf_session *session)
                     (void *)(long)self->mmap.pgoff,
                     self->mmap.filename);
 
+        if (self->mmap.pid == 0 &&
+            memcmp(self->mmap.filename, kmmap_prefix,
+                   sizeof(kmmap_prefix) - 1) == 0) {
+                const char *symbol_name = (self->mmap.filename +
+                                           sizeof(kmmap_prefix) - 1);
+                perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name,
+                                                         self->mmap.start);
+                return 0;
+        }
+
+        thread = perf_session__findnew(session, self->mmap.pid);
+        map = map__new(&self->mmap, MAP__FUNCTION,
+                       session->cwd, session->cwdlen);
+
         if (thread == NULL || map == NULL)
                 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
         else