static int fileFlushSyncCallback(void * /* pvUser */, void *pvStorage)
{
/* Validate input. */
AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
DEBUG_PRINT_FLOW();
PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
return RTFileFlush(pInt->file);
}
File::~File()
{
if (m->flushOnClose)
{
RTFileFlush(m->handle);
if (!m->strFileName.isEmpty())
RTDirFlushParent(m->strFileName.c_str());
}
if (m->opened)
RTFileClose(m->handle);
delete m;
}
VBOXDDU_DECL(int) VDDbgIoLogCommit(VDIOLOGGER hIoLogger)
{
int rc = VINF_SUCCESS;
PVDIOLOGGERINT pIoLogger = hIoLogger;
AssertPtrReturn(pIoLogger, VERR_INVALID_HANDLE);
rc = vddbgIoLoggerHeaderUpdate(pIoLogger);
if (RT_SUCCESS(rc))
rc = RTFileFlush(pIoLogger->hFile);
return rc;
}
VBOXDDU_DECL(void) VDDbgIoLogDestroy(VDIOLOGGER hIoLogger)
{
PVDIOLOGGERINT pIoLogger = hIoLogger;
AssertPtrReturnVoid(pIoLogger);
vddbgIoLoggerHeaderUpdate(pIoLogger);
RTFileFlush(pIoLogger->hFile);
RTFileClose(pIoLogger->hFile);
RTMemCacheDestroy(pIoLogger->hMemCacheIoLogEntries);
RTSemFastMutexDestroy(pIoLogger->hMtx);
RTMemFree(pIoLogger);
}
DECLHIDDEN(int) drvHostBaseFlushOs(PDRVHOSTBASE pThis)
{
return RTFileFlush(pThis->Os.hFileDevice);
}
/**
* Does one free space wipe, using the given filename.
*
* @returns RTEXITCODE_SUCCESS on success, RTEXITCODE_FAILURE on failure (fully
* bitched).
* @param pszFilename The filename to use for wiping free space. Will be
* replaced and afterwards deleted.
* @param pvFiller The filler block buffer.
* @param cbFiller The size of the filler block buffer.
* @param cbMinLeftOpt When to stop wiping.
*/
static RTEXITCODE doOneFreeSpaceWipe(const char *pszFilename, void const *pvFiller, size_t cbFiller, uint64_t cbMinLeftOpt)
{
/*
* Open the file.
*/
RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
RTFILE hFile = NIL_RTFILE;
int rc = RTFileOpen(&hFile, pszFilename,
RTFILE_O_WRITE | RTFILE_O_DENY_NONE | RTFILE_O_CREATE_REPLACE | (0775 << RTFILE_O_CREATE_MODE_SHIFT));
if (RT_SUCCESS(rc))
{
/*
* Query the amount of available free space. Figure out which API we should use.
*/
RTFOFF cbTotal = 0;
RTFOFF cbFree = 0;
rc = RTFileQueryFsSizes(hFile, &cbTotal, &cbFree, NULL, NULL);
bool const fFileHandleApiSupported = rc != VERR_NOT_SUPPORTED && rc != VERR_NOT_IMPLEMENTED;
if (!fFileHandleApiSupported)
rc = RTFsQuerySizes(pszFilename, &cbTotal, &cbFree, NULL, NULL);
if (RT_SUCCESS(rc))
{
RTPrintf("%s: %'9RTfoff MiB out of %'9RTfoff are free\n", pszFilename, cbFree / _1M, cbTotal / _1M);
/*
* Start filling up the free space, down to the last 32MB.
*/
uint64_t const nsStart = RTTimeNanoTS(); /* for speed calcs */
uint64_t nsStat = nsStart; /* for speed calcs */
uint64_t cbStatWritten = 0; /* for speed calcs */
RTFOFF const cbMinLeft = RT_MAX(cbMinLeftOpt, cbFiller * 2);
RTFOFF cbLeftToWrite = cbFree - cbMinLeft;
uint64_t cbWritten = 0;
uint32_t iLoop = 0;
while (cbLeftToWrite >= (RTFOFF)cbFiller)
{
rc = RTFileWrite(hFile, pvFiller, cbFiller, NULL);
if (RT_FAILURE(rc))
{
if (rc == VERR_DISK_FULL)
RTPrintf("%s: Disk full after writing %'9RU64 MiB\n", pszFilename, cbWritten / _1M);
else
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Write error after %'RU64 bytes: %Rrc\n",
pszFilename, cbWritten, rc);
break;
}
/* Flush every now and then as we approach a completely full disk. */
if (cbLeftToWrite <= _1G && (iLoop & (cbLeftToWrite > _128M ? 15 : 3)) == 0)
RTFileFlush(hFile);
/*
* Advance and maybe recheck the amount of free space.
*/
cbWritten += cbFiller;
cbLeftToWrite -= (ssize_t)cbFiller;
iLoop++;
if ((iLoop & (16 - 1)) == 0 || cbLeftToWrite < _256M)
{
RTFOFF cbFreeUpdated;
if (fFileHandleApiSupported)
rc = RTFileQueryFsSizes(hFile, NULL, &cbFreeUpdated, NULL, NULL);
else
rc = RTFsQuerySizes(pszFilename, NULL, &cbFreeUpdated, NULL, NULL);
if (RT_SUCCESS(rc))
{
cbFree = cbFreeUpdated;
cbLeftToWrite = cbFree - cbMinLeft;
}
else
{
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Failed to query free space after %'RU64 bytes: %Rrc\n",
pszFilename, cbWritten, rc);
break;
}
if ((iLoop & (512 - 1)) == 0)
{
uint64_t const nsNow = RTTimeNanoTS();
uint64_t cNsInterval = nsNow - nsStat;
uint64_t cbInterval = cbWritten - cbStatWritten;
uint64_t cbIntervalPerSec = cbInterval ? (uint64_t)(cbInterval / (cNsInterval / (double)RT_NS_1SEC)) : 0;
RTPrintf("%s: %'9RTfoff MiB out of %'9RTfoff are free after writing %'9RU64 MiB (%'5RU64 MiB/s)\n",
pszFilename, cbFree / _1M, cbTotal / _1M, cbWritten / _1M, cbIntervalPerSec / _1M);
nsStat = nsNow;
cbStatWritten = cbWritten;
}
}
}
/*
* Now flush the file and then reduce the size a little before closing
* it so the system won't entirely run out of space. The flush should
* ensure the data has actually hit the disk.
*/
rc = RTFileFlush(hFile);
if (RT_FAILURE(rc))
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Flush failed at %'RU64 bytes: %Rrc\n", pszFilename, cbWritten, rc);
uint64_t cbReduced = cbWritten > _512M ? cbWritten - _512M : cbWritten / 2;
rc = RTFileSetSize(hFile, cbReduced);
if (RT_FAILURE(rc))
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Failed to reduce file size from %'RU64 to %'RU64 bytes: %Rrc\n",
pszFilename, cbWritten, cbReduced, rc);
/* Issue a summary statements. */
uint64_t cNsElapsed = RTTimeNanoTS() - nsStart;
uint64_t cbPerSec = cbWritten ? (uint64_t)(cbWritten / (cNsElapsed / (double)RT_NS_1SEC)) : 0;
RTPrintf("%s: Wrote %'RU64 MiB in %'RU64 s, avg %'RU64 MiB/s.\n",
pszFilename, cbWritten / _1M, cNsElapsed / RT_NS_1SEC, cbPerSec / _1M);
}
else
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Initial free space query failed: %Rrc \n", pszFilename, rc);
RTFileClose(hFile);
/*
* Delete the file.
*/
rc = RTFileDelete(pszFilename);
if (RT_FAILURE(rc))
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Delete failed: %Rrc !!\n", pszFilename, rc);
}
else
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Open failed: %Rrc\n", pszFilename, rc);
return rcExit;
}
/**
* Processes a given task list for assigned to the given endpoint.
*/
static int pdmacFileAioMgrFailsafeProcessEndpointTaskList(PPDMACEPFILEMGR pAioMgr,
PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
PPDMACTASKFILE pTasks)
{
int rc = VINF_SUCCESS;
while (pTasks)
{
RTMSINTERVAL msWhenNext;
PPDMACTASKFILE pCurr = pTasks;
if (!pdmacEpIsTransferAllowed(&pEndpoint->Core, (uint32_t)pCurr->DataSeg.cbSeg, &msWhenNext))
{
pAioMgr->msBwLimitExpired = RT_MIN(pAioMgr->msBwLimitExpired, msWhenNext);
break;
}
pTasks = pTasks->pNext;
switch (pCurr->enmTransferType)
{
case PDMACTASKFILETRANSFER_FLUSH:
{
rc = RTFileFlush(pEndpoint->hFile);
break;
}
case PDMACTASKFILETRANSFER_READ:
case PDMACTASKFILETRANSFER_WRITE:
{
if (pCurr->enmTransferType == PDMACTASKFILETRANSFER_READ)
{
rc = RTFileReadAt(pEndpoint->hFile, pCurr->Off,
pCurr->DataSeg.pvSeg,
pCurr->DataSeg.cbSeg,
NULL);
}
else
{
if (RT_UNLIKELY((uint64_t)pCurr->Off + pCurr->DataSeg.cbSeg > pEndpoint->cbFile))
{
ASMAtomicWriteU64(&pEndpoint->cbFile, pCurr->Off + pCurr->DataSeg.cbSeg);
RTFileSetSize(pEndpoint->hFile, pCurr->Off + pCurr->DataSeg.cbSeg);
}
rc = RTFileWriteAt(pEndpoint->hFile, pCurr->Off,
pCurr->DataSeg.pvSeg,
pCurr->DataSeg.cbSeg,
NULL);
}
break;
}
default:
AssertMsgFailed(("Invalid transfer type %d\n", pTasks->enmTransferType));
}
pCurr->pfnCompleted(pCurr, pCurr->pvUser, rc);
pdmacFileTaskFree(pEndpoint, pCurr);
}
if (pTasks)
{
/* Add the rest of the tasks to the pending list */
pdmacFileAioMgrEpAddTaskList(pEndpoint, pTasks);
}
return VINF_SUCCESS;
}
