diff options
Diffstat (limited to 'lib/libproc/proc_sym.c')
| -rw-r--r-- | lib/libproc/proc_sym.c | 714 |
1 files changed, 714 insertions, 0 deletions
diff --git a/lib/libproc/proc_sym.c b/lib/libproc/proc_sym.c new file mode 100644 index 000000000000..be932b12a24f --- /dev/null +++ b/lib/libproc/proc_sym.c @@ -0,0 +1,714 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2016-2017 Mark Johnston <markj@FreeBSD.org> + * 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 <sys/types.h> +#ifndef NO_CTF +#include <sys/ctf.h> +#include <sys/ctf_api.h> +#endif +#include <sys/user.h> + +#include <assert.h> +#include <err.h> +#include <fcntl.h> +#include <libgen.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#ifndef NO_CTF +#include <libctf.h> +#endif +#include <libutil.h> + +#include <zlib.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) +{ + char buf[MAXPHYS]; + ssize_t nr; + + *crc = crc32(0L, Z_NULL, 0); + while ((nr = read(fd, buf, sizeof(buf))) > 0) { + *crc = crc32(*crc, (char *)buf, nr); + } + return (!!nr); +} + +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); +} + +struct symsort_thunk { + Elf *e; + struct symtab *symtab; +}; + +static int +symvalcmp(const void *a1, const void *a2, void *_thunk) +{ + GElf_Sym sym1, sym2; + struct symsort_thunk *thunk; + const char *s1, *s2; + u_int i1, i2; + int bind1, bind2; + + i1 = *(const u_int *)a1; + i2 = *(const u_int *)a2; + thunk = _thunk; + + (void)gelf_getsym(thunk->symtab->data, i1, &sym1); + (void)gelf_getsym(thunk->symtab->data, i2, &sym2); + + if (sym1.st_value != sym2.st_value) + return (sym1.st_value < sym2.st_value ? -1 : 1); + + /* Prefer non-local symbols. */ + bind1 = GELF_ST_BIND(sym1.st_info); + bind2 = GELF_ST_BIND(sym2.st_info); + if (bind1 != bind2) { + if (bind1 == STB_LOCAL && bind2 != STB_LOCAL) + return (-1); + if (bind1 != STB_LOCAL && bind2 == STB_LOCAL) + return (1); + } + + s1 = elf_strptr(thunk->e, thunk->symtab->stridx, sym1.st_name); + s2 = elf_strptr(thunk->e, thunk->symtab->stridx, sym2.st_name); + if (s1 != NULL && s2 != NULL) { + /* Prefer symbols without a leading '$'. */ + if (*s1 == '$') + return (-1); + if (*s2 == '$') + return (1); + + /* Prefer symbols with fewer leading underscores. */ + for (; *s1 == '_' && *s2 == '_'; s1++, s2++) + ; + if (*s1 == '_') + return (-1); + if (*s2 == '_') + return (1); + } + + return (0); +} + +static int +load_symtab(Elf *e, struct symtab *symtab, u_long sh_type) +{ + GElf_Ehdr ehdr; + GElf_Shdr shdr; + struct symsort_thunk thunk; + 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); + + nsyms = shdr.sh_size / shdr.sh_entsize; + if (nsyms > (1 << 20)) + return (-1); + + if ((symtab->data = elf_getdata(scn, NULL)) == NULL) + return (-1); + + 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; + symtab->nsyms = nsyms; + symtab->stridx = shdr.sh_link; + + thunk.e = e; + thunk.symtab = symtab; + qsort_r(symtab->index, nsyms, sizeof(u_int), symvalcmp, &thunk); + + 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)", + (ssize_t)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; + + if (p->nmappings == 0) + if (proc_rdagent(p) == NULL) + return (NULL); + 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 using a binary search, returning a copy of the + * symbol and its name. + */ +static int +lookup_symbol_by_addr(Elf *e, struct symtab *symtab, uintptr_t addr, + const char **namep, GElf_Sym *symp) +{ + GElf_Sym sym; + Elf_Data *data; + const char *s; + u_int i, min, max, mid; + + if (symtab->nsyms == 0) + return (ENOENT); + + 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) + break; + + if (addr < sym.st_value) + max = mid - 1; + else + min = mid + 1; + } + if (min > max) + return (ENOENT); + + /* + * Advance until we find the matching symbol with largest index. + */ + for (i = mid; i < symtab->nsyms; i++) { + (void)gelf_getsym(data, symtab->index[i], &sym); + if (addr < sym.st_value || addr >= sym.st_value + sym.st_size) + break; + } + (void)gelf_getsym(data, symtab->index[i - 1], symp); + s = elf_strptr(e, symtab->stridx, symp->st_name); + if (s != NULL && namep != NULL) + *namep = s; + return (0); +} + +int +proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name, + size_t namesz, GElf_Sym *symcopy) +{ + struct file_info *file; + struct map_info *mapping; + const char *s; + uintptr_t off; + int error; + + if ((mapping = _proc_addr2map(p, addr)) == NULL) { + DPRINTFX("ERROR: proc_addr2map failed to resolve 0x%jx", (uintmax_t)addr); + return (-1); + } + if (open_object(mapping) != 0) { + DPRINTFX("ERROR: failed to open object %s", + mapping->map.pr_mapname); + return (-1); + } + + file = mapping->file; + off = file->ehdr.e_type == ET_DYN ? + mapping->map.pr_vaddr - mapping->map.pr_offset : 0; + if (addr < off) + return (ENOENT); + addr -= off; + + 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++) { + mapping = &p->mappings[i]; + strlcpy(path, mapping->map.pr_mapname, sizeof(path)); + base = basename(path); + if (strncmp(base, name, len) == 0) + return (mapping); + } + if (strcmp(name, "a.out") == 0) + return (_proc_addr2map(p, + p->mappings[p->exec_map].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_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 (symtab->nsyms == 0) + return (ENOENT); + data = symtab->data; + for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { + 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 (ENOENT); +} + +int +proc_name2sym(struct proc_handle *p, const char *object, const char *symbol, + GElf_Sym *symcopy, prsyminfo_t *si) +{ + struct file_info *file; + struct map_info *mapping; + uintptr_t off; + 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); + } + + file = mapping->file; + off = file->ehdr.e_type == ET_DYN ? + mapping->map.pr_vaddr - mapping->map.pr_offset : 0; + + 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) + 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_Sym sym; + struct file_info *file; + struct map_info *mapping; + 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); + } + + file = mapping->file; + symtab = which == PR_SYMTAB ? &file->symtab : &file->dynsymtab; + if (symtab->nsyms == 0) + return (-1); + + 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(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) + break; + } + return (error); +} |