2008-05-22 02:09:21 +00:00
|
|
|
/*-
|
2016-12-06 04:19:08 +00:00
|
|
|
* Copyright (c) 2016 Mark Johnston <markj@FreeBSD.org>
|
2010-07-31 16:10:20 +00:00
|
|
|
* Copyright (c) 2010 The FreeBSD Foundation
|
2008-05-22 02:09:21 +00:00
|
|
|
* Copyright (c) 2008 John Birrell (jb@freebsd.org)
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
2010-07-31 16:10:20 +00:00
|
|
|
* Portions of this software were developed by Rui Paulo under sponsorship
|
|
|
|
* from the FreeBSD Foundation.
|
|
|
|
*
|
2008-05-22 02:09:21 +00:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2014-09-25 19:08:06 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
#include <sys/types.h>
|
2014-10-03 23:20:37 +00:00
|
|
|
#ifndef NO_CTF
|
|
|
|
#include <sys/ctf.h>
|
|
|
|
#include <sys/ctf_api.h>
|
|
|
|
#endif
|
2010-07-31 16:10:20 +00:00
|
|
|
#include <sys/user.h>
|
|
|
|
|
|
|
|
#include <assert.h>
|
|
|
|
#include <err.h>
|
2014-09-25 19:08:06 +00:00
|
|
|
#include <fcntl.h>
|
2010-07-31 16:10:20 +00:00
|
|
|
#include <libgen.h>
|
2014-09-25 19:08:06 +00:00
|
|
|
#include <stdio.h>
|
2010-07-31 16:10:20 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
2014-10-03 23:20:37 +00:00
|
|
|
#ifndef NO_CTF
|
|
|
|
#include <libctf.h>
|
|
|
|
#endif
|
2010-07-31 16:10:20 +00:00
|
|
|
#include <libutil.h>
|
|
|
|
|
2016-12-06 04:18:09 +00:00
|
|
|
#include "crc32.h"
|
2010-07-31 16:10:20 +00:00
|
|
|
#include "_libproc.h"
|
|
|
|
|
2016-12-06 04:18:09 +00:00
|
|
|
#define PATH_DEBUG_DIR "/usr/lib/debug"
|
|
|
|
|
2014-10-03 23:20:37 +00:00
|
|
|
#ifdef NO_CTF
|
|
|
|
typedef struct ctf_file ctf_file_t;
|
|
|
|
#endif
|
|
|
|
|
2014-07-09 17:31:57 +00:00
|
|
|
#ifndef NO_CXA_DEMANGLE
|
2012-09-06 03:19:48 +00:00
|
|
|
extern char *__cxa_demangle(const char *, char *, size_t *, int *);
|
2014-07-09 17:31:57 +00:00
|
|
|
#endif /* NO_CXA_DEMANGLE */
|
2012-09-06 03:19:48 +00:00
|
|
|
|
2016-12-06 04:18:09 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-09-07 02:38:07 +00:00
|
|
|
static void
|
|
|
|
demangle(const char *symbol, char *buf, size_t len)
|
|
|
|
{
|
2014-07-09 17:31:57 +00:00
|
|
|
#ifndef NO_CXA_DEMANGLE
|
2012-09-07 02:38:07 +00:00
|
|
|
char *dembuf;
|
|
|
|
|
2014-07-09 17:31:57 +00:00
|
|
|
if (symbol[0] == '_' && symbol[1] == 'Z' && symbol[2]) {
|
2014-08-09 12:25:06 +00:00
|
|
|
dembuf = __cxa_demangle(symbol, NULL, NULL, NULL);
|
2014-07-09 17:31:57 +00:00
|
|
|
if (!dembuf)
|
|
|
|
goto fail;
|
|
|
|
strlcpy(buf, dembuf, len);
|
|
|
|
free(dembuf);
|
2014-08-09 12:25:06 +00:00
|
|
|
return;
|
2014-07-09 17:31:57 +00:00
|
|
|
}
|
2012-09-07 02:38:07 +00:00
|
|
|
fail:
|
2014-07-09 17:31:57 +00:00
|
|
|
#endif /* NO_CXA_DEMANGLE */
|
2012-09-07 02:38:07 +00:00
|
|
|
strlcpy(buf, symbol, len);
|
|
|
|
}
|
|
|
|
|
2015-02-13 03:18:29 +00:00
|
|
|
static int
|
2016-12-06 04:18:09 +00:00
|
|
|
open_debug_file(char *path, const char *debugfile, uint32_t crc)
|
2015-02-13 03:18:29 +00:00
|
|
|
{
|
2016-12-06 04:18:09 +00:00
|
|
|
size_t n;
|
|
|
|
uint32_t compcrc;
|
2015-02-13 03:18:29 +00:00
|
|
|
int fd;
|
|
|
|
|
2016-12-06 04:18:09 +00:00
|
|
|
fd = -1;
|
|
|
|
if ((n = strlcat(path, "/", PATH_MAX)) >= PATH_MAX)
|
2015-02-13 03:18:29 +00:00
|
|
|
return (fd);
|
2016-12-06 04:18:09 +00:00
|
|
|
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
|
2016-12-06 04:19:08 +00:00
|
|
|
open_object(struct map_info *mapping)
|
2016-12-06 04:18:09 +00:00
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
GElf_Shdr shdr;
|
|
|
|
Elf *e, *e2;
|
|
|
|
Elf_Data *data;
|
|
|
|
Elf_Scn *scn;
|
2016-12-06 04:19:08 +00:00
|
|
|
struct file_info *file;
|
|
|
|
prmap_t *map;
|
2016-12-06 04:18:09 +00:00
|
|
|
const char *debugfile, *scnname;
|
|
|
|
size_t ndx;
|
|
|
|
uint32_t crc;
|
|
|
|
int fd, fd2;
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
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;
|
2016-12-06 04:18:09 +00:00
|
|
|
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. */
|
2016-12-06 04:19:08 +00:00
|
|
|
file->elf = e;
|
|
|
|
file->fd = fd;
|
2016-12-06 04:18:09 +00:00
|
|
|
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);
|
2016-12-06 04:19:08 +00:00
|
|
|
file->elf = e2;
|
|
|
|
file->fd = fd2;
|
2016-12-06 04:18:09 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (e != NULL)
|
|
|
|
(void)elf_end(e);
|
|
|
|
(void)close(fd);
|
|
|
|
return (-1);
|
2015-02-13 03:18:29 +00:00
|
|
|
}
|
|
|
|
|
2008-05-22 02:09:21 +00:00
|
|
|
char *
|
|
|
|
proc_objname(struct proc_handle *p, uintptr_t addr, char *objname,
|
|
|
|
size_t objnamesz)
|
|
|
|
{
|
2016-12-06 04:19:08 +00:00
|
|
|
prmap_t *map;
|
2010-07-31 16:10:20 +00:00
|
|
|
size_t i;
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
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);
|
2010-07-31 16:10:20 +00:00
|
|
|
return (objname);
|
|
|
|
}
|
|
|
|
}
|
2008-05-22 02:09:21 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
/*
|
|
|
|
* Currently just returns the first mapping of the named object, effectively
|
|
|
|
* what Plmid_to_map(p, PR_LMID_EVERY, objname) does in illumos libproc.
|
|
|
|
*/
|
2010-07-31 16:10:20 +00:00
|
|
|
prmap_t *
|
|
|
|
proc_obj2map(struct proc_handle *p, const char *objname)
|
|
|
|
{
|
2016-12-06 04:19:08 +00:00
|
|
|
char path[PATH_MAX], *base;
|
2010-07-31 16:10:20 +00:00
|
|
|
prmap_t *map;
|
2016-12-06 04:19:08 +00:00
|
|
|
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;
|
2014-05-03 04:44:03 +00:00
|
|
|
break;
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
if (map == NULL && strcmp(objname, "a.out") == 0 && p->exec_map != NULL)
|
|
|
|
map = p->exec_map;
|
2014-05-03 04:44:03 +00:00
|
|
|
return (map);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
proc_iter_objs(struct proc_handle *p, proc_map_f *func, void *cd)
|
|
|
|
{
|
2016-12-06 04:19:08 +00:00
|
|
|
char last[MAXPATHLEN], path[MAXPATHLEN], *base;
|
|
|
|
prmap_t *map;
|
2010-07-31 16:10:20 +00:00
|
|
|
size_t i;
|
2015-01-31 03:22:00 +00:00
|
|
|
int error;
|
2010-07-31 16:10:20 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
if (p->nmappings == 0)
|
|
|
|
if (proc_rdagent(p) == NULL)
|
|
|
|
return (-1);
|
2015-01-31 03:22:00 +00:00
|
|
|
|
|
|
|
error = 0;
|
2010-08-11 17:33:26 +00:00
|
|
|
memset(last, 0, sizeof(last));
|
2016-12-06 04:19:08 +00:00
|
|
|
for (i = 0; i < p->nmappings; i++) {
|
|
|
|
map = &p->mappings[i].map;
|
|
|
|
strlcpy(path, map->pr_mapname, sizeof(path));
|
|
|
|
base = basename(path);
|
2010-08-11 17:33:26 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2016-12-06 04:19:08 +00:00
|
|
|
if (strcmp(base, last) == 0)
|
2010-08-11 17:33:26 +00:00
|
|
|
continue;
|
2016-12-06 04:19:08 +00:00
|
|
|
if ((error = (*func)(cd, map, base)) != 0)
|
2015-01-31 03:22:00 +00:00
|
|
|
break;
|
2010-08-11 17:33:26 +00:00
|
|
|
strlcpy(last, path, sizeof(last));
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2015-01-31 03:22:00 +00:00
|
|
|
return (error);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
static struct map_info *
|
|
|
|
_proc_addr2map(struct proc_handle *p, uintptr_t addr)
|
2008-05-22 02:09:21 +00:00
|
|
|
{
|
2016-12-06 04:19:08 +00:00
|
|
|
struct map_info *mapping;
|
2010-07-31 16:10:20 +00:00
|
|
|
size_t i;
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
if (p->nmappings == 0)
|
|
|
|
if (proc_rdagent(p) == NULL)
|
2010-07-31 16:10:20 +00:00
|
|
|
return (NULL);
|
2016-12-06 04:19:08 +00:00
|
|
|
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);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2008-05-22 02:09:21 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
prmap_t *
|
|
|
|
proc_addr2map(struct proc_handle *p, uintptr_t addr)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (&_proc_addr2map(p, addr)->map);
|
|
|
|
}
|
|
|
|
|
2014-09-25 19:08:06 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2008-05-22 02:09:21 +00:00
|
|
|
int
|
|
|
|
proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name,
|
2010-07-31 16:10:20 +00:00
|
|
|
size_t namesz, GElf_Sym *symcopy)
|
2008-05-22 02:09:21 +00:00
|
|
|
{
|
2014-09-25 19:08:06 +00:00
|
|
|
GElf_Ehdr ehdr;
|
|
|
|
GElf_Shdr shdr;
|
2010-07-31 16:10:20 +00:00
|
|
|
Elf *e;
|
2016-12-06 04:19:08 +00:00
|
|
|
Elf_Scn *scn, *dynsymscn, *symtabscn;
|
|
|
|
struct map_info *mapping;
|
2014-09-25 19:08:06 +00:00
|
|
|
const char *s;
|
|
|
|
uintptr_t off;
|
2016-12-06 04:19:08 +00:00
|
|
|
u_long symtabstridx, dynsymstridx;
|
|
|
|
int error = -1;
|
2010-07-31 16:10:20 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
if ((mapping = _proc_addr2map(p, addr)) == NULL) {
|
2016-12-06 04:18:09 +00:00
|
|
|
DPRINTFX("ERROR: proc_addr2map failed to resolve 0x%jx", addr);
|
2010-07-31 16:10:20 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
if (open_object(mapping) != 0) {
|
|
|
|
DPRINTFX("ERROR: failed to open object %s",
|
|
|
|
mapping->map.pr_mapname);
|
2016-12-06 04:18:09 +00:00
|
|
|
return (-1);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
e = mapping->file->elf;
|
2010-07-31 16:10:20 +00:00
|
|
|
if (gelf_getehdr(e, &ehdr) == NULL) {
|
2013-10-27 20:39:10 +00:00
|
|
|
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
|
2016-12-06 04:18:09 +00:00
|
|
|
goto err;
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
/*
|
|
|
|
* Find the index of the STRTAB and SYMTAB sections to locate
|
|
|
|
* symbol names.
|
|
|
|
*/
|
2016-12-06 04:19:08 +00:00
|
|
|
symtabstridx = dynsymstridx = 0;
|
|
|
|
scn = dynsymscn = symtabscn = NULL;
|
2010-07-31 16:10:20 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
off = ehdr.e_type == ET_EXEC ? 0 : mapping->map.pr_vaddr;
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
/*
|
2014-09-25 19:08:06 +00:00
|
|
|
* First look up the symbol in the dynsymtab, and fall back to the
|
|
|
|
* symtab if the lookup fails.
|
2010-07-31 16:10:20 +00:00
|
|
|
*/
|
2014-09-25 19:08:06 +00:00
|
|
|
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);
|
2015-01-25 00:34:43 +00:00
|
|
|
if (error != 0)
|
2016-12-06 04:18:09 +00:00
|
|
|
goto err;
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
out:
|
2014-09-25 19:08:06 +00:00
|
|
|
demangle(s, name, namesz);
|
2016-12-06 04:18:09 +00:00
|
|
|
err:
|
2010-07-31 16:10:20 +00:00
|
|
|
return (error);
|
2008-05-22 02:09:21 +00:00
|
|
|
}
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
static struct map_info *
|
|
|
|
_proc_name2map(struct proc_handle *p, const char *name)
|
2008-05-22 02:09:21 +00:00
|
|
|
{
|
2016-12-06 04:19:08 +00:00
|
|
|
char path[MAXPATHLEN], *base;
|
|
|
|
struct map_info *mapping;
|
2010-07-31 16:10:20 +00:00
|
|
|
size_t i;
|
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
mapping = NULL;
|
|
|
|
if (p->nmappings == 0)
|
|
|
|
if (proc_rdagent(p) == NULL)
|
2010-07-31 16:10:20 +00:00
|
|
|
return (NULL);
|
2016-12-06 04:19:08 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
prmap_t *
|
|
|
|
proc_name2map(struct proc_handle *p, const char *name)
|
|
|
|
{
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
return (&_proc_name2map(p, name)->map);
|
2014-09-25 19:08:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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,
|
2014-10-03 23:20:37 +00:00
|
|
|
GElf_Sym *symcopy, prsyminfo_t *si)
|
2014-09-25 19:08:06 +00:00
|
|
|
{
|
|
|
|
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);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
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));
|
2014-10-03 23:20:37 +00:00
|
|
|
if (si != NULL)
|
|
|
|
si->prs_id = i;
|
2014-09-25 19:08:06 +00:00
|
|
|
return (0);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
return (1);
|
2008-05-22 02:09:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
proc_name2sym(struct proc_handle *p, const char *object, const char *symbol,
|
2014-10-03 23:20:37 +00:00
|
|
|
GElf_Sym *symcopy, prsyminfo_t *si)
|
2008-05-22 02:09:21 +00:00
|
|
|
{
|
2010-07-31 16:10:20 +00:00
|
|
|
GElf_Ehdr ehdr;
|
2016-12-06 04:19:08 +00:00
|
|
|
GElf_Shdr shdr;
|
|
|
|
Elf *e;
|
|
|
|
Elf_Scn *scn, *dynsymscn, *symtabscn;
|
|
|
|
struct map_info *mapping;
|
2014-09-25 19:08:06 +00:00
|
|
|
uintptr_t off;
|
2016-12-06 04:19:08 +00:00
|
|
|
u_long symtabstridx, dynsymstridx;
|
|
|
|
int error = -1;
|
2010-07-31 16:10:20 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
if ((mapping = _proc_name2map(p, object)) == NULL) {
|
2016-12-06 04:18:09 +00:00
|
|
|
DPRINTFX("ERROR: proc_name2map failed to resolve %s", object);
|
|
|
|
return (-1);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
if (open_object(mapping) != 0) {
|
|
|
|
DPRINTFX("ERROR: failed to open object %s",
|
|
|
|
mapping->map.pr_mapname);
|
2016-12-06 04:18:09 +00:00
|
|
|
return (-1);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
e = mapping->file->elf;
|
2010-07-31 16:10:20 +00:00
|
|
|
if (gelf_getehdr(e, &ehdr) == NULL) {
|
2013-10-27 20:39:10 +00:00
|
|
|
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
|
2016-12-06 04:18:09 +00:00
|
|
|
goto err;
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2016-12-06 04:18:09 +00:00
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
/*
|
|
|
|
* Find the index of the STRTAB and SYMTAB sections to locate
|
|
|
|
* symbol names.
|
|
|
|
*/
|
2016-12-06 04:19:08 +00:00
|
|
|
symtabstridx = dynsymstridx = 0;
|
|
|
|
scn = dynsymscn = symtabscn = NULL;
|
2010-07-31 16:10:20 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
/*
|
2014-09-25 19:08:06 +00:00
|
|
|
* First look up the symbol in the dynsymtab, and fall back to the
|
|
|
|
* symtab if the lookup fails.
|
2010-07-31 16:10:20 +00:00
|
|
|
*/
|
2014-10-03 23:20:37 +00:00
|
|
|
error = lookup_name(e, dynsymscn, dynsymstridx, symbol, symcopy, si);
|
2014-09-25 19:08:06 +00:00
|
|
|
if (error == 0)
|
|
|
|
goto out;
|
|
|
|
|
2014-10-03 23:20:37 +00:00
|
|
|
error = lookup_name(e, symtabscn, symtabstridx, symbol, symcopy, si);
|
2014-09-25 19:08:06 +00:00
|
|
|
if (error == 0)
|
|
|
|
goto out;
|
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
out:
|
2016-12-06 04:19:08 +00:00
|
|
|
off = ehdr.e_type == ET_EXEC ? 0 : mapping->map.pr_vaddr;
|
2014-09-25 19:08:06 +00:00
|
|
|
symcopy->st_value += off;
|
|
|
|
|
2016-12-06 04:18:09 +00:00
|
|
|
err:
|
2010-07-31 16:10:20 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2014-10-03 23:20:37 +00:00
|
|
|
ctf_file_t *
|
|
|
|
proc_name2ctf(struct proc_handle *p, const char *name)
|
|
|
|
{
|
|
|
|
#ifndef NO_CTF
|
2014-12-23 15:40:57 +00:00
|
|
|
ctf_file_t *ctf;
|
2014-10-03 23:20:37 +00:00
|
|
|
prmap_t *map;
|
|
|
|
int error;
|
|
|
|
|
2014-10-04 02:34:30 +00:00
|
|
|
if ((map = proc_name2map(p, name)) == NULL)
|
2014-10-03 23:20:37 +00:00
|
|
|
return (NULL);
|
|
|
|
|
2014-12-23 15:40:57 +00:00
|
|
|
ctf = ctf_open(map->pr_mapname, &error);
|
|
|
|
return (ctf);
|
2014-10-03 23:20:37 +00:00
|
|
|
#else
|
|
|
|
(void)p;
|
|
|
|
(void)name;
|
|
|
|
return (NULL);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-07-31 16:10:20 +00:00
|
|
|
int
|
|
|
|
proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which,
|
|
|
|
int mask, proc_sym_f *func, void *cd)
|
|
|
|
{
|
2013-11-11 16:57:57 +00:00
|
|
|
GElf_Ehdr ehdr;
|
2010-07-31 16:10:20 +00:00
|
|
|
GElf_Shdr shdr;
|
|
|
|
GElf_Sym sym;
|
2016-12-06 04:19:08 +00:00
|
|
|
Elf *e;
|
|
|
|
Elf_Scn *scn, *foundscn;
|
|
|
|
Elf_Data *data;
|
|
|
|
struct map_info *mapping;
|
2010-07-31 16:10:20 +00:00
|
|
|
char *s;
|
2016-12-06 04:19:08 +00:00
|
|
|
unsigned long stridx = -1;
|
|
|
|
int error = -1, i;
|
2010-07-31 16:10:20 +00:00
|
|
|
|
2016-12-06 04:19:08 +00:00
|
|
|
if ((mapping = _proc_name2map(p, object)) == NULL) {
|
2016-12-06 04:18:09 +00:00
|
|
|
DPRINTFX("ERROR: proc_name2map failed to resolve %s", object);
|
2010-07-31 16:10:20 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
if (open_object(mapping) != 0) {
|
|
|
|
DPRINTFX("ERROR: failed to open object %s",
|
|
|
|
mapping->map.pr_mapname);
|
2016-12-06 04:18:09 +00:00
|
|
|
return (-1);
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2016-12-06 04:19:08 +00:00
|
|
|
e = mapping->file->elf;
|
2013-11-11 16:57:57 +00:00
|
|
|
if (gelf_getehdr(e, &ehdr) == NULL) {
|
|
|
|
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
|
2016-12-06 04:18:09 +00:00
|
|
|
goto err;
|
2013-11-11 16:57:57 +00:00
|
|
|
}
|
2010-07-31 16:10:20 +00:00
|
|
|
/*
|
|
|
|
* Find the section we are looking for.
|
|
|
|
*/
|
2016-12-06 04:18:09 +00:00
|
|
|
foundscn = scn = NULL;
|
2010-07-31 16:10:20 +00:00
|
|
|
while ((scn = elf_nextscn(e, scn)) != NULL) {
|
|
|
|
gelf_getshdr(scn, &shdr);
|
2014-09-25 19:08:06 +00:00
|
|
|
if (which == PR_SYMTAB &&
|
2010-07-31 16:10:20 +00:00
|
|
|
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) {
|
2013-10-27 20:39:10 +00:00
|
|
|
DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1));
|
2016-12-06 04:18:09 +00:00
|
|
|
goto err;
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
2014-09-25 19:08:06 +00:00
|
|
|
for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) {
|
2010-07-31 16:10:20 +00:00
|
|
|
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);
|
2013-11-11 16:57:57 +00:00
|
|
|
if (ehdr.e_type != ET_EXEC)
|
2016-12-06 04:19:08 +00:00
|
|
|
sym.st_value += mapping->map.pr_vaddr;
|
2015-01-31 03:22:00 +00:00
|
|
|
if ((error = (*func)(cd, &sym, s)) != 0)
|
2016-12-06 04:18:09 +00:00
|
|
|
goto err;
|
2010-07-31 16:10:20 +00:00
|
|
|
}
|
|
|
|
error = 0;
|
2016-12-06 04:18:09 +00:00
|
|
|
err:
|
2010-07-31 16:10:20 +00:00
|
|
|
return (error);
|
2008-05-22 02:09:21 +00:00
|
|
|
}
|