mdb_iwalker_t *
mdb_walker_lookup(const char *s)
{
const char *p = strchr(s, '`');
mdb_var_t *v;
if (p != NULL) {
size_t nbytes = MIN((size_t)(p - s), MDB_NV_NAMELEN - 1);
char mname[MDB_NV_NAMELEN];
mdb_module_t *mod;
(void) strncpy(mname, s, nbytes);
mname[nbytes] = '\0';
if ((v = mdb_nv_lookup(&mdb.m_modules, mname)) == NULL) {
(void) set_errno(EMDB_NOMOD);
return (NULL);
}
mod = mdb_nv_get_cookie(v);
if ((v = mdb_nv_lookup(&mod->mod_walkers, ++p)) != NULL)
return (mdb_nv_get_cookie(v));
} else if ((v = mdb_nv_lookup(&mdb.m_walkers, s)) != NULL)
return (mdb_nv_get_cookie(mdb_nv_get_cookie(v)));
(void) set_errno(EMDB_NOWALK);
return (NULL);
}
static int
tab_complete_walker(mdb_var_t *v, void *arg)
{
mdb_iwalker_t *iwp = mdb_nv_get_cookie(mdb_nv_get_cookie(v));
mdb_tab_cookie_t *mcp = arg;
mdb_tab_insert(mcp, iwp->iwlk_name);
return (0);
}
static mdb_idcmd_t *
dcmd_ndef(const mdb_idcmd_t *idcp)
{
mdb_var_t *v = mdb_nv_get_ndef(idcp->idc_var);
if (v != NULL)
return (mdb_nv_get_cookie(mdb_nv_get_cookie(v)));
return (NULL);
}
static int
tab_complete_dcmd(mdb_var_t *v, void *arg)
{
mdb_idcmd_t *idcp = mdb_nv_get_cookie(mdb_nv_get_cookie(v));
mdb_tab_cookie_t *mcp = (mdb_tab_cookie_t *)arg;
/*
* The way that mdb is implemented, even commands like $C will show up
* here. As such, we don't want to match anything that doesn't start
* with an alpha or number. While nothing currently appears (via a
* cursory search with mdb -k) to start with a capital letter or a
* number, we'll support them anyways.
*/
if (!isalnum(idcp->idc_name[0]))
return (0);
mdb_tab_insert(mcp, idcp->idc_name);
return (0);
}
int
kt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name,
GElf_Sym *symp, mdb_syminfo_t *sip)
{
kt_data_t *kt = t->t_data;
kt_module_t *km, kmod;
mdb_var_t *v;
int n;
/*
* To simplify the implementation, we create a fake module on the stack
* which is "prepended" to k_modlist and whose symtab is kt->k_symtab.
*/
kmod.km_symtab = kt->k_symtab;
kmod.km_list.ml_next = mdb_list_next(&kt->k_modlist);
switch ((uintptr_t)obj) {
case (uintptr_t)MDB_TGT_OBJ_EXEC:
km = &kmod;
n = 1;
break;
case (uintptr_t)MDB_TGT_OBJ_EVERY:
km = &kmod;
n = mdb_nv_size(&kt->k_modules) + 1;
break;
case (uintptr_t)MDB_TGT_OBJ_RTLD:
obj = KT_RTLD_NAME;
/*FALLTHRU*/
default:
if ((v = mdb_nv_lookup(&kt->k_modules, obj)) == NULL)
return (set_errno(EMDB_NOOBJ));
km = mdb_nv_get_cookie(v);
n = 1;
if (km->km_symtab == NULL)
kt_load_module(kt, t, km);
}
for (; n > 0; n--, km = mdb_list_next(km)) {
if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name,
symp, &sip->sym_id) == 0) {
sip->sym_table = MDB_TGT_SYMTAB;
return (0);
}
}
return (set_errno(EMDB_NOSYM));
}
int
kt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
{
kt_data_t *kt = t->t_data;
struct as *asp;
physaddr_t pa;
mdb_module_t *mod;
mdb_var_t *v;
int (*fptr)(uintptr_t, struct as *, physaddr_t *);
switch ((uintptr_t)as) {
case (uintptr_t)MDB_TGT_AS_PHYS:
case (uintptr_t)MDB_TGT_AS_FILE:
case (uintptr_t)MDB_TGT_AS_IO:
return (set_errno(EINVAL));
case (uintptr_t)MDB_TGT_AS_VIRT:
asp = kt->k_as;
break;
default:
asp = (struct as *)as;
}
if ((pa = kvm_physaddr(kt->k_cookie, asp, va)) != -1ULL) {
*pap = pa;
return (0);
}
if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL &&
(mod = mdb_nv_get_cookie(v)) != NULL) {
fptr = (int (*)(uintptr_t, struct as *, physaddr_t *))
dlsym(mod->mod_hdl, "platform_vtop");
if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0))
return (0);
}
return (set_errno(EMDB_NOMAP));
}
void
mdb_destroy(void)
{
const mdb_dcmd_t *dcp;
mdb_var_t *v;
int unload_mode = MDB_MOD_SILENT;
#ifdef _KMDB
unload_mode |= MDB_MOD_DEFER;
#endif
mdb_intr_disable();
mdb_macalias_destroy();
/*
* Some targets use modules during ->t_destroy, so do it first.
*/
if (mdb.m_target != NULL)
(void) mdb_tgt_destroy(mdb.m_target);
/*
* Unload modules _before_ destroying the disassemblers since a
* module that installs a disassembler should try to clean up after
* itself.
*/
mdb_module_unload_all(unload_mode);
mdb_nv_rewind(&mdb.m_disasms);
while ((v = mdb_nv_advance(&mdb.m_disasms)) != NULL)
mdb_dis_destroy(mdb_nv_get_cookie(v));
mdb_callb_remove_all();
if (mdb.m_defdisasm != NULL)
strfree(mdb.m_defdisasm);
if (mdb.m_prsym != NULL)
mdb_gelf_symtab_destroy(mdb.m_prsym);
for (dcp = &mdb_dcmd_builtins[0]; dcp->dc_name != NULL; dcp++)
(void) mdb_module_remove_dcmd(&mdb.m_rmod, dcp->dc_name);
mdb_nv_destroy(&mdb.m_nv);
mdb_nv_destroy(&mdb.m_walkers);
mdb_nv_destroy(&mdb.m_dcmds);
mdb_nv_destroy(&mdb.m_modules);
mdb_nv_destroy(&mdb.m_disasms);
mdb_free(mdb.m_ipathstr, MAXPATHLEN);
mdb_free(mdb.m_lpathstr, MAXPATHLEN);
if (mdb.m_ipath != NULL)
mdb_path_free(mdb.m_ipath, mdb.m_ipathlen);
if (mdb.m_lpath != NULL)
mdb_path_free(mdb.m_lpath, mdb.m_lpathlen);
if (mdb.m_in != NULL)
mdb_iob_destroy(mdb.m_in);
mdb_iob_destroy(mdb.m_out);
mdb.m_out = NULL;
mdb_iob_destroy(mdb.m_err);
mdb.m_err = NULL;
if (mdb.m_log != NULL)
mdb_io_rele(mdb.m_log);
mdb_lex_state_destroy(&frame0);
}
int
kt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type,
mdb_tgt_sym_f *cb, void *data)
{
kt_data_t *kt = t->t_data;
kt_module_t *km;
mdb_gelf_symtab_t *symtab = NULL;
mdb_var_t *v;
switch ((uintptr_t)obj) {
case (uintptr_t)MDB_TGT_OBJ_EXEC:
if (which == MDB_TGT_SYMTAB)
symtab = kt->k_symtab;
else
symtab = kt->k_dynsym;
break;
case (uintptr_t)MDB_TGT_OBJ_EVERY:
if (which == MDB_TGT_DYNSYM) {
symtab = kt->k_dynsym;
obj = MDB_TGT_OBJ_EXEC;
break;
}
mdb_nv_rewind(&kt->k_modules);
while ((v = mdb_nv_advance(&kt->k_modules)) != NULL) {
km = mdb_nv_get_cookie(v);
if (km->km_symtab == NULL)
kt_load_module(kt, t, km);
if (km->km_symtab != NULL)
kt_symtab_iter(km->km_symtab, type,
km->km_name, cb, data);
}
break;
case (uintptr_t)MDB_TGT_OBJ_RTLD:
obj = KT_RTLD_NAME;
/*FALLTHRU*/
default:
v = mdb_nv_lookup(&kt->k_modules, obj);
if (v == NULL)
return (set_errno(EMDB_NOOBJ));
km = mdb_nv_get_cookie(v);
if (km->km_symtab == NULL)
kt_load_module(kt, t, km);
symtab = km->km_symtab;
}
if (symtab)
kt_symtab_iter(symtab, type, obj, cb, data);
return (0);
}
