static void kt_load_module(kt_data_t *kt, mdb_tgt_t *t, kt_module_t *km) { km->km_data = mdb_alloc(km->km_datasz, UM_SLEEP); (void) mdb_tgt_vread(t, km->km_data, km->km_datasz, km->km_symspace_va); km->km_symbuf = (void *) KT_RELOC_BUF(km->km_symtab_va, km->km_symspace_va, km->km_data); km->km_strtab = (char *) KT_RELOC_BUF(km->km_strtab_va, km->km_symspace_va, km->km_data); km->km_symtab = mdb_gelf_symtab_create_raw(&kt->k_file->gf_ehdr, &km->km_symtab_hdr, km->km_symbuf, &km->km_strtab_hdr, km->km_strtab, MDB_TGT_SYMTAB); }
/* * Called by the kmdb_kvm target upon debugger reentry, this routine checks * to see if the loaded dmods have changed. Of particular interest is the * exportation of dmod symbol tables, which will happen during the boot * process for dmods that were loaded prior to kernel startup. If this * has occurred, we'll need to reconstruct our view of the symbol tables for * the affected dmods, since the old symbol tables lived in bootmem * and have been moved during the kobj_export_module(). * * Also, any ctf_file_t we might have opened is now invalid, since it * has internal pointers to the old data as well. */ void kmdb_module_sync(void) { mdb_var_t *v; mdb_nv_rewind(&mdb.m_dmodctl); while ((v = mdb_nv_advance(&mdb.m_dmodctl)) != NULL) { kmdb_modctl_t *kmc = MDB_NV_COOKIE(v); struct module *mp; if (kmc->kmc_state != KMDB_MC_STATE_LOADED) continue; mp = kmc->kmc_modctl->mod_mp; if ((mp->flags & (KOBJ_PRIM | KOBJ_EXPORTED)) && !kmc->kmc_exported) { /* * The exporting process moves the symtab from boot * scratch memory to vmem. */ if (kmc->kmc_symtab != NULL) mdb_gelf_symtab_destroy(kmc->kmc_symtab); kmc->kmc_symtab = mdb_gelf_symtab_create_raw( &kmc->kmc_ehdr, mp->symhdr, mp->symtbl, mp->strhdr, mp->strings, MDB_TGT_SYMTAB); if (kmc->kmc_mod->mod_ctfp != NULL) { ctf_close(kmc->kmc_mod->mod_ctfp); kmc->kmc_mod->mod_ctfp = mdb_ctf_open(kmc->kmc_modname, NULL); } kmc->kmc_exported = TRUE; } } }
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); }