Changeset 34029 in vbox

Timestamp:

Nov 12, 2010 2:21:59 PM (14 years ago)

Author:

vboxsync

Message:

iprt/vfs/tar: more code.

Location:

trunk

Files:

• include/iprt/vfslowlevel.h (modified) (6 diffs)
• src/VBox/Runtime/common/vfs/vfsbase.cpp (modified) (21 diffs)
• src/VBox/Runtime/common/vfs/vfsstdfile.cpp (modified) (1 diff)
• src/VBox/Runtime/common/zip/tar.h (modified) (1 diff)
• src/VBox/Runtime/common/zip/tarvfs.cpp (modified) (10 diffs)

trunk/include/iprt/vfslowlevel.h

@@ -40 +40 @@
  */
 
+
+/** @name VFS Lock Abstraction
+ * @todo This should be moved somewhere else as it is of general use.
+ * @{ */
+
+/**
+ * VFS lock types.
+ */
+typedef enum RTVFSLOCKTYPE
+{
+    /** Invalid lock type. */
+    RTVFSLOCKTYPE_INVALID = 0,
+    /** Read write semaphore. */
+    RTVFSLOCKTYPE_RW,
+    /** Fast mutex semaphore (critical section in ring-3). */
+    RTVFSLOCKTYPE_FASTMUTEX,
+    /** Full fledged mutex semaphore. */
+    RTVFSLOCKTYPE_MUTEX,
+    /** The end of valid lock types. */
+    RTVFSLOCKTYPE_END,
+    /** The customary 32-bit type hack. */
+    RTVFSLOCKTYPE_32BIT_HACK = 0x7fffffff
+} RTVFSLOCKTYPE;
+
+/** VFS lock handle. */
+typedef struct RTVFSLOCKINTERNAL   *RTVFSLOCK;
+/** Pointer to a VFS lock handle. */
+typedef RTVFSLOCK                  *PRTVFSLOCK;
+/** Nil VFS lock handle. */
+#define NIL_RTVFSLOCK               ((RTVFSLOCK)~(uintptr_t)0)
+
+/** Special handle value for creating a new read/write semaphore based lock. */
+#define RTVFSLOCK_CREATE_RW         ((RTVFSLOCK)~(uintptr_t)1)
+/** Special handle value for creating a new fast mutex semaphore based lock. */
+#define RTVFSLOCK_CREATE_FASTMUTEX  ((RTVFSLOCK)~(uintptr_t)2)
+/** Special handle value for creating a new mutex semaphore based lock. */
+#define RTVFSLOCK_CREATE_MUTEX      ((RTVFSLOCK)~(uintptr_t)3)
+
+/**
+ * Retains a reference to the VFS lock handle.
+ *
+ * @returns New reference count on success, UINT32_MAX on failure.
+ * @param   hLock           The VFS lock handle.
+ */
+RTDECL(uint32_t) RTVfsLockRetain(RTVFSLOCK hLock);
+
+/**
+ * Releases a reference to the VFS lock handle.
+ *
+ * @returns New reference count on success (0 if closed), UINT32_MAX on failure.
+ * @param   hLock           The VFS lock handle.
+ */
+RTDECL(uint32_t) RTVfsLockRelease(RTVFSLOCK hLock);
+
+/**
+ * Gets the lock type.
+ *
+ * @returns The lock type on success, RTVFSLOCKTYPE_INVALID if the handle is
+ *          not valid.
+ * @param   hLock               The lock handle.
+ */
+RTDECL(RTVFSLOCKTYPE) RTVfsLockGetType(RTVFSLOCK hLock);
+
+
+
+RTDECL(void) RTVfsLockAcquireReadSlow(RTVFSLOCK hLock);
+RTDECL(void) RTVfsLockReleaseReadSlow(RTVFSLOCK hLock);
+RTDECL(void) RTVfsLockAcquireWriteSlow(RTVFSLOCK hLock);
+RTDECL(void) RTVfsLockReleaseWriteSlow(RTVFSLOCK hLock);
+/** @}  */
+
+/**
+ * Acquire a read lock.
+ *
+ * @param   hLock               The lock handle, can be NIL.
+ */
+DECLINLINE(void) RTVfsLockAcquireRead(RTVFSLOCK hLock)
+{
+    if (hLock != NIL_RTVFSLOCK)
+        RTVfsLockAcquireReadSlow(hLock);
+}
+
+
+/**
+ * Release a read lock.
+ *
+ * @param   hLock               The lock handle, can be NIL.
+ */
+DECLINLINE(void) RTVfsLockReleaseRead(RTVFSLOCK hLock)
+{
+    if (hLock != NIL_RTVFSLOCK)
+        RTVfsLockReleaseReadSlow(hLock);
+}
+
+
+/**
+ * Acquire a write lock.
+ *
+ * @param   hLock               The lock handle, can be NIL.
+ */
+DECLINLINE(void) RTVfsLockAcquireWrite(RTVFSLOCK hLock)
+{
+    if (hLock != NIL_RTVFSLOCK)
+        RTVfsLockAcquireWriteSlow(hLock);
+}
+
+
+/**
+ * Release a write lock.
+ *
+ * @param   hLock               The lock handle, can be NIL.
+ */
+DECLINLINE(void) RTVfsLockReleaseWrite(RTVFSLOCK hLock)
+{
+    if (hLock != NIL_RTVFSLOCK)
+        RTVfsLockReleaseWriteSlow(hLock);
+}
+
+/** @}  */
+
 /**
  * The VFS operations.
@@ -141 +261 @@
 /** The RTVFSOBJOPS structure version. */
 #define RTVFSOBJOPS_VERSION         RT_MAKE_U32_FROM_U8(0xff,0x1f,1,0)
+
+
+/**
+ * Creates a new VFS base object handle.
+ *
+ * @returns IPRT status code
+ * @param   pObjOps             The base object operations.
+ * @param   cbInstance          The size of the instance data.
+ * @param   hVfs                The VFS handle to associate this base object
+ *                              with.  NIL_VFS is ok.
+ * @param   hLock               Handle to a custom lock to be used with the new
+ *                              object.  The reference is consumed.  NIL and
+ *                              special lock handles are fine.
+ * @param   phVfsFss            Where to return the new handle.
+ * @param   ppvInstance         Where to return the pointer to the instance data
+ *                              (size is @a cbInstance).
+ */
+RTDECL(int) RTVfsNewBaseObj(PCRTVFSOBJOPS pObjOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
+                            PRTVFSOBJ phVfsObj, void **ppvInstance);
 
 
@@ -255 +394 @@
  * @param   cbInstance          The size of the instance data.
  * @param   hVfs                The VFS handle to associate this filesystem
- *                              steram with.  NIL_VFS is ok.
- * @param   hSemRW              The read-write semaphore to use to protect the
- *                              handle if this differs from the one the VFS
- *                              uses.  NIL_RTSEMRW is ok if no locking is
- *                              desired.
+ *                              stream with.  NIL_VFS is ok.
+ * @param   hLock               Handle to a custom lock to be used with the new
+ *                              object.  The reference is consumed.  NIL and
+ *                              special lock handles are fine.
  * @param   phVfsFss            Where to return the new handle.
  * @param   ppvInstance         Where to return the pointer to the instance data
  *                              (size is @a cbInstance).
  */
-RTDECL(int) RTVfsNewFsStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTSEMRW hSemRW,
+RTDECL(int) RTVfsNewFsStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
                              PRTVFSFSSTREAM phVfsFss, void **ppvInstance);
 
@@ -450 +588 @@
 /** The RTVFSSYMLINKOPS structure version. */
 #define RTVFSSYMLINKOPS_VERSION     RT_MAKE_U32_FROM_U8(0xff,0x5f,1,0)
+
+
+/**
+ * Creates a new VFS symlink handle.
+ *
+ * @returns IPRT status code
+ * @param   pSymlinkOps         The symlink operations.
+ * @param   cbInstance          The size of the instance data.
+ * @param   hVfs                The VFS handle to associate this symlink object
+ *                              with.  NIL_VFS is ok.
+ * @param   hLock               Handle to a custom lock to be used with the new
+ *                              object.  The reference is consumed.  NIL and
+ *                              special lock handles are fine.
+ * @param   phVfsSym            Where to return the new handle.
+ * @param   ppvInstance         Where to return the pointer to the instance data
+ *                              (size is @a cbInstance).
+ */
+RTDECL(int) RTVfsNewSymlink(PCRTVFSSYMLINKOPS pSymlinkOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
+                            PRTVFSSYMLINK phVfsSym, void **ppvInstance);
 
 
@@ -576 +733 @@
  * @param   hVfs                The VFS handle to associate this I/O stream
  *                              with.  NIL_VFS is ok.
- * @param   hSemRW              The read-write semaphore to use to protect the
- *                              handle if this differs from the one the VFS
- *                              uses.  NIL_RTSEMRW is ok if no locking is
- *                              desired.
+ * @param   hLock               Handle to a custom lock to be used with the new
+ *                              object.  The reference is consumed.  NIL and
+ *                              special lock handles are fine.
  * @param   phVfsIos            Where to return the new handle.
  * @param   ppvInstance         Where to return the pointer to the instance data
  *                              (size is @a cbInstance).
  */
-RTDECL(int) RTVfsNewIoStream(PCRTVFSIOSTREAMOPS pIoStreamOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTSEMRW hSemRW,
+RTDECL(int) RTVfsNewIoStream(PCRTVFSIOSTREAMOPS pIoStreamOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTVFSLOCK hLock,
                              PRTVFSIOSTREAM phVfsIos, void **ppvInstance);
 
@@ -647 +803 @@
  * @param   hVfs                The VFS handle to associate this file with.
  *                              NIL_VFS is ok.
+ * @param   hLock               Handle to a custom lock to be used with the new
+ *                              object.  The reference is consumed.  NIL and
+ *                              special lock handles are fine.
  * @param   phVfsFile           Where to return the new handle.
  * @param   ppvInstance         Where to return the pointer to the instance data
  *                              (size is @a cbInstance).
  */
-RTDECL(int) RTVfsNewFile(PCRTVFSFILEOPS pFileOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs,
+RTDECL(int) RTVfsNewFile(PCRTVFSFILEOPS pFileOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTVFSLOCK hLock,
                          PRTVFSFILE phVfsFile, void **ppvInstance);
 

trunk/src/VBox/Runtime/common/vfs/vfsbase.cpp

@@ -71 +71 @@
 
 /** Asserts that the VFS base object vtable is valid. */
-#define RTVFSOBJ_ASSERT_OPS(pObj, enmTypeArg) \
+#define RTVFSOBJ_ASSERT_OPS(a_pObjOps, a_enmType) \
     do \
     { \
-        Assert((pObj)->uVersion == RTVFSOBJOPS_VERSION); \
-        Assert((pObj)->enmType == (enmTypeArg) || (enmTypeArg) == RTVFSOBJTYPE_INVALID); \
-        AssertPtr((pObj)->pszName); \
-        Assert(*(pObj)->pszName); \
-        AssertPtr((pObj)->pfnClose); \
-        AssertPtr((pObj)->pfnQueryInfo); \
-        Assert((pObj)->uEndMarker == RTVFSOBJOPS_VERSION); \
+        Assert((a_pObjOps)->uVersion == RTVFSOBJOPS_VERSION); \
+        Assert((a_pObjOps)->enmType == (a_enmType) || (a_enmType) == RTVFSOBJTYPE_INVALID); \
+        AssertPtr((a_pObjOps)->pszName); \
+        Assert(*(a_pObjOps)->pszName); \
+        AssertPtr((a_pObjOps)->pfnClose); \
+        AssertPtr((a_pObjOps)->pfnQueryInfo); \
+        Assert((a_pObjOps)->uEndMarker == RTVFSOBJOPS_VERSION); \
     } while (0)
 
+/** Asserts that the VFS set object vtable is valid. */
+#define RTVFSOBJSET_ASSERT_OPS(a_pSetOps, a_offObjOps) \
+    do \
+    { \
+        Assert((a_pSetOps)->uVersion == RTVFSOBJSETOPS_VERSION); \
+        Assert((a_pSetOps)->offObjOps == (a_offObjOps)); \
+        AssertPtr((a_pSetOps)->pfnSetMode); \
+        AssertPtr((a_pSetOps)->pfnSetTimes); \
+        AssertPtr((a_pSetOps)->pfnSetOwner); \
+        Assert((a_pSetOps)->uEndMarker == RTVFSOBJSETOPS_VERSION); \
+    } while (0)
+
 /** Asserts that the VFS I/O stream vtable is valid. */
-#define RTVFSIOSTREAM_ASSERT_OPS(pIoStreamOps, enmTypeArg) \
+#define RTVFSIOSTREAM_ASSERT_OPS(pIoStreamOps, a_enmType) \
     do { \
-        RTVFSOBJ_ASSERT_OPS(&(pIoStreamOps)->Obj, enmTypeArg); \
+        RTVFSOBJ_ASSERT_OPS(&(pIoStreamOps)->Obj, a_enmType); \
         Assert((pIoStreamOps)->uVersion == RTVFSIOSTREAMOPS_VERSION); \
         Assert(!(pIoStreamOps)->fReserved); \
@@ -99 +111 @@
     } while (0)
 
+/** Asserts that the VFS symlink vtable is valid. */
+#define RTVFSSYMLINK_ASSERT_OPS(pSymlinkOps, a_enmType) \
+    do { \
+        RTVFSOBJ_ASSERT_OPS(&(pSymlinkOps)->Obj, a_enmType); \
+        RTVFSOBJSET_ASSERT_OPS(&(pSymlinkOps)->ObjSet, \
+            RT_OFFSETOF(RTVFSSYMLINKOPS, Obj) - RT_OFFSETOF(RTVFSSYMLINKOPS, ObjSet)); \
+        Assert((pSymlinkOps)->uVersion == RTVFSSYMLINKOPS_VERSION); \
+        Assert(!(pSymlinkOps)->fReserved); \
+        AssertPtr((pSymlinkOps)->pfnRead); \
+        Assert((pSymlinkOps)->uEndMarker == RTVFSSYMLINKOPS_VERSION); \
+    } while (0)
+
+
+/** Validates a VFS handle and returns @a rcRet if it's invalid. */
+#define RTVFS_ASSERT_VALID_HANDLE_OR_NIL_RETURN(hVfs, rcRet) \
+    do { \
+        if ((hVfs) != NIL_RTVFS) \
+        { \
+            AssertPtrReturn((hVfs), (rcRet)); \
+            AssertReturn((hVfs)->uMagic == RTVFS_MAGIC, (rcRet)); \
+        } \
+    } while (0)
 
 
@@ -105 +139 @@
 *******************************************************************************/
 /** @todo Move all this stuff to internal/vfs.h */
+
+
+/**
+ * The VFS internal lock data.
+ */
+typedef struct RTVFSLOCKINTERNAL
+{
+    /** The number of references to the this lock. */
+    uint32_t volatile       cRefs;
+    /** The lock type. */
+    RTVFSLOCKTYPE           enmType;
+    /** Type specific data. */
+    union
+    {
+        /** Read/Write semaphore handle. */
+        RTSEMRW             hSemRW;
+        /** Fast mutex semaphore handle. */
+        RTSEMFASTMUTEX      hFastMtx;
+        /** Regular mutex semaphore handle. */
+        RTSEMMUTEX          hMtx;
+    } u;
+} RTVFSLOCKINTERNAL;
+
 
 /**
@@ -122 +179 @@
     /** The vtable. */
     PCRTVFSOBJOPS           pOps;
-    /** Read-write semaphore protecting all access to the VFS
-     * Only valid RTVFS_C_THREAD_SAFE is set, otherwise it is NIL_RTSEMRW. */
-    RTSEMRW                 hSemRW;
+    /** The lock protecting all access to the VFS.
+     * Only valid RTVFS_C_THREAD_SAFE is set, otherwise it is NIL_RTVFSLOCK. */
+    RTVFSLOCK               hLock;
     /** Reference back to the VFS containing this object. */
     RTVFS                   hVfs;
@@ -279 +336 @@
 
 
+
+/*
+ *
+ *  V F S   L o c k   A b s t r a c t i o n
+ *  V F S   L o c k   A b s t r a c t i o n
+ *  V F S   L o c k   A b s t r a c t i o n
+ *
+ *
+ */
+
+
+RTDECL(uint32_t) RTVfsLockRetain(RTVFSLOCK hLock)
+{
+    RTVFSLOCKINTERNAL *pThis = hLock;
+    AssertPtrReturn(pThis, UINT32_MAX);
+    AssertPtrReturn(pThis->enmType > RTVFSLOCKTYPE_INVALID && pThis->enmType < RTVFSLOCKTYPE_END, UINT32_MAX);
+
+    uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
+    AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p %d\n", cRefs, pThis, pThis->enmType));
+    return cRefs;
+}
+
+
+/**
+ * Destroys a VFS lock handle.
+ *
+ * @param   pThis               The lock to destroy.
+ */
+static void rtVfsLockDestroy(RTVFSLOCKINTERNAL *pThis)
+{
+    switch (pThis->enmType)
+    {
+        case RTVFSLOCKTYPE_RW:
+            RTSemRWDestroy(pThis->u.hSemRW);
+            pThis->u.hSemRW = NIL_RTSEMRW;
+            break;
+
+        case RTVFSLOCKTYPE_FASTMUTEX:
+            RTSemFastMutexDestroy(pThis->u.hFastMtx);
+            pThis->u.hFastMtx = NIL_RTSEMFASTMUTEX;
+            break;
+
+        case RTVFSLOCKTYPE_MUTEX:
+            RTSemMutexDestroy(pThis->u.hMtx);
+            pThis->u.hFastMtx = NIL_RTSEMMUTEX;
+            break;
+
+        default:
+            AssertMsgFailedReturnVoid(("%p %d\n", pThis, pThis->enmType));
+    }
+
+    pThis->enmType = RTVFSLOCKTYPE_INVALID;
+    RTMemFree(pThis);
+}
+
+
+RTDECL(uint32_t) RTVfsLockRelease(RTVFSLOCK hLock)
+{
+    RTVFSLOCKINTERNAL *pThis = hLock;
+    AssertPtrReturn(pThis, UINT32_MAX);
+    AssertPtrReturn(pThis->enmType > RTVFSLOCKTYPE_INVALID && pThis->enmType < RTVFSLOCKTYPE_END, UINT32_MAX);
+
+    uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
+    AssertMsg(cRefs < _1M, ("%#x %p %d\n", cRefs, pThis, pThis->enmType));
+    if (cRefs == 0)
+        rtVfsLockDestroy(pThis);
+    return cRefs;
+}
+
+
+/**
+ * Creates a read/write lock.
+ *
+ * @returns IPRT status code
+ * @param   phLock              Where to return the lock handle.
+ */
+static int rtVfsLockCreateRW(PRTVFSLOCK phLock)
+{
+    RTVFSLOCKINTERNAL *pThis = (RTVFSLOCKINTERNAL *)RTMemAlloc(sizeof(*pThis));
+    if (!pThis)
+        return VERR_NO_MEMORY;
+
+    pThis->cRefs    = 1;
+    pThis->enmType  = RTVFSLOCKTYPE_RW;
+
+    int rc = RTSemRWCreate(&pThis->u.hSemRW);
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    *phLock = pThis;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Creates a fast mutex lock.
+ *
+ * @returns IPRT status code
+ * @param   phLock              Where to return the lock handle.
+ */
+static int rtVfsLockCreateFastMutex(PRTVFSLOCK phLock)
+{
+    RTVFSLOCKINTERNAL *pThis = (RTVFSLOCKINTERNAL *)RTMemAlloc(sizeof(*pThis));
+    if (!pThis)
+        return VERR_NO_MEMORY;
+
+    pThis->cRefs    = 1;
+    pThis->enmType  = RTVFSLOCKTYPE_FASTMUTEX;
+
+    int rc = RTSemFastMutexCreate(&pThis->u.hFastMtx);
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    *phLock = pThis;
+    return VINF_SUCCESS;
+
+}
+
+
+/**
+ * Creates a mutex lock.
+ *
+ * @returns IPRT status code
+ * @param   phLock              Where to return the lock handle.
+ */
+static int rtVfsLockCreateMutex(PRTVFSLOCK phLock)
+{
+    RTVFSLOCKINTERNAL *pThis = (RTVFSLOCKINTERNAL *)RTMemAlloc(sizeof(*pThis));
+    if (!pThis)
+        return VERR_NO_MEMORY;
+
+    pThis->cRefs    = 1;
+    pThis->enmType  = RTVFSLOCKTYPE_MUTEX;
+
+    int rc = RTSemMutexCreate(&pThis->u.hMtx);
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    *phLock = pThis;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Acquires the lock for reading.
+ *
+ * @param   hLock               Non-nil lock handle.
+ * @internal
+ */
+RTDECL(void) RTVfsLockAcquireReadSlow(RTVFSLOCK hLock)
+{
+    RTVFSLOCKINTERNAL *pThis = hLock;
+    int                rc;
+
+    AssertPtr(pThis);
+    switch (pThis->enmType)
+    {
+        case RTVFSLOCKTYPE_RW:
+            rc = RTSemRWRequestRead(pThis->u.hSemRW, RT_INDEFINITE_WAIT);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_FASTMUTEX:
+            rc = RTSemFastMutexRequest(pThis->u.hFastMtx);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_MUTEX:
+            rc = RTSemMutexRequest(pThis->u.hMtx, RT_INDEFINITE_WAIT);
+            AssertRC(rc);
+            break;
+        default:
+            AssertFailed();
+    }
+}
+
+
+/**
+ * Release a lock held for reading.
+ *
+ * @param   hLock               Non-nil lock handle.
+ * @internal
+ */
+RTDECL(void) RTVfsLockReleaseReadSlow(RTVFSLOCK hLock)
+{
+    RTVFSLOCKINTERNAL *pThis = hLock;
+    int                rc;
+
+    AssertPtr(pThis);
+    switch (pThis->enmType)
+    {
+        case RTVFSLOCKTYPE_RW:
+            rc = RTSemRWReleaseRead(pThis->u.hSemRW);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_FASTMUTEX:
+            rc = RTSemFastMutexRelease(pThis->u.hFastMtx);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_MUTEX:
+            rc = RTSemMutexRelease(pThis->u.hMtx);
+            AssertRC(rc);
+            break;
+        default:
+            AssertFailed();
+    }
+}
+
+
+/**
+ * Acquires the lock for writing.
+ *
+ * @param   hLock               Non-nil lock handle.
+ * @internal
+ */
+RTDECL(void) RTVfsLockAcquireWriteSlow(RTVFSLOCK hLock)
+{
+    RTVFSLOCKINTERNAL *pThis = hLock;
+    int                rc;
+
+    AssertPtr(pThis);
+    switch (pThis->enmType)
+    {
+        case RTVFSLOCKTYPE_RW:
+            rc = RTSemRWRequestWrite(pThis->u.hSemRW, RT_INDEFINITE_WAIT);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_FASTMUTEX:
+            rc = RTSemFastMutexRequest(pThis->u.hFastMtx);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_MUTEX:
+            rc = RTSemMutexRequest(pThis->u.hMtx, RT_INDEFINITE_WAIT);
+            AssertRC(rc);
+            break;
+        default:
+            AssertFailed();
+    }
+}
+
+
+/**
+ * Release a lock held for writing.
+ *
+ * @param   hLock               Non-nil lock handle.
+ * @internal
+ */
+RTDECL(void) RTVfsLockReleaseWriteSlow(RTVFSLOCK hLock)
+{
+    RTVFSLOCKINTERNAL *pThis = hLock;
+    int                rc;
+
+    AssertPtr(pThis);
+    switch (pThis->enmType)
+    {
+        case RTVFSLOCKTYPE_RW:
+            rc = RTSemRWReleaseWrite(pThis->u.hSemRW);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_FASTMUTEX:
+            rc = RTSemFastMutexRelease(pThis->u.hFastMtx);
+            AssertRC(rc);
+            break;
+
+        case RTVFSLOCKTYPE_MUTEX:
+            rc = RTSemMutexRelease(pThis->u.hMtx);
+            AssertRC(rc);
+            break;
+        default:
+            AssertFailed();
+    }
+}
+
+
+
 /*
  *
@@ -288 +634 @@
 
 /**
+ * Internal object retainer that asserts sanity in strict builds.
+ *
+ * @param   pThis               The base object handle data.
+ */
+DECLINLINE(void) rtVfsObjRetainVoid(RTVFSOBJINTERNAL *pThis)
+{
+    uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
+    AssertMsg(cRefs > 1 && cRefs < _1M,
+              ("%#x %p ops=%p %s (%d)\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType));
+    NOREF(cRefs);
+}
+
+
+/**
+ * Initializes the base object part of a new object.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               Pointer to the base object part.
+ * @param   pObjOps             The base object vtable.
+ * @param   hVfs                The VFS handle to associate with.
+ * @param   hLock               The lock handle, pseudo handle or nil.
+ * @param   pvThis              Pointer to the private data.
+ */
+static int rtVfsObjInitNewObject(RTVFSOBJINTERNAL *pThis, PCRTVFSOBJOPS pObjOps, RTVFS hVfs, RTVFSLOCK hLock, void *pvThis)
+{
+    /*
+     * Deal with the lock first as that's the most complicated matter.
+     */
+    if (hLock != NIL_RTVFSLOCK)
+    {
+        int rc;
+        if (hLock == RTVFSLOCK_CREATE_RW)
+        {
+            rc = rtVfsLockCreateRW(&hLock);
+            AssertRCReturn(rc, rc);
+        }
+        else if (hLock == RTVFSLOCK_CREATE_FASTMUTEX)
+        {
+            rc = rtVfsLockCreateFastMutex(&hLock);
+            AssertRCReturn(rc, rc);
+        }
+        else if (hLock == RTVFSLOCK_CREATE_MUTEX)
+        {
+            rc = rtVfsLockCreateMutex(&hLock);
+            AssertRCReturn(rc, rc);
+        }
+        else
+        {
+            /*
+             * The caller specified a lock, we consume the this reference.
+             */
+            AssertPtrReturn(hLock, VERR_INVALID_HANDLE);
+            AssertPtrReturn(hLock->enmType > RTVFSLOCKTYPE_INVALID && hLock->enmType < RTVFSLOCKTYPE_END, VERR_INVALID_HANDLE);
+            AssertPtrReturn(hLock->cRefs > 0, VERR_INVALID_HANDLE);
+        }
+    }
+    else if (hVfs != NIL_RTVFS)
+    {
+        /*
+         * Retain a reference to the VFS lock, if there is one.
+         */
+        hLock = hVfs->Base.hLock;
+        if (hLock != NIL_RTVFSLOCK)
+        {
+            uint32_t cRefs = RTVfsLockRetain(hLock);
+            if (RT_UNLIKELY(cRefs == UINT32_MAX))
+                return VERR_INVALID_HANDLE;
+        }
+    }
+
+
+    /*
+     * Do the actual initializing.
+     */
+    pThis->uMagic  = RTVFSOBJ_MAGIC;
+    pThis->pvThis  = pvThis;
+    pThis->pOps    = pObjOps;
+    pThis->cRefs   = 1;
+    pThis->hVfs    = hVfs;
+    pThis->hLock   = hLock;
+    if (hVfs != NIL_RTVFS)
+        rtVfsObjRetainVoid(&hVfs->Base);
+
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTVfsNewBaseObj(PCRTVFSOBJOPS pObjOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
+                            PRTVFSOBJ phVfsObj, void **ppvInstance)
+{
+    /*
+     * Validate the input, be extra strict in strict builds.
+     */
+    AssertPtr(pObjOps);
+    AssertReturn(pObjOps->uVersion   == RTVFSOBJOPS_VERSION, VERR_VERSION_MISMATCH);
+    AssertReturn(pObjOps->uEndMarker == RTVFSOBJOPS_VERSION, VERR_VERSION_MISMATCH);
+    RTVFSOBJ_ASSERT_OPS(pObjOps, RTVFSOBJTYPE_BASE);
+    Assert(cbInstance > 0);
+    AssertPtr(ppvInstance);
+    AssertPtr(phVfsObj);
+    RTVFS_ASSERT_VALID_HANDLE_OR_NIL_RETURN(hVfs, VERR_INVALID_HANDLE);
+
+    /*
+     * Allocate the handle + instance data.
+     */
+    size_t const cbThis = RT_ALIGN_Z(sizeof(RTVFSOBJINTERNAL), RTVFS_INST_ALIGNMENT)
+                        + RT_ALIGN_Z(cbInstance, RTVFS_INST_ALIGNMENT);
+    RTVFSOBJINTERNAL *pThis = (RTVFSOBJINTERNAL *)RTMemAllocZ(cbThis);
+    if (!pThis)
+        return VERR_NO_MEMORY;
+
+    int rc = rtVfsObjInitNewObject(pThis, pObjOps, hVfs, hLock,
+                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    *phVfsObj    = pThis;
+    *ppvInstance = pThis->pvThis;
+    return VINF_SUCCESS;
+}
+
+
+/**
  * Write locks the object.
  *
@@ -294 +766 @@
 DECLINLINE(void) rtVfsObjWriteLock(RTVFSOBJINTERNAL *pThis)
 {
-    if (pThis->hSemRW != NIL_RTSEMRW)
-    {
-        int rc = RTSemRWRequestWrite(pThis->hSemRW, RT_INDEFINITE_WAIT);
-        AssertRC(rc);
-    }
+    RTVfsLockAcquireWrite(pThis->hLock);
 }
 
@@ -309 +777 @@
 DECLINLINE(void) rtVfsObjWriteUnlock(RTVFSOBJINTERNAL *pThis)
 {
-    if (pThis->hSemRW != NIL_RTSEMRW)
-    {
-        int rc = RTSemRWReleaseWrite(pThis->hSemRW);
-        AssertRC(rc);
-    }
+    RTVfsLockReleaseWrite(pThis->hLock);
 }
 
@@ -323 +787 @@
 DECLINLINE(void) rtVfsObjReadLock(RTVFSOBJINTERNAL *pThis)
 {
-    if (pThis->hSemRW != NIL_RTSEMRW)
-    {
-        int rc = RTSemRWRequestRead(pThis->hSemRW, RT_INDEFINITE_WAIT);
-        AssertRC(rc);
-    }
+    RTVfsLockAcquireRead(pThis->hLock);
 }
 
@@ -338 +798 @@
 DECLINLINE(void) rtVfsObjReadUnlock(RTVFSOBJINTERNAL *pThis)
 {
-    if (pThis->hSemRW != NIL_RTSEMRW)
-    {
-        int rc = RTSemRWReleaseRead(pThis->hSemRW);
-        AssertRC(rc);
-    }
+    RTVfsLockReleaseRead(pThis->hLock);
 }
 
@@ -359 +815 @@
               ("%#x %p ops=%p %s (%d)\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType));
     return cRefs;
-}
-
-
-/**
- * Internal object retainer that asserts sanity in strict builds.
- *
- * @param   pThis               The base object handle data.
- */
-DECLINLINE(void) rtVfsObjRetainVoid(RTVFSOBJINTERNAL *pThis)
-{
-    uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
-    AssertMsg(cRefs > 1 && cRefs < _1M,
-              ("%#x %p ops=%p %s (%d)\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType));
-    NOREF(cRefs);
 }
 
@@ -1122 +1564 @@
 
 
-RTDECL(int) RTVfsNewFsStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTSEMRW hSemRW,
+RTDECL(int) RTVfsNewFsStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
                              PRTVFSFSSTREAM phVfsFss, void **ppvInstance)
 {
@@ -1137 +1579 @@
     AssertPtr(ppvInstance);
     AssertPtr(phVfsFss);
-
-    RTVFSINTERNAL *pVfs = NULL;
-    if (hVfs != NIL_RTVFS)
-    {
-        pVfs = hVfs;
-        AssertPtrReturn(pVfs, VERR_INVALID_HANDLE);
-        AssertReturn(pVfs->uMagic == RTVFS_MAGIC, VERR_INVALID_HANDLE);
-    }
+    RTVFS_ASSERT_VALID_HANDLE_OR_NIL_RETURN(hVfs, VERR_INVALID_HANDLE);
 
     /*
@@ -1155 +1590 @@
         return VERR_NO_MEMORY;
 
-    pThis->uMagic       = RTVFSFSSTREAM_MAGIC;
-    pThis->fFlags       = RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;
-    pThis->pOps         = pFsStreamOps;
-    pThis->Base.uMagic  = RTVFSOBJ_MAGIC;
-    pThis->Base.pvThis  = (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT);
-    pThis->Base.pOps    = &pFsStreamOps->Obj;
-    pThis->Base.hSemRW  = hSemRW != NIL_RTSEMRW ? hSemRW : pVfs ? pVfs->Base.hSemRW : NIL_RTSEMRW;
-    pThis->Base.hVfs    = hVfs;
-    pThis->Base.cRefs   = 1;
-    if (hVfs != NIL_RTVFS)
-        rtVfsObjRetainVoid(&pVfs->Base);
-
-    *phVfsFss    = pThis;
-    *ppvInstance = pThis->Base.pvThis;
+    int rc = rtVfsObjInitNewObject(&pThis->Base, &pFsStreamOps->Obj, hVfs, hLock,
+                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
+
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    pThis->uMagic = RTVFSFSSTREAM_MAGIC;
+    pThis->fFlags = RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;
+    pThis->pOps   = pFsStreamOps;
+
+    *phVfsFss     = pThis;
+    *ppvInstance  = pThis->Base.pvThis;
     return VINF_SUCCESS;
 }
@@ -1256 +1692 @@
  */
 
+RTDECL(int) RTVfsNewSymlink(PCRTVFSSYMLINKOPS pSymlinkOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
+                            PRTVFSSYMLINK phVfsSym, void **ppvInstance)
+{
+    /*
+     * Validate the input, be extra strict in strict builds.
+     */
+    AssertPtr(pSymlinkOps);
+    AssertReturn(pSymlinkOps->uVersion   == RTVFSSYMLINKOPS_VERSION, VERR_VERSION_MISMATCH);
+    AssertReturn(pSymlinkOps->uEndMarker == RTVFSSYMLINKOPS_VERSION, VERR_VERSION_MISMATCH);
+    Assert(!pSymlinkOps->fReserved);
+    RTVFSSYMLINK_ASSERT_OPS(pSymlinkOps, RTVFSOBJTYPE_SYMLINK);
+    Assert(cbInstance > 0);
+    AssertPtr(ppvInstance);
+    AssertPtr(phVfsSym);
+    RTVFS_ASSERT_VALID_HANDLE_OR_NIL_RETURN(hVfs, VERR_INVALID_HANDLE);
+
+    /*
+     * Allocate the handle + instance data.
+     */
+    size_t const cbThis = RT_ALIGN_Z(sizeof(RTVFSSYMLINKINTERNAL), RTVFS_INST_ALIGNMENT)
+                        + RT_ALIGN_Z(cbInstance, RTVFS_INST_ALIGNMENT);
+    RTVFSSYMLINKINTERNAL *pThis = (RTVFSSYMLINKINTERNAL *)RTMemAllocZ(cbThis);
+    if (!pThis)
+        return VERR_NO_MEMORY;
+
+    int rc = rtVfsObjInitNewObject(&pThis->Base, &pSymlinkOps->Obj, hVfs, hLock,
+                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    pThis->uMagic = RTVFSSYMLINK_MAGIC;
+    pThis->pOps   = pSymlinkOps;
+
+    *phVfsSym     = pThis;
+    *ppvInstance  = pThis->Base.pvThis;
+    return VINF_SUCCESS;
+}
+
+
 RTDECL(uint32_t)    RTVfsSymlinkRetain(RTVFSSYMLINK hVfsSym)
 {
@@ -1297 +1775 @@
  */
 
-RTDECL(int) RTVfsNewIoStream(PCRTVFSIOSTREAMOPS pIoStreamOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTSEMRW hSemRW,
+RTDECL(int) RTVfsNewIoStream(PCRTVFSIOSTREAMOPS pIoStreamOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTVFSLOCK hLock,
                              PRTVFSIOSTREAM phVfsIos, void **ppvInstance)
 {
@@ -1312 +1790 @@
     AssertPtr(ppvInstance);
     AssertPtr(phVfsIos);
-
-    RTVFSINTERNAL *pVfs = NULL;
-    if (hVfs != NIL_RTVFS)
-    {
-        pVfs = hVfs;
-        AssertPtrReturn(pVfs, VERR_INVALID_HANDLE);
-        AssertReturn(pVfs->uMagic == RTVFS_MAGIC, VERR_INVALID_HANDLE);
-    }
+    RTVFS_ASSERT_VALID_HANDLE_OR_NIL_RETURN(hVfs, VERR_INVALID_HANDLE);
 
     /*
@@ -1330 +1801 @@
         return VERR_NO_MEMORY;
 
-    pThis->uMagic       = RTVFSIOSTREAM_MAGIC;
-    pThis->fFlags       = fOpen;
-    pThis->pOps         = pIoStreamOps;
-    pThis->Base.uMagic  = RTVFSOBJ_MAGIC;
-    pThis->Base.pvThis  = (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT);
-    pThis->Base.pOps    = &pIoStreamOps->Obj;
-    pThis->Base.hSemRW  = hSemRW != NIL_RTSEMRW ? hSemRW : pVfs ? pVfs->Base.hSemRW : NIL_RTSEMRW;
-    pThis->Base.hVfs    = hVfs;
-    pThis->Base.cRefs   = 1;
-    if (hVfs != NIL_RTVFS)
-        rtVfsObjRetainVoid(&pVfs->Base);
-
-    *phVfsIos    = pThis;
-    *ppvInstance = pThis->Base.pvThis;
+    int rc = rtVfsObjInitNewObject(&pThis->Base, &pIoStreamOps->Obj, hVfs, hLock,
+                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    pThis->uMagic = RTVFSIOSTREAM_MAGIC;
+    pThis->fFlags = fOpen;
+    pThis->pOps   = pIoStreamOps;
+
+    *phVfsIos     = pThis;
+    *ppvInstance  = pThis->Base.pvThis;
     return VINF_SUCCESS;
 }
@@ -1604 +2075 @@
  */
 
-RTDECL(int) RTVfsNewFile(PCRTVFSFILEOPS pFileOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs,
+RTDECL(int) RTVfsNewFile(PCRTVFSFILEOPS pFileOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTVFSLOCK hLock,
                          PRTVFSFILE phVfsFile, void **ppvInstance)
 {
@@ -1619 +2090 @@
     AssertPtr(ppvInstance);
     AssertPtr(phVfsFile);
-
-    RTVFSINTERNAL *pVfs = NULL;
-    if (hVfs != NIL_RTVFS)
-    {
-        pVfs = hVfs;
-        AssertPtrReturn(pVfs, VERR_INVALID_HANDLE);
-        AssertReturn(pVfs->uMagic == RTVFS_MAGIC, VERR_INVALID_HANDLE);
-    }
+    RTVFS_ASSERT_VALID_HANDLE_OR_NIL_RETURN(hVfs, VERR_INVALID_HANDLE);
 
     /*
@@ -1637 +2101 @@
         return VERR_NO_MEMORY;
 
-    pThis->uMagic               = RTVFSFILE_MAGIC;
-    pThis->fReserved            = 0;
-    pThis->pOps                 = pFileOps;
-    pThis->Stream.uMagic        = RTVFSIOSTREAM_MAGIC;
-    pThis->Stream.fFlags        = fOpen;
-    pThis->Stream.pOps          = &pFileOps->Stream;
-    pThis->Stream.Base.pvThis   = (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT);
-    pThis->Stream.Base.pOps     = &pFileOps->Stream.Obj;
-    pThis->Stream.Base.hSemRW   = pVfs ? pVfs->Base.hSemRW : NIL_RTSEMRW;
-    pThis->Stream.Base.hVfs     = hVfs;
-    pThis->Stream.Base.cRefs    = 1;
-    if (hVfs != NIL_RTVFS)
-        rtVfsObjRetainVoid(&pVfs->Base);
+    int rc = rtVfsObjInitNewObject(&pThis->Stream.Base, &pFileOps->Stream.Obj, hVfs, hLock,
+                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pThis);
+        return rc;
+    }
+
+    pThis->uMagic        = RTVFSFILE_MAGIC;
+    pThis->fReserved     = 0;
+    pThis->pOps          = pFileOps;
+    pThis->Stream.uMagic = RTVFSIOSTREAM_MAGIC;
+    pThis->Stream.fFlags = fOpen;
+    pThis->Stream.pOps   = &pFileOps->Stream;
 
     *phVfsFile   = pThis;

trunk/src/VBox/Runtime/common/vfs/vfsstdfile.cpp

@@ -436 +436 @@
     PRTVFSSTDFILE   pThis;
     RTVFSFILE       hVfsFile;
-    rc = RTVfsNewFile(&g_rtVfsStdFileOps, sizeof(RTVFSSTDFILE), fOpen, NIL_RTVFS, &hVfsFile, (void **)&pThis);
+    rc = RTVfsNewFile(&g_rtVfsStdFileOps, sizeof(RTVFSSTDFILE), fOpen, NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFile, (void **)&pThis);
     if (RT_FAILURE(rc))
         return rc;

trunk/src/VBox/Runtime/common/zip/tar.h

@@ -93 +93 @@
     char            ab[512];
     /** The standard header. */
-    RTZIPTARHDRPOSIX   Hdr;
+    RTZIPTARHDRPOSIX Posix;
 } RTZIPTARHDR;
 AssertCompileSize(RTZIPTARHDR, 512);

trunk/src/VBox/Runtime/common/zip/tarvfs.cpp

@@ -35 +35 @@
 #include <iprt/err.h>
 #include <iprt/poll.h>
+#include <iprt/file.h>
 #include <iprt/string.h>
 #include <iprt/vfs.h>
@@ -111 +112 @@
 
 
+/**
+ * Checks if the TAR header includes a posix user name field.
+ *
+ * @returns true / false.
+ * @param   pTar                The TAR header.
+ */
 DECLINLINE(bool) rtZipTarHdrHasPosixUserName(PCRTZIPTARHDR pTar)
 {
@@ -117 +124 @@
 
 
+/**
+ * Checks if the TAR header includes a posix group name field.
+ *
+ * @returns true / false.
+ * @param   pTar                The TAR header.
+ */
 DECLINLINE(bool) rtZipTarHdrHasPosixGroupName(PCRTZIPTARHDR pTar)
 {
     return true;
+}
+
+
+/**
+ * Checks if the TAR header includes a posix compatible path prefix field.
+ *
+ * @returns true / false.
+ * @param   pTar                The TAR header.
+ */
+DECLINLINE(bool) rtZipTarHdrHasPrefix(PCRTZIPTARHDR pTar)
+{
+    return true;
+}
+
+
+/**
+ * Validates the TAR header.
+ *
+ * @returns VINF_SUCCESS if valid, appropriate VERR_TAR_XXX if not.
+ * @param   pTar                The TAR header.
+ */
+static int rtZipTarHdrValidate(PCRTZIPTARHDR pTar)
+{
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Translate a TAR header to an IPRT object info structure with additional UNIX
+ * attributes.
+ *
+ * @returns VINF_SUCCESS if valid, appropriate VERR_TAR_XXX if not.
+ * @param   pTar                The TAR header (input).
+ * @param   pObjInfo            The object info structure (output).
+ */
+static int rtZipTarHdrToFsObjInfo(PCRTZIPTARHDR pTar, PRTFSOBJINFO pObjInfo)
+{
+    RT_ZERO(*pObjInfo);
+
+    return VINF_SUCCESS;
 }
 
@@ -168 +221 @@
             pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
             if (rtZipTarHdrHasPosixUserName(&pThis->Hdr))
-                RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName), pThis->Hdr.Hdr.uname);
+                RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName), pThis->Hdr.Posix.uname);
             break;
 
@@ -177 +230 @@
             pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
             if (rtZipTarHdrHasPosixGroupName(&pThis->Hdr))
-                RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName), pThis->Hdr.Hdr.gname);
+                RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName), pThis->Hdr.Posix.gname);
             break;
 
@@ -194 +247 @@
 
 
-
-/**
- * Tar filesystem stream operations.
- */
-static const RTVFSOBJOPS g_rtZipTarFsStrmOps =
+/**
+ * Tar filesystem base object operations.
+ */
+static const RTVFSOBJOPS g_rtZipTarFssBaseObjOps =
 {
     RTVFSOBJOPS_VERSION,
@@ -369 +421 @@
 
 /**
- * Standard file operations.
+ * Tar I/O stream operations.
  */
 static const RTVFSIOSTREAMOPS g_rtZipTarFssIosOps =
@@ -397 +449 @@
  * @interface_method_impl{RTVFSOBJOPS,pfnClose}
  */
+static DECLCALLBACK(int) rtZipTarFssSym_Close(void *pvThis)
+{
+    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+    return rtZipTarFssBaseObj_Close(pThis);
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
+{
+    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+    return rtZipTarFssBaseObj_QueryInfo(pThis, pObjInfo, enmAddAttr);
+}
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
+{
+    NOREF(pvThis); NOREF(fMode); NOREF(fMask);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+                                                 PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+    NOREF(pvThis); NOREF(pAccessTime); NOREF(pModificationTime); NOREF(pChangeTime); NOREF(pBirthTime);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_SetOwner(void *pvThis, RTUID uid, RTGID gid)
+{
+    NOREF(pvThis); NOREF(uid); NOREF(gid);
+    return VERR_ACCESS_DENIED;
+}
+
+
+/**
+ * @interface_method_impl{RTVFSSYMLINKOPS,pfnRead}
+ */
+static DECLCALLBACK(int) rtZipTarFssSym_Read(void *pvThis, char *pszTarget, size_t cbTarget)
+{
+    PRTZIPTARBASEOBJ pThis = (PRTZIPTARBASEOBJ)pvThis;
+    return RTStrCopy(pszTarget, cbTarget, pThis->Hdr.Posix.linkname);
+}
+
+
+/**
+ * Tar symbolic (and hardlink) operations.
+ */
+static const RTVFSSYMLINKOPS g_rtZipTarFssSymOps =
+{
+    { /* Obj */
+        RTVFSOBJOPS_VERSION,
+        RTVFSOBJTYPE_IO_STREAM,
+        "TarFsStream::Symlink",
+        rtZipTarFssIos_Close,
+        rtZipTarFssIos_QueryInfo,
+        RTVFSOBJOPS_VERSION
+    },
+    RTVFSSYMLINKOPS_VERSION,
+    0,
+    { /* ObjSet */
+        RTVFSOBJSETOPS_VERSION,
+        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        rtZipTarFssSym_SetMode,
+        rtZipTarFssSym_SetTimes,
+        rtZipTarFssSym_SetOwner,
+        RTVFSOBJSETOPS_VERSION
+    },
+    rtZipTarFssSym_Read,
+    RTVFSSYMLINKOPS_VERSION
+};
+
+
+/**
+ * @interface_method_impl{RTVFSOBJOPS,pfnClose}
+ */
 static DECLCALLBACK(int) rtZipTarFss_Close(void *pvThis)
 {
@@ -493 +633 @@
         return pThis->rcFatal = VERR_TAR_UNEXPECTED_EOS;
 
-    /*
-     * Validate the header.
-     */
-    /** @todo continue here... */
+    pThis->offNextHdr = off + sizeof(Hdr);
+
+    /*
+     * Validate the header and convert to binary object info.
+     */
+/** @todo look for the two all zero headers terminating the stream... */
+    rc = rtZipTarHdrValidate(&Hdr);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
+
+    RTFSOBJINFO Info;
+    rc = rtZipTarHdrToFsObjInfo(&Hdr, &Info);
+    if (RT_FAILURE(rc))
+        return pThis->rcFatal = rc;
 
     /*
      * Create an object of the appropriate type.
      */
-
-
-    return VERR_NOT_IMPLEMENTED;
+    RTVFSOBJTYPE    enmType;
+    RTVFSOBJ        hVfsObj;
+    switch (Hdr.Posix.typeflag)
+    {
+        /*
+         * Files are represented by a VFS I/O stream.
+         */
+        case RTZIPTAR_TF_NORMAL:
+        case RTZIPTAR_TF_OLDNORMAL:
+        case RTZIPTAR_TF_CONTIG:
+        {
+            RTVFSIOSTREAM       hVfsIos;
+            PRTZIPTARIOSTREAM   pIosData;
+            rc = RTVfsNewIoStream(&g_rtZipTarFssIosOps,
+                                  sizeof(*pIosData),
+                                  RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN,
+                                  NIL_RTVFS,
+                                  NIL_RTVFSLOCK,
+                                  &hVfsIos,
+                                  (void **)&pIosData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pIosData->BaseObj.offHdr  = off;
+            pIosData->BaseObj.Hdr     = Hdr;
+            pIosData->BaseObj.ObjInfo = Info;
+            pIosData->cbFile          = Info.cbObject;
+            pIosData->offFile         = 0;
+            pIosData->cbPadding       = 512 - (uint32_t)(Info.cbObject % 512);
+            pIosData->fEndOfStream    = false;
+            pIosData->hVfsIos         = pThis->hVfsIos;
+            RTVfsIoStrmRetain(pThis->hVfsIos);
+
+            pThis->pCurIosData = pIosData;
+            pThis->offNextHdr += pIosData->cbFile + pIosData->cbPadding;
+
+            enmType = RTVFSOBJTYPE_IO_STREAM;
+            hVfsObj = RTVfsObjFromIoStream(hVfsIos);
+            RTVfsIoStrmRelease(hVfsIos);
+            break;
+        }
+
+        /*
+         * We represent hard links using a symbolic link object.  This fits
+         * best with the way TAR stores it and there is currently no better
+         * fitting VFS type alternative.
+         */
+        case RTZIPTAR_TF_LINK:
+        case RTZIPTAR_TF_SYMLINK:
+        {
+            RTVFSSYMLINK        hVfsSym;
+            PRTZIPTARBASEOBJ    pBaseObjData;
+            rc = RTVfsNewSymlink(&g_rtZipTarFssSymOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsSym,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->offHdr  = off;
+            pBaseObjData->Hdr     = Hdr;
+            pBaseObjData->ObjInfo = Info;
+
+            enmType = RTVFSOBJTYPE_SYMLINK;
+            hVfsObj = RTVfsObjFromSymlink(hVfsSym);
+            RTVfsSymlinkRelease(hVfsSym);
+            break;
+        }
+
+        /*
+         * All other objects are repesented using a VFS base object since they
+         * carry no data streams (unless some tar extension implements extended
+         * attributes / alternative streams).
+         */
+        case RTZIPTAR_TF_CHR:
+        case RTZIPTAR_TF_BLK:
+        case RTZIPTAR_TF_DIR:
+        case RTZIPTAR_TF_FIFO:
+        {
+            PRTZIPTARBASEOBJ pBaseObjData;
+            rc = RTVfsNewBaseObj(&g_rtZipTarFssBaseObjOps,
+                                 sizeof(*pBaseObjData),
+                                 NIL_RTVFS,
+                                 NIL_RTVFSLOCK,
+                                 &hVfsObj,
+                                 (void **)&pBaseObjData);
+            if (RT_FAILURE(rc))
+                return pThis->rcFatal = rc;
+
+            pBaseObjData->offHdr  = off;
+            pBaseObjData->Hdr     = Hdr;
+            pBaseObjData->ObjInfo = Info;
+
+            enmType = RTVFSOBJTYPE_BASE;
+            break;
+        }
+
+        default:
+            AssertFailed();
+            return pThis->rcFatal = VERR_INTERNAL_ERROR_5;
+    }
+    pThis->hVfsCurObj = hVfsObj;
+
+    /*
+     * Set the return data and we're done.
+     */
+    if (ppszName)
+    {
+        if (rtZipTarHdrHasPrefix(&Hdr))
+        {
+            *ppszName = NULL;
+            rc = RTStrAAppendExN(ppszName, 2, Hdr.Posix.prefix, Hdr.Posix.name);
+        }
+        else
+            rc = RTStrDupEx(ppszName, Hdr.Posix.name);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    if (phVfsObj)
+    {
+        RTVfsObjRetain(hVfsObj);
+        *phVfsObj = hVfsObj;
+    }
+
+    if (penmType)
+        *penmType = enmType;
+
+    return VINF_SUCCESS;
 }
 
@@ -548 +826 @@
     PRTZIPTARFSSTREAM pThis;
     RTVFSFSSTREAM     hVfsFss;
-    int rc = RTVfsNewFsStream(&rtZipTarFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTSEMRW, &hVfsFss, (void **)&pThis);
+    int rc = RTVfsNewFsStream(&rtZipTarFssOps, sizeof(*pThis), NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFss, (void **)&pThis);
     if (RT_SUCCESS(rc))
     {