/**
* Initializes the address space parts of DBGF.
*
* @returns VBox status code.
* @param pUVM The user mode VM handle.
*/
int dbgfR3AsInit(PUVM pUVM)
{
Assert(pUVM->pVM);
/*
* Create the semaphore.
*/
int rc = RTSemRWCreate(&pUVM->dbgf.s.hAsDbLock);
AssertRCReturn(rc, rc);
/*
* Create the debugging config instance and set it up, defaulting to
* deferred loading in order to keep things fast.
*/
rc = RTDbgCfgCreate(&pUVM->dbgf.s.hDbgCfg, NULL, true /*fNativePaths*/);
AssertRCReturn(rc, rc);
rc = RTDbgCfgChangeUInt(pUVM->dbgf.s.hDbgCfg, RTDBGCFGPROP_FLAGS, RTDBGCFGOP_PREPEND,
RTDBGCFG_FLAGS_DEFERRED);
AssertRCReturn(rc, rc);
static struct
{
RTDBGCFGPROP enmProp;
const char *pszEnvName;
const char *pszCfgName;
} const s_aProps[] =
{
{ RTDBGCFGPROP_FLAGS, "VBOXDBG_FLAGS", "Flags" },
{ RTDBGCFGPROP_PATH, "VBOXDBG_PATH", "Path" },
{ RTDBGCFGPROP_SUFFIXES, "VBOXDBG_SUFFIXES", "Suffixes" },
{ RTDBGCFGPROP_SRC_PATH, "VBOXDBG_SRC_PATH", "SrcPath" },
};
PCFGMNODE pCfgDbgf = CFGMR3GetChild(CFGMR3GetRootU(pUVM), "/DBGF");
for (unsigned i = 0; i < RT_ELEMENTS(s_aProps); i++)
{
char szEnvValue[8192];
rc = RTEnvGetEx(RTENV_DEFAULT, s_aProps[i].pszEnvName, szEnvValue, sizeof(szEnvValue), NULL);
if (RT_SUCCESS(rc))
{
rc = RTDbgCfgChangeString(pUVM->dbgf.s.hDbgCfg, s_aProps[i].enmProp, RTDBGCFGOP_PREPEND, szEnvValue);
if (RT_FAILURE(rc))
return VMR3SetError(pUVM, rc, RT_SRC_POS,
"DBGF Config Error: %s=%s -> %Rrc", s_aProps[i].pszEnvName, szEnvValue, rc);
}
else if (rc != VERR_ENV_VAR_NOT_FOUND)
return VMR3SetError(pUVM, rc, RT_SRC_POS,
"DBGF Config Error: Error querying env.var. %s: %Rrc", s_aProps[i].pszEnvName, rc);
char *pszCfgValue;
rc = CFGMR3QueryStringAllocDef(pCfgDbgf, s_aProps[i].pszCfgName, &pszCfgValue, NULL);
if (RT_FAILURE(rc))
return VMR3SetError(pUVM, rc, RT_SRC_POS,
"DBGF Config Error: Querying /DBGF/%s -> %Rrc", s_aProps[i].pszCfgName, rc);
if (pszCfgValue)
{
rc = RTDbgCfgChangeString(pUVM->dbgf.s.hDbgCfg, s_aProps[i].enmProp, RTDBGCFGOP_PREPEND, pszCfgValue);
if (RT_FAILURE(rc))
return VMR3SetError(pUVM, rc, RT_SRC_POS,
"DBGF Config Error: /DBGF/%s=%s -> %Rrc", s_aProps[i].pszCfgName, pszCfgValue, rc);
}
}
/*
* Prepend the NoArch and VBoxDbgSyms directories to the path.
*/
char szPath[RTPATH_MAX];
rc = RTPathAppPrivateNoArch(szPath, sizeof(szPath));
AssertRCReturn(rc, rc);
#ifdef RT_OS_DARWIN
rc = RTPathAppend(szPath, sizeof(szPath), "../Resources/VBoxDbgSyms/");
#else
rc = RTDbgCfgChangeString(pUVM->dbgf.s.hDbgCfg, RTDBGCFGPROP_PATH, RTDBGCFGOP_PREPEND, szPath);
AssertRCReturn(rc, rc);
rc = RTPathAppend(szPath, sizeof(szPath), "VBoxDbgSyms/");
#endif
AssertRCReturn(rc, rc);
rc = RTDbgCfgChangeString(pUVM->dbgf.s.hDbgCfg, RTDBGCFGPROP_PATH, RTDBGCFGOP_PREPEND, szPath);
AssertRCReturn(rc, rc);
/*
* Create the standard address spaces.
*/
RTDBGAS hDbgAs;
rc = RTDbgAsCreate(&hDbgAs, 0, RTGCPTR_MAX, "Global");
AssertRCReturn(rc, rc);
rc = DBGFR3AsAdd(pUVM, hDbgAs, NIL_RTPROCESS);
AssertRCReturn(rc, rc);
RTDbgAsRetain(hDbgAs);
pUVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(DBGF_AS_GLOBAL)] = hDbgAs;
RTDbgAsRetain(hDbgAs);
pUVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(DBGF_AS_KERNEL)] = hDbgAs;
rc = RTDbgAsCreate(&hDbgAs, 0, RTGCPHYS_MAX, "Physical");
AssertRCReturn(rc, rc);
rc = DBGFR3AsAdd(pUVM, hDbgAs, NIL_RTPROCESS);
AssertRCReturn(rc, rc);
RTDbgAsRetain(hDbgAs);
pUVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(DBGF_AS_PHYS)] = hDbgAs;
rc = RTDbgAsCreate(&hDbgAs, 0, RTRCPTR_MAX, "HyperRawMode");
AssertRCReturn(rc, rc);
rc = DBGFR3AsAdd(pUVM, hDbgAs, NIL_RTPROCESS);
AssertRCReturn(rc, rc);
RTDbgAsRetain(hDbgAs);
pUVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(DBGF_AS_RC)] = hDbgAs;
RTDbgAsRetain(hDbgAs);
pUVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(DBGF_AS_RC_AND_GC_GLOBAL)] = hDbgAs;
rc = RTDbgAsCreate(&hDbgAs, 0, RTR0PTR_MAX, "HyperRing0");
AssertRCReturn(rc, rc);
rc = DBGFR3AsAdd(pUVM, hDbgAs, NIL_RTPROCESS);
AssertRCReturn(rc, rc);
RTDbgAsRetain(hDbgAs);
pUVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(DBGF_AS_R0)] = hDbgAs;
return VINF_SUCCESS;
}
static int pdmacFileEpInitialize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint,
const char *pszUri, uint32_t fFlags)
{
PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->pEpClass;
PDMACEPFILEMGRTYPE enmMgrType = pEpClassFile->enmMgrTypeOverride;
PDMACFILEEPBACKEND enmEpBackend = pEpClassFile->enmEpBackendDefault;
AssertMsgReturn((fFlags & ~(PDMACEP_FILE_FLAGS_READ_ONLY | PDMACEP_FILE_FLAGS_DONT_LOCK | PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED)) == 0,
("PDMAsyncCompletion: Invalid flag specified\n"), VERR_INVALID_PARAMETER);
unsigned fFileFlags = RTFILE_O_OPEN;
/*
* Revert to the simple manager and the buffered backend if
* the host cache should be enabled.
*/
if (fFlags & PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED)
{
enmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
}
if (fFlags & PDMACEP_FILE_FLAGS_READ_ONLY)
fFileFlags |= RTFILE_O_READ | RTFILE_O_DENY_NONE;
else
{
fFileFlags |= RTFILE_O_READWRITE;
/*
* Opened in read/write mode. Check whether the caller wants to
* avoid the lock. Return an error in case caching is enabled
* because this can lead to data corruption.
*/
if (fFlags & PDMACEP_FILE_FLAGS_DONT_LOCK)
fFileFlags |= RTFILE_O_DENY_NONE;
else
fFileFlags |= RTFILE_O_DENY_WRITE;
}
if (enmMgrType == PDMACEPFILEMGRTYPE_ASYNC)
fFileFlags |= RTFILE_O_ASYNC_IO;
int rc;
if (enmEpBackend == PDMACFILEEPBACKEND_NON_BUFFERED)
{
/*
* We only disable the cache if the size of the file is a multiple of 512.
* Certain hosts like Windows, Linux and Solaris require that transfer sizes
* are aligned to the volume sector size.
* If not we just make sure that the data is written to disk with RTFILE_O_WRITE_THROUGH
* which will trash the host cache but ensures that the host cache will not
* contain dirty buffers.
*/
RTFILE hFile;
rc = RTFileOpen(&hFile, pszUri, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
if (RT_SUCCESS(rc))
{
uint64_t cbSize;
rc = RTFileGetSize(hFile, &cbSize);
if (RT_SUCCESS(rc) && ((cbSize % 512) == 0))
fFileFlags |= RTFILE_O_NO_CACHE;
else
{
/* Downgrade to the buffered backend */
enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
#ifdef RT_OS_LINUX
fFileFlags &= ~RTFILE_O_ASYNC_IO;
enmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
#endif
}
RTFileClose(hFile);
}
}
/* Open with final flags. */
rc = RTFileOpen(&pEpFile->hFile, pszUri, fFileFlags);
if ( rc == VERR_INVALID_FUNCTION
|| rc == VERR_INVALID_PARAMETER)
{
LogRel(("pdmacFileEpInitialize: RTFileOpen %s / %08x failed with %Rrc\n",
pszUri, fFileFlags, rc));
/*
* Solaris doesn't support directio on ZFS so far. :-\
* Trying to enable it returns VERR_INVALID_FUNCTION
* (ENOTTY). Remove it and hope for the best.
* ZFS supports write throttling in case applications
* write more data than can be synced to the disk
* without blocking the whole application.
*
* On Linux we have the same problem with cifs.
* Have to disable async I/O here too because it requires O_DIRECT.
*/
fFileFlags &= ~RTFILE_O_NO_CACHE;
enmEpBackend = PDMACFILEEPBACKEND_BUFFERED;
#ifdef RT_OS_LINUX
fFileFlags &= ~RTFILE_O_ASYNC_IO;
enmMgrType = PDMACEPFILEMGRTYPE_SIMPLE;
#endif
/* Open again. */
rc = RTFileOpen(&pEpFile->hFile, pszUri, fFileFlags);
if (RT_FAILURE(rc))
{
LogRel(("pdmacFileEpInitialize: RTFileOpen %s / %08x failed AGAIN(!) with %Rrc\n",
pszUri, fFileFlags, rc));
}
}
if (RT_SUCCESS(rc))
{
pEpFile->fFlags = fFileFlags;
rc = RTFileGetSize(pEpFile->hFile, (uint64_t *)&pEpFile->cbFile);
if (RT_SUCCESS(rc))
{
/* Initialize the segment cache */
rc = MMR3HeapAllocZEx(pEpClassFile->Core.pVM, MM_TAG_PDM_ASYNC_COMPLETION,
sizeof(PDMACTASKFILE),
(void **)&pEpFile->pTasksFreeHead);
if (RT_SUCCESS(rc))
{
PPDMACEPFILEMGR pAioMgr = NULL;
pEpFile->pTasksFreeTail = pEpFile->pTasksFreeHead;
pEpFile->cTasksCached = 0;
pEpFile->enmBackendType = enmEpBackend;
/*
* Disable async flushes on Solaris for now.
* They cause weird hangs which needs more investigations.
*/
#ifndef RT_OS_SOLARIS
pEpFile->fAsyncFlushSupported = true;
#else
pEpFile->fAsyncFlushSupported = false;
#endif
if (enmMgrType == PDMACEPFILEMGRTYPE_SIMPLE)
{
/* Simple mode. Every file has its own async I/O manager. */
rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgr, PDMACEPFILEMGRTYPE_SIMPLE);
}
else
{
pAioMgr = pEpClassFile->pAioMgrHead;
/* Check for an idling manager of the same type */
while (pAioMgr)
{
if (pAioMgr->enmMgrType == enmMgrType)
break;
pAioMgr = pAioMgr->pNext;
}
if (!pAioMgr)
rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgr, enmMgrType);
}
if (RT_SUCCESS(rc))
{
pEpFile->AioMgr.pTreeRangesLocked = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
if (!pEpFile->AioMgr.pTreeRangesLocked)
rc = VERR_NO_MEMORY;
else
{
pEpFile->enmState = PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE;
/* Assign the endpoint to the thread. */
rc = pdmacFileAioMgrAddEndpoint(pAioMgr, pEpFile);
if (RT_FAILURE(rc))
{
RTMemFree(pEpFile->AioMgr.pTreeRangesLocked);
MMR3HeapFree(pEpFile->pTasksFreeHead);
}
}
}
else if (rc == VERR_FILE_AIO_INSUFFICIENT_EVENTS)
{
PUVM pUVM = VMR3GetUVM(pEpClassFile->Core.pVM);
#if defined(RT_OS_LINUX)
rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
N_("Failed to create I/O manager for VM due to insufficient resources on the host. "
"Either increase the amount of allowed events in /proc/sys/fs/aio-max-nr or enable "
"the host I/O cache"));
#else
rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
N_("Failed to create I/O manager for VM due to insufficient resources on the host. "
"Enable the host I/O cache"));
#endif
}
else
{
PUVM pUVM = VMR3GetUVM(pEpClassFile->Core.pVM);
rc = VMR3SetError(pUVM, rc, RT_SRC_POS,
N_("Failed to create I/O manager for VM due to an unknown error"));
}
}
}
if (RT_FAILURE(rc))
RTFileClose(pEpFile->hFile);
}
#ifdef VBOX_WITH_STATISTICS
if (RT_SUCCESS(rc))
{
STAMR3RegisterF(pEpClassFile->Core.pVM, &pEpFile->StatRead,
STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
STAMUNIT_TICKS_PER_CALL, "Time taken to read from the endpoint",
"/PDM/AsyncCompletion/File/%s/Read", RTPathFilename(pEpFile->Core.pszUri));
STAMR3RegisterF(pEpClassFile->Core.pVM, &pEpFile->StatWrite,
STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
STAMUNIT_TICKS_PER_CALL, "Time taken to write to the endpoint",
"/PDM/AsyncCompletion/File/%s/Write", RTPathFilename(pEpFile->Core.pszUri));
}
#endif
if (RT_SUCCESS(rc))
LogRel(("AIOMgr: Endpoint for file '%s' (flags %08x) created successfully\n", pszUri, pEpFile->fFlags));
return rc;
}
