1 /* 2 * build-id.c 3 * 4 * build-id support 5 * 6 * Copyright (C) 2009, 2010 Red Hat Inc. 7 * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com> 8 */ 9 #include "util.h" 10 #include <stdio.h> 11 #include "build-id.h" 12 #include "event.h" 13 #include "symbol.h" 14 #include <linux/kernel.h> 15 #include "debug.h" 16 #include "session.h" 17 #include "tool.h" 18 #include "header.h" 19 #include "vdso.h" 20 21 22 static bool no_buildid_cache; 23 24 int build_id__mark_dso_hit(struct perf_tool *tool __maybe_unused, 25 union perf_event *event, 26 struct perf_sample *sample, 27 struct perf_evsel *evsel __maybe_unused, 28 struct machine *machine) 29 { 30 struct addr_location al; 31 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 32 struct thread *thread = machine__findnew_thread(machine, sample->pid, 33 sample->tid); 34 35 if (thread == NULL) { 36 pr_err("problem processing %d event, skipping it.\n", 37 event->header.type); 38 return -1; 39 } 40 41 thread__find_addr_map(thread, cpumode, MAP__FUNCTION, sample->ip, &al); 42 43 if (al.map != NULL) 44 al.map->dso->hit = 1; 45 46 return 0; 47 } 48 49 static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused, 50 union perf_event *event, 51 struct perf_sample *sample 52 __maybe_unused, 53 struct machine *machine) 54 { 55 struct thread *thread = machine__findnew_thread(machine, 56 event->fork.pid, 57 event->fork.tid); 58 59 dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid, 60 event->fork.ppid, event->fork.ptid); 61 62 if (thread) { 63 rb_erase(&thread->rb_node, &machine->threads); 64 machine->last_match = NULL; 65 thread__delete(thread); 66 } 67 68 return 0; 69 } 70 71 struct perf_tool build_id__mark_dso_hit_ops = { 72 .sample = build_id__mark_dso_hit, 73 .mmap = perf_event__process_mmap, 74 .mmap2 = perf_event__process_mmap2, 75 .fork = perf_event__process_fork, 76 .exit = perf_event__exit_del_thread, 77 .attr = perf_event__process_attr, 78 .build_id = perf_event__process_build_id, 79 }; 80 81 int build_id__sprintf(const u8 *build_id, int len, char *bf) 82 { 83 char *bid = bf; 84 const u8 *raw = build_id; 85 int i; 86 87 for (i = 0; i < len; ++i) { 88 sprintf(bid, "%02x", *raw); 89 ++raw; 90 bid += 2; 91 } 92 93 return raw - build_id; 94 } 95 96 /* asnprintf consolidates asprintf and snprintf */ 97 static int asnprintf(char **strp, size_t size, const char *fmt, ...) 98 { 99 va_list ap; 100 int ret; 101 102 if (!strp) 103 return -EINVAL; 104 105 va_start(ap, fmt); 106 if (*strp) 107 ret = vsnprintf(*strp, size, fmt, ap); 108 else 109 ret = vasprintf(strp, fmt, ap); 110 va_end(ap); 111 112 return ret; 113 } 114 115 static char *build_id__filename(const char *sbuild_id, char *bf, size_t size) 116 { 117 char *tmp = bf; 118 int ret = asnprintf(&bf, size, "%s/.build-id/%.2s/%s", buildid_dir, 119 sbuild_id, sbuild_id + 2); 120 if (ret < 0 || (tmp && size < (unsigned int)ret)) 121 return NULL; 122 return bf; 123 } 124 125 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size) 126 { 127 char build_id_hex[BUILD_ID_SIZE * 2 + 1]; 128 129 if (!dso->has_build_id) 130 return NULL; 131 132 build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex); 133 return build_id__filename(build_id_hex, bf, size); 134 } 135 136 #define dsos__for_each_with_build_id(pos, head) \ 137 list_for_each_entry(pos, head, node) \ 138 if (!pos->has_build_id) \ 139 continue; \ 140 else 141 142 static int write_buildid(const char *name, size_t name_len, u8 *build_id, 143 pid_t pid, u16 misc, int fd) 144 { 145 int err; 146 struct build_id_event b; 147 size_t len; 148 149 len = name_len + 1; 150 len = PERF_ALIGN(len, NAME_ALIGN); 151 152 memset(&b, 0, sizeof(b)); 153 memcpy(&b.build_id, build_id, BUILD_ID_SIZE); 154 b.pid = pid; 155 b.header.misc = misc; 156 b.header.size = sizeof(b) + len; 157 158 err = writen(fd, &b, sizeof(b)); 159 if (err < 0) 160 return err; 161 162 return write_padded(fd, name, name_len + 1, len); 163 } 164 165 static int __dsos__write_buildid_table(struct list_head *head, 166 struct machine *machine, 167 pid_t pid, u16 misc, int fd) 168 { 169 char nm[PATH_MAX]; 170 struct dso *pos; 171 172 dsos__for_each_with_build_id(pos, head) { 173 int err; 174 const char *name; 175 size_t name_len; 176 177 if (!pos->hit) 178 continue; 179 180 if (dso__is_vdso(pos)) { 181 name = pos->short_name; 182 name_len = pos->short_name_len + 1; 183 } else if (dso__is_kcore(pos)) { 184 machine__mmap_name(machine, nm, sizeof(nm)); 185 name = nm; 186 name_len = strlen(nm) + 1; 187 } else { 188 name = pos->long_name; 189 name_len = pos->long_name_len + 1; 190 } 191 192 err = write_buildid(name, name_len, pos->build_id, 193 pid, misc, fd); 194 if (err) 195 return err; 196 } 197 198 return 0; 199 } 200 201 static int machine__write_buildid_table(struct machine *machine, int fd) 202 { 203 int err; 204 u16 kmisc = PERF_RECORD_MISC_KERNEL, 205 umisc = PERF_RECORD_MISC_USER; 206 207 if (!machine__is_host(machine)) { 208 kmisc = PERF_RECORD_MISC_GUEST_KERNEL; 209 umisc = PERF_RECORD_MISC_GUEST_USER; 210 } 211 212 err = __dsos__write_buildid_table(&machine->kernel_dsos.head, machine, 213 machine->pid, kmisc, fd); 214 if (err == 0) 215 err = __dsos__write_buildid_table(&machine->user_dsos.head, 216 machine, machine->pid, umisc, 217 fd); 218 return err; 219 } 220 221 int perf_session__write_buildid_table(struct perf_session *session, int fd) 222 { 223 struct rb_node *nd; 224 int err = machine__write_buildid_table(&session->machines.host, fd); 225 226 if (err) 227 return err; 228 229 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 230 struct machine *pos = rb_entry(nd, struct machine, rb_node); 231 err = machine__write_buildid_table(pos, fd); 232 if (err) 233 break; 234 } 235 return err; 236 } 237 238 static int __dsos__hit_all(struct list_head *head) 239 { 240 struct dso *pos; 241 242 list_for_each_entry(pos, head, node) 243 pos->hit = true; 244 245 return 0; 246 } 247 248 static int machine__hit_all_dsos(struct machine *machine) 249 { 250 int err; 251 252 err = __dsos__hit_all(&machine->kernel_dsos.head); 253 if (err) 254 return err; 255 256 return __dsos__hit_all(&machine->user_dsos.head); 257 } 258 259 int dsos__hit_all(struct perf_session *session) 260 { 261 struct rb_node *nd; 262 int err; 263 264 err = machine__hit_all_dsos(&session->machines.host); 265 if (err) 266 return err; 267 268 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 269 struct machine *pos = rb_entry(nd, struct machine, rb_node); 270 271 err = machine__hit_all_dsos(pos); 272 if (err) 273 return err; 274 } 275 276 return 0; 277 } 278 279 void disable_buildid_cache(void) 280 { 281 no_buildid_cache = true; 282 } 283 284 int build_id_cache__add_s(const char *sbuild_id, const char *name, 285 bool is_kallsyms, bool is_vdso) 286 { 287 const size_t size = PATH_MAX; 288 char *realname, *filename = zalloc(size), 289 *linkname = zalloc(size), *targetname, *tmp; 290 int len, err = -1; 291 bool slash = is_kallsyms || is_vdso; 292 293 if (is_kallsyms) { 294 if (symbol_conf.kptr_restrict) { 295 pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n"); 296 err = 0; 297 goto out_free; 298 } 299 realname = (char *) name; 300 } else 301 realname = realpath(name, NULL); 302 303 if (realname == NULL || filename == NULL || linkname == NULL) 304 goto out_free; 305 306 len = scnprintf(filename, size, "%s%s%s", 307 buildid_dir, slash ? "/" : "", 308 is_vdso ? DSO__NAME_VDSO : realname); 309 if (mkdir_p(filename, 0755)) 310 goto out_free; 311 312 snprintf(filename + len, size - len, "/%s", sbuild_id); 313 314 if (access(filename, F_OK)) { 315 if (is_kallsyms) { 316 if (copyfile("/proc/kallsyms", filename)) 317 goto out_free; 318 } else if (link(realname, filename) && copyfile(name, filename)) 319 goto out_free; 320 } 321 322 if (!build_id__filename(sbuild_id, linkname, size)) 323 goto out_free; 324 tmp = strrchr(linkname, '/'); 325 *tmp = '\0'; 326 327 if (access(linkname, X_OK) && mkdir_p(linkname, 0755)) 328 goto out_free; 329 330 *tmp = '/'; 331 targetname = filename + strlen(buildid_dir) - 5; 332 memcpy(targetname, "../..", 5); 333 334 if (symlink(targetname, linkname) == 0) 335 err = 0; 336 out_free: 337 if (!is_kallsyms) 338 free(realname); 339 free(filename); 340 free(linkname); 341 return err; 342 } 343 344 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size, 345 const char *name, bool is_kallsyms, 346 bool is_vdso) 347 { 348 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 349 350 build_id__sprintf(build_id, build_id_size, sbuild_id); 351 352 return build_id_cache__add_s(sbuild_id, name, is_kallsyms, is_vdso); 353 } 354 355 int build_id_cache__remove_s(const char *sbuild_id) 356 { 357 const size_t size = PATH_MAX; 358 char *filename = zalloc(size), 359 *linkname = zalloc(size), *tmp; 360 int err = -1; 361 362 if (filename == NULL || linkname == NULL) 363 goto out_free; 364 365 if (!build_id__filename(sbuild_id, linkname, size)) 366 goto out_free; 367 368 if (access(linkname, F_OK)) 369 goto out_free; 370 371 if (readlink(linkname, filename, size - 1) < 0) 372 goto out_free; 373 374 if (unlink(linkname)) 375 goto out_free; 376 377 /* 378 * Since the link is relative, we must make it absolute: 379 */ 380 tmp = strrchr(linkname, '/') + 1; 381 snprintf(tmp, size - (tmp - linkname), "%s", filename); 382 383 if (unlink(linkname)) 384 goto out_free; 385 386 err = 0; 387 out_free: 388 free(filename); 389 free(linkname); 390 return err; 391 } 392 393 static int dso__cache_build_id(struct dso *dso, struct machine *machine) 394 { 395 bool is_kallsyms = dso->kernel && dso->long_name[0] != '/'; 396 bool is_vdso = dso__is_vdso(dso); 397 const char *name = dso->long_name; 398 char nm[PATH_MAX]; 399 400 if (dso__is_kcore(dso)) { 401 is_kallsyms = true; 402 machine__mmap_name(machine, nm, sizeof(nm)); 403 name = nm; 404 } 405 return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name, 406 is_kallsyms, is_vdso); 407 } 408 409 static int __dsos__cache_build_ids(struct list_head *head, 410 struct machine *machine) 411 { 412 struct dso *pos; 413 int err = 0; 414 415 dsos__for_each_with_build_id(pos, head) 416 if (dso__cache_build_id(pos, machine)) 417 err = -1; 418 419 return err; 420 } 421 422 static int machine__cache_build_ids(struct machine *machine) 423 { 424 int ret = __dsos__cache_build_ids(&machine->kernel_dsos.head, machine); 425 ret |= __dsos__cache_build_ids(&machine->user_dsos.head, machine); 426 return ret; 427 } 428 429 int perf_session__cache_build_ids(struct perf_session *session) 430 { 431 struct rb_node *nd; 432 int ret; 433 434 if (no_buildid_cache) 435 return 0; 436 437 if (mkdir(buildid_dir, 0755) != 0 && errno != EEXIST) 438 return -1; 439 440 ret = machine__cache_build_ids(&session->machines.host); 441 442 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 443 struct machine *pos = rb_entry(nd, struct machine, rb_node); 444 ret |= machine__cache_build_ids(pos); 445 } 446 return ret ? -1 : 0; 447 } 448 449 static bool machine__read_build_ids(struct machine *machine, bool with_hits) 450 { 451 bool ret; 452 453 ret = __dsos__read_build_ids(&machine->kernel_dsos.head, with_hits); 454 ret |= __dsos__read_build_ids(&machine->user_dsos.head, with_hits); 455 return ret; 456 } 457 458 bool perf_session__read_build_ids(struct perf_session *session, bool with_hits) 459 { 460 struct rb_node *nd; 461 bool ret = machine__read_build_ids(&session->machines.host, with_hits); 462 463 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 464 struct machine *pos = rb_entry(nd, struct machine, rb_node); 465 ret |= machine__read_build_ids(pos, with_hits); 466 } 467 468 return ret; 469 } 470