Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1648 insertions, 0 deletions

diff --git a/src/VBox/Main/src-all/NvramStoreImpl.cpp b/src/VBox/Main/src-all/NvramStoreImpl.cpp
new file mode 100644
index 00000000..833ccee8
--- /dev/null
+++ b/src/VBox/Main/src-all/NvramStoreImpl.cpp
@@ -0,0 +1,1648 @@
+/* $Id: NvramStoreImpl.cpp $ */
+/** @file
+ * VirtualBox COM NVRAM store class implementation
+ */
+
+/*
+ * Copyright (C) 2021-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
+ */
+
+#define LOG_GROUP LOG_GROUP_MAIN_NVRAMSTORE
+#include "LoggingNew.h"
+
+#include "NvramStoreImpl.h"
+#ifdef VBOX_COM_INPROC
+# include "ConsoleImpl.h"
+#else
+# include "MachineImpl.h"
+# include "GuestOSTypeImpl.h"
+# include "AutoStateDep.h"
+#endif
+#include "UefiVariableStoreImpl.h"
+#include "VirtualBoxImpl.h"
+
+#include "AutoCaller.h"
+
+#include <VBox/com/array.h>
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/err.h>
+
+#include <iprt/cpp/utils.h>
+#include <iprt/efi.h>
+#include <iprt/file.h>
+#include <iprt/vfs.h>
+#include <iprt/zip.h>
+
+
+// defines
+////////////////////////////////////////////////////////////////////////////////
+
+/** Version of the NVRAM saved state unit. */
+#define NVRAM_STORE_SAVED_STATE_VERSION 1
+
+
+// globals
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * NVRAM store driver instance data.
+ */
+typedef struct DRVMAINNVRAMSTORE
+{
+    /** Pointer to the keyboard object. */
+    NvramStore                  *pNvramStore;
+    /** Pointer to the driver instance structure. */
+    PPDMDRVINS                  pDrvIns;
+    /** Our VFS connector interface. */
+    PDMIVFSCONNECTOR            IVfs;
+} DRVMAINNVRAMSTORE, *PDRVMAINNVRAMSTORE;
+
+/** The NVRAM store map keyed by namespace/entity. */
+typedef std::map<Utf8Str, RTVFSFILE> NvramStoreMap;
+/** The NVRAM store map iterator. */
+typedef std::map<Utf8Str, RTVFSFILE>::iterator NvramStoreIter;
+
+struct BackupableNvramStoreData
+{
+    BackupableNvramStoreData()
+    { }
+
+    /** The NVRAM file path. */
+    com::Utf8Str            strNvramPath;
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    /** The key id used for encrypting the NVRAM file */
+    com::Utf8Str            strKeyId;
+    /** The key store containing the encrypting DEK */
+    com::Utf8Str            strKeyStore;
+#endif
+    /** The NVRAM store. */
+    NvramStoreMap           mapNvram;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// NvramStore::Data structure
+/////////////////////////////////////////////////////////////////////////////
+
+struct NvramStore::Data
+{
+    Data()
+        : pParent(NULL)
+#ifdef VBOX_COM_INPROC
+          , cRefs(0)
+          , fSsmSaved(false)
+#endif
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+          , mpKeyStore(NULL)
+#endif
+    { }
+
+#ifdef VBOX_COM_INPROC
+    /** The Console owning this NVRAM store. */
+    Console * const         pParent;
+    /** Number of references held to this NVRAM store from the various devices/drivers. */
+    volatile uint32_t       cRefs;
+    /** Flag whether the NVRAM data was saved during a save state operation
+     * preventing it from getting written to the backing file. */
+    bool                    fSsmSaved;
+#else
+    /** The Machine object owning this NVRAM store. */
+    Machine * const                    pParent;
+    /** The peer NVRAM store object. */
+    ComObjPtr<NvramStore>              pPeer;
+    /** The UEFI variable store. */
+    const ComObjPtr<UefiVariableStore> pUefiVarStore;
+#endif
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    /* Store for secret keys. */
+    SecretKeyStore                      *mpKeyStore;
+#endif
+
+    Backupable<BackupableNvramStoreData> bd;
+};
+
+// constructor / destructor
+////////////////////////////////////////////////////////////////////////////////
+
+DEFINE_EMPTY_CTOR_DTOR(NvramStore)
+
+HRESULT NvramStore::FinalConstruct()
+{
+    return BaseFinalConstruct();
+}
+
+void NvramStore::FinalRelease()
+{
+    uninit();
+    BaseFinalRelease();
+}
+
+// public initializer/uninitializer for internal purposes only
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Initialization stuff shared across the different methods.
+ *
+ * @returns COM result indicator
+ */
+int NvramStore::initImpl()
+{
+    m = new Data();
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+# ifdef VBOX_COM_INPROC
+    bool fNonPageable = true;
+# else
+    /* Non-pageable memory is not accessible for non-VM process */
+    bool fNonPageable = false;
+# endif
+
+    m->mpKeyStore = new SecretKeyStore(fNonPageable /* fKeyBufNonPageable */);
+    AssertReturn(m->mpKeyStore, VERR_NO_MEMORY);
+#endif
+
+    return VINF_SUCCESS;
+}
+
+
+#if !defined(VBOX_COM_INPROC)
+/**
+ * Initializes the NVRAM store object.
+ *
+ * @returns COM result indicator
+ */
+HRESULT NvramStore::init(Machine *aParent)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aParent: %p\n", aParent));
+
+    ComAssertRet(aParent, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    int vrc = initImpl();
+    if (RT_FAILURE(vrc))
+        return E_FAIL;
+
+    /* share the parent weakly */
+    unconst(m->pParent) = aParent;
+
+    m->bd.allocate();
+
+    autoInitSpan.setSucceeded();
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+/**
+ *  Initializes the NVRAM store object given another NVRAM store object
+ *  (a kind of copy constructor). This object shares data with
+ *  the object passed as an argument.
+ *
+ *  @note This object must be destroyed before the original object
+ *  it shares data with is destroyed.
+ */
+HRESULT NvramStore::init(Machine *aParent, NvramStore *that)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aParent: %p, that: %p\n", aParent, that));
+
+    ComAssertRet(aParent && that, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    initImpl();
+
+    unconst(m->pParent) = aParent;
+    m->pPeer = that;
+
+    AutoWriteLock thatlock(that COMMA_LOCKVAL_SRC_POS);
+    m->bd.share(that->m->bd);
+
+    autoInitSpan.setSucceeded();
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+/**
+ *  Initializes the guest object given another guest object
+ *  (a kind of copy constructor). This object makes a private copy of data
+ *  of the original object passed as an argument.
+ */
+HRESULT NvramStore::initCopy(Machine *aParent, NvramStore *that)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aParent: %p, that: %p\n", aParent, that));
+
+    ComAssertRet(aParent && that, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    initImpl();
+
+    unconst(m->pParent) = aParent;
+    // mPeer is left null
+
+    AutoWriteLock thatlock(that COMMA_LOCKVAL_SRC_POS);
+    m->bd.attachCopy(that->m->bd);
+
+    autoInitSpan.setSucceeded();
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+#else
+
+/**
+ * Initializes the NVRAM store object.
+ *
+ * @returns COM result indicator
+ * @param aParent                       Handle of our parent object
+ * @param strNonVolatileStorageFile     The NVRAM file path.
+ */
+HRESULT NvramStore::init(Console *aParent, const com::Utf8Str &strNonVolatileStorageFile)
+{
+    LogFlowThisFunc(("aParent=%p\n", aParent));
+
+    ComAssertRet(aParent, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    initImpl();
+
+    unconst(m->pParent) = aParent;
+
+    m->bd.allocate();
+    m->bd->strNvramPath = strNonVolatileStorageFile;
+
+    /* Confirm a successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+#endif /* VBOX_COM_INPROC */
+
+
+/**
+ *  Uninitializes the instance and sets the ready flag to FALSE.
+ *  Called either from FinalRelease() or by the parent when it gets destroyed.
+ */
+void NvramStore::uninit()
+{
+    LogFlowThisFuncEnter();
+
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan(this);
+    if (autoUninitSpan.uninitDone())
+        return;
+
+    unconst(m->pParent) = NULL;
+#ifndef VBOX_COM_INPROC
+    unconst(m->pUefiVarStore) = NULL;
+#endif
+
+    /* Delete the NVRAM content. */
+    NvramStoreIter it = m->bd->mapNvram.begin();
+    while (it != m->bd->mapNvram.end())
+    {
+        RTVfsFileRelease(it->second);
+        it++;
+    }
+
+    m->bd->mapNvram.clear();
+    m->bd.free();
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    if (m->mpKeyStore != NULL)
+        delete m->mpKeyStore;
+#endif
+
+    delete m;
+    m = NULL;
+
+    LogFlowThisFuncLeave();
+}
+
+
+HRESULT NvramStore::getNonVolatileStorageFile(com::Utf8Str &aNonVolatileStorageFile)
+{
+#ifndef VBOX_COM_INPROC
+    Utf8Str strTmp;
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+        strTmp = m->bd->strNvramPath;
+    }
+
+    AutoReadLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
+    if (strTmp.isEmpty())
+        strTmp = m->pParent->i_getDefaultNVRAMFilename();
+    if (strTmp.isNotEmpty())
+        m->pParent->i_calculateFullPath(strTmp, aNonVolatileStorageFile);
+#else
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    aNonVolatileStorageFile = m->bd->strNvramPath;
+#endif
+
+    return S_OK;
+}
+
+
+HRESULT NvramStore::getUefiVariableStore(ComPtr<IUefiVariableStore> &aUefiVarStore)
+{
+#ifndef VBOX_COM_INPROC
+    /* the machine needs to be mutable */
+    AutoMutableStateDependency adep(m->pParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    Utf8Str strPath;
+    NvramStore::getNonVolatileStorageFile(strPath);
+
+    /* We need a write lock because of the lazy initialization. */
+    AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
+
+    /* Check if we have to create the UEFI variable store object */
+    HRESULT hrc = S_OK;
+    if (!m->pUefiVarStore)
+    {
+        /* Load the NVRAM file first if it isn't already. */
+        if (!m->bd->mapNvram.size())
+        {
+            int vrc = i_loadStore(strPath.c_str());
+            if (RT_FAILURE(vrc))
+                hrc = setError(E_FAIL, tr("Loading the NVRAM store failed (%Rrc)\n"), vrc);
+        }
+
+        if (SUCCEEDED(hrc))
+        {
+            NvramStoreIter it = m->bd->mapNvram.find("efi/nvram");
+            if (it != m->bd->mapNvram.end())
+            {
+                unconst(m->pUefiVarStore).createObject();
+                m->pUefiVarStore->init(this, m->pParent);
+            }
+            else
+                hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The UEFI NVRAM file is not existing for this machine."));
+        }
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        m->pUefiVarStore.queryInterfaceTo(aUefiVarStore.asOutParam());
+
+        /* Mark the NVRAM store as potentially modified. */
+        m->pParent->i_setModified(Machine::IsModified_NvramStore);
+    }
+
+    return hrc;
+#else
+    NOREF(aUefiVarStore);
+    return E_NOTIMPL;
+#endif
+}
+
+
+HRESULT NvramStore::getKeyId(com::Utf8Str &aKeyId)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    aKeyId = m->bd->strKeyId;
+#else
+    aKeyId = com::Utf8Str::Empty;
+#endif
+
+    return S_OK;
+}
+
+
+HRESULT NvramStore::getKeyStore(com::Utf8Str &aKeyStore)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    aKeyStore = m->bd->strKeyStore;
+#else
+    aKeyStore = com::Utf8Str::Empty;
+#endif
+
+    return S_OK;
+}
+
+
+HRESULT NvramStore::initUefiVariableStore(ULONG aSize)
+{
+#ifndef VBOX_COM_INPROC
+    if (aSize != 0)
+        return setError(E_NOTIMPL, tr("Supporting another NVRAM size apart from the default one is not supported right now"));
+
+    /* the machine needs to be mutable */
+    AutoMutableStateDependency adep(m->pParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    Utf8Str strPath;
+    NvramStore::getNonVolatileStorageFile(strPath);
+
+    /* We need a write lock because of the lazy initialization. */
+    AutoReadLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (m->pParent->i_getFirmwareType() == FirmwareType_BIOS)
+        return setError(VBOX_E_NOT_SUPPORTED, tr("The selected firmware type doesn't support a UEFI variable store"));
+
+    /* Load the NVRAM file first if it isn't already. */
+    HRESULT hrc = S_OK;
+    if (!m->bd->mapNvram.size())
+    {
+        int vrc = i_loadStore(strPath.c_str());
+        if (RT_FAILURE(vrc))
+            hrc = setError(E_FAIL, tr("Loading the NVRAM store failed (%Rrc)\n"), vrc);
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        int vrc = VINF_SUCCESS;
+        RTVFSFILE hVfsUefiVarStore = NIL_RTVFSFILE;
+        NvramStoreIter it = m->bd->mapNvram.find("efi/nvram");
+        if (it != m->bd->mapNvram.end())
+            hVfsUefiVarStore = it->second;
+        else
+        {
+            /* Create a new file. */
+            vrc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, 0 /*cbEstimate*/, &hVfsUefiVarStore);
+            if (RT_SUCCESS(vrc))
+            {
+                /** @todo The size is hardcoded to match what the firmware image uses right now which is a gross hack... */
+                vrc = RTVfsFileSetSize(hVfsUefiVarStore, 540672, RTVFSFILE_SIZE_F_NORMAL);
+                if (RT_SUCCESS(vrc))
+                    m->bd->mapNvram["efi/nvram"] = hVfsUefiVarStore;
+                else
+                    RTVfsFileRelease(hVfsUefiVarStore);
+            }
+        }
+
+        if (RT_SUCCESS(vrc))
+        {
+            vrc = RTEfiVarStoreCreate(hVfsUefiVarStore, 0 /*offStore*/, 0 /*cbStore*/, RTEFIVARSTORE_CREATE_F_DEFAULT, 0 /*cbBlock*/,
+                                      NULL /*pErrInfo*/);
+            if (RT_FAILURE(vrc))
+                return setError(E_FAIL, tr("Failed to initialize the UEFI variable store (%Rrc)"), vrc);
+        }
+        else
+            return setError(E_FAIL, tr("Failed to initialize the UEFI variable store (%Rrc)"), vrc);
+
+        m->pParent->i_setModified(Machine::IsModified_NvramStore);
+    }
+
+    return hrc;
+#else
+    NOREF(aSize);
+    return E_NOTIMPL;
+#endif
+}
+
+
+Utf8Str NvramStore::i_getNonVolatileStorageFile()
+{
+    AutoCaller autoCaller(this);
+    AssertReturn(autoCaller.isOk(), Utf8Str::Empty);
+
+    Utf8Str strTmp;
+    NvramStore::getNonVolatileStorageFile(strTmp);
+    return strTmp;
+}
+
+
+/**
+ * Loads the NVRAM store from the given TAR filesystem stream.
+ *
+ * @returns IPRT status code.
+ * @param   hVfsFssTar          Handle to the tar filesystem stream.
+ */
+int NvramStore::i_loadStoreFromTar(RTVFSFSSTREAM hVfsFssTar)
+{
+    int vrc = VINF_SUCCESS;
+
+    /*
+     * Process the stream.
+     */
+    for (;;)
+    {
+        /*
+         * Retrieve the next object.
+         */
+        char       *pszName;
+        RTVFSOBJ    hVfsObj;
+        vrc = RTVfsFsStrmNext(hVfsFssTar, &pszName, NULL, &hVfsObj);
+        if (RT_FAILURE(vrc))
+        {
+            if (vrc == VERR_EOF)
+                vrc = VINF_SUCCESS;
+            break;
+        }
+
+        RTFSOBJINFO UnixInfo;
+        vrc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
+        if (RT_SUCCESS(vrc))
+        {
+            switch (UnixInfo.Attr.fMode & RTFS_TYPE_MASK)
+            {
+                case RTFS_TYPE_FILE:
+                {
+                    LogRel(("NvramStore: Loading '%s' from archive\n", pszName));
+                    RTVFSIOSTREAM hVfsIosEntry = RTVfsObjToIoStream(hVfsObj);
+                    Assert(hVfsIosEntry != NIL_RTVFSIOSTREAM);
+
+                    RTVFSFILE hVfsFileEntry;
+                    vrc = RTVfsMemorizeIoStreamAsFile(hVfsIosEntry, RTFILE_O_READ | RTFILE_O_WRITE, &hVfsFileEntry);
+                    if (RT_FAILURE(vrc))
+                        break;
+                    RTVfsIoStrmRelease(hVfsIosEntry);
+
+                    m->bd->mapNvram[Utf8Str(pszName)] = hVfsFileEntry;
+                    break;
+                }
+                case RTFS_TYPE_DIRECTORY:
+                    break;
+                default:
+                    vrc = VERR_NOT_SUPPORTED;
+                    break;
+            }
+        }
+
+        /*
+         * Release the current object and string.
+         */
+        RTVfsObjRelease(hVfsObj);
+        RTStrFree(pszName);
+
+        if (RT_FAILURE(vrc))
+            break;
+    }
+
+    return vrc;
+}
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+
+/**
+ * Sets up the encryption or decryption machinery.
+ *
+ * @returns VBox status code.
+ * @param   hVfsIosInOut        Handle to the input stream to be decrypted or the destination to the encrypted
+ *                              output is written to.
+ * @param   fEncrypt            Flag whether to setup encryption or decryption.
+ * @param   ppCryptoIf          Where to store the pointer to the cryptographic interface which needs to be released
+ *                              when done.
+ * @param   ppKey               Where to store the pointer to the secret key buffer which needs to be released when done.
+ * @param   phVfsIos            Where to store the handle to the plaintext I/O stream (either input or output) on success.
+ */
+int NvramStore::i_setupEncryptionOrDecryption(RTVFSIOSTREAM hVfsIosInOut, bool fEncrypt,
+                                              PCVBOXCRYPTOIF *ppCryptoIf, SecretKey **ppKey,
+                                              PRTVFSIOSTREAM phVfsIos)
+{
+    int vrc = VINF_SUCCESS;
+    PCVBOXCRYPTOIF pCryptoIf = NULL;
+    SecretKey *pKey = NULL;
+    const char *pszPassword = NULL;
+
+    vrc = i_retainCryptoIf(&pCryptoIf);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = m->mpKeyStore->retainSecretKey(m->bd->strKeyId, &pKey);
+        if (RT_SUCCESS(vrc))
+        {
+            pszPassword = (const char *)pKey->getKeyBuffer();
+            if (fEncrypt)
+                vrc = pCryptoIf->pfnCryptoIoStrmFromVfsIoStrmEncrypt(hVfsIosInOut, m->bd->strKeyStore.c_str(), pszPassword,
+                                                                     phVfsIos);
+            else
+                vrc = pCryptoIf->pfnCryptoIoStrmFromVfsIoStrmDecrypt(hVfsIosInOut, m->bd->strKeyStore.c_str(), pszPassword,
+                                                                     phVfsIos);
+            if (RT_SUCCESS(vrc))
+            {
+                *ppCryptoIf = pCryptoIf;
+                *ppKey      = pKey;
+                return VINF_SUCCESS;
+            }
+            else
+                LogRelMax(10, ("Failed to decrypt the NVRAM store using secret key ID '%s' with %Rrc\n",
+                               m->bd->strKeyId.c_str(), vrc));
+
+            m->mpKeyStore->releaseSecretKey(m->bd->strKeyId);
+        }
+        else
+            LogRelMax(10, ("Failed to retain the secret key ID '%s' with %Rrc\n",
+                           m->bd->strKeyId.c_str(), vrc));
+
+        i_releaseCryptoIf(pCryptoIf);
+    }
+    else
+        LogRelMax(10, ("Failed to retain the cryptographic interface with %Rrc\n", vrc));
+
+    return vrc;
+}
+
+/**
+ * Releases all resources acquired in NvramStore::i_setupEncryptionOrDecryption().
+ *
+ * @param   hVfsIos             Handle to the I/O stream previously created.
+ * @param   pCryptoIf           Pointer to the cryptographic interface being released.
+ * @param   pKey                Pointer to the key buffer being released.
+ */
+void NvramStore::i_releaseEncryptionOrDecryptionResources(RTVFSIOSTREAM hVfsIos, PCVBOXCRYPTOIF pCryptoIf,
+                                                          SecretKey *pKey)
+{
+    Assert(hVfsIos != NIL_RTVFSIOSTREAM);
+    AssertPtr(pCryptoIf);
+    AssertPtr(pKey);
+
+    i_releaseCryptoIf(pCryptoIf);
+    pKey->release();
+    RTVfsIoStrmRelease(hVfsIos);
+}
+
+#endif /* VBOX_WITH_FULL_VM_ENCRYPTION */
+
+/**
+ * Loads the NVRAM store.
+ *
+ * @returns IPRT status code.
+ */
+int NvramStore::i_loadStore(const char *pszPath)
+{
+    uint64_t cbStore = 0;
+    int vrc = RTFileQuerySizeByPath(pszPath, &cbStore);
+    if (RT_SUCCESS(vrc))
+    {
+        if (cbStore <= _1M) /* Arbitrary limit to fend off bogus files because the file will be read into memory completely. */
+        {
+            /*
+             * Old NVRAM files just consist of the EFI variable store whereas starting
+             * with VirtualBox 7.0 and the introduction of the TPM the need to handle multiple
+             * independent NVRAM files came up. For those scenarios all NVRAM states are collected
+             * in a tar archive.
+             *
+             * Here we detect whether the file is the new tar archive format or whether it is just
+             * the plain EFI variable store file.
+             */
+            RTVFSIOSTREAM hVfsIosNvram;
+            vrc = RTVfsIoStrmOpenNormal(pszPath, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE,
+                                        &hVfsIosNvram);
+            if (RT_SUCCESS(vrc))
+            {
+                RTVFSIOSTREAM hVfsIosDecrypted = NIL_RTVFSIOSTREAM;
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+                PCVBOXCRYPTOIF pCryptoIf = NULL;
+                SecretKey *pKey = NULL;
+
+                if (   m->bd->strKeyId.isNotEmpty()
+                    && m->bd->strKeyStore.isNotEmpty())
+                    vrc = i_setupEncryptionOrDecryption(hVfsIosNvram, false /*fEncrypt*/,
+                                                        &pCryptoIf, &pKey, &hVfsIosDecrypted);
+#endif
+                if (RT_SUCCESS(vrc))
+                {
+                    /* Read the content. */
+                    RTVFSFILE hVfsFileNvram;
+                    vrc = RTVfsMemorizeIoStreamAsFile(  hVfsIosDecrypted != NIL_RTVFSIOSTREAM
+                                                      ? hVfsIosDecrypted
+                                                      : hVfsIosNvram,
+                                                      RTFILE_O_READ, &hVfsFileNvram);
+                    if (RT_SUCCESS(vrc))
+                    {
+                        if (RT_SUCCESS(vrc))
+                        {
+                            /* Try to parse it as an EFI variable store. */
+                            RTERRINFOSTATIC ErrInfo;
+                            RTVFS hVfsEfiVarStore;
+                            vrc = RTEfiVarStoreOpenAsVfs(hVfsFileNvram, RTVFSMNT_F_READ_ONLY, 0 /*fVarStoreFlags*/,
+                                                         &hVfsEfiVarStore, RTErrInfoInitStatic(&ErrInfo));
+                            if (RT_SUCCESS(vrc))
+                            {
+                                vrc = RTVfsFileSeek(hVfsFileNvram, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+                                AssertRC(vrc);
+
+                                RTVfsFileRetain(hVfsFileNvram); /* Retain a new reference for the map. */
+                                m->bd->mapNvram[Utf8Str("efi/nvram")] = hVfsFileNvram;
+
+                                RTVfsRelease(hVfsEfiVarStore);
+                            }
+                            else if (vrc == VERR_VFS_UNKNOWN_FORMAT)
+                            {
+                                /* Check for the new style tar archive. */
+                                vrc = RTVfsFileSeek(hVfsFileNvram, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+                                AssertRC(vrc);
+
+                                RTVFSIOSTREAM hVfsIosTar = RTVfsFileToIoStream(hVfsFileNvram);
+                                Assert(hVfsIosTar != NIL_RTVFSIOSTREAM);
+
+                                RTVFSFSSTREAM hVfsFssTar;
+                                vrc = RTZipTarFsStreamFromIoStream(hVfsIosTar, 0 /*fFlags*/, &hVfsFssTar);
+                                RTVfsIoStrmRelease(hVfsIosTar);
+                                if (RT_SUCCESS(vrc))
+                                {
+                                    vrc = i_loadStoreFromTar(hVfsFssTar);
+                                    RTVfsFsStrmRelease(hVfsFssTar);
+                                }
+                                else
+                                    LogRel(("The given NVRAM file is neither a raw UEFI variable store nor a tar archive (opening failed with %Rrc)\n", vrc));
+                            }
+                            else
+                                LogRel(("Opening the UEFI variable store '%s' failed with %Rrc%RTeim\n", pszPath, vrc, &ErrInfo.Core));
+
+                            RTVfsFileRelease(hVfsFileNvram);
+                        }
+                        else
+                            LogRel(("Failed to memorize NVRAM store '%s' with %Rrc\n", pszPath, vrc));
+                    }
+                }
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+                if (hVfsIosDecrypted != NIL_RTVFSIOSTREAM)
+                    i_releaseEncryptionOrDecryptionResources(hVfsIosDecrypted, pCryptoIf, pKey);
+#endif
+
+                RTVfsIoStrmRelease(hVfsIosNvram);
+            }
+            else
+                LogRelMax(10, ("NVRAM store '%s' couldn't be opened with %Rrc\n", pszPath, vrc));
+        }
+        else
+        {
+            LogRelMax(10, ("NVRAM store '%s' exceeds limit of %u bytes, actual size is %u\n",
+                           pszPath, _1M, cbStore));
+            vrc = VERR_OUT_OF_RANGE;
+        }
+    }
+    else if (vrc == VERR_FILE_NOT_FOUND) /* Valid for the first run where no NVRAM file is there. */
+        vrc = VINF_SUCCESS;
+
+    return vrc;
+}
+
+
+/**
+ * Saves the NVRAM store as a tar archive.
+ */
+int NvramStore::i_saveStoreAsTar(const char *pszPath)
+{
+    uint32_t        offError = 0;
+    RTERRINFOSTATIC ErrInfo;
+    RTVFSIOSTREAM   hVfsIos;
+
+    int vrc = RTVfsChainOpenIoStream(pszPath, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE,
+                                     &hVfsIos, &offError, RTErrInfoInitStatic(&ErrInfo));
+    if (RT_SUCCESS(vrc))
+    {
+        RTVFSIOSTREAM hVfsIosEncrypted = NIL_RTVFSIOSTREAM;
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+        PCVBOXCRYPTOIF pCryptoIf = NULL;
+        SecretKey *pKey = NULL;
+
+        if (   m->bd->strKeyId.isNotEmpty()
+            && m->bd->strKeyStore.isNotEmpty())
+            vrc = i_setupEncryptionOrDecryption(hVfsIos, true /*fEncrypt*/,
+                                                &pCryptoIf, &pKey, &hVfsIosEncrypted);
+#endif
+
+        if (RT_SUCCESS(vrc))
+        {
+            RTVFSFSSTREAM hVfsFss;
+            vrc = RTZipTarFsStreamToIoStream(  hVfsIosEncrypted != NIL_RTVFSIOSTREAM
+                                             ? hVfsIosEncrypted
+                                             : hVfsIos,
+                                             RTZIPTARFORMAT_GNU, 0 /*fFlags*/, &hVfsFss);
+            if (RT_SUCCESS(vrc))
+            {
+                NvramStoreIter it = m->bd->mapNvram.begin();
+
+                while (it != m->bd->mapNvram.end())
+                {
+                    RTVFSFILE hVfsFile = it->second;
+
+                    vrc = RTVfsFileSeek(hVfsFile, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+                    AssertRC(vrc);
+
+                    RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFile);
+                    vrc = RTVfsFsStrmAdd(hVfsFss, it->first.c_str(), hVfsObj, 0 /*fFlags*/);
+                    RTVfsObjRelease(hVfsObj);
+                    if (RT_FAILURE(vrc))
+                        break;
+
+                    it++;
+                }
+
+                RTVfsFsStrmRelease(hVfsFss);
+            }
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+            if (hVfsIosEncrypted != NIL_RTVFSIOSTREAM)
+                i_releaseEncryptionOrDecryptionResources(hVfsIosEncrypted, pCryptoIf, pKey);
+#endif
+        }
+
+        RTVfsIoStrmRelease(hVfsIos);
+    }
+
+    return vrc;
+}
+
+
+int NvramStore::i_retainCryptoIf(PCVBOXCRYPTOIF *ppCryptoIf)
+{
+#ifdef VBOX_COM_INPROC
+    return m->pParent->i_retainCryptoIf(ppCryptoIf);
+#else
+    HRESULT hrc = m->pParent->i_getVirtualBox()->i_retainCryptoIf(ppCryptoIf);
+    if (SUCCEEDED(hrc))
+        return VINF_SUCCESS;
+
+    return VERR_COM_IPRT_ERROR;
+#endif
+}
+
+
+int NvramStore::i_releaseCryptoIf(PCVBOXCRYPTOIF pCryptoIf)
+{
+#ifdef VBOX_COM_INPROC
+    return m->pParent->i_releaseCryptoIf(pCryptoIf);
+#else
+    HRESULT hrc = m->pParent->i_getVirtualBox()->i_releaseCryptoIf(pCryptoIf);
+    if (SUCCEEDED(hrc))
+        return VINF_SUCCESS;
+
+    return VERR_COM_IPRT_ERROR;
+#endif
+}
+
+
+/**
+ * Saves the NVRAM store.
+ *
+ * @returns IPRT status code.
+ */
+int NvramStore::i_saveStore(void)
+{
+    int vrc = VINF_SUCCESS;
+
+    Utf8Str strTmp;
+    NvramStore::getNonVolatileStorageFile(strTmp);
+
+    /*
+     * Only store the NVRAM content if the path is not empty, if it is
+     * this means the VM was just created and the store was nnot saved yet,
+     * see @bugref{10191}.
+     */
+    if (strTmp.isNotEmpty())
+    {
+        /*
+         * Skip creating the tar archive if only the UEFI NVRAM content is available in order
+         * to maintain backwards compatibility. As soon as there is more than one entry or
+         * it doesn't belong to the UEFI the tar archive will be created.
+         */
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        if (   m->bd->mapNvram.size() == 1
+            && m->bd->mapNvram.find(Utf8Str("efi/nvram")) != m->bd->mapNvram.end())
+        {
+            RTVFSFILE hVfsFileNvram = m->bd->mapNvram[Utf8Str("efi/nvram")];
+
+            vrc = RTVfsFileSeek(hVfsFileNvram, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+            AssertRC(vrc); RT_NOREF(vrc);
+
+            RTVFSIOSTREAM hVfsIosDst;
+            vrc = RTVfsIoStrmOpenNormal(strTmp.c_str(), RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE,
+                                        &hVfsIosDst);
+            if (RT_SUCCESS(vrc))
+            {
+                RTVFSIOSTREAM hVfsIosSrc = RTVfsFileToIoStream(hVfsFileNvram);
+                Assert(hVfsIosSrc != NIL_RTVFSIOSTREAM);
+
+                RTVFSIOSTREAM hVfsIosEncrypted = NIL_RTVFSIOSTREAM;
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+                PCVBOXCRYPTOIF pCryptoIf = NULL;
+                SecretKey *pKey = NULL;
+
+                if (   m->bd->strKeyId.isNotEmpty()
+                    && m->bd->strKeyStore.isNotEmpty())
+                    vrc = i_setupEncryptionOrDecryption(hVfsIosDst, true /*fEncrypt*/,
+                                                        &pCryptoIf, &pKey, &hVfsIosEncrypted);
+#endif
+
+                vrc = RTVfsUtilPumpIoStreams(hVfsIosSrc,
+                                               hVfsIosEncrypted != NIL_RTVFSIOSTREAM
+                                             ? hVfsIosEncrypted
+                                             : hVfsIosDst
+                                             , 0 /*cbBufHint*/);
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+                if (hVfsIosEncrypted != NIL_RTVFSIOSTREAM)
+                    i_releaseEncryptionOrDecryptionResources(hVfsIosEncrypted, pCryptoIf, pKey);
+#endif
+
+                RTVfsIoStrmRelease(hVfsIosSrc);
+                RTVfsIoStrmRelease(hVfsIosDst);
+            }
+        }
+        else if (m->bd->mapNvram.size())
+            vrc = i_saveStoreAsTar(strTmp.c_str());
+        /* else: No NVRAM content to store so we are done here. */
+    }
+
+    return vrc;
+}
+
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+HRESULT NvramStore::i_updateEncryptionSettings(const com::Utf8Str &strKeyId,
+                                               const com::Utf8Str &strKeyStore)
+{
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    m->bd.backup();
+    m->bd->strKeyId = strKeyId;
+    m->bd->strKeyStore = strKeyStore;
+
+    /* clear all passwords because they are invalid now */
+    m->mpKeyStore->deleteAllSecretKeys(false, true);
+
+    alock.release();
+    AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
+#ifndef VBOX_COM_INPROC
+    m->pParent->i_setModified(Machine::IsModified_NvramStore);
+#endif
+    return S_OK;
+}
+
+
+HRESULT NvramStore::i_getEncryptionSettings(com::Utf8Str &strKeyId,
+                                            com::Utf8Str &strKeyStore)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    strKeyId    = m->bd->strKeyId;
+    strKeyStore = m->bd->strKeyStore;
+
+    return S_OK;
+}
+
+
+int NvramStore::i_addPassword(const Utf8Str &strKeyId, const Utf8Str &strPassword)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.hrc(), VERR_INVALID_STATE);
+
+    /* keep only required password */
+    if (strKeyId != m->bd->strKeyId)
+        return VINF_SUCCESS;
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    return m->mpKeyStore->addSecretKey(strKeyId, (const uint8_t *)strPassword.c_str(), strPassword.length() + 1);
+}
+
+
+int NvramStore::i_removePassword(const Utf8Str &strKeyId)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.hrc(), VERR_INVALID_STATE);
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    return m->mpKeyStore->deleteSecretKey(strKeyId);
+}
+
+
+int NvramStore::i_removeAllPasswords()
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.hrc(), VERR_INVALID_STATE);
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    m->mpKeyStore->deleteAllSecretKeys(false, true);
+    return VINF_SUCCESS;
+}
+#endif
+
+
+#ifndef VBOX_COM_INPROC
+HRESULT NvramStore::i_retainUefiVarStore(PRTVFS phVfs, bool fReadonly)
+{
+    /* the machine needs to be mutable */
+    AutoMutableStateDependency adep(m->pParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT hrc = S_OK;
+    NvramStoreIter it = m->bd->mapNvram.find("efi/nvram");
+    if (it != m->bd->mapNvram.end())
+    {
+        RTVFSFILE hVfsFileNvram = it->second;
+        RTVFS hVfsEfiVarStore;
+        uint32_t fMntFlags = fReadonly ? RTVFSMNT_F_READ_ONLY : 0;
+
+        int vrc = RTEfiVarStoreOpenAsVfs(hVfsFileNvram, fMntFlags, 0 /*fVarStoreFlags*/, &hVfsEfiVarStore,
+                                         NULL /*pErrInfo*/);
+        if (RT_SUCCESS(vrc))
+        {
+            *phVfs = hVfsEfiVarStore;
+            if (!fReadonly)
+                m->pParent->i_setModified(Machine::IsModified_NvramStore);
+        }
+        else
+            hrc = setError(E_FAIL, tr("Opening the UEFI variable store failed (%Rrc)."), vrc);
+    }
+    else
+        hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The UEFI NVRAM file is not existing for this machine."));
+
+    return hrc;
+}
+
+
+HRESULT NvramStore::i_releaseUefiVarStore(RTVFS hVfs)
+{
+    RTVfsRelease(hVfs);
+    return S_OK;
+}
+
+
+/**
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ *
+ *  @param data Configuration settings.
+ *
+ *  @note Locks this object for writing.
+ */
+HRESULT NvramStore::i_loadSettings(const settings::NvramSettings &data)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoReadLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    m->bd->strNvramPath = data.strNvramPath;
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    m->bd->strKeyId     = data.strKeyId;
+    m->bd->strKeyStore  = data.strKeyStore;
+#endif
+
+    Utf8Str strTmp(m->bd->strNvramPath);
+    if (strTmp.isNotEmpty())
+        m->pParent->i_copyPathRelativeToMachine(strTmp, m->bd->strNvramPath);
+    if (   m->pParent->i_getFirmwareType() == FirmwareType_BIOS
+        || m->bd->strNvramPath == m->pParent->i_getDefaultNVRAMFilename())
+        m->bd->strNvramPath.setNull();
+
+    return S_OK;
+}
+
+/**
+ *  Saves settings to the given machine node.
+ *
+ *  @param data Configuration settings.
+ *
+ *  @note Locks this object for writing.
+ */
+HRESULT NvramStore::i_saveSettings(settings::NvramSettings &data)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
+
+    data.strNvramPath = m->bd->strNvramPath;
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    data.strKeyId     = m->bd->strKeyId;
+    data.strKeyStore  = m->bd->strKeyStore;
+#endif
+
+    int vrc = i_saveStore();
+    if (RT_FAILURE(vrc))
+        return setError(E_FAIL, tr("Failed to save the NVRAM content to disk (%Rrc)"), vrc);
+
+    return S_OK;
+}
+
+void NvramStore::i_rollback()
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    m->bd.rollback();
+}
+
+void NvramStore::i_commit()
+{
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertReturnVoid(autoCaller.isOk());
+
+    /* sanity too */
+    AutoCaller peerCaller(m->pPeer);
+    AssertReturnVoid(peerCaller.isOk());
+
+    /* lock both for writing since we modify both (mPeer is "master" so locked
+     * first) */
+    AutoMultiWriteLock2 alock(m->pPeer, this COMMA_LOCKVAL_SRC_POS);
+
+    if (m->bd.isBackedUp())
+    {
+        m->bd.commit();
+        if (m->pPeer)
+        {
+            /* attach new data to the peer and reshare it */
+            AutoWriteLock peerlock(m->pPeer COMMA_LOCKVAL_SRC_POS);
+            m->pPeer->m->bd.attach(m->bd);
+        }
+    }
+}
+
+void NvramStore::i_copyFrom(NvramStore *aThat)
+{
+    AssertReturnVoid(aThat != NULL);
+
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertReturnVoid(autoCaller.isOk());
+
+    /* sanity too */
+    AutoCaller thatCaller(aThat);
+    AssertReturnVoid(thatCaller.isOk());
+
+    /* peer is not modified, lock it for reading (aThat is "master" so locked
+     * first) */
+    AutoReadLock rl(aThat COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
+
+    /* this will back up current data */
+    m->bd.assignCopy(aThat->m->bd);
+
+    // Intentionally "forget" the NVRAM file since it must be unique and set
+    // to the correct value before the copy of the settings makes sense.
+    m->bd->strNvramPath.setNull();
+}
+
+HRESULT NvramStore::i_applyDefaults(GuestOSType *aOSType)
+{
+    HRESULT hrc = S_OK;
+
+    if (aOSType->i_recommendedEFISecureBoot())
+    {
+        /* Initialize the UEFI variable store and enroll default keys. */
+        hrc = initUefiVariableStore(0 /*aSize*/);
+        if (SUCCEEDED(hrc))
+        {
+            ComPtr<IUefiVariableStore> pVarStore;
+
+            hrc = getUefiVariableStore(pVarStore);
+            if (SUCCEEDED(hrc))
+            {
+                hrc = pVarStore->EnrollOraclePlatformKey();
+                if (SUCCEEDED(hrc))
+                    hrc = pVarStore->EnrollDefaultMsSignatures();
+            }
+        }
+    }
+
+    return hrc;
+}
+
+void NvramStore::i_updateNonVolatileStorageFile(const Utf8Str &aNonVolatileStorageFile)
+{
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    AutoReadLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    Utf8Str strTmp(aNonVolatileStorageFile);
+    if (strTmp == m->pParent->i_getDefaultNVRAMFilename())
+        strTmp.setNull();
+
+    if (strTmp == m->bd->strNvramPath)
+        return;
+
+    m->bd.backup();
+    m->bd->strNvramPath = strTmp;
+}
+
+#else
+//
+// private methods
+//
+/*static*/
+DECLCALLBACK(int) NvramStore::i_nvramStoreQuerySize(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath,
+                                                    uint64_t *pcb)
+{
+    PDRVMAINNVRAMSTORE pThis = RT_FROM_MEMBER(pInterface, DRVMAINNVRAMSTORE, IVfs);
+
+    AutoReadLock rlock(pThis->pNvramStore COMMA_LOCKVAL_SRC_POS);
+    NvramStoreIter it = pThis->pNvramStore->m->bd->mapNvram.find(Utf8StrFmt("%s/%s", pszNamespace, pszPath));
+    if (it != pThis->pNvramStore->m->bd->mapNvram.end())
+    {
+        RTVFSFILE hVfsFile = it->second;
+        return RTVfsFileQuerySize(hVfsFile, pcb);
+    }
+
+    return VERR_NOT_FOUND;
+}
+
+
+/*static*/
+DECLCALLBACK(int) NvramStore::i_nvramStoreReadAll(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath,
+                                                  void *pvBuf, size_t cbRead)
+{
+    PDRVMAINNVRAMSTORE pThis = RT_FROM_MEMBER(pInterface, DRVMAINNVRAMSTORE, IVfs);
+
+    AutoReadLock rlock(pThis->pNvramStore COMMA_LOCKVAL_SRC_POS);
+    NvramStoreIter it = pThis->pNvramStore->m->bd->mapNvram.find(Utf8StrFmt("%s/%s", pszNamespace, pszPath));
+    if (it != pThis->pNvramStore->m->bd->mapNvram.end())
+    {
+        RTVFSFILE hVfsFile = it->second;
+
+        int vrc = RTVfsFileSeek(hVfsFile, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+        AssertRC(vrc); RT_NOREF(vrc);
+
+        return RTVfsFileRead(hVfsFile, pvBuf, cbRead, NULL /*pcbRead*/);
+    }
+
+    return VERR_NOT_FOUND;
+}
+
+
+/*static*/
+DECLCALLBACK(int) NvramStore::i_nvramStoreWriteAll(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath,
+                                                   const void *pvBuf, size_t cbWrite)
+{
+    PDRVMAINNVRAMSTORE pThis = RT_FROM_MEMBER(pInterface, DRVMAINNVRAMSTORE, IVfs);
+
+    AutoWriteLock wlock(pThis->pNvramStore COMMA_LOCKVAL_SRC_POS);
+
+    int vrc = VINF_SUCCESS;
+    NvramStoreIter it = pThis->pNvramStore->m->bd->mapNvram.find(Utf8StrFmt("%s/%s", pszNamespace, pszPath));
+    if (it != pThis->pNvramStore->m->bd->mapNvram.end())
+    {
+        RTVFSFILE hVfsFile = it->second;
+
+        vrc = RTVfsFileSeek(hVfsFile, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
+        AssertRC(vrc);
+        vrc = RTVfsFileSetSize(hVfsFile, cbWrite, RTVFSFILE_SIZE_F_NORMAL);
+        if (RT_SUCCESS(vrc))
+            vrc = RTVfsFileWrite(hVfsFile, pvBuf, cbWrite, NULL /*pcbWritten*/);
+    }
+    else
+    {
+        /* Create a new entry. */
+        RTVFSFILE hVfsFile = NIL_RTVFSFILE;
+        vrc = RTVfsFileFromBuffer(RTFILE_O_READ | RTFILE_O_WRITE, pvBuf, cbWrite, &hVfsFile);
+        if (RT_SUCCESS(vrc))
+            pThis->pNvramStore->m->bd->mapNvram[Utf8StrFmt("%s/%s", pszNamespace, pszPath)] = hVfsFile;
+    }
+
+    return vrc;
+}
+
+
+/*static*/
+DECLCALLBACK(int) NvramStore::i_nvramStoreDelete(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath)
+{
+    PDRVMAINNVRAMSTORE pThis = RT_FROM_MEMBER(pInterface, DRVMAINNVRAMSTORE, IVfs);
+
+    AutoWriteLock wlock(pThis->pNvramStore COMMA_LOCKVAL_SRC_POS);
+    NvramStoreIter it = pThis->pNvramStore->m->bd->mapNvram.find(Utf8StrFmt("%s/%s", pszNamespace, pszPath));
+    if (it != pThis->pNvramStore->m->bd->mapNvram.end())
+    {
+        RTVFSFILE hVfsFile = it->second;
+        pThis->pNvramStore->m->bd->mapNvram.erase(it);
+        RTVfsFileRelease(hVfsFile);
+        return VINF_SUCCESS;
+    }
+
+    return VERR_NOT_FOUND;
+}
+
+
+/*static*/
+DECLCALLBACK(int) NvramStore::i_SsmSaveExec(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM)
+{
+    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
+    PDRVMAINNVRAMSTORE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINNVRAMSTORE);
+    PCPDMDRVHLPR3      pHlp  = pDrvIns->pHlpR3;
+
+    AutoWriteLock wlock(pThis->pNvramStore COMMA_LOCKVAL_SRC_POS);
+
+    size_t cEntries = pThis->pNvramStore->m->bd->mapNvram.size();
+    AssertReturn(cEntries < 32, VERR_OUT_OF_RANGE); /* Some sanity checking. */
+    pHlp->pfnSSMPutU32(pSSM, (uint32_t)cEntries);
+
+    void *pvData = NULL;
+    size_t cbDataMax = 0;
+    NvramStoreIter it = pThis->pNvramStore->m->bd->mapNvram.begin();
+
+    while (it != pThis->pNvramStore->m->bd->mapNvram.end())
+    {
+        RTVFSFILE hVfsFile = it->second;
+        uint64_t cbFile;
+
+        int vrc = RTVfsFileQuerySize(hVfsFile, &cbFile);
+        AssertRCReturn(vrc, vrc);
+        AssertReturn(cbFile < _1M, VERR_OUT_OF_RANGE);
+
+        if (cbDataMax < cbFile)
+        {
+            pvData = RTMemRealloc(pvData, cbFile);
+            AssertPtrReturn(pvData, VERR_NO_MEMORY);
+            cbDataMax = cbFile;
+        }
+
+        vrc = RTVfsFileReadAt(hVfsFile, 0 /*off*/, pvData, cbFile, NULL /*pcbRead*/);
+        AssertRCReturn(vrc, vrc);
+
+        pHlp->pfnSSMPutStrZ(pSSM, it->first.c_str());
+        pHlp->pfnSSMPutU64(pSSM, cbFile);
+        pHlp->pfnSSMPutMem(pSSM, pvData, cbFile);
+        it++;
+    }
+
+    if (pvData)
+        RTMemFree(pvData);
+
+    pThis->pNvramStore->m->fSsmSaved = true;
+    return pHlp->pfnSSMPutU32(pSSM, UINT32_MAX); /* sanity/terminator */
+}
+
+
+/*static*/
+DECLCALLBACK(int) NvramStore::i_SsmLoadExec(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+{
+    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
+    PDRVMAINNVRAMSTORE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINNVRAMSTORE);
+    PCPDMDRVHLPR3      pHlp  = pDrvIns->pHlpR3;
+
+    AssertMsgReturn(uVersion >= NVRAM_STORE_SAVED_STATE_VERSION, ("%d\n", uVersion),
+                    VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
+
+    if (uPass == SSM_PASS_FINAL)
+    {
+        AutoWriteLock wlock(pThis->pNvramStore COMMA_LOCKVAL_SRC_POS);
+
+        /* Clear any content first. */
+        NvramStoreIter it = pThis->pNvramStore->m->bd->mapNvram.begin();
+        while (it != pThis->pNvramStore->m->bd->mapNvram.end())
+        {
+            RTVfsFileRelease(it->second);
+            it++;
+        }
+
+        pThis->pNvramStore->m->bd->mapNvram.clear();
+
+        uint32_t cEntries = 0;
+        int vrc = pHlp->pfnSSMGetU32(pSSM, &cEntries);
+        AssertRCReturn(vrc, vrc);
+        AssertReturn(cEntries < 32, VERR_OUT_OF_RANGE);
+
+        void *pvData = NULL;
+        size_t cbDataMax = 0;
+        while (cEntries--)
+        {
+            char szId[_1K]; /* Lazy developer */
+            uint64_t cbFile = 0;
+
+            vrc = pHlp->pfnSSMGetStrZ(pSSM, &szId[0], sizeof(szId));
+            AssertRCReturn(vrc, vrc);
+
+            vrc = pHlp->pfnSSMGetU64(pSSM, &cbFile);
+            AssertRCReturn(vrc, vrc);
+            AssertReturn(cbFile < _1M, VERR_OUT_OF_RANGE);
+
+            if (cbDataMax < cbFile)
+            {
+                pvData = RTMemRealloc(pvData, cbFile);
+                AssertPtrReturn(pvData, VERR_NO_MEMORY);
+                cbDataMax = cbFile;
+            }
+
+            vrc = pHlp->pfnSSMGetMem(pSSM, pvData, cbFile);
+            AssertRCReturn(vrc, vrc);
+
+            RTVFSFILE hVfsFile;
+            vrc = RTVfsFileFromBuffer(RTFILE_O_READWRITE, pvData, cbFile, &hVfsFile);
+            AssertRCReturn(vrc, vrc);
+
+            pThis->pNvramStore->m->bd->mapNvram[Utf8Str(szId)] = hVfsFile;
+        }
+
+        if (pvData)
+            RTMemFree(pvData);
+
+        /* The marker. */
+        uint32_t u32;
+        vrc = pHlp->pfnSSMGetU32(pSSM, &u32);
+        AssertRCReturn(vrc, vrc);
+        AssertMsgReturn(u32 == UINT32_MAX, ("%#x\n", u32), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{PDMIBASE,pfnQueryInterface}
+ */
+DECLCALLBACK(void *) NvramStore::i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
+{
+    PPDMDRVINS          pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
+    PDRVMAINNVRAMSTORE  pDrv    = PDMINS_2_DATA(pDrvIns, PDRVMAINNVRAMSTORE);
+
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIVFSCONNECTOR, &pDrv->IVfs);
+    return NULL;
+}
+
+
+/**
+ * Destruct a NVRAM store driver instance.
+ *
+ * @returns VBox status code.
+ * @param   pDrvIns     The driver instance data.
+ */
+DECLCALLBACK(void) NvramStore::i_drvDestruct(PPDMDRVINS pDrvIns)
+{
+    PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
+    PDRVMAINNVRAMSTORE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINNVRAMSTORE);
+    LogFlow(("NvramStore::drvDestruct: iInstance=%d\n", pDrvIns->iInstance));
+
+    if (pThis->pNvramStore)
+    {
+        uint32_t cRefs = ASMAtomicDecU32(&pThis->pNvramStore->m->cRefs);
+        if (   !cRefs
+            && !pThis->pNvramStore->m->fSsmSaved)
+        {
+            int vrc = pThis->pNvramStore->i_saveStore();
+            AssertRC(vrc); /** @todo Disk full error? */
+        }
+    }
+}
+
+
+/**
+ * Construct a NVRAM store driver instance.
+ *
+ * @copydoc FNPDMDRVCONSTRUCT
+ */
+DECLCALLBACK(int) NvramStore::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
+{
+    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
+    RT_NOREF(fFlags, pCfg);
+    PDRVMAINNVRAMSTORE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINNVRAMSTORE);
+    LogFlow(("NvramStore::drvConstruct: iInstance=%d\n", pDrvIns->iInstance));
+
+    /*
+     * Validate configuration.
+     */
+    PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "", "");
+    AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
+                    ("Configuration error: Not possible to attach anything to this driver!\n"),
+                    VERR_PDM_DRVINS_NO_ATTACH);
+
+    /*
+     * IBase.
+     */
+    pDrvIns->IBase.pfnQueryInterface    = NvramStore::i_drvQueryInterface;
+
+    pThis->IVfs.pfnQuerySize            = NvramStore::i_nvramStoreQuerySize;
+    pThis->IVfs.pfnReadAll              = NvramStore::i_nvramStoreReadAll;
+    pThis->IVfs.pfnWriteAll             = NvramStore::i_nvramStoreWriteAll;
+    pThis->IVfs.pfnDelete               = NvramStore::i_nvramStoreDelete;
+
+    /*
+     * Get the NVRAM store object pointer.
+     */
+    com::Guid uuid(COM_IIDOF(INvramStore));
+    pThis->pNvramStore = (NvramStore *)PDMDrvHlpQueryGenericUserObject(pDrvIns, uuid.raw());
+    if (!pThis->pNvramStore)
+    {
+        AssertMsgFailed(("Configuration error: No/bad NVRAM store object!\n"));
+        return VERR_NOT_FOUND;
+    }
+
+    /*
+     * Only the first instance will register the SSM handlers and will do the work on behalf
+     * of all other NVRAM store driver instances when it comes to SSM.
+     */
+    if (pDrvIns->iInstance == 0)
+    {
+        int vrc = PDMDrvHlpSSMRegister(pDrvIns, NVRAM_STORE_SAVED_STATE_VERSION, 0 /*cbGuess*/,
+                                       NvramStore::i_SsmSaveExec, NvramStore::i_SsmLoadExec);
+        if (RT_FAILURE(vrc))
+            return PDMDrvHlpVMSetError(pDrvIns, vrc, RT_SRC_POS,
+                                       N_("Failed to register the saved state unit for the NVRAM store"));
+    }
+
+    uint32_t cRefs = ASMAtomicIncU32(&pThis->pNvramStore->m->cRefs);
+    if (cRefs == 1)
+    {
+        int vrc = pThis->pNvramStore->i_loadStore(pThis->pNvramStore->m->bd->strNvramPath.c_str());
+        if (RT_FAILURE(vrc))
+        {
+            ASMAtomicDecU32(&pThis->pNvramStore->m->cRefs);
+            return PDMDrvHlpVMSetError(pDrvIns, vrc, RT_SRC_POS,
+                                       N_("Failed to load the NVRAM store from the file"));
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * NVRAM store driver registration record.
+ */
+const PDMDRVREG NvramStore::DrvReg =
+{
+    /* u32Version */
+    PDM_DRVREG_VERSION,
+    /* szName */
+    "NvramStore",
+    /* szRCMod */
+    "",
+    /* szR0Mod */
+    "",
+    /* pszDescription */
+    "Main NVRAM store driver (Main as in the API).",
+    /* fFlags */
+    PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
+    /* fClass. */
+    PDM_DRVREG_CLASS_STATUS,
+    /* cMaxInstances */
+    ~0U,
+    /* cbInstance */
+    sizeof(DRVMAINNVRAMSTORE),
+    /* pfnConstruct */
+    NvramStore::i_drvConstruct,
+    /* pfnDestruct */
+    NvramStore::i_drvDestruct,
+    /* pfnRelocate */
+    NULL,
+    /* pfnIOCtl */
+    NULL,
+    /* pfnPowerOn */
+    NULL,
+    /* pfnReset */
+    NULL,
+    /* pfnSuspend */
+    NULL,
+    /* pfnResume */
+    NULL,
+    /* pfnAttach */
+    NULL,
+    /* pfnDetach */
+    NULL,
+    /* pfnPowerOff */
+    NULL,
+    /* pfnSoftReset */
+    NULL,
+    /* u32EndVersion */
+    PDM_DRVREG_VERSION
+};
+#endif /* !VBOX_COM_INPROC */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */