1 #include "../perf.h" 2 #include <stdlib.h> 3 #include <stdio.h> 4 #include <string.h> 5 #include "session.h" 6 #include "thread.h" 7 #include "util.h" 8 #include "debug.h" 9 10 void map_groups__init(struct map_groups *self) 11 { 12 int i; 13 for (i = 0; i < MAP__NR_TYPES; ++i) { 14 self->maps[i] = RB_ROOT; 15 INIT_LIST_HEAD(&self->removed_maps[i]); 16 } 17 } 18 19 static struct thread *thread__new(pid_t pid) 20 { 21 struct thread *self = zalloc(sizeof(*self)); 22 23 if (self != NULL) { 24 map_groups__init(&self->mg); 25 self->pid = pid; 26 self->comm = malloc(32); 27 if (self->comm) 28 snprintf(self->comm, 32, ":%d", self->pid); 29 } 30 31 return self; 32 } 33 34 int thread__set_comm(struct thread *self, const char *comm) 35 { 36 if (self->comm) 37 free(self->comm); 38 self->comm = strdup(comm); 39 return self->comm ? 0 : -ENOMEM; 40 } 41 42 int thread__comm_len(struct thread *self) 43 { 44 if (!self->comm_len) { 45 if (!self->comm) 46 return 0; 47 self->comm_len = strlen(self->comm); 48 } 49 50 return self->comm_len; 51 } 52 53 static const char *map_type__name[MAP__NR_TYPES] = { 54 [MAP__FUNCTION] = "Functions", 55 [MAP__VARIABLE] = "Variables", 56 }; 57 58 static size_t __map_groups__fprintf_maps(struct map_groups *self, 59 enum map_type type, FILE *fp) 60 { 61 size_t printed = fprintf(fp, "%s:\n", map_type__name[type]); 62 struct rb_node *nd; 63 64 for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) { 65 struct map *pos = rb_entry(nd, struct map, rb_node); 66 printed += fprintf(fp, "Map:"); 67 printed += map__fprintf(pos, fp); 68 if (verbose > 1) { 69 printed += dso__fprintf(pos->dso, type, fp); 70 printed += fprintf(fp, "--\n"); 71 } 72 } 73 74 return printed; 75 } 76 77 size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp) 78 { 79 size_t printed = 0, i; 80 for (i = 0; i < MAP__NR_TYPES; ++i) 81 printed += __map_groups__fprintf_maps(self, i, fp); 82 return printed; 83 } 84 85 static size_t __map_groups__fprintf_removed_maps(struct map_groups *self, 86 enum map_type type, FILE *fp) 87 { 88 struct map *pos; 89 size_t printed = 0; 90 91 list_for_each_entry(pos, &self->removed_maps[type], node) { 92 printed += fprintf(fp, "Map:"); 93 printed += map__fprintf(pos, fp); 94 if (verbose > 1) { 95 printed += dso__fprintf(pos->dso, type, fp); 96 printed += fprintf(fp, "--\n"); 97 } 98 } 99 return printed; 100 } 101 102 static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp) 103 { 104 size_t printed = 0, i; 105 for (i = 0; i < MAP__NR_TYPES; ++i) 106 printed += __map_groups__fprintf_removed_maps(self, i, fp); 107 return printed; 108 } 109 110 static size_t map_groups__fprintf(struct map_groups *self, FILE *fp) 111 { 112 size_t printed = map_groups__fprintf_maps(self, fp); 113 printed += fprintf(fp, "Removed maps:\n"); 114 return printed + map_groups__fprintf_removed_maps(self, fp); 115 } 116 117 static size_t thread__fprintf(struct thread *self, FILE *fp) 118 { 119 return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) + 120 map_groups__fprintf(&self->mg, fp); 121 } 122 123 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid) 124 { 125 struct rb_node **p = &self->threads.rb_node; 126 struct rb_node *parent = NULL; 127 struct thread *th; 128 129 /* 130 * Font-end cache - PID lookups come in blocks, 131 * so most of the time we dont have to look up 132 * the full rbtree: 133 */ 134 if (self->last_match && self->last_match->pid == pid) 135 return self->last_match; 136 137 while (*p != NULL) { 138 parent = *p; 139 th = rb_entry(parent, struct thread, rb_node); 140 141 if (th->pid == pid) { 142 self->last_match = th; 143 return th; 144 } 145 146 if (pid < th->pid) 147 p = &(*p)->rb_left; 148 else 149 p = &(*p)->rb_right; 150 } 151 152 th = thread__new(pid); 153 if (th != NULL) { 154 rb_link_node(&th->rb_node, parent, p); 155 rb_insert_color(&th->rb_node, &self->threads); 156 self->last_match = th; 157 } 158 159 return th; 160 } 161 162 static void map_groups__remove_overlappings(struct map_groups *self, 163 struct map *map) 164 { 165 struct rb_root *root = &self->maps[map->type]; 166 struct rb_node *next = rb_first(root); 167 168 while (next) { 169 struct map *pos = rb_entry(next, struct map, rb_node); 170 next = rb_next(&pos->rb_node); 171 172 if (!map__overlap(pos, map)) 173 continue; 174 175 if (verbose >= 2) { 176 fputs("overlapping maps:\n", stderr); 177 map__fprintf(map, stderr); 178 map__fprintf(pos, stderr); 179 } 180 181 rb_erase(&pos->rb_node, root); 182 /* 183 * We may have references to this map, for instance in some 184 * hist_entry instances, so just move them to a separate 185 * list. 186 */ 187 list_add_tail(&pos->node, &self->removed_maps[map->type]); 188 } 189 } 190 191 void maps__insert(struct rb_root *maps, struct map *map) 192 { 193 struct rb_node **p = &maps->rb_node; 194 struct rb_node *parent = NULL; 195 const u64 ip = map->start; 196 struct map *m; 197 198 while (*p != NULL) { 199 parent = *p; 200 m = rb_entry(parent, struct map, rb_node); 201 if (ip < m->start) 202 p = &(*p)->rb_left; 203 else 204 p = &(*p)->rb_right; 205 } 206 207 rb_link_node(&map->rb_node, parent, p); 208 rb_insert_color(&map->rb_node, maps); 209 } 210 211 struct map *maps__find(struct rb_root *maps, u64 ip) 212 { 213 struct rb_node **p = &maps->rb_node; 214 struct rb_node *parent = NULL; 215 struct map *m; 216 217 while (*p != NULL) { 218 parent = *p; 219 m = rb_entry(parent, struct map, rb_node); 220 if (ip < m->start) 221 p = &(*p)->rb_left; 222 else if (ip > m->end) 223 p = &(*p)->rb_right; 224 else 225 return m; 226 } 227 228 return NULL; 229 } 230 231 void thread__insert_map(struct thread *self, struct map *map) 232 { 233 map_groups__remove_overlappings(&self->mg, map); 234 map_groups__insert(&self->mg, map); 235 } 236 237 /* 238 * XXX This should not really _copy_ te maps, but refcount them. 239 */ 240 static int map_groups__clone(struct map_groups *self, 241 struct map_groups *parent, enum map_type type) 242 { 243 struct rb_node *nd; 244 for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) { 245 struct map *map = rb_entry(nd, struct map, rb_node); 246 struct map *new = map__clone(map); 247 if (new == NULL) 248 return -ENOMEM; 249 map_groups__insert(self, new); 250 } 251 return 0; 252 } 253 254 int thread__fork(struct thread *self, struct thread *parent) 255 { 256 int i; 257 258 if (self->comm) 259 free(self->comm); 260 self->comm = strdup(parent->comm); 261 if (!self->comm) 262 return -ENOMEM; 263 264 for (i = 0; i < MAP__NR_TYPES; ++i) 265 if (map_groups__clone(&self->mg, &parent->mg, i) < 0) 266 return -ENOMEM; 267 return 0; 268 } 269 270 size_t perf_session__fprintf(struct perf_session *self, FILE *fp) 271 { 272 size_t ret = 0; 273 struct rb_node *nd; 274 275 for (nd = rb_first(&self->threads); nd; nd = rb_next(nd)) { 276 struct thread *pos = rb_entry(nd, struct thread, rb_node); 277 278 ret += thread__fprintf(pos, fp); 279 } 280 281 return ret; 282 } 283 284 struct symbol *map_groups__find_symbol(struct map_groups *self, 285 struct perf_session *session, 286 enum map_type type, u64 addr, 287 symbol_filter_t filter) 288 { 289 struct map *map = map_groups__find(self, type, addr); 290 291 if (map != NULL) 292 return map__find_symbol(map, session, map->map_ip(map, addr), filter); 293 294 return NULL; 295 } 296