VirtualBox

Changeset 66742 in vbox for trunk/src/VBox/Runtime


Ignore:
Timestamp:
May 2, 2017 9:37:06 AM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
115148
Message:

fatvfs,iso9660vfs,vfsbase: Sorted volume reference fun. Volumes will be freed now.

Location:
trunk/src/VBox/Runtime
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r66736 r66742  
    2929*   Header Files                                                                                                                 *
    3030*********************************************************************************************************************************/
     31#define LOG_GROUP RTLOGGROUP_FS
    3132#include "internal/iprt.h"
    3233#include <iprt/fsvfs.h>
    … …  
    3738#include <iprt/file.h>
    3839#include <iprt/err.h>
     40#include <iprt/log.h>
    3941#include <iprt/mem.h>
    4042#include <iprt/path.h>
    … …  
    36513653
    36523654    PRTFSFATDIR pNewDir;
    3653     int rc = RTVfsNewDir(&g_rtFsFatDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/,
    3654                          phVfsDir, (void **)&pNewDir);
     3655    int rc = RTVfsNewDir(&g_rtFsFatDirOps, sizeof(*pNewDir), pParentDir ? 0 : RTVFSDIR_F_NO_VFS_REF,
     3656                         pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/, phVfsDir, (void **)&pNewDir);
    36553657    if (RT_SUCCESS(rc))
    36563658    {
    … …  
    37723774{
    37733775    PRTFSFATVOL pThis = (PRTFSFATVOL)pvThis;
     3776    LogFlow(("rtFsFatVol_Close(%p)\n", pThis));
    37743777    int rc = rtFsFatClusterMap_Destroy(pThis);
    37753778

  • trunk/src/VBox/Runtime/common/fs/iso9660vfs.cpp

    r66736 r66742  
    918918{
    919919    RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir);
    920 RTAssertMsg2("%s: %s\n", __FUNCTION__, pszSubDir);
    921     return VERR_NOT_IMPLEMENTED;
     920    return VERR_WRITE_PROTECT;
    922921}
    923922
    … …  
    941940{
    942941    RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink);
    943 RTAssertMsg2("%s: %s\n", __FUNCTION__, pszSymlink);
    944     return VERR_NOT_SUPPORTED;
     942    return VERR_WRITE_PROTECT;
    945943}
    946944
    … …  
    952950{
    953951    RT_NOREF(pvThis, pszEntry, fType);
    954 RTAssertMsg2("%s: %s\n", __FUNCTION__, pszEntry);
    955     return VERR_NOT_IMPLEMENTED;
     952    return VERR_WRITE_PROTECT;
    956953}
    957954
    … …  
    972969 */
    973970static DECLCALLBACK(int) rtFsIso9660Dir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
    974                                             RTFSOBJATTRADD enmAddAttr)
     971                                                RTFSOBJATTRADD enmAddAttr)
    975972{
    976973    RT_NOREF(pvThis, pDirEntry, pcbDirEntry, enmAddAttr);
    … …  
    11901187
    11911188    PRTFSISO9660DIR pNewDir;
    1192     int rc = RTVfsNewDir(&g_rtFsIso9660DirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/,
    1193                          phVfsDir, (void **)&pNewDir);
     1189    int rc = RTVfsNewDir(&g_rtFsIso9660DirOps, sizeof(*pNewDir), pParentDir ? 0 : RTVFSDIR_F_NO_VFS_REF,
     1190                         pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/, phVfsDir, (void **)&pNewDir);
    11941191    if (RT_SUCCESS(rc))
    11951192    {
    … …  
    12411238{
    12421239    PRTFSISO9660VOL pThis = (PRTFSISO9660VOL)pvThis;
    1243     LogFlow(("rtFsIso9660Vol_Close(%p)\n", pThis));
     1240    Log(("rtFsIso9660Vol_Close(%p)\n", pThis));
    12441241
    12451242    if (pThis->hVfsRootDir != NIL_RTVFSDIR)

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

    r66741 r66742  
    180180{
    181181    /** The VFS magic (RTVFSOBJ_MAGIC). */
    182     uint32_t                uMagic;
     182    uint32_t                uMagic : 31;
     183    /** Set if we've got no VFS reference but still got a valid hVfs.
     184     * This is hack for permanent root directory objects. */
     185    uint32_t                fNoVfsRef : 1;
    183186    /** The number of references to this VFS object. */
    184187    uint32_t volatile       cRefs;
    … …  
    188191    PCRTVFSOBJOPS           pOps;
    189192    /** The lock protecting all access to the VFS.
    190      * Only valid RTVFS_C_THREAD_SAFE is set, otherwise it is NIL_RTVFSLOCK. */
     193     * Only valid if RTVFS_C_THREAD_SAFE is set, otherwise it is NIL_RTVFSLOCK. */
    191194    RTVFSLOCK               hLock;
    192195    /** Reference back to the VFS containing this object. */
    … …  
    344347
    345348
     349/*********************************************************************************************************************************
     350*   Internal Functions                                                                                                           *
     351*********************************************************************************************************************************/
     352DECLINLINE(uint32_t) rtVfsObjRelease(RTVFSOBJINTERNAL *pThis);
     353
     354
    346355
    347356/*
    … …  
    661670 *
    662671 * @param   pThis               The base object handle data.
    663  */
    664 DECLINLINE(void) rtVfsObjRetainVoid(RTVFSOBJINTERNAL *pThis)
     672 * @param   pszCaller           Where we're called from.
     673 */
     674DECLINLINE(void) rtVfsObjRetainVoid(RTVFSOBJINTERNAL *pThis, const char *pszCaller)
    665675{
    666676    uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
     677LogFlow(("rtVfsObjRetainVoid(%p/%p) -> %d;  caller=%s\n", pThis, pThis->pvThis, cRefs, pszCaller)); RT_NOREF(pszCaller);
    667678    AssertMsg(cRefs > 1 && cRefs < _1M,
    668               ("%#x %p ops=%p %s (%d)\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType));
     679              ("%#x %p ops=%p %s (%d); caller=%s\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType, pszCaller));
    669680    NOREF(cRefs);
    670681}
    … …  
    678689 * @param   pObjOps             The base object vtable.
    679690 * @param   hVfs                The VFS handle to associate with.
     691 * @param   fNoVfsRef           If set, do not retain an additional reference to
     692 *                              @a hVfs.  Permanent root dir hack.
    680693 * @param   hLock               The lock handle, pseudo handle or nil.
    681694 * @param   pvThis              Pointer to the private data.
    682695 */
    683 static int rtVfsObjInitNewObject(RTVFSOBJINTERNAL *pThis, PCRTVFSOBJOPS pObjOps, RTVFS hVfs, RTVFSLOCK hLock, void *pvThis)
     696static int rtVfsObjInitNewObject(RTVFSOBJINTERNAL *pThis, PCRTVFSOBJOPS pObjOps, RTVFS hVfs, bool fNoVfsRef,
     697                                 RTVFSLOCK hLock, void *pvThis)
    684698{
    685699    /*
    … …  
    732746     * Do the actual initializing.
    733747     */
    734     pThis->uMagic  = RTVFSOBJ_MAGIC;
    735     pThis->pvThis  = pvThis;
    736     pThis->pOps    = pObjOps;
    737     pThis->cRefs   = 1;
    738     pThis->hVfs    = hVfs;
    739     pThis->hLock   = hLock;
    740     if (hVfs != NIL_RTVFS)
    741         rtVfsObjRetainVoid(&hVfs->Base);
     748    pThis->uMagic       = RTVFSOBJ_MAGIC;
     749    pThis->fNoVfsRef    = fNoVfsRef;
     750    pThis->pvThis       = pvThis;
     751    pThis->pOps         = pObjOps;
     752    pThis->cRefs        = 1;
     753    pThis->hVfs         = hVfs;
     754    pThis->hLock        = hLock;
     755    if (hVfs != NIL_RTVFS && !fNoVfsRef)
     756        rtVfsObjRetainVoid(&hVfs->Base, "rtVfsObjInitNewObject");
    742757
    743758    return VINF_SUCCESS;
    … …  
    769784        return VERR_NO_MEMORY;
    770785
    771     int rc = rtVfsObjInitNewObject(pThis, pObjOps, hVfs, hLock,
     786    int rc = rtVfsObjInitNewObject(pThis, pObjOps, hVfs, false /*fNoVfsRef*/, hLock,
    772787                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    773788    if (RT_FAILURE(rc))
    … …  
    792807{
    793808    uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
     809LogFlow(("rtVfsObjRetain(%p/%p) -> %d\n", pThis, pThis->pvThis, cRefs));
    794810    AssertMsg(cRefs > 1 && cRefs < _1M,
    795811              ("%#x %p ops=%p %s (%d)\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType));
    … …  
    898914        /* no default as we want gcc warnings. */
    899915    }
    900     ASMAtomicWriteU32(&pThis->uMagic, RTVFSOBJ_MAGIC_DEAD);
     916    pThis->uMagic = RTVFSOBJ_MAGIC_DEAD;
    901917    RTVfsLockReleaseWrite(pThis->hLock);
    902918
    … …  
    906922    int rc = pThis->pOps->pfnClose(pThis->pvThis);
    907923    AssertRC(rc);
     924    if (pThis->hVfs != NIL_RTVFS)
     925    {
     926        if (!pThis->fNoVfsRef)
     927            rtVfsObjRelease(&pThis->hVfs->Base);
     928        pThis->hVfs = NIL_RTVFS;
     929    }
    908930    RTMemFree(pvToFree);
    909931}
    … …  
    920942    uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
    921943    AssertMsg(cRefs < _1M, ("%#x %p ops=%p %s (%d)\n", cRefs, pThis, pThis->pOps, pThis->pOps->pszName, pThis->pOps->enmType));
     944    LogFlow(("rtVfsObjRelease(%p/%p) -> %d\n", pThis, pThis->pvThis, cRefs));
    922945    if (cRefs == 0)
    923946        rtVfsObjDestroy(pThis);
    … …  
    947970        if (pThis->pOps->enmType == RTVFSOBJTYPE_VFS)
    948971        {
    949             rtVfsObjRetainVoid(pThis);
     972            rtVfsObjRetainVoid(pThis, "RTVfsObjToVfs");
    950973            LogFlow(("RTVfsObjToVfs(%p) -> %p\n", pThis, RT_FROM_MEMBER(pThis, RTVFSINTERNAL, Base)));
    951974            return RT_FROM_MEMBER(pThis, RTVFSINTERNAL, Base);
    … …  
    966989        if (pThis->pOps->enmType == RTVFSOBJTYPE_FS_STREAM)
    967990        {
    968             rtVfsObjRetainVoid(pThis);
     991            rtVfsObjRetainVoid(pThis, "RTVfsObjToFsStream");
    969992            return RT_FROM_MEMBER(pThis, RTVFSFSSTREAMINTERNAL, Base);
    970993        }
    … …  
    9841007        if (pThis->pOps->enmType == RTVFSOBJTYPE_DIR)
    9851008        {
    986             rtVfsObjRetainVoid(pThis);
     1009            rtVfsObjRetainVoid(pThis, "RTVfsObjToDir");
    9871010            return RT_FROM_MEMBER(pThis, RTVFSDIRINTERNAL, Base);
    9881011        }
    … …  
    10031026            || pThis->pOps->enmType == RTVFSOBJTYPE_FILE)
    10041027        {
    1005             rtVfsObjRetainVoid(pThis);
     1028            rtVfsObjRetainVoid(pThis, "RTVfsObjToIoStream");
    10061029            return RT_FROM_MEMBER(pThis, RTVFSIOSTREAMINTERNAL, Base);
    10071030        }
    … …  
    10211044        if (pThis->pOps->enmType == RTVFSOBJTYPE_FILE)
    10221045        {
    1023             rtVfsObjRetainVoid(pThis);
     1046            rtVfsObjRetainVoid(pThis, "RTVfsObjToFile");
    10241047            return RT_FROM_MEMBER(pThis, RTVFSFILEINTERNAL, Stream.Base);
    10251048        }
    … …  
    10391062        if (pThis->pOps->enmType == RTVFSOBJTYPE_SYMLINK)
    10401063        {
    1041             rtVfsObjRetainVoid(pThis);
     1064            rtVfsObjRetainVoid(pThis, "RTVfsObjToSymlink");
    10421065            return RT_FROM_MEMBER(pThis, RTVFSSYMLINKINTERNAL, Base);
    10431066        }
    … …  
    10551078        AssertReturn(pThis->uMagic == RTVFSOBJ_MAGIC, NIL_RTVFSOBJ);
    10561079
    1057         rtVfsObjRetainVoid(pThis);
     1080        rtVfsObjRetainVoid(pThis, "RTVfsObjFromVfs");
    10581081        LogFlow(("RTVfsObjFromVfs(%p) -> %p\n", hVfs, pThis));
    10591082        return pThis;
    … …  
    10711094        AssertReturn(pThis->uMagic == RTVFSOBJ_MAGIC, NIL_RTVFSOBJ);
    10721095
    1073         rtVfsObjRetainVoid(pThis);
     1096        rtVfsObjRetainVoid(pThis, "RTVfsObjFromFsStream");
    10741097        return pThis;
    10751098    }
    … …  
    10861109        AssertReturn(pThis->uMagic == RTVFSOBJ_MAGIC, NIL_RTVFSOBJ);
    10871110
    1088         rtVfsObjRetainVoid(pThis);
     1111        rtVfsObjRetainVoid(pThis, "RTVfsObjFromDir");
    10891112        return pThis;
    10901113    }
    … …  
    11011124        AssertReturn(pThis->uMagic == RTVFSOBJ_MAGIC, NIL_RTVFSOBJ);
    11021125
    1103         rtVfsObjRetainVoid(pThis);
     1126        rtVfsObjRetainVoid(pThis, "RTVfsObjFromIoStream");
    11041127        return pThis;
    11051128    }
    … …  
    11161139        AssertReturn(pThis->uMagic == RTVFSOBJ_MAGIC, NIL_RTVFSOBJ);
    11171140
    1118         rtVfsObjRetainVoid(pThis);
     1141        rtVfsObjRetainVoid(pThis, "RTVfsObjFromFile");
    11191142        return pThis;
    11201143    }
    … …  
    11311154        AssertReturn(pThis->uMagic == RTVFSOBJ_MAGIC, NIL_RTVFSOBJ);
    11321155
    1133         rtVfsObjRetainVoid(pThis);
     1156        rtVfsObjRetainVoid(pThis, "RTVfsObjFromSymlink");
    11341157        return pThis;
    11351158    }
    … …  
    17181741        return VERR_NO_MEMORY;
    17191742
    1720     int rc = rtVfsObjInitNewObject(&pThis->Base, &pVfsOps->Obj, hVfs, hLock,
     1743    int rc = rtVfsObjInitNewObject(&pThis->Base, &pVfsOps->Obj, hVfs, false /*fNoVfsRef*/, hLock,
    17211744                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    17221745    if (RT_FAILURE(rc))
    … …  
    17321755    *ppvInstance = pThis->Base.pvThis;
    17331756
     1757    LogFlow(("RTVfsNew -> VINF_SUCCESS; hVfs=%p pvThis=%p\n", pThis, pThis->Base.pvThis));
    17341758    return VINF_SUCCESS;
    17351759}
    … …  
    18501874        return VERR_NO_MEMORY;
    18511875
    1852     int rc = rtVfsObjInitNewObject(&pThis->Base, &pFsStreamOps->Obj, hVfs, hLock,
     1876    int rc = rtVfsObjInitNewObject(&pThis->Base, &pFsStreamOps->Obj, hVfs, false /*fNoVfsRef*/, hLock,
    18531877                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    18541878
    … …  
    19551979    RTVFSDIR_ASSERT_OPS(pDirOps, RTVFSOBJTYPE_DIR);
    19561980    Assert(cbInstance > 0);
    1957     AssertReturn(!fFlags, VERR_INVALID_FLAGS);
     1981    AssertReturn(!(fFlags & ~RTVFSDIR_F_NO_VFS_REF), VERR_INVALID_FLAGS);
    19581982    AssertPtr(ppvInstance);
    19591983    AssertPtr(phVfsDir);
    … …  
    19691993        return VERR_NO_MEMORY;
    19701994
    1971     int rc = rtVfsObjInitNewObject(&pThis->Base, &pDirOps->Obj, hVfs, hLock,
     1995    int rc = rtVfsObjInitNewObject(&pThis->Base, &pDirOps->Obj, hVfs, RT_BOOL(fFlags & RTVFSDIR_F_NO_VFS_REF), hLock,
    19721996                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    19731997    if (RT_FAILURE(rc))
    … …  
    22162240        return VERR_NO_MEMORY;
    22172241
    2218     int rc = rtVfsObjInitNewObject(&pThis->Base, &pSymlinkOps->Obj, hVfs, hLock,
     2242    int rc = rtVfsObjInitNewObject(&pThis->Base, &pSymlinkOps->Obj, hVfs, false /*fNoVfsRef*/, hLock,
    22192243                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    22202244    if (RT_FAILURE(rc))
    … …  
    23692393        return VERR_NO_MEMORY;
    23702394
    2371     int rc = rtVfsObjInitNewObject(&pThis->Base, &pIoStreamOps->Obj, hVfs, hLock,
     2395    int rc = rtVfsObjInitNewObject(&pThis->Base, &pIoStreamOps->Obj, hVfs, false /*fNoVfsRef*/, hLock,
    23722396                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    23732397    if (RT_FAILURE(rc))
    … …  
    24412465    if (pThis->pOps->Obj.enmType == RTVFSOBJTYPE_FILE)
    24422466    {
    2443         rtVfsObjRetainVoid(&pThis->Base);
     2467        rtVfsObjRetainVoid(&pThis->Base, "RTVfsIoStrmToFile");
    24442468        return RT_FROM_MEMBER(pThis, RTVFSFILEINTERNAL, Stream);
    24452469    }
    … …  
    28252849        return VERR_NO_MEMORY;
    28262850
    2827     int rc = rtVfsObjInitNewObject(&pThis->Stream.Base, &pFileOps->Stream.Obj, hVfs, hLock,
     2851    int rc = rtVfsObjInitNewObject(&pThis->Stream.Base, &pFileOps->Stream.Obj, hVfs, false /*fNoVfsRef*/, hLock,
    28282852                                   (char *)pThis + RT_ALIGN_Z(sizeof(*pThis), RTVFS_INST_ALIGNMENT));
    28292853    if (RT_FAILURE(rc))
    … …  
    29442968    AssertReturn(pThis->uMagic == RTVFSFILE_MAGIC, NIL_RTVFSIOSTREAM);
    29452969
    2946     rtVfsObjRetainVoid(&pThis->Stream.Base);
     2970    rtVfsObjRetainVoid(&pThis->Stream.Base, "RTVfsFileToIoStream");
    29472971    return &pThis->Stream;
    29482972}

  • trunk/src/VBox/Runtime/common/vfs/vfschain.cpp

    r66675 r66742  
    218218            RTVFSFILE hVfsFile = NIL_RTVFSFILE;
    219219            int rc = RTVfsFileOpen(hVfsIn, pElement->paArgs[0].psz, pElement->uProvider, &hVfsFile);
     220            RTVfsRelease(hVfsIn);
    220221            if (RT_SUCCESS(rc))
    221222            {
    … …  
    232233            RTVFSDIR hVfsDir = NIL_RTVFSDIR;
    233234            int rc = RTVfsDirOpen(hVfsIn, pElement->paArgs[0].psz, (uint32_t)pElement->uProvider, &hVfsDir);
     235            RTVfsRelease(hVfsIn);
    234236            if (RT_SUCCESS(rc))
    235237            {
    … …  
    242244            return rc;
    243245        }
     246        RTVfsRelease(hVfsIn);
    244247        return VERR_VFS_CHAIN_IPE;
    245248    }
    … …  
    256259            RTVFSFILE hVfsFile = NIL_RTVFSFILE;
    257260            int rc = RTVfsDirOpenFile(hVfsDirIn, pElement->paArgs[0].psz, pElement->uProvider, &hVfsFile);
     261            RTVfsDirRelease(hVfsDirIn);
    258262            if (RT_SUCCESS(rc))
    259263            {
    … …  
    270274            RTVFSDIR hVfsDir = NIL_RTVFSDIR;
    271275            int rc = RTVfsDirOpenDir(hVfsDirIn, pElement->paArgs[0].psz, pElement->uProvider, &hVfsDir);
     276            RTVfsDirRelease(hVfsDirIn);
    272277            if (RT_SUCCESS(rc))
    273278            {
    … …  
    280285            return rc;
    281286        }
     287        RTVfsDirRelease(hVfsDirIn);
    282288        return VERR_VFS_CHAIN_IPE;
    283289    }

  • trunk/src/VBox/Runtime/include/internal/magics.h

    r62477 r66742  
    209209/** The value of RTVFSOBJINTERNAL::u32Magic. (Yasunari Kawabata) */
    210210#define RTVFSOBJ_MAGIC                  UINT32_C(0x18990614)
    211 /** The value of RTVFSOBJINTERNAL::u32Magic arter close. */
     211/** The value of RTVFSOBJINTERNAL::u32Magic after close. */
    212212#define RTVFSOBJ_MAGIC_DEAD             UINT32_C(0x19720416)
    213213/** The value of RTVFSINTERNAL::u32Magic. (Sir Kingsley William Amis) */
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette