GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-06-27 09:02:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
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>
This commit is contained in:
Arnaldo Carvalho de Melo 2009-12-11 14:50:36 -02:00 • committed by Ingo Molnar
parent 58e9f94138
commit 9958e1f0ae
6 changed files with 108 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

62
tools/perf/util/thread.c
View file

@ -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 map_groups__fprintf(struct map_groups *self, FILE *fp)
{
size_t printed = map_groups__fprintf_maps(self, fp);
printed += fprintf(fp, "Removed maps:\n");
return printed + map_groups__fprintf_removed_maps(self, fp);
}
static size_t thread__fprintf(struct thread *self, FILE *fp)
{
size_t printed = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
printed += thread__fprintf_removed_maps(self, fp);
printed += fprintf(fp, "Removed maps:\n");
return printed + thread__fprintf_removed_maps(self, 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);