static void dotest(void)
{
RTDBGKRNLINFO hKrnlInfo;
RTTESTI_CHECK_RC_RETV(RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0), VINF_SUCCESS);
static const char * const s_apszSyms[] =
{
"ast_pending",
"cpu_interrupt",
"dtrace_register",
"dtrace_suspend",
"kext_alloc",
"kext_free",
"vm_map_protect"
};
for (unsigned i = 0; i < RT_ELEMENTS(s_apszSyms); i++)
{
void *pvValue = NULL;
int rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, s_apszSyms[i], &pvValue);
RTTestIPrintf(RTTESTLVL_ALWAYS, "%Rrc %p %s\n", rc, pvValue, s_apszSyms[i]);
RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
if (RT_SUCCESS(rc))
RTTESTI_CHECK_RC(RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, s_apszSyms[i], NULL), VINF_SUCCESS);
}
RTTESTI_CHECK_RC(RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "no_such_symbol_name_really", NULL), VERR_SYMBOL_NOT_FOUND);
RTTESTI_CHECK(RTR0DbgKrnlInfoRelease(hKrnlInfo) == 0);
RTTESTI_CHECK(RTR0DbgKrnlInfoRelease(NIL_RTDBGKRNLINFO) == 0);
}
/**
* Resolves kernel symbols we want (but may do without).
*/
static void vboxdrvDarwinResolveSymbols(void)
{
RTDBGKRNLINFO hKrnlInfo;
int rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0);
if (RT_SUCCESS(rc))
{
/* The VMX stuff. */
int rc1 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_resume", (void **)&g_pfnVmxResume);
int rc2 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_suspend", (void **)&g_pfnVmxSuspend);
int rc3 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_use_count", (void **)&g_pVmxUseCount);
if (RT_SUCCESS(rc1) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
{
LogRel(("VBoxDrv: vmx_resume=%p vmx_suspend=%p vmx_use_count=%p (%d) cr4=%#x\n",
g_pfnVmxResume, g_pfnVmxSuspend, g_pVmxUseCount, *g_pVmxUseCount, ASMGetCR4() ));
}
else
{
LogRel(("VBoxDrv: failed to resolve vmx stuff: vmx_resume=%Rrc vmx_suspend=%Rrc vmx_use_count=%Rrc", rc1, rc2, rc3));
g_pfnVmxResume = NULL;
g_pfnVmxSuspend = NULL;
g_pVmxUseCount = NULL;
}
RTR0DbgKrnlInfoRelease(hKrnlInfo);
}
else
LogRel(("VBoxDrv: Failed to open kernel symbols, rc=%Rrc\n", rc));
}
/**
* Module initialization code.
*
* @param hMod Opque module handle.
*/
const SUPDRVTRACERREG * VBOXCALL supdrvDTraceInit(void)
{
#ifdef RT_OS_DARWIN
/*
* Resolve the kernel symbols we need.
*/
RTDBGKRNLINFO hKrnlInfo;
int rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0);
if (RT_FAILURE(rc))
{
SUPR0Printf("supdrvDTraceInit: RTR0DbgKrnlInfoOpen failed with rc=%d.\n", rc);
return NULL;
}
static const struct
{
const char *pszName;
PFNRT *ppfn;
} s_aDTraceFunctions[] =
{
{ "dtrace_probe", (PFNRT*)&dtrace_probe },
{ "dtrace_probe_create", (PFNRT*)&dtrace_probe_create },
{ "dtrace_probe_lookup", (PFNRT*)&dtrace_probe_lookup },
{ "dtrace_register", (PFNRT*)&dtrace_register },
{ "dtrace_invalidate", (PFNRT*)&dtrace_invalidate },
{ "dtrace_unregister", (PFNRT*)&dtrace_unregister },
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aDTraceFunctions); i++)
{
rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, s_aDTraceFunctions[i].pszName,
(void **)s_aDTraceFunctions[i].ppfn);
if (RT_FAILURE(rc))
{
SUPR0Printf("supdrvDTraceInit: Failed to resolved '%s' (rc=%Rrc, i=%u).\n", s_aDTraceFunctions[i].pszName, rc, i);
break;
}
}
RTR0DbgKrnlInfoRelease(hKrnlInfo);
if (RT_FAILURE(rc))
return NULL;
#endif
return &g_VBoxDTraceReg;
}
DECLHIDDEN(int) rtR0InitNative(void)
{
/*
* Create the lock group.
*/
g_pDarwinLockGroup = lck_grp_alloc_init("IPRT", LCK_GRP_ATTR_NULL);
AssertReturn(g_pDarwinLockGroup, VERR_NO_MEMORY);
/*
* Initialize the preemption hacks.
*/
int rc = rtThreadPreemptDarwinInit();
if (RT_SUCCESS(rc))
{
/*
* Try resolve kernel symbols we need but apple don't wish to give us.
*/
RTDBGKRNLINFO hKrnlInfo;
rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0 /*fFlags*/);
if (RT_SUCCESS(rc))
{
RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "ast_pending", (void **)&g_pfnR0DarwinAstPending);
printf("ast_pending=%p\n", g_pfnR0DarwinAstPending);
RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "cpu_interrupt", (void **)&g_pfnR0DarwinCpuInterrupt);
printf("cpu_interrupt=%p\n", g_pfnR0DarwinCpuInterrupt);
RTR0DbgKrnlInfoRelease(hKrnlInfo);
}
if (RT_FAILURE(rc))
{
printf("rtR0InitNative: warning! failed to resolve special kernel symbols\n");
rc = VINF_SUCCESS;
}
}
if (RT_FAILURE(rc))
rtR0TermNative();
return rc;
}
DECLHIDDEN(int) rtR0InitNative(void)
{
/*
* IPRT has not yet been initialized at this point, so use Solaris' native cmn_err() for logging.
*/
int rc = RTR0DbgKrnlInfoOpen(&g_hKrnlDbgInfo, 0 /* fFlags */);
if (RT_SUCCESS(rc))
{
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
/*
* Detect whether spl*() is preserving the interrupt flag or not.
* This is a problem on S10.
*/
RTCCUINTREG uOldFlags = ASMIntDisableFlags();
int iOld = splr(DISP_LEVEL);
if (ASMIntAreEnabled())
g_frtSolSplSetsEIF = true;
splx(iOld);
if (ASMIntAreEnabled())
g_frtSolSplSetsEIF = true;
ASMSetFlags(uOldFlags);
#else
/* PORTME: See if the amd64/x86 problem applies to this architecture. */
#endif
/*
* Mandatory: Preemption offsets.
*/
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "cpu_t", "cpu_runrun", &g_offrtSolCpuPreempt);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find cpu_t::cpu_runrun!\n");
goto errorbail;
}
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "cpu_t", "cpu_kprunrun", &g_offrtSolCpuForceKernelPreempt);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find cpu_t::cpu_kprunrun!\n");
goto errorbail;
}
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "kthread_t", "t_preempt", &g_offrtSolThreadPreempt);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find kthread_t::t_preempt!\n");
goto errorbail;
}
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "kthread_t", "t_did", &g_offrtSolThreadId);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find kthread_t::t_did!\n");
goto errorbail;
}
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "kthread_t", "t_intr", &g_offrtSolThreadIntrThread);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find kthread_t::t_intr!\n");
goto errorbail;
}
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "kthread_t", "t_lockp", &g_offrtSolThreadLock);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find kthread_t::t_lockp!\n");
goto errorbail;
}
rc = RTR0DbgKrnlInfoQueryMember(g_hKrnlDbgInfo, NULL, "kthread_t", "t_procp", &g_offrtSolThreadProc);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "Failed to find kthread_t::t_procp!\n");
goto errorbail;
}
cmn_err(CE_CONT, "!cpu_t::cpu_runrun @ 0x%lx (%ld)\n", g_offrtSolCpuPreempt, g_offrtSolCpuPreempt);
cmn_err(CE_CONT, "!cpu_t::cpu_kprunrun @ 0x%lx (%ld)\n", g_offrtSolCpuForceKernelPreempt, g_offrtSolCpuForceKernelPreempt);
cmn_err(CE_CONT, "!kthread_t::t_preempt @ 0x%lx (%ld)\n", g_offrtSolThreadPreempt, g_offrtSolThreadPreempt);
cmn_err(CE_CONT, "!kthread_t::t_did @ 0x%lx (%ld)\n", g_offrtSolThreadId, g_offrtSolThreadId);
cmn_err(CE_CONT, "!kthread_t::t_intr @ 0x%lx (%ld)\n", g_offrtSolThreadIntrThread, g_offrtSolThreadIntrThread);
cmn_err(CE_CONT, "!kthread_t::t_lockp @ 0x%lx (%ld)\n", g_offrtSolThreadLock, g_offrtSolThreadLock);
cmn_err(CE_CONT, "!kthread_t::t_procp @ 0x%lx (%ld)\n", g_offrtSolThreadProc, g_offrtSolThreadProc);
/*
* Mandatory: CPU cross call infrastructure. Refer the-solaris-kernel.h for details.
*/
rc = RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /* pszModule */, "xc_init_cpu", NULL /* ppvSymbol */);
if (RT_SUCCESS(rc))
{
if (ncpus > IPRT_SOL_NCPUS)
{
cmn_err(CE_NOTE, "rtR0InitNative: CPU count mismatch! ncpus=%d IPRT_SOL_NCPUS=%d\n", ncpus, IPRT_SOL_NCPUS);
rc = VERR_NOT_SUPPORTED;
goto errorbail;
}
g_rtSolXcCall.u.pfnSol_xc_call = (void *)xc_call;
}
else
{
g_frtSolOldIPI = true;
g_rtSolXcCall.u.pfnSol_xc_call_old = (void *)xc_call;
if (max_cpuid + 1 == sizeof(ulong_t) * 8)
{
g_frtSolOldIPIUlong = true;
g_rtSolXcCall.u.pfnSol_xc_call_old_ulong = (void *)xc_call;
}
else if (max_cpuid + 1 != IPRT_SOL_NCPUS)
{
cmn_err(CE_NOTE, "rtR0InitNative: cpuset_t size mismatch! max_cpuid=%d IPRT_SOL_NCPUS=%d\n", max_cpuid,
IPRT_SOL_NCPUS);
rc = VERR_NOT_SUPPORTED;
goto errorbail;
}
}
/*
* Mandatory: Thread-context hooks.
*/
rc = RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /* pszModule */, "exitctx", NULL /* ppvSymbol */);
if (RT_SUCCESS(rc))
{
g_rtSolThreadCtx.Install.pfnSol_installctx = (void *)installctx;
g_rtSolThreadCtx.Remove.pfnSol_removectx = (void *)removectx;
}
else
{
g_frtSolOldThreadCtx = true;
g_rtSolThreadCtx.Install.pfnSol_installctx_old = (void *)installctx;
g_rtSolThreadCtx.Remove.pfnSol_removectx_old = (void *)removectx;
}
/*
* Optional: Timeout hooks.
*/
RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /* pszModule */, "timeout_generic",
(void **)&g_pfnrtR0Sol_timeout_generic);
RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /* pszModule */, "untimeout_generic",
(void **)&g_pfnrtR0Sol_untimeout_generic);
if ((g_pfnrtR0Sol_timeout_generic == NULL) != (g_pfnrtR0Sol_untimeout_generic == NULL))
{
static const char *s_apszFn[2] = { "timeout_generic", "untimeout_generic" };
bool iMissingFn = g_pfnrtR0Sol_timeout_generic == NULL;
cmn_err(CE_NOTE, "rtR0InitNative: Weird! Found %s but not %s!\n", s_apszFn[!iMissingFn], s_apszFn[iMissingFn]);
g_pfnrtR0Sol_timeout_generic = NULL;
g_pfnrtR0Sol_untimeout_generic = NULL;
}
RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /* pszModule */, "cyclic_reprogram",
(void **)&g_pfnrtR0Sol_cyclic_reprogram);
/*
* Optional: Querying page no-relocation support.
*/
RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /*pszModule */, "page_noreloc_supported",
(void **)&g_pfnrtR0Sol_page_noreloc_supported);
/*
* Weak binding failures: contig_free
*/
if (g_pfnrtR0Sol_contig_free == NULL)
{
rc = RTR0DbgKrnlInfoQuerySymbol(g_hKrnlDbgInfo, NULL /* pszModule */, "contig_free",
(void **)&g_pfnrtR0Sol_contig_free);
if (RT_FAILURE(rc))
{
cmn_err(CE_NOTE, "rtR0InitNative: failed to find contig_free!\n");
goto errorbail;
}
}
g_frtSolInitDone = true;
return VINF_SUCCESS;
}
else
{
cmn_err(CE_NOTE, "RTR0DbgKrnlInfoOpen failed. rc=%d\n", rc);
return rc;
}
errorbail:
RTR0DbgKrnlInfoRelease(g_hKrnlDbgInfo);
return rc;
}
DECLHIDDEN(void) rtR0TermNative(void)
{
RTR0DbgKrnlInfoRelease(g_hKrnlDbgInfo);
g_frtSolInitDone = false;
}
