Changeset 69595 in vbox

Timestamp:

Nov 6, 2017 12:48:25 PM (7 years ago)

Author:

vboxsync

Message:

fatvfs.cpp: Split dir and file structures into shared and handle specific parts, like the ifsvfs does.

File:

• trunk/src/VBox/Runtime/common/fs/fatvfs.cpp (modified) (94 diffs)

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

@@ -86 +86 @@
 *********************************************************************************************************************************/
 /** Pointer to a FAT directory instance. */
-typedef struct RTFSFATDIR *PRTFSFATDIR;
+typedef struct RTFSFATDIRSHRD *PRTFSFATDIRSHRD;
 
 
@@ -134 +134 @@
     /** The parent directory keeps a list of open objects (RTFSFATOBJ). */
     RTLISTNODE          Entry;
+    /** Reference counter.   */
+    uint32_t volatile   cRefs;
     /** The parent directory (not released till all children are close). */
-    PRTFSFATDIR         pParentDir;
+    PRTFSFATDIRSHRD     pParentDir;
     /** The byte offset of the directory entry in the parent dir.
      * This is set to UINT32_MAX for the root directory. */
@@ -160 +162 @@
 typedef RTFSFATOBJ *PRTFSFATOBJ;
 
-typedef struct RTFSFATFILE
+typedef struct RTFSFATFILESHRD
 {
     /** Core FAT object info.  */
     RTFSFATOBJ          Core;
+} RTFSFATFILESHRD;
+typedef RTFSFATFILESHRD *PRTFSFATFILESHRD;
+
+
+typedef struct RTFSFATFILE
+{
+    /** Pointer to the shared data. */
+    PRTFSFATFILESHRD    pShared;
     /** The current file offset. */
     uint32_t            offFile;
@@ -181 +191 @@
  * keeps a list of open children.
  */
-typedef struct RTFSFATDIR
+typedef struct RTFSFATDIRSHRD
 {
     /** Core FAT object info.  */
     RTFSFATOBJ          Core;
-    /** The VFS handle for this directory (for reference counting). */
-    RTVFSDIR            hVfsSelf;
     /** Open child objects (RTFSFATOBJ). */
     RTLISTNODE          OpenChildren;
@@ -220 +228 @@
             /** Number of dirty sectors. */
             uint32_t            cDirtySectors;
-            /** Dirty sector map. */
+            /** Dirty sector bitmap (one bit per sector). */
             uint8_t            *pbDirtySectors;
         } Full;
@@ -233 +241 @@
         } Simple;
     } u;
+} RTFSFATDIRSHRD;
+/** Pointer to a FAT directory instance. */
+typedef RTFSFATDIRSHRD *PRTFSFATDIRSHRD;
+
+
+/**
+ * FAT directory.
+ */
+typedef struct RTFSFATDIR
+{
+    /** Core FAT object info.  */
+    PRTFSFATDIRSHRD     pShared;
+    /** The current directory offset. */
+    uint32_t            offDir;
 } RTFSFATDIR;
 /** Pointer to a FAT directory instance. */
@@ -365 +387 @@
     /** The size of the root directory, rounded up to the nearest sector size. */
     uint32_t        cbRootDir;
-    /** The root directory handle. */
-    RTVFSDIR        hVfsRootDir;
     /** The root directory instance data. */
-    PRTFSFATDIR     pRootDir;
+    PRTFSFATDIRSHRD pRootDir;
 
     /** Serial number. */
@@ -431 +451 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static void rtFsFatDir_AddOpenChild(PRTFSFATDIR pDir, PRTFSFATOBJ pChild);
-static void rtFsFatDir_RemoveOpenChild(PRTFSFATDIR pDir, PRTFSFATOBJ pChild);
-static int  rtFsFatDir_GetEntryForUpdate(PRTFSFATDIR pThis, uint32_t offEntryInDir, PFATDIRENTRY *ppDirEntry, uint32_t *puWriteLock);
-static int  rtFsFatDir_PutEntryAfterUpdate(PRTFSFATDIR pThis, PFATDIRENTRY pDirEntry, uint32_t uWriteLock);
-static int  rtFsFatDir_Flush(PRTFSFATDIR pThis);
-static int  rtFsFatDir_New(PRTFSFATVOL pThis, PRTFSFATDIR pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
-                           uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTVFSDIR phVfsDir, PRTFSFATDIR *ppDir);
+static PRTFSFATOBJ rtFsFatDirShrd_LookupShared(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir);
+static void rtFsFatDirShrd_AddOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild);
+static void rtFsFatDirShrd_RemoveOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild);
+static int  rtFsFatDirShrd_GetEntryForUpdate(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir,
+                                             PFATDIRENTRY *ppDirEntry, uint32_t *puWriteLock);
+static int  rtFsFatDirShrd_PutEntryAfterUpdate(PRTFSFATDIRSHRD pThis, PFATDIRENTRY pDirEntry, uint32_t uWriteLock);
+static int  rtFsFatDirShrd_Flush(PRTFSFATDIRSHRD pThis);
+static int  rtFsFatDir_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
+                           uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTVFSDIR phVfsDir);
 
 
@@ -1457 +1479 @@
 {
     RTListInit(&pObj->Entry);
+    pObj->cRefs             = 1;
     pObj->pParentDir        = NULL;
     pObj->pVol              = pVol;
@@ -1485 +1508 @@
 {
     RTListInit(&pObj->Entry);
+    pObj->cRefs             = 1;
     pObj->pParentDir        = NULL;
     pObj->pVol              = pVol;
@@ -1515 +1539 @@
     if (pObj->fMaybeDirtyDirEnt)
     {
-        int rc2 = rtFsFatDir_Flush(pObj->pParentDir);
+        int rc2 = rtFsFatDirShrd_Flush(pObj->pParentDir);
         if (RT_SUCCESS(rc2))
             pObj->fMaybeDirtyDirEnt = false;
@@ -1535 +1559 @@
     int rc = rtFsFatObj_FlushMetaData(pObj);
     if (pObj->pParentDir)
-        rtFsFatDir_RemoveOpenChild(pObj->pParentDir, pObj);
+        rtFsFatDirShrd_RemoveOpenChild(pObj->pParentDir, pObj);
     rtFsFatChain_Delete(&pObj->Clusters);
     return rc;
@@ -1547 +1571 @@
 {
     PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
-    return rtFsFatObj_Close(&pThis->Core);
-}
-
-
-/**
- * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
- */
-static DECLCALLBACK(int) rtFsFatObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
-{
-    PRTFSFATOBJ pThis = (PRTFSFATOBJ)pvThis;
+    LogFlow(("rtFsFatFile_Close(%p/%p)\n", pThis, pThis->pShared));
+
+    PRTFSFATFILESHRD pShared = pThis->pShared;
+    pThis->pShared = NULL;
+
+    int rc = VINF_SUCCESS;
+    if (pShared)
+    {
+        if (ASMAtomicDecU32(&pShared->Core.cRefs) == 0)
+        {
+            LogFlow(("rtFsFatFile_Close: Destroying shared structure %p\n", pShared));
+            rc = rtFsFatObj_Close(&pShared->Core);
+            RTMemFree(pShared);
+        }
+        else
+            rc = rtFsFatObj_FlushMetaData(&pShared->Core);
+    }
+    return rc;
+}
+
+
+/**
+ * Worker for rtFsFatFile_QueryInfo and rtFsFatDir_QueryInfo
+ */
+static int rtFsFatObj_QueryInfo(PRTFSFATOBJ pThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    LogFlow(("rtFsFatObj_QueryInfo: %p fMode=%#x\n", pThis, pThis->fAttrib));
 
     pObjInfo->cbObject              = pThis->cbObject;
@@ -1599 +1640 @@
 
 /**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtFsFatFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
+    return rtFsFatObj_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr);
+}
+
+
+
+/**
  * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
  */
 static DECLCALLBACK(int) rtFsFatFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
 {
-    PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILE     pThis   = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILESHRD pShared = pThis->pShared;
     AssertReturn(pSgBuf->cSegs != 0, VERR_INTERNAL_ERROR_3);
     RT_NOREF(fBlocking);
@@ -1612 +1665 @@
     if (off == -1)
         off = pThis->offFile;
-    if ((uint64_t)off >= pThis->Core.cbObject)
+    if ((uint64_t)off >= pShared->Core.cbObject)
     {
         if (pcbRead)
@@ -1626 +1679 @@
      */
     int      rc         = VINF_SUCCESS;
-    uint32_t cbFileLeft = pThis->Core.cbObject - (uint32_t)off;
+    uint32_t cbFileLeft = pShared->Core.cbObject - (uint32_t)off;
     uint32_t cbRead     = 0;
     size_t   cbLeft     = pSgBuf->paSegs[0].cbSeg;
@@ -1634 +1687 @@
         if (cbFileLeft > 0)
         {
-            uint64_t offDisk = rtFsFatChain_FileOffsetToDiskOff(&pThis->Core.Clusters, (uint32_t)off, pThis->Core.pVol);
+            uint64_t offDisk = rtFsFatChain_FileOffsetToDiskOff(&pShared->Core.Clusters, (uint32_t)off, pShared->Core.pVol);
             if (offDisk != UINT64_MAX)
             {
-                uint32_t cbToRead = pThis->Core.Clusters.cbCluster - ((uint32_t)off & (pThis->Core.Clusters.cbCluster - 1));
+                uint32_t cbToRead = pShared->Core.Clusters.cbCluster - ((uint32_t)off & (pShared->Core.Clusters.cbCluster - 1));
                 if (cbToRead > cbLeft)
                     cbToRead = (uint32_t)cbLeft;
                 if (cbToRead > cbFileLeft)
                     cbToRead = cbFileLeft;
-                rc = RTVfsFileReadAt(pThis->Core.pVol->hVfsBacking, offDisk, pbDst, cbToRead, NULL);
+                rc = RTVfsFileReadAt(pShared->Core.pVol->hVfsBacking, offDisk, pbDst, cbToRead, NULL);
                 if (RT_SUCCESS(rc))
                 {
@@ -1737 +1790 @@
         uint32_t     uWriteLock;
         PFATDIRENTRY pDirEntry;
-        rc = rtFsFatDir_GetEntryForUpdate(pObj->pParentDir, pObj->offEntryInDir, &pDirEntry, &uWriteLock);
+        rc = rtFsFatDirShrd_GetEntryForUpdate(pObj->pParentDir, pObj->offEntryInDir, &pDirEntry, &uWriteLock);
         if (RT_SUCCESS(rc))
         {
@@ -1750 +1803 @@
                 pDirEntry->u.idxClusterHigh = (uint16_t)(idxFirstCluster >> 16);
 
-            rc = rtFsFatDir_PutEntryAfterUpdate(pObj->pParentDir, pDirEntry, uWriteLock);
+            rc = rtFsFatDirShrd_PutEntryAfterUpdate(pObj->pParentDir, pDirEntry, uWriteLock);
             pObj->fMaybeDirtyDirEnt = true;
         }
@@ -1763 +1816 @@
 static DECLCALLBACK(int) rtFsFatFile_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
 {
-    PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
-    PRTFSFATVOL  pVol  = pThis->Core.pVol;
+    PRTFSFATFILE     pThis   = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILESHRD pShared = pThis->pShared;
+    PRTFSFATVOL      pVol    = pShared->Core.pVol;
     AssertReturn(pSgBuf->cSegs != 0, VERR_INTERNAL_ERROR_3);
     RT_NOREF(fBlocking);
@@ -1784 +1838 @@
     {
         /* Figure out how much we can write.  Checking for max file size and such. */
-        uint32_t cbToWrite = pThis->Core.Clusters.cbCluster - ((uint32_t)off & (pThis->Core.Clusters.cbCluster - 1));
+        uint32_t cbToWrite = pShared->Core.Clusters.cbCluster - ((uint32_t)off & (pShared->Core.Clusters.cbCluster - 1));
         if (cbToWrite > cbLeft)
             cbToWrite = (uint32_t)cbLeft;
@@ -1799 +1853 @@
 
         /* Grow the file? */
-        if ((uint32_t)offNew > pThis->Core.cbObject)
-        {
-            rc = rtFsFatObj_SetSize(&pThis->Core, (uint32_t)offNew);
+        if ((uint32_t)offNew > pShared->Core.cbObject)
+        {
+            rc = rtFsFatObj_SetSize(&pShared->Core, (uint32_t)offNew);
             if (RT_SUCCESS(rc))
             { /* likely */}
@@ -1809 +1863 @@
 
         /* Figure the disk offset. */
-        uint64_t offDisk = rtFsFatChain_FileOffsetToDiskOff(&pThis->Core.Clusters, (uint32_t)off, pVol);
+        uint64_t offDisk = rtFsFatChain_FileOffsetToDiskOff(&pShared->Core.Clusters, (uint32_t)off, pVol);
         if (offDisk != UINT64_MAX)
         {
@@ -1843 +1897 @@
 static DECLCALLBACK(int) rtFsFatFile_Flush(void *pvThis)
 {
-    PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
-    int rc1 = rtFsFatObj_FlushMetaData(&pThis->Core);
-    int rc2 = RTVfsFileFlush(pThis->Core.pVol->hVfsBacking);
+    PRTFSFATFILE     pThis   = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILESHRD pShared = pThis->pShared;
+    int rc1 = rtFsFatObj_FlushMetaData(&pShared->Core);
+    int rc2 = RTVfsFileFlush(pShared->Core.pVol->hVfsBacking);
     return RT_FAILURE(rc1) ? rc1 : rc2;
 }
@@ -1939 +1994 @@
 static DECLCALLBACK(int) rtFsFatFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
 {
-    PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILE     pThis   = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILESHRD pShared = pThis->pShared;
+
     RTFOFF offNew;
     switch (uMethod)
@@ -1947 +2004 @@
             break;
         case RTFILE_SEEK_END:
-            offNew = (RTFOFF)pThis->Core.cbObject + offSeek;
+            offNew = (RTFOFF)pShared->Core.cbObject + offSeek;
             break;
         case RTFILE_SEEK_CURRENT:
@@ -1974 +2031 @@
 static DECLCALLBACK(int) rtFsFatFile_QuerySize(void *pvThis, uint64_t *pcbFile)
 {
-    PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis;
-    *pcbFile = pThis->Core.cbObject;
+    PRTFSFATFILE     pThis   = (PRTFSFATFILE)pvThis;
+    PRTFSFATFILESHRD pShared = pThis->pShared;
+    *pcbFile = pShared->Core.cbObject;
     return VINF_SUCCESS;
 }
@@ -1991 +2049 @@
             "FatFile",
             rtFsFatFile_Close,
-            rtFsFatObj_QueryInfo,
+            rtFsFatFile_QueryInfo,
             RTVFSOBJOPS_VERSION
         },
@@ -2033 +2091 @@
  * @param   phVfsFile       Where to return the file handle.
  */
-static int rtFsFatFile_New(PRTFSFATVOL pThis, PRTFSFATDIR pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
+static int rtFsFatFile_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
                            uint64_t fOpen, PRTVFSFILE phVfsFile)
 {
@@ -2044 +2102 @@
     if (RT_SUCCESS(rc))
     {
+        pNewFile->offFile = 0;
+        pNewFile->pShared = NULL;
+
         /*
-         * Initialize it all so rtFsFatFile_Close doesn't trip up in anyway.
+         * Look for existing shared object, create a new one if necessary.
          */
-        rtFsFatObj_InitFromDirEntry(&pNewFile->Core, pDirEntry, offEntryInDir, pThis);
-        pNewFile->offFile = 0;
-        rc = rtFsFatClusterMap_ReadClusterChain(pThis, RTFSFAT_GET_CLUSTER(pDirEntry, pThis), &pNewFile->Core.Clusters);
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * Link into parent directory so we can use it to update
-             * our directory entry.
-             */
-            rtFsFatDir_AddOpenChild(pParentDir, &pNewFile->Core);
-
-            /*
-             * Should we truncate the file or anything of that sort?
-             */
-            if (   (fOpen & RTFILE_O_TRUNCATE)
-                || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
-                rc = rtFsFatObj_SetSize(&pNewFile->Core, 0);
+        PRTFSFATFILESHRD pShared = (PRTFSFATFILESHRD)rtFsFatDirShrd_LookupShared(pParentDir, offEntryInDir);
+        if (pShared)
+        {
+            LogFlow(("rtFsFatFile_New: cbObject=%#RX32 \n", pShared->Core.cbObject));
+            pNewFile->pShared = pShared;
+            return VINF_SUCCESS;
+        }
+
+        pShared = (PRTFSFATFILESHRD)RTMemAllocZ(sizeof(*pShared));
+        if (pShared)
+        {
+            rtFsFatObj_InitFromDirEntry(&pShared->Core, pDirEntry, offEntryInDir, pThis);
+            pNewFile->pShared = pShared;
+
+            rc = rtFsFatClusterMap_ReadClusterChain(pThis, RTFSFAT_GET_CLUSTER(pDirEntry, pThis), &pShared->Core.Clusters);
             if (RT_SUCCESS(rc))
-                return VINF_SUCCESS;
-        }
-
+            {
+                /*
+                 * Link into parent directory so we can use it to update
+                 * our directory entry.
+                 */
+                rtFsFatDirShrd_AddOpenChild(pParentDir, &pShared->Core);
+
+                /*
+                 * Should we truncate the file or anything of that sort?
+                 */
+                if (   (fOpen & RTFILE_O_TRUNCATE)
+                    || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
+                    rc = rtFsFatObj_SetSize(&pShared->Core, 0);
+                if (RT_SUCCESS(rc))
+                {
+                    LogFlow(("rtFsFatFile_New: cbObject=%#RX32 pShared=%p\n", pShared->Core.cbObject, pShared));
+                    return VINF_SUCCESS;
+                }
+            }
+        }
+        else
+            rc = VERR_NO_MEMORY;
+
+        /* Destroy the file object. */
         RTVfsFileRelease(*phVfsFile);
     }
@@ -2075 +2155 @@
 
 
+/**
+ * Looks up the shared structure for a child.
+ *
+ * @returns Referenced pointer to the shared structure, NULL if not found.
+ * @param   pThis           The directory.
+ * @param   offEntryInDir   The directory record offset of the child.
+ */
+static PRTFSFATOBJ rtFsFatDirShrd_LookupShared(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir)
+{
+    PRTFSFATOBJ pCur;
+    RTListForEach(&pThis->OpenChildren, pCur, RTFSFATOBJ, Entry)
+    {
+        if (pCur->offEntryInDir == offEntryInDir)
+        {
+            uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs);
+            Assert(cRefs > 1); RT_NOREF(cRefs);
+            return pCur;
+        }
+    }
+    return NULL;
+}
 
 
@@ -2083 +2184 @@
  * @param   pThis           The directory.
  */
-static int rtFsFatDir_FlushFullyBuffered(PRTFSFATDIR pThis)
+static int rtFsFatDirShrd_FlushFullyBuffered(PRTFSFATDIRSHRD pThis)
 {
     Assert(pThis->fFullyBuffered);
@@ -2090 +2191 @@
     int             rc          = VINF_SUCCESS;
     for (uint32_t i = 0; i < pThis->u.Full.cSectors; i++)
-        if (pThis->u.Full.pbDirtySectors[i])
+        if (ASMBitTest(pThis->u.Full.pbDirtySectors, i))
         {
             int rc2 = RTVfsFileWriteAt(hVfsBacking, pThis->offEntriesOnDisk + i * cbSector,
                                        (uint8_t *)pThis->paEntries + i * cbSector, cbSector, NULL);
             if (RT_SUCCESS(rc2))
-                pThis->u.Full.pbDirtySectors[i] = false;
+                ASMBitClear(pThis->u.Full.pbDirtySectors, i);
             else if (RT_SUCCESS(rc))
                 rc = rc2;
@@ -2109 +2210 @@
  * @param   pThis           The directory.
  */
-static int rtFsFatDir_FlushSimple(PRTFSFATDIR pThis)
+static int rtFsFatDirShrd_FlushSimple(PRTFSFATDIRSHRD pThis)
 {
     Assert(!pThis->fFullyBuffered);
@@ -2134 +2235 @@
  * @param   pThis           The directory.
  */
-static int rtFsFatDir_Flush(PRTFSFATDIR pThis)
+static int rtFsFatDirShrd_Flush(PRTFSFATDIRSHRD pThis)
 {
     if (pThis->fFullyBuffered)
-        return rtFsFatDir_FlushFullyBuffered(pThis);
-    return rtFsFatDir_FlushSimple(pThis);
+        return rtFsFatDirShrd_FlushFullyBuffered(pThis);
+    return rtFsFatDirShrd_FlushSimple(pThis);
 }
 
@@ -2145 +2246 @@
  * Gets one or more entires at @a offEntryInDir.
  *
- * Common worker for rtFsFatDir_GetEntriesAt and rtFsFatDir_GetEntryForUpdate
+ * Common worker for rtFsFatDirShrd_GetEntriesAt and rtFsFatDirShrd_GetEntryForUpdate
  *
  * @returns IPRT status code.
@@ -2156 +2257 @@
  *                              @a *ppaEntries points to.
  * @param   puBufferReadLock    Where to return the buffer read lock handle.
- *                              Call rtFsFatDir_ReleaseBufferAfterReading when
+ *                              Call rtFsFatDirShrd_ReleaseBufferAfterReading when
  *                              done.
  */
-static int rtFsFatDir_GetEntriesAtCommon(PRTFSFATDIR pThis, uint32_t offEntryInDir, bool fForUpdate,
-                                         PFATDIRENTRYUNION *ppaEntries, uint32_t *pcEntries, uint32_t *puLock)
+static int rtFsFatDirShrd_GetEntriesAtCommon(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir, bool fForUpdate,
+                                             PFATDIRENTRYUNION *ppaEntries, uint32_t *pcEntries, uint32_t *puLock)
 {
     *puLock = UINT32_MAX;
@@ -2204 +2305 @@
                     rc = VINF_SUCCESS;
                 else
-                    rc = rtFsFatDir_FlushSimple(pThis);
+                    rc = rtFsFatDirShrd_FlushSimple(pThis);
                 if (RT_SUCCESS(rc))
                 {
@@ -2244 +2345 @@
  * @param   uWriteLock      The write lock.
  */
-static int rtFsFatDir_PutEntryAfterUpdate(PRTFSFATDIR pThis, PFATDIRENTRY pDirEntry, uint32_t uWriteLock)
+static int rtFsFatDirShrd_PutEntryAfterUpdate(PRTFSFATDIRSHRD pThis, PFATDIRENTRY pDirEntry, uint32_t uWriteLock)
 {
     Assert(uWriteLock == UINT32_C(0x80000001));
@@ -2251 +2352 @@
     {
         uint32_t idxSector = ((uintptr_t)pDirEntry - (uintptr_t)pThis->paEntries) / pThis->Core.pVol->cbSector;
-        pThis->u.Full.pbDirtySectors[idxSector] = true;
+        ASMBitSet(pThis->u.Full.pbDirtySectors, idxSector);
     }
     else
@@ -2262 +2363 @@
  * Gets the pointer to the given directory entry for the purpose of updating it.
  *
- * Call rtFsFatDir_PutEntryAfterUpdate afterwards.
+ * Call rtFsFatDirShrd_PutEntryAfterUpdate afterwards.
  *
  * @returns IPRT status code.
@@ -2271 +2372 @@
  * @param   puWriteLock     Where to return the write lock.
  */
-static int rtFsFatDir_GetEntryForUpdate(PRTFSFATDIR pThis, uint32_t offEntryInDir, PFATDIRENTRY *ppDirEntry,
-                                        uint32_t *puWriteLock)
+static int rtFsFatDirShrd_GetEntryForUpdate(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir, PFATDIRENTRY *ppDirEntry,
+                                            uint32_t *puWriteLock)
 {
     uint32_t cEntriesIgn;
-    return rtFsFatDir_GetEntriesAtCommon(pThis, offEntryInDir, true /*fForUpdate*/, (PFATDIRENTRYUNION *)ppDirEntry,
-                                         &cEntriesIgn, puWriteLock);
+    return rtFsFatDirShrd_GetEntriesAtCommon(pThis, offEntryInDir, true /*fForUpdate*/, (PFATDIRENTRYUNION *)ppDirEntry,
+                                             &cEntriesIgn, puWriteLock);
 }
 
@@ -2288 +2389 @@
  * @param   uBufferReadLock The buffer lock.
  */
-static void rtFsFatDir_ReleaseBufferAfterReading(PRTFSFATDIR pThis, uint32_t uBufferReadLock)
+static void rtFsFatDirShrd_ReleaseBufferAfterReading(PRTFSFATDIRSHRD pThis, uint32_t uBufferReadLock)
 {
     RT_NOREF(pThis, uBufferReadLock);
@@ -2306 +2407 @@
  *                              @a *ppaEntries points to.
  * @param   puBufferReadLock    Where to return the buffer read lock handle.
- *                              Call rtFsFatDir_ReleaseBufferAfterReading when
+ *                              Call rtFsFatDirShrd_ReleaseBufferAfterReading when
  *                              done.
  */
-static int rtFsFatDir_GetEntriesAt(PRTFSFATDIR pThis, uint32_t offEntryInDir,
-                                   PCFATDIRENTRYUNION *ppaEntries, uint32_t *pcEntries, uint32_t *puBufferReadLock)
-{
-    return rtFsFatDir_GetEntriesAtCommon(pThis, offEntryInDir, false /*fForUpdate*/, (PFATDIRENTRYUNION *)ppaEntries,
-                                         pcEntries, puBufferReadLock);
+static int rtFsFatDirShrd_GetEntriesAt(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir,
+                                       PCFATDIRENTRYUNION *ppaEntries, uint32_t *pcEntries, uint32_t *puBufferReadLock)
+{
+    return rtFsFatDirShrd_GetEntriesAtCommon(pThis, offEntryInDir, false /*fForUpdate*/, (PFATDIRENTRYUNION *)ppaEntries,
+                                             pcEntries, puBufferReadLock);
 }
 
@@ -2457 +2558 @@
  * @param   pDirEntry       Where to return a copy of the directory entry.
  */
-static int rtFsFatDir_FindEntry(PRTFSFATDIR pThis, const char *pszEntry, uint32_t *poffEntryInDir, bool *pfLong,
-                                PFATDIRENTRY pDirEntry)
+static int rtFsFatDirShrd_FindEntry(PRTFSFATDIRSHRD pThis, const char *pszEntry, uint32_t *poffEntryInDir, bool *pfLong,
+                                    PFATDIRENTRY pDirEntry)
 {
     /* Set return values. */
@@ -2489 +2590 @@
         uint32_t            cEntries    = 0;
         PCFATDIRENTRYUNION  paEntries   = NULL;
-        int rc = rtFsFatDir_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock);
+        int rc = rtFsFatDirShrd_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock);
         if (RT_FAILURE(rc))
             return rc;
@@ -2508 +2609 @@
                     if (pThis->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0)
                     {
-                        rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                        rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                         return VERR_FILE_NOT_FOUND;
                     }
@@ -2556 +2657 @@
                 *pDirEntry      = paEntries[iEntry].Entry;
                 *pfLong         = false;
-                rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                 return VINF_SUCCESS;
             }
@@ -2567 +2668 @@
                 *pDirEntry      = paEntries[iEntry].Entry;
                 *pfLong         = true;
-                rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                 return VINF_SUCCESS;
             }
@@ -2574 +2675 @@
         }
 
-        rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+        rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
     }
 
@@ -2582 +2683 @@
 
 /**
- * Watered down version of rtFsFatDir_FindEntry that is used by the short name
+ * Watered down version of rtFsFatDirShrd_FindEntry that is used by the short name
  * generator to check for duplicates.
  *
@@ -2591 +2692 @@
  * @param   pszEntry        The entry to look for.
  */
-static int rtFsFatDir_FindEntryShort(PRTFSFATDIR pThis, const char *pszName8Dot3)
+static int rtFsFatDirShrd_FindEntryShort(PRTFSFATDIRSHRD pThis, const char *pszName8Dot3)
 {
     Assert(strlen(pszName8Dot3) == 8+3);
@@ -2608 +2709 @@
         uint32_t            cEntries    = 0;
         PCFATDIRENTRYUNION  paEntries   = NULL;
-        int rc = rtFsFatDir_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock);
+        int rc = rtFsFatDirShrd_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock);
         if (RT_FAILURE(rc))
             return rc;
@@ -2626 +2727 @@
                     if (pThis->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0)
                     {
-                        rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                        rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                         return VERR_FILE_NOT_FOUND;
                     }
@@ -2646 +2747 @@
             else if (memcmp(paEntries[iEntry].Entry.achName, pszName8Dot3, sizeof(paEntries[iEntry].Entry.achName)) == 0)
             {
-                rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                 return VINF_SUCCESS;
             }
         }
 
-        rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+        rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
     }
 
@@ -2804 +2905 @@
 
 /**
- * Worker for rtFsFatDir_GenerateShortName.
+ * Worker for rtFsFatDirShrd_GenerateShortName.
  */
 static void rtFsFatDir_CopyShortName(char *pszDst, uint32_t cchDst, const char *pszSrc, size_t cchSrc, char chPad)
@@ -2857 +2958 @@
  * @param   pDirEntry       Where to put the short name.
  */
-static int rtFsFatDir_GenerateShortName(PRTFSFATDIR pThis, const char *pszEntry, PFATDIRENTRY pDirEntry)
+static int rtFsFatDirShrd_GenerateShortName(PRTFSFATDIRSHRD pThis, const char *pszEntry, PFATDIRENTRY pDirEntry)
 {
     /* Do some input parsing. */
@@ -2877 +2978 @@
     {
         szShortName[7] = iLastDigit + '0';
-        int rc = rtFsFatDir_FindEntryShort(pThis, szShortName);
+        int rc = rtFsFatDirShrd_FindEntryShort(pThis, szShortName);
         if (rc == VERR_FILE_NOT_FOUND)
         {
@@ -2896 +2997 @@
             szShortName[6] = iFirstDigit + '0';
             szShortName[7] = iLastDigit  + '0';
-            int rc = rtFsFatDir_FindEntryShort(pThis, szShortName);
+            int rc = rtFsFatDirShrd_FindEntryShort(pThis, szShortName);
             if (rc == VERR_FILE_NOT_FOUND)
             {
@@ -2920 +3021 @@
         szShortName[4] = szHex[cchHex - 4];
         szShortName[3] = szHex[cchHex - 5];
-        int rc = rtFsFatDir_FindEntryShort(pThis, szShortName);
+        int rc = rtFsFatDirShrd_FindEntryShort(pThis, szShortName);
         if (rc == VERR_FILE_NOT_FOUND)
         {
@@ -2949 +3050 @@
  * @param   pcSlots         Where to return the actual number of slots used.
  */
-static int rtFsFatDir_MaybeCreateLongNameAndShortAlias(PRTFSFATDIR pThis, const char *pszEntry, bool fIs8Dot3Name,
-                                                       PFATDIRENTRY pDirEntry, PFATDIRNAMESLOT paSlots, uint32_t *pcSlots)
+static int rtFsFatDirShrd_MaybeCreateLongNameAndShortAlias(PRTFSFATDIRSHRD pThis, const char *pszEntry, bool fIs8Dot3Name,
+                                                           PFATDIRENTRY pDirEntry, PFATDIRNAMESLOT paSlots, uint32_t *pcSlots)
 {
     RT_NOREF(pThis, pDirEntry, paSlots, pszEntry);
@@ -2979 +3080 @@
          */
         if (!fIs8Dot3Name)
-            rc = rtFsFatDir_GenerateShortName(pThis, pszEntry, pDirEntry);
+            rc = rtFsFatDirShrd_GenerateShortName(pThis, pszEntry, pDirEntry);
         if (RT_SUCCESS(rc))
         {
@@ -3035 +3136 @@
  *                          returned.
  */
-static int rtFsFatChain_FindFreeEntries(PRTFSFATDIR pThis, uint32_t cEntriesNeeded,
+static int rtFsFatChain_FindFreeEntries(PRTFSFATDIRSHRD pThis, uint32_t cEntriesNeeded,
                                         uint32_t *poffEntryInDir, uint32_t *pcFreeTail)
 {
@@ -3056 +3157 @@
         uint32_t            cEntries    = 0;
         PCFATDIRENTRYUNION  paEntries   = NULL;
-        int rc = rtFsFatDir_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock);
+        int rc = rtFsFatDirShrd_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock);
         if (RT_FAILURE(rc))
             return rc;
@@ -3080 +3181 @@
                     *pcFreeTail     = cEntriesNeeded;
                     *poffEntryInDir = offStartFreeEntries;
-                    rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                    rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                     return VINF_SUCCESS;
                 }
@@ -3088 +3189 @@
                     if (pThis->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0)
                     {
-                        rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                        rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                         *pcFreeTail = cFreeEntries = (cbDir - offStartFreeEntries) / sizeof(FATDIRENTRY);
                         if (cFreeEntries >= cEntriesNeeded)
                         {
                             *poffEntryInDir = offStartFreeEntries;
-                            rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+                            rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
                             return VINF_SUCCESS;
                         }
@@ -3106 +3207 @@
             }
         }
-        rtFsFatDir_ReleaseBufferAfterReading(pThis, uBufferLock);
+        rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock);
     }
     *pcFreeTail = cFreeEntries;
@@ -3123 +3224 @@
  * @param   cMinNewEntries  The minimum number of new entries to allocated.
  */
-static int rtFsFatChain_GrowDirectory(PRTFSFATDIR pThis, uint32_t cMinNewEntries)
+static int rtFsFatChain_GrowDirectory(PRTFSFATDIRSHRD pThis, uint32_t cMinNewEntries)
 {
     RT_NOREF(pThis, cMinNewEntries);
@@ -3140 +3241 @@
  * @param   poffEntryInDir  Where to return the directory offset.
  */
-static int rtFsFatChain_InsertEntries(PRTFSFATDIR pThis, PCFATDIRENTRY pDirEntry, PFATDIRNAMESLOT paSlots, uint32_t cSlots,
+static int rtFsFatChain_InsertEntries(PRTFSFATDIRSHRD pThis, PCFATDIRENTRY pDirEntry, PFATDIRNAMESLOT paSlots, uint32_t cSlots,
                                       uint32_t *poffEntryInDir)
 {
@@ -3179 +3280 @@
             uint32_t        uBufferLock;
             PFATDIRENTRY    pDstEntry;
-            rc = rtFsFatDir_GetEntryForUpdate(pThis, offCurrent, &pDstEntry, &uBufferLock);
+            rc = rtFsFatDirShrd_GetEntryForUpdate(pThis, offCurrent, &pDstEntry, &uBufferLock);
             if (RT_SUCCESS(rc))
             {
@@ -3186 +3287 @@
                 else
                     memcpy(pDstEntry, pDirEntry,          sizeof(*pDstEntry));
-                rc = rtFsFatDir_PutEntryAfterUpdate(pThis, pDstEntry, uBufferLock);
+                rc = rtFsFatDirShrd_PutEntryAfterUpdate(pThis, pDstEntry, uBufferLock);
                 if (RT_SUCCESS(rc))
                     continue;
@@ -3197 +3298 @@
             while (iSrcSlot-- > 0)
             {
-                int rc2 = rtFsFatDir_GetEntryForUpdate(pThis, offFirstInDir + iSrcSlot * sizeof(FATDIRENTRY),
+                int rc2 = rtFsFatDirShrd_GetEntryForUpdate(pThis, offFirstInDir + iSrcSlot * sizeof(FATDIRENTRY),
                                                        &pDstEntry, &uBufferLock);
                 if (RT_SUCCESS(rc2))
                 {
                     pDstEntry->achName[0] = FATDIRENTRY_CH0_DELETED;
-                    rtFsFatDir_PutEntryAfterUpdate(pThis, pDstEntry, uBufferLock);
+                    rtFsFatDirShrd_PutEntryAfterUpdate(pThis, pDstEntry, uBufferLock);
                 }
             }
@@ -3234 +3335 @@
  * @param   pDirEntry       Where to return a copy of the directory entry.
  *
- * @remarks ASSUMES caller has already called rtFsFatDir_FindEntry to make sure
+ * @remarks ASSUMES caller has already called rtFsFatDirShrd_FindEntry to make sure
  *          the entry doesn't exist.
  */
-static int rtFsFatDir_CreateEntry(PRTFSFATDIR pThis, const char *pszEntry, uint8_t fAttrib, uint32_t cbInitial,
-                                  uint32_t *poffEntryInDir, PFATDIRENTRY pDirEntry)
+static int rtFsFatDirShrd_CreateEntry(PRTFSFATDIRSHRD pThis, const char *pszEntry, uint8_t fAttrib, uint32_t cbInitial,
+                                      uint32_t *poffEntryInDir, PFATDIRENTRY pDirEntry)
 {
     PRTFSFATVOL pVol = pThis->Core.pVol;
@@ -3265 +3366 @@
     FATDIRNAMESLOT  aSlots[FATDIRNAMESLOT_MAX_SLOTS];
     AssertCompile(RTFSFAT_MAX_LFN_CHARS < RT_ELEMENTS(aSlots) * FATDIRNAMESLOT_CHARS_PER_SLOT);
-    int rc = rtFsFatDir_MaybeCreateLongNameAndShortAlias(pThis, pszEntry, fIs8Dot3Name, pDirEntry, aSlots, &cSlots);
+    int rc = rtFsFatDirShrd_MaybeCreateLongNameAndShortAlias(pThis, pszEntry, fIs8Dot3Name, pDirEntry, aSlots, &cSlots);
     if (RT_SUCCESS(rc))
     {
@@ -3308 +3409 @@
 
 
+/**
+ * Releases a reference to a shared directory structure.
+ *
+ * @param   pShared             The shared directory structure.
+ */
+static int rtFsFatDirShrd_Release(PRTFSFATDIRSHRD pShared)
+{
+    uint32_t cRefs = ASMAtomicDecU32(&pShared->Core.cRefs);
+    Assert(cRefs < UINT32_MAX / 2);
+    if (cRefs == 0)
+    {
+        LogFlow(("rtFsFatDirShrd_Release: Destroying shared structure %p\n", pShared));
+        Assert(pShared->Core.cRefs == 0);
+
+        int rc;
+        if (pShared->paEntries)
+        {
+            rc = rtFsFatDirShrd_Flush(pShared);
+            RTMemFree(pShared->paEntries);
+            pShared->paEntries = NULL;
+        }
+        else
+            rc = VINF_SUCCESS;
+
+        if (   pShared->fFullyBuffered
+            && pShared->u.Full.pbDirtySectors)
+        {
+            RTMemFree(pShared->u.Full.pbDirtySectors);
+            pShared->u.Full.pbDirtySectors = NULL;
+        }
+
+        int rc2 = rtFsFatObj_Close(&pShared->Core);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+
+        RTMemFree(pShared);
+        return rc;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Retains a reference to a shared directory structure.
+ *
+ * @param   pShared             The shared directory structure.
+ */
+static void rtFsFatDirShrd_Retain(PRTFSFATDIRSHRD pShared)
+{
+    uint32_t cRefs = ASMAtomicIncU32(&pShared->Core.cRefs);
+    Assert(cRefs > 1); NOREF(cRefs);
+}
+
 
 /**
@@ -3314 +3468 @@
 static DECLCALLBACK(int) rtFsFatDir_Close(void *pvThis)
 {
+    PRTFSFATDIR     pThis   = (PRTFSFATDIR)pvThis;
+    PRTFSFATDIRSHRD pShared = pThis->pShared;
+    pThis->pShared = NULL;
+    if (pShared)
+        return rtFsFatDirShrd_Release(pShared);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtFsFatDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
     PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis;
-    int rc;
-    if (pThis->paEntries)
-    {
-        rc = rtFsFatDir_Flush(pThis);
-        RTMemFree(pThis->paEntries);
-        pThis->paEntries = NULL;
-    }
-    else
-        rc = VINF_SUCCESS;
-
-    rtFsFatObj_Close(&pThis->Core);
-    return rc;
+    return rtFsFatObj_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr);
 }
 
@@ -3350 +3507 @@
         *phVfsDir = NIL_RTVFSDIR;
 
-        PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis;
-        uint32_t    offEntryInDir;
-        bool        fLong;
-        FATDIRENTRY DirEntry;
-        rc = rtFsFatDir_FindEntry(pThis, pszEntry, &offEntryInDir, &fLong, &DirEntry);
+        PRTFSFATDIR     pThis   = (PRTFSFATDIR)pvThis;
+        PRTFSFATDIRSHRD pShared = pThis->pShared;
+        uint32_t        offEntryInDir;
+        bool            fLong;
+        FATDIRENTRY     DirEntry;
+        rc = rtFsFatDirShrd_FindEntry(pShared, pszEntry, &offEntryInDir, &fLong, &DirEntry);
         if (RT_SUCCESS(rc))
         {
@@ -3361 +3519 @@
                 case FAT_ATTR_DIRECTORY:
                 {
-                    rc = rtFsFatDir_New(pThis->Core.pVol, pThis, &DirEntry, offEntryInDir,
-                                        RTFSFAT_GET_CLUSTER(&DirEntry, pThis->Core.pVol), UINT64_MAX /*offDisk*/,
-                                        DirEntry.cbFile, phVfsDir, NULL /*ppDir*/);
+                    rc = rtFsFatDir_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir,
+                                        RTFSFAT_GET_CLUSTER(&DirEntry, pShared->Core.pVol), UINT64_MAX /*offDisk*/,
+                                        DirEntry.cbFile, phVfsDir);
                     break;
                 }
@@ -3388 +3546 @@
 static DECLCALLBACK(int) rtFsFatDir_OpenFile(void *pvThis, const char *pszFilename, uint32_t fOpen, PRTVFSFILE phVfsFile)
 {
-    PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis;
+    PRTFSFATDIR     pThis   = (PRTFSFATDIR)pvThis;
+    PRTFSFATDIRSHRD pShared = pThis->pShared;
 
     /*
@@ -3396 +3555 @@
     bool        fLong;
     FATDIRENTRY DirEntry;
-    int rc = rtFsFatDir_FindEntry(pThis, pszFilename, &offEntryInDir, &fLong, &DirEntry);
+    int rc = rtFsFatDirShrd_FindEntry(pShared, pszFilename, &offEntryInDir, &fLong, &DirEntry);
     if (RT_SUCCESS(rc))
     {
@@ -3408 +3567 @@
                         || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
                         || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
-                        rc = rtFsFatFile_New(pThis->Core.pVol, pThis, &DirEntry, offEntryInDir, fOpen, phVfsFile);
+                        rc = rtFsFatFile_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir, fOpen, phVfsFile);
                     else
                         rc = VERR_ALREADY_EXISTS;
@@ -3432 +3591 @@
                  || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE) )
     {
-        rc = rtFsFatDir_CreateEntry(pThis, pszFilename, FAT_ATTR_ARCHIVE, 0 /*cbInitial*/, &offEntryInDir, &DirEntry);
+        rc = rtFsFatDirShrd_CreateEntry(pShared, pszFilename, FAT_ATTR_ARCHIVE, 0 /*cbInitial*/, &offEntryInDir, &DirEntry);
         if (RT_SUCCESS(rc))
-            rc = rtFsFatFile_New(pThis->Core.pVol, pThis, &DirEntry, offEntryInDir, fOpen, phVfsFile);
+            rc = rtFsFatFile_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir, fOpen, phVfsFile);
     }
     return rc;
@@ -3494 +3653 @@
      * Try locate the entry.
      */
-    PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis;
-    uint32_t    offEntryInDir;
-    bool        fLong;
-    FATDIRENTRY DirEntry;
-    int rc = rtFsFatDir_FindEntry(pThis, pszEntry, &offEntryInDir, &fLong, &DirEntry);
+    PRTFSFATDIR     pThis   = (PRTFSFATDIR)pvThis;
+    PRTFSFATDIRSHRD pShared = pThis->pShared;
+    uint32_t        offEntryInDir;
+    bool            fLong;
+    FATDIRENTRY     DirEntry;
+    int rc = rtFsFatDirShrd_FindEntry(pShared, pszEntry, &offEntryInDir, &fLong, &DirEntry);
     Log2(("rtFsFatDir_QueryEntryInfo: FindEntry(,%s,) -> %Rrc\n", pszEntry, rc));
     if (RT_SUCCESS(rc))
@@ -3508 +3668 @@
         RTFSFATOBJ TmpObj;
         RT_ZERO(TmpObj);
-        rtFsFatObj_InitFromDirEntry(&TmpObj, &DirEntry, offEntryInDir, pThis->Core.pVol);
+        rtFsFatObj_InitFromDirEntry(&TmpObj, &DirEntry, offEntryInDir, pShared->Core.pVol);
         rc = rtFsFatObj_QueryInfo(&TmpObj, pObjInfo, enmAddAttr);
     }
@@ -3570 +3730 @@
         "FatDir",
         rtFsFatDir_Close,
-        rtFsFatObj_QueryInfo,
+        rtFsFatDir_QueryInfo,
         RTVFSOBJOPS_VERSION
     },
@@ -3598 +3758 @@
 
 
+
+
 /**
  * Adds an open child to the parent directory.
@@ -3607 +3769 @@
  * @param   pDir        The directory.
  * @param   pChild      The child being opened.
- * @sa      rtFsFatDir_RemoveOpenChild
- */
-static void rtFsFatDir_AddOpenChild(PRTFSFATDIR pDir, PRTFSFATOBJ pChild)
-{
-    /* First child that gets opened retains the parent directory.  This is
-       released by the final open child. */
-    if (RTListIsEmpty(&pDir->OpenChildren))
-    {
-        uint32_t cRefs = RTVfsDirRetain(pDir->hVfsSelf);
-        Assert(cRefs != UINT32_MAX); NOREF(cRefs);
-
-        /* Root also retains the whole file system. */
-        if (pDir->Core.pVol->pRootDir == pDir)
-        {
-            Assert(pDir->Core.pVol);
-            Assert(pDir->Core.pVol == pChild->pVol);
-            cRefs = RTVfsRetain(pDir->Core.pVol->hVfsSelf);
-            Assert(cRefs != UINT32_MAX); NOREF(cRefs);
-        }
-    }
+ * @sa      rtFsFatDirShrd_RemoveOpenChild
+ */
+static void rtFsFatDirShrd_AddOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild)
+{
+    rtFsFatDirShrd_Retain(pDir);
+
     RTListAppend(&pDir->OpenChildren, &pChild->Entry);
     pChild->pParentDir = pDir;
@@ -3641 +3789 @@
  *          objects to be released recursively (parent dir and the volume).
  *
- * @sa      rtFsFatDir_AddOpenChild
- */
-static void rtFsFatDir_RemoveOpenChild(PRTFSFATDIR pDir, PRTFSFATOBJ pChild)
+ * @sa      rtFsFatDirShrd_AddOpenChild
+ */
+static void rtFsFatDirShrd_RemoveOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild)
 {
     AssertReturnVoid(pChild->pParentDir == pDir);
@@ -3649 +3797 @@
     pChild->pParentDir = NULL;
 
-    /* Final child? If so, release directory. */
-    if (RTListIsEmpty(&pDir->OpenChildren))
-    {
-        bool const fIsRootDir = pDir->Core.pVol->pRootDir == pDir;
-
-        uint32_t cRefs = RTVfsDirRelease(pDir->hVfsSelf);
-        Assert(cRefs != UINT32_MAX); NOREF(cRefs);
-
-        /* Root directory releases the file system as well.  Since the volume
-           holds a reference to the root directory, it will remain valid after
-           the above release. */
-        if (fIsRootDir)
-        {
-            Assert(cRefs > 0);
-            Assert(pDir->Core.pVol);
-            Assert(pDir->Core.pVol == pChild->pVol);
-            cRefs = RTVfsRelease(pDir->Core.pVol->hVfsSelf);
-            Assert(cRefs != UINT32_MAX); NOREF(cRefs);
-        }
-    }
-}
-
-
-/**
- * Instantiates a new directory.
+    rtFsFatDirShrd_Release(pDir);
+}
+
+
+/**
+ * Instantiates a new shared directory instance.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The FAT volume instance.
+ * @param   pParentDir      The parent directory.  This is NULL for the root
+ *                          directory.
+ * @param   pDirEntry       The parent directory entry. This is NULL for the
+ *                          root directory.
+ * @param   offEntryInDir   The byte offset of the directory entry in the parent
+ *                          directory.  UINT32_MAX if root directory.
+ * @param   idxCluster      The cluster where the directory content is to be
+ *                          found. This can be UINT32_MAX if a root FAT12/16
+ *                          directory.
+ * @param   offDisk         The disk byte offset of the FAT12/16 root directory.
+ *                          This is UINT64_MAX if idxCluster is given.
+ * @param   cbDir           The size of the directory.
+ * @param   ppSharedDir     Where to return shared FAT directory instance.
+ */
+static int rtFsFatDirShrd_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
+                              uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTFSFATDIRSHRD *ppSharedDir)
+{
+    Assert((idxCluster == UINT32_MAX) != (offDisk == UINT64_MAX));
+    Assert((pDirEntry == NULL) == (offEntryInDir == UINT32_MAX));
+    *ppSharedDir = NULL;
+
+    int rc = VERR_NO_MEMORY;
+    PRTFSFATDIRSHRD pShared = (PRTFSFATDIRSHRD)RTMemAllocZ(sizeof(*pShared));
+    if (pShared)
+    {
+        /*
+         * Initialize it all so rtFsFatDir_Close doesn't trip up in anyway.
+         */
+        RTListInit(&pShared->OpenChildren);
+        if (pDirEntry)
+            rtFsFatObj_InitFromDirEntry(&pShared->Core, pDirEntry, offEntryInDir, pThis);
+        else
+            rtFsFatObj_InitDummy(&pShared->Core, cbDir, RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | RTFS_UNIX_ALL_PERMS, pThis);
+
+        pShared->cEntries           = cbDir / sizeof(FATDIRENTRY);
+        pShared->fIsLinearRootDir   = idxCluster == UINT32_MAX;
+        pShared->fFullyBuffered     = pShared->fIsLinearRootDir;
+        pShared->paEntries          = NULL;
+        pShared->offEntriesOnDisk   = UINT64_MAX;
+        if (pShared->fFullyBuffered)
+            pShared->cbAllocatedForEntries = RT_ALIGN_32(cbDir, pThis->cbSector);
+        else
+            pShared->cbAllocatedForEntries = pThis->cbSector;
+
+        /*
+         * If clustered backing, read the chain and see if we cannot still do the full buffering.
+         */
+        if (idxCluster != UINT32_MAX)
+        {
+            rc = rtFsFatClusterMap_ReadClusterChain(pThis, idxCluster, &pShared->Core.Clusters);
+            if (RT_SUCCESS(rc))
+            {
+                if (   pShared->Core.Clusters.cClusters >= 1
+                    && pShared->Core.Clusters.cbChain   <= _64K
+                    && rtFsFatChain_IsContiguous(&pShared->Core.Clusters))
+                {
+                    Assert(pShared->Core.Clusters.cbChain >= cbDir);
+                    pShared->cbAllocatedForEntries = pShared->Core.Clusters.cbChain;
+                    pShared->fFullyBuffered = true;
+                }
+            }
+        }
+        else
+        {
+            rtFsFatChain_InitEmpty(&pShared->Core.Clusters, pThis);
+            rc = VINF_SUCCESS;
+        }
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Allocate and initialize the buffering.  Fill the buffer.
+             */
+            pShared->paEntries = (PFATDIRENTRYUNION)RTMemAlloc(pShared->cbAllocatedForEntries);
+            if (!pShared->paEntries)
+            {
+                if (pShared->fFullyBuffered && !pShared->fIsLinearRootDir)
+                {
+                    pShared->fFullyBuffered = false;
+                    pShared->cbAllocatedForEntries = pThis->cbSector;
+                    pShared->paEntries = (PFATDIRENTRYUNION)RTMemAlloc(pShared->cbAllocatedForEntries);
+                }
+                if (!pShared->paEntries)
+                    rc = VERR_NO_MEMORY;
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                if (pShared->fFullyBuffered)
+                {
+                    pShared->u.Full.cDirtySectors   = 0;
+                    pShared->u.Full.cSectors        = pShared->cbAllocatedForEntries / pThis->cbSector;
+                    pShared->u.Full.pbDirtySectors  = (uint8_t *)RTMemAllocZ((pShared->u.Full.cSectors + 63) / 8);
+                    if (pShared->u.Full.pbDirtySectors)
+                        pShared->offEntriesOnDisk   = offDisk != UINT64_MAX ? offDisk
+                                                    : rtFsFatClusterToDiskOffset(pThis, idxCluster);
+                    else
+                        rc = VERR_NO_MEMORY;
+                }
+                else
+                {
+                    pShared->offEntriesOnDisk       = rtFsFatClusterToDiskOffset(pThis, idxCluster);
+                    pShared->u.Simple.offInDir      = 0;
+                    pShared->u.Simple.fDirty        = false;
+                }
+                if (RT_SUCCESS(rc))
+                    rc = RTVfsFileReadAt(pThis->hVfsBacking, pShared->offEntriesOnDisk,
+                                         pShared->paEntries, pShared->cbAllocatedForEntries, NULL);
+                if (RT_SUCCESS(rc))
+                {
+                    /*
+                     * Link into parent directory so we can use it to update
+                     * our directory entry.
+                     */
+                    if (pParentDir)
+                        rtFsFatDirShrd_AddOpenChild(pParentDir, &pShared->Core);
+                    *ppSharedDir = pShared;
+                    return VINF_SUCCESS;
+                }
+            }
+
+            /* Free the buffer on failure so rtFsFatDir_Close doesn't try do anything with it. */
+            RTMemFree(pShared->paEntries);
+            pShared->paEntries = NULL;
+        }
+
+        Assert(pShared->Core.cRefs == 1);
+        rtFsFatDirShrd_Release(pShared);
+    }
+    return rc;
+}
+
+
+/**
+ * Instantiates a new directory with a shared structure presupplied.
+ *
+ * @returns IPRT status code.
+ * @param   pThis           The FAT volume instance.
+ * @param   pShared         Referenced pointer to the shared structure.  The
+ *                          reference is always CONSUMED.
+ * @param   phVfsDir        Where to return the directory handle.
+ */
+static int rtFsFatDir_NewWithShared(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pShared, PRTVFSDIR phVfsDir)
+{
+    /*
+     * Create VFS object around the shared structure.
+     */
+    PRTFSFATDIR pNewDir;
+    int rc = RTVfsNewDir(&g_rtFsFatDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf,
+                         NIL_RTVFSLOCK /*use volume lock*/, phVfsDir, (void **)&pNewDir);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Look for existing shared object, create a new one if necessary.
+         * We CONSUME a reference to pShared here.
+         */
+        pNewDir->offDir  = 0;
+        pNewDir->pShared = pShared;
+        return VINF_SUCCESS;
+    }
+
+    rtFsFatDirShrd_Release(pShared);
+    *phVfsDir = NIL_RTVFSDIR;
+    return rc;
+}
+
+
+
+/**
+ * Instantiates a new directory VFS, creating the shared structure as necessary.
  *
  * @returns IPRT status code.
@@ -3690 +3991 @@
  * @param   cbDir           The size of the directory.
  * @param   phVfsDir        Where to return the directory handle.
- * @param   ppDir           Where to return the FAT directory instance data.
- */
-static int rtFsFatDir_New(PRTFSFATVOL pThis, PRTFSFATDIR pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
-                          uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTVFSDIR phVfsDir, PRTFSFATDIR *ppDir)
-{
-    Assert((idxCluster == UINT32_MAX) != (offDisk == UINT64_MAX));
-    Assert((pDirEntry == NULL) == (offEntryInDir == UINT32_MAX));
-    if (ppDir)
-        *ppDir = NULL;
-
-    PRTFSFATDIR pNewDir;
-    int rc = RTVfsNewDir(&g_rtFsFatDirOps, sizeof(*pNewDir), pParentDir ? 0 : RTVFSDIR_F_NO_VFS_REF,
-                         pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/, phVfsDir, (void **)&pNewDir);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Initialize it all so rtFsFatDir_Close doesn't trip up in anyway.
-         */
-        RTListInit(&pNewDir->OpenChildren);
-        if (pDirEntry)
-            rtFsFatObj_InitFromDirEntry(&pNewDir->Core, pDirEntry, offEntryInDir, pThis);
-        else
-            rtFsFatObj_InitDummy(&pNewDir->Core, cbDir, RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | RTFS_UNIX_ALL_PERMS, pThis);
-
-        pNewDir->hVfsSelf           = *phVfsDir;
-        pNewDir->cEntries           = cbDir / sizeof(FATDIRENTRY);
-        pNewDir->fIsLinearRootDir   = idxCluster == UINT32_MAX;
-        pNewDir->fFullyBuffered     = pNewDir->fIsLinearRootDir;
-        pNewDir->paEntries          = NULL;
-        pNewDir->offEntriesOnDisk   = UINT64_MAX;
-        if (pNewDir->fFullyBuffered)
-            pNewDir->cbAllocatedForEntries = RT_ALIGN_32(cbDir, pThis->cbSector);
-        else
-            pNewDir->cbAllocatedForEntries = pThis->cbSector;
-
-        /*
-         * If clustered backing, read the chain and see if we cannot still do the full buffering.
-         */
-        if (idxCluster != UINT32_MAX)
-        {
-            rc = rtFsFatClusterMap_ReadClusterChain(pThis, idxCluster, &pNewDir->Core.Clusters);
-            if (RT_SUCCESS(rc))
-            {
-                if (   pNewDir->Core.Clusters.cClusters >= 1
-                    && pNewDir->Core.Clusters.cbChain   <= _64K
-                    && rtFsFatChain_IsContiguous(&pNewDir->Core.Clusters))
-                {
-                    Assert(pNewDir->Core.Clusters.cbChain >= cbDir);
-                    pNewDir->cbAllocatedForEntries = pNewDir->Core.Clusters.cbChain;
-                    pNewDir->fFullyBuffered = true;
-                }
-            }
-        }
-        else
-            rtFsFatChain_InitEmpty(&pNewDir->Core.Clusters, pThis);
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * Allocate and initialize the buffering.  Fill the buffer.
-             */
-            pNewDir->paEntries = (PFATDIRENTRYUNION)RTMemAlloc(pNewDir->cbAllocatedForEntries);
-            if (!pNewDir->paEntries)
-            {
-                if (pNewDir->fFullyBuffered && !pNewDir->fIsLinearRootDir)
-                {
-                    pNewDir->fFullyBuffered = false;
-                    pNewDir->cbAllocatedForEntries = pThis->cbSector;
-                    pNewDir->paEntries = (PFATDIRENTRYUNION)RTMemAlloc(pNewDir->cbAllocatedForEntries);
-                }
-                if (!pNewDir->paEntries)
-                    rc = VERR_NO_MEMORY;
-            }
-
-            if (RT_SUCCESS(rc))
-            {
-                if (pNewDir->fFullyBuffered)
-                {
-                    pNewDir->u.Full.cDirtySectors   = 0;
-                    pNewDir->u.Full.cSectors        = pNewDir->cbAllocatedForEntries / pThis->cbSector;
-                    pNewDir->u.Full.pbDirtySectors  = (uint8_t *)RTMemAllocZ((pNewDir->u.Full.cSectors + 63) / 8);
-                    if (pNewDir->u.Full.pbDirtySectors)
-                        pNewDir->offEntriesOnDisk   = offDisk != UINT64_MAX ? offDisk
-                                                    : rtFsFatClusterToDiskOffset(pThis, idxCluster);
-                    else
-                        rc = VERR_NO_MEMORY;
-                }
-                else
-                {
-                    pNewDir->offEntriesOnDisk       = rtFsFatClusterToDiskOffset(pThis, idxCluster);
-                    pNewDir->u.Simple.offInDir      = 0;
-                    pNewDir->u.Simple.fDirty        = false;
-                }
-                if (RT_SUCCESS(rc))
-                    rc = RTVfsFileReadAt(pThis->hVfsBacking, pNewDir->offEntriesOnDisk,
-                                         pNewDir->paEntries, pNewDir->cbAllocatedForEntries, NULL);
-                if (RT_SUCCESS(rc))
-                {
-                    /*
-                     * Link into parent directory so we can use it to update
-                     * our directory entry.
-                     */
-                    if (pParentDir)
-                        rtFsFatDir_AddOpenChild(pParentDir, &pNewDir->Core);
-                    if (ppDir)
-                        *ppDir = pNewDir;
-                    return VINF_SUCCESS;
-                }
-            }
-
-            /* Free the buffer on failure so rtFsFatDir_Close doesn't try do anything with it. */
-            RTMemFree(pNewDir->paEntries);
-            pNewDir->paEntries = NULL;
-        }
-
-        RTVfsDirRelease(*phVfsDir);
-    }
-    *phVfsDir = NIL_RTVFSDIR;
-    if (ppDir)
-        *ppDir = NULL;
-    return rc;
+ */
+static int  rtFsFatDir_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir,
+                           uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTVFSDIR phVfsDir)
+{
+    /*
+     * Look for existing shared object, create a new one if necessary.
+     */
+    PRTFSFATDIRSHRD pShared = (PRTFSFATDIRSHRD)rtFsFatDirShrd_LookupShared(pParentDir, offEntryInDir);
+    if (!pShared)
+    {
+        int rc = rtFsFatDirShrd_New(pThis, pParentDir, pDirEntry, offEntryInDir, idxCluster, offDisk, cbDir, &pShared);
+        if (RT_FAILURE(rc))
+        {
+            *phVfsDir = NIL_RTVFSDIR;
+            return rc;
+        }
+    }
+    return rtFsFatDir_NewWithShared(pThis, pShared, phVfsDir);
 }
 
@@ -3823 +4022 @@
     PRTFSFATVOL pThis = (PRTFSFATVOL)pvThis;
     LogFlow(("rtFsFatVol_Close(%p)\n", pThis));
-    int rc = rtFsFatClusterMap_Destroy(pThis);
-
-    if (pThis->hVfsRootDir != NIL_RTVFSDIR)
+
+    int rc = VINF_SUCCESS;
+    if (pThis->pRootDir != NULL)
     {
         Assert(RTListIsEmpty(&pThis->pRootDir->OpenChildren));
-        uint32_t cRefs = RTVfsDirRelease(pThis->hVfsRootDir);
-        Assert(cRefs == 0); NOREF(cRefs);
-        pThis->hVfsRootDir = NIL_RTVFSDIR;
-        pThis->pRootDir    = NULL;
-    }
+        Assert(pThis->pRootDir->Core.cRefs == 1);
+        rc = rtFsFatDirShrd_Release(pThis->pRootDir);
+        pThis->pRootDir = NULL;
+    }
+
+    int rc2 = rtFsFatClusterMap_Destroy(pThis);
+    if (RT_SUCCESS(rc))
+        rc = rc2;
 
     RTVfsFileRelease(pThis->hVfsBacking);
@@ -3852 +4054 @@
 
 /**
- * @interface_method_impl{RTVFSOPS,pfnOpenRoo}
+ * @interface_method_impl{RTVFSOPS,pfnOpenRoot}
  */
 static DECLCALLBACK(int) rtFsFatVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir)
 {
     PRTFSFATVOL pThis = (PRTFSFATVOL)pvThis;
-    uint32_t cRefs = RTVfsDirRetain(pThis->hVfsRootDir);
-    if (cRefs != UINT32_MAX)
-    {
-        *phVfsDir = pThis->hVfsRootDir;
-        return VINF_SUCCESS;
-    }
-    return VERR_INTERNAL_ERROR_5;
+
+    rtFsFatDirShrd_Retain(pThis->pRootDir); /* consumed by the next call */
+    return rtFsFatDir_NewWithShared(pThis, pThis->pRootDir, phVfsDir);
 }
 
@@ -4485 +4683 @@
     pThis->cRootDirEntries      = UINT32_MAX;
     pThis->cbRootDir            = 0;
-    pThis->hVfsRootDir          = NIL_RTVFSDIR;
     pThis->pRootDir             = NULL;
 
@@ -4558 +4755 @@
      */
     if (pThis->idxRootDirCluster == UINT32_MAX)
-        rc = rtFsFatDir_New(pThis, NULL /*pParentDir*/, NULL /*pDirEntry*/, UINT32_MAX /*offEntryInDir*/,
-                            UINT32_MAX, pThis->offRootDir, pThis->cbRootDir,
-                            &pThis->hVfsRootDir, &pThis->pRootDir);
+        rc = rtFsFatDirShrd_New(pThis, NULL /*pParentDir*/, NULL /*pDirEntry*/, UINT32_MAX /*offEntryInDir*/,
+                                UINT32_MAX, pThis->offRootDir, pThis->cbRootDir, &pThis->pRootDir);
     else
-        rc = rtFsFatDir_New(pThis, NULL /*pParentDir*/, NULL /*pDirEntry*/, UINT32_MAX /*offEntryInDir*/,
-                            pThis->idxRootDirCluster, UINT64_MAX, pThis->cbRootDir,
-                            &pThis->hVfsRootDir, &pThis->pRootDir);
+        rc = rtFsFatDirShrd_New(pThis, NULL /*pParentDir*/, NULL /*pDirEntry*/, UINT32_MAX /*offEntryInDir*/,
+                                pThis->idxRootDirCluster, UINT64_MAX, pThis->cbRootDir, &pThis->pRootDir);
     return rc;
 }