perf: Store trace event name/id pairs in perf.data

The trace event name<->id mapping is dynamic for each kernel
compile. In order for perf.data to be useable outside the actual
system, we thus need to store a table of this mapping for later
use.

This patch adds this table to perf.data, and provides helper
functions for lookup up fields from this table.

To avoid mistakes, lookup-from-table is kept completely seprate
from lookup-from-local-debugfs.

Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
LKML-Reference: <20090912130405.6960d099@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index ec4d4c2f95223ff1df63c4a6f523e6b00a004132..ef9114583994ffe4730146204e0adf60ef36a2e7 100644 (file)
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -86,6 +86,44 @@ void perf_header__add_attr(struct perf_header *self,
        self->attr[pos] = attr;
 }
 
+struct perf_trace_event_type {
+       u64     event_id;
+       char    name[64];
+};
+
+static int event_count;
+static struct perf_trace_event_type *events;
+
+void perf_header__push_event(u64 id, const char *name)
+{
+       if (strlen(name) > 64)
+               printf("Event %s will be truncated\n", name);
+
+       if (!events) {
+               events = malloc(sizeof(struct perf_trace_event_type));
+               if (!events)
+                       die("nomem");
+       } else {
+               events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
+               if (!events)
+                       die("nomem");
+       }
+       memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
+       events[event_count].event_id = id;
+       strncpy(events[event_count].name, name, 63);
+       event_count++;
+}
+
+char *perf_header__find_event(u64 id)
+{
+       int i;
+       for (i = 0 ; i < event_count; i++) {
+               if (events[i].event_id == id)
+                       return events[i].name;
+       }
+       return NULL;
+}
+
 static const char *__perf_magic = "PERFFILE";
 
 #define PERF_MAGIC     (*(u64 *)__perf_magic)
@@ -106,6 +144,7 @@ struct perf_file_header {
        u64                             attr_size;
        struct perf_file_section        attrs;
        struct perf_file_section        data;
+       struct perf_file_section        event_types;
 };
 
 static void do_write(int fd, void *buf, size_t size)
@@ -154,6 +193,11 @@ void perf_header__write(struct perf_header *self, int fd)
                do_write(fd, &f_attr, sizeof(f_attr));
        }
 
+       self->event_offset = lseek(fd, 0, SEEK_CUR);
+       self->event_size = event_count * sizeof(struct perf_trace_event_type);
+       if (events)
+               do_write(fd, events, self->event_size);
+
 
        self->data_offset = lseek(fd, 0, SEEK_CUR);
 
@@ -169,6 +213,10 @@ void perf_header__write(struct perf_header *self, int fd)
                        .offset = self->data_offset,
                        .size   = self->data_size,
                },
+               .event_types = {
+                       .offset = self->event_offset,
+                       .size   = self->event_size,
+               },
        };
 
        lseek(fd, 0, SEEK_SET);
@@ -234,6 +282,17 @@ struct perf_header *perf_header__read(int fd)
                lseek(fd, tmp, SEEK_SET);
        }
 
+       if (f_header.event_types.size) {
+               lseek(fd, f_header.event_types.offset, SEEK_SET);
+               events = malloc(f_header.event_types.size);
+               if (!events)
+                       die("nomem");
+               do_read(fd, events, f_header.event_types.size);
+               event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
+       }
+       self->event_offset = f_header.event_types.offset;
+       self->event_size   = f_header.event_types.size;
+
        self->data_offset = f_header.data.offset;
        self->data_size   = f_header.data.size;
 

diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 5d0a72ecc919f4fcdd448a3a0140e1d4ba114947..7b0e84a871792ec6e0feb471ed10b56965084ba2 100644 (file)
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -19,6 +19,8 @@ struct perf_header {
        s64 attr_offset;
        u64 data_offset;
        u64 data_size;
+       u64 event_offset;
+       u64 event_size;
 };
 
 struct perf_header *perf_header__read(int fd);
@@ -27,6 +29,10 @@ void perf_header__write(struct perf_header *self, int fd);
 void perf_header__add_attr(struct perf_header *self,
                           struct perf_header_attr *attr);
 
+void perf_header__push_event(u64 id, const char *name);
+char *perf_header__find_event(u64 id);
+
+
 struct perf_header_attr *
 perf_header_attr__new(struct perf_counter_attr *attr);
 void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index a9bdcab8c0702c5e0fd2134955b43bf8aa1b7d8e..89172fd0038badef081bca09af00c16bb4de012b 100644 (file)
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -6,6 +6,7 @@
 #include "exec_cmd.h"
 #include "string.h"
 #include "cache.h"
+#include "header.h"
 
 int                                    nr_counters;
 
@@ -687,11 +688,35 @@ modifier:
        return ret;
 }
 
+static void store_event_type(const char *orgname)
+{
+       char filename[PATH_MAX], *c;
+       FILE *file;
+       int id;
+
+       sprintf(filename, "/sys/kernel/debug/tracing/events/%s/id", orgname);
+       c = strchr(filename, ':');
+       if (c)
+               *c = '/';
+
+       file = fopen(filename, "r");
+       if (!file)
+               return;
+       if (fscanf(file, "%i", &id) < 1)
+               die("cannot store event ID");
+       fclose(file);
+       perf_header__push_event(id, orgname);
+}
+
+
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 {
        struct perf_counter_attr attr;
        enum event_result ret;
 
+       if (strchr(str, ':'))
+               store_event_type(str);
+
        for (;;) {
                if (nr_counters == MAX_COUNTERS)
                        return -1;