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 thread__put(thread); 47 return 0; 48 } 49 50 static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused, 51 union perf_event *event, 52 struct perf_sample *sample 53 __maybe_unused, 54 struct machine *machine) 55 { 56 struct thread *thread = machine__findnew_thread(machine, 57 event->fork.pid, 58 event->fork.tid); 59 60 dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid, 61 event->fork.ppid, event->fork.ptid); 62 63 if (thread) { 64 machine__remove_thread(machine, thread); 65 thread__put(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 .ordered_events = true, 80 }; 81 82 int build_id__sprintf(const u8 *build_id, int len, char *bf) 83 { 84 char *bid = bf; 85 const u8 *raw = build_id; 86 int i; 87 88 for (i = 0; i < len; ++i) { 89 sprintf(bid, "%02x", *raw); 90 ++raw; 91 bid += 2; 92 } 93 94 return raw - build_id; 95 } 96 97 int sysfs__sprintf_build_id(const char *root_dir, char *sbuild_id) 98 { 99 char notes[PATH_MAX]; 100 u8 build_id[BUILD_ID_SIZE]; 101 int ret; 102 103 if (!root_dir) 104 root_dir = ""; 105 106 scnprintf(notes, sizeof(notes), "%s/sys/kernel/notes", root_dir); 107 108 ret = sysfs__read_build_id(notes, build_id, sizeof(build_id)); 109 if (ret < 0) 110 return ret; 111 112 return build_id__sprintf(build_id, sizeof(build_id), sbuild_id); 113 } 114 115 int filename__sprintf_build_id(const char *pathname, char *sbuild_id) 116 { 117 u8 build_id[BUILD_ID_SIZE]; 118 int ret; 119 120 ret = filename__read_build_id(pathname, build_id, sizeof(build_id)); 121 if (ret < 0) 122 return ret; 123 else if (ret != sizeof(build_id)) 124 return -EINVAL; 125 126 return build_id__sprintf(build_id, sizeof(build_id), sbuild_id); 127 } 128 129 /* asnprintf consolidates asprintf and snprintf */ 130 static int asnprintf(char **strp, size_t size, const char *fmt, ...) 131 { 132 va_list ap; 133 int ret; 134 135 if (!strp) 136 return -EINVAL; 137 138 va_start(ap, fmt); 139 if (*strp) 140 ret = vsnprintf(*strp, size, fmt, ap); 141 else 142 ret = vasprintf(strp, fmt, ap); 143 va_end(ap); 144 145 return ret; 146 } 147 148 static char *build_id__filename(const char *sbuild_id, char *bf, size_t size) 149 { 150 char *tmp = bf; 151 int ret = asnprintf(&bf, size, "%s/.build-id/%.2s/%s", buildid_dir, 152 sbuild_id, sbuild_id + 2); 153 if (ret < 0 || (tmp && size < (unsigned int)ret)) 154 return NULL; 155 return bf; 156 } 157 158 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size) 159 { 160 char build_id_hex[SBUILD_ID_SIZE]; 161 162 if (!dso->has_build_id) 163 return NULL; 164 165 build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex); 166 return build_id__filename(build_id_hex, bf, size); 167 } 168 169 #define dsos__for_each_with_build_id(pos, head) \ 170 list_for_each_entry(pos, head, node) \ 171 if (!pos->has_build_id) \ 172 continue; \ 173 else 174 175 static int write_buildid(const char *name, size_t name_len, u8 *build_id, 176 pid_t pid, u16 misc, int fd) 177 { 178 int err; 179 struct build_id_event b; 180 size_t len; 181 182 len = name_len + 1; 183 len = PERF_ALIGN(len, NAME_ALIGN); 184 185 memset(&b, 0, sizeof(b)); 186 memcpy(&b.build_id, build_id, BUILD_ID_SIZE); 187 b.pid = pid; 188 b.header.misc = misc; 189 b.header.size = sizeof(b) + len; 190 191 err = writen(fd, &b, sizeof(b)); 192 if (err < 0) 193 return err; 194 195 return write_padded(fd, name, name_len + 1, len); 196 } 197 198 static int machine__write_buildid_table(struct machine *machine, int fd) 199 { 200 int err = 0; 201 char nm[PATH_MAX]; 202 struct dso *pos; 203 u16 kmisc = PERF_RECORD_MISC_KERNEL, 204 umisc = PERF_RECORD_MISC_USER; 205 206 if (!machine__is_host(machine)) { 207 kmisc = PERF_RECORD_MISC_GUEST_KERNEL; 208 umisc = PERF_RECORD_MISC_GUEST_USER; 209 } 210 211 dsos__for_each_with_build_id(pos, &machine->dsos.head) { 212 const char *name; 213 size_t name_len; 214 215 if (!pos->hit) 216 continue; 217 218 if (dso__is_vdso(pos)) { 219 name = pos->short_name; 220 name_len = pos->short_name_len + 1; 221 } else if (dso__is_kcore(pos)) { 222 machine__mmap_name(machine, nm, sizeof(nm)); 223 name = nm; 224 name_len = strlen(nm) + 1; 225 } else { 226 name = pos->long_name; 227 name_len = pos->long_name_len + 1; 228 } 229 230 err = write_buildid(name, name_len, pos->build_id, machine->pid, 231 pos->kernel ? kmisc : umisc, fd); 232 if (err) 233 break; 234 } 235 236 return err; 237 } 238 239 int perf_session__write_buildid_table(struct perf_session *session, int fd) 240 { 241 struct rb_node *nd; 242 int err = machine__write_buildid_table(&session->machines.host, fd); 243 244 if (err) 245 return err; 246 247 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 248 struct machine *pos = rb_entry(nd, struct machine, rb_node); 249 err = machine__write_buildid_table(pos, fd); 250 if (err) 251 break; 252 } 253 return err; 254 } 255 256 static int __dsos__hit_all(struct list_head *head) 257 { 258 struct dso *pos; 259 260 list_for_each_entry(pos, head, node) 261 pos->hit = true; 262 263 return 0; 264 } 265 266 static int machine__hit_all_dsos(struct machine *machine) 267 { 268 return __dsos__hit_all(&machine->dsos.head); 269 } 270 271 int dsos__hit_all(struct perf_session *session) 272 { 273 struct rb_node *nd; 274 int err; 275 276 err = machine__hit_all_dsos(&session->machines.host); 277 if (err) 278 return err; 279 280 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 281 struct machine *pos = rb_entry(nd, struct machine, rb_node); 282 283 err = machine__hit_all_dsos(pos); 284 if (err) 285 return err; 286 } 287 288 return 0; 289 } 290 291 void disable_buildid_cache(void) 292 { 293 no_buildid_cache = true; 294 } 295 296 static char *build_id_cache__dirname_from_path(const char *name, 297 bool is_kallsyms, bool is_vdso) 298 { 299 char *realname = (char *)name, *filename; 300 bool slash = is_kallsyms || is_vdso; 301 302 if (!slash) { 303 realname = realpath(name, NULL); 304 if (!realname) 305 return NULL; 306 } 307 308 if (asprintf(&filename, "%s%s%s", buildid_dir, slash ? "/" : "", 309 is_vdso ? DSO__NAME_VDSO : realname) < 0) 310 filename = NULL; 311 312 if (!slash) 313 free(realname); 314 315 return filename; 316 } 317 318 int build_id_cache__list_build_ids(const char *pathname, 319 struct strlist **result) 320 { 321 struct strlist *list; 322 char *dir_name; 323 DIR *dir; 324 struct dirent *d; 325 int ret = 0; 326 327 list = strlist__new(NULL, NULL); 328 dir_name = build_id_cache__dirname_from_path(pathname, false, false); 329 if (!list || !dir_name) { 330 ret = -ENOMEM; 331 goto out; 332 } 333 334 /* List up all dirents */ 335 dir = opendir(dir_name); 336 if (!dir) { 337 ret = -errno; 338 goto out; 339 } 340 341 while ((d = readdir(dir)) != NULL) { 342 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) 343 continue; 344 strlist__add(list, d->d_name); 345 } 346 closedir(dir); 347 348 out: 349 free(dir_name); 350 if (ret) 351 strlist__delete(list); 352 else 353 *result = list; 354 355 return ret; 356 } 357 358 int build_id_cache__add_s(const char *sbuild_id, const char *name, 359 bool is_kallsyms, bool is_vdso) 360 { 361 const size_t size = PATH_MAX; 362 char *realname = NULL, *filename = NULL, *dir_name = NULL, 363 *linkname = zalloc(size), *targetname, *tmp; 364 int err = -1; 365 366 if (!is_kallsyms) { 367 realname = realpath(name, NULL); 368 if (!realname) 369 goto out_free; 370 } 371 372 dir_name = build_id_cache__dirname_from_path(name, is_kallsyms, is_vdso); 373 if (!dir_name) 374 goto out_free; 375 376 if (mkdir_p(dir_name, 0755)) 377 goto out_free; 378 379 if (asprintf(&filename, "%s/%s", dir_name, sbuild_id) < 0) { 380 filename = NULL; 381 goto out_free; 382 } 383 384 if (access(filename, F_OK)) { 385 if (is_kallsyms) { 386 if (copyfile("/proc/kallsyms", filename)) 387 goto out_free; 388 } else if (link(realname, filename) && errno != EEXIST && 389 copyfile(name, filename)) 390 goto out_free; 391 } 392 393 if (!build_id__filename(sbuild_id, linkname, size)) 394 goto out_free; 395 tmp = strrchr(linkname, '/'); 396 *tmp = '\0'; 397 398 if (access(linkname, X_OK) && mkdir_p(linkname, 0755)) 399 goto out_free; 400 401 *tmp = '/'; 402 targetname = filename + strlen(buildid_dir) - 5; 403 memcpy(targetname, "../..", 5); 404 405 if (symlink(targetname, linkname) == 0) 406 err = 0; 407 out_free: 408 if (!is_kallsyms) 409 free(realname); 410 free(filename); 411 free(dir_name); 412 free(linkname); 413 return err; 414 } 415 416 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size, 417 const char *name, bool is_kallsyms, 418 bool is_vdso) 419 { 420 char sbuild_id[SBUILD_ID_SIZE]; 421 422 build_id__sprintf(build_id, build_id_size, sbuild_id); 423 424 return build_id_cache__add_s(sbuild_id, name, is_kallsyms, is_vdso); 425 } 426 427 bool build_id_cache__cached(const char *sbuild_id) 428 { 429 bool ret = false; 430 char *filename = build_id__filename(sbuild_id, NULL, 0); 431 432 if (filename && !access(filename, F_OK)) 433 ret = true; 434 free(filename); 435 436 return ret; 437 } 438 439 int build_id_cache__remove_s(const char *sbuild_id) 440 { 441 const size_t size = PATH_MAX; 442 char *filename = zalloc(size), 443 *linkname = zalloc(size), *tmp; 444 int err = -1; 445 446 if (filename == NULL || linkname == NULL) 447 goto out_free; 448 449 if (!build_id__filename(sbuild_id, linkname, size)) 450 goto out_free; 451 452 if (access(linkname, F_OK)) 453 goto out_free; 454 455 if (readlink(linkname, filename, size - 1) < 0) 456 goto out_free; 457 458 if (unlink(linkname)) 459 goto out_free; 460 461 /* 462 * Since the link is relative, we must make it absolute: 463 */ 464 tmp = strrchr(linkname, '/') + 1; 465 snprintf(tmp, size - (tmp - linkname), "%s", filename); 466 467 if (unlink(linkname)) 468 goto out_free; 469 470 err = 0; 471 out_free: 472 free(filename); 473 free(linkname); 474 return err; 475 } 476 477 static int dso__cache_build_id(struct dso *dso, struct machine *machine) 478 { 479 bool is_kallsyms = dso->kernel && dso->long_name[0] != '/'; 480 bool is_vdso = dso__is_vdso(dso); 481 const char *name = dso->long_name; 482 char nm[PATH_MAX]; 483 484 if (dso__is_kcore(dso)) { 485 is_kallsyms = true; 486 machine__mmap_name(machine, nm, sizeof(nm)); 487 name = nm; 488 } 489 return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name, 490 is_kallsyms, is_vdso); 491 } 492 493 static int __dsos__cache_build_ids(struct list_head *head, 494 struct machine *machine) 495 { 496 struct dso *pos; 497 int err = 0; 498 499 dsos__for_each_with_build_id(pos, head) 500 if (dso__cache_build_id(pos, machine)) 501 err = -1; 502 503 return err; 504 } 505 506 static int machine__cache_build_ids(struct machine *machine) 507 { 508 return __dsos__cache_build_ids(&machine->dsos.head, machine); 509 } 510 511 int perf_session__cache_build_ids(struct perf_session *session) 512 { 513 struct rb_node *nd; 514 int ret; 515 516 if (no_buildid_cache) 517 return 0; 518 519 if (mkdir(buildid_dir, 0755) != 0 && errno != EEXIST) 520 return -1; 521 522 ret = machine__cache_build_ids(&session->machines.host); 523 524 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 525 struct machine *pos = rb_entry(nd, struct machine, rb_node); 526 ret |= machine__cache_build_ids(pos); 527 } 528 return ret ? -1 : 0; 529 } 530 531 static bool machine__read_build_ids(struct machine *machine, bool with_hits) 532 { 533 return __dsos__read_build_ids(&machine->dsos.head, with_hits); 534 } 535 536 bool perf_session__read_build_ids(struct perf_session *session, bool with_hits) 537 { 538 struct rb_node *nd; 539 bool ret = machine__read_build_ids(&session->machines.host, with_hits); 540 541 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 542 struct machine *pos = rb_entry(nd, struct machine, rb_node); 543 ret |= machine__read_build_ids(pos, with_hits); 544 } 545 546 return ret; 547 } 548