Changeset 82595 in vbox for trunk/src

Timestamp:

Dec 16, 2019 5:58:40 PM (5 years ago)

Author:

vboxsync

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

135480

Message:

Storage/QCOW: Implement readonly support for compressed clusters in v2 images

File:

• trunk/src/VBox/Storage/QCOW.cpp (modified) (14 diffs)

trunk/src/VBox/Storage/QCOW.cpp

@@ -31 +31 @@
 #include <iprt/path.h>
 #include <iprt/list.h>
+#include <iprt/zip.h>
 
 #include "VDBackends.h"
@@ -250 +251 @@
     /** Cluster size in bytes. */
     uint32_t            cbCluster;
+    /** Number of bits in the virtual offset used as the cluster offset. */
+    uint32_t            cClusterBits;
+    /** Bitmask to extract the offset from a compressed cluster descriptor. */
+    uint64_t            fMaskCompressedClusterOffset;
+    /** Bitmask to extract the sector count from a compressed cluster descriptor. */
+    uint64_t            fMaskCompressedClusterSectors;
+    /** Number of bits to shift the sector count to the right to get the final value. */
+    uint32_t            cBitsShiftRCompressedClusterSectors;
     /** Number of entries in the L1 table. */
     uint32_t            cL1TableEntries;
@@ -287 +296 @@
     /** Number of bits to shift to get the L2 index. */
     uint32_t            cL2Shift;
+
+    /** Size of compressed cluster buffer. */
+    size_t              cbCompCluster;
+    /** Compressed cluster buffer. */
+    void                *pvCompCluster;
+    /** Buffer to hold the uncompressed data. */
+    void                *pvCluster;
 
     /** Pointer to the L2 table we are currently allocating
@@ -860 +876 @@
 static int qcowConvertToImageOffset(PQCOWIMAGE pImage, PVDIOCTX pIoCtx,
                                     uint32_t idxL1, uint32_t idxL2,
-                                    uint32_t offCluster, uint64_t *poffImage)
+                                    uint32_t offCluster, uint64_t *poffImage,
+                                    bool *pfCompressed, size_t *pcbCompressed)
 {
     int rc = VERR_VD_BLOCK_FREE;
@@ -886 +903 @@
                 {
                     if (RT_UNLIKELY(off & QCOW_V2_COMPRESSED_FLAG))
-                        rc = VERR_NOT_SUPPORTED;
+                    {
+                        size_t cCompressedClusterSectors = ((off & pImage->fMaskCompressedClusterSectors) >> pImage->cBitsShiftRCompressedClusterSectors);
+                        uint64_t offImage = off & pImage->fMaskCompressedClusterOffset;
+
+                        *pfCompressed  = true;
+                        *poffImage     = offImage;
+                        *pcbCompressed = (cCompressedClusterSectors + 1) * 512 - (offImage & 511ULL);
+                    }
                     else
+                    {
                         off &= QCOW_V2_TBL_OFFSET_MASK;
+
+                        *pfCompressed = false;
+                        *poffImage = off + offCluster;
+                    }
                 }
                 else
                 {
                     if (RT_UNLIKELY(off & QCOW_V1_COMPRESSED_FLAG))
-                        rc = VERR_NOT_SUPPORTED;
+                    {
+                        size_t cCompressedClusterSectors = (off & pImage->fMaskCompressedClusterSectors) >> pImage->cBitsShiftRCompressedClusterSectors;
+
+                        *pfCompressed  = true;
+                        *poffImage     = off & pImage->fMaskCompressedClusterOffset;
+                        *pcbCompressed = cCompressedClusterSectors * 512; /* Only additional sectors */
+                        /* Add remaining bytes of the sector the offset starts in. */
+                        *pcbCompressed += 512 - RT_ALIGN_64(*poffImage, 512) - *poffImage;
+                    }
                     else
+                    {
                         off &= ~QCOW_V1_COMPRESSED_FLAG;
+
+                        *pfCompressed = false;
+                        *poffImage = off + offCluster;
+                    }
                 }
-
-                *poffImage = off + offCluster;
             }
             else
@@ -1031 +1071 @@
             RTStrFree(pImage->pszBackingFilename);
             pImage->pszBackingFilename = NULL;
+        }
+
+        if (pImage->pvCompCluster)
+        {
+            RTMemFree(pImage->pvCompCluster);
+            pImage->pvCompCluster = NULL;
+            pImage->cbCompCluster = 0;
+        }
+
+        if (pImage->pvCluster)
+        {
+            RTMemFree(pImage->pvCluster);
+            pImage->pvCluster = NULL;
         }
 
@@ -1156 +1209 @@
                                 pImage->MTime              = Header.Version.v1.u32MTime;
                                 pImage->cbSize             = Header.Version.v1.u64Size;
+                                pImage->cClusterBits       = Header.Version.v1.u8ClusterBits;
                                 pImage->cbCluster          = RT_BIT_32(Header.Version.v1.u8ClusterBits);
                                 pImage->cL2TableEntries    = RT_BIT_32(Header.Version.v1.u8L2Bits);
@@ -1185 +1239 @@
                                 pImage->cbBackingFilename     = Header.Version.v2.u32BackingFileSize;
                                 pImage->cbSize                = Header.Version.v2.u64Size;
+                                pImage->cClusterBits          = Header.Version.v2.u32ClusterBits;
                                 pImage->cbCluster             = RT_BIT_32(Header.Version.v2.u32ClusterBits);
                                 pImage->cL2TableEntries       = pImage->cbCluster / sizeof(uint64_t);
@@ -1193 +1248 @@
                                 pImage->cbRefcountTable       = qcowCluster2Byte(pImage, Header.Version.v2.u32RefcountTableClusters);
                                 pImage->cRefcountTableEntries = pImage->cbRefcountTable / sizeof(uint64_t);
+
+                                /* Init the masks to extract offset and sector count from a compressed cluster descriptor. */
+                                uint32_t cBitsCompressedClusterOffset = 62 - (pImage->cClusterBits - 8);
+                                pImage->fMaskCompressedClusterOffset  = RT_BIT_64(cBitsCompressedClusterOffset) - 1;
+                                pImage->fMaskCompressedClusterSectors = (RT_BIT_64(62) - 1) & ~pImage->fMaskCompressedClusterOffset;
+                                pImage->cBitsShiftRCompressedClusterSectors = cBitsCompressedClusterOffset;
 
                                 if (Header.u32Version == 3)
@@ -1575 +1636 @@
 }
 
+/**
+ * Reads a compressed cluster, inflates it and copies the amount of data requested
+ * into the given I/O context.
+ *
+ * @returns VBox status code.
+ * @param   pImage              The image instance data.
+ * @param   pIoCtx              The I/O context.
+ * @param   offCluster          Where to start reading in the uncompressed cluster.
+ * @param   cbToRead            How much to read in the uncomrpessed cluster.
+ * @param   offFile             Offset where the compressed cluster is stored in the image.
+ * @param   cbCompressedCluster Size of the comrpessed cluster in bytes.
+ */
+static int qcowReadCompressedCluster(PQCOWIMAGE pImage, PVDIOCTX pIoCtx,
+                                     uint32_t offCluster, size_t cbToRead,
+                                     uint64_t offFile, size_t cbCompressedCluster)
+{
+    int rc = VINF_SUCCESS;
+
+    AssertReturn(!(pImage->uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO), VERR_NOT_SUPPORTED); /* Only synchronous I/O supported so far. */
+
+    if (cbCompressedCluster > pImage->cbCompCluster)
+    {
+        void *pvCompClusterNew = RTMemRealloc(pImage->pvCompCluster, cbCompressedCluster);
+        if (RT_LIKELY(pvCompClusterNew))
+        {
+            pImage->pvCompCluster = pvCompClusterNew;
+            pImage->cbCompCluster = cbCompressedCluster;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage,
+                                   offFile, pImage->pvCompCluster,
+                                   cbCompressedCluster, NULL,
+                                   NULL, NULL, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            if (!pImage->pvCluster)
+            {
+                pImage->pvCluster = RTMemAllocZ(pImage->cbCluster);
+                if (!pImage->pvCluster)
+                    rc = VERR_NO_MEMORY;
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                size_t cbDecomp = 0;
+
+                rc = RTZipBlockDecompress(RTZIPTYPE_ZLIB_NO_HEADER, 0 /*fFlags*/,
+                                          pImage->pvCompCluster, cbCompressedCluster, NULL,
+                                          pImage->pvCluster, pImage->cbCluster, &cbDecomp);
+                if (RT_SUCCESS(rc))
+                {
+                    Assert(cbDecomp == pImage->cbCluster);
+                    vdIfIoIntIoCtxCopyTo(pImage->pIfIo, pIoCtx,
+                                         (uint8_t *)pImage->pvCluster + offCluster,
+                                         cbToRead);
+                }
+            }
+        }
+    }
+
+    return rc;
+}
+
 /** @copydoc VDIMAGEBACKEND::pfnProbe */
 static DECLCALLBACK(int) qcowProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
@@ -1773 +1902 @@
 
 static DECLCALLBACK(int) qcowRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
-                    PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
+                                  PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
 {
     LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
@@ -1796 +1925 @@
 
     /* Get offset in image. */
-    rc = qcowConvertToImageOffset(pImage, pIoCtx, idxL1, idxL2, offCluster, &offFile);
+    bool fCompressedCluster = false;
+    size_t cbCompressedCluster = 0;
+    rc = qcowConvertToImageOffset(pImage, pIoCtx, idxL1, idxL2, offCluster,
+                                  &offFile, &fCompressedCluster, &cbCompressedCluster);
     if (RT_SUCCESS(rc))
-        rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, offFile,
-                                   pIoCtx, cbToRead);
+    {
+        if (!fCompressedCluster)
+            rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, offFile,
+                                       pIoCtx, cbToRead);
+        else
+            rc = qcowReadCompressedCluster(pImage, pIoCtx, offCluster, cbToRead, offFile, cbCompressedCluster);
+    }
 
     if (   (   RT_SUCCESS(rc)
@@ -1812 +1949 @@
 
 static DECLCALLBACK(int) qcowWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
-                     PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
-                     size_t *pcbPostRead, unsigned fWrite)
+                                   PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
+                                   size_t *pcbPostRead, unsigned fWrite)
 {
     LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
@@ -1840 +1977 @@
 
         /* Get offset in image. */
-        rc = qcowConvertToImageOffset(pImage, pIoCtx, idxL1, idxL2, offCluster, &offImage);
+        bool fCompressedCluster = false;
+        size_t cbCompressedCluster = 0;
+        rc = qcowConvertToImageOffset(pImage, pIoCtx, idxL1, idxL2, offCluster,
+                                      &offImage, &fCompressedCluster, &cbCompressedCluster);
         if (RT_SUCCESS(rc))
-            rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
-                                        offImage, pIoCtx, cbToWrite, NULL, NULL);
+        {
+            if (!fCompressedCluster)
+                rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
+                                            offImage, pIoCtx, cbToWrite, NULL, NULL);
+            else
+                rc = VERR_NOT_SUPPORTED; /** @todo Support writing compressed clusters */
+        }
         else if (rc == VERR_VD_BLOCK_FREE)
         {