Index: head/cddl/lib/libdtrace/libproc_compat.h =================================================================== --- head/cddl/lib/libdtrace/libproc_compat.h (revision 309594) +++ head/cddl/lib/libdtrace/libproc_compat.h (revision 309595) @@ -1,64 +1,64 @@ /* * Copyright (c) 2010 The FreeBSD Foundation * All rights reserved. * * This software was 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. * * $FreeBSD$ */ /* * Compatibility functions between Solaris libproc and FreeBSD libproc. * Functions sorted alphabetically. */ #define PR_LMID_EVERY 0 #define Psetrun(p, a1, a2) proc_continue((p)) #define Pxlookup_by_addr(p, a, n, s, sym, i) \ proc_addr2sym(p, a, n, s, sym) #define Pxlookup_by_name(p, l, s1, s2, sym, a) \ proc_name2sym(p, s1, s2, sym, a) #define Paddr_to_map proc_addr2map #define Pcreate_error strerror #define Pdelbkpt proc_bkptdel #define Pgrab_error strerror #define Plmid(p, a, l) (-1) -#define Plmid_to_map(p, l, o) proc_obj2map((p), (o)) +#define Plmid_to_map(p, l, o) proc_name2map(p, o) #define Plookup_by_addr proc_addr2sym #define Pname_to_ctf(p, obj) (ctf_file_t *)proc_name2ctf(p, obj) #define Pname_to_map proc_name2map #define Pobject_iter proc_iter_objs #define Pobject_iter_resolved(p, f, arg) proc_iter_objs(p, f, arg) #define Pobjname proc_objname #define Pread proc_read #define Prd_agent proc_rdagent #define Prelease proc_detach #define Psetbkpt proc_bkptset #define Psetflags proc_setflags #define Pstate proc_state #define Psymbol_iter_by_addr proc_iter_symbyaddr #define Punsetflags proc_clearflags #define Pupdate_maps proc_rdagent #define Pupdate_syms proc_updatesyms #define Pxecbkpt proc_bkptexec Index: head/lib/libproc/libproc.h =================================================================== --- head/lib/libproc/libproc.h (revision 309594) +++ head/lib/libproc/libproc.h (revision 309595) @@ -1,166 +1,165 @@ /*- * 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. * * $FreeBSD$ */ #ifndef _LIBPROC_H_ #define _LIBPROC_H_ #include #include #include struct ctf_file; struct proc_handle; typedef void (*proc_child_func)(void *); /* Values returned by proc_state(). */ #define PS_IDLE 1 #define PS_STOP 2 #define PS_RUN 3 #define PS_UNDEAD 4 #define PS_DEAD 5 #define PS_LOST 6 /* Reason values for proc_detach(). */ #define PRELEASE_HANG 1 #define PRELEASE_KILL 2 typedef struct prmap { uintptr_t pr_vaddr; /* Virtual address. */ size_t pr_size; /* Mapping size in bytes */ size_t pr_offset; /* Mapping offset in object */ char pr_mapname[PATH_MAX]; /* Mapping filename */ uint8_t pr_mflags; /* Protection flags */ #define MA_READ 0x01 #define MA_WRITE 0x02 #define MA_EXEC 0x04 #define MA_COW 0x08 #define MA_NEEDS_COPY 0x10 #define MA_NOCOREDUMP 0x20 } prmap_t; typedef struct prsyminfo { u_int prs_lmid; /* Map id. */ u_int prs_id; /* Symbol id. */ } prsyminfo_t; typedef int proc_map_f(void *, const prmap_t *, const char *); typedef int proc_sym_f(void *, const GElf_Sym *, const char *); /* Values for ELF sections */ #define PR_SYMTAB 1 #define PR_DYNSYM 2 /* Values for the 'mask' parameter in the iteration functions */ #define BIND_LOCAL 0x0001 #define BIND_GLOBAL 0x0002 #define BIND_WEAK 0x0004 #define BIND_ANY (BIND_LOCAL|BIND_GLOBAL|BIND_WEAK) #define TYPE_NOTYPE 0x0100 #define TYPE_OBJECT 0x0200 #define TYPE_FUNC 0x0400 #define TYPE_SECTION 0x0800 #define TYPE_FILE 0x1000 #define TYPE_ANY (TYPE_NOTYPE|TYPE_OBJECT|TYPE_FUNC|TYPE_SECTION|\ TYPE_FILE) typedef enum { REG_PC, REG_SP, REG_RVAL1, REG_RVAL2 } proc_reg_t; #define SIG2STR_MAX 8 typedef struct lwpstatus { int pr_why; #define PR_REQUESTED 1 #define PR_FAULTED 2 #define PR_SYSENTRY 3 #define PR_SYSEXIT 4 #define PR_SIGNALLED 5 int pr_what; #define FLTBPT -1 } lwpstatus_t; #define PR_MODEL_ILP32 1 #define PR_MODEL_LP64 2 struct proc_handle_public { pid_t pid; }; #define proc_getpid(phdl) (((struct proc_handle_public *)(phdl))->pid) /* Function prototype definitions. */ __BEGIN_DECLS prmap_t *proc_addr2map(struct proc_handle *, uintptr_t); prmap_t *proc_name2map(struct proc_handle *, const char *); char *proc_objname(struct proc_handle *, uintptr_t, char *, size_t); -prmap_t *proc_obj2map(struct proc_handle *, const char *); int proc_iter_objs(struct proc_handle *, proc_map_f *, void *); int proc_iter_symbyaddr(struct proc_handle *, const char *, int, int, proc_sym_f *, void *); int proc_addr2sym(struct proc_handle *, uintptr_t, char *, size_t, GElf_Sym *); int proc_attach(pid_t pid, int flags, struct proc_handle **pphdl); int proc_continue(struct proc_handle *); int proc_clearflags(struct proc_handle *, int); int proc_create(const char *, char * const *, proc_child_func *, void *, struct proc_handle **); int proc_detach(struct proc_handle *, int); int proc_getflags(struct proc_handle *); int proc_name2sym(struct proc_handle *, const char *, const char *, GElf_Sym *, prsyminfo_t *); struct ctf_file *proc_name2ctf(struct proc_handle *, const char *); int proc_setflags(struct proc_handle *, int); int proc_state(struct proc_handle *); int proc_getmodel(struct proc_handle *); int proc_wstatus(struct proc_handle *); int proc_getwstat(struct proc_handle *); char * proc_signame(int, char *, size_t); int proc_read(struct proc_handle *, void *, size_t, size_t); const lwpstatus_t *proc_getlwpstatus(struct proc_handle *); void proc_free(struct proc_handle *); rd_agent_t *proc_rdagent(struct proc_handle *); void proc_updatesyms(struct proc_handle *); int proc_bkptset(struct proc_handle *, uintptr_t, unsigned long *); int proc_bkptdel(struct proc_handle *, uintptr_t, unsigned long); void proc_bkptregadj(unsigned long *); int proc_bkptexec(struct proc_handle *, unsigned long); int proc_regget(struct proc_handle *, proc_reg_t, unsigned long *); int proc_regset(struct proc_handle *, proc_reg_t, unsigned long); __END_DECLS #endif /* _LIBPROC_H_ */ Index: head/lib/libproc/proc_sym.c =================================================================== --- head/lib/libproc/proc_sym.c (revision 309594) +++ head/lib/libproc/proc_sym.c (revision 309595) @@ -1,700 +1,681 @@ /*- * 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 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; } 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; 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; 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); } -/* - * Currently just returns the first mapping of the named object, effectively - * what Plmid_to_map(p, PR_LMID_EVERY, objname) does in illumos libproc. - */ -prmap_t * -proc_obj2map(struct proc_handle *p, const char *objname) -{ - char path[PATH_MAX], *base; - prmap_t *map; - size_t i; - - map = NULL; - for (i = 0; i < p->nmappings; i++) { - strlcpy(path, p->mappings[i].map.pr_mapname, sizeof(path)); - base = basename(path); - if (strcmp(base, objname) == 0) { - map = &p->mappings[i].map; - break; - } - } - if (map == NULL && strcmp(objname, "a.out") == 0 && p->exec_map != NULL) - map = p->exec_map; - return (map); -} - 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. */ static int lookup_addr(Elf *e, Elf_Scn *scn, u_long stridx, uintptr_t off, uintptr_t addr, const char **name, GElf_Sym *symcopy) { GElf_Sym sym; Elf_Data *data; const char *s; uint64_t rsym; int i; 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); } } } return (1); } 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 map_info *mapping; const char *s; uintptr_t off; u_long symtabstridx, dynsymstridx; int error = -1; 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; } } 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: 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; + size_t i, len; - mapping = NULL; + 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) - break; + return (mapping); } - if (i == p->nmappings) - mapping = NULL; - if (mapping == NULL && strcmp(name, "a.out") == 0) - mapping = _proc_addr2map(p, p->exec_map->pr_vaddr); - 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, 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); } for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) { s = elf_strptr(e, 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); } 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 map_info *mapping; uintptr_t off; u_long symtabstridx, dynsymstridx; int error = -1; 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; } } /* * 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); 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: 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 map_info *mapping; char *s; unsigned long stridx = -1; int error = -1, 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) 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++) { 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) sym.st_value += mapping->map.pr_vaddr; if ((error = (*func)(cd, &sym, s)) != 0) goto err; } error = 0; err: return (error); } Index: head/lib/libproc/tests/proc_test.c =================================================================== --- head/lib/libproc/tests/proc_test.c (revision 309594) +++ head/lib/libproc/tests/proc_test.c (revision 309595) @@ -1,387 +1,384 @@ /*- - * Copyright (c) 2014, 2015 Mark Johnston + * Copyright (c) 2014-2016 Mark Johnston * 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 static const char *aout_object = "a.out"; static const char *ldelf_object = "ld-elf.so.1"; static const char *target_prog_file = "target_prog"; /* * Run the test program. If the sig parameter is set to true, the test program * will deliver SIGUSR1 to itself during execution. */ static struct proc_handle * start_prog(const struct atf_tc *tc, bool sig) { char *argv[3]; struct proc_handle *phdl; int error; asprintf(&argv[0], "%s/%s", atf_tc_get_config_var(tc, "srcdir"), target_prog_file); ATF_REQUIRE(argv[0] != NULL); if (sig) { argv[1] = strdup("-s"); argv[2] = NULL; } else { argv[1] = NULL; } error = proc_create(argv[0], argv, NULL, NULL, &phdl); ATF_REQUIRE_EQ_MSG(error, 0, "failed to run '%s'", target_prog_file); ATF_REQUIRE(phdl != NULL); free(argv[0]); free(argv[1]); return (phdl); } static void set_bkpt(struct proc_handle *phdl, uintptr_t addr, u_long *saved) { int error; error = proc_bkptset(phdl, addr, saved); ATF_REQUIRE_EQ_MSG(error, 0, "failed to set breakpoint at 0x%jx", (uintmax_t)addr); } static void remove_bkpt(struct proc_handle *phdl, uintptr_t addr, u_long val) { int error; error = proc_bkptdel(phdl, addr, val); ATF_REQUIRE_EQ_MSG(error, 0, "failed to delete breakpoint at 0x%jx", (uintmax_t)addr); error = proc_regset(phdl, REG_PC, addr); ATF_REQUIRE_EQ_MSG(error, 0, "failed to reset program counter"); } /* * Wait for the specified process to hit a breakpoint at the specified symbol. */ static void verify_bkpt(struct proc_handle *phdl, GElf_Sym *sym, const char *symname, const char *mapname) { char mapbname[MAXPATHLEN], *name; GElf_Sym tsym; prmap_t *map; size_t namesz; u_long addr; int error, state; state = proc_wstatus(phdl); ATF_REQUIRE_EQ_MSG(state, PS_STOP, "process has state %d", state); /* Get the program counter and decrement it. */ error = proc_regget(phdl, REG_PC, &addr); ATF_REQUIRE_EQ_MSG(error, 0, "failed to obtain PC for '%s'", target_prog_file); proc_bkptregadj(&addr); /* * Make sure the PC matches the expected value obtained from the symbol * definition we looked up earlier. */ ATF_CHECK_EQ_MSG(addr, sym->st_value, "program counter 0x%lx doesn't match expected value 0x%jx", addr, (uintmax_t)sym->st_value); /* * Ensure we can look up the r_debug_state symbol using its starting * address and that the resulting symbol matches the one we found using * a name lookup. */ namesz = strlen(symname) + 1; name = malloc(namesz); ATF_REQUIRE(name != NULL); error = proc_addr2sym(phdl, addr, name, namesz, &tsym); ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up symbol at 0x%lx", addr); ATF_REQUIRE_EQ(memcmp(sym, &tsym, sizeof(*sym)), 0); ATF_REQUIRE_EQ(strcmp(symname, name), 0); free(name); map = proc_addr2map(phdl, addr); ATF_REQUIRE_MSG(map != NULL, "failed to look up map for address 0x%lx", addr); basename_r(map->pr_mapname, mapbname); ATF_REQUIRE_EQ_MSG(strcmp(mapname, mapbname), 0, "expected map name '%s' doesn't match '%s'", mapname, mapbname); } -ATF_TC(map_alias_obj2map); -ATF_TC_HEAD(map_alias_obj2map, tc) +ATF_TC(map_alias_name2map); +ATF_TC_HEAD(map_alias_name2map, tc) { atf_tc_set_md_var(tc, "descr", "Callers are supposed to be able to use \"a.out\" as an alias for " - "the program executable. Make sure that proc_obj2map() handles " + "the program executable. Make sure that proc_name2map() handles " "this properly."); } -ATF_TC_BODY(map_alias_obj2map, tc) +ATF_TC_BODY(map_alias_name2map, tc) { struct proc_handle *phdl; prmap_t *map1, *map2; phdl = start_prog(tc, false); /* Initialize the rtld_db handle. */ (void)proc_rdagent(phdl); /* Ensure that "target_prog" and "a.out" return the same map. */ - map1 = proc_obj2map(phdl, target_prog_file); + map1 = proc_name2map(phdl, target_prog_file); ATF_REQUIRE_MSG(map1 != NULL, "failed to look up map for '%s'", target_prog_file); - map2 = proc_obj2map(phdl, aout_object); + map2 = proc_name2map(phdl, aout_object); ATF_REQUIRE_MSG(map2 != NULL, "failed to look up map for '%s'", aout_object); ATF_CHECK_EQ(strcmp(map1->pr_mapname, map2->pr_mapname), 0); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); proc_free(phdl); } -ATF_TC(map_alias_name2map); -ATF_TC_HEAD(map_alias_name2map, tc) +ATF_TC(map_prefix_name2map); +ATF_TC_HEAD(map_prefix_name2map, tc) { atf_tc_set_md_var(tc, "descr", - "Callers are supposed to be able to use \"a.out\" as an alias for " - "the program executable. Make sure that proc_name2map() handles " - "this properly."); + "Verify that proc_name2map() returns prefix matches of the " + "basename of loaded objects if no full matches are found."); } -ATF_TC_BODY(map_alias_name2map, tc) +ATF_TC_BODY(map_prefix_name2map, tc) { struct proc_handle *phdl; prmap_t *map1, *map2; phdl = start_prog(tc, false); /* Initialize the rtld_db handle. */ (void)proc_rdagent(phdl); - /* Ensure that "target_prog" and "a.out" return the same map. */ - map1 = proc_name2map(phdl, target_prog_file); - ATF_REQUIRE_MSG(map1 != NULL, "failed to look up map for '%s'", - target_prog_file); - map2 = proc_name2map(phdl, aout_object); - ATF_REQUIRE_MSG(map2 != NULL, "failed to look up map for '%s'", - aout_object); + /* Make sure that "ld-elf" and "ld-elf.so" return the same map. */ + map1 = proc_name2map(phdl, "ld-elf"); + ATF_REQUIRE_MSG(map1 != NULL, "failed to look up map for 'ld-elf'"); + map2 = proc_name2map(phdl, "ld-elf.so"); + ATF_REQUIRE_MSG(map2 != NULL, "failed to look up map for 'ld-elf.so'"); ATF_CHECK_EQ(strcmp(map1->pr_mapname, map2->pr_mapname), 0); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); proc_free(phdl); } ATF_TC(map_alias_name2sym); ATF_TC_HEAD(map_alias_name2sym, tc) { atf_tc_set_md_var(tc, "descr", "Callers are supposed to be able to use \"a.out\" as an alias for " "the program executable. Make sure that proc_name2sym() handles " "this properly."); } ATF_TC_BODY(map_alias_name2sym, tc) { GElf_Sym sym1, sym2; prsyminfo_t si1, si2; struct proc_handle *phdl; int error; phdl = start_prog(tc, false); /* Initialize the rtld_db handle. */ (void)proc_rdagent(phdl); /* * Make sure that "target_prog:main" and "a.out:main" return the same * symbol. */ error = proc_name2sym(phdl, target_prog_file, "main", &sym1, &si1); ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'main' via %s", target_prog_file); error = proc_name2sym(phdl, aout_object, "main", &sym2, &si2); ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'main' via %s", aout_object); ATF_CHECK_EQ(memcmp(&sym1, &sym2, sizeof(sym1)), 0); ATF_CHECK_EQ(si1.prs_id, si2.prs_id); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); proc_free(phdl); } ATF_TC(symbol_lookup); ATF_TC_HEAD(symbol_lookup, tc) { atf_tc_set_md_var(tc, "descr", "Look up a couple of well-known symbols in the test program, place " "breakpoints on them, and verify that we hit the breakpoints. Also " "make sure that we can use the breakpoint address to look up the " "corresponding symbol."); } ATF_TC_BODY(symbol_lookup, tc) { GElf_Sym main_sym, r_debug_state_sym; struct proc_handle *phdl; u_long saved; int error; phdl = start_prog(tc, false); error = proc_name2sym(phdl, target_prog_file, "main", &main_sym, NULL); ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'main'"); error = proc_name2sym(phdl, ldelf_object, "r_debug_state", &r_debug_state_sym, NULL); ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'r_debug_state'"); set_bkpt(phdl, r_debug_state_sym.st_value, &saved); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); verify_bkpt(phdl, &r_debug_state_sym, "r_debug_state", ldelf_object); remove_bkpt(phdl, r_debug_state_sym.st_value, saved); set_bkpt(phdl, main_sym.st_value, &saved); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); verify_bkpt(phdl, &main_sym, "main", target_prog_file); remove_bkpt(phdl, main_sym.st_value, saved); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); proc_free(phdl); } ATF_TC(symbol_lookup_fail); ATF_TC_HEAD(symbol_lookup_fail, tc) { atf_tc_set_md_var(tc, "descr", "Verify that proc_addr2sym() returns an error when given an offset " "that it cannot resolve."); } ATF_TC_BODY(symbol_lookup_fail, tc) { char symname[32]; GElf_Sym sym; struct proc_handle *phdl; prmap_t *map; int error; phdl = start_prog(tc, false); /* Initialize the rtld_db handle. */ (void)proc_rdagent(phdl); - map = proc_obj2map(phdl, target_prog_file); + map = proc_name2map(phdl, target_prog_file); ATF_REQUIRE_MSG(map != NULL, "failed to look up map for '%s'", target_prog_file); /* * We shouldn't be able to find symbols at the beginning of a mapped * file. */ error = proc_addr2sym(phdl, map->pr_vaddr, symname, sizeof(symname), &sym); ATF_REQUIRE_MSG(error != 0, "unexpectedly found a symbol"); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); proc_free(phdl); } ATF_TC(signal_forward); ATF_TC_HEAD(signal_forward, tc) { atf_tc_set_md_var(tc, "descr", "Run the test program in a mode which causes it to send a signal " "to itself. Make sure that we intercept the signal and that " "proc_continue() forwards it to the process."); } ATF_TC_BODY(signal_forward, tc) { struct proc_handle *phdl; int state, status; phdl = start_prog(tc, true); ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); /* The process should have been interrupted by a signal. */ state = proc_wstatus(phdl); ATF_REQUIRE_EQ_MSG(state, PS_STOP, "process has unexpected state %d", state); /* Continue execution and allow the signal to be delivered. */ ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution"); /* * Make sure the process exited with status 0. If it didn't receive the * SIGUSR1 that it sent to itself, it'll exit with a non-zero exit * status, causing the test to fail. */ state = proc_wstatus(phdl); ATF_REQUIRE_EQ_MSG(state, PS_UNDEAD, "process has unexpected state %d", state); status = proc_getwstat(phdl); ATF_REQUIRE(status >= 0); ATF_REQUIRE(WIFEXITED(status)); ATF_REQUIRE_EQ(WEXITSTATUS(status), 0); proc_free(phdl); } ATF_TP_ADD_TCS(tp) { - ATF_TP_ADD_TC(tp, map_alias_obj2map); ATF_TP_ADD_TC(tp, map_alias_name2map); + ATF_TP_ADD_TC(tp, map_prefix_name2map); ATF_TP_ADD_TC(tp, map_alias_name2sym); ATF_TP_ADD_TC(tp, symbol_lookup); ATF_TP_ADD_TC(tp, symbol_lookup_fail); ATF_TP_ADD_TC(tp, signal_forward); return (atf_no_error()); }