Index: head/lib/libproc/_libproc.h =================================================================== --- head/lib/libproc/_libproc.h (revision 309595) +++ head/lib/libproc/_libproc.h (revision 309596) @@ -1,77 +1,89 @@ /*- * Copyright (c) 2008 John Birrell (jb@freebsd.org) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef __LIBPROC_H_ #define __LIBPROC_H_ #include #include #include #include #include "libproc.h" struct procstat; +struct symtab { + Elf_Data *data; + u_int nsyms; + u_int *index; + u_long stridx; +}; + struct file_info { Elf *elf; int fd; u_int refs; + GElf_Ehdr ehdr; + + /* Symbol tables, sorted by value. */ + struct symtab dynsymtab; + struct symtab symtab; }; struct map_info { prmap_t map; struct file_info *file; }; struct proc_handle { struct proc_handle_public public; /* Public fields. */ int flags; /* Process flags. */ int status; /* Process status (PS_*). */ int wstat; /* Process wait status. */ int model; /* Process data model. */ rd_agent_t *rdap; /* librtld_db agent */ struct map_info *mappings; /* File mappings for proc. */ size_t maparrsz; /* Map array size. */ size_t nmappings; /* Number of mappings. */ prmap_t *exec_map; /* Executable text mapping. */ lwpstatus_t lwps; /* Process status. */ struct procstat *procstat; /* libprocstat handle. */ char execpath[PATH_MAX]; /* Path to program executable. */ }; #ifdef DEBUG #define DPRINTF(...) warn(__VA_ARGS__) #define DPRINTFX(...) warnx(__VA_ARGS__) #else #define DPRINTF(...) do { } while (0) #define DPRINTFX(...) do { } while (0) #endif #endif /* __LIBPROC_H_ */ Index: head/lib/libproc/proc_create.c =================================================================== --- head/lib/libproc/proc_create.c (revision 309595) +++ head/lib/libproc/proc_create.c (revision 309596) @@ -1,253 +1,257 @@ /*- * Copyright (c) 2008 John Birrell (jb@freebsd.org) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include "_libproc.h" static int getelfclass(int); static int proc_init(pid_t, int, int, struct proc_handle **); static int getelfclass(int fd) { GElf_Ehdr ehdr; Elf *e; int class; class = ELFCLASSNONE; if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) goto out; if (gelf_getehdr(e, &ehdr) == NULL) goto out; class = ehdr.e_ident[EI_CLASS]; out: (void)elf_end(e); return (class); } static int proc_init(pid_t pid, int flags, int status, struct proc_handle **pphdl) { struct kinfo_proc *kp; struct proc_handle *phdl; int error, class, count, fd; error = ENOMEM; if ((phdl = malloc(sizeof(*phdl))) == NULL) goto out; memset(phdl, 0, sizeof(*phdl)); phdl->public.pid = pid; phdl->flags = flags; phdl->status = status; phdl->procstat = procstat_open_sysctl(); if (phdl->procstat == NULL) goto out; /* Obtain a path to the executable. */ if ((kp = procstat_getprocs(phdl->procstat, KERN_PROC_PID, pid, &count)) == NULL) goto out; error = procstat_getpathname(phdl->procstat, kp, phdl->execpath, sizeof(phdl->execpath)); procstat_freeprocs(phdl->procstat, kp); if (error != 0) goto out; /* Use it to determine the data model for the process. */ if ((fd = open(phdl->execpath, O_RDONLY)) < 0) { error = errno; goto out; } class = getelfclass(fd); switch (class) { case ELFCLASS64: phdl->model = PR_MODEL_LP64; break; case ELFCLASS32: phdl->model = PR_MODEL_ILP32; break; case ELFCLASSNONE: default: error = EINVAL; break; } (void)close(fd); out: *pphdl = phdl; return (error); } int proc_attach(pid_t pid, int flags, struct proc_handle **pphdl) { struct proc_handle *phdl; int error, status; if (pid == 0 || pid == getpid()) return (EINVAL); if (elf_version(EV_CURRENT) == EV_NONE) return (ENOENT); /* * Allocate memory for the process handle, a structure containing * all things related to the process. */ error = proc_init(pid, flags, PS_RUN, &phdl); if (error != 0) goto out; if (ptrace(PT_ATTACH, proc_getpid(phdl), 0, 0) != 0) { error = errno; DPRINTF("ERROR: cannot ptrace child process %d", pid); goto out; } /* Wait for the child process to stop. */ if (waitpid(pid, &status, WUNTRACED) == -1) { error = errno; DPRINTF("ERROR: child process %d didn't stop as expected", pid); goto out; } /* Check for an unexpected status. */ if (!WIFSTOPPED(status)) DPRINTFX("ERROR: child process %d status 0x%x", pid, status); else phdl->status = PS_STOP; out: if (error && phdl != NULL) { proc_free(phdl); phdl = NULL; } *pphdl = phdl; return (error); } int proc_create(const char *file, char * const *argv, proc_child_func *pcf, void *child_arg, struct proc_handle **pphdl) { struct proc_handle *phdl; int error = 0; int status; pid_t pid; if (elf_version(EV_CURRENT) == EV_NONE) return (ENOENT); /* Fork a new process. */ if ((pid = vfork()) == -1) error = errno; else if (pid == 0) { /* The child expects to be traced. */ if (ptrace(PT_TRACE_ME, 0, 0, 0) != 0) _exit(1); if (pcf != NULL) (*pcf)(child_arg); /* Execute the specified file: */ execvp(file, argv); /* Couldn't execute the file. */ _exit(2); /* NOTREACHED */ } else { /* The parent owns the process handle. */ error = proc_init(pid, 0, PS_IDLE, &phdl); if (error != 0) goto bad; /* Wait for the child process to stop. */ if (waitpid(pid, &status, WUNTRACED) == -1) { error = errno; DPRINTF("ERROR: child process %d didn't stop as expected", pid); goto bad; } /* Check for an unexpected status. */ if (!WIFSTOPPED(status)) { error = errno; DPRINTFX("ERROR: child process %d status 0x%x", pid, status); goto bad; } else phdl->status = PS_STOP; } bad: if (error && phdl != NULL) { proc_free(phdl); phdl = NULL; } *pphdl = phdl; return (error); } void proc_free(struct proc_handle *phdl) { struct file_info *file; size_t i; for (i = 0; i < phdl->nmappings; i++) { file = phdl->mappings[i].file; if (file != NULL && --file->refs == 0) { if (file->elf != NULL) { (void)elf_end(file->elf); (void)close(file->fd); + if (file->symtab.nsyms > 0) + free(file->symtab.index); + if (file->dynsymtab.nsyms > 0) + free(file->dynsymtab.index); } free(file); } } if (phdl->maparrsz > 0) free(phdl->mappings); if (phdl->procstat != NULL) procstat_close(phdl->procstat); if (phdl->rdap != NULL) rd_delete(phdl->rdap); free(phdl); } Index: head/lib/libproc/proc_sym.c =================================================================== --- head/lib/libproc/proc_sym.c (revision 309595) +++ head/lib/libproc/proc_sym.c (revision 309596) @@ -1,681 +1,658 @@ /*- * Copyright (c) 2016 Mark Johnston * Copyright (c) 2010 The FreeBSD Foundation * Copyright (c) 2008 John Birrell (jb@freebsd.org) * All rights reserved. * * Portions of this software were developed by Rui Paulo under sponsorship * from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #ifndef NO_CTF #include #include #endif #include #include #include #include #include #include #include #include #include #ifndef NO_CTF #include #endif #include #include "crc32.h" #include "_libproc.h" #define PATH_DEBUG_DIR "/usr/lib/debug" #ifdef NO_CTF typedef struct ctf_file ctf_file_t; #endif #ifndef NO_CXA_DEMANGLE extern char *__cxa_demangle(const char *, char *, size_t *, int *); #endif /* NO_CXA_DEMANGLE */ static int crc32_file(int fd, uint32_t *crc) { uint8_t buf[PAGE_SIZE], *p; size_t n; *crc = ~0; while ((n = read(fd, buf, sizeof(buf))) > 0) { p = &buf[0]; while (n-- > 0) *crc = crc32_tab[(*crc ^ *p++) & 0xff] ^ (*crc >> 8); } *crc = ~*crc; return (n); } static void demangle(const char *symbol, char *buf, size_t len) { #ifndef NO_CXA_DEMANGLE char *dembuf; if (symbol[0] == '_' && symbol[1] == 'Z' && symbol[2]) { dembuf = __cxa_demangle(symbol, NULL, NULL, NULL); if (!dembuf) goto fail; strlcpy(buf, dembuf, len); free(dembuf); return; } fail: #endif /* NO_CXA_DEMANGLE */ strlcpy(buf, symbol, len); } static int +symvalcomp(void *thunk, const void *a1, const void *a2) +{ + struct symtab *symtab; + GElf_Sym sym1, sym2; + u_int i1, i2; + int ret; + + i1 = *(const u_int *)a1; + i2 = *(const u_int *)a2; + symtab = thunk; + + (void)gelf_getsym(symtab->data, i1, &sym1); + (void)gelf_getsym(symtab->data, i2, &sym2); + if (sym1.st_value < sym2.st_value) + ret = -1; + else if (sym1.st_value == sym2.st_value) + ret = 0; + else + ret = 1; + return (ret); +} + +static int +load_symtab(Elf *e, struct symtab *symtab, u_long sh_type) +{ + GElf_Ehdr ehdr; + GElf_Shdr shdr; + Elf_Scn *scn; + u_int nsyms; + + if (gelf_getehdr(e, &ehdr) == NULL) + return (-1); + + scn = NULL; + while ((scn = elf_nextscn(e, scn)) != NULL) { + (void)gelf_getshdr(scn, &shdr); + if (shdr.sh_type == sh_type) + break; + } + if (scn == NULL) + return (-1); + + if ((symtab->data = elf_getdata(scn, NULL)) == NULL) + return (-1); + + nsyms = shdr.sh_size / shdr.sh_entsize; + + symtab->index = calloc(nsyms, sizeof(u_int)); + if (symtab->index == NULL) + return (-1); + for (u_int i = 0; i < nsyms; i++) + symtab->index[i] = i; + qsort_r(symtab->index, nsyms, sizeof(u_int), symtab, symvalcomp); + symtab->nsyms = nsyms; + symtab->stridx = shdr.sh_link; + return (0); +} + +static void +load_symtabs(struct file_info *file) +{ + + file->symtab.nsyms = file->dynsymtab.nsyms = 0; + (void)load_symtab(file->elf, &file->symtab, SHT_SYMTAB); + (void)load_symtab(file->elf, &file->dynsymtab, SHT_DYNSYM); +} + +static int open_debug_file(char *path, const char *debugfile, uint32_t crc) { size_t n; uint32_t compcrc; int fd; fd = -1; if ((n = strlcat(path, "/", PATH_MAX)) >= PATH_MAX) return (fd); if (strlcat(path, debugfile, PATH_MAX) >= PATH_MAX) goto out; if ((fd = open(path, O_RDONLY | O_CLOEXEC)) < 0) goto out; if (crc32_file(fd, &compcrc) != 0 || crc != compcrc) { DPRINTFX("ERROR: CRC32 mismatch for %s", path); (void)close(fd); fd = -1; } out: path[n] = '\0'; return (fd); } /* * Obtain an ELF descriptor for the specified mapped object. If a GNU debuglink * section is present, a descriptor for the corresponding debug file is * returned. */ static int open_object(struct map_info *mapping) { char path[PATH_MAX]; GElf_Shdr shdr; Elf *e, *e2; Elf_Data *data; Elf_Scn *scn; struct file_info *file; prmap_t *map; const char *debugfile, *scnname; size_t ndx; uint32_t crc; int fd, fd2; if (mapping->map.pr_mapname[0] == '\0') return (-1); /* anonymous object */ if (mapping->file->elf != NULL) return (0); /* already loaded */ file = mapping->file; map = &mapping->map; if ((fd = open(map->pr_mapname, O_RDONLY | O_CLOEXEC)) < 0) { DPRINTF("ERROR: open %s failed", map->pr_mapname); return (-1); } if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1)); goto err; } + if (gelf_getehdr(e, &file->ehdr) != &file->ehdr) { + DPRINTFX("ERROR: elf_getehdr() failed: %s", elf_errmsg(-1)); + goto err; + } scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &shdr) != &shdr) { DPRINTFX("ERROR: gelf_getshdr failed: %s", elf_errmsg(-1)); goto err; } if (shdr.sh_type != SHT_PROGBITS) continue; if (elf_getshdrstrndx(e, &ndx) != 0) { DPRINTFX("ERROR: elf_getshdrstrndx failed: %s", elf_errmsg(-1)); goto err; } if ((scnname = elf_strptr(e, ndx, shdr.sh_name)) == NULL) continue; if (strcmp(scnname, ".gnu_debuglink") == 0) break; } if (scn == NULL) goto internal; if ((data = elf_getdata(scn, NULL)) == NULL) { DPRINTFX("ERROR: elf_getdata failed: %s", elf_errmsg(-1)); goto err; } /* * The data contains a null-terminated file name followed by a 4-byte * CRC. */ if (data->d_size < sizeof(crc) + 1) { DPRINTFX("ERROR: debuglink section is too small (%zd bytes)", data->d_size); goto internal; } if (strnlen(data->d_buf, data->d_size) >= data->d_size - sizeof(crc)) { DPRINTFX("ERROR: no null-terminator in gnu_debuglink section"); goto internal; } debugfile = data->d_buf; memcpy(&crc, (char *)data->d_buf + data->d_size - sizeof(crc), sizeof(crc)); /* * Search for the debug file using the algorithm described in the gdb * documentation: * - look in the directory containing the object, * - look in the subdirectory ".debug" of the directory containing the * object, * - look in the global debug directories (currently /usr/lib/debug). */ (void)strlcpy(path, map->pr_mapname, sizeof(path)); (void)dirname(path); if ((fd2 = open_debug_file(path, debugfile, crc)) >= 0) goto external; if (strlcat(path, "/.debug", sizeof(path)) < sizeof(path) && (fd2 = open_debug_file(path, debugfile, crc)) >= 0) goto external; (void)snprintf(path, sizeof(path), PATH_DEBUG_DIR); if (strlcat(path, map->pr_mapname, sizeof(path)) < sizeof(path)) { (void)dirname(path); if ((fd2 = open_debug_file(path, debugfile, crc)) >= 0) goto external; } internal: /* We didn't find a debug file, just return the object's descriptor. */ file->elf = e; file->fd = fd; + load_symtabs(file); return (0); external: if ((e2 = elf_begin(fd2, ELF_C_READ, NULL)) == NULL) { DPRINTFX("ERROR: elf_begin failed: %s", elf_errmsg(-1)); (void)close(fd2); goto err; } (void)elf_end(e); (void)close(fd); file->elf = e2; file->fd = fd2; + load_symtabs(file); return (0); err: if (e != NULL) (void)elf_end(e); (void)close(fd); return (-1); } char * proc_objname(struct proc_handle *p, uintptr_t addr, char *objname, size_t objnamesz) { prmap_t *map; size_t i; for (i = 0; i < p->nmappings; i++) { map = &p->mappings[i].map; if (addr >= map->pr_vaddr && addr < map->pr_vaddr + map->pr_size) { strlcpy(objname, map->pr_mapname, objnamesz); return (objname); } } return (NULL); } int proc_iter_objs(struct proc_handle *p, proc_map_f *func, void *cd) { char last[MAXPATHLEN], path[MAXPATHLEN], *base; prmap_t *map; size_t i; int error; if (p->nmappings == 0) if (proc_rdagent(p) == NULL) return (-1); error = 0; memset(last, 0, sizeof(last)); for (i = 0; i < p->nmappings; i++) { map = &p->mappings[i].map; strlcpy(path, map->pr_mapname, sizeof(path)); base = basename(path); /* * We shouldn't call the callback twice with the same object. * To do that we are assuming the fact that if there are * repeated object names (i.e. different mappings for the * same object) they occur next to each other. */ if (strcmp(base, last) == 0) continue; if ((error = (*func)(cd, map, base)) != 0) break; strlcpy(last, path, sizeof(last)); } return (error); } static struct map_info * _proc_addr2map(struct proc_handle *p, uintptr_t addr) { struct map_info *mapping; size_t i; if (p->nmappings == 0) if (proc_rdagent(p) == NULL) return (NULL); for (i = 0; i < p->nmappings; i++) { mapping = &p->mappings[i]; if (addr >= mapping->map.pr_vaddr && addr < mapping->map.pr_vaddr + mapping->map.pr_size) return (mapping); } return (NULL); } prmap_t * proc_addr2map(struct proc_handle *p, uintptr_t addr) { return (&_proc_addr2map(p, addr)->map); } /* - * Look up the symbol at addr, returning a copy of the symbol and its name. + * Look up the symbol at addr using a binary search, returning a copy of the + * symbol and its name. */ static int -lookup_addr(Elf *e, Elf_Scn *scn, u_long stridx, uintptr_t off, uintptr_t addr, - const char **name, GElf_Sym *symcopy) +lookup_symbol_by_addr(Elf *elf, struct symtab *symtab, uintptr_t addr, + const char **namep, GElf_Sym *sym) { - GElf_Sym sym; Elf_Data *data; const char *s; - uint64_t rsym; - int i; + int min, max, mid; - if ((data = elf_getdata(scn, NULL)) == NULL) { - DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1)); - return (1); - } - for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { - rsym = off + sym.st_value; - if (addr >= rsym && addr < rsym + sym.st_size) { - s = elf_strptr(e, stridx, sym.st_name); - if (s != NULL) { - *name = s; - memcpy(symcopy, &sym, sizeof(*symcopy)); - /* - * DTrace expects the st_value to contain - * only the address relative to the start of - * the function. - */ - symcopy->st_value = rsym; - return (0); - } + data = symtab->data; + min = 0; + max = symtab->nsyms - 1; + + while (min <= max) { + mid = (max + min) / 2; + (void)gelf_getsym(data, symtab->index[mid], sym); + if (addr >= sym->st_value && + addr < sym->st_value + sym->st_size) { + s = elf_strptr(elf, symtab->stridx, sym->st_name); + if (s != NULL && namep != NULL) + *namep = s; + return (0); } + + if (addr < sym->st_value) + max = mid - 1; + else + min = mid + 1; } - return (1); + return (ENOENT); } int proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name, size_t namesz, GElf_Sym *symcopy) { - GElf_Ehdr ehdr; - GElf_Shdr shdr; - Elf *e; - Elf_Scn *scn, *dynsymscn, *symtabscn; + struct file_info *file; struct map_info *mapping; const char *s; uintptr_t off; - u_long symtabstridx, dynsymstridx; - int error = -1; + int error; if ((mapping = _proc_addr2map(p, addr)) == NULL) { DPRINTFX("ERROR: proc_addr2map failed to resolve 0x%jx", addr); return (-1); } if (open_object(mapping) != 0) { DPRINTFX("ERROR: failed to open object %s", mapping->map.pr_mapname); return (-1); } - e = mapping->file->elf; - if (gelf_getehdr(e, &ehdr) == NULL) { - DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1)); - goto err; - } - /* - * Find the index of the STRTAB and SYMTAB sections to locate - * symbol names. - */ - symtabstridx = dynsymstridx = 0; - scn = dynsymscn = symtabscn = NULL; - while ((scn = elf_nextscn(e, scn)) != NULL) { - gelf_getshdr(scn, &shdr); - switch (shdr.sh_type) { - case SHT_SYMTAB: - symtabscn = scn; - symtabstridx = shdr.sh_link; - break; - case SHT_DYNSYM: - dynsymscn = scn; - dynsymstridx = shdr.sh_link; - break; - } - } + file = mapping->file; + off = file->ehdr.e_type == ET_DYN ? mapping->map.pr_vaddr : 0; + if (addr < off) + return (ENOENT); + addr -= off; - off = ehdr.e_type == ET_EXEC ? 0 : mapping->map.pr_vaddr; - - /* - * First look up the symbol in the dynsymtab, and fall back to the - * symtab if the lookup fails. - */ - error = lookup_addr(e, dynsymscn, dynsymstridx, off, addr, &s, symcopy); - if (error == 0) - goto out; - - error = lookup_addr(e, symtabscn, symtabstridx, off, addr, &s, symcopy); - if (error != 0) - goto err; - -out: - demangle(s, name, namesz); -err: + error = lookup_symbol_by_addr(file->elf, &file->dynsymtab, addr, &s, + symcopy); + if (error == ENOENT) + error = lookup_symbol_by_addr(file->elf, &file->symtab, addr, + &s, symcopy); + if (error == 0) { + symcopy->st_value += off; + demangle(s, name, namesz); + } return (error); } static struct map_info * _proc_name2map(struct proc_handle *p, const char *name) { char path[MAXPATHLEN], *base; struct map_info *mapping; size_t i, len; if ((len = strlen(name)) == 0) return (NULL); if (p->nmappings == 0) if (proc_rdagent(p) == NULL) return (NULL); for (i = 0; i < p->nmappings; i++) { mapping = &p->mappings[i]; (void)strlcpy(path, mapping->map.pr_mapname, sizeof(path)); base = basename(path); if (strcmp(base, name) == 0) return (mapping); } /* If we didn't find a match, try matching prefixes of the basename. */ for (i = 0; i < p->nmappings; i++) { strlcpy(path, p->mappings[i].map.pr_mapname, sizeof(path)); base = basename(path); if (strncmp(base, name, len) == 0) return (&p->mappings[i]); } if (strcmp(name, "a.out") == 0) return (_proc_addr2map(p, p->exec_map->pr_vaddr)); return (NULL); } prmap_t * proc_name2map(struct proc_handle *p, const char *name) { return (&_proc_name2map(p, name)->map); } /* * Look up the symbol with the given name and return a copy of it. */ static int -lookup_name(Elf *e, Elf_Scn *scn, u_long stridx, const char *symbol, +lookup_symbol_by_name(Elf *elf, struct symtab *symtab, const char *symbol, GElf_Sym *symcopy, prsyminfo_t *si) { GElf_Sym sym; Elf_Data *data; char *s; int i; - if ((data = elf_getdata(scn, NULL)) == NULL) { - DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1)); - return (1); - } + if (symtab->nsyms == 0) + return (ENOENT); + data = symtab->data; for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { - s = elf_strptr(e, stridx, sym.st_name); + s = elf_strptr(elf, symtab->stridx, sym.st_name); if (s != NULL && strcmp(s, symbol) == 0) { memcpy(symcopy, &sym, sizeof(*symcopy)); if (si != NULL) si->prs_id = i; return (0); } } - return (1); + return (ENOENT); } int proc_name2sym(struct proc_handle *p, const char *object, const char *symbol, GElf_Sym *symcopy, prsyminfo_t *si) { - GElf_Ehdr ehdr; - GElf_Shdr shdr; - Elf *e; - Elf_Scn *scn, *dynsymscn, *symtabscn; + struct file_info *file; struct map_info *mapping; uintptr_t off; - u_long symtabstridx, dynsymstridx; - int error = -1; + int error; if ((mapping = _proc_name2map(p, object)) == NULL) { DPRINTFX("ERROR: proc_name2map failed to resolve %s", object); return (-1); } if (open_object(mapping) != 0) { DPRINTFX("ERROR: failed to open object %s", mapping->map.pr_mapname); return (-1); } - e = mapping->file->elf; - if (gelf_getehdr(e, &ehdr) == NULL) { - DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1)); - goto err; - } - /* - * Find the index of the STRTAB and SYMTAB sections to locate - * symbol names. - */ - symtabstridx = dynsymstridx = 0; - scn = dynsymscn = symtabscn = NULL; - while ((scn = elf_nextscn(e, scn)) != NULL) { - gelf_getshdr(scn, &shdr); - switch (shdr.sh_type) { - case SHT_SYMTAB: - symtabscn = scn; - symtabstridx = shdr.sh_link; - break; - case SHT_DYNSYM: - dynsymscn = scn; - dynsymstridx = shdr.sh_link; - break; - } - } + file = mapping->file; + off = file->ehdr.e_type == ET_DYN ? mapping->map.pr_vaddr : 0; - /* - * First look up the symbol in the dynsymtab, and fall back to the - * symtab if the lookup fails. - */ - error = lookup_name(e, dynsymscn, dynsymstridx, symbol, symcopy, si); + error = lookup_symbol_by_name(file->elf, &file->dynsymtab, symbol, + symcopy, si); + if (error == ENOENT) + error = lookup_symbol_by_name(file->elf, &file->symtab, symbol, + symcopy, si); if (error == 0) - goto out; - - error = lookup_name(e, symtabscn, symtabstridx, symbol, symcopy, si); - if (error == 0) - goto out; - -out: - off = ehdr.e_type == ET_EXEC ? 0 : mapping->map.pr_vaddr; - symcopy->st_value += off; - -err: + symcopy->st_value += off; return (error); } ctf_file_t * proc_name2ctf(struct proc_handle *p, const char *name) { #ifndef NO_CTF ctf_file_t *ctf; prmap_t *map; int error; if ((map = proc_name2map(p, name)) == NULL) return (NULL); ctf = ctf_open(map->pr_mapname, &error); return (ctf); #else (void)p; (void)name; return (NULL); #endif } int proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which, int mask, proc_sym_f *func, void *cd) { - GElf_Ehdr ehdr; - GElf_Shdr shdr; GElf_Sym sym; - Elf *e; - Elf_Scn *scn, *foundscn; - Elf_Data *data; + struct file_info *file; struct map_info *mapping; - char *s; - unsigned long stridx = -1; - int error = -1, i; + struct symtab *symtab; + const char *s; + int error, i; if ((mapping = _proc_name2map(p, object)) == NULL) { DPRINTFX("ERROR: proc_name2map failed to resolve %s", object); return (-1); } if (open_object(mapping) != 0) { DPRINTFX("ERROR: failed to open object %s", mapping->map.pr_mapname); return (-1); } - e = mapping->file->elf; - if (gelf_getehdr(e, &ehdr) == NULL) { - DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1)); - goto err; - } - /* - * Find the section we are looking for. - */ - foundscn = scn = NULL; - while ((scn = elf_nextscn(e, scn)) != NULL) { - gelf_getshdr(scn, &shdr); - if (which == PR_SYMTAB && - shdr.sh_type == SHT_SYMTAB) { - foundscn = scn; - break; - } else if (which == PR_DYNSYM && - shdr.sh_type == SHT_DYNSYM) { - foundscn = scn; - break; - } - } - if (!foundscn) + + file = mapping->file; + symtab = which == PR_SYMTAB ? &file->symtab : &file->dynsymtab; + if (symtab->nsyms == 0) return (-1); - stridx = shdr.sh_link; - if ((data = elf_getdata(foundscn, NULL)) == NULL) { - DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1)); - goto err; - } - for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { + + error = 0; + for (i = 0; gelf_getsym(symtab->data, i, &sym) != NULL; i++) { if (GELF_ST_BIND(sym.st_info) == STB_LOCAL && (mask & BIND_LOCAL) == 0) continue; if (GELF_ST_BIND(sym.st_info) == STB_GLOBAL && (mask & BIND_GLOBAL) == 0) continue; if (GELF_ST_BIND(sym.st_info) == STB_WEAK && (mask & BIND_WEAK) == 0) continue; if (GELF_ST_TYPE(sym.st_info) == STT_NOTYPE && (mask & TYPE_NOTYPE) == 0) continue; if (GELF_ST_TYPE(sym.st_info) == STT_OBJECT && (mask & TYPE_OBJECT) == 0) continue; if (GELF_ST_TYPE(sym.st_info) == STT_FUNC && (mask & TYPE_FUNC) == 0) continue; if (GELF_ST_TYPE(sym.st_info) == STT_SECTION && (mask & TYPE_SECTION) == 0) continue; if (GELF_ST_TYPE(sym.st_info) == STT_FILE && (mask & TYPE_FILE) == 0) continue; - s = elf_strptr(e, stridx, sym.st_name); - if (ehdr.e_type != ET_EXEC) + s = elf_strptr(file->elf, symtab->stridx, sym.st_name); + if (file->ehdr.e_type == ET_DYN) sym.st_value += mapping->map.pr_vaddr; if ((error = (*func)(cd, &sym, s)) != 0) - goto err; + break; } - error = 0; -err: return (error); }