/**
* Detaches a debugger from the specified VM.
*
* Caller must be attached to the VM.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
*/
VMMR3DECL(int) DBGFR3Detach(PVM pVM)
{
LogFlow(("DBGFR3Detach:\n"));
int rc;
/*
* Check if attached.
*/
AssertReturn(pVM->dbgf.s.fAttached, VERR_DBGF_NOT_ATTACHED);
/*
* Try send the detach command.
* Keep in mind that we might be racing EMT, so, be extra careful.
*/
DBGFCMD enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_DETACH_DEBUGGER);
if (RTSemPongIsSpeaker(&pVM->dbgf.s.PingPong))
{
rc = RTSemPong(&pVM->dbgf.s.PingPong);
AssertMsgRCReturn(rc, ("Failed to signal emulation thread. rc=%Rrc\n", rc), rc);
LogRel(("DBGFR3Detach: enmCmd=%d (pong -> ping)\n", enmCmd));
}
/*
* Wait for the OK event.
*/
rc = RTSemPongWait(&pVM->dbgf.s.PingPong, RT_INDEFINITE_WAIT);
AssertLogRelMsgRCReturn(rc, ("Wait on detach command failed, rc=%Rrc\n", rc), rc);
/*
* Send the notification command indicating that we're really done.
*/
enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_DETACHED_DEBUGGER);
rc = RTSemPong(&pVM->dbgf.s.PingPong);
AssertMsgRCReturn(rc, ("Failed to signal emulation thread. rc=%Rrc\n", rc), rc);
LogFlowFunc(("returns VINF_SUCCESS\n"));
return VINF_SUCCESS;
}
/**
* @interface_method_impl{PDMDEVREG,pfnConstruct}
*/
static DECLCALLBACK(int) gimdevR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
{
PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
RT_NOREF2(iInstance, pCfg);
Assert(iInstance == 0);
PGIMDEV pThis = PDMINS_2_DATA(pDevIns, PGIMDEV);
/*
* Initialize relevant state bits.
*/
pThis->pDevInsR3 = pDevIns;
pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
/*
* Get debug setup requirements from GIM.
*/
PVM pVM = PDMDevHlpGetVM(pDevIns);
int rc = GIMR3GetDebugSetup(pVM, &pThis->DbgSetup);
if ( RT_SUCCESS(rc)
&& pThis->DbgSetup.cbDbgRecvBuf > 0)
{
/*
* Attach the stream driver for the debug connection.
*/
PPDMISTREAM pDbgDrvStream = NULL;
pThis->IDbgBase.pfnQueryInterface = gimdevR3QueryInterface;
rc = PDMDevHlpDriverAttach(pDevIns, GIMDEV_DEBUG_LUN, &pThis->IDbgBase, &pThis->pDbgDrvBase, "GIM Debug Port");
if (RT_SUCCESS(rc))
{
pDbgDrvStream = PDMIBASE_QUERY_INTERFACE(pThis->pDbgDrvBase, PDMISTREAM);
if (pDbgDrvStream)
LogRel(("GIMDev: LUN#%u: Debug port configured\n", GIMDEV_DEBUG_LUN));
else
{
LogRel(("GIMDev: LUN#%u: No unit\n", GIMDEV_DEBUG_LUN));
rc = VERR_INTERNAL_ERROR_2;
}
}
else
{
pThis->pDbgDrvBase = NULL;
LogRel(("GIMDev: LUN#%u: No debug port configured! rc=%Rrc\n", GIMDEV_DEBUG_LUN, rc));
}
if (!pDbgDrvStream)
{
Assert(rc != VINF_SUCCESS);
return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
N_("Debug port configuration expected when GIM configured with debugging support"));
}
void *pvDbgRecvBuf = RTMemAllocZ(pThis->DbgSetup.cbDbgRecvBuf);
if (RT_UNLIKELY(!pvDbgRecvBuf))
{
LogRel(("GIMDev: Failed to alloc %u bytes for debug receive buffer\n", pThis->DbgSetup.cbDbgRecvBuf));
return VERR_NO_MEMORY;
}
/*
* Update the shared debug struct.
*/
pThis->Dbg.pDbgDrvStream = pDbgDrvStream;
pThis->Dbg.pvDbgRecvBuf = pvDbgRecvBuf;
pThis->Dbg.cbDbgRecvBufRead = 0;
pThis->Dbg.fDbgRecvBufRead = false;
/*
* Create the sempahore and the debug receive thread itself.
*/
rc = RTSemEventMultiCreate(&pThis->Dbg.hDbgRecvThreadSem);
if (RT_SUCCESS(rc))
{
rc = RTThreadCreate(&pThis->hDbgRecvThread, gimDevR3DbgRecvThread, pDevIns, 0 /*cbStack*/, RTTHREADTYPE_IO,
RTTHREADFLAGS_WAITABLE, "GIMDebugRecv");
if (RT_FAILURE(rc))
{
RTSemEventMultiDestroy(pThis->Dbg.hDbgRecvThreadSem);
pThis->Dbg.hDbgRecvThreadSem = NIL_RTSEMEVENTMULTI;
RTMemFree(pThis->Dbg.pvDbgRecvBuf);
pThis->Dbg.pvDbgRecvBuf = NULL;
return rc;
}
}
else
return rc;
}
/*
* Register this device with the GIM component.
*/
GIMR3GimDeviceRegister(pVM, pDevIns, pThis->DbgSetup.cbDbgRecvBuf ? &pThis->Dbg : NULL);
/*
* Get the MMIO2 regions from the GIM provider.
*/
uint32_t cRegions = 0;
PGIMMMIO2REGION pRegionsR3 = GIMR3GetMmio2Regions(pVM, &cRegions);
if ( cRegions
&& pRegionsR3)
{
/*
* Register the MMIO2 regions.
*/
PGIMMMIO2REGION pCur = pRegionsR3;
for (uint32_t i = 0; i < cRegions; i++, pCur++)
{
Assert(!pCur->fRegistered);
rc = PDMDevHlpMMIO2Register(pDevIns, NULL, pCur->iRegion, pCur->cbRegion, 0 /* fFlags */, &pCur->pvPageR3,
pCur->szDescription);
if (RT_FAILURE(rc))
return rc;
pCur->fRegistered = true;
#if defined(VBOX_WITH_2X_4GB_ADDR_SPACE)
RTR0PTR pR0Mapping = 0;
rc = PDMDevHlpMMIO2MapKernel(pDevIns, NULL, pCur->iRegion, 0 /* off */, pCur->cbRegion, pCur->szDescription,
&pR0Mapping);
AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMapMMIO2IntoR0(%#x,) -> %Rrc\n", pCur->cbRegion, rc), rc);
pCur->pvPageR0 = pR0Mapping;
#else
pCur->pvPageR0 = (RTR0PTR)pCur->pvPageR3;
#endif
/*
* Map into RC if required.
*/
if (pCur->fRCMapping)
{
RTRCPTR pRCMapping = 0;
rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, NULL, pCur->iRegion, 0 /* off */, pCur->cbRegion, pCur->szDescription,
&pRCMapping);
AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMHyperMapMMIO2(%#x,) -> %Rrc\n", pCur->cbRegion, rc), rc);
pCur->pvPageRC = pRCMapping;
}
else
pCur->pvPageRC = NIL_RTRCPTR;
LogRel(("GIMDev: Registered %s\n", pCur->szDescription));
}
}
/** @todo Register SSM: PDMDevHlpSSMRegister(). */
/** @todo Register statistics: STAM_REG(). */
/** @todo Register DBGFInfo: PDMDevHlpDBGFInfoRegister(). */
return VINF_SUCCESS;
}
/**
* rtR3Init worker.
*/
static int rtR3InitBody(uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath)
{
/*
* Early native initialization.
*/
int rc = rtR3InitNativeFirst(fFlags);
AssertMsgRCReturn(rc, ("rtR3InitNativeFirst failed with %Rrc\n", rc), rc);
/*
* Disable error popups.
*/
#if defined(RT_OS_OS2) /** @todo move to private code. */
DosError(FERR_DISABLEHARDERR);
#endif
/*
* Init C runtime locale before we do anything that may end up converting
* paths or we'll end up using the "C" locale for path conversion.
*/
setlocale(LC_CTYPE, "");
/*
* The Process ID.
*/
#ifdef _MSC_VER
g_ProcessSelf = _getpid(); /* crappy ansi compiler */
#else
g_ProcessSelf = getpid();
#endif
/*
* Save the init flags.
*/
g_fInitFlags |= fFlags;
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
# ifdef VBOX
/*
* This MUST be done as the very first thing, before any file is opened.
* The log is opened on demand, but the first log entries may be caused
* by rtThreadInit() below.
*/
const char *pszDisableHostCache = getenv("VBOX_DISABLE_HOST_DISK_CACHE");
if ( pszDisableHostCache != NULL
&& *pszDisableHostCache
&& strcmp(pszDisableHostCache, "0") != 0)
{
RTFileSetForceFlags(RTFILE_O_WRITE, RTFILE_O_WRITE_THROUGH, 0);
RTFileSetForceFlags(RTFILE_O_READWRITE, RTFILE_O_WRITE_THROUGH, 0);
}
# endif /* VBOX */
#endif /* !IN_GUEST && !RT_NO_GIP */
/*
* Thread Thread database and adopt the caller thread as 'main'.
* This must be done before everything else or else we'll call into threading
* without having initialized TLS entries and suchlike.
*/
rc = rtThreadInit();
AssertMsgRCReturn(rc, ("Failed to initialize threads, rc=%Rrc!\n", rc), rc);
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
if (fFlags & RTR3INIT_FLAGS_SUPLIB)
{
/*
* Init GIP first.
* (The more time for updates before real use, the better.)
*/
rc = SUPR3Init(NULL);
AssertMsgRCReturn(rc, ("Failed to initializable the support library, rc=%Rrc!\n", rc), rc);
}
#endif
/*
* The executable path, name and directory. Convert arguments.
*/
rc = rtR3InitProgramPath(pszProgramPath);
AssertLogRelMsgRCReturn(rc, ("Failed to get executable directory path, rc=%Rrc!\n", rc), rc);
rc = rtR3InitArgv(fFlags, cArgs, papszArgs);
AssertLogRelMsgRCReturn(rc, ("Failed to convert the arguments, rc=%Rrc!\n", rc), rc);
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
/*
* The threading is initialized we can safely sleep a bit if GIP
* needs some time to update itself updating.
*/
if ((fFlags & RTR3INIT_FLAGS_SUPLIB) && g_pSUPGlobalInfoPage)
{
RTThreadSleep(20);
RTTimeNanoTS();
}
#endif
/*
* Init the program start TSes.
* Do that here to be sure that the GIP time was properly updated the 1st time.
*/
g_u64ProgramStartNanoTS = RTTimeNanoTS();
g_u64ProgramStartMicroTS = g_u64ProgramStartNanoTS / 1000;
g_u64ProgramStartMilliTS = g_u64ProgramStartNanoTS / 1000000;
/*
* The remainder cannot easily be undone, so it has to go last.
*/
/* Fork and exit callbacks. */
#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
rc = pthread_atfork(NULL, NULL, rtR3ForkChildCallback);
AssertMsg(rc == 0, ("%d\n", rc));
#endif
atexit(rtR3ExitCallback);
#ifdef IPRT_USE_SIG_CHILD_DUMMY
/*
* SIGCHLD must not be ignored (that's default), otherwise posix compliant waitpid
* implementations won't work right.
*/
for (;;)
{
struct sigaction saOld;
rc = sigaction(SIGCHLD, 0, &saOld); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
if ( rc != 0
|| (saOld.sa_flags & SA_SIGINFO)
|| ( saOld.sa_handler != SIG_IGN
&& saOld.sa_handler != SIG_DFL)
)
break;
/* Try install dummy handler. */
struct sigaction saNew = saOld;
saNew.sa_flags = SA_NOCLDSTOP | SA_RESTART;
saNew.sa_handler = rtR3SigChildHandler;
rc = sigemptyset(&saNew.sa_mask); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
struct sigaction saOld2;
rc = sigaction(SIGCHLD, &saNew, &saOld2); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
if ( rc != 0
|| ( saOld2.sa_handler == saOld.sa_handler
&& !(saOld2.sa_flags & SA_SIGINFO))
)
break;
/* Race during dynamic load, restore and try again... */
sigaction(SIGCHLD, &saOld2, NULL);
RTThreadYield();
}
#endif /* IPRT_USE_SIG_CHILD_DUMMY */
#ifdef IPRT_WITH_ALIGNMENT_CHECKS
/*
* Enable alignment checks.
*/
const char *pszAlignmentChecks = getenv("IPRT_ALIGNMENT_CHECKS");
g_fRTAlignmentChecks = pszAlignmentChecks != NULL
&& pszAlignmentChecks[0] == '1'
&& pszAlignmentChecks[1] == '\0';
if (g_fRTAlignmentChecks)
IPRT_ALIGNMENT_CHECKS_ENABLE();
#endif
/*
* Final native initialization.
*/
rc = rtR3InitNativeFinal(fFlags);
AssertMsgRCReturn(rc, ("rtR3InitNativeFinal failed with %Rrc\n", rc), rc);
return VINF_SUCCESS;
}
