VirtualBox

Ignore:
Timestamp:
May 31, 2022 10:14:03 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
151635
Message:

Frontends + Main: Adjust to the new rules wrt. to rc -> hrc,vrc usage. This also fixes quite a few bugs wrt shadow variables, wrong return values and output error translations / exit codes. Also see @todos added [build fix, cleanup for VBoxImgMount mess] ​bugref:10223

Location:
trunk/src/VBox/ImageMounter/vboximg-mount
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ImageMounter/vboximg-mount/vboximg-mount.cpp

    r95142 r95144  
    271271vboximgOptHandler(void *data, const char *arg, int optKey, struct fuse_args *outargs)
    272272{
    273     NOREF(data);
    274     NOREF(arg);
    275     NOREF(optKey);
    276     NOREF(outargs);
     273    RT_NOREF(data);
     274    RT_NOREF(arg);
     275    RT_NOREF(optKey);
     276    RT_NOREF(outargs);
    277277
    278278    /*
    … …  
    313313                /* Retrieve the accessed volume and return the stat data. */
    314314                uint32_t idxVol;
    315                 int rcIprt = RTStrToUInt32Full(&pPathSplit->apszComps[1][3], 10, &idxVol);
    316                 if (   rcIprt == VINF_SUCCESS
     315                int vrc = RTStrToUInt32Full(&pPathSplit->apszComps[1][3], 10, &idxVol);
     316                if (   vrc == VINF_SUCCESS
    317317                    && idxVol < g_cVolumes
    318318                    && g_paVolumes[idxVol].hVfsFileVol != NIL_RTVFSFILE)
    … …  
    325325                /* Retrieve the accessed volume and return the stat data. */
    326326                uint32_t idxVol;
    327                 int rcIprt = RTStrToUInt32Full(&pPathSplit->apszComps[1][2], 10, &idxVol);
    328                 if (   rcIprt == VINF_SUCCESS
     327                int vrc = RTStrToUInt32Full(&pPathSplit->apszComps[1][2], 10, &idxVol);
     328                if (   vrc == VINF_SUCCESS
    329329                    && idxVol < g_cVolumes
    330330                    && g_paVolumes[idxVol].hVfsDirRoot != NIL_RTVFSDIR)
    … …  
    390390
    391391    RTVFSOBJ hVfsObj;
    392     int rcIprt = vboxImgMntVfsObjQueryFromPath(pszPath, &hVfsObj);
    393     if (RT_SUCCESS(rc))
     392    int vrc = vboxImgMntVfsObjQueryFromPath(pszPath, &hVfsObj);
     393    if (RT_SUCCESS(vrc))
    394394    {
    395395        uint32_t fNotSup = 0;
    … …  
    420420# endif
    421421#endif
    422 
    423422            if (!rc)
    424423            {
    … …  
    433432    }
    434433    else
    435         rc = -RTErrConvertToErrno(rcIprt);
     434        rc = -RTErrConvertToErrno(vrc);
    436435
    437436    LogFlowFunc(("rc=%d \"%s\"\n", rc, pszPath));
    … …  
    443442static int vboximgOp_release(const char *pszPath, struct fuse_file_info *pInfo)
    444443{
    445     NOREF(pszPath);
     444    RT_NOREF(pszPath);
    446445
    447446    LogFlowFunc(("pszPath=%s\n", pszPath));
    … …  
    457456/** @copydoc fuse_operations::read */
    458457static int vboximgOp_read(const char *pszPath, char *pbBuf, size_t cbBuf,
    459                            off_t offset, struct fuse_file_info *pInfo)
    460 {
    461     NOREF(pszPath);
     458                          off_t offset, struct fuse_file_info *pInfo)
     459{
     460    RT_NOREF(pszPath);
    462461
    463462    LogFlowFunc(("offset=%#llx size=%#zx path=\"%s\"\n", (uint64_t)offset, cbBuf, pszPath));
    … …  
    475474            size_t cbRead = 0;
    476475            RTVFSFILE hVfsFile = RTVfsObjToFile(hVfsObj);
    477             int rcIprt = RTVfsFileReadAt(hVfsFile, offset, pbBuf, cbBuf, &cbRead);
     476            int vrc = RTVfsFileReadAt(hVfsFile, offset, pbBuf, cbBuf, &cbRead);
    478477            if (cbRead)
    479478                rc = cbRead;
    480             else if (rcIprt == VINF_EOF)
     479            else if (vrc == VINF_EOF)
    481480                rc = -RTErrConvertToErrno(VERR_EOF);
    482481            RTVfsFileRelease(hVfsFile);
    … …  
    496495                           off_t offset, struct fuse_file_info *pInfo)
    497496{
    498     NOREF(pszPath);
    499     NOREF(pInfo);
     497    RT_NOREF(pszPath);
     498    RT_NOREF(pInfo);
    500499
    501500    LogFlowFunc(("offset=%#llx size=%#zx path=\"%s\"\n", (uint64_t)offset, cbBuf, pszPath));
    … …  
    520519            size_t cbWritten = 0;
    521520            RTVFSFILE hVfsFile = RTVfsObjToFile(hVfsObj);
    522             int rcIprt = RTVfsFileWriteAt(hVfsFile, offset, pbBuf, cbBuf, &cbWritten);
     521            int vrc = RTVfsFileWriteAt(hVfsFile, offset, pbBuf, cbBuf, &cbWritten);
    523522            if (cbWritten)
    524523                rc = cbWritten;
    525             else if (rcIprt == VINF_EOF)
     524            else if (vrc == VINF_EOF)
    526525                rc = -RTErrConvertToErrno(VERR_EOF);
    527526            RTVfsFileRelease(hVfsFile);
    … …  
    539538
    540539/** @copydoc fuse_operations::getattr */
    541 static int
    542 vboximgOp_getattr(const char *pszPath, struct stat *stbuf)
     540static int vboximgOp_getattr(const char *pszPath, struct stat *stbuf)
    543541{
    544542    int rc = 0;
    … …  
    577575        /* Query the VFS object and fill in the data. */
    578576        RTVFSOBJ hVfsObj = NIL_RTVFSOBJ;
    579         int rcIprt = vboxImgMntVfsObjQueryFromPath(pszPath, &hVfsObj);
    580         if (RT_SUCCESS(rcIprt))
     577        int vrc = vboxImgMntVfsObjQueryFromPath(pszPath, &hVfsObj);
     578        if (RT_SUCCESS(vrc))
    581579        {
    582580            RTFSOBJINFO ObjInfo;
    583581
    584             rcIprt = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_UNIX);
    585             if (RT_SUCCESS(rcIprt))
     582            vrc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_UNIX);
     583            if (RT_SUCCESS(vrc))
    586584            {
    587585                stbuf->st_size  = ObjInfo.cbObject;
    … …  
    696694            RTVfsObjRelease(hVfsObj);
    697695        }
    698         else if (rcIprt == VERR_NOT_FOUND)
     696        else if (vrc == VERR_NOT_FOUND)
    699697            rc = -ENOENT;
    700698        else
    701             rc = -RTErrConvertToErrno(rcIprt);
     699            rc = -RTErrConvertToErrno(vrc);
    702700    }
    703701
    … …  
    706704
    707705/** @copydoc fuse_operations::readdir */
    708 static int
    709 vboximgOp_readdir(const char *pszPath, void *pvBuf, fuse_fill_dir_t pfnFiller,
    710                               off_t offset, struct fuse_file_info *pInfo)
    711 
     706static int vboximgOp_readdir(const char *pszPath, void *pvBuf, fuse_fill_dir_t pfnFiller,
     707                             off_t offset, struct fuse_file_info *pInfo)
    712708{
    713709    RT_NOREF(offset);
    … …  
    768764        /* Query the VFS object and fill in the data. */
    769765        RTVFSOBJ hVfsObj = NIL_RTVFSOBJ;
    770         int rcIprt = vboxImgMntVfsObjQueryFromPath(pszPath, &hVfsObj);
    771         if (RT_SUCCESS(rcIprt))
     766        int vrc = vboxImgMntVfsObjQueryFromPath(pszPath, &hVfsObj);
     767        if (RT_SUCCESS(vrc))
    772768        {
    773769            switch (RTVfsObjGetType(hVfsObj))
    … …  
    778774                    RTDIRENTRYEX DirEntry;
    779775
    780                     rcIprt = RTVfsDirRewind(hVfsDir); AssertRC(rcIprt);
    781                     rcIprt = RTVfsDirReadEx(hVfsDir, &DirEntry, NULL, RTFSOBJATTRADD_NOTHING);
    782                     while (RT_SUCCESS(rcIprt))
     776                    vrc = RTVfsDirRewind(hVfsDir); AssertRC(vrc);
     777                    vrc = RTVfsDirReadEx(hVfsDir, &DirEntry, NULL, RTFSOBJATTRADD_NOTHING);
     778                    while (RT_SUCCESS(vrc))
    783779                    {
    784780                        pfnFiller(pvBuf, DirEntry.szName, NULL, 0);
    785                         rcIprt = RTVfsDirReadEx(hVfsDir, &DirEntry, NULL, RTFSOBJATTRADD_NOTHING);
     781                        vrc = RTVfsDirReadEx(hVfsDir, &DirEntry, NULL, RTFSOBJATTRADD_NOTHING);
    786782                    }
    787783
    … …  
    796792        }
    797793        else
    798             rc = -RTErrConvertToErrno(rcIprt);
     794            rc = -RTErrConvertToErrno(vrc);
    799795    }
    800796
    … …  
    803799
    804800/** @copydoc fuse_operations::readlink */
    805 static int
    806 vboximgOp_readlink(const char *pszPath, char *buf, size_t size)
    807 {
    808     NOREF(pszPath);
     801static int vboximgOp_readlink(const char *pszPath, char *buf, size_t size)
     802{
     803    RT_NOREF(pszPath);
    809804    RTStrCopy(buf, size, g_pszImagePath);
    810805    return 0;
    … …  
    990985    if (g_vboximgOpts.pszImageUuidOrPath)
    991986    {
    992         HRESULT hrc;
    993 
    994987        /* compiler was too fussy about access mode's data type in conditional expr, so... */
    995988        if (g_vboximgOpts.fRW)
    … …  
    11891182/* **************** END IFDEF'D (STUBBED-OUT) CODE ***************** */
    11901183
    1191     int rc = RTCritSectInit(&g_vdioLock);
    1192     if (RT_SUCCESS(rc))
     1184    int vrc = RTCritSectInit(&g_vdioLock);
     1185    if (RT_SUCCESS(vrc))
    11931186    {
    11941187        g_VDIfThreadSync.pfnStartRead   = vboximgThreadStartRead;
    … …  
    11961189        g_VDIfThreadSync.pfnStartWrite  = vboximgThreadStartWrite;
    11971190        g_VDIfThreadSync.pfnFinishWrite = vboximgThreadFinishWrite;
    1198         rc = VDInterfaceAdd(&g_VDIfThreadSync.Core, "vboximg_ThreadSync", VDINTERFACETYPE_THREADSYNC,
    1199                             &g_vdioLock, sizeof(VDINTERFACETHREADSYNC), &g_pVdIfs);
     1191        vrc = VDInterfaceAdd(&g_VDIfThreadSync.Core, "vboximg_ThreadSync", VDINTERFACETYPE_THREADSYNC,
     1192                             &g_vdioLock, sizeof(VDINTERFACETHREADSYNC), &g_pVdIfs);
    12001193    }
    12011194    else
    12021195        return RTMsgErrorExitFailure("ERROR: Failed to create critsects "
    1203                                      "for virtual disk I/O, rc=%Rrc\n", rc);
     1196                                     "for virtual disk I/O, rc=%Rrc\n", vrc);
    12041197
    12051198   /*
    12061199     * Create HDD container to open base image and differencing images into
    12071200     */
    1208     rc = VDGetFormat(NULL /* pVDIIfsDisk */, NULL /* pVDIIfsImage*/,
    1209                      CSTR(pVDiskBaseImagePath), VDTYPE_INVALID, &pszFormat, &enmType);
    1210 
    1211     if (RT_FAILURE(rc))
     1201    vrc = VDGetFormat(NULL /* pVDIIfsDisk */, NULL /* pVDIIfsImage*/,
     1202                      CSTR(pVDiskBaseImagePath), VDTYPE_INVALID, &pszFormat, &enmType);
     1203
     1204    if (RT_FAILURE(vrc))
    12121205        return RTMsgErrorExitFailure("VDGetFormat(,,%s,,) "
    1213             "failed (during HDD container creation), rc=%Rrc\n", g_pszImagePath, rc);
     1206            "failed (during HDD container creation), rc=%Rrc\n", g_pszImagePath, vrc);
    12141207
    12151208    if (VERBOSE)
    … …  
    12171210
    12181211    PVDISK pVDisk = NULL;
    1219     rc = VDCreate(g_pVdIfs, enmType, &pVDisk);
    1220     if ((rc))
     1212    vrc = VDCreate(g_pVdIfs, enmType, &pVDisk);
     1213    if (RT_FAILURE(vrc))
    12211214        return RTMsgErrorExitFailure("ERROR: Couldn't create virtual disk container\n");
    12221215
    … …  
    12321225            RTPrintf("  Open: %s\n", CSTR(pCurMedium->pImagePath));
    12331226
    1234         rc = VDOpen(pVDisk,
    1235                     pszFormat,
    1236                     CSTR(pCurMedium->pImagePath),
    1237                     pCurMedium->fWriteable ? 0 : VD_OPEN_FLAGS_READONLY,
    1238                     g_pVdIfs);
    1239 
    1240         if (RT_FAILURE(rc))
     1227        vrc = VDOpen(pVDisk,
     1228                     pszFormat,
     1229                     CSTR(pCurMedium->pImagePath),
     1230                     pCurMedium->fWriteable ? 0 : VD_OPEN_FLAGS_READONLY,
     1231                     g_pVdIfs);
     1232
     1233        if (RT_FAILURE(vrc))
    12411234            return RTMsgErrorExitFailure("Could not open the medium storage unit '%s' %Rrc",
    1242                 CSTR(pCurMedium->pImagePath), rc);
     1235                                         CSTR(pCurMedium->pImagePath), vrc);
    12431236
    12441237        pCurMedium = pCurMedium->prev;
    … …  
    12481241
    12491242    /* Create the VFS file to use for the disk image access. */
    1250     rc = VDCreateVfsFileFromDisk(pVDisk, VD_VFSFILE_DESTROY_ON_RELEASE, &g_hVfsFileDisk);
    1251     if (RT_FAILURE(rc))
     1243    vrc = VDCreateVfsFileFromDisk(pVDisk, VD_VFSFILE_DESTROY_ON_RELEASE, &g_hVfsFileDisk);
     1244    if (RT_FAILURE(vrc))
    12521245        return RTMsgErrorExitFailure("Error creating VFS file wrapper for disk image\n");
    12531246
    12541247    g_cbSector = VDGetSectorSize(pVDisk, VD_LAST_IMAGE);
    12551248
    1256     rc = vboxImgMntVolumesSetup();
    1257     if (RT_FAILURE(rc))
     1249    vrc = vboxImgMntVolumesSetup();
     1250    if (RT_FAILURE(vrc))
    12581251        return RTMsgErrorExitFailure("Error parsing volumes on disk\n");
    12591252
    … …  
    12651258        RTPrintf("\n");
    12661259        vboxImgMntVolumesDisplay();
    1267         return 0;
     1260        return VINF_SUCCESS; /** @todo r=andy Re-visit this. */
    12681261    }
    12691262
    … …  
    12731266        for (uint32_t i = 0; i < g_cVolumes; i++)
    12741267        {
    1275             rc = RTVfsMountVol(g_paVolumes[i].hVfsFileVol,
     1268            vrc = RTVfsMountVol(g_paVolumes[i].hVfsFileVol,
    12761269                               g_vboximgOpts.fRW ? 0 : RTVFSMNT_F_READ_ONLY,
    12771270                               &g_paVolumes[i].hVfsRoot,
    12781271                               NULL);
    1279             if (RT_SUCCESS(rc))
     1272            if (RT_SUCCESS(vrc))
    12801273            {
    1281                 rc = RTVfsOpenRoot(g_paVolumes[i].hVfsRoot, &g_paVolumes[i].hVfsDirRoot);
    1282                 if (RT_FAILURE(rc))
     1274                vrc = RTVfsOpenRoot(g_paVolumes[i].hVfsRoot, &g_paVolumes[i].hVfsDirRoot);
     1275                if (RT_FAILURE(vrc))
    12831276                {
    12841277                    RTPrintf("\nvboximg-mount: Failed to access filesystem on volume %u, ignoring\n", i);
    … …  
    12981291        RTPrintf("\nvboximg-mount: Going into background...\n");
    12991292
    1300     rc = fuse_main_real(args->argc, args->argv, &g_vboximgOps, sizeof(g_vboximgOps), NULL);
     1293    int rc = fuse_main_real(args->argc, args->argv, &g_vboximgOps, sizeof(g_vboximgOps), NULL);
     1294    RTPrintf("vboximg-mount: fuse_main -> %d\n", rc);
    13011295
    13021296    int rc2 = RTVfsFileRelease(g_hVfsFileDisk);
    13031297    AssertRC(rc2);
    1304     RTPrintf("vboximg-mount: fuse_main -> %d\n", rc);
    1305     return rc;
     1298
     1299    return vrc;
    13061300}
    13071301

  • trunk/src/VBox/ImageMounter/vboximg-mount/vboximgMedia.cpp

    r95141 r95144  
    9494}
    9595
    96 static int
    97 getMediumInfo(IMachine *pMachine, IMedium *pMedium, MEDIUMINFO **ppMediumInfo)
    98 {
    99     NOREF(pMachine);
    100     int rc;
     96static int getMediumInfo(IMachine *pMachine, IMedium *pMedium, MEDIUMINFO **ppMediumInfo)
     97{
     98    RT_NOREF(pMachine);
     99
    101100    MEDIUMINFO *info = new MEDIUMINFO();
    102101    *ppMediumInfo = info;
    … …  
    114113
    115114    *pState = MediumState_NotCreated;
     115
     116    HRESULT hrc;
    116117
    117118    CHECK_ERROR(pMedium, RefreshState(pState));
    … …  
    254255static int vboximgListBranch(IMachine *pMachine, IMedium *pMedium, uint8_t nestLevel, bool fLast)
    255256{
    256     int rc;
    257257    MEDIUMINFO *pMediumInfo;
    258     rc = getMediumInfo(pMachine, pMedium, &pMediumInfo);
    259     if (FAILED(rc))
    260         return rc;
     258    int vrc = getMediumInfo(pMachine, pMedium, &pMediumInfo);
     259    if (RT_FAILURE(vrc))
     260        return vrc;
     261
    261262    displayMediumInfo(pMediumInfo, nestLevel, fLast);
     263
     264    HRESULT hrc;
    262265    com::SafeIfaceArray<IMedium> pChildren;
    263     CHECK_ERROR_RET(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(pChildren)), rc);
     266    CHECK_ERROR_RET(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(pChildren)), VERR_NOT_FOUND); /** @todo r=andy Find a better rc. */
     267
    264268    for (size_t i = 0; i < pChildren.size(); i++)
    265269        vboximgListBranch(pMachine, pChildren[i], nestLevel + 1, fLast);
     270
    266271    delete pMediumInfo;
     272
    267273    return VINF_SUCCESS;
    268274}
    269275
    270 static int
    271 listMedia(IVirtualBox *pVirtualBox, IMachine *pMachine, char *vmName, char *vmUuid)
    272 {
    273 
    274     NOREF(pVirtualBox);
    275     NOREF(vmName);
    276     NOREF(vmUuid);
    277 
    278     int rc = 0;
     276static int listMedia(IVirtualBox *pVirtualBox, IMachine *pMachine, char *vmName, char *vmUuid)
     277{
     278    RT_NOREF(pVirtualBox);
     279    RT_NOREF(vmName);
     280    RT_NOREF(vmUuid);
     281
     282    int vrc = VINF_SUCCESS;
     283
    279284    com::SafeIfaceArray<IMediumAttachment> pMediumAttachments;
    280285
     286    HRESULT hrc;
    281287    CHECK_ERROR(pMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(pMediumAttachments)));
     288
    282289    for (size_t i = 0; i < pMediumAttachments.size(); i++)
    283290    {
    … …  
    298305        else
    299306            RTPrintf("\n");
    300         rc = vboximgListBranch(pMachine, pBase, 0, fLast);
    301         if (FAILED(rc))
     307
     308        vrc = vboximgListBranch(pMachine, pBase, 0, fLast);
     309        if (RT_FAILURE(vrc))
    302310        {
    303             RTPrintf("vboximgListBranch failed %d\n", rc);
    304             return rc;
     311            RTPrintf("vboximgListBranch failed with %Rrc\n", vrc);
     312            break;
    305313        }
    306 
    307     }
    308     return VINF_SUCCESS;
     314    }
     315
     316    return vrc;
    309317}
    310318/**
    … …  
    313321 * @param virtualBox VirtualBox instance object.
    314322 */
    315 int
    316 vboximgListVMs(IVirtualBox *pVirtualBox)
    317 {
    318     HRESULT hrc = 0;
     323int vboximgListVMs(IVirtualBox *pVirtualBox)
     324{
     325    HRESULT hrc;
    319326    com::SafeIfaceArray<IMachine> pMachines;
    320327    CHECK_ERROR(pVirtualBox, COMGETTER(Machines)(ComSafeArrayAsOutParam(pMachines)));
     328
    321329    if (g_vboximgOpts.fWide)
    322330    {
    … …  
    324332        RTPrintf("VM  Image                             Size   Type          State  UUID (hierarchy)\n");
    325333    }
     334
     335    int vrc = VINF_SUCCESS;
     336
    326337    for (size_t i = 0; i < pMachines.size(); ++i)
    327338    {
    … …  
    372383                        }
    373384                    }
    374                     hrc = listMedia(pVirtualBox, pMachine,
    375                             RTStrDup(CSTR(machineName)), RTStrDup(CSTR(machineUuid)));
     385
     386                    int vrc2 = listMedia(pVirtualBox, pMachine,
     387                                         RTStrDup(CSTR(machineName)), RTStrDup(CSTR(machineUuid)));
     388                    if (RT_SUCCESS(vrc))
     389                        vrc = vrc2;
     390
    376391                    RTPrintf("\n");
    377392                }
    … …  
    379394        }
    380395    }
    381     return hrc;
    382 }
     396
     397    return vrc;
     398}
     399
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