Changeset 7780 in vbox

Timestamp:

Apr 7, 2008 4:36:56 PM (17 years ago)

Author:

vboxsync

Message:

Add function to query all available VD backends, together with their capabilities. Also added a flag to the write operation (purely a dummy at the moment).

Location:

trunk/src/VBox/Devices/Storage

Files:

• RawHDDCore.cpp (modified) (2 diffs)
• VBoxHDD-new.cpp (modified) (7 diffs)
• VBoxHDD-newInternal.h (modified) (3 diffs)
• VDIHDDCore.cpp (modified) (2 diffs)
• VmdkHDDCore.cpp (modified) (2 diffs)

trunk/src/VBox/Devices/Storage/RawHDDCore.cpp

@@ -466 +466 @@
 static int rawWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
                     size_t cbToWrite, size_t *pcbWriteProcess,
-                    size_t *pcbPreRead, size_t *pcbPostRead)
+                    size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite)
 {
     LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
@@ -990 +990 @@
     /* cbSize */
     sizeof(VBOXHDDBACKEND),
+    /* uBackendCaps */
+    VD_CAP_CREATE_FIXED,
     /* pfnCheckIfValid */
     rawCheckIfValid,

trunk/src/VBox/Devices/Storage/VBoxHDD-new.cpp

@@ -109 +109 @@
 
 
+extern VBOXHDDBACKEND g_RawBackend;
 extern VBOXHDDBACKEND g_VmdkBackend;
 extern VBOXHDDBACKEND g_VDIBackend;
@@ -117 +118 @@
 static PCVBOXHDDBACKEND aBackends[] =
 {
+    &g_RawBackend,
     &g_VmdkBackend,
     &g_VDIBackend,
@@ -441 +443 @@
                                    uOffset - cbPreRead, pvTmp,
                                    cbPreRead + cbThisWrite + cbPostRead,
-                                   NULL,
-                                   &cbPreRead, &cbPostRead);
+                                   NULL, &cbPreRead, &cbPostRead, 0);
     Assert(rc != VERR_VDI_BLOCK_FREE);
     Assert(cbPreRead == 0);
@@ -521 +522 @@
                                    uOffset - cbPreRead, pvTmp,
                                    cbPreRead + cbThisWrite + cbPostRead,
-                                   NULL,
-                                   &cbPreRead, &cbPostRead);
+                                   NULL, &cbPreRead, &cbPostRead, 0);
     Assert(rc != VERR_VDI_BLOCK_FREE);
     Assert(cbPreRead == 0);
@@ -551 +551 @@
         rc = pImage->Backend->pfnWrite(pImage->pvBackendData, uOffset, pvBuf,
                                        cbThisWrite, &cbThisWrite, &cbPreRead,
-                                       &cbPostRead);
+                                       &cbPostRead, 0);
         if (rc == VERR_VDI_BLOCK_FREE)
         {
@@ -585 +585 @@
     } while (cbWrite != 0 && VBOX_SUCCESS(rc));
 
+    return rc;
+}
+
+
+/**
+ * Lists all HDD backends and their capabilities in a caller-provided buffer.
+ *
+ * @returns VBox status code.
+ *          VERR_BUFFER_OVERFLOW if not enough space is passed.
+ * @param   cEntriesAlloc   Number of list entries available.
+ * @param   pEntries        Pointer to array for the entries.
+ * @param   pcEntriesUsed   Number of entries returned.
+ */
+VBOXDDU_DECL(int) VDBackendInfo(unsigned cEntriesAlloc, PVDBACKENDINFO pEntries,
+                                unsigned *pcEntriesUsed)
+{
+    int rc = VINF_SUCCESS;
+    PRTDIR pPluginDir = NULL;
+    unsigned cEntries = 0;
+
+    LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
+    do
+    {
+        /* Check arguments. */
+        AssertMsgBreak(cEntriesAlloc,
+                       ("cEntriesAlloc=%u\n", cEntriesAlloc),
+                       rc = VERR_INVALID_PARAMETER);
+        AssertMsgBreak(VALID_PTR(pEntries),
+                       ("pEntries=%#p\n", pEntries),
+                       rc = VERR_INVALID_PARAMETER);
+        AssertMsgBreak(VALID_PTR(pcEntriesUsed),
+                       ("pcEntriesUsed=%#p\n", pcEntriesUsed),
+                       rc = VERR_INVALID_PARAMETER);
+
+        /* First enumerate static backends. */
+        for (unsigned i = 0; aBackends[i] != NULL; i++)
+        {
+            char *pszName = RTStrDup(aBackends[i]->pszBackendName);
+            if (!pszName)
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+            pEntries[cEntries].pszBackend = pszName;
+            pEntries[cEntries].uBackendCaps = aBackends[i]->uBackendCaps;
+            cEntries++;
+            if (cEntries >= cEntriesAlloc)
+            {
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
+            }
+        }
+        if (VBOX_FAILURE(rc))
+            break;
+
+        /* Then enumerate plugin backends. */
+        char szPath[RTPATH_MAX];
+        rc = RTPathSharedLibs(szPath, sizeof(szPath));
+        if (VBOX_FAILURE(rc))
+            break;
+
+        /* To get all entries with VBoxHDD as prefix. */
+        char *pszPluginFilter;
+        rc = RTStrAPrintf(&pszPluginFilter, "%s/%s*", szPath,
+                          VBOX_HDDFORMAT_PLUGIN_PREFIX);
+        if (VBOX_FAILURE(rc))
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        /* The plugins are in the same directory as the other shared libs. */
+        rc = RTDirOpenFiltered(&pPluginDir, pszPluginFilter, RTDIRFILTER_WINNT);
+        if (VBOX_FAILURE(rc))
+            break;
+
+        PRTDIRENTRY pPluginDirEntry = NULL;
+        unsigned cbPluginDirEntry = sizeof(RTDIRENTRY);
+        pPluginDirEntry = (PRTDIRENTRY)RTMemAllocZ(sizeof(RTDIRENTRY));
+        if (!pPluginDirEntry)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        while ((rc = RTDirRead(pPluginDir, pPluginDirEntry, &cbPluginDirEntry)) != VERR_NO_MORE_FILES)
+        {
+            RTLDRMOD hPlugin = NIL_RTLDRMOD;
+            PFNVBOXHDDFORMATLOAD pfnHDDFormatLoad = NULL;
+            PVBOXHDDBACKEND pBackend = NULL;
+
+            if (rc == VERR_BUFFER_OVERFLOW)
+            {
+                /* allocate new buffer. */
+                RTMemFree(pPluginDirEntry);
+                pPluginDirEntry = (PRTDIRENTRY)RTMemAllocZ(cbPluginDirEntry);
+                /* Retry. */
+                rc = RTDirRead(pPluginDir, pPluginDirEntry, &cbPluginDirEntry);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+            else if (VBOX_FAILURE(rc))
+                break;
+
+            /* We got the new entry. */
+            if (pPluginDirEntry->enmType != RTDIRENTRYTYPE_FILE)
+                continue;
+
+            rc = RTLdrLoad(pPluginDirEntry->szName, &hPlugin);
+            if (VBOX_SUCCESS(rc))
+            {
+                rc = RTLdrGetSymbol(hPlugin, VBOX_HDDFORMAT_LOAD_NAME, (void**)&pfnHDDFormatLoad);
+                if (VBOX_FAILURE(rc) || !pfnHDDFormatLoad)
+                {
+                    LogFunc(("error resolving the entry point %s in plugin %s, rc=%Vrc, pfnHDDFormat=%#p\n", VBOX_HDDFORMAT_LOAD_NAME, pPluginDirEntry->szName, rc, pfnHDDFormatLoad));
+                    if (VBOX_SUCCESS(rc))
+                        rc = VERR_SYMBOL_NOT_FOUND;
+                }
+
+                if (VBOX_SUCCESS(rc))
+                {
+                    /* Get the function table. */
+                    rc = pfnHDDFormatLoad(&pBackend);
+                    if (VBOX_SUCCESS(rc) && pBackend->cbSize == sizeof(VBOXHDDBACKEND))
+                    {
+                        char *pszName = RTStrDup(pBackend->pszBackendName);
+                        if (!pszName)
+                        {
+                            rc = VERR_NO_MEMORY;
+                            break;
+                        }
+                        pEntries[cEntries].pszBackend = pszName;
+                        pEntries[cEntries].uBackendCaps = pBackend->uBackendCaps;
+                        cEntries++;
+                        if (cEntries >= cEntriesAlloc)
+                        {
+                            rc = VERR_BUFFER_OVERFLOW;
+                            break;
+                        }
+                    }
+                }
+                else
+                    pBackend = NULL;
+
+                RTLdrClose(hPlugin);
+            }
+        }
+        RTStrFree(pszPluginFilter);
+        if (pPluginDirEntry)
+            RTMemFree(pPluginDirEntry);
+        if (pPluginDir)
+            RTDirClose(pPluginDir);
+    } while (0);
+
+    LogFlowFunc(("returns %Vrc *pcEntriesUsed=%u\n", rc, cEntries));
+    *pcEntriesUsed = cEntries;
     return rc;
 }
@@ -3029 +3185 @@
         {
             RTLogPrintf("Dumping VD image \"%s\" (Backend=%s)\n",
-                        pImage->Backend->pszBackendName, pImage->pszFilename);
+                        pImage->Backend->pszBackendName, pImage->pszFilename);
             pImage->Backend->pfnDump(pImage->pvBackendData);
         }

trunk/src/VBox/Devices/Storage/VBoxHDD-newInternal.h

@@ -21 +21 @@
 #include <VBox/VBoxHDD-new.h>
 
+
+/** @name VBox HDD backend write flags
+ * @{
+ */
+/** Do not allocate a new block on this write. */
+#define VD_WRITE_NO_ALLOC   RT_BIT(1)
+/** @}*/
+
+
 /**
  * Image format backend interface used by VBox HDD Container implementation.
@@ -35 +44 @@
      */
     uint32_t cbSize;
+
+    /**
+     * The capabilities of the backend.
+     */
+    uint64_t uBackendCaps;
 
     /**
@@ -144 +158 @@
      * @param   pcbPostRead     Pointer to the returned amount of data that must
      *                          be postfixed to perform a full block write.
-     */
-    DECLR3CALLBACKMEMBER(int, pfnWrite, (void *pvBackendData, uint64_t off, const void *pvBuf, size_t cbWrite, size_t *pcbWriteProcess, size_t *pcbPreRead, size_t *pcbPostRead));
+     * @param   fWrite          Flags which affect write behavior. Combination
+     *                          of the VD_WRITE_* flags.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnWrite, (void *pvBackendData, uint64_t off, const void *pvBuf, size_t cbWrite, size_t *pcbWriteProcess, size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite));
 
     /**

trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp

@@ -962 +962 @@
 static int vdiWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
                     size_t cbToWrite, size_t *pcbWriteProcess,
-                    size_t *pcbPreRead, size_t *pcbPostRead)
+                    size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite)
 {
     LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
@@ -1710 +1710 @@
     /* cbSize */
     sizeof(VBOXHDDBACKEND),
+    /* uBackendCaps */
+      VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
+    | VD_CAP_CREATE_SPLIT_2G | VD_CAP_DIFF,
     /* pfnCheckIfValid */
     vdiCheckIfValid,

trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp

@@ -3683 +3683 @@
 static int vmdkWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
                      size_t cbToWrite, size_t *pcbWriteProcess,
-                     size_t *pcbPreRead, size_t *pcbPostRead)
+                     size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite)
 {
     LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
@@ -4350 +4350 @@
     /* cbSize */
     sizeof(VBOXHDDBACKEND),
+    /* uBackendCaps */
+      VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
+    | VD_CAP_CREATE_SPLIT_2G | VD_CAP_DIFF,
     /* pfnCheckIfValid */
     vmdkCheckIfValid,