Changeset 35789 in vbox for trunk/src

Timestamp:

Jan 31, 2011 3:25:22 PM (14 years ago)

Author:

vboxsync

Message:

Storage/tstVDIo: Updates + sample script which is a replacement of tstVDShareable

Location:

trunk/src/VBox/Storage/testcase

Files:

• tstVDIo.cpp (modified) (64 diffs)
• tstVDShareable.vd (added)

trunk/src/VBox/Storage/testcase/tstVDIo.cpp

@@ -17 +17 @@
  */
 #define LOGGROUP LOGGROUP_DEFAULT
+#define RTMEM_WRAP_TO_EF_APIS
 #include <VBox/vd.h>
 #include <VBox/err.h>
@@ -46 +47 @@
     /** Memory file baking the file. */
     PVDMEMDISK     pMemDisk;
+    /** Flag whether the file is read locked. */
+    bool           fReadLock;
+    /** Flag whether the file is write locked. */
+    bool           fWriteLock;
+} VDFILE, *PVDFILE;
+
+/**
+ * VD storage object.
+ */
+typedef struct VDSTORAGE
+{
+    /** Pointer to the file. */
+    PVDFILE        pFile;
     /** Completion callback of the VD layer. */
     PFNVDCOMPLETED pfnComplete;
-} VDFILE, *PVDFILE;
+} VDSTORAGE, *PVDSTORAGE;
+
+/**
+ * A virtual disk.
+ */
+typedef struct VDDISK
+{
+    /** List node. */
+    RTLISTNODE     ListNode;
+    /** Name of the disk handle for identification. */
+    char          *pszName;
+    /** HDD handle to operate on. */
+    PVBOXHDD       pVD;
+    /** Physical CHS Geometry. */
+    VDGEOMETRY     PhysGeom;
+    /** Logical CHS geometry. */
+    VDGEOMETRY     LogicalGeom;
+} VDDISK, *PVDDISK;
 
 /**
@@ -55 +86 @@
 typedef struct VDTESTGLOB
 {
-    /** HDD handle to operate on. */
-    PVBOXHDD         pVD;
+    /** List of active virtual disks. */
+    RTLISTNODE       ListDisks;
     /** Head of the active file list. */
     RTLISTNODE       ListFiles;
@@ -73 +104 @@
     /** Pointer to the per image interface list. */
     PVDINTERFACE     pInterfacesImages;
-    /** Physical CHS Geometry. */
-    VDGEOMETRY       PhysGeom;
-    /** Logical CHS geometry. */
-    VDGEOMETRY       LogicalGeom;
     /** I/O RNG handle. */
     PVDIORND         pIoRnd;
@@ -136 +163 @@
     union
     {
-        /** Next offset for seuential access. */
+        /** Next offset for sequential access. */
         uint64_t    offNext;
         /** Data for random acess. */
@@ -251 +278 @@
 static DECLCALLBACK(int) vdScriptHandlerSleep(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs);
 static DECLCALLBACK(int) vdScriptHandlerDumpFile(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs);
+static DECLCALLBACK(int) vdScriptHandlerCreateDisk(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs);
+static DECLCALLBACK(int) vdScriptHandlerDestroyDisk(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs);
+static DECLCALLBACK(int) vdScriptHandlerCompareDisks(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs);
 
 /* create action */
 const VDSCRIPTARGDESC g_aArgCreate[] =
 {
-    /* pcszName chId enmType                          fFlags */
-    {"mode",    'm', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"name",    'n', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"backend", 'b', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"size",    's', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY | VDSCRIPTARGDESC_FLAG_SIZE_SUFFIX},
+    /* pcszName    chId enmType                          fFlags */
+    {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"mode",       'm', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"name",       'n', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"type",       't', VDSCRIPTARGTYPE_STRING,          0},
+    {"backend",    'b', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"size",       's', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY | VDSCRIPTARGDESC_FLAG_SIZE_SUFFIX}
 };
 
@@ -265 +297 @@
 const VDSCRIPTARGDESC g_aArgOpen[] =
 {
-    /* pcszName chId enmType                             fFlags */
-    {"name",    'n', VDSCRIPTARGTYPE_STRING,             VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"backend", 'b', VDSCRIPTARGTYPE_STRING,             VDSCRIPTARGDESC_FLAG_MANDATORY}
+    /* pcszName    chId enmType                          fFlags */
+    {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"name",       'n', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"backend",    'b', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"shareable",  's', VDSCRIPTARGTYPE_BOOL,            0},
+    {"readonly",   'r', VDSCRIPTARGTYPE_BOOL,            0}
 };
 
-/* write action */
+/* I/O action */
 const VDSCRIPTARGDESC g_aArgIo[] =
 {
     /* pcszName    chId enmType                          fFlags */
+    {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
     {"async",      'a', VDSCRIPTARGTYPE_BOOL,            0},
     {"max-reqs",   'l', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, 0},
@@ -280 +316 @@
     {"blocksize",  'b', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY | VDSCRIPTARGDESC_FLAG_SIZE_SUFFIX},
     {"off",        'o', VDSCRIPTARGTYPE_UNSIGNED_RANGE,  VDSCRIPTARGDESC_FLAG_SIZE_SUFFIX},
-    {"reads",      'r', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY},
     {"writes",     'w', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
@@ -287 +322 @@
 const VDSCRIPTARGDESC g_aArgFlush[] =
 {
-    /* pcszName  chId enmType                            fFlags */
-    {"async",    'a', VDSCRIPTARGTYPE_BOOL,              0}
+    /* pcszName    chId enmType                          fFlags */
+    {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"async",      'a', VDSCRIPTARGTYPE_BOOL,            0}
 };
 
@@ -294 +330 @@
 const VDSCRIPTARGDESC g_aArgMerge[] =
 {
-    /* pcszName  chId enmType                            fFlags */
-    {"forward",  'f', VDSCRIPTARGTYPE_BOOL,              VDSCRIPTARGDESC_FLAG_MANDATORY}
+    /* pcszName    chId enmType                          fFlags */
+    {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"forward",    'f', VDSCRIPTARGTYPE_BOOL,            VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
 
@@ -301 +338 @@
 const VDSCRIPTARGDESC g_aArgClose[] =
 {
-    /* pcszName  chId enmType                            fFlags */
-    {"mode",     'm', VDSCRIPTARGTYPE_STRING,            VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"delete",   'd', VDSCRIPTARGTYPE_BOOL,              VDSCRIPTARGDESC_FLAG_MANDATORY}
+    /* pcszName    chId enmType                          fFlags */
+    {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"mode",       'm', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"delete",     'r', VDSCRIPTARGTYPE_BOOL,            VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
 
@@ -309 +347 @@
 const VDSCRIPTARGDESC g_aArgIoRngCreate[] =
 {
-    /* pcszName  chId enmType                            fFlags */
-    {"size",     'd', VDSCRIPTARGTYPE_UNSIGNED_NUMBER,   VDSCRIPTARGDESC_FLAG_MANDATORY | VDSCRIPTARGDESC_FLAG_SIZE_SUFFIX},
-    {"seed",     's', VDSCRIPTARGTYPE_UNSIGNED_NUMBER,   VDSCRIPTARGDESC_FLAG_MANDATORY}
+    /* pcszName    chId enmType                          fFlags */
+    {"size",       'd', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY | VDSCRIPTARGDESC_FLAG_SIZE_SUFFIX},
+    {"seed",       's', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
 
@@ -317 +355 @@
 const VDSCRIPTARGDESC g_aArgSleep[] =
 {
-    /* pcszName  chId enmType                            fFlags */
-    {"time",     't', VDSCRIPTARGTYPE_UNSIGNED_NUMBER,   VDSCRIPTARGDESC_FLAG_MANDATORY},
+    /* pcszName    chId enmType                          fFlags */
+    {"time",       't', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
 
@@ -324 +362 @@
 const VDSCRIPTARGDESC g_aArgDumpFile[] =
 {
-    /* pcszName  chId enmType                            fFlags */
-    {"file",     'f', VDSCRIPTARGTYPE_STRING,            VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"path",     'p', VDSCRIPTARGTYPE_STRING,            VDSCRIPTARGDESC_FLAG_MANDATORY},
+    /* pcszName    chId enmType                          fFlags */
+    {"file",       'f', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"path",       'p', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY}
+};
+
+/* Create virtual disk handle */
+const VDSCRIPTARGDESC g_aArgCreateDisk[] =
+{
+    /* pcszName    chId enmType                          fFlags */
+    {"name",       'n', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY}
+};
+
+/* Create virtual disk handle */
+const VDSCRIPTARGDESC g_aArgDestroyDisk[] =
+{
+    /* pcszName    chId enmType                          fFlags */
+    {"name",       'n', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY}
+};
+
+/* Compare virtual disks */
+const VDSCRIPTARGDESC g_aArgCompareDisks[] =
+{
+    /* pcszName    chId enmType                          fFlags */
+    {"disk1",      '1', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"disk2",      '2', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
 
@@ -341 +401 @@
     {"iorngdestroy", NULL,                0,                               vdScriptHandlerIoRngDestroy},
     {"sleep",        g_aArgSleep,         RT_ELEMENTS(g_aArgSleep),        vdScriptHandlerSleep},
-    {"dumpfile",     g_aArgDumpFile,      RT_ELEMENTS(g_aArgDumpFile),     vdScriptHandlerDumpFile}
+    {"dumpfile",     g_aArgDumpFile,      RT_ELEMENTS(g_aArgDumpFile),     vdScriptHandlerDumpFile},
+    {"createdisk",   g_aArgCreateDisk,    RT_ELEMENTS(g_aArgCreateDisk),   vdScriptHandlerCreateDisk},
+    {"destroydisk",  g_aArgDestroyDisk,   RT_ELEMENTS(g_aArgDestroyDisk),  vdScriptHandlerDestroyDisk},
+    {"comparedisks", g_aArgCompareDisks,  RT_ELEMENTS(g_aArgCompareDisks), vdScriptHandlerCompareDisks}
 };
 
@@ -363 +426 @@
 static int tstVDIoTestInit(PVDIOTEST pIoTest, PVDTESTGLOB pGlob, bool fRandomAcc, uint64_t cbIo,
                            size_t cbBlkSize, uint64_t offStart, uint64_t offEnd,
-                           unsigned uWriteChance, unsigned uReadChance);
+                           unsigned uWriteChance);
 static bool tstVDIoTestRunning(PVDIOTEST pIoTest);
 static void tstVDIoTestDestroy(PVDIOTEST pIoTest);
@@ -370 +433 @@
 static void tstVDIoTestReqComplete(void *pvUser1, void *pvUser2, int rcReq);
 
+static PVDDISK tstVDIoGetDiskByName(PVDTESTGLOB pGlob, const char *pcszDisk);
+
 static DECLCALLBACK(int) vdScriptHandlerCreate(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs)
 {
@@ -376 +441 @@
     const char *pcszBackend = NULL;
     const char *pcszImage = NULL;
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
     bool fBase = false;
+    bool fDynamic = true;
 
     for (unsigned i = 0; i < cScriptArgs; i++)
@@ -382 +450 @@
         switch (paScriptArgs[i].chId)
         {
+            case 'd':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
             case 'm':
             {
@@ -410 +483 @@
                 break;
             }
+            case 't':
+            {
+                if (!RTStrICmp(paScriptArgs[i].u.pcszString, "fixed"))
+                    fDynamic = false;
+                else if (!RTStrICmp(paScriptArgs[i].u.pcszString, "dynamic"))
+                    fDynamic = true;
+                else
+                {
+                    RTPrintf("Invalid image type '%s' given\n", paScriptArgs[i].u.pcszString);
+                    rc = VERR_INVALID_PARAMETER;
+                }
+                break;
+            }
             default:
                 AssertMsgFailed(("Invalid argument given!\n"));
@@ -420 +506 @@
     if (RT_SUCCESS(rc))
     {
-        if (fBase)
-            rc = VDCreateBase(pGlob->pVD, pcszBackend, pcszImage, cbSize, 0, NULL,
-                              &pGlob->PhysGeom, &pGlob->LogicalGeom,
-                              NULL, VD_OPEN_FLAGS_ASYNC_IO, pGlob->pInterfacesImages, NULL);
+        pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+        if (pDisk)
+        {
+            unsigned fImageFlags = VD_IMAGE_FLAGS_NONE;
+
+            if (!fDynamic)
+                fImageFlags |= VD_IMAGE_FLAGS_FIXED;
+
+            if (fBase)
+                rc = VDCreateBase(pDisk->pVD, pcszBackend, pcszImage, cbSize, fImageFlags, NULL,
+                                  &pDisk->PhysGeom, &pDisk->LogicalGeom,
+                                  NULL, VD_OPEN_FLAGS_ASYNC_IO, pGlob->pInterfacesImages, NULL);
+            else
+                rc = VDCreateDiff(pDisk->pVD, pcszBackend, pcszImage, fImageFlags, NULL, NULL, NULL, VD_OPEN_FLAGS_ASYNC_IO,
+                                  pGlob->pInterfacesImages, NULL);
+        }
         else
-            rc = VDCreateDiff(pGlob->pVD, pcszBackend, pcszImage, 0, NULL, NULL, NULL, VD_OPEN_FLAGS_ASYNC_IO,
-                              pGlob->pInterfacesImages, NULL);
+            rc = VERR_NOT_FOUND;
     }
 
@@ -437 +534 @@
     const char *pcszBackend = NULL;
     const char *pcszImage = NULL;
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
+    bool fShareable = false;
+    bool fReadonly = false;
 
     for (unsigned i = 0; i < cScriptArgs; i++)
@@ -442 +543 @@
         switch (paScriptArgs[i].chId)
         {
+            case 'd':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
             case 'n':
             {
@@ -450 +556 @@
             {
                 pcszBackend = paScriptArgs[i].u.pcszString;
+                break;
+            }
+            case 's':
+            {
+                fShareable = paScriptArgs[i].u.fFlag;
+                break;
+            }
+            case 'r':
+            {
+                fReadonly = paScriptArgs[i].u.fFlag;
                 break;
             }
@@ -462 +578 @@
     if (RT_SUCCESS(rc))
     {
-        rc = VDOpen(pGlob->pVD, pcszBackend, pcszImage, VD_OPEN_FLAGS_ASYNC_IO, pGlob->pInterfacesImages);
+        pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+        if (pDisk)
+        {
+            unsigned fOpenFlags = VD_OPEN_FLAGS_ASYNC_IO;
+
+            if (fShareable)
+                fOpenFlags |= VD_OPEN_FLAGS_SHAREABLE;
+            if (fReadonly)
+                fOpenFlags |= VD_OPEN_FLAGS_READONLY;
+
+            rc = VDOpen(pDisk->pVD, pcszBackend, pcszImage, fOpenFlags, pGlob->pInterfacesImages);
+        }
+        else
+            rc = VERR_NOT_FOUND;
     }
 
@@ -481 +610 @@
     unsigned cMaxReqs = 0;
     uint8_t uWriteChance = 0;
-    uint8_t uReadChance = 0;
-
-    offEnd = VDGetSize(pGlob->pVD, VD_LAST_IMAGE);
-    if (offEnd == 0)
-        return VERR_INVALID_STATE;
-    cbIo = offEnd;
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
 
     for (unsigned i = 0; i < cScriptArgs; i++)
@@ -492 +617 @@
         switch (paScriptArgs[i].chId)
         {
+            case 'd':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
             case 'a':
             {
@@ -531 +661 @@
                 break;
             }
-            case 'r':
-            {
-                uReadChance = (uint8_t)paScriptArgs[i].u.u64;
-                break;
-            }
             case 'w':
             {
@@ -551 +676 @@
     if (RT_SUCCESS(rc))
     {
+        pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+        if (!pDisk)
+            rc = VERR_NOT_FOUND;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Set defaults if not set by the user. */
+        if (offStart == 0 && offEnd == 0)
+        {
+            offEnd = VDGetSize(pDisk->pVD, VD_LAST_IMAGE);
+            if (offEnd == 0)
+                return VERR_INVALID_STATE;
+        }
+
+        if (!cbIo)
+            cbIo = offEnd;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
         VDIOTEST IoTest;
 
-        rc = tstVDIoTestInit(&IoTest, pGlob, fRandomAcc, cbIo, cbBlkSize, offStart, offEnd, uWriteChance, uReadChance);
+        rc = tstVDIoTestInit(&IoTest, pGlob, fRandomAcc, cbIo, cbBlkSize, offStart, offEnd, uWriteChance);
         if (RT_SUCCESS(rc))
         {
@@ -601 +747 @@
                                         case VDIOREQTXDIR_READ:
                                         {
-                                            rc = VDRead(pGlob->pVD, paIoReq[idx].off, paIoReq[idx].DataSeg.pvSeg, paIoReq[idx].cbReq);
+                                            rc = VDRead(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].DataSeg.pvSeg, paIoReq[idx].cbReq);
                                             break;
                                         }
                                         case VDIOREQTXDIR_WRITE:
                                         {
-                                            rc = VDWrite(pGlob->pVD, paIoReq[idx].off, paIoReq[idx].DataSeg.pvSeg, paIoReq[idx].cbReq);
+                                            rc = VDWrite(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].DataSeg.pvSeg, paIoReq[idx].cbReq);
                                             break;
                                         }
                                         case VDIOREQTXDIR_FLUSH:
                                         {
-                                            rc = VDFlush(pGlob->pVD);
+                                            rc = VDFlush(pDisk->pVD);
                                             break;
                                         }
@@ -624 +770 @@
                                         case VDIOREQTXDIR_READ:
                                         {
-                                            rc = VDAsyncRead(pGlob->pVD, paIoReq[idx].off, paIoReq[idx].cbReq, &paIoReq[idx].SgBuf,
+                                            rc = VDAsyncRead(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].cbReq, &paIoReq[idx].SgBuf,
                                                              tstVDIoTestReqComplete, &paIoReq[idx], EventSem);
                                             break;
@@ -630 +776 @@
                                         case VDIOREQTXDIR_WRITE:
                                         {
-                                            rc = VDAsyncWrite(pGlob->pVD, paIoReq[idx].off, paIoReq[idx].cbReq, &paIoReq[idx].SgBuf,
+                                            rc = VDAsyncWrite(pDisk->pVD, paIoReq[idx].off, paIoReq[idx].cbReq, &paIoReq[idx].SgBuf,
                                                               tstVDIoTestReqComplete, &paIoReq[idx], EventSem);
                                             break;
@@ -636 +782 @@
                                         case VDIOREQTXDIR_FLUSH:
                                         {
-                                            rc = VDAsyncFlush(pGlob->pVD, tstVDIoTestReqComplete, &paIoReq[idx], EventSem);
+                                            rc = VDAsyncFlush(pDisk->pVD, tstVDIoTestReqComplete, &paIoReq[idx], EventSem);
                                             break;
                                         }
@@ -715 +861 @@
     int rc = VINF_SUCCESS;
     bool fAsync = false;
-
-    if (cScriptArgs == 1 && paScriptArgs[0].chId == 'a')
-        fAsync = paScriptArgs[0].u.fFlag;
-
-    if (fAsync)
-    {
-        /** @todo  */
-        rc = VERR_NOT_IMPLEMENTED;
-    }
-    else
-        rc = VDFlush(pGlob->pVD);
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
+
+    for (unsigned i = 0; i < cScriptArgs; i++)
+    {
+        switch (paScriptArgs[i].chId)
+        {
+            case 'd':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
+            case 'a':
+            {
+                fAsync = paScriptArgs[i].u.fFlag;
+                break;
+            }
+
+            default:
+                AssertMsgFailed(("Invalid argument given!\n"));
+        }
+
+        if (RT_FAILURE(rc))
+            break;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+        if (!pDisk)
+            rc = VERR_NOT_FOUND;
+        else if (fAsync)
+        {
+            /** @todo  */
+            rc = VERR_NOT_IMPLEMENTED;
+        }
+        else
+            rc = VDFlush(pDisk->pVD);
+    }
 
     return rc;
@@ -740 +914 @@
     bool fAll = false;
     bool fDelete = false;
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
 
     for (unsigned i = 0; i < cScriptArgs; i++)
@@ -745 +921 @@
         switch (paScriptArgs[i].chId)
         {
+            case 'd':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
             case 'm':
             {
@@ -758 +939 @@
                 break;
             }
-            case 'd':
+            case 'r':
             {
                 fDelete = paScriptArgs[i].u.fFlag;
@@ -781 +962 @@
     if (RT_SUCCESS(rc))
     {
-        if (fAll)
-            rc = VDCloseAll(pGlob->pVD);
+        pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+        if (pDisk)
+        {
+            if (fAll)
+                rc = VDCloseAll(pDisk->pVD);
+            else
+                rc = VDClose(pDisk->pVD, fDelete);
+        }
         else
-            rc = VDClose(pGlob->pVD, fDelete);
+            rc = VERR_NOT_FOUND;
     }
     return rc;
@@ -910 +1097 @@
 }
 
+static DECLCALLBACK(int) vdScriptHandlerCreateDisk(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs)
+{
+    int rc = VINF_SUCCESS;
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
+
+    for (unsigned i = 0; i < cScriptArgs; i++)
+    {
+        switch (paScriptArgs[i].chId)
+        {
+            case 'n':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
+            default:
+                AssertMsgFailed(("Invalid argument given!\n"));
+        }
+    }
+
+    pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+    if (pDisk)
+        rc = VERR_ALREADY_EXISTS;
+    else
+    {
+        pDisk = (PVDDISK)RTMemAllocZ(sizeof(VDDISK));
+        if (pDisk)
+        {
+            pDisk->pszName = RTStrDup(pcszDisk);
+            if (pDisk->pszName)
+            {
+                rc = VDCreate(pGlob->pInterfacesDisk, VDTYPE_HDD, &pDisk->pVD);
+
+                if (RT_SUCCESS(rc))
+                    RTListAppend(&pGlob->ListDisks, &pDisk->ListNode);
+                else
+                    RTStrFree(pDisk->pszName);
+            }
+            else
+                rc = VERR_NO_MEMORY;
+
+            if (RT_FAILURE(rc))
+                RTMemFree(pDisk);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    return rc;
+}
+
+static DECLCALLBACK(int) vdScriptHandlerDestroyDisk(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs)
+{
+    int rc = VINF_SUCCESS;
+    const char *pcszDisk = NULL;
+    PVDDISK pDisk = NULL;
+
+    for (unsigned i = 0; i < cScriptArgs; i++)
+    {
+        switch (paScriptArgs[i].chId)
+        {
+            case 'n':
+            {
+                pcszDisk = paScriptArgs[i].u.pcszString;
+                break;
+            }
+            default:
+                AssertMsgFailed(("Invalid argument given!\n"));
+        }
+    }
+
+    pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+    if (pDisk)
+    {
+        RTListNodeRemove(&pDisk->ListNode);
+        VDDestroy(pDisk->pVD);
+        RTStrFree(pDisk->pszName);
+        RTMemFree(pDisk);
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdScriptHandlerCompareDisks(PVDTESTGLOB pGlob, PVDSCRIPTARG paScriptArgs, unsigned cScriptArgs)
+{
+    int rc = VINF_SUCCESS;
+    const char *pcszDisk1 = NULL;
+    PVDDISK pDisk1 = NULL;
+    const char *pcszDisk2 = NULL;
+    PVDDISK pDisk2 = NULL;
+
+    for (unsigned i = 0; i < cScriptArgs; i++)
+    {
+        switch (paScriptArgs[i].chId)
+        {
+            case '1':
+            {
+                pcszDisk1 = paScriptArgs[i].u.pcszString;
+                break;
+            }
+            case '2':
+            {
+                pcszDisk2 = paScriptArgs[i].u.pcszString;
+                break;
+            }
+            default:
+                AssertMsgFailed(("Invalid argument given!\n"));
+        }
+    }
+
+    pDisk1 = tstVDIoGetDiskByName(pGlob, pcszDisk1);
+    pDisk2 = tstVDIoGetDiskByName(pGlob, pcszDisk2);
+
+    if (pDisk1 && pDisk2)
+    {
+        uint8_t *pbBuf1 = (uint8_t *)RTMemAllocZ(16 * _1M);
+        uint8_t *pbBuf2 = (uint8_t *)RTMemAllocZ(16 * _1M);
+        if (pbBuf1 && pbBuf2)
+        {
+            uint64_t cbDisk1, cbDisk2;
+            uint64_t uOffCur = 0;
+
+            cbDisk1 = VDGetSize(pDisk1->pVD, VD_LAST_IMAGE);
+            cbDisk2 = VDGetSize(pDisk2->pVD, VD_LAST_IMAGE);
+
+            if (cbDisk1 != cbDisk2)
+                RTPrintf("Disks differ in size %llu vs %llu\n", cbDisk1, cbDisk2);
+            else
+            {
+                while (uOffCur < cbDisk1)
+                {
+                    size_t cbRead = RT_MIN(cbDisk1, 16 * _1M);
+
+                    rc = VDRead(pDisk1->pVD, uOffCur, pbBuf1, cbRead);
+                    if (RT_SUCCESS(rc))
+                        rc = VDRead(pDisk2->pVD, uOffCur, pbBuf2, cbRead);
+
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (memcmp(pbBuf1, pbBuf2, cbRead))
+                        {
+                            RTPrintf("Disks differ at offset %llu\n", uOffCur);
+                            rc = VERR_DEV_IO_ERROR;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        RTPrintf("Reading one disk at offset %llu failed\n", uOffCur);
+                        break;
+                    }
+
+                    uOffCur += cbRead;
+                    cbDisk1 -= cbRead;
+                }
+            }
+            RTMemFree(pbBuf1);
+            RTMemFree(pbBuf2);
+        }
+        else
+        {
+            if (pbBuf1)
+                RTMemFree(pbBuf1);
+            if (pbBuf2)
+                RTMemFree(pbBuf2);
+            rc = VERR_NO_MEMORY;
+        }
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    return rc;
+}
+
 static DECLCALLBACK(int) tstVDIoFileOpen(void *pvUser, const char *pszLocation,
                                          uint32_t fOpen,
@@ -919 +1281 @@
     bool fFound = false;
 
+    /*
+     * Some backends use ./ for paths, strip it.
+     * @todo: Implement proper directory support for the
+     * memory filesystem.
+     */
+    if (   strlen(pszLocation) >= 2
+        && *pszLocation == '.'
+        && pszLocation[1] == '/')
+        pszLocation += 2;
+
     /* Check if the file exists. */
     PVDFILE pIt = NULL;
@@ -930 +1302 @@
     }
 
-    if (fFound && pIt->pfnComplete)
-        rc = VERR_FILE_LOCK_FAILED;
-    else if ((fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE)
+    if ((fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE)
     {
         /* If the file exists delete the memory disk. */
@@ -943 +1313 @@
             if (pIt)
             {
-                pIt->pfnComplete = pfnCompleted;
-                pIt->pszName     = RTStrDup(pszLocation);
+                pIt->pszName = RTStrDup(pszLocation);
 
                 if (pIt->pszName)
@@ -970 +1339 @@
         if (!fFound)
             rc = VERR_FILE_NOT_FOUND;
-        else
-            pIt->pfnComplete = pfnCompleted;
     }
     else
@@ -979 +1346 @@
     {
         AssertPtr(pIt);
-        *ppStorage = pIt;
+        PVDSTORAGE pStorage = (PVDSTORAGE)RTMemAllocZ(sizeof(VDSTORAGE));
+        if (!pStorage)
+            rc = VERR_NO_MEMORY;
+
+        pStorage->pFile = pIt;
+        pStorage->pfnComplete = pfnCompleted;
+        *ppStorage = pStorage;
     }
 
@@ -987 +1360 @@
 static DECLCALLBACK(int) tstVDIoFileClose(void *pvUser, void *pStorage)
 {
-    PVDFILE pFile = (PVDFILE)pStorage;
-
-    /* Mark as not busy. */
-    pFile->pfnComplete = NULL;
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
+
+    RTMemFree(pIoStorage);
     return VINF_SUCCESS;
 }
@@ -1076 +1448 @@
 static DECLCALLBACK(int) tstVDIoFileGetSize(void *pvUser, void *pStorage, uint64_t *pcbSize)
 {
-    PVDFILE pFile = (PVDFILE)pStorage;
-
-    return VDMemDiskGetSize(pFile->pMemDisk, pcbSize);
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
+
+    return VDMemDiskGetSize(pIoStorage->pFile->pMemDisk, pcbSize);
 }
 
 static DECLCALLBACK(int) tstVDIoFileSetSize(void *pvUser, void *pStorage, uint64_t cbSize)
 {
-    PVDFILE pFile = (PVDFILE)pStorage;
-
-    return VDMemDiskSetSize(pFile->pMemDisk, cbSize);
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
+
+    return VDMemDiskSetSize(pIoStorage->pFile->pMemDisk, cbSize);
 }
 
@@ -1092 +1464 @@
 {
     int rc = VINF_SUCCESS;
-    PVDFILE pFile = (PVDFILE)pStorage;
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
 
     RTSGBUF SgBuf;
@@ -1100 +1472 @@
     Seg.cbSeg = cbBuffer;
     RTSgBufInit(&SgBuf, &Seg, 1);
-    rc = VDMemDiskWrite(pFile->pMemDisk, uOffset, cbBuffer, &SgBuf);
+    rc = VDMemDiskWrite(pIoStorage->pFile->pMemDisk, uOffset, cbBuffer, &SgBuf);
     if (RT_SUCCESS(rc) && pcbWritten)
         *pcbWritten = cbBuffer;
@@ -1111 +1483 @@
 {
     int rc = VINF_SUCCESS;
-    PVDFILE pFile = (PVDFILE)pStorage;
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
 
     RTSGBUF SgBuf;
@@ -1119 +1491 @@
     Seg.cbSeg = cbBuffer;
     RTSgBufInit(&SgBuf, &Seg, 1);
-    rc = VDMemDiskRead(pFile->pMemDisk, uOffset, cbBuffer, &SgBuf);
+    rc = VDMemDiskRead(pIoStorage->pFile->pMemDisk, uOffset, cbBuffer, &SgBuf);
     if (RT_SUCCESS(rc) && pcbRead)
         *pcbRead = cbBuffer;
@@ -1139 +1511 @@
     int rc = VINF_SUCCESS;
     PVDTESTGLOB pGlob = (PVDTESTGLOB)pvUser;
-    PVDFILE pFile = (PVDFILE)pStorage;
-
-    rc = VDIoBackendMemTransfer(pGlob->pIoBackend, pFile->pMemDisk, VDIOTXDIR_READ, uOffset,
-                                cbRead, paSegments, cSegments, pFile->pfnComplete, pvCompletion);
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
+
+    rc = VDIoBackendMemTransfer(pGlob->pIoBackend, pIoStorage->pFile->pMemDisk, VDIOTXDIR_READ, uOffset,
+                                cbRead, paSegments, cSegments, pIoStorage->pfnComplete, pvCompletion);
     if (RT_SUCCESS(rc))
         rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -1156 +1528 @@
     int rc = VINF_SUCCESS;
     PVDTESTGLOB pGlob = (PVDTESTGLOB)pvUser;
-    PVDFILE pFile = (PVDFILE)pStorage;
-
-    rc = VDIoBackendMemTransfer(pGlob->pIoBackend, pFile->pMemDisk, VDIOTXDIR_WRITE, uOffset,
-                                cbWrite, paSegments, cSegments, pFile->pfnComplete, pvCompletion);
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
+
+    rc = VDIoBackendMemTransfer(pGlob->pIoBackend, pIoStorage->pFile->pMemDisk, VDIOTXDIR_WRITE, uOffset,
+                                cbWrite, paSegments, cSegments, pIoStorage->pfnComplete, pvCompletion);
     if (RT_SUCCESS(rc))
         rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -1171 +1543 @@
     int rc = VINF_SUCCESS;
     PVDTESTGLOB pGlob = (PVDTESTGLOB)pvUser;
-    PVDFILE pFile = (PVDFILE)pStorage;
-
-    rc = VDIoBackendMemTransfer(pGlob->pIoBackend, pFile->pMemDisk, VDIOTXDIR_FLUSH, 0,
-                                0, NULL, 0, pFile->pfnComplete, pvCompletion);
+    PVDSTORAGE pIoStorage = (PVDSTORAGE)pStorage;
+
+    rc = VDIoBackendMemTransfer(pGlob->pIoBackend, pIoStorage->pFile->pMemDisk, VDIOTXDIR_FLUSH, 0,
+                                0, NULL, 0, pIoStorage->pfnComplete, pvCompletion);
     if (RT_SUCCESS(rc))
         rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -1183 +1555 @@
 static int tstVDIoTestInit(PVDIOTEST pIoTest, PVDTESTGLOB pGlob, bool fRandomAcc, uint64_t cbIo,
                            size_t cbBlkSize, uint64_t offStart, uint64_t offEnd,
-                           unsigned uWriteChance, unsigned uReadChance)
+                           unsigned uWriteChance)
 {
     int rc = VINF_SUCCESS;
@@ -1303 +1675 @@
                 if (!pIoTest->u.Rnd.cBlocksLeft)
                 {
-                    /* New round, clear everthing. */
+                    /* New round, clear everything. */
                     ASMBitClearRange(pIoTest->u.Rnd.pbMapAccessed, 0, pIoTest->u.Rnd.cBlocks);
                     pIoTest->u.Rnd.cBlocksLeft = pIoTest->u.Rnd.cBlocks;
@@ -1346 +1718 @@
 
 /**
+ * Returns the disk handle by name or NULL if not found
+ *
+ * @returns Disk handle or NULL if the disk could not be found.
+ *
+ * @param pGlob    Global test state.
+ * @param pcszDisk Name of the disk to get.
+ */
+static PVDDISK tstVDIoGetDiskByName(PVDTESTGLOB pGlob, const char *pcszDisk)
+{
+    PVDDISK pIt = NULL;
+    bool fFound = false;
+
+    LogFlowFunc(("pGlob=%#p pcszDisk=%s\n", pGlob, pcszDisk));
+
+    RTListForEach(&pGlob->ListDisks, pIt, VDDISK, ListNode)
+    {
+        if (!RTStrCmp(pIt->pszName, pcszDisk))
+        {
+            fFound = true;
+            break;
+        }
+    }
+
+    LogFlowFunc(("return %#p\n", fFound ? pIt : NULL));
+    return fFound ? pIt : NULL;
+}
+
+/**
  * Skips the characters until the given character is reached.
  *
@@ -1396 +1796 @@
 
     return psz;
+}
+
+/**
+ * Returns true if the first character of the given string
+ * contains a character marking a line end (comment or \0
+ * terminator).
+ *
+ * @returns true if the line contains no more characters of
+ *          interest and false otherwise.
+ *
+ * @param psz    The string to check for.
+ */
+static bool tstVDIoIsLineEnd(const char *psz)
+{
+    return *psz == '\0' || *psz == '#';
 }
 
@@ -1620 +2035 @@
 
     while (    psz
-           && *psz != '\0')
+           && !tstVDIoIsLineEnd(psz))
     {
         const char *pcszName = psz;
 
         psz = tstVDIoScriptSkipUntil(psz, '=');
-        if (psz != '\0')
+        if (!tstVDIoIsLineEnd(psz))
         {
             *psz = '\0'; /* Overwrite */
@@ -1632 +2047 @@
 
             psz = tstVDIoScriptSkipNonSpace(psz);
-            if (psz != '\0')
+            if (!tstVDIoIsLineEnd(psz))
             {
                 *psz = '\0'; /* Overwrite */
                 psz++;
                 psz = tstVDIoScriptSkipSpace(psz);
-
-                /* We have the name and value pair now. */
-                bool fMandatory = false; /* Shut up gcc */
-                rc = tstVDIoScriptArgumentParse(pVDScriptAction, pcszName, pcszValue, &paScriptArgs[cScriptArgs], &fMandatory);
-                if (RT_SUCCESS(rc))
-                {
-                    if (fMandatory)
-                        cMandatoryArgsReq--;
-                    cScriptArgs++;
-                }
-            }
-            else
+            }
+
+            pcszValue = tstVDIoScriptSkipSpace((char *)pcszValue);
+            if (*pcszValue == '\0')
             {
                 RTPrintf("Value missing for argument '%s'\n", pcszName);
                 rc = VERR_INVALID_STATE;
                 break;
+            }
+
+            /* We have the name and value pair now. */
+            bool fMandatory = false; /* Shut up gcc */
+            rc = tstVDIoScriptArgumentParse(pVDScriptAction, pcszName, pcszValue, &paScriptArgs[cScriptArgs], &fMandatory);
+            if (RT_SUCCESS(rc))
+            {
+                if (fMandatory)
+                    cMandatoryArgsReq--;
+                cScriptArgs++;
             }
         }
@@ -1703 +2120 @@
             /* Skip space */
             psz = tstVDIoScriptSkipSpace(psz);
-            if (psz != '\0')
+            if (!tstVDIoIsLineEnd(psz))
             {
                 PCVDSCRIPTACTION pVDScriptAction = NULL;
@@ -1711 +2128 @@
 
                 psz = tstVDIoScriptSkipNonSpace(psz);
-                if (psz != '\0')
+                if (!tstVDIoIsLineEnd(psz))
                 {
                     Assert(RT_C_IS_SPACE(*psz));
@@ -1763 +2180 @@
                 }
             }
-            else
-            {
-                RTPrintf("Missing action name\n");
-                rc = VERR_INVALID_STATE;
-            }
+            /* else empty line, just continue */
         }
     } while(RT_SUCCESS(rc));
@@ -1794 +2207 @@
     memset(&GlobTest, 0, sizeof(VDTESTGLOB));
     RTListInit(&GlobTest.ListFiles);
+    RTListInit(&GlobTest.ListDisks);
 
     rc = RTStrmOpen(pcszFilename, "r", &pScriptStrm);
@@ -1833 +2247 @@
         if (RT_SUCCESS(rc))
         {
-            rc = VDCreate(GlobTest.pInterfacesDisk, VDTYPE_HDD, &GlobTest.pVD);
-            if (RT_SUCCESS(rc))
-            {
-                /* Execute the script. */
-                rc = tstVDIoScriptExecute(pScriptStrm, &GlobTest);
-                if (RT_FAILURE(rc))
-                {
-                    RTPrintf("Executing the script stream failed rc=%Rrc\n", rc);
-                }
-            }
-            else
-                RTPrintf("Failed to create disk container rc=%Rrc\n", rc);
+            /* Execute the script. */
+            rc = tstVDIoScriptExecute(pScriptStrm, &GlobTest);
+            if (RT_FAILURE(rc))
+            {
+                RTPrintf("Executing the script stream failed rc=%Rrc\n", rc);
+            }
             VDIoBackendMemDestroy(GlobTest.pIoBackend);
         }