Changeset 69609 in vbox for trunk/src/VBox/Runtime/common/dvm

Timestamp:

Nov 7, 2017 6:59:38 PM (7 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

118969

Message:

iprt/dvm: Some API adjusting to VFS - work in progress.

Location:

trunk/src/VBox/Runtime/common/dvm

Files:

• dvm.cpp (modified) (15 diffs)
• dvmbsdlabel.cpp (modified) (1 diff)
• dvmgpt.cpp (modified) (11 diffs)
• dvmvfs.cpp (modified) (4 diffs)

trunk/src/VBox/Runtime/common/dvm/dvm.cpp

@@ -101 +101 @@
  * Supported volume formats.
  */
-static PCRTDVMFMTOPS g_aDvmFmts[] =
+static PCRTDVMFMTOPS const g_aDvmFmts[] =
 {
     &g_rtDvmFmtMbr,
@@ -113 +113 @@
  * This is indexed by RTDVMVOLTYPE.
  */
-static const char * g_apcszDvmVolTypes[] =
+static const char * const g_apszDvmVolTypes[] =
 {
     "Invalid",
@@ -130 +130 @@
     "Solaris"
 };
+AssertCompile(RT_ELEMENTS(g_apszDvmVolTypes) == RTDVMVOLTYPE_END);
+
 
 /**
@@ -139 +141 @@
  * @param   phVol    Where to store the generic volume handle on success.
  */
-static int rtDvmVolumeCreate(PRTDVMINTERNAL pThis, RTDVMVOLUMEFMT hVolFmt,
-                             PRTDVMVOLUME phVol)
-{
-    int rc = VINF_SUCCESS;
-    PRTDVMVOLUMEINTERNAL pVol = NULL;
-
-    pVol = (PRTDVMVOLUMEINTERNAL)RTMemAllocZ(sizeof(RTDVMVOLUMEINTERNAL));
+static int rtDvmVolumeCreate(PRTDVMINTERNAL pThis, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUME phVol)
+{
+    PRTDVMVOLUMEINTERNAL pVol = (PRTDVMVOLUMEINTERNAL)RTMemAllocZ(sizeof(RTDVMVOLUMEINTERNAL));
     if (pVol)
     {
@@ -154 +152 @@
 
         *phVol = pVol;
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    return rc;
+        return VINF_SUCCESS;
+    }
+    return VERR_NO_MEMORY;
 }
 
@@ -184 +180 @@
 }
 
-RTDECL(int) RTDvmCreate(PRTDVM phVolMgr, PFNDVMREAD pfnRead,
-                        PFNDVMWRITE pfnWrite, uint64_t cbDisk,
-                        uint64_t cbSector, uint32_t fFlags, void *pvUser)
-{
-    int rc = VINF_SUCCESS;
-    PRTDVMINTERNAL pThis;
-
-    AssertMsgReturn(!(fFlags & ~DVM_FLAGS_MASK),
-                    ("Invalid flags given %#x\n", fFlags),
-                    VERR_INVALID_PARAMETER);
-
-    pThis = (PRTDVMINTERNAL)RTMemAllocZ(sizeof(RTDVMINTERNAL));
-    if (pThis)
-    {
-        pThis->u32Magic         = RTDVM_MAGIC;
-        pThis->DvmDisk.cbDisk   = cbDisk;
-        pThis->DvmDisk.cbSector = cbSector;
-        pThis->DvmDisk.pvUser   = pvUser;
-        pThis->DvmDisk.pfnRead  = pfnRead;
-        pThis->DvmDisk.pfnWrite = pfnWrite;
-        pThis->pDvmFmtOps       = NULL;
-        pThis->hVolMgrFmt       = NIL_RTDVMFMT;
-        pThis->fFlags           = fFlags;
-        pThis->cRefs            = 1;
-        RTListInit(&pThis->VolumeList);
-        *phVolMgr = pThis;
-    }
-    else
+
+RTDECL(int) RTDvmCreate(PRTDVM phVolMgr, RTVFSFILE hVfsFile, uint32_t cbSector, uint32_t fFlags)
+{
+    AssertMsgReturn(!(fFlags & ~DVM_FLAGS_VALID_MASK), ("Invalid flags given %#x\n", fFlags), VERR_INVALID_FLAGS);
+    uint32_t cRefs = RTVfsFileRetain(hVfsFile);
+    AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
+
+    uint64_t cbDisk;
+    int rc = RTVfsFileGetSize(hVfsFile, &cbDisk);
+    if (RT_SUCCESS(rc))
+    {
+        PRTDVMINTERNAL pThis = (PRTDVMINTERNAL)RTMemAllocZ(sizeof(RTDVMINTERNAL));
+        if (pThis)
+        {
+            pThis->u32Magic         = RTDVM_MAGIC;
+            pThis->DvmDisk.cbDisk   = cbDisk;
+            pThis->DvmDisk.cbSector = cbSector;
+            pThis->DvmDisk.hVfsFile = hVfsFile;
+
+            pThis->pDvmFmtOps       = NULL;
+            pThis->hVolMgrFmt       = NIL_RTDVMFMT;
+            pThis->fFlags           = fFlags;
+            pThis->cRefs            = 1;
+            RTListInit(&pThis->VolumeList);
+
+            *phVolMgr = pThis;
+            return VINF_SUCCESS;
+        }
         rc = VERR_NO_MEMORY;
-
+    }
+    RTVfsFileRelease(hVfsFile);
     return rc;
 }
+
 
 RTDECL(uint32_t) RTDvmRetain(RTDVM hVolMgr)
@@ -235 +233 @@
 static void rtDvmDestroy(PRTDVMINTERNAL pThis)
 {
+    pThis->u32Magic = RTDVM_MAGIC_DEAD;
+
     if (pThis->hVolMgrFmt != NIL_RTDVMFMT)
     {
@@ -242 +242 @@
         pThis->pDvmFmtOps->pfnClose(pThis->hVolMgrFmt);
         pThis->hVolMgrFmt = NIL_RTDVMFMT;
-    }
-
-    pThis->DvmDisk.cbDisk   = 0;
-    pThis->DvmDisk.pvUser   = NULL;
-    pThis->DvmDisk.pfnRead  = NULL;
-    pThis->DvmDisk.pfnWrite = NULL;
-    pThis->u32Magic         = RTDVM_MAGIC_DEAD;
+        pThis->pDvmFmtOps = NULL;
+    }
+
+    pThis->DvmDisk.cbDisk = 0;
+    pThis->DvmDisk.cbSector = 0;
+    if (pThis->DvmDisk.hVfsFile != NIL_RTVFSFILE)
+    {
+        RTVfsFileRelease(pThis->DvmDisk.hVfsFile);
+        pThis->DvmDisk.hVfsFile = NIL_RTVFSFILE;
+    }
     RTMemFree(pThis);
 }
@@ -269 +272 @@
 RTDECL(int) RTDvmMapOpen(RTDVM hVolMgr)
 {
-    int            rc = VINF_SUCCESS;
-    uint32_t       uScoreMax = RTDVM_MATCH_SCORE_UNSUPPORTED;
+    PRTDVMINTERNAL pThis = hVolMgr;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTDVM_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->hVolMgrFmt == NIL_RTDVMFMT, VERR_WRONG_ORDER);
+
+    Assert(!pThis->pDvmFmtOps);
+
+    /*
+     * Let each format backend have a go at the disk, pick the one which scores the highest.
+     */
+    int            rc              = VINF_SUCCESS;
+    uint32_t       uScoreMax       = RTDVM_MATCH_SCORE_UNSUPPORTED;
     PCRTDVMFMTOPS  pDvmFmtOpsMatch = NULL;
-    PRTDVMINTERNAL pThis = hVolMgr;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTDVM_MAGIC, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->hVolMgrFmt == NIL_RTDVMFMT, VERR_INVALID_HANDLE);
-
-    Assert(!pThis->pDvmFmtOps);
-
     for (unsigned i = 0; i < RT_ELEMENTS(g_aDvmFmts); i++)
     {
-        uint32_t uScore;
+        uint32_t uScore = 0;
         PCRTDVMFMTOPS pDvmFmtOps = g_aDvmFmts[i];
 
         rc = pDvmFmtOps->pfnProbe(&pThis->DvmDisk, &uScore);
-        if (   RT_SUCCESS(rc)
-            && uScore > uScoreMax)
+        if (RT_SUCCESS(rc))
         {
-            pDvmFmtOpsMatch = pDvmFmtOps;
-            uScoreMax       = uScore;
-        }
-        else if (RT_FAILURE(rc))
-            break;
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        if (uScoreMax > RTDVM_MATCH_SCORE_UNSUPPORTED)
-        {
-            AssertPtr(pDvmFmtOpsMatch);
-
-            /* Open the format. */
-            rc = pDvmFmtOpsMatch->pfnOpen(&pThis->DvmDisk, &pThis->hVolMgrFmt);
-            if (RT_SUCCESS(rc))
+            if (uScore > uScoreMax)
             {
-                uint32_t cVols;
-
-                pThis->pDvmFmtOps = pDvmFmtOpsMatch;
-
-                cVols = pThis->pDvmFmtOps->pfnGetValidVolumes(pThis->hVolMgrFmt);
-
-                /* Construct volume list. */
-                if (cVols)
-                {
-                    PRTDVMVOLUMEINTERNAL pVol = NULL;
-                    RTDVMVOLUMEFMT hVolFmt = NIL_RTDVMVOLUMEFMT;
-
-                    rc = pThis->pDvmFmtOps->pfnQueryFirstVolume(pThis->hVolMgrFmt, &hVolFmt);
-                    if (RT_SUCCESS(rc))
-                    {
-                        rc = rtDvmVolumeCreate(pThis, hVolFmt, &pVol);
-                        if (RT_FAILURE(rc))
-                            pThis->pDvmFmtOps->pfnVolumeClose(hVolFmt);
-                    }
-
-                    if (RT_SUCCESS(rc))
-                    {
-                        cVols--;
-                        RTListAppend(&pThis->VolumeList, &pVol->VolumeNode);
-
-                        while (   cVols > 0
-                               && RT_SUCCESS(rc))
-                        {
-                            rc = pThis->pDvmFmtOps->pfnQueryNextVolume(pThis->hVolMgrFmt, pVol->hVolFmt, &hVolFmt);
-                            if (RT_SUCCESS(rc))
-                            {
-                                rc = rtDvmVolumeCreate(pThis, hVolFmt, &pVol);
-                                if (RT_FAILURE(rc))
-                                    pThis->pDvmFmtOps->pfnVolumeClose(hVolFmt);
-                                else
-                                    RTListAppend(&pThis->VolumeList, &pVol->VolumeNode);
-                                cVols--;
-                            }
-                        }
-                    }
-
-                    if (RT_FAILURE(rc))
-                    {
-                        /* Remove all entries. */
-                        PRTDVMVOLUMEINTERNAL pItNext, pIt;
-                        RTListForEachSafe(&pThis->VolumeList, pIt, pItNext, RTDVMVOLUMEINTERNAL, VolumeNode)
-                        {
-                            RTListNodeRemove(&pIt->VolumeNode);
-                            rtDvmVolumeDestroy(pIt);
-                        }
-                    }
-                }
+                pDvmFmtOpsMatch = pDvmFmtOps;
+                uScoreMax       = uScore;
             }
         }
         else
-            rc = VERR_NOT_SUPPORTED;
-    }
-
+            return rc;
+    }
+    if (uScoreMax > RTDVM_MATCH_SCORE_UNSUPPORTED)
+    {
+        AssertPtr(pDvmFmtOpsMatch);
+
+        /*
+         * Open the format.
+         */
+        rc = pDvmFmtOpsMatch->pfnOpen(&pThis->DvmDisk, &pThis->hVolMgrFmt);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->pDvmFmtOps = pDvmFmtOpsMatch;
+
+            /*
+             * Construct volume list (we're done if none).
+             */
+            uint32_t cVols = pThis->pDvmFmtOps->pfnGetValidVolumes(pThis->hVolMgrFmt);
+            if (cVols == 0)
+                return VINF_SUCCESS;
+
+            /* First volume. */
+            RTDVMVOLUMEFMT hVolFmt = NIL_RTDVMVOLUMEFMT;
+            rc = pThis->pDvmFmtOps->pfnQueryFirstVolume(pThis->hVolMgrFmt, &hVolFmt);
+            if (RT_SUCCESS(rc))
+            {
+                for (;;)
+                {
+                    PRTDVMVOLUMEINTERNAL pVol = NULL;
+                    rc = rtDvmVolumeCreate(pThis, hVolFmt, &pVol);
+                    if (RT_FAILURE(rc))
+                    {
+                        pThis->pDvmFmtOps->pfnVolumeClose(hVolFmt);
+                        break;
+                    }
+                    RTListAppend(&pThis->VolumeList, &pVol->VolumeNode);
+
+                    /* Done?*/
+                    cVols--;
+                    if (cVols < 1)
+                        return VINF_SUCCESS;
+
+                    /* Next volume. */
+                    rc = pThis->pDvmFmtOps->pfnQueryNextVolume(pThis->hVolMgrFmt, pVol->hVolFmt, &hVolFmt);
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+
+                /* Bail out. */
+                PRTDVMVOLUMEINTERNAL pItNext, pIt;
+                RTListForEachSafe(&pThis->VolumeList, pIt, pItNext, RTDVMVOLUMEINTERNAL, VolumeNode)
+                {
+                    RTListNodeRemove(&pIt->VolumeNode);
+                    rtDvmVolumeDestroy(pIt);
+                }
+            }
+
+            /** @todo shouldn't we close the format too here?  */
+        }
+    }
+    else
+        rc = VERR_NOT_SUPPORTED;
     return rc;
 }
@@ -368 +367 @@
 RTDECL(int) RTDvmMapInitialize(RTDVM hVolMgr, const char *pszFmt)
 {
-    int rc = VERR_NOT_SUPPORTED;
     PRTDVMINTERNAL pThis = hVolMgr;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertPtrReturn(pszFmt, VERR_INVALID_POINTER);
     AssertReturn(pThis->u32Magic == RTDVM_MAGIC, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->hVolMgrFmt == NIL_RTDVMFMT, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->hVolMgrFmt == NIL_RTDVMFMT, VERR_WRONG_ORDER);
 
     for (unsigned i = 0; i < RT_ELEMENTS(g_aDvmFmts); i++)
     {
         PCRTDVMFMTOPS pDvmFmtOps = g_aDvmFmts[i];
-
         if (!RTStrCmp(pDvmFmtOps->pcszFmt, pszFmt))
         {
-            rc = pDvmFmtOps->pfnInitialize(&pThis->DvmDisk, &pThis->hVolMgrFmt);
+            int rc = pDvmFmtOps->pfnInitialize(&pThis->DvmDisk, &pThis->hVolMgrFmt);
             if (RT_SUCCESS(rc))
                 pThis->pDvmFmtOps = pDvmFmtOps;
-
-            break;
+            return rc;
         }
     }
-
-    return rc;
+    return VERR_NOT_SUPPORTED;
 }
 
@@ -444 +439 @@
 RTDECL(int) RTDvmMapQueryNextVolume(RTDVM hVolMgr, RTDVMVOLUME hVol, PRTDVMVOLUME phVolNext)
 {
-    int rc = VERR_DVM_MAP_NO_VOLUME;
     PRTDVMINTERNAL       pThis = hVolMgr;
     PRTDVMVOLUMEINTERNAL pVol = hVol;
@@ -454 +448 @@
     AssertPtrReturn(phVolNext, VERR_INVALID_POINTER);
 
-    PRTDVMVOLUMEINTERNAL pVolNext = RTListGetNext(&pThis->VolumeList, pVol,
-                                                  RTDVMVOLUMEINTERNAL, VolumeNode);
+    int rc = VERR_DVM_MAP_NO_VOLUME;
+    PRTDVMVOLUMEINTERNAL pVolNext = RTListGetNext(&pThis->VolumeList, pVol, RTDVMVOLUMEINTERNAL, VolumeNode);
     if (pVolNext)
     {
@@ -466 +460 @@
 }
 
-RTDECL(int) RTDvmMapQueryBlockStatus(RTDVM hVolMgr, uint64_t off, uint64_t cb,
-                                     bool *pfAllocated)
-{
-    int rc = VINF_SUCCESS;
-    PRTDVMINTERNAL       pThis = hVolMgr;
+RTDECL(int) RTDvmMapQueryBlockStatus(RTDVM hVolMgr, uint64_t off, uint64_t cb, bool *pfAllocated)
+{
+    PRTDVMINTERNAL pThis = hVolMgr;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertPtrReturn(pfAllocated, VERR_INVALID_POINTER);
     AssertReturn(pThis->u32Magic == RTDVM_MAGIC, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->hVolMgrFmt != NIL_RTDVMFMT, VERR_INVALID_HANDLE);
-    AssertReturn(off + cb <= pThis->DvmDisk.cbDisk * pThis->DvmDisk.cbSector,
-                 VERR_INVALID_PARAMETER);
+    AssertReturn(pThis->hVolMgrFmt != NIL_RTDVMFMT, VERR_WRONG_ORDER);
+    AssertMsgReturn(   off      <= pThis->DvmDisk.cbDisk
+                    || cb       <= pThis->DvmDisk.cbDisk
+                    || off + cb <= pThis->DvmDisk.cbDisk,
+                    ("off=%#RX64 cb=%#RX64 cbDisk=%#RX64\n", off, cb, pThis->DvmDisk.cbDisk),
+                    VERR_OUT_OF_RANGE);
 
     /* Check whether the range is inuse by the volume manager metadata first. */
-    rc = pThis->pDvmFmtOps->pfnQueryRangeUse(pThis->hVolMgrFmt, off, cb, pfAllocated);
+    int rc = pThis->pDvmFmtOps->pfnQueryRangeUse(pThis->hVolMgrFmt, off, cb, pfAllocated);
     if (RT_FAILURE(rc))
         return rc;
@@ -513 +508 @@
                     {
                         bool fVolAllocated = true;
-
-                        rc = pVol->pfnQueryBlockStatus(pVol->pvUser, offVol, cbIntersect,
-                                                       &fVolAllocated);
+                        rc = pVol->pfnQueryBlockStatus(pVol->pvUser, offVol, cbIntersect, &fVolAllocated);
                         if (RT_FAILURE(rc))
                             break;
-                        else if (fVolAllocated)
+                        if (fVolAllocated)
                         {
                             fAllocated = true;
@@ -657 +650 @@
     AssertReturn(enmVolType >= RTDVMVOLTYPE_INVALID && enmVolType < RTDVMVOLTYPE_END, NULL);
 
-    return g_apcszDvmVolTypes[enmVolType];
-}
+    return g_apszDvmVolTypes[enmVolType];
+}
+

trunk/src/VBox/Runtime/common/dvm/dvmbsdlabel.cpp

@@ -415 +415 @@
             if (pThis->DiskLabel.aPartitions[i].cSectors)
             {
-                rc = rtDvmFmtBsdLblVolumeCreate(pThis, &pThis->DiskLabel.aPartitions[i],
-                                              i, phVolFmt);
+                rc = rtDvmFmtBsdLblVolumeCreate(pThis, &pThis->DiskLabel.aPartitions[i], i, phVolFmt);
                 break;
             }

trunk/src/VBox/Runtime/common/dvm/dvmgpt.cpp

@@ -48 +48 @@
  * GPT on disk header.
  */
+typedef struct GPTHDR
+{
+    /** 0x00: Signature ("EFI PART"). */
+    char     abSignature[8];
+    /** 0x08: Revision. */
+    uint32_t u32Revision;
+    /** 0x0c: Header size. */
+    uint32_t cbHeader;
+    /** 0x10: CRC of header. */
+    uint32_t u32Crc;
+} GPTHDR;
+/** Pointer to a GPT header. */
+typedef struct GPTHDR *PGPTHDR;
+AssertCompileSize(GPTHDR, 20);
+
+/**
+ * Complete GPT table header for revision 1.0.
+ */
 #pragma pack(1)
-typedef struct GptHdr
-{
-    /** Signature ("EFI PART"). */
-    char     abSignature[8];
-    /** Revision. */
-    uint32_t u32Revision;
-    /** Header size. */
-    uint32_t cbHeader;
-    /** CRC of header. */
-    uint32_t u32Crc;
-} GptHdr;
-/** Pointer to a GPT header. */
-typedef struct GptHdr *PGptHdr;
+typedef struct GPTHDRREV1
+{
+    /** 0x00: Header. */
+    GPTHDR   Hdr;
+    /** 0x14: Reserved. */
+    uint32_t u32Reserved;
+    /** 0x18: Current LBA. */
+    uint64_t u64LbaCurrent;
+    /** 0x20: Backup LBA. */
+    uint64_t u64LbaBackup;
+    /** 0x28:First usable LBA for partitions. */
+    uint64_t u64LbaFirstPartition;
+    /** 0x30: Last usable LBA for partitions. */
+    uint64_t u64LbaLastPartition;
+    /** 0x38: Disk UUID. */
+    RTUUID   DiskUuid;
+    /** 0x48: LBA of first partition entry. */
+    uint64_t u64LbaPartitionEntries;
+    /** 0x50: Number of partition entries. */
+    uint32_t cPartitionEntries;
+    /** 0x54: Partition entry size. */
+    uint32_t cbPartitionEntry;
+    /** 0x58: CRC of partition entries. */
+    uint32_t u32CrcPartitionEntries;
+} GPTHDRREV1;
+/** Pointer to a revision 1.0 GPT header. */
+typedef GPTHDRREV1 *PGPTHDRREV1;
 #pragma pack()
-AssertCompileSize(GptHdr, 20);
-
-/**
- * Complete GPT table header for revision 1.0.
- */
-#pragma pack(1)
-typedef struct GptHdrRev1
-{
-    /** Header. */
-    GptHdr   Hdr;
-    /** Reserved. */
-    uint32_t u32Reserved;
-    /** Current LBA. */
-    uint64_t u64LbaCurrent;
-    /** Backup LBA. */
-    uint64_t u64LbaBackup;
-    /** First usable LBA for partitions. */
-    uint64_t u64LbaFirstPartition;
-    /** Last usable LBA for partitions. */
-    uint64_t u64LbaLastPartition;
-    /** Disk UUID. */
-    RTUUID   DiskUuid;
-    /** LBA of first partition entry. */
-    uint64_t u64LbaPartitionEntries;
-    /** Number of partition entries. */
-    uint32_t cPartitionEntries;
-    /** Partition entry size. */
-    uint32_t cbPartitionEntry;
-    /** CRC of partition entries. */
-    uint32_t u32CrcPartitionEntries;
-} GptHdrRev1;
-/** Pointer to a revision 1.0 GPT header. */
-typedef GptHdrRev1 *PGptHdrRev1;
-#pragma pack()
-AssertCompileSize(GptHdrRev1, 92);
+AssertCompileSize(GPTHDRREV1, 92);
 
 /**
  * GPT partition table entry.
  */
-#pragma pack(1)
-typedef struct GptEntry
-{
-    /** Partition type UUID. */
+typedef struct GPTENTRY
+{
+    /** 0x00: Partition type UUID. */
     RTUUID   UuidType;
-    /** Partition UUID. */
+    /** 0x10: Partition UUID. */
     RTUUID   UuidPartition;
-    /** First LBA. */
+    /** 0x20: First LBA. */
     uint64_t u64LbaFirst;
-    /** Last LBA. */
+    /** 0x28: Last LBA. */
     uint64_t u64LbaLast;
-    /** Attribute flags. */
+    /** 0x30: Attribute flags. */
     uint64_t u64Flags;
-    /** Partition name (UTF-16LE code units). */
+    /** 0x38: Partition name (UTF-16LE code units). */
     RTUTF16  aPartitionName[36];
-} GptEntry;
+} GPTENTRY;
 /** Pointer to a GPT entry. */
-typedef struct GptEntry *PGptEntry;
-#pragma pack()
-AssertCompileSize(GptEntry, 128);
+typedef struct GPTENTRY *PGPTENTRY;
+AssertCompileSize(GPTENTRY, 128);
 
 /** Partition flags - System partition. */
@@ -140 +136 @@
     PCRTDVMDISK     pDisk;
     /** GPT header. */
-    GptHdrRev1      HdrRev1;
+    GPTHDRREV1      HdrRev1;
     /** GPT array. */
-    PGptEntry       paGptEntries;
+    PGPTENTRY       paGptEntries;
     /** Number of occupied partition entries. */
     uint32_t        cPartitions;
@@ -163 +159 @@
     uint64_t          cbVolume;
     /** Pointer to the GPT entry in the array. */
-    PGptEntry         pGptEntry;
+    PGPTENTRY         pGptEntry;
 } RTDVMVOLUMEFMTINTERNAL;
 /** Pointer to an MBR volume. */
@@ -232 +228 @@
 {
     int rc = VINF_SUCCESS;
-    GptHdr Hdr;
+    GPTHDR Hdr;
 
     *puScore = RTDVM_MATCH_SCORE_UNSUPPORTED;
@@ -239 +235 @@
     {
         /* Read from the disk and check for the signature. */
-        rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &Hdr, sizeof(GptHdr));
+        rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &Hdr, sizeof(GPTHDR));
         if (   RT_SUCCESS(rc)
             && !strncmp(&Hdr.abSignature[0], RTDVM_GPT_SIGNATURE, RT_ELEMENTS(Hdr.abSignature))
             && RT_LE2H_U32(Hdr.u32Revision) == 0x00010000
-            && RT_LE2H_U32(Hdr.cbHeader)    == sizeof(GptHdrRev1))
+            && RT_LE2H_U32(Hdr.cbHeader)    == sizeof(GPTHDRREV1))
             *puScore = RTDVM_MATCH_SCORE_PERFECT;
     }
@@ -278 +274 @@
             pThis->HdrRev1.u32CrcPartitionEntries = RT_LE2H_U32(pThis->HdrRev1.u32CrcPartitionEntries);
 
-            if (pThis->HdrRev1.cbPartitionEntry == sizeof(GptEntry))
+            if (pThis->HdrRev1.cbPartitionEntry == sizeof(GPTENTRY))
             {
-                pThis->paGptEntries = (PGptEntry)RTMemAllocZ(pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry);
+                pThis->paGptEntries = (PGPTENTRY)RTMemAllocZ(pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry);
                 if (pThis->paGptEntries)
                 {
@@ -381 +377 @@
  * @param   phVolFmt      Where to store the volume data on success.
  */
-static int rtDvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, PGptEntry pGptEntry,
+static int rtDvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, PGPTENTRY pGptEntry,
                                  uint32_t idx, PRTDVMVOLUMEFMT phVolFmt)
 {
@@ -405 +401 @@
 static DECLCALLBACK(int) rtDvmFmtGptQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt)
 {
-    int rc = VINF_SUCCESS;
     PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
 
     if (pThis->cPartitions != 0)
     {
-        PGptEntry pGptEntry = &pThis->paGptEntries[0];
+        PGPTENTRY pGptEntry = &pThis->paGptEntries[0];
 
         /* Search for the first non empty entry. */
@@ -416 +411 @@
         {
             if (!RTUuidIsNull(&pGptEntry->UuidType))
-            {
-                rc = rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmt);
-                break;
-            }
+                return rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmt);
             pGptEntry++;
         }
+        AssertFailed();
     }
-    else
-        rc = VERR_DVM_MAP_EMPTY;
-
-    return rc;
+    return VERR_DVM_MAP_EMPTY;
 }
 
 static DECLCALLBACK(int) rtDvmFmtGptQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext)
 {
-    int rc = VERR_DVM_MAP_NO_VOLUME;
     PRTDVMFMTINTERNAL pThis = hVolMgrFmt;
     PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
-    PGptEntry pGptEntry = pVol->pGptEntry + 1;
+    PGPTENTRY pGptEntry = pVol->pGptEntry + 1;
 
     for (unsigned i = pVol->idxEntry + 1; i < pThis->HdrRev1.cPartitionEntries; i++)
     {
         if (!RTUuidIsNull(&pGptEntry->UuidType))
-        {
-            rc = rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmtNext);
-            break;
-        }
+            return rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmtNext);
         pGptEntry++;
     }
 
-    return rc;
+    return VERR_DVM_MAP_NO_VOLUME;
 }
 
@@ -471 +457 @@
 {
     PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
-    int rc = VINF_SUCCESS;
 
     *ppszVolName = NULL;
-    rc = RTUtf16ToUtf8Ex(&pVol->pGptEntry->aPartitionName[0], RT_ELEMENTS(pVol->pGptEntry->aPartitionName),
-                         ppszVolName, 0, NULL);
-
-    return rc;
+    return RTUtf16ToUtf8Ex(&pVol->pGptEntry->aPartitionName[0], RT_ELEMENTS(pVol->pGptEntry->aPartitionName),
+                           ppszVolName, 0, NULL);
 }
 
 static DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtGptVolumeGetType(RTDVMVOLUMEFMT hVolFmt)
 {
-    RTDVMVOLTYPE enmVolType = RTDVMVOLTYPE_UNKNOWN;
     PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
 
     for (unsigned i = 0; i < RT_ELEMENTS(g_aPartType2DvmVolTypes); i++)
         if (!RTUuidCompareStr(&pVol->pGptEntry->UuidType, g_aPartType2DvmVolTypes[i].pcszUuid))
-        {
-            enmVolType = g_aPartType2DvmVolTypes[i].enmVolType;
-            break;
-        }
-
-    return enmVolType;
+            return g_aPartType2DvmVolTypes[i].enmVolType;
+
+    return RTDVMVOLTYPE_UNKNOWN;
 }
 
@@ -506 +485 @@
                                                                uint64_t *pcbIntersect)
 {
-    bool fIntersect = false;
     PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt;
 
     if (RTDVM_RANGE_IS_INTERSECTING(pVol->offStart, pVol->cbVolume, offStart))
     {
-        fIntersect    = true;
         *poffVol      = offStart - pVol->offStart;
         *pcbIntersect = RT_MIN(cbRange, pVol->offStart + pVol->cbVolume - offStart);
+        return true;
     }
-
-    return fIntersect;
+    return false;
 }
 

trunk/src/VBox/Runtime/common/dvm/dvmvfs.cpp

@@ -29 +29 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
+#define LOG_GROUP RTLOGGROUP_FS /** @todo fix log group  */
 #include <iprt/types.h>
 #include <iprt/assert.h>
@@ -40 +41 @@
 #include <iprt/vfslowlevel.h>
 #include <iprt/poll.h>
+#include <iprt/log.h>
 #include "internal/dvm.h"
 
@@ -59 +61 @@
 /** Pointer to a the internal data of a DVM volume file. */
 typedef RTVFSDVMFILE *PRTVFSDVMFILE;
+
+/**
+ * A volume manager VFS for use in chains (thing pseudo/devfs).
+ */
+typedef struct RTDVMVFSVOL
+{
+    /** The volume manager. */
+    RTDVM       hVolMgr;
+    /** Whether to close it on success. */
+    bool        fCloseDvm;
+    /** Whether the access is read-only. */
+    bool        fReadOnly;
+    /** Number of volumes. */
+    uint32_t    cVolumes;
+} RTDVMVFSVOL;
+/** Poitner to a volume manager VFS. */
+typedef RTDVMVFSVOL *PRTDVMVFSVOL;
+
+/**
+ * The volume manager VFS root dir data.
+ */
+typedef struct RTDVMVFSROOTDIR
+{
+    /** Pointer to the VFS volume. */
+    PRTDVMVFSVOL    pVfsVol;
+    /** The current directory offset. */
+    uint32_t        offDir;
+} RTDVMVFSROOTDIR;
+/** Poitner to a volume manager VFS root dir. */
+typedef RTDVMVFSROOTDIR *PRTDVMVFSROOTDIR;
 
 
@@ -413 +445 @@
 }
 
+
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose}
+ */
+static DECLCALLBACK(int) rtDvmVfsVol_Close(void *pvThis)
+{
+    PRTDVMVFSVOL pThis = (PRTDVMVFSVOL)pvThis;
+    LogFlow(("rtDvmVfsVol_Close(%p)\n", pThis));
+
+    if (   pThis->fCloseDvm
+        && pThis->hVolMgr != NIL_RTDVM )
+        RTDvmRelease(pThis->hVolMgr);
+    pThis->hVolMgr = NIL_RTDVM;
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtDvmVfsVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    RT_NOREF(pvThis, pObjInfo, enmAddAttr);
+    return VERR_WRONG_TYPE;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOPS,pfnOpenRoot}
+ */
+static DECLCALLBACK(int) rtDvmVfsVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir)
+{
+    //PRTDVMVFSVOL pThis = (PRTDVMVFSVOL)pvThis;
+
+    //rtDvmDirShrd_Retain(pThis->pRootDir); /* consumed by the next call */
+    //return rtDvmDir_NewWithShared(pThis, pThis->pRootDir, phVfsDir);
+    RT_NOREF(pvThis, phVfsDir);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOPS,pfnIsRangeInUse}
+ */
+static DECLCALLBACK(int) rtDvmVfsVol_IsRangeInUse(void *pvThis, RTFOFF off, size_t cb, bool *pfUsed)
+{
+    RT_NOREF(pvThis, off, cb, pfUsed);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+DECL_HIDDEN_CONST(const RTVFSOPS) g_rtDvmVfsVolOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_VFS,
+        "DvmVol",
+        rtDvmVfsVol_Close,
+        rtDvmVfsVol_QueryInfo,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSOPS_VERSION,
+    0 /* fFeatures */,
+    rtDvmVfsVol_OpenRoot,
+    rtDvmVfsVol_IsRangeInUse,
+    RTVFSOPS_VERSION
+};
+
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
+ */
+static DECLCALLBACK(int) rtDvmVfsChain_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
+                                                PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
+{
+    RT_NOREF(pProviderReg, pSpec);
+
+    /*
+     * Basic checks.
+     */
+    if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE)
+        return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE;
+    if (pElement->enmType != RTVFSOBJTYPE_VFS)
+        return VERR_VFS_CHAIN_ONLY_VFS;
+
+    if (pElement->cArgs > 1)
+        return VERR_VFS_CHAIN_AT_MOST_ONE_ARG;
+
+    /*
+     * Parse the flag if present, save in pElement->uProvider.
+     */
+    /** @todo allow specifying sector size   */
+    bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ;
+    if (pElement->cArgs > 0)
+    {
+        const char *psz = pElement->paArgs[0].psz;
+        if (*psz)
+        {
+            if (   !strcmp(psz, "ro")
+                || !strcmp(psz, "r"))
+                fReadOnly = true;
+            else if (!strcmp(psz, "rw"))
+                fReadOnly = false;
+            else
+            {
+                *poffError = pElement->paArgs[0].offSpec;
+                return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument");
+            }
+        }
+    }
+
+    pElement->uProvider = fReadOnly;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
+ */
+static DECLCALLBACK(int) rtDvmVfsChain_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
+                                                   PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
+                                                   PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
+{
+    RT_NOREF(pProviderReg, pSpec, poffError, pErrInfo);
+    AssertReturn(hPrevVfsObj != NIL_RTVFSOBJ, VERR_VFS_CHAIN_IPE);
+
+    /*
+     * Instantiate the volume manager and open the map stuff.
+     */
+    RTVFSFILE hPrevVfsFile = RTVfsObjToFile(hPrevVfsObj);
+    AssertReturn(hPrevVfsFile != NIL_RTVFSFILE, VERR_VFS_CHAIN_CAST_FAILED);
+
+    RTDVM hVolMgr;
+    int rc = RTDvmCreate(&hVolMgr, hPrevVfsFile, 512, 0 /*fFlags*/);
+    RTVfsFileRelease(hPrevVfsFile);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTDvmMapOpen(hVolMgr);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Create a VFS instance for the volume manager.
+             */
+            RTVFS        hVfs  = NIL_RTVFS;
+            PRTDVMVFSVOL pThis = NULL;
+            int rc = RTVfsNew(&g_rtDvmVfsVolOps, sizeof(RTDVMVFSVOL), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis);
+            if (RT_SUCCESS(rc))
+            {
+                pThis->hVolMgr   = hVolMgr;
+                pThis->fCloseDvm = true;
+                pThis->fReadOnly = pElement->uProvider == (uint64_t)true;
+                pThis->cVolumes  = RTDvmMapGetValidVolumes(hVolMgr);
+
+                *phVfsObj = RTVfsObjFromVfs(hVfs);
+                RTVfsRelease(hVfs);
+                return *phVfsObj != NIL_RTVFSOBJ ? VINF_SUCCESS : VERR_VFS_CHAIN_CAST_FAILED;
+            }
+        }
+        else
+            rc = RTErrInfoSetF(pErrInfo, rc, "RTDvmMapOpen failed: %Rrc", rc);
+        RTDvmRelease(hVolMgr);
+    }
+    else
+        rc = RTErrInfoSetF(pErrInfo, rc, "RTDvmCreate failed: %Rrc", rc);
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
+ */
+static DECLCALLBACK(bool) rtDvmVfsChain_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
+                                                        PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
+                                                        PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
+{
+    RT_NOREF(pProviderReg, pSpec, pElement, pReuseSpec, pReuseElement);
+    return false;
+}
+
+
+/** VFS chain element 'file'. */
+static RTVFSCHAINELEMENTREG g_rtVfsChainIsoFsVolReg =
+{
+    /* uVersion = */            RTVFSCHAINELEMENTREG_VERSION,
+    /* fReserved = */           0,
+    /* pszName = */             "dvm",
+    /* ListEntry = */           { NULL, NULL },
+    /* pszHelp = */             "Opens a container image using the VD API.\n",
+    /* pfnValidate = */         rtDvmVfsChain_Validate,
+    /* pfnInstantiate = */      rtDvmVfsChain_Instantiate,
+    /* pfnCanReuseElement = */  rtDvmVfsChain_CanReuseElement,
+    /* uEndMarker = */          RTVFSCHAINELEMENTREG_VERSION
+};
+
+RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainIsoFsVolReg, rtVfsChainIsoFsVolReg);
+