perf symbols: Rename kthreads to kmaps, using another abstraction for it

Using a struct thread instance just to hold the kernel space maps
(vmlinux + modules) is overkill and confuses people trying to
understand the perf symbols abstractions.

The kernel maps are really present in all threads, i.e. the kernel
is a library, not a separate thread.

So introduce the 'map_groups' abstraction and use it for the kernel
maps, now in the kmaps global variable.

It, in turn, will move, together with the threads list to the
perf_file abstraction, so that we can support multiple perf_file
instances, needed by perf diff.

Brainstormed-with: Eduardo Habkost <ehabkost@redhat.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260550239-5372-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 35 insertions, 27 deletions

diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 603f5610861b..a1285129c831 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -9,11 +9,9 @@
 static struct rb_root threads;
 static struct thread *last_match;
 
-void thread__init(struct thread *self, pid_t pid)
+void map_groups__init(struct map_groups *self)
 {
         int i;
-        self->pid = pid;
-        self->comm = NULL;
         for (i = 0; i < MAP__NR_TYPES; ++i) {
                 self->maps[i] = RB_ROOT;
                 INIT_LIST_HEAD(&self->removed_maps[i]);
@@ -25,7 +23,8 @@ static struct thread *thread__new(pid_t pid)
         struct thread *self = zalloc(sizeof(*self));
 
         if (self != NULL) {
-                thread__init(self, pid);
+                map_groups__init(&self->mg);
+                self->pid = pid;
                 self->comm = malloc(32);
                 if (self->comm)
                         snprintf(self->comm, 32, ":%d", self->pid);
@@ -57,8 +56,8 @@ static const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__FUNCTION] = "Functions",
 };
 
-static size_t __thread__fprintf_maps(struct thread *self,
-                                     enum map_type type, FILE *fp)
+static size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                         enum map_type type, FILE *fp)
 {
         size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
         struct rb_node *nd;
@@ -76,16 +75,16 @@ static size_t __thread__fprintf_maps(struct thread *self,
         return printed;
 }
 
-size_t thread__fprintf_maps(struct thread *self, FILE *fp)
+size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __thread__fprintf_maps(self, i, fp);
+                printed += __map_groups__fprintf_maps(self, i, fp);
         return printed;
 }
 
-static size_t __thread__fprintf_removed_maps(struct thread *self,
-                                             enum map_type type, FILE *fp)
+static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
+                                                 enum map_type type, FILE *fp)
 {
         struct map *pos;
         size_t printed = 0;
@@ -101,20 +100,25 @@ static size_t __thread__fprintf_removed_maps(struct thread *self,
         return printed;
 }
 
-static size_t thread__fprintf_removed_maps(struct thread *self, FILE *fp)
+static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __thread__fprintf_removed_maps(self, i, fp);
+                printed += __map_groups__fprintf_removed_maps(self, i, fp);
         return printed;
 }
 
-static size_t thread__fprintf(struct thread *self, FILE *fp)
+static size_t map_groups__fprintf(struct map_groups *self, FILE *fp)
 {
-        size_t printed = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
-        printed += thread__fprintf_removed_maps(self, fp);
+        size_t printed = map_groups__fprintf_maps(self, fp);
         printed += fprintf(fp, "Removed maps:\n");
-        return printed + thread__fprintf_removed_maps(self, fp);
+        return printed + map_groups__fprintf_removed_maps(self, fp);
+}
+
+static size_t thread__fprintf(struct thread *self, FILE *fp)
+{
+        return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
+               map_groups__fprintf(&self->mg, fp);
 }
 
 struct thread *threads__findnew(pid_t pid)
@@ -168,7 +172,8 @@ struct thread *register_idle_thread(void)
         return thread;
 }
 
-static void thread__remove_overlappings(struct thread *self, struct map *map)
+static void map_groups__remove_overlappings(struct map_groups *self,
+                                            struct map *map)
 {
         struct rb_root *root = &self->maps[map->type];
         struct rb_node *next = rb_first(root);
@@ -238,12 +243,15 @@ struct map *maps__find(struct rb_root *maps, u64 ip)
 
 void thread__insert_map(struct thread *self, struct map *map)
 {
-        thread__remove_overlappings(self, map);
-        maps__insert(&self->maps[map->type], map);
+        map_groups__remove_overlappings(&self->mg, map);
+        map_groups__insert(&self->mg, map);
 }
 
-static int thread__clone_maps(struct thread *self, struct thread *parent,
-                              enum map_type type)
+/*
+ * XXX This should not really _copy_ te maps, but refcount them.
+ */
+static int map_groups__clone(struct map_groups *self,
+                             struct map_groups *parent, enum map_type type)
 {
         struct rb_node *nd;
         for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
@@ -251,7 +259,7 @@ static int thread__clone_maps(struct thread *self, struct thread *parent,
                 struct map *new = map__clone(map);
                 if (new == NULL)
                         return -ENOMEM;
-                thread__insert_map(self, new);
+                map_groups__insert(self, new);
         }
         return 0;
 }
@@ -267,7 +275,7 @@ int thread__fork(struct thread *self, struct thread *parent)
                 return -ENOMEM;
 
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                if (thread__clone_maps(self, parent, i) < 0)
+                if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
                         return -ENOMEM;
         return 0;
 }
@@ -286,11 +294,11 @@ size_t threads__fprintf(FILE *fp)
         return ret;
 }
 
-struct symbol *thread__find_symbol(struct thread *self,
-                                   enum map_type type, u64 addr,
-                                   symbol_filter_t filter)
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       symbol_filter_t filter)
 {
-        struct map *map = thread__find_map(self, type, addr);
+        struct map *map = map_groups__find(self, type, addr);
 
         if (map != NULL)
                 return map__find_symbol(map, map->map_ip(map, addr), filter);