summaryrefslogtreecommitdiffstats
path: root/src/VBox/Main/src-server/MediumIOImpl.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-11 08:17:27 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-11 08:17:27 +0000
commitf215e02bf85f68d3a6106c2a1f4f7f063f819064 (patch)
tree6bb5b92c046312c4e95ac2620b10ddf482d3fa8b /src/VBox/Main/src-server/MediumIOImpl.cpp
parentInitial commit. (diff)
downloadvirtualbox-f215e02bf85f68d3a6106c2a1f4f7f063f819064.tar.xz
virtualbox-f215e02bf85f68d3a6106c2a1f4f7f063f819064.zip
Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/VBox/Main/src-server/MediumIOImpl.cpp')
-rw-r--r--src/VBox/Main/src-server/MediumIOImpl.cpp905
1 files changed, 905 insertions, 0 deletions
diff --git a/src/VBox/Main/src-server/MediumIOImpl.cpp b/src/VBox/Main/src-server/MediumIOImpl.cpp
new file mode 100644
index 00000000..954a5552
--- /dev/null
+++ b/src/VBox/Main/src-server/MediumIOImpl.cpp
@@ -0,0 +1,905 @@
+/* $Id: MediumIOImpl.cpp $ */
+/** @file
+ * VirtualBox COM class implementation: MediumIO
+ */
+
+/*
+ * Copyright (C) 2018-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_MAIN_MEDIUMIO
+#include "MediumIOImpl.h"
+#include "MediumImpl.h"
+#include "MediumLock.h"
+#include "DataStreamImpl.h"
+#include "Global.h"
+#include "ProgressImpl.h"
+#include "VirtualBoxImpl.h"
+
+#include "AutoCaller.h"
+#include "LoggingNew.h"
+#include "ThreadTask.h"
+
+#include <iprt/fsvfs.h>
+#include <iprt/dvm.h>
+#include <iprt/zero.h>
+#include <iprt/cpp/utils.h>
+
+
+/*********************************************************************************************************************************
+* Structures and Typedefs *
+*********************************************************************************************************************************/
+/**
+ * Private member data.
+ */
+struct MediumIO::Data
+{
+ Data(Medium * const a_pMedium, VirtualBox * const a_pVirtualBox, bool a_fWritable, uint32_t a_cbSector = 512)
+ : ptrMedium(a_pMedium)
+ , ptrVirtualBox(a_pVirtualBox)
+ , fWritable(a_fWritable)
+ , cbSector(a_cbSector)
+ , PasswordStore(false /*fKeyBufNonPageable*/)
+ , pHdd(NULL)
+ , hVfsFile(NIL_RTVFSFILE)
+ {
+ }
+
+ /** Reference to the medium we're accessing. */
+ ComPtr<Medium> ptrMedium;
+ /** Reference to the VirtualBox object the medium is part of. */
+ ComPtr<VirtualBox> ptrVirtualBox;
+ /** Set if writable, clear if readonly. */
+ bool fWritable;
+ /** The sector size. */
+ uint32_t cbSector;
+ /** Secret key store used to hold the passwords for encrypted medium. */
+ SecretKeyStore PasswordStore;
+ /** Crypto filter settings. */
+ MediumCryptoFilterSettings CryptoSettings;
+ /** Medium lock list. */
+ MediumLockList LockList;
+ /** The HDD instance. */
+ PVDISK pHdd;
+ /** VFS file for the HDD instance. */
+ RTVFSFILE hVfsFile;
+
+private:
+ Data() : PasswordStore(false) { }
+};
+
+
+/**
+ * MediumIO::StreamTask class for asynchronous convert to stream operation.
+ *
+ * @note Instances of this class must be created using new() because the
+ * task thread function will delete them when the task is complete.
+ *
+ * @note The constructor of this class adds a caller on the managed Medium
+ * object which is automatically released upon destruction.
+ */
+class MediumIO::StreamTask : public ThreadTask
+{
+public:
+ StreamTask(MediumIO *pMediumIO, DataStream *pDataStream, Progress *pProgress, const char *pszFormat,
+ MediumVariant_T fMediumVariant)
+ : ThreadTask("StreamTask"),
+ mMediumIO(pMediumIO),
+ mMediumCaller(pMediumIO->m->ptrMedium),
+ m_pDataStream(pDataStream),
+ m_fMediumVariant(fMediumVariant),
+ m_strFormat(pszFormat),
+ mProgress(pProgress),
+ mVirtualBoxCaller(NULL)
+ {
+ AssertReturnVoidStmt(pMediumIO, mHrc = E_FAIL);
+ AssertReturnVoidStmt(pDataStream, mHrc = E_FAIL);
+ mHrc = mMediumCaller.hrc();
+ if (FAILED(mHrc))
+ return;
+
+ /* Get strong VirtualBox reference, see below. */
+ VirtualBox *pVirtualBox = pMediumIO->m->ptrVirtualBox;
+ mVirtualBox = pVirtualBox;
+ mVirtualBoxCaller.attach(pVirtualBox);
+ mHrc = mVirtualBoxCaller.hrc();
+ if (FAILED(mHrc))
+ return;
+ }
+
+ // Make all destructors virtual. Just in case.
+ virtual ~StreamTask()
+ {
+ /* send the notification of completion.*/
+ if ( isAsync()
+ && !mProgress.isNull())
+ mProgress->i_notifyComplete(mHrc);
+ }
+
+ HRESULT hrc() const { return mHrc; }
+ bool isOk() const { return SUCCEEDED(hrc()); }
+
+ const ComPtr<Progress>& GetProgressObject() const {return mProgress;}
+
+ /**
+ * Implementation code for the "create base" task.
+ * Used as function for execution from a standalone thread.
+ */
+ void handler()
+ {
+ LogFlowFuncEnter();
+ try
+ {
+ mHrc = executeTask(); /* (destructor picks up mHrc, see above) */
+ LogFlowFunc(("hrc=%Rhrc\n", mHrc));
+ }
+ catch (...)
+ {
+ LogRel(("Some exception in the function MediumIO::StreamTask:handler()\n"));
+ }
+
+ LogFlowFuncLeave();
+ }
+
+ const ComObjPtr<MediumIO> mMediumIO;
+ AutoCaller mMediumCaller;
+
+protected:
+ HRESULT mHrc;
+
+ ComObjPtr<DataStream> m_pDataStream;
+ MediumVariant_T m_fMediumVariant;
+ Utf8Str m_strFormat;
+
+private:
+ HRESULT executeTask();
+
+ const ComObjPtr<Progress> mProgress;
+
+ /* Must have a strong VirtualBox reference during a task otherwise the
+ * reference count might drop to 0 while a task is still running. This
+ * would result in weird behavior, including deadlocks due to uninit and
+ * locking order issues. The deadlock often is not detectable because the
+ * uninit uses event semaphores which sabotages deadlock detection. */
+ ComObjPtr<VirtualBox> mVirtualBox;
+ AutoCaller mVirtualBoxCaller;
+
+ static DECLCALLBACK(int) i_vdStreamOpen(void *pvUser, const char *pszLocation, uint32_t fOpen,
+ PFNVDCOMPLETED pfnCompleted, void **ppStorage);
+ static DECLCALLBACK(int) i_vdStreamClose(void *pvUser, void *pStorage);
+ static DECLCALLBACK(int) i_vdStreamDelete(void *pvUser, const char *pcszFilename);
+ static DECLCALLBACK(int) i_vdStreamMove(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove);
+ static DECLCALLBACK(int) i_vdStreamGetFreeSpace(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace);
+ static DECLCALLBACK(int) i_vdStreamGetModificationTime(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime);
+ static DECLCALLBACK(int) i_vdStreamGetSize(void *pvUser, void *pStorage, uint64_t *pcbSize);
+ static DECLCALLBACK(int) i_vdStreamSetSize(void *pvUser, void *pStorage, uint64_t cbSize);
+ static DECLCALLBACK(int) i_vdStreamRead(void *pvUser, void *pStorage, uint64_t uOffset, void *pvBuffer, size_t cbBuffer,
+ size_t *pcbRead);
+ static DECLCALLBACK(int) i_vdStreamWrite(void *pvUser, void *pStorage, uint64_t uOffset,
+ const void *pvBuffer, size_t cbBuffer, size_t *pcbWritten);
+ static DECLCALLBACK(int) i_vdStreamFlush(void *pvUser, void *pStorage);
+};
+
+
+/**
+ * State of a streamed file.
+ */
+typedef struct STREAMFILE
+{
+ /** The data stream for this file state. */
+ DataStream *pDataStream;
+ /** The last seen offset used to stream zeroes for non consecutive writes. */
+ uint64_t uOffsetLast;
+ /** Set file size. */
+ uint64_t cbFile;
+} STREAMFILE;
+/** Pointer to the stream file state. */
+typedef STREAMFILE *PSTREAMFILE;
+
+
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamOpen(void *pvUser, const char *pszLocation, uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
+ void **ppStorage)
+{
+ RT_NOREF2(pvUser, pszLocation);
+
+ /* Validate input. */
+ AssertPtrReturn(ppStorage, VERR_INVALID_POINTER);
+ AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
+ AssertReturn((fOpen & RTFILE_O_ACCESS_MASK) == RTFILE_O_WRITE, VERR_INVALID_PARAMETER);
+
+ int vrc = VINF_SUCCESS;
+ PSTREAMFILE pStreamFile = (PSTREAMFILE)RTMemAllocZ(sizeof(*pStreamFile));
+ if (RT_LIKELY(pStreamFile))
+ {
+ pStreamFile->pDataStream = (DataStream *)pvUser;
+ pStreamFile->uOffsetLast = 0;
+ pStreamFile->cbFile = 0;
+ *ppStorage = pStreamFile;
+ }
+ else
+ vrc = VERR_NO_MEMORY;
+
+ return vrc;
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamClose(void *pvUser, void *pStorage)
+{
+ RT_NOREF(pvUser);
+ PSTREAMFILE pStreamFile = (PSTREAMFILE)pStorage;
+ int vrc = VINF_SUCCESS;
+
+ /* Fill up to the configured file size. */
+ if (pStreamFile->uOffsetLast < pStreamFile->cbFile)
+ {
+ do
+ {
+ size_t cbThisWrite = sizeof(g_abRTZero64K);
+ size_t cbWritten = 0;
+
+ if (pStreamFile->cbFile - pStreamFile->uOffsetLast < sizeof(g_abRTZero64K))
+ cbThisWrite = (size_t)(pStreamFile->cbFile - pStreamFile->uOffsetLast);
+
+ vrc = pStreamFile->pDataStream->i_write(&g_abRTZero64K[0], cbThisWrite, &cbWritten);
+ if (RT_SUCCESS(vrc))
+ pStreamFile->uOffsetLast += cbWritten;
+
+ } while ( RT_SUCCESS(vrc)
+ && pStreamFile->uOffsetLast < pStreamFile->cbFile);
+ }
+
+ int vrc2 = pStreamFile->pDataStream->i_close();
+ if (RT_SUCCESS(vrc))
+ vrc = vrc2;
+
+ RTMemFree(pStreamFile);
+ return vrc;
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamDelete(void *pvUser, const char *pcszFilename)
+{
+ NOREF(pvUser);
+ NOREF(pcszFilename);
+ AssertFailedReturn(VERR_NOT_SUPPORTED);
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamMove(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
+{
+ NOREF(pvUser);
+ NOREF(pcszSrc);
+ NOREF(pcszDst);
+ NOREF(fMove);
+ AssertFailedReturn(VERR_NOT_SUPPORTED);
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamGetFreeSpace(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
+{
+ NOREF(pvUser);
+ NOREF(pcszFilename);
+ AssertPtrReturn(pcbFreeSpace, VERR_INVALID_POINTER);
+ *pcbFreeSpace = INT64_MAX;
+ return VINF_SUCCESS;
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamGetModificationTime(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
+{
+ NOREF(pvUser);
+ NOREF(pcszFilename);
+ AssertPtrReturn(pModificationTime, VERR_INVALID_POINTER);
+ AssertFailedReturn(VERR_NOT_SUPPORTED);
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamGetSize(void *pvUser, void *pStorage, uint64_t *pcbSize)
+{
+ NOREF(pvUser);
+ PSTREAMFILE pStreamFile = (PSTREAMFILE)pStorage;
+ AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
+
+ *pcbSize = pStreamFile->cbFile;
+ return VINF_SUCCESS;
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamSetSize(void *pvUser, void *pStorage, uint64_t cbSize)
+{
+ RT_NOREF(pvUser);
+ PSTREAMFILE pStreamFile = (PSTREAMFILE)pStorage;
+
+ /* Reducing the size is not supported. */
+ int vrc = VINF_SUCCESS;
+ if (pStreamFile->cbFile < cbSize)
+ pStreamFile->cbFile = cbSize;
+ else
+ vrc = VERR_NOT_SUPPORTED;
+
+ return vrc;
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamRead(void *pvUser, void *pStorage, uint64_t uOffset, void *pvBuffer, size_t cbBuffer,
+ size_t *pcbRead)
+{
+ NOREF(pvUser);
+ NOREF(pStorage);
+ NOREF(uOffset);
+ NOREF(cbBuffer);
+ NOREF(pcbRead);
+ AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
+ AssertFailedReturn(VERR_NOT_SUPPORTED);
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamWrite(void *pvUser, void *pStorage, uint64_t uOffset, const void *pvBuffer, size_t cbBuffer,
+ size_t *pcbWritten)
+{
+ RT_NOREF(pvUser);
+ PSTREAMFILE pStreamFile = (PSTREAMFILE)pStorage;
+ int vrc = VINF_SUCCESS;
+
+ /* Fill up to the new offset if there is non consecutive access. */
+ if (pStreamFile->uOffsetLast < uOffset)
+ {
+ do
+ {
+ size_t cbThisWrite = sizeof(g_abRTZero64K);
+ size_t cbWritten = 0;
+
+ if (uOffset - pStreamFile->uOffsetLast < sizeof(g_abRTZero64K))
+ cbThisWrite = (size_t)(uOffset - pStreamFile->uOffsetLast);
+
+ vrc = pStreamFile->pDataStream->i_write(&g_abRTZero64K[0], cbThisWrite, &cbWritten);
+ if (RT_SUCCESS(vrc))
+ pStreamFile->uOffsetLast += cbWritten;
+
+ } while ( RT_SUCCESS(vrc)
+ && pStreamFile->uOffsetLast < uOffset);
+ }
+
+ if (RT_SUCCESS(vrc))
+ {
+ if (pcbWritten)
+ vrc = pStreamFile->pDataStream->i_write(pvBuffer, cbBuffer, pcbWritten);
+ else
+ {
+ const uint8_t *pbBuf = (const uint8_t *)pvBuffer;
+ size_t cbLeft = cbBuffer;
+ size_t cbWritten = 0;
+ while ( cbLeft > 0
+ && RT_SUCCESS(vrc))
+ {
+ vrc = pStreamFile->pDataStream->i_write(pbBuf, cbLeft, &cbWritten);
+ if (RT_SUCCESS(vrc))
+ {
+ pbBuf += cbWritten;
+ cbLeft -= cbWritten;
+ }
+ }
+ }
+
+ if (RT_SUCCESS(vrc))
+ {
+ size_t cbWritten = pcbWritten ? *pcbWritten : cbBuffer;
+
+ /* Adjust file size. */
+ if (uOffset + cbWritten > pStreamFile->cbFile)
+ pStreamFile->cbFile = uOffset + cbWritten;
+
+ pStreamFile->uOffsetLast = uOffset + cbWritten;
+ }
+ }
+
+ return vrc;
+}
+
+DECLCALLBACK(int) MediumIO::StreamTask::i_vdStreamFlush(void *pvUser, void *pStorage)
+{
+ NOREF(pvUser);
+ NOREF(pStorage);
+ return VINF_SUCCESS;
+}
+
+/**
+ * Implementation code for the "stream" task.
+ */
+HRESULT MediumIO::StreamTask::executeTask()
+{
+ HRESULT hrc = S_OK;
+ VDINTERFACEIO IfsOutputIO;
+ VDINTERFACEPROGRESS IfsProgress;
+ PVDINTERFACE pIfsOp = NULL;
+ PVDINTERFACE pIfsImg = NULL;
+ PVDISK pDstDisk;
+
+ if (mProgress)
+ {
+ IfsProgress.pfnProgress = mProgress->i_vdProgressCallback;
+ VDInterfaceAdd(&IfsProgress.Core,
+ "Medium::StreamTask::vdInterfaceProgress",
+ VDINTERFACETYPE_PROGRESS,
+ mProgress,
+ sizeof(IfsProgress),
+ &pIfsOp);
+ }
+
+ IfsOutputIO.pfnOpen = i_vdStreamOpen;
+ IfsOutputIO.pfnClose = i_vdStreamClose;
+ IfsOutputIO.pfnDelete = i_vdStreamDelete;
+ IfsOutputIO.pfnMove = i_vdStreamMove;
+ IfsOutputIO.pfnGetFreeSpace = i_vdStreamGetFreeSpace;
+ IfsOutputIO.pfnGetModificationTime = i_vdStreamGetModificationTime;
+ IfsOutputIO.pfnGetSize = i_vdStreamGetSize;
+ IfsOutputIO.pfnSetSize = i_vdStreamSetSize;
+ IfsOutputIO.pfnReadSync = i_vdStreamRead;
+ IfsOutputIO.pfnWriteSync = i_vdStreamWrite;
+ IfsOutputIO.pfnFlushSync = i_vdStreamFlush;
+ VDInterfaceAdd(&IfsOutputIO.Core, "stream", VDINTERFACETYPE_IO,
+ m_pDataStream, sizeof(VDINTERFACEIO), &pIfsImg);
+
+ int vrc = VDCreate(NULL, VDTYPE_HDD, &pDstDisk);
+ if (RT_SUCCESS(vrc))
+ {
+ /* Create the output image */
+ vrc = VDCopy(mMediumIO->m->pHdd, VD_LAST_IMAGE, pDstDisk, m_strFormat.c_str(),
+ "stream", false, 0, m_fMediumVariant, NULL,
+ VD_OPEN_FLAGS_NORMAL | VD_OPEN_FLAGS_SEQUENTIAL, pIfsOp,
+ pIfsImg, NULL);
+ if (RT_FAILURE(vrc))
+ hrc = mMediumIO->setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+ tr("Failed to convert and stream disk image"));
+
+ VDDestroy(pDstDisk);
+ }
+ else
+ hrc = mMediumIO->setErrorBoth(VBOX_E_FILE_ERROR, vrc,
+ tr("Failed to create destination disk container"));
+
+ return hrc;
+}
+
+
+/*********************************************************************************************************************************
+* Boilerplate constructor & destructor *
+*********************************************************************************************************************************/
+
+DEFINE_EMPTY_CTOR_DTOR(MediumIO)
+
+HRESULT MediumIO::FinalConstruct()
+{
+ LogFlowThisFunc(("\n"));
+ return BaseFinalConstruct();
+}
+
+void MediumIO::FinalRelease()
+{
+ LogFlowThisFuncEnter();
+ uninit();
+ BaseFinalRelease();
+ LogFlowThisFuncLeave();
+}
+
+
+/*********************************************************************************************************************************
+* Initializer & uninitializer *
+*********************************************************************************************************************************/
+
+/**
+ * Initializes the medium I/O object.
+ *
+ * @param pMedium Pointer to the medium to access.
+ * @param pVirtualBox Pointer to the VirtualBox object the medium is part of.
+ * @param fWritable Read-write (true) or readonly (false) access.
+ * @param rStrKeyId The key ID for an encrypted medium. Empty if not
+ * encrypted.
+ * @param rStrPassword The password for an encrypted medium. Empty if not
+ * encrypted.
+ *
+ */
+HRESULT MediumIO::initForMedium(Medium *pMedium, VirtualBox *pVirtualBox, bool fWritable,
+ com::Utf8Str const &rStrKeyId, com::Utf8Str const &rStrPassword)
+{
+ LogFlowThisFunc(("pMedium=%p pVirtualBox=%p fWritable=%RTbool\n", pMedium, pVirtualBox, fWritable));
+ CheckComArgExpr(rStrPassword, rStrPassword.isEmpty() == rStrKeyId.isEmpty()); /* checked by caller */
+
+ /*
+ * Enclose the state transition NotReady->InInit->Ready
+ */
+ AutoInitSpan autoInitSpan(this);
+ AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+ /*
+ * Allocate data instance.
+ */
+ HRESULT hrc = S_OK;
+ m = new(std::nothrow) Data(pMedium, pVirtualBox, fWritable);
+ if (m)
+ {
+ /*
+ * Add the password to the keystore if specified.
+ */
+ if (rStrKeyId.isNotEmpty())
+ {
+ int vrc = m->PasswordStore.addSecretKey(rStrKeyId, (const uint8_t *)rStrPassword.c_str(),
+ rStrPassword.length() + 1 /*including the Schwarzenegger character*/);
+ if (vrc == VERR_NO_MEMORY)
+ hrc = setError(E_OUTOFMEMORY, tr("Failed to allocate enough secure memory for the key/password"));
+ else if (RT_FAILURE(vrc))
+ hrc = setErrorBoth(E_FAIL, vrc, tr("Unknown error happened while adding a password (%Rrc)"), vrc);
+ }
+
+ /*
+ * Try open the medium and then get a VFS file handle for it.
+ */
+ if (SUCCEEDED(hrc))
+ {
+ hrc = pMedium->i_openForIO(fWritable, &m->PasswordStore, &m->pHdd, &m->LockList, &m->CryptoSettings);
+ if (SUCCEEDED(hrc))
+ {
+ int vrc = VDCreateVfsFileFromDisk(m->pHdd, 0 /*fFlags*/, &m->hVfsFile);
+ if (RT_FAILURE(vrc))
+ {
+ hrc = setErrorBoth(E_FAIL, vrc, tr("VDCreateVfsFileFromDisk failed: %Rrc"), vrc);
+ m->hVfsFile = NIL_RTVFSFILE;
+ }
+ }
+ }
+ }
+ else
+ hrc = E_OUTOFMEMORY;
+
+ /*
+ * Done. Just update object readiness state.
+ */
+ if (SUCCEEDED(hrc))
+ autoInitSpan.setSucceeded();
+ else
+ {
+ if (m)
+ i_close(); /* Free password and whatever i_openHddForIO() may accidentally leave around on failure. */
+ autoInitSpan.setFailed(hrc);
+ }
+
+ LogFlowThisFunc(("returns %Rhrc\n", hrc));
+ return hrc;
+}
+
+/**
+ * Uninitializes the instance (called from FinalRelease()).
+ */
+void MediumIO::uninit()
+{
+ LogFlowThisFuncEnter();
+
+ /* Enclose the state transition Ready->InUninit->NotReady */
+ AutoUninitSpan autoUninitSpan(this);
+ if (!autoUninitSpan.uninitDone())
+ {
+ if (m)
+ {
+ i_close();
+
+ delete m;
+ m = NULL;
+ }
+ }
+
+ LogFlowThisFuncLeave();
+}
+
+
+/*********************************************************************************************************************************
+* IMediumIO attributes *
+*********************************************************************************************************************************/
+
+HRESULT MediumIO::getMedium(ComPtr<IMedium> &a_rPtrMedium)
+{
+ a_rPtrMedium = m->ptrMedium;
+ return S_OK;
+}
+
+HRESULT MediumIO::getWritable(BOOL *a_fWritable)
+{
+ *a_fWritable = m->fWritable;
+ return S_OK;
+}
+
+HRESULT MediumIO::getExplorer(ComPtr<IVFSExplorer> &a_rPtrExplorer)
+{
+ RT_NOREF_PV(a_rPtrExplorer);
+ return E_NOTIMPL;
+}
+
+
+/*********************************************************************************************************************************
+* IMediumIO methods *
+*********************************************************************************************************************************/
+
+HRESULT MediumIO::read(LONG64 a_off, ULONG a_cbRead, std::vector<BYTE> &a_rData)
+{
+ /*
+ * Validate input.
+ */
+ if (a_cbRead > _256K)
+ return setError(E_INVALIDARG, tr("Max read size is 256KB, given: %u"), a_cbRead);
+ if (a_cbRead == 0)
+ return setError(E_INVALIDARG, tr("Zero byte read is not supported."));
+
+ /*
+ * Allocate return buffer.
+ */
+ try
+ {
+ a_rData.resize(a_cbRead);
+ }
+ catch (std::bad_alloc &)
+ {
+ return E_OUTOFMEMORY;
+ }
+
+ /*
+ * Do the reading. To play safe we exclusivly lock the object while doing this.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ size_t cbActual = 0;
+ int vrc = RTVfsFileReadAt(m->hVfsFile, a_off, &a_rData.front(), a_cbRead, &cbActual);
+ alock.release();
+
+ /*
+ * Manage the result.
+ */
+ HRESULT hrc;
+ if (RT_SUCCESS(vrc))
+ {
+ if (cbActual != a_cbRead)
+ {
+ Assert(cbActual < a_cbRead);
+ a_rData.resize(cbActual);
+ }
+ hrc = S_OK;
+ }
+ else
+ {
+ a_rData.resize(0);
+ hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Error reading %u bytes at %RU64: %Rrc", "", a_cbRead),
+ a_cbRead, a_off, vrc);
+ }
+
+ return hrc;
+}
+
+HRESULT MediumIO::write(LONG64 a_off, const std::vector<BYTE> &a_rData, ULONG *a_pcbWritten)
+{
+ /*
+ * Validate input.
+ */
+ size_t cbToWrite = a_rData.size();
+ if (cbToWrite == 0)
+ return setError(E_INVALIDARG, tr("Zero byte write is not supported."));
+ if (!m->fWritable)
+ return setError(E_ACCESSDENIED, tr("Medium not opened for writing."));
+ CheckComArgPointerValid(a_pcbWritten);
+ *a_pcbWritten = 0;
+
+ /*
+ * Do the writing. To play safe we exclusivly lock the object while doing this.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ size_t cbActual = 0;
+ int vrc = RTVfsFileWriteAt(m->hVfsFile, a_off, &a_rData.front(), cbToWrite, &cbActual);
+ alock.release();
+
+ /*
+ * Manage the result.
+ */
+ HRESULT hrc;
+ if (RT_SUCCESS(vrc))
+ {
+ *a_pcbWritten = (ULONG)cbActual;
+ hrc = S_OK;
+ }
+ else
+ hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Error writing %zu bytes at %RU64: %Rrc", "", cbToWrite),
+ cbToWrite, a_off, vrc);
+
+ return hrc;
+}
+
+HRESULT MediumIO::formatFAT(BOOL a_fQuick)
+{
+ /*
+ * Validate input.
+ */
+ if (!m->fWritable)
+ return setError(E_ACCESSDENIED, tr("Medium not opened for writing."));
+
+ /*
+ * Format the medium as FAT and let the format API figure the parameters.
+ * We exclusivly lock the object while doing this as concurrent medium access makes no sense.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ RTERRINFOSTATIC ErrInfo;
+ int vrc = RTFsFatVolFormat(m->hVfsFile, 0, 0, a_fQuick ? RTFSFATVOL_FMT_F_QUICK : RTFSFATVOL_FMT_F_FULL,
+ (uint16_t)m->cbSector, 0, RTFSFATTYPE_INVALID, 0, 0, 0, 0, 0, RTErrInfoInitStatic(&ErrInfo));
+ alock.release();
+
+ /*
+ * Manage the result.
+ */
+ HRESULT hrc;
+ if (RT_SUCCESS(vrc))
+ hrc = S_OK;
+ else if (RTErrInfoIsSet(&ErrInfo.Core))
+ hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Error formatting (%Rrc): %s"), vrc, ErrInfo.Core.pszMsg);
+ else
+ hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Error formatting: %Rrc"), vrc);
+
+ return hrc;
+}
+
+HRESULT MediumIO::initializePartitionTable(PartitionTableType_T a_enmFormat, BOOL a_fWholeDiskInOneEntry)
+{
+ /*
+ * Validate input.
+ */
+ const char *pszFormat;
+ if (a_enmFormat == PartitionTableType_MBR)
+ pszFormat = "MBR"; /* RTDVMFORMATTYPE_MBR */
+ else if (a_enmFormat == PartitionTableType_GPT)
+ pszFormat = "GPT"; /* RTDVMFORMATTYPE_GPT */
+ else
+ return setError(E_INVALIDARG, tr("Invalid partition format type: %d"), a_enmFormat);
+ if (!m->fWritable)
+ return setError(E_ACCESSDENIED, tr("Medium not opened for writing."));
+ if (a_fWholeDiskInOneEntry)
+ return setError(E_NOTIMPL, tr("whole-disk-in-one-entry is not implemented yet, sorry."));
+
+ /*
+ * Do the partitioning.
+ * We exclusivly lock the object while doing this as concurrent medium access makes little sense.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+ RTDVM hVolMgr;
+ int vrc = RTDvmCreate(&hVolMgr, m->hVfsFile, m->cbSector, 0 /*fFlags*/);
+ HRESULT hrc;
+ if (RT_SUCCESS(vrc))
+ {
+ vrc = RTDvmMapInitialize(hVolMgr, pszFormat); /** @todo Why doesn't RTDvmMapInitialize take RTDVMFORMATTYPE? */
+ if (RT_SUCCESS(vrc))
+ {
+ /*
+ * Create a partition for the whole disk?
+ */
+ hrc = S_OK; /** @todo a_fWholeDiskInOneEntry requies RTDvm to get a function for creating partitions. */
+ }
+ else
+ hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("RTDvmMapInitialize failed: %Rrc"), vrc);
+ RTDvmRelease(hVolMgr);
+ }
+ else
+ hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("RTDvmCreate failed: %Rrc"), vrc);
+
+ return hrc;
+}
+
+HRESULT MediumIO::convertToStream(const com::Utf8Str &aFormat,
+ const std::vector<MediumVariant_T> &aVariant,
+ ULONG aBufferSize,
+ ComPtr<IDataStream> &aStream,
+ ComPtr<IProgress> &aProgress)
+{
+ HRESULT hrc = S_OK;
+ ComObjPtr<Progress> pProgress;
+ ComObjPtr<DataStream> pDataStream;
+ MediumIO::StreamTask *pTask = NULL;
+
+ try
+ {
+ pDataStream.createObject();
+ hrc = pDataStream->init(aBufferSize);
+ if (FAILED(hrc))
+ throw hrc;
+
+ pProgress.createObject();
+ hrc = pProgress->init(m->ptrVirtualBox,
+ static_cast<IMediumIO*>(this),
+ BstrFmt(tr("Converting medium '%s' to data stream"), m->ptrMedium->i_getLocationFull().c_str()),
+ TRUE /* aCancelable */);
+ if (FAILED(hrc))
+ throw hrc;
+
+ ULONG mediumVariantFlags = 0;
+
+ if (aVariant.size())
+ {
+ for (size_t i = 0; i < aVariant.size(); i++)
+ mediumVariantFlags |= (ULONG)aVariant[i];
+ }
+
+ /* setup task object to carry out the operation asynchronously */
+ pTask = new MediumIO::StreamTask(this, pDataStream, pProgress,
+ aFormat.c_str(), (MediumVariant_T)mediumVariantFlags);
+ hrc = pTask->hrc();
+ AssertComRC(hrc);
+ if (FAILED(hrc))
+ throw hrc;
+ }
+ catch (HRESULT hrcXcpt) { hrc = hrcXcpt; }
+
+ if (SUCCEEDED(hrc))
+ {
+ hrc = pTask->createThread();
+ pTask = NULL;
+ if (SUCCEEDED(hrc))
+ {
+ pDataStream.queryInterfaceTo(aStream.asOutParam());
+ pProgress.queryInterfaceTo(aProgress.asOutParam());
+ }
+ }
+ else if (pTask != NULL)
+ delete pTask;
+
+ return hrc;
+}
+
+HRESULT MediumIO::close()
+{
+ /*
+ * We need a write lock here to exclude all other access.
+ */
+ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+ i_close();
+ return S_OK;
+}
+
+
+
+/*********************************************************************************************************************************
+* IMediumIO internal methods *
+*********************************************************************************************************************************/
+
+/**
+ * This is used by both uninit and close().
+ *
+ * Expects exclusive access (write lock or autouninit) to the object.
+ */
+void MediumIO::i_close()
+{
+ if (m->hVfsFile != NIL_RTVFSFILE)
+ {
+ uint32_t cRefs = RTVfsFileRelease(m->hVfsFile);
+ Assert(cRefs == 0);
+ NOREF(cRefs);
+
+ m->hVfsFile = NIL_RTVFSFILE;
+ }
+
+ if (m->pHdd)
+ {
+ VDDestroy(m->pHdd);
+ m->pHdd = NULL;
+ }
+
+ m->LockList.Clear();
+ m->ptrMedium.setNull();
+ m->PasswordStore.deleteAllSecretKeys(false /* fSuspend */, true /* fForce */);
+}
+