#include <sys/types.h>
#include <sys/stat.h>
#include "darwin_shim.h"
#include "elf.h"
#include "decl.h"
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <mach-o/stab.h>
#include <fcntl.h>
#define stat64 stat
#define OBJFS_ROOT "/system/object"
#include <unistd.h>
#include <strings.h>
#include <stdlib.h>
#include <libelf.h>
#include <limits.h>
#include <assert.h>
#include <errno.h>
#include <dirent.h>
#include <ctype.h>
#include <sys/sysctl.h>
#include <dtrace.h>
#include <sys/kas_info.h>
#include <dt_strtab.h>
#include <dt_module.h>
#include <dt_impl.h>
static const char *dt_module_strtab;
int dtrace_kernel_path(char*, size_t);
static void
dt_module_symhash_insert(dt_module_t *dmp, const char *name, uint_t id)
{
dt_sym_t *dsp = &dmp->dm_symchains[dmp->dm_symfree];
uint_t h;
assert(dmp->dm_symfree < dmp->dm_nsymelems + 1);
dsp->ds_symid = id;
h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
dsp->ds_next = dmp->dm_symbuckets[h];
dmp->dm_symbuckets[h] = dmp->dm_symfree++;
}
static uint_t
dt_module_syminit32(dt_module_t *dmp)
{
const Elf32_Sym *sym = dmp->dm_symtab.cts_data;
const char *base = dmp->dm_strtab.cts_data;
size_t ss_size = dmp->dm_strtab.cts_size;
uint_t i, n = dmp->dm_nsymelems;
uint_t asrsv = 0;
for (i = 0; i < n; i++, sym++) {
const char *name = base + sym->st_name;
uchar_t type = ELF32_ST_TYPE(sym->st_info);
if (type >= STT_NUM || type == STT_SECTION)
continue;
if (sym->st_name == 0 || sym->st_name >= ss_size)
continue;
if (sym->st_value != 0 &&
(ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))
asrsv++;
dt_module_symhash_insert(dmp, name, i);
}
return (asrsv);
}
static uint_t
dt_module_syminit64(dt_module_t *dmp)
{
const Elf64_Sym *sym = dmp->dm_symtab.cts_data;
const char *base = dmp->dm_strtab.cts_data;
size_t ss_size = dmp->dm_strtab.cts_size;
uint_t i, n = dmp->dm_nsymelems;
uint_t asrsv = 0;
for (i = 0; i < n; i++, sym++) {
const char *name = base + sym->st_name;
uchar_t type = ELF64_ST_TYPE(sym->st_info);
if (type >= STT_NUM || type == STT_SECTION)
continue;
if (sym->st_name == 0 || sym->st_name >= ss_size)
continue;
if (sym->st_value != 0 &&
(ELF64_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))
asrsv++;
dt_module_symhash_insert(dmp, name, i);
}
return (asrsv);
}
static int
dt_module_symcomp32(const void *lp, const void *rp)
{
Elf32_Sym *lhs = *((Elf32_Sym **)lp);
Elf32_Sym *rhs = *((Elf32_Sym **)rp);
if (lhs->st_value != rhs->st_value)
return (lhs->st_value > rhs->st_value ? 1 : -1);
if ((lhs->st_size == 0) != (rhs->st_size == 0))
return (lhs->st_size == 0 ? 1 : -1);
if ((ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE) !=
(ELF32_ST_TYPE(rhs->st_info) == STT_NOTYPE))
return (ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1);
if ((ELF32_ST_BIND(lhs->st_info) == STB_WEAK) !=
(ELF32_ST_BIND(rhs->st_info) == STB_WEAK))
return (ELF32_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1);
return (strcmp(dt_module_strtab + lhs->st_name,
dt_module_strtab + rhs->st_name));
}
static int
dt_module_symcomp64(const void *lp, const void *rp)
{
Elf64_Sym *lhs = *((Elf64_Sym **)lp);
Elf64_Sym *rhs = *((Elf64_Sym **)rp);
if (lhs->st_value != rhs->st_value)
return (lhs->st_value > rhs->st_value ? 1 : -1);
if ((lhs->st_size == 0) != (rhs->st_size == 0))
return (lhs->st_size == 0 ? 1 : -1);
if ((ELF64_ST_TYPE(lhs->st_info) == STT_NOTYPE) !=
(ELF64_ST_TYPE(rhs->st_info) == STT_NOTYPE))
return (ELF64_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1);
if ((ELF64_ST_BIND(lhs->st_info) == STB_WEAK) !=
(ELF64_ST_BIND(rhs->st_info) == STB_WEAK))
return (ELF64_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1);
return (strcmp(dt_module_strtab + lhs->st_name,
dt_module_strtab + rhs->st_name));
}
static void
dt_module_symsort32(dt_module_t *dmp)
{
Elf32_Sym *symtab = (Elf32_Sym *)dmp->dm_symtab.cts_data;
Elf32_Sym **sympp = (Elf32_Sym **)dmp->dm_asmap;
const dt_sym_t *dsp = dmp->dm_symchains + 1;
uint_t i, n = dmp->dm_symfree;
for (i = 1; i < n; i++, dsp++) {
Elf32_Sym *sym = symtab + dsp->ds_symid;
if (sym->st_value != 0 &&
(ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))
*sympp++ = sym;
}
dmp->dm_aslen = (uint_t)(sympp - (Elf32_Sym **)dmp->dm_asmap);
assert(dmp->dm_aslen <= dmp->dm_asrsv);
dt_module_strtab = dmp->dm_strtab.cts_data;
qsort(dmp->dm_asmap, dmp->dm_aslen,
sizeof (Elf32_Sym *), dt_module_symcomp32);
dt_module_strtab = NULL;
}
static void
dt_module_symsort64(dt_module_t *dmp)
{
Elf64_Sym *symtab = (Elf64_Sym *)dmp->dm_symtab.cts_data;
Elf64_Sym **sympp = (Elf64_Sym **)dmp->dm_asmap;
const dt_sym_t *dsp = dmp->dm_symchains + 1;
uint_t i, n = dmp->dm_symfree;
for (i = 1; i < n; i++, dsp++) {
Elf64_Sym *sym = symtab + dsp->ds_symid;
if (sym->st_value != 0 &&
(ELF64_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))
*sympp++ = sym;
}
dmp->dm_aslen = (uint_t)(sympp - (Elf64_Sym **)dmp->dm_asmap);
assert(dmp->dm_aslen <= dmp->dm_asrsv);
dt_module_strtab = dmp->dm_strtab.cts_data;
qsort(dmp->dm_asmap, dmp->dm_aslen,
sizeof (Elf64_Sym *), dt_module_symcomp64);
dt_module_strtab = NULL;
}
static GElf_Sym *
dt_module_symgelf32(const Elf32_Sym *src, GElf_Sym *dst)
{
if (dst != NULL) {
dst->st_name = src->st_name;
dst->st_info = src->st_info;
dst->st_other = src->st_other;
dst->st_shndx = src->st_shndx;
dst->st_value = src->st_value;
dst->st_size = src->st_size;
}
return (dst);
}
static GElf_Sym *
dt_module_symgelf64(const Elf64_Sym *src, GElf_Sym *dst)
{
if (dst != NULL)
bcopy(src, dst, sizeof (GElf_Sym));
return (dst);
}
static GElf_Sym *
dt_module_symname32(dt_module_t *dmp, const char *name,
GElf_Sym *symp, uint_t *idp)
{
const Elf32_Sym *symtab = dmp->dm_symtab.cts_data;
const char *strtab = dmp->dm_strtab.cts_data;
const Elf32_Sym *sym;
const dt_sym_t *dsp;
uint_t i, h;
if (dmp->dm_nsymelems == 0)
return (NULL);
h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) {
dsp = &dmp->dm_symchains[i];
sym = symtab + dsp->ds_symid;
if (strcmp(name, strtab + sym->st_name) == 0) {
if (idp != NULL)
*idp = dsp->ds_symid;
return (dt_module_symgelf32(sym, symp));
}
}
return (NULL);
}
static GElf_Sym *
dt_module_symname64(dt_module_t *dmp, const char *name,
GElf_Sym *symp, uint_t *idp)
{
const Elf64_Sym *symtab = dmp->dm_symtab.cts_data;
const char *strtab = dmp->dm_strtab.cts_data;
const Elf64_Sym *sym;
const dt_sym_t *dsp;
uint_t i, h;
if (dmp->dm_nsymelems == 0)
return (NULL);
h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) {
dsp = &dmp->dm_symchains[i];
sym = symtab + dsp->ds_symid;
if (strcmp(name, strtab + sym->st_name) == 0) {
if (idp != NULL)
*idp = dsp->ds_symid;
return (dt_module_symgelf64(sym, symp));
}
}
return (NULL);
}
static GElf_Sym *
dt_module_symaddr32(dt_module_t *dmp, GElf_Addr addr,
GElf_Sym *symp, uint_t *idp)
{
const Elf32_Sym **asmap = (const Elf32_Sym **)dmp->dm_asmap;
const Elf32_Sym *symtab = dmp->dm_symtab.cts_data;
const Elf32_Sym *sym;
uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1;
Elf32_Addr v;
if (dmp->dm_aslen == 0)
return (NULL);
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (addr >= asmap[mid]->st_value)
lo = mid;
else
hi = mid;
}
i = addr < asmap[hi]->st_value ? lo : hi;
sym = asmap[i];
v = sym->st_value;
while (i-- != 0 && asmap[i]->st_value == v)
sym = asmap[i];
if (addr - sym->st_value < MAX(sym->st_size, 1)) {
if (idp != NULL)
*idp = (uint_t)(sym - symtab);
return (dt_module_symgelf32(sym, symp));
}
return (NULL);
}
static GElf_Sym *
dt_module_symaddr64(dt_module_t *dmp, GElf_Addr addr,
GElf_Sym *symp, uint_t *idp)
{
const Elf64_Sym **asmap = (const Elf64_Sym **)dmp->dm_asmap;
const Elf64_Sym *symtab = dmp->dm_symtab.cts_data;
const Elf64_Sym *sym;
uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1;
Elf64_Addr v;
if (dmp->dm_aslen == 0)
return (NULL);
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (addr >= asmap[mid]->st_value)
lo = mid;
else
hi = mid;
}
i = addr < asmap[hi]->st_value ? lo : hi;
sym = asmap[i];
v = sym->st_value;
while (i-- != 0 && asmap[i]->st_value == v)
sym = asmap[i];
if (addr - sym->st_value < MAX(sym->st_size, 1)) {
if (idp != NULL)
*idp = (uint_t)(sym - symtab);
return (dt_module_symgelf64(sym, symp));
}
return (NULL);
}
static const dt_modops_t dt_modops_32 = {
dt_module_syminit32,
dt_module_symsort32,
dt_module_symname32,
dt_module_symaddr32
};
static const dt_modops_t dt_modops_64 = {
dt_module_syminit64,
dt_module_symsort64,
dt_module_symname64,
dt_module_symaddr64
};
static uint_t
dt_module_syminit_macho(dt_module_t *dmp)
{
const struct nlist *sym = (const struct nlist *)(dmp->dm_symtab.cts_data);
const char *base = (const char *)dmp->dm_strtab.cts_data;
uint_t i, n = dmp->dm_nsymelems;
uint_t asrsv = 0;
for (i = 0; i < n; i++, sym++) {
const char *name = base + sym->n_un.n_strx;
uchar_t type = sym->n_type & (N_TYPE | N_EXT);
if (((N_SECT | N_EXT) != type && (N_ABS | N_EXT) != type))
continue;
if (STT_FUNC != sym->n_desc && STT_OBJECT != sym->n_desc)
continue;
if (0 == sym->n_un.n_strx) continue;
if ('_' == name[0])
name++;
if (sym->n_value != 0)
asrsv++;
dt_module_symhash_insert(dmp, name, i);
}
return (asrsv);
}
static int
dt_module_symcomp_macho(const void *lp, const void *rp)
{
struct nlist *lhs = *((struct nlist **)lp);
struct nlist *rhs = *((struct nlist **)rp);
if (lhs->n_value != rhs->n_value)
return (lhs->n_value > rhs->n_value ? 1 : -1);
if ((lhs->n_desc & N_WEAK_REF) != (rhs->n_desc & N_WEAK_REF))
return ((lhs->n_desc & N_WEAK_REF) ? 1 : -1);
return (strcmp(dt_module_strtab + lhs->n_un.n_strx,
dt_module_strtab + rhs->n_un.n_strx)); }
static void
dt_module_symsort_macho(dt_module_t *dmp)
{
struct nlist *symtab = (struct nlist *)(dmp->dm_symtab.cts_data);
struct nlist **sympp = (struct nlist **)dmp->dm_asmap;
const dt_sym_t *dsp = dmp->dm_symchains + 1;
uint_t i, n = dmp->dm_symfree;
for (i = 1; i < n; i++, dsp++) {
struct nlist *sym = symtab + dsp->ds_symid;
if (sym->n_value != 0)
*sympp++ = sym;
}
dmp->dm_aslen = (uint_t)(sympp - (struct nlist **)dmp->dm_asmap);
assert(dmp->dm_aslen <= dmp->dm_asrsv);
dt_module_strtab = ((char *)(dmp->dm_symtab.cts_data)) + dmp->dm_symtab.cts_size;
qsort(dmp->dm_asmap, dmp->dm_aslen,
sizeof (struct nlist *), dt_module_symcomp_macho);
dt_module_strtab = NULL;
}
static uint64_t
dt_module_slide()
{
static bool initialized = FALSE;
static pthread_mutex_t guard = PTHREAD_MUTEX_INITIALIZER;
static uint64_t kernel_slide = 0;
if (!initialized) {
pthread_mutex_lock(&guard);
if (!initialized) {
initialized = TRUE;
size_t size = sizeof(kernel_slide);
if (kas_info(KAS_INFO_KERNEL_TEXT_SLIDE_SELECTOR, &kernel_slide, &size) != KERN_SUCCESS)
kernel_slide = 0;
}
pthread_mutex_unlock(&guard);
}
return kernel_slide;
}
static GElf_Sym *
dt_module_symname_macho(dt_module_t *dmp, const char *name,
GElf_Sym *symp, uint_t *idp)
{
const struct nlist *symtab = (const struct nlist *)(dmp->dm_symtab.cts_data);
const char *strtab = (const char *)dmp->dm_strtab.cts_data;
const struct nlist *sym;
const dt_sym_t *dsp;
uint_t i, h;
if (dmp->dm_nsymelems == 0)
return (NULL);
h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) {
dsp = &dmp->dm_symchains[i];
sym = symtab + dsp->ds_symid;
const char *sname = strtab + sym->n_un.n_strx;
if ('_' == sname[0])
sname++;
if (strcmp(name, sname) == 0) {
if (idp != NULL)
*idp = dsp->ds_symid;
symp->st_name = (GElf_Sxword)(sname - strtab);
symp->st_info = STT_NOTYPE;
symp->st_other = 0;
symp->st_shndx = sym->n_sect;
symp->st_value = sym->n_value + dt_module_slide();
symp->st_size = 0;
if (sym->n_type & N_STAB) {
switch(sym->n_type) {
case N_FUN:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_FUNC));
break;
case N_GSYM:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
break;
default:
break;
}
} else if ((N_ABS | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) ||
(N_SECT | N_EXT) == (sym->n_type & (N_TYPE | N_EXT))) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (sym->n_desc));
} else if ((N_UNDF | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) &&
sym->n_sect == NO_SECT) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
}
return symp;
}
}
return (NULL);
}
static GElf_Sym *
dt_module_symaddr_macho(dt_module_t *dmp, GElf_Addr addr,
GElf_Sym *symp, uint_t *idp)
{
const struct nlist **asmap = (const struct nlist **)dmp->dm_asmap;
const struct nlist *symtab = (const struct nlist *)(dmp->dm_symtab.cts_data);
const char *strtab = (const char *)dmp->dm_strtab.cts_data;
const struct nlist *sym;
uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1;
Elf32_Addr v;
if (dmp->dm_aslen == 0)
return (NULL);
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (addr >= asmap[mid]->n_value)
lo = mid;
else
hi = mid;
}
i = addr < asmap[hi]->n_value ? lo : hi;
sym = asmap[i];
v = sym->n_value + dt_module_slide();
while (i-- != 0 && asmap[i]->n_value == v)
sym = asmap[i];
if (sym->n_value <= addr) {
const char *name = strtab + sym->n_un.n_strx;
if ('_' == name[0])
name++;
symp->st_name = (GElf_Sxword)(name - strtab);
symp->st_info = STT_NOTYPE;
symp->st_other = 0;
symp->st_shndx = sym->n_sect;
symp->st_value = sym->n_value;
symp->st_size = 0;
if (sym->n_type & N_STAB) {
switch(sym->n_type) {
case N_FUN:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_FUNC));
break;
case N_GSYM:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
break;
default:
break;
}
} else if ((N_ABS | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) ||
(N_SECT | N_EXT) == (sym->n_type & (N_TYPE | N_EXT))) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (sym->n_desc));
} else if ((N_UNDF | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) &&
sym->n_sect == NO_SECT) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
}
if (idp != NULL) {
*idp = (uint_t)(sym - symtab);
}
return symp;
}
return (NULL);
}
static const dt_modops_t dt_modops_macho_32 = {
dt_module_syminit_macho,
dt_module_symsort_macho,
dt_module_symname_macho,
dt_module_symaddr_macho
};
static uint_t
dt_module_syminit_macho_64(dt_module_t *dmp)
{
const struct nlist_64 *sym = (const struct nlist_64 *)(dmp->dm_symtab.cts_data);
const char *base = (const char *)dmp->dm_strtab.cts_data;
uint_t i, n = dmp->dm_nsymelems;
uint_t asrsv = 0;
for (i = 0; i < n; i++, sym++) {
const char *name = base + sym->n_un.n_strx;
uchar_t type = sym->n_type & (N_TYPE | N_EXT);
if (((N_SECT | N_EXT) != type && (N_ABS | N_EXT) != type))
continue;
if (STT_FUNC != sym->n_desc && STT_OBJECT != sym->n_desc)
continue;
if (0 == sym->n_un.n_strx) continue;
if ('_' == name[0])
name++;
if (sym->n_value != 0)
asrsv++;
dt_module_symhash_insert(dmp, name, i);
}
return (asrsv);
}
static int
dt_module_symcomp_macho_64(const void *lp, const void *rp)
{
struct nlist_64 *lhs = *((struct nlist_64 **)lp);
struct nlist_64 *rhs = *((struct nlist_64 **)rp);
if (lhs->n_value != rhs->n_value)
return (lhs->n_value > rhs->n_value ? 1 : -1);
if ((lhs->n_desc & N_WEAK_REF) != (rhs->n_desc & N_WEAK_REF))
return ((lhs->n_desc & N_WEAK_REF) ? 1 : -1);
return (strcmp(dt_module_strtab + lhs->n_un.n_strx,
dt_module_strtab + rhs->n_un.n_strx)); }
static void
dt_module_symsort_macho_64(dt_module_t *dmp)
{
struct nlist_64 *symtab = (struct nlist_64 *)(dmp->dm_symtab.cts_data);
struct nlist_64 **sympp = (struct nlist_64 **)dmp->dm_asmap;
const dt_sym_t *dsp = dmp->dm_symchains + 1;
uint_t i, n = dmp->dm_symfree;
for (i = 1; i < n; i++, dsp++) {
struct nlist_64 *sym = symtab + dsp->ds_symid;
if (sym->n_value != 0)
*sympp++ = sym;
}
dmp->dm_aslen = (uint_t)(sympp - (struct nlist_64 **)dmp->dm_asmap);
assert(dmp->dm_aslen <= dmp->dm_asrsv);
dt_module_strtab = ((char *)(dmp->dm_symtab.cts_data)) + dmp->dm_symtab.cts_size;
qsort(dmp->dm_asmap, dmp->dm_aslen,
sizeof (struct nlist_64 *), dt_module_symcomp_macho_64);
dt_module_strtab = NULL;
}
static GElf_Sym *
dt_module_symname_macho_64(dt_module_t *dmp, const char *name,
GElf_Sym *symp, uint_t *idp)
{
const struct nlist_64 *symtab = (const struct nlist_64 *)(dmp->dm_symtab.cts_data);
const char *strtab = (const char *)dmp->dm_strtab.cts_data;
const struct nlist_64 *sym;
const dt_sym_t *dsp;
uint_t i, h;
if (dmp->dm_nsymelems == 0)
return (NULL);
h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) {
dsp = &dmp->dm_symchains[i];
sym = symtab + dsp->ds_symid;
const char *sname = strtab + sym->n_un.n_strx;
if ('_' == sname[0])
sname++;
if (strcmp(name, sname) == 0) {
if (idp != NULL)
*idp = dsp->ds_symid;
symp->st_name = (GElf_Sxword)(sname - strtab);
symp->st_info = STT_NOTYPE;
symp->st_other = 0;
symp->st_shndx = sym->n_sect;
symp->st_value = sym->n_value + dt_module_slide();
symp->st_size = 0;
if (sym->n_type & N_STAB) {
switch(sym->n_type) {
case N_FUN:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_FUNC));
break;
case N_GSYM:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
break;
default:
break;
}
} else if ((N_ABS | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) ||
(N_SECT | N_EXT) == (sym->n_type & (N_TYPE | N_EXT))) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (sym->n_desc));
} else if ((N_UNDF | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) &&
sym->n_sect == NO_SECT) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
}
return symp;
}
}
return (NULL);
}
static GElf_Sym *
dt_module_symaddr_macho_64(dt_module_t *dmp, GElf_Addr addr,
GElf_Sym *symp, uint_t *idp)
{
const struct nlist_64 **asmap = (const struct nlist_64 **)dmp->dm_asmap;
const struct nlist_64 *symtab = (const struct nlist_64 *)(dmp->dm_symtab.cts_data);
const char *strtab = (const char *)dmp->dm_strtab.cts_data;
const struct nlist_64 *sym;
uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1;
Elf32_Addr v;
if (dmp->dm_aslen == 0)
return (NULL);
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (addr >= asmap[mid]->n_value)
lo = mid;
else
hi = mid;
}
i = addr < asmap[hi]->n_value ? lo : hi;
sym = asmap[i];
v = sym->n_value;
while (i-- != 0 && asmap[i]->n_value == v)
sym = asmap[i];
if (sym->n_value <= addr) {
const char *name = strtab + sym->n_un.n_strx;
if ('_' == name[0])
name++;
symp->st_name = (GElf_Sxword)(name - strtab);
symp->st_info = STT_NOTYPE;
symp->st_other = 0;
symp->st_shndx = sym->n_sect;
symp->st_value = sym->n_value + dt_module_slide();
symp->st_size = 0;
if (sym->n_type & N_STAB) {
switch(sym->n_type) {
case N_FUN:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_FUNC));
break;
case N_GSYM:
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
break;
default:
break;
}
} else if ((N_ABS | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) ||
(N_SECT | N_EXT) == (sym->n_type & (N_TYPE | N_EXT))) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (sym->n_desc));
} else if ((N_UNDF | N_EXT) == (sym->n_type & (N_TYPE | N_EXT)) &&
sym->n_sect == NO_SECT) {
symp->st_info = GELF_ST_INFO((STB_GLOBAL), (STT_OBJECT));
}
if (idp != NULL) {
*idp = (uint_t)(sym - symtab);
}
return symp;
}
return (NULL);
}
static const dt_modops_t dt_modops_macho_64 = {
dt_module_syminit_macho_64,
dt_module_symsort_macho_64,
dt_module_symname_macho_64,
dt_module_symaddr_macho_64
};
dt_module_t *
dt_module_create(dtrace_hdl_t *dtp, const char *name)
{
uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_modbuckets;
dt_module_t *dmp;
for (dmp = dtp->dt_mods[h]; dmp != NULL; dmp = dmp->dm_next) {
if (strcmp(dmp->dm_name, name) == 0)
return (dmp);
}
if ((dmp = malloc(sizeof (dt_module_t))) == NULL)
return (NULL);
bzero(dmp, sizeof (dt_module_t));
(void) strlcpy(dmp->dm_name, name, sizeof (dmp->dm_name));
dt_list_append(&dtp->dt_modlist, dmp);
dmp->dm_next = dtp->dt_mods[h];
dtp->dt_mods[h] = dmp;
dtp->dt_nmods++;
if (dtp->dt_conf.dtc_ctfmodel == CTF_MODEL_LP64)
dmp->dm_ops = &dt_modops_macho_64;
else
dmp->dm_ops = &dt_modops_macho_32;
return (dmp);
}
dt_module_t *
dt_module_lookup_by_name(dtrace_hdl_t *dtp, const char *name)
{
uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_modbuckets;
dt_module_t *dmp;
for (dmp = dtp->dt_mods[h]; dmp != NULL; dmp = dmp->dm_next) {
if (strcmp(dmp->dm_name, name) == 0)
return (dmp);
}
return (NULL);
}
dt_module_t *
dt_module_lookup_by_ctf(dtrace_hdl_t *dtp, ctf_file_t *ctfp)
{
return (ctfp ? ctf_getspecific(ctfp) : NULL);
}
static int
dt_module_load_sect(dtrace_hdl_t *dtp, dt_module_t *dmp, ctf_sect_t *ctsp)
{
const char *s;
size_t shstrs;
GElf_Shdr sh;
Elf_Data *dp;
Elf_Scn *sp;
if (elf_getshstrndx(dmp->dm_elf, &shstrs) == 0)
return (dt_set_errno(dtp, EDT_NOTLOADED));
for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) {
if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL ||
(s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL)
continue;
if (sh.sh_type == ctsp->cts_type &&
sh.sh_entsize == ctsp->cts_entsize &&
strcmp(s, ctsp->cts_name) == 0)
break;
}
if (sp == NULL || (dp = elf_getdata(sp, NULL)) == NULL)
return (0);
ctsp->cts_data = dp->d_buf;
ctsp->cts_size = dp->d_size;
dt_dprintf("loaded %s [%s] (%lu bytes)\n",
dmp->dm_name, ctsp->cts_name, (ulong_t)ctsp->cts_size);
return (0);
}
int
dt_module_load(dtrace_hdl_t *dtp, dt_module_t *dmp)
{
if (dmp->dm_flags & DT_DM_LOADED)
return (0);
dmp->dm_ctdata.cts_name = ".SUNW_ctf";
dmp->dm_ctdata.cts_type = SHT_UNKNOWN12;
dmp->dm_ctdata.cts_flags = 0;
dmp->dm_ctdata.cts_data = NULL;
dmp->dm_ctdata.cts_size = 0;
dmp->dm_ctdata.cts_entsize = 0;
dmp->dm_ctdata.cts_offset = 0;
dmp->dm_symtab.cts_name = ".symtab";
dmp->dm_symtab.cts_type = SHT_STRTAB;
dmp->dm_symtab.cts_flags = 0;
dmp->dm_symtab.cts_data = NULL;
dmp->dm_symtab.cts_size = 0;
dmp->dm_symtab.cts_entsize =
dmp->dm_ops == &dt_modops_macho_32 ? sizeof(struct nlist) :
dmp->dm_ops == &dt_modops_macho_64 ? sizeof(struct nlist_64) :
(dmp->dm_ops == &dt_modops_64 ? sizeof (Elf64_Sym) : sizeof (Elf32_Sym));
dmp->dm_symtab.cts_offset = 0;
dmp->dm_strtab.cts_name = ".dir_str_table";
dmp->dm_strtab.cts_type = SHT_STRTAB;
dmp->dm_strtab.cts_flags = 0;
dmp->dm_strtab.cts_data = NULL;
dmp->dm_strtab.cts_size = 0;
dmp->dm_strtab.cts_entsize = 0;
dmp->dm_strtab.cts_offset = 0;
if (dt_module_load_sect(dtp, dmp, &dmp->dm_ctdata) == -1 ||
dt_module_load_sect(dtp, dmp, &dmp->dm_symtab) == -1 ||
dt_module_load_sect(dtp, dmp, &dmp->dm_strtab) == -1) {
dt_module_unload(dtp, dmp);
return (-1);
}
dmp->dm_nsymelems =
dmp->dm_symtab.cts_size / dmp->dm_symtab.cts_entsize;
dmp->dm_nsymbuckets = _dtrace_strbuckets;
dmp->dm_symfree = 1;
dmp->dm_symbuckets = malloc(sizeof (uint_t) * dmp->dm_nsymbuckets);
dmp->dm_symchains = malloc(sizeof (dt_sym_t) * dmp->dm_nsymelems + 1);
if (dmp->dm_symbuckets == NULL || dmp->dm_symchains == NULL) {
dt_module_unload(dtp, dmp);
return (dt_set_errno(dtp, EDT_NOMEM));
}
bzero(dmp->dm_symbuckets, sizeof (uint_t) * dmp->dm_nsymbuckets);
bzero(dmp->dm_symchains, sizeof (dt_sym_t) * dmp->dm_nsymelems + 1);
dmp->dm_asrsv = dmp->dm_ops->do_syminit(dmp);
dt_dprintf("hashed %s [%s] (%u symbols)\n",
dmp->dm_name, dmp->dm_symtab.cts_name, dmp->dm_symfree - 1);
if ((dmp->dm_asmap = malloc(sizeof (void *) * dmp->dm_asrsv)) == NULL) {
dt_module_unload(dtp, dmp);
return (dt_set_errno(dtp, EDT_NOMEM));
}
dmp->dm_ops->do_symsort(dmp);
dt_dprintf("sorted %s [%s] (%u symbols)\n",
dmp->dm_name, dmp->dm_symtab.cts_name, dmp->dm_aslen);
dmp->dm_flags |= DT_DM_LOADED;
return (0);
}
ctf_file_t *
dt_module_getctf(dtrace_hdl_t *dtp, dt_module_t *dmp)
{
const char *parent;
dt_module_t *pmp;
ctf_file_t *pfp;
int model;
if (dmp->dm_ctfp != NULL || dt_module_load(dtp, dmp) != 0)
return (dmp->dm_ctfp);
if (dmp->dm_ops == &dt_modops_macho_64)
model = CTF_MODEL_LP64;
else if (dmp->dm_ops == &dt_modops_macho_32)
model = CTF_MODEL_ILP32;
else
if (dmp->dm_ops == &dt_modops_64)
model = CTF_MODEL_LP64;
else
model = CTF_MODEL_ILP32;
if (dmp->dm_ctdata.cts_size == 0) {
(void) dt_set_errno(dtp, EDT_NOCTF);
return (NULL);
}
dmp->dm_ctfp = ctf_bufopen(&dmp->dm_ctdata,
&dmp->dm_symtab, &dmp->dm_strtab, &dtp->dt_ctferr);
if (dmp->dm_ctfp == NULL) {
(void) dt_set_errno(dtp, EDT_CTF);
return (NULL);
}
(void) ctf_setmodel(dmp->dm_ctfp, model);
ctf_setspecific(dmp->dm_ctfp, dmp);
if ((parent = ctf_parent_name(dmp->dm_ctfp)) != NULL) {
if ((pmp = dt_module_create(dtp, parent)) == NULL ||
(pfp = dt_module_getctf(dtp, pmp)) == NULL) {
if (pmp == NULL)
(void) dt_set_errno(dtp, EDT_NOMEM);
goto err;
}
if (ctf_import(dmp->dm_ctfp, pfp) == CTF_ERR) {
dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
(void) dt_set_errno(dtp, EDT_CTF);
goto err;
}
}
dt_dprintf("loaded CTF container for %s (%p)\n",
dmp->dm_name, (void *)dmp->dm_ctfp);
return (dmp->dm_ctfp);
err:
ctf_close(dmp->dm_ctfp);
dmp->dm_ctfp = NULL;
return (NULL);
}
void
dt_module_unload(dtrace_hdl_t *dtp, dt_module_t *dmp)
{
ctf_close(dmp->dm_ctfp);
dmp->dm_ctfp = NULL;
bzero(&dmp->dm_ctdata, sizeof (ctf_sect_t));
bzero(&dmp->dm_symtab, sizeof (ctf_sect_t));
bzero(&dmp->dm_strtab, sizeof (ctf_sect_t));
if (dmp->dm_symbuckets != NULL) {
free(dmp->dm_symbuckets);
dmp->dm_symbuckets = NULL;
}
if (dmp->dm_symchains != NULL) {
free(dmp->dm_symchains);
dmp->dm_symchains = NULL;
}
if (dmp->dm_asmap != NULL) {
free(dmp->dm_asmap);
dmp->dm_asmap = NULL;
}
dmp->dm_symfree = 0;
dmp->dm_nsymbuckets = 0;
dmp->dm_nsymelems = 0;
dmp->dm_asrsv = 0;
dmp->dm_aslen = 0;
dmp->dm_text_va = (GElf_Addr)0;
dmp->dm_text_size = 0;
dmp->dm_data_va = (GElf_Addr)0;
dmp->dm_data_size = 0;
dmp->dm_bss_va = (GElf_Addr)0;
dmp->dm_bss_size = 0;
if (dmp->dm_extern != NULL) {
dt_idhash_destroy(dmp->dm_extern);
dmp->dm_extern = NULL;
}
(void) elf_end(dmp->dm_elf);
dmp->dm_elf = NULL;
dmp->dm_flags &= ~DT_DM_LOADED;
}
void
dt_module_destroy(dtrace_hdl_t *dtp, dt_module_t *dmp)
{
dt_list_delete(&dtp->dt_modlist, dmp);
assert(dtp->dt_nmods != 0);
dtp->dt_nmods--;
dt_module_unload(dtp, dmp);
free(dmp);
}
dt_ident_t *
dt_module_extern(dtrace_hdl_t *dtp, dt_module_t *dmp,
const char *name, const dtrace_typeinfo_t *tip)
{
dtrace_syminfo_t *sip;
dt_ident_t *idp;
uint_t id;
if (dmp->dm_extern == NULL && (dmp->dm_extern = dt_idhash_create(
"extern", NULL, dmp->dm_nsymelems, UINT_MAX)) == NULL) {
(void) dt_set_errno(dtp, EDT_NOMEM);
return (NULL);
}
if (dt_idhash_nextid(dmp->dm_extern, &id) == -1) {
(void) dt_set_errno(dtp, EDT_SYMOFLOW);
return (NULL);
}
if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL) {
(void) dt_set_errno(dtp, EDT_NOMEM);
return (NULL);
}
idp = dt_idhash_insert(dmp->dm_extern, name, DT_IDENT_SYMBOL, 0, id,
_dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
if (idp == NULL) {
(void) dt_set_errno(dtp, EDT_NOMEM);
free(sip);
return (NULL);
}
sip->dts_object = dmp->dm_name;
sip->dts_name = idp->di_name;
sip->dts_id = idp->di_id;
idp->di_data = sip;
idp->di_ctfp = tip->dtt_ctfp;
idp->di_type = tip->dtt_type;
return (idp);
}
const char *
dt_module_modelname(dt_module_t *dmp)
{
if (dmp->dm_ops == &dt_modops_macho_64)
return ("64-bit");
else if (dmp->dm_ops == &dt_modops_32)
return ("32-bit");
else if (dmp->dm_ops == &dt_modops_64)
return ("64-bit");
else
return ("32-bit");
}
static void
dt_module_update(dtrace_hdl_t *dtp, const char *name)
{
char fname[MAXPATHLEN];
struct stat64 st;
int fd, err, bits;
dt_module_t *dmp;
const char *s;
size_t shstrs;
GElf_Shdr sh;
Elf_Data *dp;
Elf_Scn *sp;
unsigned read_cmd = ELF_C_READ;
if (0 == strcmp("mach_kernel", name)) {
if (dtrace_kernel_path(fname, sizeof(fname)) != 0) {
fprintf(stderr, "failed to retrieve the kernel binary, the module cache will not be updated\n");
return;
}
read_cmd = ELF_C_RDKERNTYPE;
}
if ((fd = open(fname, O_RDONLY)) == -1 || fstat64(fd, &st) == -1 ||
(dmp = dt_module_create(dtp, name)) == NULL) {
dt_dprintf("failed to open %s: %s\n", fname, strerror(errno));
(void) close(fd);
return;
}
dmp->dm_elf = elf_begin(fd, read_cmd, NULL);
err = elf_cntl(dmp->dm_elf, ELF_C_FDREAD);
(void) close(fd);
if (dmp->dm_elf == NULL || err == -1 ||
elf_getshstrndx(dmp->dm_elf, &shstrs) == 0) {
dt_dprintf("failed to load %s: %s\n",
fname, elf_errmsg(elf_errno()));
dt_module_destroy(dtp, dmp);
return;
}
switch (gelf_getclass(dmp->dm_elf)) {
case ELFCLASS32:
dmp->dm_ops = (dmp->dm_elf->ed_kind == ELF_K_MACHO ? &dt_modops_macho_32 : &dt_modops_32);
bits = 32;
break;
case ELFCLASS64:
dmp->dm_ops = (dmp->dm_elf->ed_kind == ELF_K_MACHO ? &dt_modops_macho_64 : &dt_modops_64);
bits = 64;
break;
default:
dt_dprintf("failed to load %s: unknown ELF class\n", fname);
dt_module_destroy(dtp, dmp);
return;
}
for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) {
if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL ||
(s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL)
continue;
if (strcmp(s, ".text") == 0) {
dmp->dm_text_size = sh.sh_size;
dmp->dm_text_va = sh.sh_addr;
} else if (strcmp(s, ".data") == 0) {
dmp->dm_data_size = sh.sh_size;
dmp->dm_data_va = sh.sh_addr;
} else if (strcmp(s, ".bss") == 0) {
dmp->dm_bss_size = sh.sh_size;
dmp->dm_bss_va = sh.sh_addr;
} else if (strcmp(s, ".info") == 0 &&
(dp = elf_getdata(sp, NULL)) != NULL) {
bcopy(dp->d_buf, &dmp->dm_info,
MIN(sh.sh_size, sizeof (dmp->dm_info)));
} else if (strcmp(s, ".filename") == 0 &&
(dp = elf_getdata(sp, NULL)) != NULL) {
(void) strlcpy(dmp->dm_file,
dp->d_buf, sizeof (dmp->dm_file));
}
}
dmp->dm_flags |= DT_DM_KERNEL;
dmp->dm_modid = (int)OBJFS_MODID(st.st_ino);
if (dmp->dm_info.objfs_info_primary)
dmp->dm_flags |= DT_DM_PRIMARY;
dt_dprintf("opened %d-bit module %s (%s) [%d]\n",
bits, dmp->dm_name, dmp->dm_file, dmp->dm_modid);
}
void
dtrace_update(dtrace_hdl_t *dtp)
{
dt_module_t *dmp;
DIR *dirp;
for (dmp = dt_list_next(&dtp->dt_modlist);
dmp != NULL; dmp = dt_list_next(dmp))
dt_module_unload(dtp, dmp);
if (!(dtp->dt_oflags & DTRACE_O_NOSYS)) {
dt_module_update(dtp, "mach_kernel");
}
dt_idhash_lookup(dtp->dt_macros, "egid")->di_id = getegid();
dt_idhash_lookup(dtp->dt_macros, "euid")->di_id = geteuid();
dt_idhash_lookup(dtp->dt_macros, "gid")->di_id = getgid();
dt_idhash_lookup(dtp->dt_macros, "pid")->di_id = getpid();
dt_idhash_lookup(dtp->dt_macros, "pgid")->di_id = getpgid(0);
dt_idhash_lookup(dtp->dt_macros, "ppid")->di_id = getppid();
#ifdef illumos
dt_idhash_lookup(dtp->dt_macros, "projid")->di_id = getprojid();
#endif
dt_idhash_lookup(dtp->dt_macros, "sid")->di_id = getsid(0);
#ifdef illumos
dt_idhash_lookup(dtp->dt_macros, "taskid")->di_id = gettaskid();
#endif
dt_idhash_lookup(dtp->dt_macros, "uid")->di_id = getuid();
dtp->dt_exec = dt_module_lookup_by_name(dtp, "mach_kernel");
dtp->dt_rtld = dt_module_lookup_by_name(dtp, "dyld");
if (dtp->dt_exec != NULL &&
dtp->dt_cdefs == NULL && dtp->dt_ddefs == NULL) {
dt_list_delete(&dtp->dt_modlist, dtp->dt_exec);
dt_list_prepend(&dtp->dt_modlist, dtp->dt_exec);
}
}
static dt_module_t *
dt_module_from_object(dtrace_hdl_t *dtp, const char *object)
{
int err = EDT_NOMOD;
dt_module_t *dmp;
switch ((uintptr_t)object) {
case (uintptr_t)DTRACE_OBJ_EXEC:
dmp = dtp->dt_exec;
break;
case (uintptr_t)DTRACE_OBJ_RTLD:
dmp = dtp->dt_rtld;
break;
case (uintptr_t)DTRACE_OBJ_CDEFS:
dmp = dtp->dt_cdefs;
break;
case (uintptr_t)DTRACE_OBJ_DDEFS:
dmp = dtp->dt_ddefs;
break;
default:
dmp = dt_module_create(dtp, object);
err = EDT_NOMEM;
}
if (dmp == NULL)
(void) dt_set_errno(dtp, err);
return (dmp);
}
int
dtrace_lookup_by_name(dtrace_hdl_t *dtp, const char *object, const char *name,
GElf_Sym *symp, dtrace_syminfo_t *sip)
{
dt_module_t *dmp;
dt_ident_t *idp;
uint_t n, id;
GElf_Sym sym;
uint_t mask = 0;
uint_t bits = 0;
if (object != DTRACE_OBJ_EVERY &&
object != DTRACE_OBJ_KMODS &&
object != DTRACE_OBJ_UMODS) {
if ((dmp = dt_module_from_object(dtp, object)) == NULL)
return (-1);
if (dt_module_load(dtp, dmp) == -1)
return (-1);
n = 1;
} else {
if (object == DTRACE_OBJ_KMODS)
mask = bits = DT_DM_KERNEL;
else if (object == DTRACE_OBJ_UMODS)
mask = DT_DM_KERNEL;
dmp = dt_list_next(&dtp->dt_modlist);
n = dtp->dt_nmods;
}
if (symp == NULL)
symp = &sym;
for (; n > 0; n--, dmp = dt_list_next(dmp)) {
if ((dmp->dm_flags & mask) != bits)
continue;
if (dt_module_load(dtp, dmp) == -1)
continue;
if (dmp->dm_ops->do_symname(dmp, name, symp, &id) != NULL) {
if (sip != NULL) {
sip->dts_object = dmp->dm_name;
sip->dts_name = (const char *)
dmp->dm_strtab.cts_data + symp->st_name;
sip->dts_id = id;
}
return (0);
}
if (dmp->dm_extern != NULL &&
(idp = dt_idhash_lookup(dmp->dm_extern, name)) != NULL) {
if (symp != &sym) {
symp->st_name = (uintptr_t)idp->di_name;
symp->st_info =
GELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
symp->st_other = 0;
symp->st_shndx = SHN_UNDEF;
symp->st_value = 0;
symp->st_size =
ctf_type_size(idp->di_ctfp, idp->di_type);
}
if (sip != NULL) {
sip->dts_object = dmp->dm_name;
sip->dts_name = idp->di_name;
sip->dts_id = idp->di_id;
}
return (0);
}
}
return (dt_set_errno(dtp, EDT_NOSYM));
}
int
dtrace_lookup_by_type(dtrace_hdl_t *dtp, const char *object, const char *name,
dtrace_typeinfo_t *tip)
{
dtrace_typeinfo_t ti;
dt_module_t *dmp;
int found = 0;
ctf_id_t id;
uint_t n;
int justone;
uint_t mask = 0;
uint_t bits = 0;
if (object != DTRACE_OBJ_EVERY &&
object != DTRACE_OBJ_KMODS &&
object != DTRACE_OBJ_UMODS) {
if ((dmp = dt_module_from_object(dtp, object)) == NULL)
return (-1);
if (dt_module_load(dtp, dmp) == -1)
return (-1);
n = 1;
justone = 1;
} else {
if (object == DTRACE_OBJ_KMODS)
mask = bits = DT_DM_KERNEL;
else if (object == DTRACE_OBJ_UMODS)
mask = DT_DM_KERNEL;
dmp = dt_list_next(&dtp->dt_modlist);
n = dtp->dt_nmods;
justone = 0;
}
if (tip == NULL)
tip = &ti;
for (; n > 0; n--, dmp = dt_list_next(dmp)) {
if ((dmp->dm_flags & mask) != bits)
continue;
if (dt_module_getctf(dtp, dmp) == NULL) {
if (justone)
return (-1);
continue;
}
if ((id = ctf_lookup_by_name(dmp->dm_ctfp, name)) != CTF_ERR) {
tip->dtt_object = dmp->dm_name;
tip->dtt_ctfp = dmp->dm_ctfp;
tip->dtt_type = id;
if (ctf_type_kind(dmp->dm_ctfp, ctf_type_resolve(
dmp->dm_ctfp, id)) != CTF_K_FORWARD)
return (0);
found++;
}
}
if (found == 0)
return (dt_set_errno(dtp, EDT_NOTYPE));
return (0);
}
int
dtrace_symbol_type(dtrace_hdl_t *dtp, const GElf_Sym *symp,
const dtrace_syminfo_t *sip, dtrace_typeinfo_t *tip)
{
dt_module_t *dmp;
tip->dtt_object = NULL;
tip->dtt_ctfp = NULL;
tip->dtt_type = CTF_ERR;
tip->dtt_flags = 0;
if ((dmp = dt_module_lookup_by_name(dtp, sip->dts_object)) == NULL)
return (dt_set_errno(dtp, EDT_NOMOD));
if (symp->st_shndx == SHN_UNDEF && dmp->dm_extern != NULL) {
dt_ident_t *idp =
dt_idhash_lookup(dmp->dm_extern, sip->dts_name);
if (idp == NULL)
return (dt_set_errno(dtp, EDT_NOSYM));
tip->dtt_ctfp = idp->di_ctfp;
tip->dtt_type = idp->di_type;
} else if (GELF_ST_TYPE(symp->st_info) != STT_FUNC) {
if (dt_module_getctf(dtp, dmp) == NULL)
return (-1);
tip->dtt_ctfp = dmp->dm_ctfp;
tip->dtt_type = ctf_lookup_by_symbol(dmp->dm_ctfp, sip->dts_id);
if (tip->dtt_type == CTF_ERR) {
dtp->dt_ctferr = ctf_errno(tip->dtt_ctfp);
return (dt_set_errno(dtp, EDT_CTF));
}
} else {
tip->dtt_ctfp = DT_FPTR_CTFP(dtp);
tip->dtt_type = DT_FPTR_TYPE(dtp);
}
tip->dtt_object = dmp->dm_name;
return (0);
}
static dtrace_objinfo_t *
dt_module_info(const dt_module_t *dmp, dtrace_objinfo_t *dto)
{
dto->dto_name = dmp->dm_name;
dto->dto_file = dmp->dm_file;
dto->dto_id = dmp->dm_modid;
dto->dto_flags = 0;
if (dmp->dm_flags & DT_DM_KERNEL)
dto->dto_flags |= DTRACE_OBJ_F_KERNEL;
if (dmp->dm_flags & DT_DM_PRIMARY)
dto->dto_flags |= DTRACE_OBJ_F_PRIMARY;
dto->dto_text_va = dmp->dm_text_va;
dto->dto_text_size = dmp->dm_text_size;
dto->dto_data_va = dmp->dm_data_va;
dto->dto_data_size = dmp->dm_data_size;
dto->dto_bss_va = dmp->dm_bss_va;
dto->dto_bss_size = dmp->dm_bss_size;
return (dto);
}
int
dtrace_object_iter(dtrace_hdl_t *dtp, dtrace_obj_f *func, void *data)
{
const dt_module_t *dmp = dt_list_next(&dtp->dt_modlist);
dtrace_objinfo_t dto;
int rv;
for (; dmp != NULL; dmp = dt_list_next(dmp)) {
if ((rv = (*func)(dtp, dt_module_info(dmp, &dto), data)) != 0)
return (rv);
}
return (0);
}
int
dtrace_object_info(dtrace_hdl_t *dtp, const char *object, dtrace_objinfo_t *dto)
{
dt_module_t *dmp;
if (object == DTRACE_OBJ_EVERY || object == DTRACE_OBJ_KMODS ||
object == DTRACE_OBJ_UMODS || dto == NULL)
return (dt_set_errno(dtp, EINVAL));
if ((dmp = dt_module_from_object(dtp, object)) == NULL)
return (-1);
if (dt_module_load(dtp, dmp) == -1)
return (-1);
(void) dt_module_info(dmp, dto);
return (0);
}