lib/libproc/proc_sym.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2016-2017 Mark Johnston <markj@FreeBSD.org>
   5  * Copyright (c) 2010 The FreeBSD Foundation
   6  * Copyright (c) 2008 John Birrell (jb@freebsd.org)
   7  * All rights reserved.
   8  *
   9  * Portions of this software were developed by Rui Paulo under sponsorship
  10  * from the FreeBSD Foundation.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/types.h>
  38 #ifndef NO_CTF
  39 #include <sys/ctf.h>
  40 #include <sys/ctf_api.h>
  41 #endif
  42 #include <sys/user.h>
  43
  44 #include <assert.h>
  45 #include <err.h>
  46 #include <fcntl.h>
  47 #include <libgen.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <unistd.h>
  52 #ifndef NO_CTF
  53 #include <libctf.h>
  54 #endif
  55 #include <libutil.h>
  56
  57 #include "crc32.h"
  58 #include "_libproc.h"
  59
  60 #define PATH_DEBUG_DIR  "/usr/lib/debug"
  61
  62 #ifdef NO_CTF
  63 typedef struct ctf_file ctf_file_t;
  64 #endif
  65
  66 #ifndef NO_CXA_DEMANGLE
  67 extern char *__cxa_demangle(const char *, char *, size_t *, int *);
  68 #endif /* NO_CXA_DEMANGLE */
  69
  70 static int
  71 crc32_file(int fd, uint32_t *crc)
  72 {
  73         uint8_t buf[PAGE_SIZE], *p;
  74         size_t n;
  75
  76         *crc = ~0;
  77         while ((n = read(fd, buf, sizeof(buf))) > 0) {
  78                 p = &buf[0];
  79                 while (n-- > 0)
  80                         *crc = crc32_tab[(*crc ^ *p++) & 0xff] ^ (*crc >> 8);
  81         }
  82         *crc = ~*crc;
  83         return (n);
  84 }
  85
  86 static void
  87 demangle(const char *symbol, char *buf, size_t len)
  88 {
  89 #ifndef NO_CXA_DEMANGLE
  90         char *dembuf;
  91
  92         if (symbol[0] == '_' && symbol[1] == 'Z' && symbol[2]) {
  93                 dembuf = __cxa_demangle(symbol, NULL, NULL, NULL);
  94                 if (!dembuf)
  95                         goto fail;
  96                 strlcpy(buf, dembuf, len);
  97                 free(dembuf);
  98                 return;
  99         }
 100 fail:
 101 #endif /* NO_CXA_DEMANGLE */
 102         strlcpy(buf, symbol, len);
 103 }
 104
 105 struct symsort_thunk {
 106         Elf *e;
 107         struct symtab *symtab;
 108 };
 109
 110 static int
 111 symvalcmp(void *_thunk, const void *a1, const void *a2)
 112 {
 113         GElf_Sym sym1, sym2;
 114         struct symsort_thunk *thunk;
 115         const char *s1, *s2;
 116         u_int i1, i2;
 117         int bind1, bind2;
 118
 119         i1 = *(const u_int *)a1;
 120         i2 = *(const u_int *)a2;
 121         thunk = _thunk;
 122
 123         (void)gelf_getsym(thunk->symtab->data, i1, &sym1);
 124         (void)gelf_getsym(thunk->symtab->data, i2, &sym2);
 125
 126         if (sym1.st_value != sym2.st_value)
 127                 return (sym1.st_value < sym2.st_value ? -1 : 1);
 128
 129         /* Prefer non-local symbols. */
 130         bind1 = GELF_ST_BIND(sym1.st_info);
 131         bind2 = GELF_ST_BIND(sym2.st_info);
 132         if (bind1 != bind2) {
 133                 if (bind1 == STB_LOCAL && bind2 != STB_LOCAL)
 134                         return (-1);
 135                 if (bind1 != STB_LOCAL && bind2 == STB_LOCAL)
 136                         return (1);
 137         }
 138
 139         s1 = elf_strptr(thunk->e, thunk->symtab->stridx, sym1.st_name);
 140         s2 = elf_strptr(thunk->e, thunk->symtab->stridx, sym2.st_name);
 141         if (s1 != NULL && s2 != NULL) {
 142                 /* Prefer symbols without a leading '$'. */
 143                 if (*s1 == '$')
 144                         return (-1);
 145                 if (*s2 == '$')
 146                         return (1);
 147
 148                 /* Prefer symbols with fewer leading underscores. */
 149                 for (; *s1 == '_' && *s2 == '_'; s1++, s2++)
 150                         ;
 151                 if (*s1 == '_')
 152                         return (-1);
 153                 if (*s2 == '_')
 154                         return (1);
 155         }
 156
 157         return (0);
 158 }
 159
 160 static int
 161 load_symtab(Elf *e, struct symtab *symtab, u_long sh_type)
 162 {
 163         GElf_Ehdr ehdr;
 164         GElf_Shdr shdr;
 165         struct symsort_thunk thunk;
 166         Elf_Scn *scn;
 167         u_int nsyms;
 168
 169         if (gelf_getehdr(e, &ehdr) == NULL)
 170                 return (-1);
 171
 172         scn = NULL;
 173         while ((scn = elf_nextscn(e, scn)) != NULL) {
 174                 (void)gelf_getshdr(scn, &shdr);
 175                 if (shdr.sh_type == sh_type)
 176                         break;
 177         }
 178         if (scn == NULL)
 179                 return (-1);
 180
 181         nsyms = shdr.sh_size / shdr.sh_entsize;
 182         if (nsyms > (1 << 20))
 183                 return (-1);
 184
 185         if ((symtab->data = elf_getdata(scn, NULL)) == NULL)
 186                 return (-1);
 187
 188         symtab->index = calloc(nsyms, sizeof(u_int));
 189         if (symtab->index == NULL)
 190                 return (-1);
 191         for (u_int i = 0; i < nsyms; i++)
 192                 symtab->index[i] = i;
 193         symtab->nsyms = nsyms;
 194         symtab->stridx = shdr.sh_link;
 195
 196         thunk.e = e;
 197         thunk.symtab = symtab;
 198         qsort_r(symtab->index, nsyms, sizeof(u_int), &thunk, symvalcmp);
 199
 200         return (0);
 201 }
 202
 203 static void
 204 load_symtabs(struct file_info *file)
 205 {
 206
 207         file->symtab.nsyms = file->dynsymtab.nsyms = 0;
 208         (void)load_symtab(file->elf, &file->symtab, SHT_SYMTAB);
 209         (void)load_symtab(file->elf, &file->dynsymtab, SHT_DYNSYM);
 210 }
 211
 212 static int
 213 open_debug_file(char *path, const char *debugfile, uint32_t crc)
 214 {
 215         size_t n;
 216         uint32_t compcrc;
 217         int fd;
 218
 219         fd = -1;
 220         if ((n = strlcat(path, "/", PATH_MAX)) >= PATH_MAX)
 221                 return (fd);
 222         if (strlcat(path, debugfile, PATH_MAX) >= PATH_MAX)
 223                 goto out;
 224         if ((fd = open(path, O_RDONLY | O_CLOEXEC)) < 0)
 225                 goto out;
 226         if (crc32_file(fd, &compcrc) != 0 || crc != compcrc) {
 227                 DPRINTFX("ERROR: CRC32 mismatch for %s", path);
 228                 (void)close(fd);
 229                 fd = -1;
 230         }
 231 out:
 232         path[n] = '\0';
 233         return (fd);
 234 }
 235
 236 /*
 237  * Obtain an ELF descriptor for the specified mapped object. If a GNU debuglink
 238  * section is present, a descriptor for the corresponding debug file is
 239  * returned.
 240  */
 241 static int
 242 open_object(struct map_info *mapping)
 243 {
 244         char path[PATH_MAX];
 245         GElf_Shdr shdr;
 246         Elf *e, *e2;
 247         Elf_Data *data;
 248         Elf_Scn *scn;
 249         struct file_info *file;
 250         prmap_t *map;
 251         const char *debugfile, *scnname;
 252         size_t ndx;
 253         uint32_t crc;
 254         int fd, fd2;
 255
 256         if (mapping->map.pr_mapname[0] == '\0')
 257                 return (-1); /* anonymous object */
 258         if (mapping->file->elf != NULL)
 259                 return (0); /* already loaded */
 260
 261         file = mapping->file;
 262         map = &mapping->map;
 263         if ((fd = open(map->pr_mapname, O_RDONLY | O_CLOEXEC)) < 0) {
 264                 DPRINTF("ERROR: open %s failed", map->pr_mapname);
 265                 return (-1);
 266         }
 267         if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
 268                 DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
 269                 goto err;
 270         }
 271         if (gelf_getehdr(e, &file->ehdr) != &file->ehdr) {
 272                 DPRINTFX("ERROR: elf_getehdr() failed: %s", elf_errmsg(-1));
 273                 goto err;
 274         }
 275
 276         scn = NULL;
 277         while ((scn = elf_nextscn(e, scn)) != NULL) {
 278                 if (gelf_getshdr(scn, &shdr) != &shdr) {
 279                         DPRINTFX("ERROR: gelf_getshdr failed: %s",
 280                             elf_errmsg(-1));
 281                         goto err;
 282                 }
 283                 if (shdr.sh_type != SHT_PROGBITS)
 284                         continue;
 285                 if (elf_getshdrstrndx(e, &ndx) != 0) {
 286                         DPRINTFX("ERROR: elf_getshdrstrndx failed: %s",
 287                             elf_errmsg(-1));
 288                         goto err;
 289                 }
 290                 if ((scnname = elf_strptr(e, ndx, shdr.sh_name)) == NULL)
 291                         continue;
 292
 293                 if (strcmp(scnname, ".gnu_debuglink") == 0)
 294                         break;
 295         }
 296         if (scn == NULL)
 297                 goto internal;
 298
 299         if ((data = elf_getdata(scn, NULL)) == NULL) {
 300                 DPRINTFX("ERROR: elf_getdata failed: %s", elf_errmsg(-1));
 301                 goto err;
 302         }
 303
 304         /*
 305          * The data contains a null-terminated file name followed by a 4-byte
 306          * CRC.
 307          */
 308         if (data->d_size < sizeof(crc) + 1) {
 309                 DPRINTFX("ERROR: debuglink section is too small (%zd bytes)",
 310                     data->d_size);
 311                 goto internal;
 312         }
 313         if (strnlen(data->d_buf, data->d_size) >= data->d_size - sizeof(crc)) {
 314                 DPRINTFX("ERROR: no null-terminator in gnu_debuglink section");
 315                 goto internal;
 316         }
 317
 318         debugfile = data->d_buf;
 319         memcpy(&crc, (char *)data->d_buf + data->d_size - sizeof(crc),
 320             sizeof(crc));
 321
 322         /*
 323          * Search for the debug file using the algorithm described in the gdb
 324          * documentation:
 325          * - look in the directory containing the object,
 326          * - look in the subdirectory ".debug" of the directory containing the
 327          *   object,
 328          * - look in the global debug directories (currently /usr/lib/debug).
 329          */
 330         (void)strlcpy(path, map->pr_mapname, sizeof(path));
 331         (void)dirname(path);
 332
 333         if ((fd2 = open_debug_file(path, debugfile, crc)) >= 0)
 334                 goto external;
 335
 336         if (strlcat(path, "/.debug", sizeof(path)) < sizeof(path) &&
 337             (fd2 = open_debug_file(path, debugfile, crc)) >= 0)
 338                 goto external;
 339
 340         (void)snprintf(path, sizeof(path), PATH_DEBUG_DIR);
 341         if (strlcat(path, map->pr_mapname, sizeof(path)) < sizeof(path)) {
 342                 (void)dirname(path);
 343                 if ((fd2 = open_debug_file(path, debugfile, crc)) >= 0)
 344                         goto external;
 345         }
 346
 347 internal:
 348         /* We didn't find a debug file, just return the object's descriptor. */
 349         file->elf = e;
 350         file->fd = fd;
 351         load_symtabs(file);
 352         return (0);
 353
 354 external:
 355         if ((e2 = elf_begin(fd2, ELF_C_READ, NULL)) == NULL) {
 356                 DPRINTFX("ERROR: elf_begin failed: %s", elf_errmsg(-1));
 357                 (void)close(fd2);
 358                 goto err;
 359         }
 360         (void)elf_end(e);
 361         (void)close(fd);
 362         file->elf = e2;
 363         file->fd = fd2;
 364         load_symtabs(file);
 365         return (0);
 366
 367 err:
 368         if (e != NULL)
 369                 (void)elf_end(e);
 370         (void)close(fd);
 371         return (-1);
 372 }
 373
 374 char *
 375 proc_objname(struct proc_handle *p, uintptr_t addr, char *objname,
 376     size_t objnamesz)
 377 {
 378         prmap_t *map;
 379         size_t i;
 380
 381         if (p->nmappings == 0)
 382                 if (proc_rdagent(p) == NULL)
 383                         return (NULL);
 384         for (i = 0; i < p->nmappings; i++) {
 385                 map = &p->mappings[i].map;
 386                 if (addr >= map->pr_vaddr &&
 387                     addr < map->pr_vaddr + map->pr_size) {
 388                         strlcpy(objname, map->pr_mapname, objnamesz);
 389                         return (objname);
 390                 }
 391         }
 392         return (NULL);
 393 }
 394
 395 int
 396 proc_iter_objs(struct proc_handle *p, proc_map_f *func, void *cd)
 397 {
 398         char last[MAXPATHLEN], path[MAXPATHLEN], *base;
 399         prmap_t *map;
 400         size_t i;
 401         int error;
 402
 403         if (p->nmappings == 0)
 404                 if (proc_rdagent(p) == NULL)
 405                         return (-1);
 406
 407         error = 0;
 408         memset(last, 0, sizeof(last));
 409         for (i = 0; i < p->nmappings; i++) {
 410                 map = &p->mappings[i].map;
 411                 strlcpy(path, map->pr_mapname, sizeof(path));
 412                 base = basename(path);
 413                 /*
 414                  * We shouldn't call the callback twice with the same object.
 415                  * To do that we are assuming the fact that if there are
 416                  * repeated object names (i.e. different mappings for the
 417                  * same object) they occur next to each other.
 418                  */
 419                 if (strcmp(base, last) == 0)
 420                         continue;
 421                 if ((error = (*func)(cd, map, base)) != 0)
 422                         break;
 423                 strlcpy(last, path, sizeof(last));
 424         }
 425         return (error);
 426 }
 427
 428 static struct map_info *
 429 _proc_addr2map(struct proc_handle *p, uintptr_t addr)
 430 {
 431         struct map_info *mapping;
 432         size_t i;
 433
 434         if (p->nmappings == 0)
 435                 if (proc_rdagent(p) == NULL)
 436                         return (NULL);
 437         for (i = 0; i < p->nmappings; i++) {
 438                 mapping = &p->mappings[i];
 439                 if (addr >= mapping->map.pr_vaddr &&
 440                     addr < mapping->map.pr_vaddr + mapping->map.pr_size)
 441                         return (mapping);
 442         }
 443         return (NULL);
 444 }
 445
 446 prmap_t *
 447 proc_addr2map(struct proc_handle *p, uintptr_t addr)
 448 {
 449
 450         return (&_proc_addr2map(p, addr)->map);
 451 }
 452
 453 /*
 454  * Look up the symbol at addr using a binary search, returning a copy of the
 455  * symbol and its name.
 456  */
 457 static int
 458 lookup_symbol_by_addr(Elf *e, struct symtab *symtab, uintptr_t addr,
 459     const char **namep, GElf_Sym *symp)
 460 {
 461         GElf_Sym sym;
 462         Elf_Data *data;
 463         const char *s;
 464         u_int i, min, max, mid;
 465
 466         if (symtab->nsyms == 0)
 467                 return (ENOENT);
 468
 469         data = symtab->data;
 470         min = 0;
 471         max = symtab->nsyms - 1;
 472
 473         while (min <= max) {
 474                 mid = (max + min) / 2;
 475                 (void)gelf_getsym(data, symtab->index[mid], &sym);
 476                 if (addr >= sym.st_value && addr < sym.st_value + sym.st_size)
 477                         break;
 478
 479                 if (addr < sym.st_value)
 480                         max = mid - 1;
 481                 else
 482                         min = mid + 1;
 483         }
 484         if (min > max)
 485                 return (ENOENT);
 486
 487         /*
 488          * Advance until we find the matching symbol with largest index.
 489          */
 490         for (i = mid; i < symtab->nsyms; i++) {
 491                 (void)gelf_getsym(data, symtab->index[i], &sym);
 492                 if (addr < sym.st_value || addr >= sym.st_value + sym.st_size)
 493                         break;
 494         }
 495         (void)gelf_getsym(data, symtab->index[i - 1], symp);
 496         s = elf_strptr(e, symtab->stridx, symp->st_name);
 497         if (s != NULL && namep != NULL)
 498                 *namep = s;
 499         return (0);
 500 }
 501
 502 int
 503 proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name,
 504     size_t namesz, GElf_Sym *symcopy)
 505 {
 506         struct file_info *file;
 507         struct map_info *mapping;
 508         const char *s;
 509         uintptr_t off;
 510         int error;
 511
 512         if ((mapping = _proc_addr2map(p, addr)) == NULL) {
 513                 DPRINTFX("ERROR: proc_addr2map failed to resolve 0x%jx", addr);
 514                 return (-1);
 515         }
 516         if (open_object(mapping) != 0) {
 517                 DPRINTFX("ERROR: failed to open object %s",
 518                     mapping->map.pr_mapname);
 519                 return (-1);
 520         }
 521
 522         file = mapping->file;
 523         off = file->ehdr.e_type == ET_DYN ?
 524             mapping->map.pr_vaddr - mapping->map.pr_offset : 0;
 525         if (addr < off)
 526                 return (ENOENT);
 527         addr -= off;
 528
 529         error = lookup_symbol_by_addr(file->elf, &file->dynsymtab, addr, &s,
 530             symcopy);
 531         if (error == ENOENT)
 532                 error = lookup_symbol_by_addr(file->elf, &file->symtab, addr,
 533                     &s, symcopy);
 534         if (error == 0) {
 535                 symcopy->st_value += off;
 536                 demangle(s, name, namesz);
 537         }
 538         return (error);
 539 }
 540
 541 static struct map_info *
 542 _proc_name2map(struct proc_handle *p, const char *name)
 543 {
 544         char path[MAXPATHLEN], *base;
 545         struct map_info *mapping;
 546         size_t i, len;
 547
 548         if ((len = strlen(name)) == 0)
 549                 return (NULL);
 550         if (p->nmappings == 0)
 551                 if (proc_rdagent(p) == NULL)
 552                         return (NULL);
 553         for (i = 0; i < p->nmappings; i++) {
 554                 mapping = &p->mappings[i];
 555                 (void)strlcpy(path, mapping->map.pr_mapname, sizeof(path));
 556                 base = basename(path);
 557                 if (strcmp(base, name) == 0)
 558                         return (mapping);
 559         }
 560         /* If we didn't find a match, try matching prefixes of the basename. */
 561         for (i = 0; i < p->nmappings; i++) {
 562                 strlcpy(path, p->mappings[i].map.pr_mapname, sizeof(path));
 563                 base = basename(path);
 564                 if (strncmp(base, name, len) == 0)
 565                         return (&p->mappings[i]);
 566         }
 567         if (strcmp(name, "a.out") == 0)
 568                 return (_proc_addr2map(p,
 569                     p->mappings[p->exec_map].map.pr_vaddr));
 570         return (NULL);
 571 }
 572
 573 prmap_t *
 574 proc_name2map(struct proc_handle *p, const char *name)
 575 {
 576
 577         return (&_proc_name2map(p, name)->map);
 578 }
 579
 580 /*
 581  * Look up the symbol with the given name and return a copy of it.
 582  */
 583 static int
 584 lookup_symbol_by_name(Elf *elf, struct symtab *symtab, const char *symbol,
 585     GElf_Sym *symcopy, prsyminfo_t *si)
 586 {
 587         GElf_Sym sym;
 588         Elf_Data *data;
 589         char *s;
 590         int i;
 591
 592         if (symtab->nsyms == 0)
 593                 return (ENOENT);
 594         data = symtab->data;
 595         for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) {
 596                 s = elf_strptr(elf, symtab->stridx, sym.st_name);
 597                 if (s != NULL && strcmp(s, symbol) == 0) {
 598                         memcpy(symcopy, &sym, sizeof(*symcopy));
 599                         if (si != NULL)
 600                                 si->prs_id = i;
 601                         return (0);
 602                 }
 603         }
 604         return (ENOENT);
 605 }
 606
 607 int
 608 proc_name2sym(struct proc_handle *p, const char *object, const char *symbol,
 609     GElf_Sym *symcopy, prsyminfo_t *si)
 610 {
 611         struct file_info *file;
 612         struct map_info *mapping;
 613         uintptr_t off;
 614         int error;
 615
 616         if ((mapping = _proc_name2map(p, object)) == NULL) {
 617                 DPRINTFX("ERROR: proc_name2map failed to resolve %s", object);
 618                 return (-1);
 619         }
 620         if (open_object(mapping) != 0) {
 621                 DPRINTFX("ERROR: failed to open object %s",
 622                     mapping->map.pr_mapname);
 623                 return (-1);
 624         }
 625
 626         file = mapping->file;
 627         off = file->ehdr.e_type == ET_DYN ?
 628             mapping->map.pr_vaddr - mapping->map.pr_offset : 0;
 629
 630         error = lookup_symbol_by_name(file->elf, &file->dynsymtab, symbol,
 631             symcopy, si);
 632         if (error == ENOENT)
 633                 error = lookup_symbol_by_name(file->elf, &file->symtab, symbol,
 634                     symcopy, si);
 635         if (error == 0)
 636                 symcopy->st_value += off;
 637         return (error);
 638 }
 639
 640 ctf_file_t *
 641 proc_name2ctf(struct proc_handle *p, const char *name)
 642 {
 643 #ifndef NO_CTF
 644         ctf_file_t *ctf;
 645         prmap_t *map;
 646         int error;
 647
 648         if ((map = proc_name2map(p, name)) == NULL)
 649                 return (NULL);
 650
 651         ctf = ctf_open(map->pr_mapname, &error);
 652         return (ctf);
 653 #else
 654         (void)p;
 655         (void)name;
 656         return (NULL);
 657 #endif
 658 }
 659
 660 int
 661 proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which,
 662     int mask, proc_sym_f *func, void *cd)
 663 {
 664         GElf_Sym sym;
 665         struct file_info *file;
 666         struct map_info *mapping;
 667         struct symtab *symtab;
 668         const char *s;
 669         int error, i;
 670
 671         if ((mapping = _proc_name2map(p, object)) == NULL) {
 672                 DPRINTFX("ERROR: proc_name2map failed to resolve %s", object);
 673                 return (-1);
 674         }
 675         if (open_object(mapping) != 0) {
 676                 DPRINTFX("ERROR: failed to open object %s",
 677                     mapping->map.pr_mapname);
 678                 return (-1);
 679         }
 680
 681         file = mapping->file;
 682         symtab = which == PR_SYMTAB ? &file->symtab : &file->dynsymtab;
 683         if (symtab->nsyms == 0)
 684                 return (-1);
 685
 686         error = 0;
 687         for (i = 0; gelf_getsym(symtab->data, i, &sym) != NULL; i++) {
 688                 if (GELF_ST_BIND(sym.st_info) == STB_LOCAL &&
 689                     (mask & BIND_LOCAL) == 0)
 690                         continue;
 691                 if (GELF_ST_BIND(sym.st_info) == STB_GLOBAL &&
 692                     (mask & BIND_GLOBAL) == 0)
 693                         continue;
 694                 if (GELF_ST_BIND(sym.st_info) == STB_WEAK &&
 695                     (mask & BIND_WEAK) == 0)
 696                         continue;
 697                 if (GELF_ST_TYPE(sym.st_info) == STT_NOTYPE &&
 698                     (mask & TYPE_NOTYPE) == 0)
 699                         continue;
 700                 if (GELF_ST_TYPE(sym.st_info) == STT_OBJECT &&
 701                     (mask & TYPE_OBJECT) == 0)
 702                         continue;
 703                 if (GELF_ST_TYPE(sym.st_info) == STT_FUNC &&
 704                     (mask & TYPE_FUNC) == 0)
 705                         continue;
 706                 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION &&
 707                     (mask & TYPE_SECTION) == 0)
 708                         continue;
 709                 if (GELF_ST_TYPE(sym.st_info) == STT_FILE &&
 710                     (mask & TYPE_FILE) == 0)
 711                         continue;
 712                 s = elf_strptr(file->elf, symtab->stridx, sym.st_name);
 713                 if (file->ehdr.e_type == ET_DYN)
 714                         sym.st_value += mapping->map.pr_vaddr;
 715                 if ((error = (*func)(cd, &sym, s)) != 0)
 716                         break;
 717         }
 718         return (error);
 719 }