1 /*- 2 * Copyright (c) 2010 The FreeBSD Foundation 3 * Copyright (c) 2008 John Birrell (jb@freebsd.org) 4 * All rights reserved. 5 * 6 * Portions of this software were developed by Rui Paulo under sponsorship 7 * from the FreeBSD Foundation. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/types.h> 35 #ifndef NO_CTF 36 #include <sys/ctf.h> 37 #include <sys/ctf_api.h> 38 #endif 39 #include <sys/user.h> 40 41 #include <assert.h> 42 #include <err.h> 43 #include <fcntl.h> 44 #include <libgen.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 #ifndef NO_CTF 50 #include <libctf.h> 51 #endif 52 #include <libutil.h> 53 54 #include "_libproc.h" 55 56 #ifdef NO_CTF 57 typedef struct ctf_file ctf_file_t; 58 #endif 59 60 #ifndef NO_CXA_DEMANGLE 61 extern char *__cxa_demangle(const char *, char *, size_t *, int *); 62 #endif /* NO_CXA_DEMANGLE */ 63 64 static void proc_rdl2prmap(rd_loadobj_t *, prmap_t *); 65 66 static void 67 demangle(const char *symbol, char *buf, size_t len) 68 { 69 #ifndef NO_CXA_DEMANGLE 70 char *dembuf; 71 72 if (symbol[0] == '_' && symbol[1] == 'Z' && symbol[2]) { 73 dembuf = __cxa_demangle(symbol, NULL, NULL, NULL); 74 if (!dembuf) 75 goto fail; 76 strlcpy(buf, dembuf, len); 77 free(dembuf); 78 return; 79 } 80 fail: 81 #endif /* NO_CXA_DEMANGLE */ 82 strlcpy(buf, symbol, len); 83 } 84 85 static void 86 proc_rdl2prmap(rd_loadobj_t *rdl, prmap_t *map) 87 { 88 map->pr_vaddr = rdl->rdl_saddr; 89 map->pr_size = rdl->rdl_eaddr - rdl->rdl_saddr; 90 map->pr_offset = rdl->rdl_offset; 91 map->pr_mflags = 0; 92 if (rdl->rdl_prot & RD_RDL_R) 93 map->pr_mflags |= MA_READ; 94 if (rdl->rdl_prot & RD_RDL_W) 95 map->pr_mflags |= MA_WRITE; 96 if (rdl->rdl_prot & RD_RDL_X) 97 map->pr_mflags |= MA_EXEC; 98 strlcpy(map->pr_mapname, rdl->rdl_path, 99 sizeof(map->pr_mapname)); 100 } 101 102 char * 103 proc_objname(struct proc_handle *p, uintptr_t addr, char *objname, 104 size_t objnamesz) 105 { 106 size_t i; 107 rd_loadobj_t *rdl; 108 109 for (i = 0; i < p->nobjs; i++) { 110 rdl = &p->rdobjs[i]; 111 if (addr >= rdl->rdl_saddr && addr < rdl->rdl_eaddr) { 112 strlcpy(objname, rdl->rdl_path, objnamesz); 113 return (objname); 114 } 115 } 116 return (NULL); 117 } 118 119 prmap_t * 120 proc_obj2map(struct proc_handle *p, const char *objname) 121 { 122 size_t i; 123 prmap_t *map; 124 rd_loadobj_t *rdl; 125 char path[MAXPATHLEN]; 126 127 rdl = NULL; 128 for (i = 0; i < p->nobjs; i++) { 129 basename_r(p->rdobjs[i].rdl_path, path); 130 if (strcmp(path, objname) == 0) { 131 rdl = &p->rdobjs[i]; 132 break; 133 } 134 } 135 if (rdl == NULL) { 136 if (strcmp(objname, "a.out") == 0 && p->rdexec != NULL) 137 rdl = p->rdexec; 138 else 139 return (NULL); 140 } 141 142 if ((map = malloc(sizeof(*map))) == NULL) 143 return (NULL); 144 proc_rdl2prmap(rdl, map); 145 return (map); 146 } 147 148 int 149 proc_iter_objs(struct proc_handle *p, proc_map_f *func, void *cd) 150 { 151 size_t i; 152 rd_loadobj_t *rdl; 153 prmap_t map; 154 char path[MAXPATHLEN]; 155 char last[MAXPATHLEN]; 156 int error; 157 158 if (p->nobjs == 0) 159 return (-1); 160 161 error = 0; 162 memset(last, 0, sizeof(last)); 163 for (i = 0; i < p->nobjs; i++) { 164 rdl = &p->rdobjs[i]; 165 proc_rdl2prmap(rdl, &map); 166 basename_r(rdl->rdl_path, path); 167 /* 168 * We shouldn't call the callback twice with the same object. 169 * To do that we are assuming the fact that if there are 170 * repeated object names (i.e. different mappings for the 171 * same object) they occur next to each other. 172 */ 173 if (strcmp(path, last) == 0) 174 continue; 175 if ((error = (*func)(cd, &map, path)) != 0) 176 break; 177 strlcpy(last, path, sizeof(last)); 178 } 179 return (error); 180 } 181 182 prmap_t * 183 proc_addr2map(struct proc_handle *p, uintptr_t addr) 184 { 185 size_t i; 186 int cnt, lastvn = 0; 187 prmap_t *map; 188 rd_loadobj_t *rdl; 189 struct kinfo_vmentry *kves, *kve; 190 191 /* 192 * If we don't have a cache of listed objects, we need to query 193 * it ourselves. 194 */ 195 if (p->nobjs == 0) { 196 if ((kves = kinfo_getvmmap(p->pid, &cnt)) == NULL) 197 return (NULL); 198 for (i = 0; i < (size_t)cnt; i++) { 199 kve = kves + i; 200 if (kve->kve_type == KVME_TYPE_VNODE) 201 lastvn = i; 202 if (addr >= kve->kve_start && addr < kve->kve_end) { 203 if ((map = malloc(sizeof(*map))) == NULL) { 204 free(kves); 205 return (NULL); 206 } 207 map->pr_vaddr = kve->kve_start; 208 map->pr_size = kve->kve_end - kve->kve_start; 209 map->pr_offset = kve->kve_offset; 210 map->pr_mflags = 0; 211 if (kve->kve_protection & KVME_PROT_READ) 212 map->pr_mflags |= MA_READ; 213 if (kve->kve_protection & KVME_PROT_WRITE) 214 map->pr_mflags |= MA_WRITE; 215 if (kve->kve_protection & KVME_PROT_EXEC) 216 map->pr_mflags |= MA_EXEC; 217 if (kve->kve_flags & KVME_FLAG_COW) 218 map->pr_mflags |= MA_COW; 219 if (kve->kve_flags & KVME_FLAG_NEEDS_COPY) 220 map->pr_mflags |= MA_NEEDS_COPY; 221 if (kve->kve_flags & KVME_FLAG_NOCOREDUMP) 222 map->pr_mflags |= MA_NOCOREDUMP; 223 strlcpy(map->pr_mapname, kves[lastvn].kve_path, 224 sizeof(map->pr_mapname)); 225 free(kves); 226 return (map); 227 } 228 } 229 free(kves); 230 return (NULL); 231 } 232 233 for (i = 0; i < p->nobjs; i++) { 234 rdl = &p->rdobjs[i]; 235 if (addr >= rdl->rdl_saddr && addr < rdl->rdl_eaddr) { 236 if ((map = malloc(sizeof(*map))) == NULL) 237 return (NULL); 238 proc_rdl2prmap(rdl, map); 239 return (map); 240 } 241 } 242 return (NULL); 243 } 244 245 /* 246 * Look up the symbol at addr, returning a copy of the symbol and its name. 247 */ 248 static int 249 lookup_addr(Elf *e, Elf_Scn *scn, u_long stridx, uintptr_t off, uintptr_t addr, 250 const char **name, GElf_Sym *symcopy) 251 { 252 GElf_Sym sym; 253 Elf_Data *data; 254 const char *s; 255 uint64_t rsym; 256 int i; 257 258 if ((data = elf_getdata(scn, NULL)) == NULL) { 259 DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1)); 260 return (1); 261 } 262 for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { 263 rsym = off + sym.st_value; 264 if (addr >= rsym && addr < rsym + sym.st_size) { 265 s = elf_strptr(e, stridx, sym.st_name); 266 if (s != NULL) { 267 *name = s; 268 memcpy(symcopy, &sym, sizeof(*symcopy)); 269 /* 270 * DTrace expects the st_value to contain 271 * only the address relative to the start of 272 * the function. 273 */ 274 symcopy->st_value = rsym; 275 return (0); 276 } 277 } 278 } 279 return (1); 280 } 281 282 int 283 proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name, 284 size_t namesz, GElf_Sym *symcopy) 285 { 286 GElf_Ehdr ehdr; 287 GElf_Shdr shdr; 288 Elf *e; 289 Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL; 290 prmap_t *map; 291 const char *s; 292 uintptr_t off; 293 u_long symtabstridx = 0, dynsymstridx = 0; 294 int fd, error = -1; 295 296 if ((map = proc_addr2map(p, addr)) == NULL) 297 return (-1); 298 if ((fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) { 299 DPRINTF("ERROR: open %s failed", map->pr_mapname); 300 goto err0; 301 } 302 if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 303 DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1)); 304 goto err1; 305 } 306 if (gelf_getehdr(e, &ehdr) == NULL) { 307 DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1)); 308 goto err2; 309 } 310 311 /* 312 * Find the index of the STRTAB and SYMTAB sections to locate 313 * symbol names. 314 */ 315 scn = NULL; 316 while ((scn = elf_nextscn(e, scn)) != NULL) { 317 gelf_getshdr(scn, &shdr); 318 switch (shdr.sh_type) { 319 case SHT_SYMTAB: 320 symtabscn = scn; 321 symtabstridx = shdr.sh_link; 322 break; 323 case SHT_DYNSYM: 324 dynsymscn = scn; 325 dynsymstridx = shdr.sh_link; 326 break; 327 } 328 } 329 330 off = ehdr.e_type == ET_EXEC ? 0 : map->pr_vaddr; 331 332 /* 333 * First look up the symbol in the dynsymtab, and fall back to the 334 * symtab if the lookup fails. 335 */ 336 error = lookup_addr(e, dynsymscn, dynsymstridx, off, addr, &s, symcopy); 337 if (error == 0) 338 goto out; 339 340 error = lookup_addr(e, symtabscn, symtabstridx, off, addr, &s, symcopy); 341 if (error != 0) 342 goto err2; 343 344 out: 345 demangle(s, name, namesz); 346 err2: 347 elf_end(e); 348 err1: 349 close(fd); 350 err0: 351 free(map); 352 return (error); 353 } 354 355 prmap_t * 356 proc_name2map(struct proc_handle *p, const char *name) 357 { 358 size_t i; 359 int cnt; 360 prmap_t *map = NULL; 361 char tmppath[MAXPATHLEN]; 362 struct kinfo_vmentry *kves, *kve; 363 rd_loadobj_t *rdl; 364 365 /* 366 * If we haven't iterated over the list of loaded objects, 367 * librtld_db isn't yet initialized and it's very likely 368 * that librtld_db called us. We need to do the heavy 369 * lifting here to find the symbol librtld_db is looking for. 370 */ 371 if (p->nobjs == 0) { 372 if ((kves = kinfo_getvmmap(proc_getpid(p), &cnt)) == NULL) 373 return (NULL); 374 for (i = 0; i < (size_t)cnt; i++) { 375 kve = kves + i; 376 basename_r(kve->kve_path, tmppath); 377 if (strcmp(tmppath, name) == 0) { 378 map = proc_addr2map(p, kve->kve_start); 379 break; 380 } 381 } 382 free(kves); 383 } else 384 for (i = 0; i < p->nobjs; i++) { 385 rdl = &p->rdobjs[i]; 386 basename_r(rdl->rdl_path, tmppath); 387 if (strcmp(tmppath, name) == 0) { 388 if ((map = malloc(sizeof(*map))) == NULL) 389 return (NULL); 390 proc_rdl2prmap(rdl, map); 391 break; 392 } 393 } 394 395 if (map == NULL && strcmp(name, "a.out") == 0 && p->rdexec != NULL) 396 map = proc_addr2map(p, p->rdexec->rdl_saddr); 397 398 return (map); 399 } 400 401 /* 402 * Look up the symbol with the given name and return a copy of it. 403 */ 404 static int 405 lookup_name(Elf *e, Elf_Scn *scn, u_long stridx, const char *symbol, 406 GElf_Sym *symcopy, prsyminfo_t *si) 407 { 408 GElf_Sym sym; 409 Elf_Data *data; 410 char *s; 411 int i; 412 413 if ((data = elf_getdata(scn, NULL)) == NULL) { 414 DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1)); 415 return (1); 416 } 417 for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { 418 s = elf_strptr(e, stridx, sym.st_name); 419 if (s != NULL && strcmp(s, symbol) == 0) { 420 memcpy(symcopy, &sym, sizeof(*symcopy)); 421 if (si != NULL) 422 si->prs_id = i; 423 return (0); 424 } 425 } 426 return (1); 427 } 428 429 int 430 proc_name2sym(struct proc_handle *p, const char *object, const char *symbol, 431 GElf_Sym *symcopy, prsyminfo_t *si) 432 { 433 Elf *e; 434 Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL; 435 GElf_Shdr shdr; 436 GElf_Ehdr ehdr; 437 prmap_t *map; 438 uintptr_t off; 439 u_long symtabstridx = 0, dynsymstridx = 0; 440 int fd, error = -1; 441 442 if ((map = proc_name2map(p, object)) == NULL) { 443 DPRINTFX("ERROR: couldn't find object %s", object); 444 goto err0; 445 } 446 if ((fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) { 447 DPRINTF("ERROR: open %s failed", map->pr_mapname); 448 goto err0; 449 } 450 if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 451 DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1)); 452 goto err1; 453 } 454 if (gelf_getehdr(e, &ehdr) == NULL) { 455 DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1)); 456 goto err2; 457 } 458 /* 459 * Find the index of the STRTAB and SYMTAB sections to locate 460 * symbol names. 461 */ 462 scn = NULL; 463 while ((scn = elf_nextscn(e, scn)) != NULL) { 464 gelf_getshdr(scn, &shdr); 465 switch (shdr.sh_type) { 466 case SHT_SYMTAB: 467 symtabscn = scn; 468 symtabstridx = shdr.sh_link; 469 break; 470 case SHT_DYNSYM: 471 dynsymscn = scn; 472 dynsymstridx = shdr.sh_link; 473 break; 474 } 475 } 476 477 /* 478 * First look up the symbol in the dynsymtab, and fall back to the 479 * symtab if the lookup fails. 480 */ 481 error = lookup_name(e, dynsymscn, dynsymstridx, symbol, symcopy, si); 482 if (error == 0) 483 goto out; 484 485 error = lookup_name(e, symtabscn, symtabstridx, symbol, symcopy, si); 486 if (error == 0) 487 goto out; 488 489 out: 490 off = ehdr.e_type == ET_EXEC ? 0 : map->pr_vaddr; 491 symcopy->st_value += off; 492 493 err2: 494 elf_end(e); 495 err1: 496 close(fd); 497 err0: 498 free(map); 499 500 return (error); 501 } 502 503 ctf_file_t * 504 proc_name2ctf(struct proc_handle *p, const char *name) 505 { 506 #ifndef NO_CTF 507 ctf_file_t *ctf; 508 prmap_t *map; 509 int error; 510 511 if ((map = proc_name2map(p, name)) == NULL) 512 return (NULL); 513 514 ctf = ctf_open(map->pr_mapname, &error); 515 free(map); 516 return (ctf); 517 #else 518 (void)p; 519 (void)name; 520 return (NULL); 521 #endif 522 } 523 524 int 525 proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which, 526 int mask, proc_sym_f *func, void *cd) 527 { 528 Elf *e; 529 int i, fd; 530 prmap_t *map; 531 Elf_Scn *scn, *foundscn = NULL; 532 Elf_Data *data; 533 GElf_Ehdr ehdr; 534 GElf_Shdr shdr; 535 GElf_Sym sym; 536 unsigned long stridx = -1; 537 char *s; 538 int error = -1; 539 540 if ((map = proc_name2map(p, object)) == NULL) 541 return (-1); 542 if ((fd = open(map->pr_mapname, O_RDONLY)) < 0) { 543 DPRINTF("ERROR: open %s failed", map->pr_mapname); 544 goto err0; 545 } 546 if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 547 DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1)); 548 goto err1; 549 } 550 if (gelf_getehdr(e, &ehdr) == NULL) { 551 DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1)); 552 goto err2; 553 } 554 /* 555 * Find the section we are looking for. 556 */ 557 scn = NULL; 558 while ((scn = elf_nextscn(e, scn)) != NULL) { 559 gelf_getshdr(scn, &shdr); 560 if (which == PR_SYMTAB && 561 shdr.sh_type == SHT_SYMTAB) { 562 foundscn = scn; 563 break; 564 } else if (which == PR_DYNSYM && 565 shdr.sh_type == SHT_DYNSYM) { 566 foundscn = scn; 567 break; 568 } 569 } 570 if (!foundscn) 571 return (-1); 572 stridx = shdr.sh_link; 573 if ((data = elf_getdata(foundscn, NULL)) == NULL) { 574 DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1)); 575 goto err2; 576 } 577 for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { 578 if (GELF_ST_BIND(sym.st_info) == STB_LOCAL && 579 (mask & BIND_LOCAL) == 0) 580 continue; 581 if (GELF_ST_BIND(sym.st_info) == STB_GLOBAL && 582 (mask & BIND_GLOBAL) == 0) 583 continue; 584 if (GELF_ST_BIND(sym.st_info) == STB_WEAK && 585 (mask & BIND_WEAK) == 0) 586 continue; 587 if (GELF_ST_TYPE(sym.st_info) == STT_NOTYPE && 588 (mask & TYPE_NOTYPE) == 0) 589 continue; 590 if (GELF_ST_TYPE(sym.st_info) == STT_OBJECT && 591 (mask & TYPE_OBJECT) == 0) 592 continue; 593 if (GELF_ST_TYPE(sym.st_info) == STT_FUNC && 594 (mask & TYPE_FUNC) == 0) 595 continue; 596 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION && 597 (mask & TYPE_SECTION) == 0) 598 continue; 599 if (GELF_ST_TYPE(sym.st_info) == STT_FILE && 600 (mask & TYPE_FILE) == 0) 601 continue; 602 s = elf_strptr(e, stridx, sym.st_name); 603 if (ehdr.e_type != ET_EXEC) 604 sym.st_value += map->pr_vaddr; 605 if ((error = (*func)(cd, &sym, s)) != 0) 606 goto err2; 607 } 608 error = 0; 609 err2: 610 elf_end(e); 611 err1: 612 close(fd); 613 err0: 614 free(map); 615 return (error); 616 } 617