/*ARGSUSED*/
static int
dt_opt_cpp_path(dtrace_hdl_t *dtp, const char *arg, uintptr_t option)
{
char *cpp;
if (arg == NULL)
return (dt_set_errno(dtp, EDT_BADOPTVAL));
if (dtp->dt_pcb != NULL)
return (dt_set_errno(dtp, EDT_BADOPTCTX));
if ((cpp = strdup(arg)) == NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
#if defined(__APPLE__)
// We use the full path to cpp
dtp->dt_cpp_argv[0] = cpp;
#else
dtp->dt_cpp_argv[0] = (char *)strbasename(cpp);
#endif
free(dtp->dt_cpp_path);
dtp->dt_cpp_path = cpp;
return (0);
}
/*
* Sends a request to the driver to load the module. If/when the load has
* completed successfully, kmdb_module_loaded is called.
*/
int
mdb_module_load(const char *fname, int mode)
{
const char *modname = strbasename(fname);
kmdb_wr_load_t *dlr;
kmdb_modctl_t *kmc = NULL;
const char *wformat = NULL;
mdb_var_t *v;
if (!mdb_module_validate_name(modname, &wformat))
goto module_load_err;
if ((v = mdb_nv_lookup(&mdb.m_dmodctl, modname)) != NULL) {
kmc = MDB_NV_COOKIE(v);
if (kmc->kmc_state == KMDB_MC_STATE_LOADING)
wformat = "module %s is already being loaded\n";
else
wformat = "module %s is being unloaded\n";
goto module_load_err;
}
kmc = mdb_zalloc(sizeof (kmdb_modctl_t), UM_SLEEP);
kmc->kmc_loadmode = mode;
kmc->kmc_modname = strdup(modname);
kmc->kmc_state = KMDB_MC_STATE_LOADING;
if (mdb_nv_insert(&mdb.m_dmodctl, modname, NULL, (uintptr_t)kmc, 0) ==
NULL) {
wformat = "module %s can't be registered for load\n";
kmc_free(kmc);
goto module_load_err;
}
dlr = mdb_zalloc(sizeof (kmdb_wr_load_t), UM_SLEEP);
dlr->dlr_node.wn_task = WNTASK_DMOD_LOAD;
dlr->dlr_fname = strdup(fname);
kmdb_wr_driver_notify(dlr);
if (!(mode & MDB_MOD_DEFER) &&
mdb_tgt_continue(mdb.m_target, NULL) == 0)
return (0);
if (!(mode & MDB_MOD_SILENT))
mdb_printf("%s load pending (:c to complete)\n", modname);
return (0);
module_load_err:
if (!(mode & MDB_MOD_SILENT))
warn(wformat, modname);
return (-1);
}
static void
print_frame(uintptr_t pc, int fnum)
{
Dl_info dli;
if (dladdr((void *)pc, &dli)) {
mdb_iob_printf(mdb.m_err, " [%d] %s`%s+0x%lx()\n", fnum,
strbasename(dli.dli_fname), dli.dli_sname,
pc - (uintptr_t)dli.dli_saddr);
} else
mdb_iob_printf(mdb.m_err, " [%d] %p()\n", fnum, pc);
}
static kp_file_t *
kp_file_create(mdb_tgt_t *t, kp_map_t *kpm, GElf_Half etype)
{
kp_file_t *kpf = mdb_zalloc(sizeof (kp_file_t), UM_SLEEP);
kp_data_t *kp = t->t_data;
size_t dyns_sz;
void *dyns;
kpf->kpf_fio = kp_io_create(t, kpm);
kpf->kpf_map = kpm;
kpf->kpf_basename = strbasename(kpm->kpm_map.map_name);
kpf->kpf_file = mdb_gelf_create(kpf->kpf_fio, etype, GF_PROGRAM);
kpf->kpf_text_base = kpm->kpm_map.map_base;
if (kpm != kp->kp_map_exec)
kpf->kpf_dyn_base = kpf->kpf_text_base;
if (kpf->kpf_file == NULL)
goto err; /* Failed to create ELF file */
mdb_dprintf(MDB_DBG_TGT, "loading symbols for %s\n",
kpm->kpm_map.map_name);
if ((kp->kp_rap != NULL) && (rd_get_dyns(kp->kp_rap,
kpf->kpf_text_base, &dyns, &dyns_sz) == RD_OK))
mdb_gelf_dyns_set(kpf->kpf_file, dyns, dyns_sz);
kpf->kpf_dynsym = mdb_gelf_symtab_create_dynamic(kpf->kpf_file,
MDB_TGT_DYNSYM);
if (kpf->kpf_dynsym == NULL)
goto err; /* Failed to create symbol table */
kpm->kpm_file = kpf;
if (kp->kp_file_tail != NULL)
kp->kp_file_tail->kpf_next = kpf;
else
kp->kp_file_head = kpf;
kp->kp_file_tail = kpf;
kp->kp_num_files++;
return (kpf);
err:
if (kpf->kpf_file != NULL)
mdb_gelf_destroy(kpf->kpf_file);
else
mdb_io_destroy(kpf->kpf_fio);
mdb_free(kpf, sizeof (kp_file_t));
return (NULL);
}
static int
kp_iter_mapping(const rd_loadobj_t *rlp, mdb_tgt_t *t)
{
kp_data_t *kp = t->t_data;
kp_file_t *kpf;
kp_map_t *kpm;
char name[MDB_TGT_MAPSZ];
if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name,
sizeof (name), (mdb_tgt_addr_t)rlp->rl_nameaddr) <= 0) {
mdb_dprintf(MDB_DBG_TGT, "failed to read name %p",
(void *)rlp->rl_nameaddr);
return (1); /* Keep going; forget this if we can't read name */
}
mdb_dprintf(MDB_DBG_TGT, "rd_loadobj name = \"%s\" rl_base = %p\n",
name, (void *)rlp->rl_base);
if ((kpm = kp_addr_to_kpmap(kp, rlp->rl_base)) == NULL)
return (1); /* Keep going; no mapping at this address */
(void) strncpy(kpm->kpm_map.map_name, name, MDB_TGT_MAPSZ);
kpm->kpm_map.map_name[MDB_TGT_MAPSZ - 1] = '\0';
if ((kpf = kpm->kpm_file) == NULL) {
if (kpm == kp->kp_map_exec)
kpf = kp_file_create(t, kpm, ET_EXEC);
else
kpf = kp_file_create(t, kpm, ET_DYN);
if (kpf == NULL)
return (1); /* Keep going; failed to build ELF file */
} else
kpf->kpf_basename = strbasename(kpm->kpm_map.map_name);
if ((kpm = kp_find_data(kp, kpf, rlp)) != NULL) {
mdb_dprintf(MDB_DBG_TGT, "found data for %s at %p\n",
kpf->kpf_basename, (void *)kpm->kpm_map.map_base);
kpm->kpm_file = kpf;
}
return (1);
}
/*ARGSUSED*/
static int
dt_opt_cpp_path(dtrace_hdl_t *dtp, const char *arg, uintptr_t option)
{
char *cpp;
if (arg == NULL)
return (dt_set_errno(dtp, EDT_BADOPTVAL));
if (dtp->dt_pcb != NULL)
return (dt_set_errno(dtp, EDT_BADOPTCTX));
if ((cpp = strdup(arg)) == NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
dtp->dt_cpp_argv[0] = (char *)strbasename(cpp);
free(dtp->dt_cpp_path);
dtp->dt_cpp_path = cpp;
return (0);
}
void
mdb_create(const char *execname, const char *arg0)
{
static const mdb_nv_disc_t psym_disc = { psym_disc_set, psym_disc_get };
static const mdb_nv_disc_t roff_disc = { roff_disc_set, roff_disc_get };
static const mdb_nv_disc_t thr_disc = { NULL, thr_disc_get };
static char rootdir[MAXPATHLEN];
const mdb_dcmd_t *dcp;
int i;
bzero(&mdb, sizeof (mdb_t));
mdb.m_flags = MDB_FL_PSYM | MDB_FL_PAGER | MDB_FL_BPTNOSYMSTOP |
MDB_FL_READBACK;
mdb.m_radix = MDB_DEF_RADIX;
mdb.m_nargs = MDB_DEF_NARGS;
mdb.m_histlen = MDB_DEF_HISTLEN;
mdb.m_armemlim = MDB_DEF_ARRMEM;
mdb.m_arstrlim = MDB_DEF_ARRSTR;
mdb.m_pname = strbasename(arg0);
if (strcmp(mdb.m_pname, "adb") == 0) {
mdb.m_flags |= MDB_FL_NOMODS | MDB_FL_ADB | MDB_FL_REPLAST;
mdb.m_flags &= ~MDB_FL_PAGER;
}
mdb.m_ipathstr = mdb_zalloc(MAXPATHLEN, UM_SLEEP);
mdb.m_lpathstr = mdb_zalloc(MAXPATHLEN, UM_SLEEP);
(void) strncpy(rootdir, execname, sizeof (rootdir));
rootdir[sizeof (rootdir) - 1] = '\0';
(void) strdirname(rootdir);
if (strcmp(strbasename(rootdir), "sparcv9") == 0 ||
strcmp(strbasename(rootdir), "sparcv7") == 0 ||
strcmp(strbasename(rootdir), "amd64") == 0 ||
strcmp(strbasename(rootdir), "i86") == 0)
(void) strdirname(rootdir);
if (strcmp(strbasename(rootdir), "bin") == 0) {
(void) strdirname(rootdir);
if (strcmp(strbasename(rootdir), "usr") == 0)
(void) strdirname(rootdir);
} else
(void) strcpy(rootdir, "/");
mdb.m_root = rootdir;
mdb.m_rminfo.mi_dvers = MDB_API_VERSION;
mdb.m_rminfo.mi_dcmds = mdb_dcmd_builtins;
mdb.m_rminfo.mi_walkers = NULL;
(void) mdb_nv_create(&mdb.m_rmod.mod_walkers, UM_SLEEP);
(void) mdb_nv_create(&mdb.m_rmod.mod_dcmds, UM_SLEEP);
mdb.m_rmod.mod_name = mdb.m_pname;
mdb.m_rmod.mod_info = &mdb.m_rminfo;
(void) mdb_nv_create(&mdb.m_disasms, UM_SLEEP);
(void) mdb_nv_create(&mdb.m_modules, UM_SLEEP);
(void) mdb_nv_create(&mdb.m_dcmds, UM_SLEEP);
(void) mdb_nv_create(&mdb.m_walkers, UM_SLEEP);
(void) mdb_nv_create(&mdb.m_nv, UM_SLEEP);
mdb.m_dot = mdb_nv_insert(&mdb.m_nv, ".", NULL, 0, MDB_NV_PERSIST);
mdb.m_rvalue = mdb_nv_insert(&mdb.m_nv, "0", NULL, 0, MDB_NV_PERSIST);
mdb.m_roffset =
mdb_nv_insert(&mdb.m_nv, "1", &roff_disc, 0, MDB_NV_PERSIST);
mdb.m_proffset = mdb_nv_insert(&mdb.m_nv, "2", NULL, 0, MDB_NV_PERSIST);
mdb.m_rcount = mdb_nv_insert(&mdb.m_nv, "9", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "b", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "d", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "e", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "m", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "t", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "_", &psym_disc, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "hits", NULL, 0, MDB_NV_PERSIST);
(void) mdb_nv_insert(&mdb.m_nv, "thread", &thr_disc, 0,
MDB_NV_PERSIST | MDB_NV_RDONLY);
mdb.m_prsym = mdb_gelf_symtab_create_mutable();
(void) mdb_nv_insert(&mdb.m_modules, mdb.m_pname, NULL,
(uintptr_t)&mdb.m_rmod, MDB_NV_RDONLY);
for (dcp = &mdb_dcmd_builtins[0]; dcp->dc_name != NULL; dcp++)
(void) mdb_module_add_dcmd(&mdb.m_rmod, dcp, 0);
for (i = 0; mdb_dis_builtins[i] != NULL; i++)
(void) mdb_dis_create(mdb_dis_builtins[i]);
mdb_macalias_create();
mdb_create_builtin_tgts();
(void) mdb_callb_add(NULL, MDB_CALLB_PROMPT, (mdb_callb_f)prompt_update,
NULL);
#ifdef _KMDB
(void) mdb_nv_create(&mdb.m_dmodctl, UM_SLEEP);
#endif
mdb_lex_state_create(&frame0);
mdb_list_append(&mdb.m_flist, &frame0);
mdb.m_frame = &frame0;
}
/*ARGSUSED*/
int
mdb_module_unload(const char *name, int mode)
{
kmdb_modctl_t *kmc = NULL;
const char *basename;
mdb_var_t *v;
/*
* We may have been called with the name from the module itself
* if the caller is iterating through the module list, so we need
* to make a copy of the name. If we don't, we can't use it after
* the call to unload_common(), which frees the module.
*/
name = strdup(name);
basename = strbasename(name);
/*
* Make sure the module is in the proper state for unloading. Modules
* may only be unloaded if they have properly completed loading.
*/
if ((v = mdb_nv_lookup(&mdb.m_dmodctl, basename)) != NULL) {
kmc = MDB_NV_COOKIE(v);
switch (kmc->kmc_state) {
case KMDB_MC_STATE_LOADING:
warn("%s is in the process of loading\n", basename);
return (set_errno(EMDB_NOMOD));
case KMDB_MC_STATE_UNLOADING:
warn("%s is already being unloaded\n", basename);
return (set_errno(EMDB_NOMOD));
default:
ASSERT(kmc->kmc_state == KMDB_MC_STATE_LOADED);
}
if (kmc->kmc_flags & KMDB_MC_FL_NOUNLOAD)
return (set_errno(EMDB_KMODNOUNLOAD));
}
if (mdb_module_unload_common(name) < 0) {
if (!(mode & MDB_MOD_SILENT)) {
mdb_dprintf(MDB_DBG_MODULE, "unload of %s failed\n",
name);
}
return (-1); /* errno is set for us */
}
/*
* Any modules legitimately not listed in dmodctl (builtins, for
* example) will be handled by mdb_module_unload_common. If any of
* them get here, we've got a problem.
*/
if (v == NULL) {
warn("unload of unregistered module %s\n", basename);
return (set_errno(EMDB_NOMOD));
}
ASSERT(kmc->kmc_dlrefcnt == 0);
mdb_gelf_symtab_destroy(kmc->kmc_symtab);
kmdb_module_request_unload(kmc, basename, mode);
return (0);
}
int
kmdb_module_loaded(kmdb_wr_load_t *dlr)
{
struct modctl *modp = dlr->dlr_modctl;
const char *modname = strbasename(dlr->dlr_fname);
struct module *mp;
kmdb_modctl_t *kmc;
mdb_var_t *v;
v = mdb_nv_lookup(&mdb.m_dmodctl, modname);
if (dlr->dlr_errno != 0) {
/*
* We're somewhat limited in the diagnostics that we can
* provide in the event of a failed load. In most load-failure
* cases, the driver can only send up a generic errno. We use
* EMDB_ENOMOD to signal generic errors, and supply our own
* message. This twists the meaning of EMDB_NOMOD somewhat, but
* it's better than defining a new one.
*/
if (dlr->dlr_errno == EMDB_NOMOD) {
mdb_warn("%s does not appear to be a kmdb dmod\n",
modname);
} else {
(void) set_errno(dlr->dlr_errno);
mdb_warn("dmod %s failed to load", modname);
}
if (v != NULL)
mdb_nv_remove(&mdb.m_dmodctl, v);
return (0);
}
if ((mp = modp->mod_mp) == NULL || mp->symhdr == NULL ||
mp->strhdr == NULL || mp->symtbl == NULL || mp->strings == NULL) {
mdb_warn("dmod %s did not load properly\n");
goto module_loaded_err;
}
if ((v = mdb_nv_lookup(&mdb.m_dmodctl, modname)) == NULL) {
kmc = mdb_zalloc(sizeof (kmdb_modctl_t), UM_SLEEP);
kmc->kmc_loadmode = MDB_MOD_LOCAL;
kmc->kmc_modname = strdup(modname);
kmc->kmc_state = KMDB_MC_STATE_LOADING;
(void) mdb_nv_insert(&mdb.m_dmodctl, modname, NULL,
(uintptr_t)kmc, 0);
} else {
kmc = MDB_NV_COOKIE(v);
ASSERT(kmc->kmc_symtab == NULL);
}
kmc->kmc_modctl = modp;
kmc->kmc_exported = (mp->flags & KOBJ_EXPORTED) != 0;
mdb_gelf_ehdr_to_gehdr(&mp->hdr, &kmc->kmc_ehdr);
kmc->kmc_symtab = mdb_gelf_symtab_create_raw(&kmc->kmc_ehdr, mp->symhdr,
mp->symtbl, mp->strhdr, mp->strings,
MDB_TGT_SYMTAB);
if (mp->flags & KOBJ_PRIM)
kmc->kmc_flags |= KMDB_MC_FL_NOUNLOAD;
if (mdb_module_create(modname, modp->mod_filename,
kmc->kmc_loadmode, &kmc->kmc_mod) < 0)
goto module_loaded_err;
kmc->kmc_state = KMDB_MC_STATE_LOADED;
return (1);
module_loaded_err:
if (kmc->kmc_symtab != NULL)
mdb_gelf_symtab_destroy(kmc->kmc_symtab);
kmdb_module_request_unload(kmc, kmc->kmc_modname, MDB_MOD_DEFER);
return (0);
}
static int
kmdb_dbgnotify_cb(kmdb_wr_t *wn, void *arg)
{
work_results_t *res = arg;
switch (WR_TASK(wn)) {
case WNTASK_DMOD_LOAD: {
/*
* If this is an ack, the driver finished processing a load we
* requested. We process it and free the message. If this
* isn't an ack, then it's a driver-initiated load. We process
* the message, and send it back as an ack so the driver can
* free it.
*/
kmdb_wr_load_t *dlr = (kmdb_wr_load_t *)wn;
mdb_dprintf(MDB_DBG_DPI, "received module load message\n");
if (kmdb_module_loaded(dlr) && res != NULL) {
(void) mdb_nv_insert(&res->res_loads,
strbasename(dlr->dlr_fname), NULL, 0, 0);
}
if (WR_ISACK(dlr)) {
kmdb_module_load_ack(dlr);
return (0);
}
/* Send it back as an ack */
mdb_dprintf(MDB_DBG_DPI, "Sending load request for %s back "
"as an ack\n", dlr->dlr_fname);
WR_ACK(wn);
kmdb_wr_driver_notify(wn);
return (0);
}
case WNTASK_DMOD_LOAD_ALL:
/*
* We initiated the load-all, so this must be an ack. The
* individual module load messages will arrive separately -
* there's no need to do anything further with this message.
*/
ASSERT(WR_ISACK(wn));
mdb_dprintf(MDB_DBG_DPI, "received module load all ack\n");
kmdb_module_load_all_ack(wn);
return (0);
case WNTASK_DMOD_UNLOAD: {
/*
* The debugger received an unload message. The driver isn't
* supposed to initiate unloads, so we shouldn't see anything
* but acks. We tell the dmod subsystem that the module has
* been unloaded, and we free the message.
*/
kmdb_wr_unload_t *dur = (kmdb_wr_unload_t *)wn;
ASSERT(WR_ISACK(dur));
mdb_dprintf(MDB_DBG_DPI, "received module unload ack\n");
if (kmdb_module_unloaded(dur) && res != NULL) {
(void) mdb_nv_insert(&res->res_unloads,
dur->dur_modname, NULL, 0, 0);
}
/* Done with message */
kmdb_module_unload_ack(dur);
return (0);
}
case WNTASK_DMOD_PATH_CHANGE: {
/*
* The debugger received a path change message. The driver
* can't initiate these, so it must be an acknowledgement.
* There's no processing to be done, so just free the message.
*/
kmdb_wr_path_t *dpth = (kmdb_wr_path_t *)wn;
ASSERT(WR_ISACK(dpth));
mdb_dprintf(MDB_DBG_DPI, "received path change ack\n");
kmdb_module_path_ack(dpth);
return (0);
}
default:
mdb_warn("Received unknown message type %d from driver\n",
wn->wn_task);
/* Ignore it */
return (0);
}
}
