perf tools: Rename "kernel_info" to "machine"
[linux-2.6.git] / tools / perf / util / map.h
1 #ifndef __PERF_MAP_H
2 #define __PERF_MAP_H
3
4 #include <linux/compiler.h>
5 #include <linux/list.h>
6 #include <linux/rbtree.h>
7 #include <stdio.h>
8 #include <stdbool.h>
9 #include "types.h"
10
11 enum map_type {
12         MAP__FUNCTION = 0,
13         MAP__VARIABLE,
14 };
15
16 #define MAP__NR_TYPES (MAP__VARIABLE + 1)
17
18 extern const char *map_type__name[MAP__NR_TYPES];
19
20 struct dso;
21 struct ref_reloc_sym;
22 struct map_groups;
23 struct machine;
24
25 struct map {
26         union {
27                 struct rb_node  rb_node;
28                 struct list_head node;
29         };
30         u64                     start;
31         u64                     end;
32         enum map_type           type;
33         u64                     pgoff;
34
35         /* ip -> dso rip */
36         u64                     (*map_ip)(struct map *, u64);
37         /* dso rip -> ip */
38         u64                     (*unmap_ip)(struct map *, u64);
39
40         struct dso              *dso;
41         struct map_groups       *groups;
42 };
43
44 struct kmap {
45         struct ref_reloc_sym    *ref_reloc_sym;
46         struct map_groups       *kmaps;
47 };
48
49 struct map_groups {
50         struct rb_root   maps[MAP__NR_TYPES];
51         struct list_head removed_maps[MAP__NR_TYPES];
52         struct machine   *machine;
53 };
54
55 /* Native host kernel uses -1 as pid index in machine */
56 #define HOST_KERNEL_ID                  (-1)
57 #define DEFAULT_GUEST_KERNEL_ID         (0)
58
59 struct machine {
60         struct rb_node    rb_node;
61         pid_t             pid;
62         char              *root_dir;
63         struct list_head  user_dsos;
64         struct list_head  kernel_dsos;
65         struct map_groups kmaps;
66         struct map        *vmlinux_maps[MAP__NR_TYPES];
67 };
68
69 static inline struct kmap *map__kmap(struct map *self)
70 {
71         return (struct kmap *)(self + 1);
72 }
73
74 static inline u64 map__map_ip(struct map *map, u64 ip)
75 {
76         return ip - map->start + map->pgoff;
77 }
78
79 static inline u64 map__unmap_ip(struct map *map, u64 ip)
80 {
81         return ip + map->start - map->pgoff;
82 }
83
84 static inline u64 identity__map_ip(struct map *map __used, u64 ip)
85 {
86         return ip;
87 }
88
89
90 /* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
91 u64 map__rip_2objdump(struct map *map, u64 rip);
92 u64 map__objdump_2ip(struct map *map, u64 addr);
93
94 struct symbol;
95
96 typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
97
98 void map__init(struct map *self, enum map_type type,
99                u64 start, u64 end, u64 pgoff, struct dso *dso);
100 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
101                      u64 pgoff, u32 pid, char *filename,
102                      enum map_type type, char *cwd, int cwdlen);
103 void map__delete(struct map *self);
104 struct map *map__clone(struct map *self);
105 int map__overlap(struct map *l, struct map *r);
106 size_t map__fprintf(struct map *self, FILE *fp);
107
108 int map__load(struct map *self, symbol_filter_t filter);
109 struct symbol *map__find_symbol(struct map *self,
110                                 u64 addr, symbol_filter_t filter);
111 struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
112                                         symbol_filter_t filter);
113 void map__fixup_start(struct map *self);
114 void map__fixup_end(struct map *self);
115
116 void map__reloc_vmlinux(struct map *self);
117
118 size_t __map_groups__fprintf_maps(struct map_groups *self,
119                                   enum map_type type, int verbose, FILE *fp);
120 void maps__insert(struct rb_root *maps, struct map *map);
121 struct map *maps__find(struct rb_root *maps, u64 addr);
122 void map_groups__init(struct map_groups *self);
123 int map_groups__clone(struct map_groups *self,
124                       struct map_groups *parent, enum map_type type);
125 size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
126 size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp);
127
128 typedef void (*machine__process_t)(struct machine *self, void *data);
129
130 void machines__process(struct rb_root *self, machine__process_t process, void *data);
131 struct machine *machines__add(struct rb_root *self, pid_t pid,
132                               const char *root_dir);
133 struct machine *machines__find_host(struct rb_root *self);
134 struct machine *machines__find(struct rb_root *self, pid_t pid);
135 struct machine *machines__findnew(struct rb_root *self, pid_t pid);
136 char *machine__mmap_name(struct machine *self, char *buff);
137
138 /*
139  * Default guest kernel is defined by parameter --guestkallsyms
140  * and --guestmodules
141  */
142 static inline bool machine__is_default_guest(struct machine *self)
143 {
144         return self ? self->pid == DEFAULT_GUEST_KERNEL_ID : false;
145 }
146
147 static inline bool machine__is_host(struct machine *self)
148 {
149         return self ? self->pid == HOST_KERNEL_ID : false;
150 }
151
152 static inline void map_groups__insert(struct map_groups *self, struct map *map)
153 {
154         maps__insert(&self->maps[map->type], map);
155         map->groups = self;
156 }
157
158 static inline struct map *map_groups__find(struct map_groups *self,
159                                            enum map_type type, u64 addr)
160 {
161         return maps__find(&self->maps[type], addr);
162 }
163
164 struct symbol *map_groups__find_symbol(struct map_groups *self,
165                                        enum map_type type, u64 addr,
166                                        struct map **mapp,
167                                        symbol_filter_t filter);
168
169 struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
170                                                enum map_type type,
171                                                const char *name,
172                                                struct map **mapp,
173                                                symbol_filter_t filter);
174
175 static inline
176 struct symbol *map_groups__find_function(struct map_groups *self, u64 addr,
177                                          struct map **mapp, symbol_filter_t filter)
178 {
179         return map_groups__find_symbol(self, MAP__FUNCTION, addr, mapp, filter);
180 }
181
182 static inline
183 struct symbol *map_groups__find_function_by_name(struct map_groups *self,
184                                                  const char *name, struct map **mapp,
185                                                  symbol_filter_t filter)
186 {
187         return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter);
188 }
189
190 int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
191                                    int verbose, FILE *fp);
192
193 struct map *map_groups__find_by_name(struct map_groups *self,
194                                      enum map_type type, const char *name);
195 struct map *map_groups__new_module(struct map_groups *self, u64 start,
196                                    const char *filename, struct machine *machine);
197
198 void map_groups__flush(struct map_groups *self);
199
200 #endif /* __PERF_MAP_H */