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 * $FreeBSD$ 31 */ 32 33 #include <sys/types.h> 34 #include <sys/user.h> 35 36 #include <assert.h> 37 #include <err.h> 38 #include <stdio.h> 39 #include <libgen.h> 40 #include <string.h> 41 #include <stdlib.h> 42 #include <fcntl.h> 43 #include <string.h> 44 #include <unistd.h> 45 #include <libutil.h> 46 47 #include "_libproc.h" 48 49 extern char *__cxa_demangle(const char *, char *, size_t *, int *); 50 51 static void proc_rdl2prmap(rd_loadobj_t *, prmap_t *); 52 53 static void 54 demangle(const char *symbol, char *buf, size_t len) 55 { 56 char *dembuf; 57 size_t demlen = len; 58 59 dembuf = malloc(len); 60 if (!dembuf) 61 goto fail; 62 dembuf = __cxa_demangle(symbol, dembuf, &demlen, NULL); 63 if (!dembuf) 64 goto fail; 65 strlcpy(buf, dembuf, len); 66 free(dembuf); 67 68 return; 69 fail: 70 strlcpy(buf, symbol, len); 71 } 72 73 static void 74 proc_rdl2prmap(rd_loadobj_t *rdl, prmap_t *map) 75 { 76 map->pr_vaddr = rdl->rdl_saddr; 77 map->pr_size = rdl->rdl_eaddr - rdl->rdl_saddr; 78 map->pr_offset = rdl->rdl_offset; 79 map->pr_mflags = 0; 80 if (rdl->rdl_prot & RD_RDL_R) 81 map->pr_mflags |= MA_READ; 82 if (rdl->rdl_prot & RD_RDL_W) 83 map->pr_mflags |= MA_WRITE; 84 if (rdl->rdl_prot & RD_RDL_X) 85 map->pr_mflags |= MA_EXEC; 86 strlcpy(map->pr_mapname, rdl->rdl_path, 87 sizeof(map->pr_mapname)); 88 } 89 90 char * 91 proc_objname(struct proc_handle *p, uintptr_t addr, char *objname, 92 size_t objnamesz) 93 { 94 size_t i; 95 rd_loadobj_t *rdl; 96 97 for (i = 0; i < p->nobjs; i++) { 98 rdl = &p->rdobjs[i]; 99 if (addr >= rdl->rdl_saddr && addr <= rdl->rdl_eaddr) { 100 strlcpy(objname, rdl->rdl_path, objnamesz); 101 return (objname); 102 } 103 } 104 return (NULL); 105 } 106 107 prmap_t * 108 proc_obj2map(struct proc_handle *p, const char *objname) 109 { 110 size_t i; 111 prmap_t *map; 112 rd_loadobj_t *rdl; 113 char path[MAXPATHLEN]; 114 115 for (i = 0; i < p->nobjs; i++) { 116 rdl = &p->rdobjs[i]; 117 basename_r(rdl->rdl_path, path); 118 if (strcmp(path, objname) == 0) { 119 if ((map = malloc(sizeof(*map))) == NULL) 120 return (NULL); 121 proc_rdl2prmap(rdl, map); 122 return (map); 123 } 124 } 125 return (NULL); 126 } 127 128 int 129 proc_iter_objs(struct proc_handle *p, proc_map_f *func, void *cd) 130 { 131 size_t i; 132 rd_loadobj_t *rdl; 133 prmap_t map; 134 char path[MAXPATHLEN]; 135 char last[MAXPATHLEN]; 136 137 if (p->nobjs == 0) 138 return (-1); 139 memset(last, 0, sizeof(last)); 140 for (i = 0; i < p->nobjs; i++) { 141 rdl = &p->rdobjs[i]; 142 proc_rdl2prmap(rdl, &map); 143 basename_r(rdl->rdl_path, path); 144 /* 145 * We shouldn't call the callback twice with the same object. 146 * To do that we are assuming the fact that if there are 147 * repeated object names (i.e. different mappings for the 148 * same object) they occur next to each other. 149 */ 150 if (strcmp(path, last) == 0) 151 continue; 152 (*func)(cd, &map, path); 153 strlcpy(last, path, sizeof(last)); 154 } 155 156 return (0); 157 } 158 159 prmap_t * 160 proc_addr2map(struct proc_handle *p, uintptr_t addr) 161 { 162 size_t i; 163 int cnt, lastvn = 0; 164 prmap_t *map; 165 rd_loadobj_t *rdl; 166 struct kinfo_vmentry *kves, *kve; 167 168 /* 169 * If we don't have a cache of listed objects, we need to query 170 * it ourselves. 171 */ 172 if (p->nobjs == 0) { 173 if ((kves = kinfo_getvmmap(p->pid, &cnt)) == NULL) 174 return (NULL); 175 for (i = 0; i < (size_t)cnt; i++) { 176 kve = kves + i; 177 if (kve->kve_type == KVME_TYPE_VNODE) 178 lastvn = i; 179 if (addr >= kve->kve_start && addr <= kve->kve_end) { 180 if ((map = malloc(sizeof(*map))) == NULL) { 181 free(kves); 182 return (NULL); 183 } 184 map->pr_vaddr = kve->kve_start; 185 map->pr_size = kve->kve_end - kve->kve_start; 186 map->pr_offset = kve->kve_offset; 187 map->pr_mflags = 0; 188 if (kve->kve_protection & KVME_PROT_READ) 189 map->pr_mflags |= MA_READ; 190 if (kve->kve_protection & KVME_PROT_WRITE) 191 map->pr_mflags |= MA_WRITE; 192 if (kve->kve_protection & KVME_PROT_EXEC) 193 map->pr_mflags |= MA_EXEC; 194 if (kve->kve_flags & KVME_FLAG_COW) 195 map->pr_mflags |= MA_COW; 196 if (kve->kve_flags & KVME_FLAG_NEEDS_COPY) 197 map->pr_mflags |= MA_NEEDS_COPY; 198 if (kve->kve_flags & KVME_FLAG_NOCOREDUMP) 199 map->pr_mflags |= MA_NOCOREDUMP; 200 strlcpy(map->pr_mapname, kves[lastvn].kve_path, 201 sizeof(map->pr_mapname)); 202 free(kves); 203 return (map); 204 } 205 } 206 free(kves); 207 return (NULL); 208 } 209 210 for (i = 0; i < p->nobjs; i++) { 211 rdl = &p->rdobjs[i]; 212 if (addr >= rdl->rdl_saddr && addr <= rdl->rdl_eaddr) { 213 if ((map = malloc(sizeof(*map))) == NULL) 214 return (NULL); 215 proc_rdl2prmap(rdl, map); 216 return (map); 217 } 218 } 219 return (NULL); 220 } 221 222 int 223 proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name, 224 size_t namesz, GElf_Sym *symcopy) 225 { 226 Elf *e; 227 Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL; 228 Elf_Data *data; 229 GElf_Shdr shdr; 230 GElf_Sym sym; 231 GElf_Ehdr ehdr; 232 int fd, error = -1; 233 size_t i; 234 uint64_t rsym; 235 prmap_t *map; 236 char *s; 237 unsigned long symtabstridx = 0, dynsymstridx = 0; 238 239 if ((map = proc_addr2map(p, addr)) == NULL) 240 return (-1); 241 if (!map->pr_mapname || (fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) { 242 warn("ERROR: open %s failed", map->pr_mapname); 243 goto err0; 244 } 245 if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 246 warn("ERROR: elf_begin() failed"); 247 goto err1; 248 } 249 if (gelf_getehdr(e, &ehdr) == NULL) { 250 warn("ERROR: gelf_getehdr() failed"); 251 goto err2; 252 } 253 /* 254 * Find the index of the STRTAB and SYMTAB sections to locate 255 * symbol names. 256 */ 257 scn = NULL; 258 while ((scn = elf_nextscn(e, scn)) != NULL) { 259 gelf_getshdr(scn, &shdr); 260 switch (shdr.sh_type) { 261 case SHT_SYMTAB: 262 symtabscn = scn; 263 symtabstridx = shdr.sh_link; 264 break; 265 case SHT_DYNSYM: 266 dynsymscn = scn; 267 dynsymstridx = shdr.sh_link; 268 break; 269 default: 270 break; 271 } 272 } 273 /* 274 * Iterate over the Dynamic Symbols table to find the symbol. 275 * Then look up the string name in STRTAB (.dynstr) 276 */ 277 if ((data = elf_getdata(dynsymscn, NULL)) == NULL) { 278 DPRINTF("ERROR: elf_getdata() failed"); 279 goto symtab; 280 } 281 i = 0; 282 while (gelf_getsym(data, i++, &sym) != NULL) { 283 /* 284 * Calculate the address mapped to the virtual memory 285 * by rtld. 286 */ 287 rsym = map->pr_vaddr + sym.st_value; 288 if (addr >= rsym && addr <= (rsym + sym.st_size)) { 289 s = elf_strptr(e, dynsymstridx, sym.st_name); 290 if (s) { 291 if (s[0] == '_' && s[1] == 'Z' && s[2]) 292 demangle(s, name, namesz); 293 else 294 strlcpy(name, s, namesz); 295 memcpy(symcopy, &sym, sizeof(sym)); 296 /* 297 * DTrace expects the st_value to contain 298 * only the address relative to the start of 299 * the function. 300 */ 301 symcopy->st_value = rsym; 302 error = 0; 303 goto out; 304 } 305 } 306 } 307 symtab: 308 /* 309 * Iterate over the Symbols Table to find the symbol. 310 * Then look up the string name in STRTAB (.dynstr) 311 */ 312 if (symtabscn == NULL) 313 goto err2; 314 if ((data = elf_getdata(symtabscn, NULL)) == NULL) { 315 DPRINTF("ERROR: elf_getdata() failed"); 316 goto err2; 317 } 318 i = 0; 319 while (gelf_getsym(data, i++, &sym) != NULL) { 320 /* 321 * Calculate the address mapped to the virtual memory 322 * by rtld. 323 */ 324 if (ehdr.e_type != ET_EXEC) 325 rsym = map->pr_vaddr + sym.st_value; 326 else 327 rsym = sym.st_value; 328 if (addr >= rsym && addr <= (rsym + sym.st_size)) { 329 s = elf_strptr(e, symtabstridx, sym.st_name); 330 if (s) { 331 if (s[0] == '_' && s[1] == 'Z' && s[2]) 332 demangle(s, name, namesz); 333 else 334 strlcpy(name, s, namesz); 335 memcpy(symcopy, &sym, sizeof(sym)); 336 /* 337 * DTrace expects the st_value to contain 338 * only the address relative to the start of 339 * the function. 340 */ 341 symcopy->st_value = rsym; 342 error = 0; 343 goto out; 344 } 345 } 346 } 347 out: 348 err2: 349 elf_end(e); 350 err1: 351 close(fd); 352 err0: 353 free(map); 354 return (error); 355 } 356 357 prmap_t * 358 proc_name2map(struct proc_handle *p, const char *name) 359 { 360 size_t i; 361 int cnt; 362 prmap_t *map; 363 char tmppath[MAXPATHLEN]; 364 struct kinfo_vmentry *kves, *kve; 365 rd_loadobj_t *rdl; 366 367 /* 368 * If we haven't iterated over the list of loaded objects, 369 * librtld_db isn't yet initialized and it's very likely 370 * that librtld_db called us. We need to do the heavy 371 * lifting here to find the symbol librtld_db is looking for. 372 */ 373 if (p->nobjs == 0) { 374 if ((kves = kinfo_getvmmap(proc_getpid(p), &cnt)) == NULL) 375 return (NULL); 376 for (i = 0; i < (size_t)cnt; i++) { 377 kve = kves + i; 378 basename_r(kve->kve_path, tmppath); 379 if (strcmp(tmppath, name) == 0) { 380 map = proc_addr2map(p, kve->kve_start); 381 free(kves); 382 return (map); 383 } 384 } 385 free(kves); 386 return (NULL); 387 } 388 if (name == NULL || strcmp(name, "a.out") == 0) { 389 map = proc_addr2map(p, p->rdobjs[0].rdl_saddr); 390 return (map); 391 } 392 for (i = 0; i < p->nobjs; i++) { 393 rdl = &p->rdobjs[i]; 394 basename_r(rdl->rdl_path, tmppath); 395 if (strcmp(tmppath, name) == 0) { 396 if ((map = malloc(sizeof(*map))) == NULL) 397 return (NULL); 398 proc_rdl2prmap(rdl, map); 399 return (map); 400 } 401 } 402 403 return (NULL); 404 } 405 406 int 407 proc_name2sym(struct proc_handle *p, const char *object, const char *symbol, 408 GElf_Sym *symcopy) 409 { 410 Elf *e; 411 Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL; 412 Elf_Data *data; 413 GElf_Shdr shdr; 414 GElf_Sym sym; 415 GElf_Ehdr ehdr; 416 int fd, error = -1; 417 size_t i; 418 prmap_t *map; 419 char *s; 420 unsigned long symtabstridx = 0, dynsymstridx = 0; 421 422 if ((map = proc_name2map(p, object)) == NULL) { 423 DPRINTF("ERROR: couldn't find object %s", object); 424 goto err0; 425 } 426 if ((fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) { 427 DPRINTF("ERROR: open %s failed", map->pr_mapname); 428 goto err0; 429 } 430 if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 431 warn("ERROR: elf_begin() failed"); 432 goto err1; 433 } 434 if (gelf_getehdr(e, &ehdr) == NULL) { 435 warn("ERROR: gelf_getehdr() failed"); 436 goto err2; 437 } 438 /* 439 * Find the index of the STRTAB and SYMTAB sections to locate 440 * symbol names. 441 */ 442 scn = NULL; 443 while ((scn = elf_nextscn(e, scn)) != NULL) { 444 gelf_getshdr(scn, &shdr); 445 switch (shdr.sh_type) { 446 case SHT_SYMTAB: 447 symtabscn = scn; 448 symtabstridx = shdr.sh_link; 449 break; 450 case SHT_DYNSYM: 451 dynsymscn = scn; 452 dynsymstridx = shdr.sh_link; 453 break; 454 default: 455 break; 456 } 457 } 458 /* 459 * Iterate over the Dynamic Symbols table to find the symbol. 460 * Then look up the string name in STRTAB (.dynstr) 461 */ 462 if ((data = elf_getdata(dynsymscn, NULL))) { 463 DPRINTF("ERROR: elf_getdata() failed"); 464 i = 0; 465 while (gelf_getsym(data, i++, &sym) != NULL) { 466 s = elf_strptr(e, dynsymstridx, sym.st_name); 467 if (s && strcmp(s, symbol) == 0) { 468 memcpy(symcopy, &sym, sizeof(sym)); 469 symcopy->st_value = map->pr_vaddr + sym.st_value; 470 error = 0; 471 goto out; 472 } 473 } 474 } 475 /* 476 * Iterate over the Symbols Table to find the symbol. 477 * Then look up the string name in STRTAB (.dynstr) 478 */ 479 if (symtabscn == NULL) 480 goto err2; 481 if ((data = elf_getdata(symtabscn, NULL))) { 482 i = 0; 483 while (gelf_getsym(data, i++, &sym) != NULL) { 484 s = elf_strptr(e, symtabstridx, sym.st_name); 485 if (s && strcmp(s, symbol) == 0) { 486 memcpy(symcopy, &sym, sizeof(sym)); 487 error = 0; 488 goto out; 489 } 490 } 491 } 492 out: 493 err2: 494 elf_end(e); 495 err1: 496 close(fd); 497 err0: 498 free(map); 499 500 return (error); 501 } 502 503 504 int 505 proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which, 506 int mask, proc_sym_f *func, void *cd) 507 { 508 Elf *e; 509 int i, fd; 510 prmap_t *map; 511 Elf_Scn *scn, *foundscn = NULL; 512 Elf_Data *data; 513 GElf_Shdr shdr; 514 GElf_Sym sym; 515 unsigned long stridx = -1; 516 char *s; 517 int error = -1; 518 519 if ((map = proc_name2map(p, object)) == NULL) 520 return (-1); 521 if ((fd = open(map->pr_mapname, O_RDONLY)) < 0) { 522 warn("ERROR: open %s failed", map->pr_mapname); 523 goto err0; 524 } 525 if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 526 warn("ERROR: elf_begin() failed"); 527 goto err1; 528 } 529 /* 530 * Find the section we are looking for. 531 */ 532 scn = NULL; 533 while ((scn = elf_nextscn(e, scn)) != NULL) { 534 gelf_getshdr(scn, &shdr); 535 if (which == PR_SYMTAB && 536 shdr.sh_type == SHT_SYMTAB) { 537 foundscn = scn; 538 break; 539 } else if (which == PR_DYNSYM && 540 shdr.sh_type == SHT_DYNSYM) { 541 foundscn = scn; 542 break; 543 } 544 } 545 if (!foundscn) 546 return (-1); 547 stridx = shdr.sh_link; 548 if ((data = elf_getdata(foundscn, NULL)) == NULL) { 549 DPRINTF("ERROR: elf_getdata() failed"); 550 goto err2; 551 } 552 i = 0; 553 while (gelf_getsym(data, i++, &sym) != NULL) { 554 if (GELF_ST_BIND(sym.st_info) == STB_LOCAL && 555 (mask & BIND_LOCAL) == 0) 556 continue; 557 if (GELF_ST_BIND(sym.st_info) == STB_GLOBAL && 558 (mask & BIND_GLOBAL) == 0) 559 continue; 560 if (GELF_ST_BIND(sym.st_info) == STB_WEAK && 561 (mask & BIND_WEAK) == 0) 562 continue; 563 if (GELF_ST_TYPE(sym.st_info) == STT_NOTYPE && 564 (mask & TYPE_NOTYPE) == 0) 565 continue; 566 if (GELF_ST_TYPE(sym.st_info) == STT_OBJECT && 567 (mask & TYPE_OBJECT) == 0) 568 continue; 569 if (GELF_ST_TYPE(sym.st_info) == STT_FUNC && 570 (mask & TYPE_FUNC) == 0) 571 continue; 572 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION && 573 (mask & TYPE_SECTION) == 0) 574 continue; 575 if (GELF_ST_TYPE(sym.st_info) == STT_FILE && 576 (mask & TYPE_FILE) == 0) 577 continue; 578 s = elf_strptr(e, stridx, sym.st_name); 579 sym.st_value += map->pr_vaddr; 580 (*func)(cd, &sym, s); 581 } 582 error = 0; 583 err2: 584 elf_end(e); 585 err1: 586 close(fd); 587 err0: 588 free(map); 589 return (error); 590 } 591