Changeset 66672 in vbox for trunk/src/VBox/Runtime/common

Timestamp:

Apr 25, 2017 1:07:05 PM (8 years ago)

Author:

vboxsync

Message:

fatvfs: trunacting files

File:

• trunk/src/VBox/Runtime/common/filesystem/fatvfs.cpp (modified) (14 diffs)

trunk/src/VBox/Runtime/common/filesystem/fatvfs.cpp

@@ -68 +68 @@
 
 
+/** The number of entire in a chain part. */
+#define RTFSFATCHAINPART_ENTRIES (256U - 4U)
+
 /**
  * A part of the cluster chain covering up to 252 clusters.
@@ -76 +79 @@
     RTLISTNODE  ListEntry;
     /** Chain entries. */
-    uint32_t    aEntries[256 - 4];
+    uint32_t    aEntries[RTFSFATCHAINPART_ENTRIES];
 } RTFSFATCHAINPART;
 AssertCompile(sizeof(RTFSFATCHAINPART) <= _1K);
 typedef RTFSFATCHAINPART *PRTFSFATCHAINPART;
 typedef RTFSFATCHAINPART const *PCRTFSFATCHAINPART;
+
 
 /**
@@ -467 +471 @@
 {
     PRTFSFATCHAINPART pPart;
-    uint32_t idxLast = pChain->cClusters % RT_ELEMENTS(pPart->aEntries);
+    uint32_t idxLast = pChain->cClusters % RTFSFATCHAINPART_ENTRIES;
     if (idxLast != 0)
         pPart = RTListGetLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry);
@@ -500 +504 @@
     {
         PRTFSFATCHAINPART pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry);
-        while (idxCluster >= RT_ELEMENTS(pPart->aEntries))
+        while (idxCluster >= RTFSFATCHAINPART_ENTRIES)
         {
-            idxCluster -= RT_ELEMENTS(pPart->aEntries);
+            idxCluster -= RTFSFATCHAINPART_ENTRIES;
             pPart = RTListGetNext(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry);
         }
@@ -529 +533 @@
     for (;;)
     {
-        uint32_t const cInPart = RT_MIN(cLeft, RT_ELEMENTS(pPart->aEntries));
+        uint32_t const cInPart = RT_MIN(cLeft, RTFSFATCHAINPART_ENTRIES);
         for (uint32_t iPart = 0; iPart < cInPart; iPart++)
             if (pPart->aEntries[iPart] == idxNext)
@@ -543 +547 @@
 
 
+/**
+ * Gets a cluster array index.
+ *
+ * This works the chain thing as an indexed array.
+ *
+ * @returns The cluster number, UINT32_MAX if out of bounds.
+ * @param   pChain              The chain.
+ * @param   idx                 The index.
+ */
+static uint32_t rtFsFatChain_GetClusterByIndex(PCRTFSFATCHAIN pChain, uint32_t idx)
+{
+    if (idx < pChain->cClusters)
+    {
+        /*
+         * In the first part?
+         */
+        PRTFSFATCHAINPART pPart;
+        if (idx < RTFSFATCHAINPART_ENTRIES)
+        {
+            pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry);
+            return pPart->aEntries[idx];
+        }
+
+        /*
+         * In the last part?
+         */
+        uint32_t cParts    = (pChain->cClusters + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES;
+        uint32_t idxPart   = idx / RTFSFATCHAINPART_ENTRIES;
+        uint32_t idxInPart = idx % RTFSFATCHAINPART_ENTRIES;
+        if (idxPart + 1 == cParts)
+            pPart = RTListGetLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry);
+        else
+        {
+            /*
+             * No, do linear search from the start, skipping the first part.
+             */
+            pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry);
+            while (idxPart-- > 1)
+                pPart = RTListGetNext(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry);
+        }
+
+        return pPart->aEntries[idxInPart];
+    }
+    return UINT32_MAX;
+}
+
+#ifdef RT_STRICT
+/**
+ * Assert chain consistency.
+ */
+static bool rtFsFatChain_AssertValid(PCRTFSFATCHAIN pChain)
+{
+    bool                fRc = true;
+    uint32_t            cParts = 0;
+    PRTFSFATCHAINPART   pPart;
+    RTListForEach(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry)
+        cParts++;
+
+    uint32_t cExpected = (pChain->cClusters + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES;
+    AssertMsgStmt(cExpected == cParts, ("cExpected=%#x cParts=%#x\n", cExpected, cParts), fRc = false);
+    AssertMsgStmt(pChain->cbChain == (pChain->cClusters << pChain->cClusterByteShift),
+                  ("cExpected=%#x cParts=%#x\n", cExpected, cParts), fRc = false);
+    return fRc;
+}
+#endif /* RT_STRICT */
 
 /**
@@ -957 +1026 @@
 {
     AssertReturn(idxCluster >= FAT_FIRST_DATA_CLUSTER, VERR_VFS_BOGUS_OFFSET);
-    AssertReturn(idxCluster < pThis->cClusters, VERR_VFS_BOGUS_OFFSET);
+    AssertMsgReturn(idxCluster < pThis->cClusters, ("idxCluster=%#x cClusters=%#x\n", idxCluster, pThis->cClusters),
+                    VERR_VFS_BOGUS_OFFSET);
     switch (pThis->enmFatType)
     {
@@ -1230 +1300 @@
 static int rtFsFatObj_SetSize(PRTFSFATOBJ pObj, uint32_t cbFile)
 {
-    AssertReturn((pObj->cbObject >> pObj->Clusters.cClusterByteShift) == pObj->Clusters.cClusters, VERR_INTERNAL_ERROR_3);
+    AssertReturn(   ((pObj->cbObject + pObj->Clusters.cbCluster - 1) >> pObj->Clusters.cClusterByteShift)
+                 == pObj->Clusters.cClusters, VERR_INTERNAL_ERROR_3);
 
     /*
@@ -1242 +1313 @@
      * or release clusters.
      */
-    int rc;
+    int rc = VINF_SUCCESS;
     uint32_t const cClustersNew = (cbFile + pObj->Clusters.cbCluster - 1) >> pObj->Clusters.cClusterByteShift;
     AssertReturn(pObj->pParentDir, VERR_INTERNAL_ERROR_2);
@@ -1248 +1319 @@
     {
         pObj->cbObject = cbFile;
-        rc = VINF_SUCCESS;
     }
     else if (pObj->cbObject < cbFile)
@@ -1257 +1327 @@
     {
         /* Free clusters we don't need any more. */
-        rc = rtFsFatClusterMap_SetEndOfChain(pObj->pVol, rtFsFatChain_GetCluster(&pObj->Clusters, cClustersNew - 1));
+        if (cClustersNew > 0)
+            rc = rtFsFatClusterMap_SetEndOfChain(pObj->pVol, rtFsFatChain_GetClusterByIndex(&pObj->Clusters, cClustersNew - 1));
         if (RT_SUCCESS(rc))
         {
@@ -1263 +1334 @@
             while (iClusterToFree < pObj->Clusters.cClusters && RT_SUCCESS(rc))
             {
-                rc = rtFsFatClusterMap_FreeCluster(pObj->pVol, rtFsFatChain_GetCluster(&pObj->Clusters, iClusterToFree));
+                rc = rtFsFatClusterMap_FreeCluster(pObj->pVol, rtFsFatChain_GetClusterByIndex(&pObj->Clusters, iClusterToFree));
                 iClusterToFree++;
             }
 
             /* Update the chain structure. */
+            uint32_t cOldParts = (pObj->Clusters.cClusters + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES;
+            uint32_t cNewParts = (cClustersNew             + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES;
+            Assert(cOldParts >= cNewParts);
+            while (cOldParts-- > cNewParts)
+                RTMemFree(RTListRemoveLast(&pObj->Clusters.ListParts, RTFSFATCHAINPART, ListEntry));
             pObj->Clusters.cClusters = cClustersNew;
+            pObj->Clusters.cbChain   = pObj->Clusters.cClusters << pObj->Clusters.cClusterByteShift;
+            Assert(rtFsFatChain_AssertValid(&pObj->Clusters));
         }
     }
@@ -1282 +1360 @@
         {
             pDirEntry->cbFile = cbFile;
+            /** @todo figure out if setting the cluster to 0 is the right way to deal
+             *        with empty files... */
+            if (cClustersNew == 0)
+            {
+                pDirEntry->idxCluster = 0;
+                if (pObj->pVol->enmFatType >= RTFSFATTYPE_FAT32)
+                    pDirEntry->u.idxClusterHigh = 0;
+            }
             rc = rtFsFatDir_PutEntryAfterUpdate(pObj->pParentDir, pDirEntry, uWriteLock);
         }
@@ -2604 +2690 @@
     uint32_t const offJump      = 2 + pBootSector->abJmp[1];
     uint32_t const offFirstZero = 2 /*jmp */ + 3 * 2 /* words */ + 9 /* date string */;
-    Assert(offFirstZero >= RT_OFFSETOF(FATBOOTSECTOR, Bpb));
+    Assert(offFirstZero >= RT_UOFFSETOF(FATBOOTSECTOR, Bpb));
     uint32_t const cbZeroPad    = RT_MIN(offJump - offFirstZero,
                                          sizeof(pBootSector->Bpb.Bpb20) - (offFirstZero - RT_OFFSETOF(FATBOOTSECTOR, Bpb)));