VirtualBox

Changeset 98288 in vbox for trunk


Ignore:
Timestamp:
Jan 24, 2023 3:32:43 PM (21 months ago)
Author:
vboxsync
Message:

Main/src-server: rc -> hrc/vrc (partial). bugref:10223

Location:
trunk
Files:
43 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/VBox/com/MultiResult.h

    r98103 r98288  
    188188     * @copydoc FWResult::FWResult()
    189189     */
    190     MultiResult (HRESULT aRC = E_FAIL) : FWResult (aRC) { incCounter(); }
    191 
    192     MultiResult (const MultiResult &aThat) : FWResult (aThat)
     190    MultiResult(HRESULT aRC = E_FAIL) : FWResult (aRC) { incCounter(); }
     191
     192    MultiResult(const MultiResult &aThat) : FWResult (aThat)
    193193    {
    194194        /* We need this copy constructor only for GCC that wants to have
  • trunk/src/VBox/Main/include/ApplianceImplPrivate.h

    r98103 r98288  
    306306            LocationInfo aLocInfo,
    307307            ComObjPtr<Progress> &aProgress)
    308       : ThreadTask("TaskOVF"),
    309         pAppliance(aThat),
    310         taskType(aType),
    311         locInfo(aLocInfo),
    312         pProgress(aProgress),
    313         enFormat(ovf::OVFVersion_unknown),
    314         rc(S_OK)
     308      : ThreadTask("TaskOVF")
     309      , pAppliance(aThat)
     310      , taskType(aType)
     311      , locInfo(aLocInfo)
     312      , pProgress(aProgress)
     313      , enFormat(ovf::OVFVersion_unknown)
     314      , hrc(S_OK)
    315315    {
    316316        switch (taskType)
     
    332332    ovf::OVFVersion_T enFormat;
    333333
    334     HRESULT rc;
     334    HRESULT hrc;
    335335
    336336    void handler()
     
    352352            LocationInfo aLocInfo,
    353353            ComObjPtr<Progress> &aProgress)
    354       : ThreadTask("TaskOPC"),
    355         pAppliance(aThat),
    356         taskType(aType),
    357         locInfo(aLocInfo),
    358         pProgress(aProgress),
    359         rc(S_OK)
     354      : ThreadTask("TaskOPC")
     355      , pAppliance(aThat)
     356      , taskType(aType)
     357      , locInfo(aLocInfo)
     358      , pProgress(aProgress)
     359      , hrc(S_OK)
    360360    {
    361361        m_strTaskName = "OPCExpt";
     
    373373    ComObjPtr<Progress> pProgress;
    374374
    375     HRESULT rc;
     375    HRESULT hrc;
    376376
    377377    void handler()
     
    393393
    394394    TaskCloud(Appliance *aThat,
    395             TaskType aType,
    396             LocationInfo aLocInfo,
    397             ComObjPtr<Progress> &aProgress)
    398       : ThreadTask("TaskCloud"),
    399         pAppliance(aThat),
    400         taskType(aType),
    401         locInfo(aLocInfo),
    402         pProgress(aProgress),
    403         rc(S_OK)
     395              TaskType aType,
     396              LocationInfo aLocInfo,
     397              ComObjPtr<Progress> &aProgress)
     398      : ThreadTask("TaskCloud")
     399      , pAppliance(aThat)
     400      , taskType(aType)
     401      , locInfo(aLocInfo)
     402      , pProgress(aProgress)
     403      , hrc(S_OK)
    404404    {
    405405        switch (taskType)
     
    423423    ComObjPtr<Progress> pProgress;
    424424
    425     HRESULT rc;
     425    HRESULT hrc;
    426426
    427427    void handler()
     
    486486    // and will be cleaned up on errors
    487487    std::list<MyHardDiskAttachment> llHardDiskAttachments;      // disks that were attached
    488     std::map<Utf8Str , Utf8Str>     mapNewUUIDsToOriginalUUIDs;
     488    std::map<Utf8Str, Utf8Str>      mapNewUUIDsToOriginalUUIDs;
    489489
    490490    ImportStack(const LocationInfo &aLocInfo,
     
    533533
    534534    HRESULT restoreOriginalUUIDOfAttachedDevice(settings::MachineConfigFile *config);
    535     HRESULT saveOriginalUUIDOfAttachedDevice(settings::AttachedDevice &device,
    536                                                   const Utf8Str &newlyUuid);
     535    HRESULT saveOriginalUUIDOfAttachedDevice(settings::AttachedDevice &device, const Utf8Str &newlyUuid);
    537536    RTVFSIOSTREAM claimOvaLookAHead(void);
    538 
    539537};
    540538
     
    547545struct VirtualSystemDescription::Data
    548546{
    549     std::vector<VirtualSystemDescriptionEntry>
    550                             maDescriptions;     // item descriptions
    551 
    552     ComPtr<Machine>         pMachine;           // VirtualBox machine this description was exported from (export only)
    553 
    554     settings::MachineConfigFile
    555                             *pConfig;           // machine config created from <vbox:Machine> element if found (import only)
     547    /** item descriptions */
     548    std::vector<VirtualSystemDescriptionEntry> maDescriptions;
     549
     550    /** VirtualBox machine this description was exported from (export only) */
     551    ComPtr<Machine> pMachine;
     552
     553    /** machine config created from <vbox:Machine> element if found (import only) */
     554    settings::MachineConfigFile *pConfig;
    556555};
    557556
  • trunk/src/VBox/Main/include/MachineImpl.h

    r98103 r98288  
    604604    HRESULT i_getDirectControl(ComPtr<IInternalSessionControl> *directControl)
    605605    {
    606         HRESULT rc;
    607606        *directControl = mData->mSession.mDirectControl;
    608607
     608        HRESULT hrc;
    609609        if (!*directControl)
    610             rc = E_ACCESSDENIED;
     610            hrc = E_ACCESSDENIED;
    611611        else
    612             rc = S_OK;
    613 
    614         return rc;
     612            hrc = S_OK;
     613
     614        return hrc;
    615615    }
    616616
  • trunk/src/VBox/Main/src-server/ApplianceImpl.cpp

    r98103 r98288  
    546546HRESULT Appliance::init(VirtualBox *aVirtualBox)
    547547{
    548     HRESULT rc = S_OK;
    549548    /* Enclose the state transition NotReady->InInit->Ready */
    550549    AutoInitSpan autoInitSpan(this);
     
    559558    AssertReturn(m->m_pSecretKeyStore, E_FAIL);
    560559
    561     rc = i_initBackendNames();
     560    HRESULT hrc = i_initBackendNames();
    562561
    563562    /* Confirm a successful initialization */
    564563    autoInitSpan.setSucceeded();
    565564
    566     return rc;
     565    return hrc;
    567566}
    568567
     
    703702
    704703    ComObjPtr<VFSExplorer> explorer;
    705     HRESULT rc = S_OK;
     704    HRESULT hrc;
    706705    try
    707706    {
     
    712711        /* Create the explorer object */
    713712        explorer.createObject();
    714         rc = explorer->init(li.storageType, li.strPath, li.strHostname, li.strUsername, li.strPassword, mVirtualBox);
     713        hrc = explorer->init(li.storageType, li.strPath, li.strHostname, li.strUsername, li.strPassword, mVirtualBox);
    715714    }
    716715    catch (HRESULT aRC)
    717716    {
    718         rc = aRC;
    719     }
    720 
    721     if (SUCCEEDED(rc))
     717        hrc = aRC;
     718    }
     719
     720    if (SUCCEEDED(hrc))
    722721        /* Return explorer to the caller */
    723722        explorer.queryInterfaceTo(aExplorer.asOutParam());
    724723
    725     return rc;
     724    return hrc;
    726725}
    727726
     
    738737    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    739738
    740     HRESULT rc = S_OK;
     739    HRESULT hrc = S_OK;
    741740    uint32_t lQuantity = aRequested;
    742741    uint32_t i=0;
     
    749748        {
    750749            ComObjPtr<VirtualSystemDescription> opVSD;
    751             rc = opVSD.createObject();
    752             if (SUCCEEDED(rc))
     750            hrc = opVSD.createObject();
     751            if (SUCCEEDED(hrc))
    753752            {
    754                 rc = opVSD->init();
    755                 if (SUCCEEDED(rc))
     753                hrc = opVSD->init();
     754                if (SUCCEEDED(hrc))
    756755                    m->virtualSystemDescriptions.push_back(opVSD);
    757756                else
     
    777776                break;
    778777        }
    779         rc = aRC;
    780     }
    781 
    782     return rc;
     778        hrc = aRC;
     779    }
     780
     781    return hrc;
    783782}
    784783
     
    837836    {
    838837        SecretKey *pKey = NULL;
    839         int rc = m->m_pSecretKeyStore->retainSecretKey(aIdentifiers[i], &pKey);
    840         if (rc != VERR_NOT_FOUND)
     838        int vrc = m->m_pSecretKeyStore->retainSecretKey(aIdentifiers[i], &pKey);
     839        if (vrc != VERR_NOT_FOUND)
    841840        {
    842841            AssertPtr(pKey);
     
    852851        const uint8_t *pbKey = (const uint8_t *)aPasswords[i].c_str();
    853852
    854         int rc = m->m_pSecretKeyStore->addSecretKey(aIdentifiers[i], pbKey, cbKey);
    855         if (RT_SUCCESS(rc))
     853        int vrc = m->m_pSecretKeyStore->addSecretKey(aIdentifiers[i], pbKey, cbKey);
     854        if (RT_SUCCESS(vrc))
    856855            m->m_cPwProvided++;
    857         else if (rc == VERR_NO_MEMORY)
     856        else if (vrc == VERR_NO_MEMORY)
    858857            hrc = setError(E_OUTOFMEMORY, tr("Failed to allocate enough secure memory for the key"));
    859858        else
    860             hrc = setError(E_FAIL, tr("Unknown error happened while adding a password (%Rrc)"), rc);
     859            hrc = setErrorBoth(E_FAIL, vrc, tr("Unknown error happened while adding a password (%Rrc)"), vrc);
    861860    }
    862861
     
    947946HRESULT Appliance::i_findMediumFormatFromDiskImage(const ovf::DiskImage &di, ComObjPtr<MediumFormat>& mf)
    948947{
    949     HRESULT rc = S_OK;
     948    HRESULT hrc = S_OK;
    950949
    951950    /* Get the system properties. */
     
    977976            {
    978977                mf.setNull();
    979                 rc = setError(E_FAIL,
    980                               tr("Internal inconsistency looking up medium format for the disk image '%s'"),
    981                               di.strHref.c_str());
    982                 return rc;
     978                hrc = setError(E_FAIL, tr("Internal inconsistency looking up medium format for the disk image '%s'"),
     979                               di.strHref.c_str());
     980                return hrc;
    983981            }
    984982        }
     
    998996
    999997    if (mf.isNull())
    1000         rc = setError(E_FAIL, tr("Internal inconsistency looking up medium format for the disk image '%s'"),
    1001                       di.strHref.c_str());
    1002 
    1003     return rc;
     998        hrc = setError(E_FAIL, tr("Internal inconsistency looking up medium format for the disk image '%s'"), di.strHref.c_str());
     999
     1000    return hrc;
    10041001}
    10051002
     
    10371034        return hVfsIosPt;
    10381035
    1039     setErrorVrc(vrc, tr("RTManifestEntryAddPassthruIoStream failed with rc=%Rrc"), vrc);
     1036    setErrorVrc(vrc, tr("RTManifestEntryAddPassthruIoStream failed with vrc=%Rrc"), vrc);
    10401037    return NIL_RTVFSIOSTREAM;
    10411038}
     
    10931090    {
    10941091        /* Complete the path (could be relative to machine folder). */
    1095         int rc = RTPathAbsExCxx(strAbsName, aMachineFolder, aName);
    1096         AssertRCReturn(rc, Global::vboxStatusCodeToCOM(rc));  /** @todo stupid caller ignores this */
     1092        int vrc = RTPathAbsExCxx(strAbsName, aMachineFolder, aName);
     1093        AssertRCReturn(vrc, Global::vboxStatusCodeToCOM(vrc));  /** @todo stupid caller ignores this */
    10971094
    10981095        /* Check that the file does not exist and that there is no media somehow matching the name. */
     
    11271124                                   SetUpProgressMode mode)
    11281125{
    1129     HRESULT rc;
     1126    HRESULT hrc;
    11301127
    11311128    /* Create the progress object */
    11321129    try
    11331130    {
    1134         rc = pProgress.createObject();
    1135         if (FAILED(rc))
    1136             return rc;
     1131        hrc = pProgress.createObject();
     1132        if (FAILED(hrc))
     1133            return hrc;
    11371134    }
    11381135    catch (std::bad_alloc &)
     
    13351332            pAppliance->m->resetReadData();
    13361333            if (pTask->locInfo.storageType == VFSType_File)
    1337                 pTask->rc = pAppliance->i_readFS(pTask);
     1334                pTask->hrc = pAppliance->i_readFS(pTask);
    13381335            else
    1339                 pTask->rc = E_NOTIMPL;
     1336                pTask->hrc = E_NOTIMPL;
    13401337            break;
    13411338
     
    13431340            /** @todo allow overriding these? */
    13441341            if (!pAppliance->m->fSignatureValid && pAppliance->m->pbSignedDigest)
    1345                 pTask->rc = pAppliance->setError(E_FAIL, tr("The manifest signature for '%s' is not valid"),
    1346                                                  pTask->locInfo.strPath.c_str());
     1342                pTask->hrc = pAppliance->setError(E_FAIL, tr("The manifest signature for '%s' is not valid"),
     1343                                                  pTask->locInfo.strPath.c_str());
    13471344            else if (!pAppliance->m->fCertificateValid && pAppliance->m->pbSignedDigest)
    13481345            {
    13491346                if (pAppliance->m->strCertError.isNotEmpty())
    1350                     pTask->rc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is not valid: %s"),
    1351                                                      pTask->locInfo.strPath.c_str(), pAppliance->m->strCertError.c_str());
     1347                    pTask->hrc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is not valid: %s"),
     1348                                                      pTask->locInfo.strPath.c_str(), pAppliance->m->strCertError.c_str());
    13521349                else
    1353                     pTask->rc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is not valid"),
    1354                                                      pTask->locInfo.strPath.c_str());
     1350                    pTask->hrc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is not valid"),
     1351                                                      pTask->locInfo.strPath.c_str());
    13551352            }
    13561353            // fusion does not consider this a show stopper (we've filed a warning during read).
    13571354            //else if (pAppliance->m->fCertificateMissingPath && pAppliance->m->pbSignedDigest)
    1358             //    pTask->rc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is does not have a valid CA path"),
    1359             //                                     pTask->locInfo.strPath.c_str());
     1355            //    pTask->hrc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is does not have a valid CA path"),
     1356            //                                      pTask->locInfo.strPath.c_str());
    13601357            else
    13611358            {
    13621359                if (pTask->locInfo.storageType == VFSType_File)
    1363                     pTask->rc = pAppliance->i_importFS(pTask);
     1360                    pTask->hrc = pAppliance->i_importFS(pTask);
    13641361                else
    1365                     pTask->rc = E_NOTIMPL;
     1362                    pTask->hrc = E_NOTIMPL;
    13661363            }
    13671364            break;
     
    13691366        case TaskOVF::Write:
    13701367            if (pTask->locInfo.storageType == VFSType_File)
    1371                 pTask->rc = pAppliance->i_writeFS(pTask);
     1368                pTask->hrc = pAppliance->i_writeFS(pTask);
    13721369            else
    1373                 pTask->rc = E_NOTIMPL;
     1370                pTask->hrc = E_NOTIMPL;
    13741371            break;
    13751372
    13761373        default:
    13771374            AssertFailed();
    1378             pTask->rc = E_FAIL;
     1375            pTask->hrc = E_FAIL;
    13791376            break;
    13801377    }
    13811378
    13821379    if (!pTask->pProgress.isNull())
    1383         pTask->pProgress->i_notifyComplete(pTask->rc);
     1380        pTask->pProgress->i_notifyComplete(pTask->hrc);
    13841381
    13851382    LogFlowFuncLeave();
     
    14181415    {
    14191416        case TaskOPC::Export:
    1420             pTask->rc = pAppliance->i_writeFSOPC(pTask);
     1417            pTask->hrc = pAppliance->i_writeFSOPC(pTask);
    14211418            break;
    14221419
    14231420        default:
    14241421            AssertFailed();
    1425             pTask->rc = E_FAIL;
     1422            pTask->hrc = E_FAIL;
    14261423            break;
    14271424    }
    14281425
    14291426    if (!pTask->pProgress.isNull())
    1430         pTask->pProgress->i_notifyComplete(pTask->rc);
     1427        pTask->pProgress->i_notifyComplete(pTask->hrc);
    14311428
    14321429    LogFlowFuncLeave();
     
    14671464        case TaskCloud::Export:
    14681465            pAppliance->i_setApplianceState(ApplianceExporting);
    1469             pTask->rc = pAppliance->i_exportCloudImpl(pTask);
     1466            pTask->hrc = pAppliance->i_exportCloudImpl(pTask);
    14701467            break;
    14711468        case TaskCloud::Import:
    14721469            pAppliance->i_setApplianceState(ApplianceImporting);
    1473             pTask->rc = pAppliance->i_importCloudImpl(pTask);
     1470            pTask->hrc = pAppliance->i_importCloudImpl(pTask);
    14741471            break;
    14751472        case TaskCloud::ReadData:
    14761473            pAppliance->i_setApplianceState(ApplianceImporting);
    1477             pTask->rc = pAppliance->i_gettingCloudData(pTask);
     1474            pTask->hrc = pAppliance->i_gettingCloudData(pTask);
    14781475            break;
    14791476        default:
    14801477            AssertFailed();
    1481             pTask->rc = E_FAIL;
     1478            pTask->hrc = E_FAIL;
    14821479            break;
    14831480    }
     
    14861483
    14871484    if (!pTask->pProgress.isNull())
    1488         pTask->pProgress->i_notifyComplete(pTask->rc);
     1485        pTask->pProgress->i_notifyComplete(pTask->hrc);
    14891486
    14901487    LogFlowFuncLeave();
  • trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

    r98262 r98288  
    7373                          ComPtr<IVirtualSystemDescription> &aDescription)
    7474{
    75     HRESULT rc = S_OK;
     75    HRESULT hrc = S_OK;
    7676
    7777    if (!aAppliance)
     
    9494
    9595        // create a new virtual system to store in the appliance
    96         rc = pNewDesc.createObject();
    97         if (FAILED(rc)) throw rc;
    98         rc = pNewDesc->init();
    99         if (FAILED(rc)) throw rc;
     96        hrc = pNewDesc.createObject();
     97        if (FAILED(hrc)) throw hrc;
     98        hrc = pNewDesc->init();
     99        if (FAILED(hrc)) throw hrc;
    100100
    101101        // store the machine object so we can dump the XML in Appliance::Write()
     
    106106        BOOL fUSBEnabled = FALSE;
    107107        com::SafeIfaceArray<IUSBController> usbControllers;
    108         rc = COMGETTER(USBControllers)(ComSafeArrayAsOutParam(usbControllers));
    109         if (SUCCEEDED(rc))
     108        hrc = COMGETTER(USBControllers)(ComSafeArrayAsOutParam(usbControllers));
     109        if (SUCCEEDED(hrc))
    110110        {
    111111            for (unsigned i = 0; i < usbControllers.size(); ++i)
     
    113113                USBControllerType_T enmType;
    114114
    115                 rc = usbControllers[i]->COMGETTER(Type)(&enmType);
    116                 if (FAILED(rc)) throw rc;
     115                hrc = usbControllers[i]->COMGETTER(Type)(&enmType);
     116                if (FAILED(hrc)) throw hrc;
    117117
    118118                if (enmType == USBControllerType_OHCI)
     
    126126
    127127        ComPtr<IAudioAdapter> pAudioAdapter;
    128         rc = mAudioSettings->COMGETTER(Adapter)(pAudioAdapter.asOutParam());
    129         if (FAILED(rc)) throw rc;
     128        hrc = mAudioSettings->COMGETTER(Adapter)(pAudioAdapter.asOutParam());
     129        if (FAILED(hrc)) throw hrc;
    130130        BOOL fAudioEnabled;
    131         rc = pAudioAdapter->COMGETTER(Enabled)(&fAudioEnabled);
    132         if (FAILED(rc)) throw rc;
     131        hrc = pAudioAdapter->COMGETTER(Enabled)(&fAudioEnabled);
     132        if (FAILED(hrc)) throw hrc;
    133133        AudioControllerType_T audioController;
    134         rc = pAudioAdapter->COMGETTER(AudioController)(&audioController);
    135         if (FAILED(rc)) throw rc;
     134        hrc = pAudioAdapter->COMGETTER(AudioController)(&audioController);
     135        if (FAILED(hrc)) throw hrc;
    136136
    137137        // get name
     
    154154        // Long mode enabled?
    155155        BOOL fLongMode;
    156         rc = GetCPUProperty(CPUPropertyType_LongMode, &fLongMode);
    157         if (FAILED(rc)) throw rc;
     156        hrc = GetCPUProperty(CPUPropertyType_LongMode, &fLongMode);
     157        if (FAILED(hrc)) throw hrc;
    158158
    159159        // snapshotFolder?
     
    203203        /* Fetch all available storage controllers */
    204204        com::SafeIfaceArray<IStorageController> nwControllers;
    205         rc = COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(nwControllers));
    206         if (FAILED(rc)) throw rc;
     205        hrc = COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(nwControllers));
     206        if (FAILED(hrc)) throw hrc;
    207207
    208208        ComPtr<IStorageController> pIDEController;
     
    214214        {
    215215            StorageBus_T eType;
    216             rc = nwControllers[j]->COMGETTER(Bus)(&eType);
    217             if (FAILED(rc)) throw rc;
     216            hrc = nwControllers[j]->COMGETTER(Bus)(&eType);
     217            if (FAILED(hrc)) throw hrc;
    218218            if (   eType == StorageBus_IDE
    219219                && pIDEController.isNull())
     
    237237        {
    238238            StorageControllerType_T ctlr;
    239             rc = pIDEController->COMGETTER(ControllerType)(&ctlr);
    240             if (FAILED(rc)) throw rc;
     239            hrc = pIDEController->COMGETTER(ControllerType)(&ctlr);
     240            if (FAILED(hrc)) throw hrc;
    241241
    242242            Utf8Str strVBox;
     
    279279        {
    280280            StorageControllerType_T ctlr;
    281             rc = pSCSIController->COMGETTER(ControllerType)(&ctlr);
    282             if (SUCCEEDED(rc))
     281            hrc = pSCSIController->COMGETTER(ControllerType)(&ctlr);
     282            if (SUCCEEDED(hrc))
    283283            {
    284284                Utf8Str strVBox = "LsiLogic";       // the default in VBox
     
    296296            }
    297297            else
    298                 throw rc;
     298                throw hrc;
    299299        }
    300300
     
    314314        {
    315315            StorageControllerType_T ctlr;
    316             rc = pVirtioSCSIController->COMGETTER(ControllerType)(&ctlr);
    317             if (SUCCEEDED(rc))
     316            hrc = pVirtioSCSIController->COMGETTER(ControllerType)(&ctlr);
     317            if (SUCCEEDED(hrc))
    318318            {
    319319                Utf8Str strVBox = "VirtioSCSI";       // the default in VBox
     
    330330            }
    331331            else
    332                 throw rc;
     332                throw hrc;
    333333        }
    334334
     
    349349            Bstr controllerName;
    350350
    351             rc = pHDA->COMGETTER(Controller)(controllerName.asOutParam());
    352             if (FAILED(rc)) throw rc;
    353 
    354             rc = GetStorageControllerByName(controllerName.raw(), ctl.asOutParam());
    355             if (FAILED(rc)) throw rc;
     351            hrc = pHDA->COMGETTER(Controller)(controllerName.asOutParam());
     352            if (FAILED(hrc)) throw hrc;
     353
     354            hrc = GetStorageControllerByName(controllerName.raw(), ctl.asOutParam());
     355            if (FAILED(hrc)) throw hrc;
    356356
    357357            StorageBus_T storageBus;
     
    360360            LONG lDevice;
    361361
    362             rc = ctl->COMGETTER(Bus)(&storageBus);
    363             if (FAILED(rc)) throw rc;
    364 
    365             rc = pHDA->COMGETTER(Type)(&deviceType);
    366             if (FAILED(rc)) throw rc;
    367 
    368             rc = pHDA->COMGETTER(Port)(&lChannel);
    369             if (FAILED(rc)) throw rc;
    370 
    371             rc = pHDA->COMGETTER(Device)(&lDevice);
    372             if (FAILED(rc)) throw rc;
    373 
    374             rc = pHDA->COMGETTER(Medium)(pMedium.asOutParam());
    375             if (FAILED(rc)) throw rc;
     362            hrc = ctl->COMGETTER(Bus)(&storageBus);
     363            if (FAILED(hrc)) throw hrc;
     364
     365            hrc = pHDA->COMGETTER(Type)(&deviceType);
     366            if (FAILED(hrc)) throw hrc;
     367
     368            hrc = pHDA->COMGETTER(Port)(&lChannel);
     369            if (FAILED(hrc)) throw hrc;
     370
     371            hrc = pHDA->COMGETTER(Device)(&lDevice);
     372            if (FAILED(hrc)) throw hrc;
     373
     374            hrc = pHDA->COMGETTER(Medium)(pMedium.asOutParam());
     375            if (FAILED(hrc)) throw hrc;
    376376            if (pMedium.isNull())
    377377            {
     
    402402                Bstr bstrLocation;
    403403
    404                 rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
    405                 if (FAILED(rc)) throw rc;
     404                hrc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
     405                if (FAILED(hrc)) throw hrc;
    406406                strLocation = bstrLocation;
    407407
     
    412412                //    on export, the progress will be based on that (and not the diff image)
    413413                ComPtr<IMedium> pBaseMedium;
    414                 rc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
     414                hrc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
    415415                        // returns pMedium if there are no diff images
    416                 if (FAILED(rc)) throw rc;
     416                if (FAILED(hrc)) throw hrc;
    417417
    418418                strTargetImageName = Utf8StrFmt("%s-disk%.3d.vmdk", strBasename.c_str(), ++pAppliance->m->cDisks);
     
    423423                // force reading state, or else size will be returned as 0
    424424                MediumState_T ms;
    425                 rc = pBaseMedium->RefreshState(&ms);
    426                 if (FAILED(rc)) throw rc;
    427 
    428                 rc = pBaseMedium->COMGETTER(Size)(&llSize);
    429                 if (FAILED(rc)) throw rc;
     425                hrc = pBaseMedium->RefreshState(&ms);
     426                if (FAILED(hrc)) throw hrc;
     427
     428                hrc = pBaseMedium->COMGETTER(Size)(&llSize);
     429                if (FAILED(hrc)) throw hrc;
    430430
    431431                /* If the medium is encrypted add the key identifier to the list. */
     
    479479                //1. no host drive CD/DVD image
    480480                BOOL fHostDrive = false;
    481                 rc = pMedium->COMGETTER(HostDrive)(&fHostDrive);
    482                 if (FAILED(rc)) throw rc;
     481                hrc = pMedium->COMGETTER(HostDrive)(&fHostDrive);
     482                if (FAILED(hrc)) throw hrc;
    483483
    484484                if(fHostDrive)
     
    487487                //2. the image must be accessible and readable
    488488                MediumState_T ms;
    489                 rc = pMedium->RefreshState(&ms);
    490                 if (FAILED(rc)) throw rc;
     489                hrc = pMedium->RefreshState(&ms);
     490                if (FAILED(hrc)) throw hrc;
    491491
    492492                if (ms != MediumState_Created)
     
    495495                //3. only ISO image is exported
    496496                Bstr bstrLocation;
    497                 rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
    498                 if (FAILED(rc)) throw rc;
     497                hrc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
     498                if (FAILED(hrc)) throw hrc;
    499499
    500500                strLocation = bstrLocation;
     
    512512                                tr("Cannot attach image '%s' -- file name too long"), strTargetImageName.c_str());
    513513
    514                 rc = pMedium->COMGETTER(Size)(&llSize);
    515                 if (FAILED(rc)) throw rc;
     514                hrc = pMedium->COMGETTER(Size)(&llSize);
     515                if (FAILED(hrc)) throw hrc;
    516516            }
    517517            // and how this translates to the virtual system
     
    624624        {
    625625            ComPtr<INetworkAdapter> pNetworkAdapter;
     626            hrc = GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
     627            if (FAILED(hrc)) throw hrc;
     628
     629            /* Enable the network card & set the adapter type */
    626630            BOOL fEnabled;
    627             NetworkAdapterType_T adapterType;
    628             NetworkAttachmentType_T attachmentType;
    629 
    630             rc = GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
    631             if (FAILED(rc)) throw rc;
    632             /* Enable the network card & set the adapter type */
    633             rc = pNetworkAdapter->COMGETTER(Enabled)(&fEnabled);
    634             if (FAILED(rc)) throw rc;
     631            hrc = pNetworkAdapter->COMGETTER(Enabled)(&fEnabled);
     632            if (FAILED(hrc)) throw hrc;
    635633
    636634            if (fEnabled)
    637635            {
    638                 rc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
    639                 if (FAILED(rc)) throw rc;
    640 
    641                 rc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
    642                 if (FAILED(rc)) throw rc;
     636                NetworkAdapterType_T adapterType;
     637                hrc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
     638                if (FAILED(hrc)) throw hrc;
     639
     640                NetworkAttachmentType_T attachmentType;
     641                hrc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
     642                if (FAILED(hrc)) throw hrc;
    643643
    644644                Utf8Str strAttachmentType = convertNetworkAttachmentTypeToString(attachmentType);
     
    675675    catch(HRESULT arc)
    676676    {
    677         rc = arc;
    678     }
    679 
    680     return rc;
     677        hrc = arc;
     678    }
     679
     680    return hrc;
    681681}
    682682
     
    711711    }
    712712
    713     HRESULT rc = S_OK;
     713    HRESULT hrc = S_OK;
    714714//  AssertReturn(!(m->optListExport.contains(ExportOptions_CreateManifest)
    715715//  && m->optListExport.contains(ExportOptions_ExportDVDImages)), E_INVALIDARG);
     
    720720    if (m->locInfo.storageType == VFSType_Cloud)
    721721    {
    722         rc = S_OK;
     722        hrc = S_OK;
    723723        ComObjPtr<Progress> progress;
    724724        try
    725725        {
    726             rc = i_writeCloudImpl(m->locInfo, progress);
     726            hrc = i_writeCloudImpl(m->locInfo, progress);
    727727        }
    728728        catch (HRESULT aRC)
    729729        {
    730             rc = aRC;
    731         }
    732 
    733         if (SUCCEEDED(rc))
     730            hrc = aRC;
     731        }
     732
     733        if (SUCCEEDED(hrc))
    734734            /* Return progress to the caller */
    735735            progress.queryInterfaceTo(aProgress.asOutParam());
     
    799799
    800800        ComObjPtr<Progress> progress;
    801         rc = S_OK;
     801        hrc = S_OK;
    802802        try
    803803        {
     
    808808            {
    809809                case ovf::OVFVersion_unknown:
    810                     rc = i_writeOPCImpl(ovfF, m->locInfo, progress);
     810                    hrc = i_writeOPCImpl(ovfF, m->locInfo, progress);
    811811                    break;
    812812                default:
    813                     rc = i_writeImpl(ovfF, m->locInfo, progress);
     813                    hrc = i_writeImpl(ovfF, m->locInfo, progress);
    814814                    break;
    815815            }
     
    818818        catch (HRESULT aRC)
    819819        {
    820             rc = aRC;
    821         }
    822 
    823         if (SUCCEEDED(rc))
     820            hrc = aRC;
     821        }
     822
     823        if (SUCCEEDED(hrc))
    824824            /* Return progress to the caller */
    825825            progress.queryInterfaceTo(aProgress.asOutParam());
    826826    }
    827827
    828     return rc;
     828    return hrc;
    829829}
    830830
     
    11841184            Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
    11851185
    1186             HRESULT rc;
     1186            HRESULT hrc;
    11871187
    11881188            if (pDiskEntry->type == VirtualSystemDescriptionType_HardDiskImage)
    11891189            {
    1190                 rc = mVirtualBox->OpenMedium(bstrSrcFilePath.raw(),
    1191                                              DeviceType_HardDisk,
    1192                                              AccessMode_ReadWrite,
    1193                                              FALSE /* fForceNewUuid */,
    1194                                              pSourceDisk.asOutParam());
    1195                 if (FAILED(rc))
    1196                     throw rc;
     1190                hrc = mVirtualBox->OpenMedium(bstrSrcFilePath.raw(),
     1191                                              DeviceType_HardDisk,
     1192                                              AccessMode_ReadWrite,
     1193                                              FALSE /* fForceNewUuid */,
     1194                                              pSourceDisk.asOutParam());
     1195                if (FAILED(hrc))
     1196                    throw hrc;
    11971197            }
    11981198            else if (pDiskEntry->type == VirtualSystemDescriptionType_CDROM)//may be, this is CD/DVD
    11991199            {
    1200                 rc = mVirtualBox->OpenMedium(bstrSrcFilePath.raw(),
    1201                                              DeviceType_DVD,
    1202                                              AccessMode_ReadOnly,
    1203                                              FALSE,
    1204                                              pSourceDisk.asOutParam());
    1205                 if (FAILED(rc))
    1206                     throw rc;
     1200                hrc = mVirtualBox->OpenMedium(bstrSrcFilePath.raw(),
     1201                                              DeviceType_DVD,
     1202                                              AccessMode_ReadOnly,
     1203                                              FALSE,
     1204                                              pSourceDisk.asOutParam());
     1205                if (FAILED(hrc))
     1206                    throw hrc;
    12071207            }
    12081208
    12091209            Bstr uuidSource;
    1210             rc = pSourceDisk->COMGETTER(Id)(uuidSource.asOutParam());
    1211             if (FAILED(rc)) throw rc;
     1210            hrc = pSourceDisk->COMGETTER(Id)(uuidSource.asOutParam());
     1211            if (FAILED(hrc)) throw hrc;
    12121212            Guid guidSource(uuidSource);
    12131213
     
    12271227
    12281228            LONG64 cbCapacity = 0;     // size reported to guest
    1229             rc = pSourceDisk->COMGETTER(LogicalSize)(&cbCapacity);
    1230             if (FAILED(rc)) throw rc;
     1229            hrc = pSourceDisk->COMGETTER(LogicalSize)(&cbCapacity);
     1230            if (FAILED(hrc)) throw hrc;
    12311231            /// @todo r=poetzsch: wrong it is reported in bytes ...
    12321232            // capacity is reported in megabytes, so...
     
    22302230    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
    22312231
    2232     HRESULT rc = S_OK;
     2232    HRESULT hrc = S_OK;
    22332233
    22342234    // Lock the media tree early to make sure nobody else tries to make changes
     
    22412241
    22422242    if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
    2243         rc = i_writeFSOVF(pTask, multiLock);
     2243        hrc = i_writeFSOVF(pTask, multiLock);
    22442244    else
    2245         rc = i_writeFSOVA(pTask, multiLock);
     2245        hrc = i_writeFSOVA(pTask, multiLock);
    22462246
    22472247    // reset the state so others can call methods again
    22482248    m->state = ApplianceIdle;
    22492249
    2250     LogFlowFunc(("rc=%Rhrc\n", rc));
     2250    LogFlowFunc(("hrc=%Rhrc\n", hrc));
    22512251    LogFlowFuncLeave();
    2252     return rc;
     2252    return hrc;
    22532253}
    22542254
     
    26092609    LogFlowFuncEnter();
    26102610
    2611     HRESULT rc = S_OK;
     2611    HRESULT hrc = S_OK;
    26122612    int vrc;
    26132613    try
     
    26372637
    26382638            /* Write the ovf file to "disk". */
    2639             rc = i_writeBufferToFile(hVfsFssDst, strOvfFile.c_str(), pvBuf, cbSize);
    2640             if (FAILED(rc))
    2641                 throw rc;
     2639            hrc = i_writeBufferToFile(hVfsFssDst, strOvfFile.c_str(), pvBuf, cbSize);
     2640            if (FAILED(hrc))
     2641                throw hrc;
    26422642        }
    26432643
     
    26922692            if (pDiskEntry->type == VirtualSystemDescriptionType_HardDiskImage)
    26932693            {
    2694                 rc = mVirtualBox->i_findHardDiskByLocation(strSrcFilePath, true, &pSourceDisk);
    2695                 if (FAILED(rc)) throw rc;
     2694                hrc = mVirtualBox->i_findHardDiskByLocation(strSrcFilePath, true, &pSourceDisk);
     2695                if (FAILED(hrc)) throw hrc;
    26962696            }
    26972697            else//may be CD or DVD
    26982698            {
    2699                 rc = mVirtualBox->i_findDVDOrFloppyImage(DeviceType_DVD,
    2700                                                          NULL,
    2701                                                          strSrcFilePath,
    2702                                                          true,
    2703                                                          &pSourceDisk);
    2704                 if (FAILED(rc)) throw rc;
     2699                hrc = mVirtualBox->i_findDVDOrFloppyImage(DeviceType_DVD,
     2700                                                          NULL,
     2701                                                          strSrcFilePath,
     2702                                                          true,
     2703                                                          &pSourceDisk);
     2704                if (FAILED(hrc)) throw hrc;
    27052705            }
    27062706
    27072707            Bstr uuidSource;
    2708             rc = pSourceDisk->COMGETTER(Id)(uuidSource.asOutParam());
    2709             if (FAILED(rc)) throw rc;
     2708            hrc = pSourceDisk->COMGETTER(Id)(uuidSource.asOutParam());
     2709            if (FAILED(hrc)) throw hrc;
    27102710            Guid guidSource(uuidSource);
    27112711
     
    27432743                        throw setError(E_FAIL, "i_manifestSetupDigestCalculationForGivenIoStream(%s)", strTargetFilePath.c_str());
    27442744
    2745                     rc = pSourceDisk->i_exportFile(strTargetFilePath.c_str(),
    2746                                                    format,
    2747                                                    MediumVariant_VmdkStreamOptimized,
    2748                                                    m->m_pSecretKeyStore,
    2749                                                    hVfsIosDst,
    2750                                                    pTask->pProgress);
     2745                    hrc = pSourceDisk->i_exportFile(strTargetFilePath.c_str(),
     2746                                                    format,
     2747                                                    MediumVariant_VmdkStreamOptimized,
     2748                                                    m->m_pSecretKeyStore,
     2749                                                    hVfsIosDst,
     2750                                                    pTask->pProgress);
    27512751                    RTVfsIoStrmRelease(hVfsIosDst);
    27522752                }
     
    27572757                     */
    27582758                    Assert(pDiskEntry->type == VirtualSystemDescriptionType_CDROM);
    2759                     rc = pSourceDisk->i_addRawToFss(strTargetFilePath.c_str(), m->m_pSecretKeyStore, hVfsFssDst,
     2759                    hrc = pSourceDisk->i_addRawToFss(strTargetFilePath.c_str(), m->m_pSecretKeyStore, hVfsFssDst,
    27602760                                                    pTask->pProgress, false /*fSparse*/);
    27612761                }
    2762                 if (FAILED(rc)) throw rc;
     2762                if (FAILED(hrc)) throw hrc;
    27632763            }
    27642764            catch (HRESULT rc3)
     
    27982798                    vrc = RTVfsFsStrmAdd(hVfsFssDst, strMfFileName.c_str(), hVfsObjManifest, 0 /*fFlags*/);
    27992799                    if (RT_SUCCESS(vrc))
    2800                         rc = S_OK;
     2800                        hrc = S_OK;
    28012801                    else
    2802                         rc = setErrorVrc(vrc, tr("RTVfsFsStrmAdd failed for the manifest (%Rrc)"), vrc);
     2802                        hrc = setErrorVrc(vrc, tr("RTVfsFsStrmAdd failed for the manifest (%Rrc)"), vrc);
    28032803                }
    28042804                else
    2805                     rc = setErrorVrc(vrc, tr("RTManifestWriteStandard failed (%Rrc)"), vrc);
     2805                    hrc = setErrorVrc(vrc, tr("RTManifestWriteStandard failed (%Rrc)"), vrc);
    28062806            }
    28072807            else
    2808                 rc = setErrorVrc(vrc, tr("RTManifestWriteStandard failed (%Rrc)"), vrc);
     2808                hrc = setErrorVrc(vrc, tr("RTManifestWriteStandard failed (%Rrc)"), vrc);
    28092809            RTVfsIoStrmRelease(hVfsIosManifest);
    2810             if (FAILED(rc))
    2811                 throw rc;
     2810            if (FAILED(hrc))
     2811                throw hrc;
    28122812        }
    28132813    }
    28142814    catch (RTCError &x)  // includes all XML exceptions
    28152815    {
    2816         rc = setError(VBOX_E_FILE_ERROR,
    2817                       x.what());
     2816        hrc = setError(VBOX_E_FILE_ERROR, x.what());
    28182817    }
    28192818    catch (HRESULT aRC)
    28202819    {
    2821         rc = aRC;
    2822     }
    2823 
    2824     LogFlowFunc(("rc=%Rhrc\n", rc));
     2820        hrc = aRC;
     2821    }
     2822
     2823    LogFlowFunc(("hrc=%Rhrc\n", hrc));
    28252824    LogFlowFuncLeave();
    28262825
    2827     return rc;
     2826    return hrc;
    28282827}
    28292828
  • trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

    r98262 r98288  
    104104    try
    105105    {
    106         i_parseURI(aFile, m->locInfo); /* may trhow rc. */
     106        i_parseURI(aFile, m->locInfo); /* may throw hrc. */
    107107    }
    108108    catch (HRESULT aRC)
     
    144144        return E_ACCESSDENIED;
    145145
    146     HRESULT rc = S_OK;
     146    HRESULT hrc = S_OK;
    147147
    148148    /* Clear any previous virtual system descriptions */
     
    171171
    172172            ComObjPtr<VirtualSystemDescription> pNewDesc;
    173             rc = pNewDesc.createObject();
    174             if (FAILED(rc)) throw rc;
    175             rc = pNewDesc->init();
    176             if (FAILED(rc)) throw rc;
     173            hrc = pNewDesc.createObject();
     174            if (FAILED(hrc)) throw hrc;
     175            hrc = pNewDesc->init();
     176            if (FAILED(hrc)) throw hrc;
    177177
    178178            // if the virtual system in OVF had a <vbox:Machine> element, have the
     
    233233            /* Based on the VM name, create a target machine path. */
    234234            Bstr bstrSettingsFilename;
    235             rc = mVirtualBox->ComposeMachineFilename(Bstr(nameVBox).raw(),
    236                                                      Bstr(strPrimaryGroup).raw(),
    237                                                      NULL /* aCreateFlags */,
    238                                                      NULL /* aBaseFolder */,
    239                                                      bstrSettingsFilename.asOutParam());
    240             if (FAILED(rc)) throw rc;
     235            hrc = mVirtualBox->ComposeMachineFilename(Bstr(nameVBox).raw(),
     236                                                      Bstr(strPrimaryGroup).raw(),
     237                                                      NULL /* aCreateFlags */,
     238                                                      NULL /* aBaseFolder */,
     239                                                      bstrSettingsFilename.asOutParam());
     240            if (FAILED(hrc)) throw hrc;
    241241            Utf8Str strMachineFolder(bstrSettingsFilename);
    242242            strMachineFolder.stripFilename();
     
    364364                if (!pGuestOSType.isNull())
    365365                {
    366                     rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
    367                     if (FAILED(rc)) throw rc;
     366                    hrc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
     367                    if (FAILED(hrc)) throw hrc;
    368368                }
    369369                else
     
    456456                if (!pGuestOSType.isNull())
    457457                {
    458                     rc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
    459                     if (FAILED(rc)) throw rc;
     458                    hrc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
     459                    if (FAILED(hrc)) throw hrc;
    460460                }
    461461                else
     
    724724
    725725                    ComObjPtr<MediumFormat> mediumFormat;
    726                     rc = i_findMediumFormatFromDiskImage(di, mediumFormat);
    727                     if (FAILED(rc))
    728                         throw rc;
     726                    hrc = i_findMediumFormatFromDiskImage(di, mediumFormat);
     727                    if (FAILED(hrc))
     728                        throw hrc;
    729729
    730730                    Bstr bstrFormatName;
    731                     rc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
    732                     if (FAILED(rc))
    733                         throw rc;
     731                    hrc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
     732                    if (FAILED(hrc))
     733                        throw hrc;
    734734                    Utf8Str vdf = Utf8Str(bstrFormatName);
    735735
     
    799799        /* On error we clear the list & return */
    800800        m->virtualSystemDescriptions.clear();
    801         rc = aRC;
     801        hrc = aRC;
    802802    }
    803803
     
    806806    m->state = ApplianceIdle;
    807807
    808     return rc;
     808    return hrc;
    809809}
    810810
     
    13091309    }
    13101310
    1311     LogFlowFunc(("rc=%Rhrc\n", hrc));
     1311    LogFlowFunc(("hrc=%Rhrc\n", hrc));
    13121312    LogFlowFuncLeave();
    13131313
     
    22702270    }
    22712271
    2272     LogFlowFunc(("rc=%Rhrc\n", hrc));
     2272    LogFlowFunc(("hrc=%Rhrc\n", hrc));
    22732273    LogFlowFuncLeave();
    22742274    return hrc;
     
    22962296    AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
    22972297
    2298     HRESULT rc;
     2298    HRESULT hrc;
    22992299    if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
    2300         rc = i_readFSOVF(pTask);
     2300        hrc = i_readFSOVF(pTask);
    23012301    else
    2302         rc = i_readFSOVA(pTask);
    2303 
    2304     LogFlowFunc(("rc=%Rhrc\n", rc));
     2302        hrc = i_readFSOVA(pTask);
     2303
     2304    LogFlowFunc(("hrc=%Rhrc\n", hrc));
    23052305    LogFlowFuncLeave();
    23062306
    2307     return rc;
     2307    return hrc;
    23082308}
    23092309
     
    25802580        hrc = E_FAIL;
    25812581    }
    2582     LogFlowFunc(("OVFReader(%s) -> rc=%Rhrc\n", pTask->locInfo.strPath.c_str(), hrc));
     2582    LogFlowFunc(("OVFReader(%s) -> hrc=%Rhrc\n", pTask->locInfo.strPath.c_str(), hrc));
    25832583
    25842584    RTVfsIoStrmReadAllFree(pvBufferedOvf, cbBufferedOvf);
     
    35303530                                ComObjPtr<Progress> &progress)
    35313531{
    3532     HRESULT rc;
     3532    HRESULT hrc;
    35333533
    35343534    /* Initialize our worker task */
     
    35363536    if (locInfo.storageType != VFSType_Cloud)
    35373537    {
    3538         rc = i_setUpProgress(progress, Utf8StrFmt(tr("Importing appliance '%s'"), locInfo.strPath.c_str()),
    3539                              locInfo.storageType == VFSType_File ? ImportFile : ImportS3);
    3540         if (FAILED(rc))
    3541             return setError(rc, tr("Failed to create task for importing appliance into VirtualBox"));
     3538        hrc = i_setUpProgress(progress, Utf8StrFmt(tr("Importing appliance '%s'"), locInfo.strPath.c_str()),
     3539                              locInfo.storageType == VFSType_File ? ImportFile : ImportS3);
     3540        if (FAILED(hrc))
     3541            return setError(hrc, tr("Failed to create task for importing appliance into VirtualBox"));
    35423542        try
    35433543        {
     
    35923592            try
    35933593            {
    3594                 rc = progress.createObject();
    3595                 if (SUCCEEDED(rc))
    3596                     rc = progress->init(mVirtualBox, static_cast<IAppliance *>(this),
    3597                                         Utf8Str(tr("Importing VM from Cloud...")),
    3598                                         TRUE /* aCancelable */,
    3599                                         10, // ULONG cOperations,
    3600                                         1000, // ULONG ulTotalOperationsWeight,
    3601                                         Utf8Str(tr("Start import VM from the Cloud...")), // aFirstOperationDescription
    3602                                         25); // ULONG ulFirstOperationWeight
    3603                 if (SUCCEEDED(rc))
     3594                hrc = progress.createObject();
     3595                if (SUCCEEDED(hrc))
     3596                    hrc = progress->init(mVirtualBox, static_cast<IAppliance *>(this),
     3597                                         Utf8Str(tr("Importing VM from Cloud...")),
     3598                                         TRUE /* aCancelable */,
     3599                                         10, // ULONG cOperations,
     3600                                         1000, // ULONG ulTotalOperationsWeight,
     3601                                         Utf8Str(tr("Start import VM from the Cloud...")), // aFirstOperationDescription
     3602                                         25); // ULONG ulFirstOperationWeight
     3603                if (SUCCEEDED(hrc))
    36043604                    pTask = new TaskCloud(this, TaskCloud::Import, locInfo, progress);
    36053605                else
     
    36103610                return E_OUTOFMEMORY;
    36113611            }
    3612             if (FAILED(rc))
    3613                 return setError(rc, tr("Failed to create task for importing appliance into VirtualBox"));
     3612            if (FAILED(hrc))
     3613                return setError(hrc, tr("Failed to create task for importing appliance into VirtualBox"));
    36143614        }
    36153615        else
     
    36213621     * Start the task thread.
    36223622     */
    3623     rc = pTask->createThread();
     3623    hrc = pTask->createThread();
    36243624    pTask = NULL;
    3625     if (SUCCEEDED(rc))
    3626         return rc;
    3627     return setError(rc, tr("Failed to start thread for importing appliance into VirtualBox"));
     3625    if (SUCCEEDED(hrc))
     3626        return hrc;
     3627    return setError(hrc, tr("Failed to start thread for importing appliance into VirtualBox"));
    36283628}
    36293629
     
    36633663    m->state = ApplianceImporting;
    36643664
    3665     HRESULT rc = S_OK;
     3665    HRESULT hrc = S_OK;
    36663666
    36673667    /* Clear the list of imported machines, if any */
     
    36693669
    36703670    if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
    3671         rc = i_importFSOVF(pTask, writeLock);
     3671        hrc = i_importFSOVF(pTask, writeLock);
    36723672    else
    3673         rc = i_importFSOVA(pTask, writeLock);
    3674     if (FAILED(rc))
     3673        hrc = i_importFSOVA(pTask, writeLock);
     3674    if (FAILED(hrc))
    36753675    {
    36763676        /* With _whatever_ error we've had, do a complete roll-back of
     
    37013701    m->state = ApplianceIdle;
    37023702
    3703     LogFlowFunc(("rc=%Rhrc\n", rc));
     3703    LogFlowFunc(("hrc=%Rhrc\n", hrc));
    37043704    LogFlowFuncLeave();
    3705     return rc;
     3705    return hrc;
    37063706}
    37073707
     
    40294029                                     ImportStack &stack)
    40304030{
    4031     HRESULT rc;
     4031    HRESULT hrc;
    40324032
    40334033    Utf8Str strAbsDstPath;
     
    40634063    if (vrc == VINF_SUCCESS)
    40644064    {
    4065         rc = mVirtualBox->i_findHardDiskById(Guid(uuid), true, &pTargetMedium);
    4066         if (FAILED(rc)) throw rc;
     4065        hrc = mVirtualBox->i_findHardDiskById(Guid(uuid), true, &pTargetMedium);
     4066        if (FAILED(hrc)) throw hrc;
    40674067    }
    40684068    else
     
    40994099                    throw setError(E_FAIL, tr("Unsupported medium format for disk image '%s'"), di.strHref.c_str());
    41004100
    4101                 rc = trgFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
    4102                 if (FAILED(rc)) throw rc;
     4101                hrc = trgFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
     4102                if (FAILED(hrc)) throw hrc;
    41034103
    41044104                strTrgFormat = Utf8Str(bstrFormatName);
     
    41184118                lCabs = 0;
    41194119                com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
    4120                 rc = trgFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
    4121 
    4122                 if (FAILED(rc))
    4123                     throw rc;
     4120                hrc = trgFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
     4121
     4122                if (FAILED(hrc))
     4123                    throw hrc;
    41244124
    41254125                for (ULONG j = 0; j < mediumFormatCap.size(); j++)
     
    41504150
    41514151                    ComPtr<IMedium> pTmp;
    4152                     rc = mVirtualBox->OpenMedium(Bstr(strAbsDstPath).raw(),
    4153                                                  DeviceType_DVD,
    4154                                                  AccessMode_ReadWrite,
    4155                                                  false,
    4156                                                  pTmp.asOutParam());
    4157                     if (FAILED(rc))
    4158                         throw rc;
     4152                    hrc = mVirtualBox->OpenMedium(Bstr(strAbsDstPath).raw(),
     4153                                                  DeviceType_DVD,
     4154                                                  AccessMode_ReadWrite,
     4155                                                  false,
     4156                                                  pTmp.asOutParam());
     4157                    if (FAILED(hrc))
     4158                        throw hrc;
    41594159
    41604160                    IMedium *iM = pTmp;
     
    41774177                pTargetMedium.createObject();
    41784178
    4179                 rc = pTargetMedium->init(mVirtualBox,
    4180                                          strTrgFormat,
    4181                                          strAbsDstPath,
    4182                                          Guid::Empty /* media registry: none yet */,
    4183                                          DeviceType_HardDisk);
    4184                 if (FAILED(rc)) throw rc;
     4179                hrc = pTargetMedium->init(mVirtualBox,
     4180                                          strTrgFormat,
     4181                                          strAbsDstPath,
     4182                                          Guid::Empty /* media registry: none yet */,
     4183                                          DeviceType_HardDisk);
     4184                if (FAILED(hrc)) throw hrc;
    41854185
    41864186                ComPtr<IProgress> pProgressImport;
     
    41924192
    41934193                    /* Kick off the creation of a dynamic growing disk image with the given capacity. */
    4194                     rc = pTargetMedium->CreateBaseStorage(di.iCapacity / _1M,
    4195                                                           ComSafeArrayAsInParam(mediumVariant),
    4196                                                           pProgressImport.asOutParam());
    4197                     if (FAILED(rc)) throw rc;
     4194                    hrc = pTargetMedium->CreateBaseStorage(di.iCapacity / _1M,
     4195                                                           ComSafeArrayAsInParam(mediumVariant),
     4196                                                           pProgressImport.asOutParam());
     4197                    if (FAILED(hrc)) throw hrc;
    41984198
    41994199                    /* Advance to the next operation. */
     
    42084208                    /* Which format to use? */
    42094209                    ComObjPtr<MediumFormat> srcFormat;
    4210                     rc = i_findMediumFormatFromDiskImage(di, srcFormat);
    4211                     if (FAILED(rc))
     4210                    hrc = i_findMediumFormatFromDiskImage(di, srcFormat);
     4211                    if (FAILED(hrc))
    42124212                        throw setError(VBOX_E_NOT_SUPPORTED,
    42134213                                       tr("Could not find a valid medium format for the source disk '%s' "
     
    42544254                    ComObjPtr<Medium> nullParent;
    42554255                    ComObjPtr<Progress> pProgressImportTmp;
    4256                     rc = pProgressImportTmp.createObject();
    4257                     if (FAILED(rc)) throw rc;
    4258                     rc = pProgressImportTmp->init(mVirtualBox,
    4259                                                   static_cast<IAppliance*>(this),
    4260                                                   Utf8StrFmt(tr("Importing medium '%s'"),
    4261                                                              strAbsDstPath.c_str()),
    4262                                                   TRUE);
    4263                     if (FAILED(rc)) throw rc;
     4256                    hrc = pProgressImportTmp.createObject();
     4257                    if (FAILED(hrc)) throw hrc;
     4258                    hrc = pProgressImportTmp->init(mVirtualBox,
     4259                                                   static_cast<IAppliance*>(this),
     4260                                                   Utf8StrFmt(tr("Importing medium '%s'"), strAbsDstPath.c_str()),
     4261                                                   TRUE);
     4262                    if (FAILED(hrc)) throw hrc;
    42644263                    pProgressImportTmp.queryInterfaceTo(pProgressImport.asOutParam());
    42654264                    /* pProgressImportTmp is in parameter for Medium::i_importFile,
    42664265                     * which is somewhat unusual and might be changed later. */
    4267                     rc = pTargetMedium->i_importFile(strSrcFilePath.c_str(),
    4268                                                      srcFormat,
    4269                                                      MediumVariant_Standard,
    4270                                                      hVfsIosReadAhead,
    4271                                                      nullParent,
    4272                                                      pProgressImportTmp,
    4273                                                      true /* aNotify */);
     4266                    hrc = pTargetMedium->i_importFile(strSrcFilePath.c_str(),
     4267                                                      srcFormat,
     4268                                                      MediumVariant_Standard,
     4269                                                      hVfsIosReadAhead,
     4270                                                      nullParent,
     4271                                                      pProgressImportTmp,
     4272                                                      true /* aNotify */);
    42744273                    RTVfsIoStrmRelease(hVfsIosReadAhead);
    42754274                    hVfsIosSrc = NIL_RTVFSIOSTREAM;
    4276                     if (FAILED(rc))
    4277                         throw rc;
     4275                    if (FAILED(hrc))
     4276                        throw hrc;
    42784277
    42794278                    /* Advance to the next operation. */
     
    44014400{
    44024401    LogFlowFuncEnter();
    4403     HRESULT rc;
     4402    HRESULT hrc;
    44044403
    44054404    // Get the instance of IGuestOSType which matches our string guest OS type so we
    44064405    // can use recommended defaults for the new machine where OVF doesn't provide any
    44074406    ComPtr<IGuestOSType> osType;
    4408     rc = mVirtualBox->GetGuestOSType(Bstr(stack.strOsTypeVBox).raw(), osType.asOutParam());
    4409     if (FAILED(rc)) throw rc;
     4407    hrc = mVirtualBox->GetGuestOSType(Bstr(stack.strOsTypeVBox).raw(), osType.asOutParam());
     4408    if (FAILED(hrc)) throw hrc;
    44104409
    44114410    /* Create the machine */
     
    44144413        Bstr(stack.strPrimaryGroup).detachTo(groups.appendedRaw());
    44154414    ComPtr<IMachine> pNewMachine;
    4416     rc = mVirtualBox->CreateMachine(Bstr(stack.strSettingsFilename).raw(),
    4417                                     Bstr(stack.strNameVBox).raw(),
    4418                                     ComSafeArrayAsInParam(groups),
    4419                                     Bstr(stack.strOsTypeVBox).raw(),
    4420                                     NULL, /* aCreateFlags */
    4421                                     NULL, /* aCipher */
    4422                                     NULL, /* aPasswordId */
    4423                                     NULL, /* aPassword */
    4424                                     pNewMachine.asOutParam());
    4425     if (FAILED(rc)) throw rc;
     4415    hrc = mVirtualBox->CreateMachine(Bstr(stack.strSettingsFilename).raw(),
     4416                                     Bstr(stack.strNameVBox).raw(),
     4417                                     ComSafeArrayAsInParam(groups),
     4418                                     Bstr(stack.strOsTypeVBox).raw(),
     4419                                     NULL, /* aCreateFlags */
     4420                                     NULL, /* aCipher */
     4421                                     NULL, /* aPasswordId */
     4422                                     NULL, /* aPassword */
     4423                                     pNewMachine.asOutParam());
     4424    if (FAILED(hrc)) throw hrc;
    44264425    pNewMachineRet = pNewMachine;
    44274426
     
    44294428    if (!stack.strDescription.isEmpty())
    44304429    {
    4431         rc = pNewMachine->COMSETTER(Description)(Bstr(stack.strDescription).raw());
    4432         if (FAILED(rc)) throw rc;
     4430        hrc = pNewMachine->COMSETTER(Description)(Bstr(stack.strDescription).raw());
     4431        if (FAILED(hrc)) throw hrc;
    44334432    }
    44344433
    44354434    // CPU count
    4436     rc = pNewMachine->COMSETTER(CPUCount)(stack.cCPUs);
    4437     if (FAILED(rc)) throw rc;
     4435    hrc = pNewMachine->COMSETTER(CPUCount)(stack.cCPUs);
     4436    if (FAILED(hrc)) throw hrc;
    44384437
    44394438    if (stack.fForceHWVirt)
    44404439    {
    4441         rc = pNewMachine->SetHWVirtExProperty(HWVirtExPropertyType_Enabled, TRUE);
    4442         if (FAILED(rc)) throw rc;
     4440        hrc = pNewMachine->SetHWVirtExProperty(HWVirtExPropertyType_Enabled, TRUE);
     4441        if (FAILED(hrc)) throw hrc;
    44434442    }
    44444443
    44454444    // RAM
    4446     rc = pNewMachine->COMSETTER(MemorySize)(stack.ulMemorySizeMB);
    4447     if (FAILED(rc)) throw rc;
     4445    hrc = pNewMachine->COMSETTER(MemorySize)(stack.ulMemorySizeMB);
     4446    if (FAILED(hrc)) throw hrc;
    44484447
    44494448    /* VRAM */
    44504449    /* Get the recommended VRAM for this guest OS type */
    44514450    ULONG vramVBox;
    4452     rc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
    4453     if (FAILED(rc)) throw rc;
     4451    hrc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
     4452    if (FAILED(hrc)) throw hrc;
    44544453
    44554454    /* Set the VRAM */
    44564455    ComPtr<IGraphicsAdapter> pGraphicsAdapter;
    4457     rc = pNewMachine->COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam());
    4458     if (FAILED(rc)) throw rc;
    4459     rc = pGraphicsAdapter->COMSETTER(VRAMSize)(vramVBox);
    4460     if (FAILED(rc)) throw rc;
     4456    hrc = pNewMachine->COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam());
     4457    if (FAILED(hrc)) throw hrc;
     4458    hrc = pGraphicsAdapter->COMSETTER(VRAMSize)(vramVBox);
     4459    if (FAILED(hrc)) throw hrc;
    44614460
    44624461    // I/O APIC: Generic OVF has no setting for this. Enable it if we
     
    44674466    {
    44684467        Bstr bstrFamilyId;
    4469         rc = osType->COMGETTER(FamilyId)(bstrFamilyId.asOutParam());
    4470         if (FAILED(rc)) throw rc;
     4468        hrc = osType->COMGETTER(FamilyId)(bstrFamilyId.asOutParam());
     4469        if (FAILED(hrc)) throw hrc;
    44714470        if (bstrFamilyId == "Windows")
    44724471            stack.fForceIOAPIC = true;
     
    44764475    {
    44774476        ComPtr<IBIOSSettings> pBIOSSettings;
    4478         rc = pNewMachine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
    4479         if (FAILED(rc)) throw rc;
    4480 
    4481         rc = pBIOSSettings->COMSETTER(IOAPICEnabled)(TRUE);
    4482         if (FAILED(rc)) throw rc;
     4477        hrc = pNewMachine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
     4478        if (FAILED(hrc)) throw hrc;
     4479
     4480        hrc = pBIOSSettings->COMSETTER(IOAPICEnabled)(TRUE);
     4481        if (FAILED(hrc)) throw hrc;
    44834482    }
    44844483
     
    44954494                firmwareType = FirmwareType_EFI;
    44964495        }
    4497         rc = pNewMachine->COMSETTER(FirmwareType)(firmwareType);
    4498         if (FAILED(rc)) throw rc;
     4496        hrc = pNewMachine->COMSETTER(FirmwareType)(firmwareType);
     4497        if (FAILED(hrc)) throw hrc;
    44994498    }
    45004499
     
    45034502        {
    45044503            ComPtr<IAudioSettings> audioSettings;
    4505             rc = pNewMachine->COMGETTER(AudioSettings)(audioSettings.asOutParam());
    4506             if (FAILED(rc)) throw rc;
     4504            hrc = pNewMachine->COMGETTER(AudioSettings)(audioSettings.asOutParam());
     4505            if (FAILED(hrc)) throw hrc;
    45074506            uint32_t audio = RTStrToUInt32(stack.strAudioAdapter.c_str());       // should be 0 for AC97
    45084507            ComPtr<IAudioAdapter> audioAdapter;
    4509             rc = audioSettings->COMGETTER(Adapter)(audioAdapter.asOutParam());
    4510             if (FAILED(rc)) throw rc;
    4511             rc = audioAdapter->COMSETTER(Enabled)(true);
    4512             if (FAILED(rc)) throw rc;
    4513             rc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
    4514             if (FAILED(rc)) throw rc;
     4508            hrc = audioSettings->COMGETTER(Adapter)(audioAdapter.asOutParam());
     4509            if (FAILED(hrc)) throw hrc;
     4510            hrc = audioAdapter->COMSETTER(Enabled)(true);
     4511            if (FAILED(hrc)) throw hrc;
     4512            hrc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
     4513            if (FAILED(hrc)) throw hrc;
    45154514        }
    45164515
     
    45204519    {
    45214520        ComPtr<IUSBController> usbController;
    4522         rc = pNewMachine->AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, usbController.asOutParam());
    4523         if (FAILED(rc)) throw rc;
     4521        hrc = pNewMachine->AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, usbController.asOutParam());
     4522        if (FAILED(hrc)) throw hrc;
    45244523    }
    45254524#endif /* VBOX_WITH_USB */
     
    45334532        /* No network adapters, so we have to disable our default one */
    45344533        ComPtr<INetworkAdapter> nwVBox;
    4535         rc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
    4536         if (FAILED(rc)) throw rc;
    4537         rc = nwVBox->COMSETTER(Enabled)(false);
    4538         if (FAILED(rc)) throw rc;
     4534        hrc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
     4535        if (FAILED(hrc)) throw hrc;
     4536        hrc = nwVBox->COMSETTER(Enabled)(false);
     4537        if (FAILED(hrc)) throw hrc;
    45394538    }
    45404539    else if (vsdeNW.size() > maxNetworkAdapters)
     
    45564555            uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
    45574556            ComPtr<INetworkAdapter> pNetworkAdapter;
    4558             rc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
    4559             if (FAILED(rc)) throw rc;
     4557            hrc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
     4558            if (FAILED(hrc)) throw hrc;
    45604559            /* Enable the network card & set the adapter type */
    4561             rc = pNetworkAdapter->COMSETTER(Enabled)(true);
    4562             if (FAILED(rc)) throw rc;
    4563             rc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
    4564             if (FAILED(rc)) throw rc;
     4560            hrc = pNetworkAdapter->COMSETTER(Enabled)(true);
     4561            if (FAILED(hrc)) throw hrc;
     4562            hrc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
     4563            if (FAILED(hrc)) throw hrc;
    45654564
    45664565            // default is NAT; change to "bridged" if extra conf says so
     
    45684567            {
    45694568                /* Attach to the right interface */
    4570                 rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged);
    4571                 if (FAILED(rc)) throw rc;
     4569                hrc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged);
     4570                if (FAILED(hrc)) throw hrc;
    45724571                ComPtr<IHost> host;
    4573                 rc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
    4574                 if (FAILED(rc)) throw rc;
     4572                hrc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
     4573                if (FAILED(hrc)) throw hrc;
    45754574                com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
    4576                 rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
    4577                 if (FAILED(rc)) throw rc;
     4575                hrc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
     4576                if (FAILED(hrc)) throw hrc;
    45784577                // We search for the first host network interface which
    45794578                // is usable for bridged networking
     
    45834582                {
    45844583                    HostNetworkInterfaceType_T itype;
    4585                     rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
    4586                     if (FAILED(rc)) throw rc;
     4584                    hrc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
     4585                    if (FAILED(hrc)) throw hrc;
    45874586                    if (itype == HostNetworkInterfaceType_Bridged)
    45884587                    {
    45894588                        Bstr name;
    4590                         rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
    4591                         if (FAILED(rc)) throw rc;
     4589                        hrc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
     4590                        if (FAILED(hrc)) throw hrc;
    45924591                        /* Set the interface name to attach to */
    4593                         rc = pNetworkAdapter->COMSETTER(BridgedInterface)(name.raw());
    4594                         if (FAILED(rc)) throw rc;
     4592                        hrc = pNetworkAdapter->COMSETTER(BridgedInterface)(name.raw());
     4593                        if (FAILED(hrc)) throw hrc;
    45954594                        break;
    45964595                    }
     
    46014600            {
    46024601                /* Attach to the right interface */
    4603                 rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly);
    4604                 if (FAILED(rc)) throw rc;
     4602                hrc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly);
     4603                if (FAILED(hrc)) throw hrc;
    46054604                ComPtr<IHost> host;
    4606                 rc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
    4607                 if (FAILED(rc)) throw rc;
     4605                hrc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
     4606                if (FAILED(hrc)) throw hrc;
    46084607                com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
    4609                 rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
    4610                 if (FAILED(rc)) throw rc;
     4608                hrc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
     4609                if (FAILED(hrc)) throw hrc;
    46114610                // We search for the first host network interface which
    46124611                // is usable for host only networking
     
    46164615                {
    46174616                    HostNetworkInterfaceType_T itype;
    4618                     rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
    4619                     if (FAILED(rc)) throw rc;
     4617                    hrc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
     4618                    if (FAILED(hrc)) throw hrc;
    46204619                    if (itype == HostNetworkInterfaceType_HostOnly)
    46214620                    {
    46224621                        Bstr name;
    4623                         rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
    4624                         if (FAILED(rc)) throw rc;
     4622                        hrc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
     4623                        if (FAILED(hrc)) throw hrc;
    46254624                        /* Set the interface name to attach to */
    4626                         rc = pNetworkAdapter->COMSETTER(HostOnlyInterface)(name.raw());
    4627                         if (FAILED(rc)) throw rc;
     4625                        hrc = pNetworkAdapter->COMSETTER(HostOnlyInterface)(name.raw());
     4626                        if (FAILED(hrc)) throw hrc;
    46284627                        break;
    46294628                    }
     
    46344633            {
    46354634                /* Attach to the right interface */
    4636                 rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Internal);
    4637                 if (FAILED(rc)) throw rc;
     4635                hrc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Internal);
     4636                if (FAILED(hrc)) throw hrc;
    46384637            }
    46394638            /* Next test for Generic interfaces */
     
    46414640            {
    46424641                /* Attach to the right interface */
    4643                 rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Generic);
    4644                 if (FAILED(rc)) throw rc;
     4642                hrc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Generic);
     4643                if (FAILED(hrc)) throw hrc;
    46454644            }
    46464645
     
    46494648            {
    46504649                /* Attach to the right interface */
    4651                 rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork);
    4652                 if (FAILED(rc)) throw rc;
     4650                hrc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork);
     4651                if (FAILED(hrc)) throw hrc;
    46534652                com::SafeIfaceArray<INATNetwork> nwNATNetworks;
    4654                 rc = mVirtualBox->COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nwNATNetworks));
    4655                 if (FAILED(rc)) throw rc;
     4653                hrc = mVirtualBox->COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nwNATNetworks));
     4654                if (FAILED(hrc)) throw hrc;
    46564655                // Pick the first NAT network (if there is any)
    46574656                if (nwNATNetworks.size())
    46584657                {
    46594658                    Bstr name;
    4660                     rc = nwNATNetworks[0]->COMGETTER(NetworkName)(name.asOutParam());
    4661                     if (FAILED(rc)) throw rc;
     4659                    hrc = nwNATNetworks[0]->COMGETTER(NetworkName)(name.asOutParam());
     4660                    if (FAILED(hrc)) throw hrc;
    46624661                    /* Set the NAT network name to attach to */
    4663                     rc = pNetworkAdapter->COMSETTER(NATNetwork)(name.raw());
    4664                     if (FAILED(rc)) throw rc;
     4662                    hrc = pNetworkAdapter->COMSETTER(NATNetwork)(name.raw());
     4663                    if (FAILED(hrc)) throw hrc;
    46654664                    break;
    46664665                }
     
    46854684        // one or two IDE controllers present in OVF: add one VirtualBox controller
    46864685        ComPtr<IStorageController> pController;
    4687         rc = pNewMachine->AddStorageController(Bstr("IDE").raw(), StorageBus_IDE, pController.asOutParam());
    4688         if (FAILED(rc)) throw rc;
     4686        hrc = pNewMachine->AddStorageController(Bstr("IDE").raw(), StorageBus_IDE, pController.asOutParam());
     4687        if (FAILED(hrc)) throw hrc;
    46894688
    46904689        const char *pcszIDEType = vsdeHDCIDE.front()->strVBoxCurrent.c_str();
    46914690        if (!strcmp(pcszIDEType, "PIIX3"))
    4692             rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
     4691            hrc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
    46934692        else if (!strcmp(pcszIDEType, "PIIX4"))
    4694             rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
     4693            hrc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
    46954694        else if (!strcmp(pcszIDEType, "ICH6"))
    4696             rc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
     4695            hrc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
    46974696        else
    46984697            throw setError(VBOX_E_FILE_ERROR,
    46994698                           tr("Invalid IDE controller type \"%s\""),
    47004699                           pcszIDEType);
    4701         if (FAILED(rc)) throw rc;
     4700        if (FAILED(hrc)) throw hrc;
    47024701    }
    47034702
     
    47144713        if (hdcVBox == "AHCI")
    47154714        {
    4716             rc = pNewMachine->AddStorageController(Bstr("SATA").raw(),
    4717                                                    StorageBus_SATA,
    4718                                                    pController.asOutParam());
    4719             if (FAILED(rc)) throw rc;
     4715            hrc = pNewMachine->AddStorageController(Bstr("SATA").raw(), StorageBus_SATA, pController.asOutParam());
     4716            if (FAILED(hrc)) throw hrc;
    47204717        }
    47214718        else
    4722             throw setError(VBOX_E_FILE_ERROR,
    4723                            tr("Invalid SATA controller type \"%s\""),
    4724                            hdcVBox.c_str());
     4719            throw setError(VBOX_E_FILE_ERROR, tr("Invalid SATA controller type \"%s\""), hdcVBox.c_str());
    47254720    }
    47264721
     
    47504745            controllerType = StorageControllerType_BusLogic;
    47514746        else
    4752             throw setError(VBOX_E_FILE_ERROR,
    4753                            tr("Invalid SCSI controller type \"%s\""),
    4754                            hdcVBox.c_str());
    4755 
    4756         rc = pNewMachine->AddStorageController(Bstr(strName).raw(), busType, pController.asOutParam());
    4757         if (FAILED(rc)) throw rc;
    4758         rc = pController->COMSETTER(ControllerType)(controllerType);
    4759         if (FAILED(rc)) throw rc;
     4747            throw setError(VBOX_E_FILE_ERROR, tr("Invalid SCSI controller type \"%s\""), hdcVBox.c_str());
     4748
     4749        hrc = pNewMachine->AddStorageController(Bstr(strName).raw(), busType, pController.asOutParam());
     4750        if (FAILED(hrc)) throw hrc;
     4751        hrc = pController->COMSETTER(ControllerType)(controllerType);
     4752        if (FAILED(hrc)) throw hrc;
    47604753    }
    47614754
     
    47694762    {
    47704763        ComPtr<IStorageController> pController;
    4771         rc = pNewMachine->AddStorageController(Bstr(L"SAS").raw(),
    4772                                                StorageBus_SAS,
    4773                                                pController.asOutParam());
    4774         if (FAILED(rc)) throw rc;
    4775         rc = pController->COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas);
    4776         if (FAILED(rc)) throw rc;
     4764        hrc = pNewMachine->AddStorageController(Bstr(L"SAS").raw(), StorageBus_SAS, pController.asOutParam());
     4765        if (FAILED(hrc)) throw hrc;
     4766        hrc = pController->COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas);
     4767        if (FAILED(hrc)) throw hrc;
    47774768    }
    47784769
     
    47914782        if (hdcVBox == "VirtioSCSI")
    47924783        {
    4793             rc = pNewMachine->AddStorageController(Bstr(strName).raw(),
    4794                                                    StorageBus_VirtioSCSI,
    4795                                                    pController.asOutParam());
    4796             if (FAILED(rc)) throw rc;
    4797 
    4798             rc = pController->COMSETTER(ControllerType)(StorageControllerType_VirtioSCSI);
    4799             if (FAILED(rc)) throw rc;
     4784            hrc = pNewMachine->AddStorageController(Bstr(strName).raw(), StorageBus_VirtioSCSI, pController.asOutParam());
     4785            if (FAILED(hrc)) throw hrc;
     4786
     4787            hrc = pController->COMSETTER(ControllerType)(StorageControllerType_VirtioSCSI);
     4788            if (FAILED(hrc)) throw hrc;
    48004789        }
    48014790        else
    4802             throw setError(VBOX_E_FILE_ERROR,
    4803                            tr("Invalid VirtioSCSI controller type \"%s\""),
    4804                            hdcVBox.c_str());
     4791            throw setError(VBOX_E_FILE_ERROR, tr("Invalid VirtioSCSI controller type \"%s\""), hdcVBox.c_str());
    48054792    }
    48064793
    48074794    /* Now its time to register the machine before we add any storage devices */
    4808     rc = mVirtualBox->RegisterMachine(pNewMachine);
    4809     if (FAILED(rc)) throw rc;
     4795    hrc = mVirtualBox->RegisterMachine(pNewMachine);
     4796    if (FAILED(hrc)) throw hrc;
    48104797
    48114798    // store new machine for roll-back in case of errors
    48124799    Bstr bstrNewMachineId;
    4813     rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
    4814     if (FAILED(rc)) throw rc;
     4800    hrc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
     4801    if (FAILED(hrc)) throw hrc;
    48154802    Guid uuidNewMachine(bstrNewMachineId);
    48164803    m->llGuidsMachinesCreated.push_back(uuidNewMachine);
     
    48324819        {
    48334820            // to attach things we need to open a session for the new machine
    4834             rc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
    4835             if (FAILED(rc)) throw rc;
     4821            hrc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
     4822            if (FAILED(hrc)) throw hrc;
    48364823            stack.fSessionOpen = true;
    48374824
    48384825            ComPtr<IMachine> sMachine;
    4839             rc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
    4840             if (FAILED(rc)) throw rc;
     4826            hrc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
     4827            if (FAILED(hrc)) throw hrc;
    48414828
    48424829            // floppy first
     
    48444831            {
    48454832                ComPtr<IStorageController> pController;
    4846                 rc = sMachine->AddStorageController(Bstr("Floppy").raw(),
    4847                                                     StorageBus_Floppy,
    4848                                                     pController.asOutParam());
    4849                 if (FAILED(rc)) throw rc;
     4833                hrc = sMachine->AddStorageController(Bstr("Floppy").raw(), StorageBus_Floppy, pController.asOutParam());
     4834                if (FAILED(hrc)) throw hrc;
    48504835
    48514836                Bstr bstrName;
    4852                 rc = pController->COMGETTER(Name)(bstrName.asOutParam());
    4853                 if (FAILED(rc)) throw rc;
     4837                hrc = pController->COMGETTER(Name)(bstrName.asOutParam());
     4838                if (FAILED(hrc)) throw hrc;
    48544839
    48554840                // this is for rollback later
     
    48624847                Log(("Attaching floppy\n"));
    48634848
    4864                 rc = sMachine->AttachDevice(Bstr(mhda.controllerName).raw(),
    4865                                             mhda.lControllerPort,
    4866                                             mhda.lDevice,
    4867                                             DeviceType_Floppy,
    4868                                             NULL);
    4869                 if (FAILED(rc)) throw rc;
     4849                hrc = sMachine->AttachDevice(Bstr(mhda.controllerName).raw(),
     4850                                             mhda.lControllerPort,
     4851                                             mhda.lDevice,
     4852                                             DeviceType_Floppy,
     4853                                             NULL);
     4854                if (FAILED(hrc)) throw hrc;
    48704855
    48714856                stack.llHardDiskAttachments.push_back(mhda);
    48724857            }
    48734858
    4874             rc = sMachine->SaveSettings();
    4875             if (FAILED(rc)) throw rc;
     4859            hrc = sMachine->SaveSettings();
     4860            if (FAILED(hrc)) throw hrc;
    48764861
    48774862            // only now that we're done with all storage devices, close the session
    4878             rc = stack.pSession->UnlockMachine();
    4879             if (FAILED(rc)) throw rc;
     4863            hrc = stack.pSession->UnlockMachine();
     4864            if (FAILED(hrc)) throw hrc;
    48804865            stack.fSessionOpen = false;
    48814866        }
     
    49184903
    49194904            // to attach things we need to open a session for the new machine
    4920             rc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
    4921             if (FAILED(rc)) throw rc;
     4905            hrc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
     4906            if (FAILED(hrc)) throw hrc;
    49224907            stack.fSessionOpen = true;
    49234908
     
    49884973                    }
    49894974l_skipped:
    4990                     rc = i_preCheckImageAvailability(stack);
    4991                     if (SUCCEEDED(rc))
     4975                    hrc = i_preCheckImageAvailability(stack);
     4976                    if (SUCCEEDED(hrc))
    49924977                    {
    49934978                        /* current opened file isn't the same as passed one */
     
    50785063
    50795064                    Guid id(ovfVdisk.strDiskId);
    5080                     rc = mVirtualBox->i_findHardDiskById(id, false, &pTargetMedium);
    5081                     if (FAILED(rc))
    5082                         throw rc;
     5065                    hrc = mVirtualBox->i_findHardDiskById(id, false, &pTargetMedium);
     5066                    if (FAILED(hrc))
     5067                        throw hrc;
    50835068                }
    50845069                else
     
    50925077                // now use the new uuid to attach the medium to our new machine
    50935078                ComPtr<IMachine> sMachine;
    5094                 rc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
    5095                 if (FAILED(rc))
    5096                     throw rc;
     5079                hrc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
     5080                if (FAILED(hrc))
     5081                    throw hrc;
    50975082
    50985083                // this is for rollback later
     
    51655150
    51665151                    ULONG ulMaxPorts;
    5167                     rc = i_verifyStorageControllerPortValid(hdStorageControllerType,
    5168                                                             uNewControllerPortValue,
    5169                                                             &ulMaxPorts);
    5170                     if (FAILED(rc))
     5152                    hrc = i_verifyStorageControllerPortValid(hdStorageControllerType, uNewControllerPortValue, &ulMaxPorts);
     5153                    if (FAILED(hrc))
    51715154                    {
    5172                         if (rc == E_INVALIDARG)
     5155                        if (hrc == E_INVALIDARG)
    51735156                        {
    51745157                            const char *pcszSCType = Global::stringifyStorageControllerType(hdStorageControllerType);
     
    51785161                        }
    51795162                        else
    5180                             throw rc;
     5163                            throw hrc;
    51815164                    }
    51825165
     
    51975180
    51985181                DeviceType_T devType = DeviceType_Null;
    5199                 rc = pTargetMedium->COMGETTER(DeviceType)(&devType);
    5200                 if (FAILED(rc))
    5201                     throw rc;
    5202 
    5203                 rc = sMachine->AttachDevice(Bstr(mhda.controllerName).raw(),// name
    5204                                             mhda.lControllerPort,     // long controllerPort
    5205                                             mhda.lDevice,             // long device
    5206                                             devType,                  // DeviceType_T type
    5207                                             pTargetMedium);
    5208                 if (FAILED(rc))
    5209                     throw rc;
     5182                hrc = pTargetMedium->COMGETTER(DeviceType)(&devType);
     5183                if (FAILED(hrc))
     5184                    throw hrc;
     5185
     5186                hrc = sMachine->AttachDevice(Bstr(mhda.controllerName).raw(),// name
     5187                                             mhda.lControllerPort,     // long controllerPort
     5188                                             mhda.lDevice,             // long device
     5189                                             devType,                  // DeviceType_T type
     5190                                             pTargetMedium);
     5191                if (FAILED(hrc))
     5192                    throw hrc;
    52105193
    52115194                stack.llHardDiskAttachments.push_back(mhda);
    52125195
    5213                 rc = sMachine->SaveSettings();
    5214                 if (FAILED(rc))
    5215                     throw rc;
     5196                hrc = sMachine->SaveSettings();
     5197                if (FAILED(hrc))
     5198                    throw hrc;
    52165199
    52175200                ++cImportedDisks;
     
    52295212
    52305213            // only now that we're done with all disks, close the session
    5231             rc = stack.pSession->UnlockMachine();
    5232             if (FAILED(rc))
    5233                 throw rc;
     5214            hrc = stack.pSession->UnlockMachine();
     5215            if (FAILED(hrc))
     5216                throw hrc;
    52345217            stack.fSessionOpen = false;
    52355218        }
     
    52855268    Assert(vsdescThis->m->pConfig);
    52865269
    5287     HRESULT rc = S_OK;
     5270    HRESULT hrc = S_OK;
    52885271
    52895272    settings::MachineConfigFile &config = *vsdescThis->m->pConfig;
     
    55475530            }
    55485531l_skipped:
    5549             rc = i_preCheckImageAvailability(stack);
    5550             if (SUCCEEDED(rc))
     5532            hrc = i_preCheckImageAvailability(stack);
     5533            if (SUCCEEDED(hrc))
    55515534            {
    55525535                /* current opened file isn't the same as passed one */
     
    57555738                        {
    57565739                            ULONG ulMaxPorts;
    5757                             rc = i_verifyStorageControllerPortValid(SC.controllerType,
    5758                                                                     uNewControllerPortValue,
    5759                                                                     &ulMaxPorts);
    5760                             if (FAILED(rc))
     5740                            hrc = i_verifyStorageControllerPortValid(SC.controllerType, uNewControllerPortValue, &ulMaxPorts);
     5741                            if (FAILED(hrc))
    57615742                            {
    5762                                 if (rc == E_INVALIDARG)
     5743                                if (hrc == E_INVALIDARG)
    57635744                                    throw setError(E_INVALIDARG,
    57645745                                                   tr("Illegal channel: '%u'.  For %s controllers the valid values are "
    57655746                                                   "0 to %lu (inclusive).\n"), uNewControllerPortValue, pcszSCType, ulMaxPorts-1);
    57665747                                else
    5767                                     throw rc;
     5748                                    throw hrc;
    57685749                            }
    57695750
     
    58985879                // the imported disk that was just created
    58995880                Bstr hdId;
    5900                 rc = pTargetMedium->COMGETTER(Id)(hdId.asOutParam());
    5901                 if (FAILED(rc)) throw rc;
     5881                hrc = pTargetMedium->COMGETTER(Id)(hdId.asOutParam());
     5882                if (FAILED(hrc)) throw hrc;
    59025883
    59035884                /*
     
    59065887                 */
    59075888                {
    5908                     rc = stack.saveOriginalUUIDOfAttachedDevice(d, Utf8Str(hdId));
     5889                    hrc = stack.saveOriginalUUIDOfAttachedDevice(d, Utf8Str(hdId));
    59095890                    d.uuid = hdId;
    59105891                }
     
    59415922
    59425923    ComObjPtr<Machine> pNewMachine;
    5943     rc = pNewMachine.createObject();
    5944     if (FAILED(rc)) throw rc;
     5924    hrc = pNewMachine.createObject();
     5925    if (FAILED(hrc)) throw hrc;
    59455926
    59465927    // this magic constructor fills the new machine object with the MachineConfig
    59475928    // instance that we created from the vbox:Machine
    5948     rc = pNewMachine->init(mVirtualBox,
    5949                            stack.strNameVBox,// name from OVF preparations; can be suffixed to avoid duplicates
    5950                            stack.strSettingsFilename,
    5951                            config);          // the whole machine config
    5952     if (FAILED(rc)) throw rc;
     5929    hrc = pNewMachine->init(mVirtualBox,
     5930                            stack.strNameVBox,// name from OVF preparations; can be suffixed to avoid duplicates
     5931                            stack.strSettingsFilename,
     5932                            config);          // the whole machine config
     5933    if (FAILED(hrc)) throw hrc;
    59535934
    59545935    pReturnNewMachine = ComPtr<IMachine>(pNewMachine);
    59555936
    59565937    // and register it
    5957     rc = mVirtualBox->RegisterMachine(pNewMachine);
    5958     if (FAILED(rc)) throw rc;
     5938    hrc = mVirtualBox->RegisterMachine(pNewMachine);
     5939    if (FAILED(hrc)) throw hrc;
    59595940
    59605941    // store new machine for roll-back in case of errors
    59615942    Bstr bstrNewMachineId;
    5962     rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
    5963     if (FAILED(rc)) throw rc;
     5943    hrc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
     5944    if (FAILED(hrc)) throw hrc;
    59645945    m->llGuidsMachinesCreated.push_back(Guid(bstrNewMachineId));
    59655946
     
    59765957
    59775958    // create a session for the machine + disks we manipulate below
    5978     HRESULT rc = stack.pSession.createInprocObject(CLSID_Session);
    5979     ComAssertComRCThrowRC(rc);
     5959    HRESULT hrc = stack.pSession.createInprocObject(CLSID_Session);
     5960    ComAssertComRCThrowRC(hrc);
    59805961
    59815962    list<ovf::VirtualSystem>::const_iterator it;
     
    60366017                strBaseFolder = vsdeBaseFolder.front()->strVBoxCurrent;
    60376018            Bstr bstrSettingsFilename;
    6038             rc = mVirtualBox->ComposeMachineFilename(Bstr(stack.strNameVBox).raw(),
    6039                                                      Bstr(stack.strPrimaryGroup).raw(),
    6040                                                      NULL /* aCreateFlags */,
    6041                                                      Bstr(strBaseFolder).raw(),
    6042                                                      bstrSettingsFilename.asOutParam());
    6043             if (FAILED(rc)) throw rc;
     6019            hrc = mVirtualBox->ComposeMachineFilename(Bstr(stack.strNameVBox).raw(),
     6020                                                      Bstr(stack.strPrimaryGroup).raw(),
     6021                                                      NULL /* aCreateFlags */,
     6022                                                      Bstr(strBaseFolder).raw(),
     6023                                                      bstrSettingsFilename.asOutParam());
     6024            if (FAILED(hrc)) throw hrc;
    60446025            stack.strSettingsFilename = bstrSettingsFilename;
    60456026        }
     
    61216102                                                     const Utf8Str &newlyUuid)
    61226103{
    6123     HRESULT rc = S_OK;
     6104    HRESULT hrc = S_OK;
    61246105
    61256106    /* save for restoring */
    61266107    mapNewUUIDsToOriginalUUIDs.insert(std::make_pair(newlyUuid, device.uuid.toString()));
    61276108
    6128     return rc;
     6109    return hrc;
    61296110}
    61306111
    61316112HRESULT Appliance::ImportStack::restoreOriginalUUIDOfAttachedDevice(settings::MachineConfigFile *config)
    61326113{
    6133     HRESULT rc = S_OK;
    6134 
    61356114    settings::StorageControllersList &llControllers = config->hardwareMachine.storage.llStorageControllers;
    61366115    settings::StorageControllersList::iterator itscl;
     
    61556134    }
    61566135
    6157     return rc;
     6136    return S_OK;
    61586137}
    61596138
  • trunk/src/VBox/Main/src-server/AudioAdapterImpl.cpp

    r98262 r98288  
    332332    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    333333
    334     HRESULT rc = S_OK;
     334    HRESULT hrc = S_OK;
    335335
    336336    if (m->bd->driverType != aAudioDriver)
     
    348348        {
    349349            AssertMsgFailed(("Wrong audio driver type %d\n", aAudioDriver));
    350             rc = E_FAIL;
    351         }
    352     }
    353 
    354     return rc;
     350            hrc = E_FAIL;
     351        }
     352    }
     353
     354    return hrc;
    355355}
    356356
  • trunk/src/VBox/Main/src-server/AudioSettingsImpl.cpp

    r98262 r98288  
    372372
    373373    AudioControllerType_T audioController;
    374     HRESULT rc = aGuestOsType->COMGETTER(RecommendedAudioController)(&audioController);
    375     if (FAILED(rc)) return rc;
    376 
    377     rc = m->pAdapter->COMSETTER(AudioController)(audioController);
    378     if (FAILED(rc)) return rc;
     374    HRESULT hrc = aGuestOsType->COMGETTER(RecommendedAudioController)(&audioController);
     375    if (FAILED(hrc)) return hrc;
     376
     377    hrc = m->pAdapter->COMSETTER(AudioController)(audioController);
     378    if (FAILED(hrc)) return hrc;
    379379
    380380    AudioCodecType_T audioCodec;
    381     rc = aGuestOsType->COMGETTER(RecommendedAudioCodec)(&audioCodec);
    382     if (FAILED(rc)) return rc;
    383 
    384     rc = m->pAdapter->COMSETTER(AudioCodec)(audioCodec);
    385     if (FAILED(rc)) return rc;
    386 
    387     rc = m->pAdapter->COMSETTER(Enabled)(true);
    388     if (FAILED(rc)) return rc;
    389 
    390     rc = m->pAdapter->COMSETTER(EnabledOut)(true);
    391     if (FAILED(rc)) return rc;
     381    hrc = aGuestOsType->COMGETTER(RecommendedAudioCodec)(&audioCodec);
     382    if (FAILED(hrc)) return hrc;
     383
     384    hrc = m->pAdapter->COMSETTER(AudioCodec)(audioCodec);
     385    if (FAILED(hrc)) return hrc;
     386
     387    hrc = m->pAdapter->COMSETTER(Enabled)(true);
     388    if (FAILED(hrc)) return hrc;
     389
     390    hrc = m->pAdapter->COMSETTER(EnabledOut)(true);
     391    if (FAILED(hrc)) return hrc;
    392392
    393393    /* Note: We do NOT enable audio input by default due to security reasons!
  • trunk/src/VBox/Main/src-server/BandwidthControlImpl.cpp

    r98262 r98288  
    489489
    490490    ComObjPtr<BandwidthGroup> group;
    491     HRESULT rc = i_getBandwidthGroupByName(aName, group, true /* aSetError */);
    492     if (FAILED(rc)) return rc;
     491    HRESULT hrc = i_getBandwidthGroupByName(aName, group, true /* aSetError */);
     492    if (FAILED(hrc)) return hrc;
    493493
    494494    if (group->i_getReferences() != 0)
     
    525525
    526526    ComObjPtr<BandwidthGroup> group;
    527     HRESULT rc = i_getBandwidthGroupByName(aName, group, true /* aSetError */);
    528 
    529     if (SUCCEEDED(rc))
     527    HRESULT hrc = i_getBandwidthGroupByName(aName, group, true /* aSetError */);
     528    if (SUCCEEDED(hrc))
    530529        group.queryInterfaceTo(aBandwidthGroup.asOutParam());
    531530
    532     return rc;
     531    return hrc;
    533532}
    534533
     
    548547HRESULT BandwidthControl::i_loadSettings(const settings::IOSettings &data)
    549548{
    550     HRESULT rc = S_OK;
     549    HRESULT hrc = S_OK;
    551550
    552551    AutoCaller autoCaller(this);
     
    558557    {
    559558        const settings::BandwidthGroup &gr = *it;
    560         rc = createBandwidthGroup(gr.strName, gr.enmType, (LONG64)gr.cMaxBytesPerSec);
    561         if (FAILED(rc)) break;
    562     }
    563 
    564     return rc;
     559        hrc = createBandwidthGroup(gr.strName, gr.enmType, (LONG64)gr.cMaxBytesPerSec);
     560        if (FAILED(hrc)) break;
     561    }
     562
     563    return hrc;
    565564}
    566565
  • trunk/src/VBox/Main/src-server/CertificateImpl.cpp

    r98103 r98288  
    111111HRESULT Certificate::initCertificate(PCRTCRX509CERTIFICATE a_pCert, bool a_fTrusted, bool a_fExpired)
    112112{
    113     HRESULT rc = S_OK;
     113    HRESULT hrc = S_OK;
    114114    LogFlowThisFuncEnter();
    115115
     
    128128    }
    129129    else
    130         rc = Global::vboxStatusCodeToCOM(vrc);
    131 
    132     LogFlowThisFunc(("returns rc=%Rhrc\n", rc));
    133     return rc;
     130        hrc = Global::vboxStatusCodeToCOM(vrc);
     131
     132    LogFlowThisFunc(("returns hrc=%Rhrc\n", hrc));
     133    return hrc;
    134134}
    135135
  • trunk/src/VBox/Main/src-server/ClientToken.cpp

    r98103 r98288  
    260260#elif defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
    261261    ComObjPtr<MachineToken> pToken;
    262     HRESULT rc = pToken.createObject();
    263     if (SUCCEEDED(rc))
    264     {
    265         rc = pToken->init(pSessionMachine);
    266         if (SUCCEEDED(rc))
     262    HRESULT hrc = pToken.createObject();
     263    if (SUCCEEDED(hrc))
     264    {
     265        hrc = pToken->init(pSessionMachine);
     266        if (SUCCEEDED(hrc))
    267267        {
    268268            mClientToken = pToken;
    269269            if (mClientToken)
    270270            {
    271                 rc = mClientToken->AddRef();
    272                 if (FAILED(rc))
     271                hrc = mClientToken->AddRef();
     272                if (FAILED(hrc))
    273273                    mClientToken = NULL;
    274274            }
     
    279279    /* mClientTokenId isn't really used */
    280280    mClientTokenId = pMachine->mData->m_strConfigFileFull;
    281     AssertMsg(mClientToken,
    282               ("Cannot create token '%s', rc=%Rhrc",
    283                mClientTokenId.c_str(), rc));
     281    AssertMsg(mClientToken, ("Cannot create token '%s', hrc=%Rhrc", mClientTokenId.c_str(), hrc));
    284282#else
    285283# error "Port me!"
  • trunk/src/VBox/Main/src-server/ClientWatcher.cpp

    r98103 r98288  
    873873            }
    874874
    875             int rc = RTSemEventWait(that->mUpdateReq, cMillies);
     875            int vrc = RTSemEventWait(that->mUpdateReq, cMillies);
    876876
    877877            /*
     
    883883                break;
    884884
    885             if (RT_SUCCESS(rc) || update || updateSpawned)
    886             {
    887                 /* RT_SUCCESS(rc) means an update event is signaled */
     885            if (RT_SUCCESS(vrc) || update || updateSpawned)
     886            {
     887                /* RT_SUCCESS(vrc) means an update event is signaled */
    888888
    889889                // get reference to the machines list in VirtualBox
     
    893893                AutoReadLock thatLock(allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
    894894
    895                 if (RT_SUCCESS(rc) || update)
     895                if (RT_SUCCESS(vrc) || update)
    896896                {
    897897                    /* obtain a new set of opened machines */
     
    911911                }
    912912
    913                 if (RT_SUCCESS(rc) || updateSpawned)
     913                if (RT_SUCCESS(vrc) || updateSpawned)
    914914                {
    915915                    /* obtain a new set of spawned machines */
     
    982982            }
    983983
    984             int rc = RTSemEventWait(that->mUpdateReq, cMillies);
     984            int vrc = RTSemEventWait(that->mUpdateReq, cMillies);
    985985
    986986            /*
     
    998998             * from the pid to the corresponding machine object. Both cases do
    999999             * more or less the same thing anyway. */
    1000             if (RT_SUCCESS(rc) || updateSpawned)
    1001             {
    1002                 /* RT_SUCCESS(rc) means an update event is signaled */
     1000            if (RT_SUCCESS(vrc) || updateSpawned)
     1001            {
     1002                /* RT_SUCCESS(vrc) means an update event is signaled */
    10031003
    10041004                // get reference to the machines list in VirtualBox
     
    10081008                AutoReadLock thatLock(allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
    10091009
    1010                 if (RT_SUCCESS(rc) || updateSpawned)
     1010                if (RT_SUCCESS(vrc) || updateSpawned)
    10111011                {
    10121012                    /* obtain a new set of spawned machines */
  • trunk/src/VBox/Main/src-server/CloudNetworkImpl.cpp

    r98262 r98288  
    168168
    169169    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    170     HRESULT rc = m->pVirtualBox->i_saveSettings();
    171     ComAssertComRCRetRC(rc);
     170    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     171    ComAssertComRCRetRC(hrc);
    172172    return S_OK;
    173173}
     
    190190
    191191    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    192     HRESULT rc = m->pVirtualBox->i_saveSettings();
    193     ComAssertComRCRetRC(rc);
     192    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     193    ComAssertComRCRetRC(hrc);
    194194    return S_OK;
    195195}
     
    212212
    213213    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    214     HRESULT rc = m->pVirtualBox->i_saveSettings();
    215     ComAssertComRCRetRC(rc);
     214    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     215    ComAssertComRCRetRC(hrc);
    216216    return S_OK;
    217217}
     
    234234
    235235    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    236     HRESULT rc = m->pVirtualBox->i_saveSettings();
    237     ComAssertComRCRetRC(rc);
     236    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     237    ComAssertComRCRetRC(hrc);
    238238    return S_OK;
    239239}
     
    256256
    257257    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    258     HRESULT rc = m->pVirtualBox->i_saveSettings();
    259     ComAssertComRCRetRC(rc);
    260     return S_OK;
    261 }
    262 
     258    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     259    ComAssertComRCRetRC(hrc);
     260    return S_OK;
     261}
     262
  • trunk/src/VBox/Main/src-server/DHCPConfigImpl.cpp

    r98103 r98288  
    392392     */
    393393    DhcpOption *pParsed = NULL;
    394     int         rc      = VINF_SUCCESS;
     394    int         vrc     = VINF_SUCCESS;
    395395    try
    396396    {
    397         pParsed = DhcpOption::parse((uint8_t)aOption, aEncoding, aValue.c_str(), &rc);
     397        pParsed = DhcpOption::parse((uint8_t)aOption, aEncoding, aValue.c_str(), &vrc);
    398398    }
    399399    catch (std::bad_alloc &)
     
    423423    }
    424424
    425     if (rc == VERR_WRONG_TYPE)
     425    if (vrc == VERR_WRONG_TYPE)
    426426        return m_pHack->setError(E_INVALIDARG, tr("Unsupported encoding %d (option %d, value %s)"),
    427427                                 (int)aEncoding, (int)aOption, aValue.c_str());
    428     if (rc == VERR_NOT_SUPPORTED)
     428    if (vrc == VERR_NOT_SUPPORTED)
    429429        return m_pHack->setError(E_INVALIDARG, tr("Unsupported option %d (encoding %d, value %s)"),
    430430                                 (int)aOption, (int)aEncoding, aValue.c_str());
    431     return m_pHack->setError(E_INVALIDARG, tr("Malformed option %d value '%s' (encoding %d, rc=%Rrc)"),
    432                              (int)aOption, aValue.c_str(), (int)aEncoding, rc);
     431    return m_pHack->setError(E_INVALIDARG, tr("Malformed option %d value '%s' (encoding %d, vrc=%Rrc)"),
     432                             (int)aOption, aValue.c_str(), (int)aEncoding, vrc);
    433433}
    434434
  • trunk/src/VBox/Main/src-server/HostDnsService.cpp

    r98103 r98288  
    198198        LogRel2(("HostDnsMonitor: starting thread ...\n"));
    199199
    200         int rc = RTSemEventCreate(&m->hMonitorThreadEvent);
    201         AssertRCReturn(rc, E_FAIL);
    202 
    203         rc = RTThreadCreate(&m->hMonitorThread,
    204                             HostDnsServiceBase::threadMonitorProc,
    205                             this, 128 * _1K, RTTHREADTYPE_IO,
    206                             RTTHREADFLAGS_WAITABLE, "dns-monitor");
    207         AssertRCReturn(rc, E_FAIL);
     200        int vrc = RTSemEventCreate(&m->hMonitorThreadEvent);
     201        AssertRCReturn(vrc, E_FAIL);
     202
     203        vrc = RTThreadCreate(&m->hMonitorThread,
     204                             HostDnsServiceBase::threadMonitorProc,
     205                             this, 128 * _1K, RTTHREADTYPE_IO,
     206                             RTTHREADFLAGS_WAITABLE, "dns-monitor");
     207        AssertRCReturn(vrc, E_FAIL);
    208208
    209209        RTSemEventWait(m->hMonitorThreadEvent, RT_INDEFINITE_WAIT);
     
    227227        monitorThreadShutdown(uTimeoutMs);
    228228
    229         int rc = RTThreadWait(m->hMonitorThread, uTimeoutMs, NULL);
    230         if (RT_FAILURE(rc))
    231             LogRel(("HostDnsMonitor: waiting for thread failed with rc=%Rrc\n", rc));
     229        int vrc = RTThreadWait(m->hMonitorThread, uTimeoutMs, NULL);
     230        if (RT_FAILURE(vrc))
     231            LogRel(("HostDnsMonitor: waiting for thread failed with vrc=%Rrc\n", vrc));
    232232
    233233        if (m->hMonitorThreadEvent != NIL_RTSEMEVENT)
  • trunk/src/VBox/Main/src-server/HostDnsServiceResolvConf.cpp

    r98103 r98288  
    106106
    107107    st.rcps_flags = RCPSF_NO_STR2IPCONV;
    108     int rc = rcp_parse(&st, m->resolvConfFilename.c_str());
    109     if (rc == -1)
     108    int vrc = rcp_parse(&st, m->resolvConfFilename.c_str());
     109    if (vrc == -1)
    110110        return S_OK;
    111111
  • trunk/src/VBox/Main/src-server/HostImpl.cpp

    r98262 r98288  
    387387                {
    388388                    const char *pszIgn;
    389                     int rc = SUPR3QueryVTxSupported(&pszIgn);
    390                     if (RT_SUCCESS(rc))
     389                    int vrc = SUPR3QueryVTxSupported(&pszIgn);
     390                    if (RT_SUCCESS(vrc))
    391391                        m->fVTSupported = true;
    392392                }
     
    590590
    591591    MediaList *pList;
    592     HRESULT rc = i_getDrives(DeviceType_DVD, true /* fRefresh */, pList, treeLock);
    593     if (FAILED(rc))
    594         return rc;
     592    HRESULT vrc = i_getDrives(DeviceType_DVD, true /* fRefresh */, pList, treeLock);
     593    if (FAILED(vrc))
     594        return vrc;
    595595
    596596    aDVDDrives.resize(pList->size());
     
    613613
    614614    MediaList *pList;
    615     HRESULT rc = i_getDrives(DeviceType_Floppy, true /* fRefresh */, pList, treeLock);
    616     if (FAILED(rc))
    617         return rc;
     615    HRESULT vrc = i_getDrives(DeviceType_Floppy, true /* fRefresh */, pList, treeLock);
     616    if (FAILED(vrc))
     617        return vrc;
    618618
    619619    aFloppyDrives.resize(pList->size());
     
    635635    GUID IfGuid;
    636636    HRESULT hr;
    637     int rc = VERR_GENERAL_FAILURE;
     637    int vrc = VERR_GENERAL_FAILURE;
    638638
    639639    hr = pncc->GetDisplayName(&lpszName);
     
    655655//                iface->setVirtualBox(m->pParent);
    656656                pPist->push_back(iface);
    657                 rc = VINF_SUCCESS;
     657                vrc = VINF_SUCCESS;
    658658            }
    659659            else
     
    665665    }
    666666
    667     return rc;
     667    return vrc;
    668668}
    669669#endif /* defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
     
    830830#if defined(RT_OS_WINDOWS) || defined(VBOX_WITH_NETFLT) /*|| defined(RT_OS_OS2)*/
    831831# ifdef VBOX_WITH_HOSTNETIF_API
    832     HRESULT rc = i_updateNetIfList();
    833     if (FAILED(rc))
    834     {
    835         Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
    836         return rc;
     832    HRESULT vrc = i_updateNetIfList();
     833    if (FAILED(vrc))
     834    {
     835        Log(("Failed to update host network interface list with vrc=%Rhrc\n", vrc));
     836        return vrc;
    837837    }
    838838#if defined(RT_OS_WINDOWS)
    839     rc = i_updatePersistentConfigForHostOnlyAdapters();
    840     if (FAILED(rc))
    841     {
    842         LogRel(("Failed to update persistent config for host-only adapters with rc=%Rhrc\n", rc));
    843         return rc;
     839    vrc = i_updatePersistentConfigForHostOnlyAdapters();
     840    if (FAILED(vrc))
     841    {
     842        LogRel(("Failed to update persistent config for host-only adapters with vrc=%Rhrc\n", vrc));
     843        return vrc;
    844844    }
    845845#endif /* defined(RT_OS_WINDOWS) */
     
    10321032    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    10331033
    1034     MultiResult rc = i_checkUSBProxyService();
    1035     if (FAILED(rc) || SUCCEEDED_WARNING(rc))
    1036         return rc;
     1034    MultiResult vrc = i_checkUSBProxyService();
     1035    if (FAILED(vrc) || SUCCEEDED_WARNING(vrc))
     1036        return vrc;
    10371037
    10381038    return m->pUSBProxyService->getDeviceCollection(aUSBDevices);
     
    10811081    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    10821082
    1083     MultiResult rc = i_checkUSBProxyService();
    1084     if (FAILED(rc))
    1085         return rc;
     1083    MultiResult vrc = i_checkUSBProxyService();
     1084    if (FAILED(vrc))
     1085        return vrc;
    10861086
    10871087    aUSBDeviceFilters.resize(m->llUSBDeviceFilters.size());
     
    10901090        (*it).queryInterfaceTo(aUSBDeviceFilters[i].asOutParam());
    10911091
    1092     return rc;
     1092    return vrc;
    10931093#else
    10941094    /* Note: The GUI depends on this method returning E_NOTIMPL with no
     
    12091209{
    12101210    /* Perhaps the driver is available now... */
    1211     int rc = SUPR3InitEx(SUPR3INIT_F_LIMITED, NULL);
    1212     if (RT_SUCCESS(rc))
     1211    int vrc = SUPR3InitEx(SUPR3INIT_F_LIMITED, NULL);
     1212    if (RT_SUCCESS(vrc))
    12131213    {
    12141214        uint32_t fVTCaps;
    1215         rc = SUPR3QueryVTCaps(&fVTCaps);
    1216         AssertMsg(RT_SUCCESS(rc) || rc == VERR_SUP_DRIVERLESS, ("SUPR3QueryVTCaps failed rc=%Rrc\n", rc));
     1215        vrc = SUPR3QueryVTCaps(&fVTCaps);
     1216        AssertMsg(RT_SUCCESS(vrc) || vrc == VERR_SUP_DRIVERLESS, ("SUPR3QueryVTCaps failed vrc=%Rrc\n", vrc));
    12171217
    12181218        SUPR3Term(false);
    12191219
    12201220        AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
    1221         if (RT_FAILURE(rc))
     1221        if (RT_FAILURE(vrc))
    12221222        {
    12231223            fVTCaps = 0;
    1224             if (rc != VERR_SUP_DRIVERLESS)
    1225                 LogRel(("SUPR0QueryVTCaps -> %Rrc\n", rc));
     1224            if (vrc != VERR_SUP_DRIVERLESS)
     1225                LogRel(("SUPR0QueryVTCaps -> %Rrc\n", vrc));
    12261226# if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) /* Preserve detected VT-x/AMD-V support for show. */
    12271227            else
     
    13761376
    13771377    uint64_t cb;
    1378     int rc = RTSystemQueryTotalRam(&cb);
    1379     if (RT_FAILURE(rc))
     1378    int vrc = RTSystemQueryTotalRam(&cb);
     1379    if (RT_FAILURE(vrc))
    13801380        return E_FAIL;
    13811381    *aSize = (ULONG)(cb / _1M);
     
    13941394
    13951395    uint64_t cb;
    1396     int rc = RTSystemQueryAvailableRam(&cb);
    1397     if (RT_FAILURE(rc))
     1396    int vrc = RTSystemQueryAvailableRam(&cb);
     1397    if (RT_FAILURE(vrc))
    13981398        return E_FAIL;
    13991399    *aAvailable = (ULONG)(cb / _1M);
     
    15721572
    15731573    Bstr name;
    1574     HRESULT rc;
     1574    HRESULT hrc;
    15751575
    15761576    /* first check whether an interface with the given name already exists */
    15771577    {
    15781578        ComPtr<IHostNetworkInterface> iface;
    1579         rc = findHostNetworkInterfaceById(aId, iface);
    1580         if (FAILED(rc))
     1579        hrc = findHostNetworkInterfaceById(aId, iface);
     1580        if (FAILED(hrc))
    15811581            return setError(VBOX_E_OBJECT_NOT_FOUND,
    15821582                            tr("Host network interface with UUID {%RTuuid} does not exist"),
    15831583                            Guid(aId).raw());
    1584         rc = iface->COMGETTER(Name)(name.asOutParam());
    1585         ComAssertComRCRet(rc, rc);
    1586     }
    1587 
    1588     int r = NetIfRemoveHostOnlyNetworkInterface(m->pParent, aId, aProgress.asOutParam());
    1589     if (RT_SUCCESS(r))
     1584        hrc = iface->COMGETTER(Name)(name.asOutParam());
     1585        ComAssertComRCRet(hrc, hrc);
     1586    }
     1587
     1588    int vrc = NetIfRemoveHostOnlyNetworkInterface(m->pParent, aId, aProgress.asOutParam());
     1589    if (RT_SUCCESS(vrc))
    15901590    {
    15911591        /* Drop configuration parameters for removed interface */
    15921592#ifdef RT_OS_WINDOWS
    1593         rc = i_removePersistentConfig(Utf8StrFmt("%RTuuid", &aId));
    1594         if (FAILED(rc))
    1595             LogRel(("i_removePersistentConfig(%RTuuid) failed with 0x%x\n", &aId, rc));
     1593        hrc = i_removePersistentConfig(Utf8StrFmt("%RTuuid", &aId));
     1594        if (FAILED(hrc))
     1595            LogRel(("i_removePersistentConfig(%RTuuid) failed with 0x%x\n", &aId, hrc));
    15961596#else /* !RT_OS_WINDOWS */
    1597         rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", name.raw()).raw(), NULL);
    1598         rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", name.raw()).raw(), NULL);
    1599         rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", name.raw()).raw(), NULL);
    1600         rc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", name.raw()).raw(), NULL);
     1597        hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", name.raw()).raw(), NULL);
     1598        hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", name.raw()).raw(), NULL);
     1599        hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", name.raw()).raw(), NULL);
     1600        hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", name.raw()).raw(), NULL);
    16011601#endif /* !RT_OS_WINDOWS */
    16021602
     
    16041604    }
    16051605
    1606     return r == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
     1606    return vrc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
    16071607#else
    16081608    RT_NOREF(aId, aProgress);
     
    16201620    ComObjPtr<HostUSBDeviceFilter> filter;
    16211621    filter.createObject();
    1622     HRESULT rc = filter->init(this, Bstr(aName).raw());
    1623     ComAssertComRCRet(rc, rc);
    1624     rc = filter.queryInterfaceTo(aFilter.asOutParam());
    1625     AssertComRCReturn(rc, rc);
     1622    HRESULT hrc = filter->init(this, Bstr(aName).raw());
     1623    ComAssertComRCRet(hrc, hrc);
     1624    hrc = filter.queryInterfaceTo(aFilter.asOutParam());
     1625    AssertComRCReturn(hrc, hrc);
    16261626    return S_OK;
    16271627#else
     
    16421642    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    16431643
    1644     MultiResult rc = i_checkUSBProxyService();
    1645     if (FAILED(rc))
    1646         return rc;
     1644    MultiResult hrcMult = i_checkUSBProxyService();
     1645    if (FAILED(hrcMult))
     1646        return hrcMult;
    16471647
    16481648    ComObjPtr<HostUSBDeviceFilter> pFilter;
     
    16831683    alock.release();
    16841684    AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
    1685     return rc = m->pParent->i_saveSettings();
     1685    return hrcMult = m->pParent->i_saveSettings();
    16861686#else
    16871687
     
    17011701    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    17021702
    1703     MultiResult rc = i_checkUSBProxyService();
    1704     if (FAILED(rc))
    1705         return rc;
     1703    MultiResult hrcMult = i_checkUSBProxyService();
     1704    if (FAILED(hrcMult))
     1705        return hrcMult;
    17061706
    17071707    if (!m->llUSBDeviceFilters.size())
     
    17371737    alock.release();
    17381738    AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
    1739     return rc = m->pParent->i_saveSettings();
     1739    return hrcMult = m->pParent->i_saveSettings();
    17401740#else
    17411741    /* Note: The GUI depends on this method returning E_NOTIMPL with no
     
    17511751{
    17521752    ComObjPtr<Medium> medium;
    1753     HRESULT rc = i_findHostDriveByNameOrId(DeviceType_DVD, aName, medium);
    1754     if (SUCCEEDED(rc))
    1755         rc = medium.queryInterfaceTo(aDrive.asOutParam());
     1753    HRESULT hrc = i_findHostDriveByNameOrId(DeviceType_DVD, aName, medium);
     1754    if (SUCCEEDED(hrc))
     1755        hrc = medium.queryInterfaceTo(aDrive.asOutParam());
    17561756    else
    1757         rc = setError(rc, tr("The host DVD drive named '%s' could not be found"), aName.c_str());
    1758     return rc;
     1757        hrc = setError(hrc, tr("The host DVD drive named '%s' could not be found"), aName.c_str());
     1758    return hrc;
    17591759}
    17601760
     
    17651765    ComObjPtr<Medium>medium;
    17661766
    1767     HRESULT rc = i_findHostDriveByNameOrId(DeviceType_Floppy, aName, medium);
    1768     if (SUCCEEDED(rc))
     1767    HRESULT hrc = i_findHostDriveByNameOrId(DeviceType_Floppy, aName, medium);
     1768    if (SUCCEEDED(hrc))
    17691769        return medium.queryInterfaceTo(aDrive.asOutParam());
    1770     else
    1771         return setError(rc, tr("The host floppy drive named '%s' could not be found"), aName.c_str());
     1770    return setError(hrc, tr("The host floppy drive named '%s' could not be found"), aName.c_str());
    17721771}
    17731772
     
    17821781        return E_INVALIDARG;
    17831782
    1784     HRESULT rc = i_updateNetIfList();
    1785     if (FAILED(rc))
    1786     {
    1787         Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
    1788         return rc;
     1783    HRESULT hrc = i_updateNetIfList();
     1784    if (FAILED(hrc))
     1785    {
     1786        Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
     1787        return hrc;
    17891788    }
    17901789#if defined(RT_OS_WINDOWS)
    1791     rc = i_updatePersistentConfigForHostOnlyAdapters();
    1792     if (FAILED(rc))
    1793     {
    1794         LogRel(("Failed to update persistent config for host-only adapters with rc=%Rhrc\n", rc));
    1795         return rc;
     1790    hrc = i_updatePersistentConfigForHostOnlyAdapters();
     1791    if (FAILED(hrc))
     1792    {
     1793        LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
     1794        return hrc;
    17961795    }
    17971796#endif /* defined(RT_OS_WINDOWS) */
     
    18261825        return E_INVALIDARG;
    18271826
    1828     HRESULT rc = i_updateNetIfList();
    1829     if (FAILED(rc))
    1830     {
    1831         Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
    1832         return rc;
     1827    HRESULT hrc = i_updateNetIfList();
     1828    if (FAILED(hrc))
     1829    {
     1830        Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
     1831        return hrc;
    18331832    }
    18341833#if defined(RT_OS_WINDOWS)
    1835     rc = i_updatePersistentConfigForHostOnlyAdapters();
    1836     if (FAILED(rc))
    1837     {
    1838         LogRel(("Failed to update persistent config for host-only adapters with rc=%Rhrc\n", rc));
    1839         return rc;
     1834    hrc = i_updatePersistentConfigForHostOnlyAdapters();
     1835    if (FAILED(hrc))
     1836    {
     1837        LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
     1838        return hrc;
    18401839    }
    18411840#endif /* defined(RT_OS_WINDOWS) */
     
    18641863{
    18651864#ifdef VBOX_WITH_HOSTNETIF_API
    1866     HRESULT rc = i_updateNetIfList();
    1867     if (FAILED(rc))
    1868     {
    1869         Log(("Failed to update host network interface list with rc=%Rhrc\n", rc));
    1870         return rc;
     1865    HRESULT hrc = i_updateNetIfList();
     1866    if (FAILED(hrc))
     1867    {
     1868        Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
     1869        return hrc;
    18711870    }
    18721871#if defined(RT_OS_WINDOWS)
    1873     rc = i_updatePersistentConfigForHostOnlyAdapters();
    1874     if (FAILED(rc))
    1875     {
    1876         LogRel(("Failed to update persistent config for host-only adapters with rc=%Rhrc\n", rc));
    1877         return rc;
     1872    hrc = i_updatePersistentConfigForHostOnlyAdapters();
     1873    if (FAILED(hrc))
     1874    {
     1875        LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
     1876        return hrc;
    18781877    }
    18791878#endif /* defined(RT_OS_WINDOWS) */
     
    19131912    aDevice = NULL;
    19141913    SafeIfaceArray<IHostUSBDevice> devsvec;
    1915     HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
    1916     if (FAILED(rc))
    1917         return rc;
     1914    HRESULT hrc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
     1915    if (FAILED(hrc))
     1916        return hrc;
    19181917
    19191918    for (size_t i = 0; i < devsvec.size(); ++i)
    19201919    {
    19211920        Bstr address;
    1922         rc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
    1923         if (FAILED(rc))
    1924             return rc;
     1921        hrc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
     1922        if (FAILED(hrc))
     1923            return hrc;
    19251924        if (address == aName)
    19261925        {
     
    19481947
    19491948    SafeIfaceArray<IHostUSBDevice> devsvec;
    1950     HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
    1951     if (FAILED(rc))
    1952         return rc;
     1949    HRESULT hrc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
     1950    if (FAILED(hrc))
     1951        return hrc;
    19531952
    19541953    for (size_t i = 0; i < devsvec.size(); ++i)
    19551954    {
    19561955        Bstr id;
    1957         rc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
    1958         if (FAILED(rc))
    1959             return rc;
     1956        hrc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
     1957        if (FAILED(hrc))
     1958            return hrc;
    19601959        if (Guid(id) == aId)
    19611960        {
     
    19911990    HostVideoInputDeviceList list;
    19921991
    1993     HRESULT rc = HostVideoInputDevice::queryHostDevices(m->pParent, &list);
    1994     if (FAILED(rc))
    1995         return rc;
     1992    HRESULT hrc = HostVideoInputDevice::queryHostDevices(m->pParent, &list);
     1993    if (FAILED(hrc))
     1994        return hrc;
    19961995
    19971996    aVideoInputDevices.resize(list.size());
     
    20772076HRESULT Host::i_loadSettings(const settings::Host &data)
    20782077{
    2079     HRESULT rc = S_OK;
     2078    HRESULT hrc = S_OK;
    20802079#ifdef VBOX_WITH_USB
    20812080    AutoCaller autoCaller(this);
     
    20922091        ComObjPtr<HostUSBDeviceFilter> pFilter;
    20932092        pFilter.createObject();
    2094         rc = pFilter->init(this, f);
    2095         if (FAILED(rc))
     2093        hrc = pFilter->init(this, f);
     2094        if (FAILED(hrc))
    20962095            break;
    20972096
     
    21072106    }
    21082107
    2109     rc = m->pUSBProxyService->i_loadSettings(data.llUSBDeviceSources);
     2108    hrc = m->pUSBProxyService->i_loadSettings(data.llUSBDeviceSources);
    21102109#else
    21112110    RT_NOREF(data);
     
    21132112
    21142113#ifdef VBOX_WITH_UPDATE_AGENT
    2115     rc = m->pUpdateHost->i_loadSettings(data.updateHost);
    2116     ComAssertComRCRet(rc, rc);
     2114    hrc = m->pUpdateHost->i_loadSettings(data.updateHost);
     2115    ComAssertComRCRet(hrc, hrc);
    21172116    /** @todo Add handling for ExtPack and Guest Additions updates here later. See @bugref{7983}. */
    21182117#endif
    21192118
    2120     return rc;
     2119    return hrc;
    21212120}
    21222121
     
    21292128    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    21302129
    2131     HRESULT rc;
     2130    HRESULT hrc;
    21322131
    21332132#ifdef VBOX_WITH_USB
     
    21452144    }
    21462145
    2147     rc = m->pUSBProxyService->i_saveSettings(data.llUSBDeviceSources);
    2148     ComAssertComRCRet(rc, rc);
     2146    hrc = m->pUSBProxyService->i_saveSettings(data.llUSBDeviceSources);
     2147    ComAssertComRCRet(hrc, hrc);
    21492148#else
    21502149    RT_NOREF(data);
     
    21522151
    21532152#ifdef VBOX_WITH_UPDATE_AGENT
    2154     rc = m->pUpdateHost->i_saveSettings(data.updateHost);
    2155     ComAssertComRCRet(rc, rc);
     2153    hrc = m->pUpdateHost->i_saveSettings(data.updateHost);
     2154    ComAssertComRCRet(hrc, hrc);
    21562155    /** @todo Add handling for ExtPack and Guest Additions updates here later. See @bugref{7983}. */
    21572156#endif
     
    21832182                          AutoWriteLock &treeLock)
    21842183{
    2185     HRESULT rc = S_OK;
     2184    HRESULT hrc = S_OK;
    21862185    Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
    21872186
     
    21952194            if (!m->fDVDDrivesListBuilt || fRefresh)
    21962195            {
    2197                 rc = i_buildDVDDrivesList(llNew);
    2198                 if (FAILED(rc))
    2199                     return rc;
     2196                hrc = i_buildDVDDrivesList(llNew);
     2197                if (FAILED(hrc))
     2198                    return hrc;
    22002199                pfListBuilt = &m->fDVDDrivesListBuilt;
    22012200            }
     
    22062205            if (!m->fFloppyDrivesListBuilt || fRefresh)
    22072206            {
    2208                 rc = i_buildFloppyDrivesList(llNew);
    2209                 if (FAILED(rc))
    2210                     return rc;
     2207                hrc = i_buildFloppyDrivesList(llNew);
     2208                if (FAILED(hrc))
     2209                    return hrc;
    22112210                pfListBuilt = &m->fFloppyDrivesListBuilt;
    22122211            }
     
    22992298    treeLock.acquire();
    23002299
    2301     return rc;
     2300    return hrc;
    23022301}
    23032302
     
    23212320
    23222321    AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    2323     HRESULT rc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
    2324     if (SUCCEEDED(rc))
     2322    HRESULT hrc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
     2323    if (SUCCEEDED(hrc))
    23252324    {
    23262325        for (MediaList::iterator it = pllMedia->begin();
     
    23612360
    23622361    AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    2363     HRESULT rc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
    2364     if (SUCCEEDED(rc))
     2362    HRESULT hrc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
     2363    if (SUCCEEDED(hrc))
    23652364    {
    23662365        for (MediaList::iterator it = pllMedia->begin();
     
    24132412HRESULT Host::i_buildDVDDrivesList(MediaList &list)
    24142413{
    2415     HRESULT rc = S_OK;
     2414    HRESULT hrc = S_OK;
    24162415
    24172416    Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
     
    24512450        if (RT_SUCCESS(m->hostDrives.updateDVDs()))
    24522451            for (DriveInfoList::const_iterator it = m->hostDrives.DVDBegin();
    2453                 SUCCEEDED(rc) && it != m->hostDrives.DVDEnd(); ++it)
     2452                SUCCEEDED(hrc) && it != m->hostDrives.DVDEnd(); ++it)
    24542453            {
    24552454                ComObjPtr<Medium> hostDVDDriveObj;
    24562455                Utf8Str location(it->mDevice);
    24572456                Utf8Str description(it->mDescription);
    2458                 if (SUCCEEDED(rc))
    2459                     rc = hostDVDDriveObj.createObject();
    2460                 if (SUCCEEDED(rc))
    2461                     rc = hostDVDDriveObj->init(m->pParent, DeviceType_DVD, location, description);
    2462                 if (SUCCEEDED(rc))
     2457                if (SUCCEEDED(hrc))
     2458                    hrc = hostDVDDriveObj.createObject();
     2459                if (SUCCEEDED(hrc))
     2460                    hrc = hostDVDDriveObj->init(m->pParent, DeviceType_DVD, location, description);
     2461                if (SUCCEEDED(hrc))
    24632462                    list.push_back(hostDVDDriveObj);
    24642463            }
     
    24812480#endif
    24822481    }
    2483     catch(std::bad_alloc &)
    2484     {
    2485         rc = E_OUTOFMEMORY;
    2486     }
    2487     return rc;
     2482    catch (std::bad_alloc &)
     2483    {
     2484        hrc = E_OUTOFMEMORY;
     2485    }
     2486    return hrc;
    24882487}
    24892488
     
    24952494HRESULT Host::i_buildFloppyDrivesList(MediaList &list)
    24962495{
    2497     HRESULT rc = S_OK;
     2496    HRESULT hrc = S_OK;
    24982497
    24992498    Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
     
    25242523        if (RT_SUCCESS(m->hostDrives.updateFloppies()))
    25252524            for (DriveInfoList::const_iterator it = m->hostDrives.FloppyBegin();
    2526                 SUCCEEDED(rc) && it != m->hostDrives.FloppyEnd(); ++it)
     2525                SUCCEEDED(hrc) && it != m->hostDrives.FloppyEnd(); ++it)
    25272526            {
    25282527                ComObjPtr<Medium> hostFloppyDriveObj;
    25292528                Utf8Str location(it->mDevice);
    25302529                Utf8Str description(it->mDescription);
    2531                 if (SUCCEEDED(rc))
    2532                     rc = hostFloppyDriveObj.createObject();
    2533                 if (SUCCEEDED(rc))
    2534                     rc = hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, location, description);
    2535                 if (SUCCEEDED(rc))
     2530                if (SUCCEEDED(hrc))
     2531                    hrc = hostFloppyDriveObj.createObject();
     2532                if (SUCCEEDED(hrc))
     2533                    hrc = hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, location, description);
     2534                if (SUCCEEDED(hrc))
    25362535                    list.push_back(hostFloppyDriveObj);
    25372536            }
     
    25432542    catch(std::bad_alloc &)
    25442543    {
    2545         rc = E_OUTOFMEMORY;
    2546     }
    2547 
    2548     return rc;
     2544        hrc = E_OUTOFMEMORY;
     2545    }
     2546
     2547    return hrc;
    25492548}
    25502549
     
    29102909
    29112910                            const char *pszDevPath = pszDisk ? pszDisk : pszPartition0 ? pszPartition0 : pszSlice0;
    2912                             int rc = RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevPath);
    2913                             AssertRC(rc);
     2911                            int hrc = RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevPath);
     2912                            AssertRC(hrc);
    29142913
    29152914                            if (*ppDrives)
     
    36473646     * to cause update starvation. */
    36483647    HostNetworkInterfaceList list;
    3649     int rc = NetIfList(list);
    3650     if (rc)
    3651     {
    3652         Log(("Failed to get host network interface list with rc=%Rrc\n", rc));
     3648    int vrc = NetIfList(list);
     3649    if (RT_FAILURE(vrc))
     3650    {
     3651        Log(("Failed to get host network interface list with vrc=%Rrc\n", vrc));
    36533652        return E_FAIL;
    36543653    }
     
    37673766    /* For now we are concerned with the root file system only. */
    37683767    pm::DiskList disksUsage, disksLoad;
    3769     int rc = hal->getDiskListByFs("/", disksUsage, disksLoad);
    3770     if (RT_FAILURE(rc))
     3768    int hrc = hal->getDiskListByFs("/", disksUsage, disksLoad);
     3769    if (RT_FAILURE(hrc))
    37713770        return;
    37723771    pm::DiskList::iterator it;
     
    39723971    uint32_t         offError;
    39733972    RTVFSDIR         hVfsDir;
    3974     int rc = RTVfsChainOpenDir("\\\\:iprtnt:\\GLOBAL??", 0 /*fFlags*/, &hVfsDir, &offError, RTErrInfoInitStatic(&ErrInfo));
    3975     if (RT_FAILURE(rc))
    3976         return setError(E_FAIL, tr("Failed to open NT\\GLOBAL?? (error %Rrc)"), rc);
     3973    int vrc = RTVfsChainOpenDir("\\\\:iprtnt:\\GLOBAL??", 0 /*fFlags*/, &hVfsDir, &offError, RTErrInfoInitStatic(&ErrInfo));
     3974    if (RT_FAILURE(vrc))
     3975        return setError(E_FAIL, tr("Failed to open NT\\GLOBAL?? (error %Rrc)"), vrc);
    39773976
    39783977    /*
     
    39923991    {
    39933992        size_t cbDirEntry = cbDirEntryAlloced;
    3994         rc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING);
    3995         if (RT_FAILURE(rc))
    3996         {
    3997             if (rc == VERR_BUFFER_OVERFLOW)
     3993        vrc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING);
     3994        if (RT_FAILURE(vrc))
     3995        {
     3996            if (vrc == VERR_BUFFER_OVERFLOW)
    39983997            {
    39993998                RTMemTmpFree(pDirEntry);
     
    40044003                hrc = setError(E_OUTOFMEMORY, tr("Out of memory! (direntry buffer)"));
    40054004            }
    4006             else if (rc != VERR_NO_MORE_FILES)
    4007                 hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsDirReadEx failed: %Rrc"), rc);
     4005            else if (vrc != VERR_NO_MORE_FILES)
     4006                hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsDirReadEx failed: %Rrc"), vrc);
    40084007            break;
    40094008        }
     
    40144013
    40154014            RTFILE hRawFile = NIL_RTFILE;
    4016             int vrc = RTFileOpen(&hRawFile, szPhysicalDrive, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
     4015            vrc = RTFileOpen(&hRawFile, szPhysicalDrive, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    40174016            if (RT_FAILURE(vrc))
    40184017            {
  • trunk/src/VBox/Main/src-server/HostNetworkInterfaceImpl.cpp

    r98262 r98288  
    257257{
    258258    NETIFINFO info;
    259     int rc = NetIfGetConfig(this, &info);
    260     if (RT_SUCCESS(rc))
     259    int vrc = NetIfGetConfig(this, &info);
     260    if (RT_SUCCESS(vrc))
    261261    {
    262262        int iPrefixIPv6;
     
    280280        return S_OK;
    281281    }
    282     return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
     282    return vrc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
    283283}
    284284
     
    562562        if (m.IPAddress)
    563563        {
    564             int rc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, 0, 0);
    565             if (RT_SUCCESS(rc))
     564            int vrc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, 0, 0);
     565            if (RT_SUCCESS(vrc))
    566566            {
    567567                m.realIPAddress = 0;
     
    596596            if (m.realIPAddress == ip && m.realNetworkMask == mask)
    597597                return S_OK;
    598             int rc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, ip, mask);
    599             if (RT_SUCCESS(rc))
     598            int vrc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, ip, mask);
     599            if (RT_SUCCESS(vrc))
    600600            {
    601601                m.realIPAddress   = ip;
     
    617617            else
    618618            {
    619                 LogRel(("Failed to EnableStaticIpConfig with rc=%Rrc\n", rc));
     619                LogRel(("Failed to EnableStaticIpConfig with vrc=%Rrc\n", vrc));
    620620                /* Global::vboxStatusCodeToCOM assert things we can guarantee */
    621                 switch (rc)
     621                switch (vrc)
    622622                {
    623623                    case VERR_NOT_IMPLEMENTED:
     
    652652
    653653    HRESULT hrc;
    654     int rc;
    655 
    656     RTNETADDRIPV6 AddrOld, AddrNew;
     654
     655    RTNETADDRIPV6 AddrNew;
    657656    char *pszZoneIgnored;
    658     bool fAddrChanged;
    659 
    660     rc = RTNetStrToIPv6Addr(aIPV6Address.c_str(), &AddrNew, &pszZoneIgnored);
    661     if (RT_FAILURE(rc))
    662     {
    663         return mVirtualBox->setErrorBoth(E_INVALIDARG, rc, tr("Invalid IPv6 address"));
    664     }
    665 
    666     rc = RTNetStrToIPv6Addr(com::Utf8Str(m.realIPV6Address).c_str(), &AddrOld, &pszZoneIgnored);
    667     if (RT_SUCCESS(rc))
    668     {
    669         fAddrChanged = (AddrNew.s.Lo != AddrOld.s.Lo || AddrNew.s.Hi != AddrOld.s.Hi);
    670     }
    671     else
    672     {
    673         fAddrChanged = true;
    674     }
     657    int vrc = RTNetStrToIPv6Addr(aIPV6Address.c_str(), &AddrNew, &pszZoneIgnored);
     658    if (RT_FAILURE(vrc))
     659        return mVirtualBox->setErrorBoth(E_INVALIDARG, vrc, tr("Invalid IPv6 address"));
     660
     661    RTNETADDRIPV6 AddrOld;
     662    vrc = RTNetStrToIPv6Addr(com::Utf8Str(m.realIPV6Address).c_str(), &AddrOld, &pszZoneIgnored);
     663    bool fAddrChanged = RT_SUCCESS(vrc) ? AddrNew.s.Lo != AddrOld.s.Lo || AddrNew.s.Hi != AddrOld.s.Hi : true;
    675664
    676665    if (   fAddrChanged
     
    679668        if (aIPV6NetworkMaskPrefixLength == 0)
    680669            aIPV6NetworkMaskPrefixLength = 64;
    681         rc = NetIfEnableStaticIpConfigV6(mVirtualBox, this, m.IPV6Address.c_str(),
    682                                          aIPV6Address.c_str(),
    683                                          aIPV6NetworkMaskPrefixLength);
    684         if (RT_FAILURE(rc))
     670        vrc = NetIfEnableStaticIpConfigV6(mVirtualBox, this, m.IPV6Address.c_str(),
     671                                          aIPV6Address.c_str(),
     672                                          aIPV6NetworkMaskPrefixLength);
     673        if (RT_FAILURE(vrc))
    685674        {
    686             LogRel(("Failed to EnableStaticIpConfigV6 with rc=%Rrc\n", rc));
     675            LogRel(("Failed to EnableStaticIpConfigV6 with vrc=%Rrc\n", vrc));
    687676            /* Global::vboxStatusCodeToCOM assert things we can guarantee */
    688             switch (rc)
     677            switch (vrc)
    689678            {
    690679                case VERR_NOT_IMPLEMENTED:
     
    728717    return E_NOTIMPL;
    729718#else
    730     int rc = NetIfEnableDynamicIpConfig(mVirtualBox, this);
    731     if (RT_FAILURE(rc))
    732     {
    733         LogRel(("Failed to EnableDynamicIpConfig with rc=%Rrc\n", rc));
    734         return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
     719    int vrc = NetIfEnableDynamicIpConfig(mVirtualBox, this);
     720    if (RT_FAILURE(vrc))
     721    {
     722        LogRel(("Failed to EnableDynamicIpConfig with vrc=%Rrc\n", vrc));
     723        return vrc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
    735724    }
    736725    return S_OK;
     
    743732    return E_NOTIMPL;
    744733#else
    745     int rc = NetIfDhcpRediscover(mVirtualBox, this);
    746     if (RT_FAILURE(rc))
    747     {
    748         LogRel(("Failed to DhcpRediscover with rc=%Rrc\n", rc));
    749         return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
     734    int vrc = NetIfDhcpRediscover(mVirtualBox, this);
     735    if (RT_FAILURE(vrc))
     736    {
     737        LogRel(("Failed to DhcpRediscover with vrc=%Rrc\n", vrc));
     738        return vrc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
    750739    }
    751740    return S_OK;
  • trunk/src/VBox/Main/src-server/HostOnlyNetworkImpl.cpp

    r98262 r98288  
    159159
    160160    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    161     HRESULT rc = m->pVirtualBox->i_saveSettings();
    162     ComAssertComRCRetRC(rc);
     161    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     162    ComAssertComRCRetRC(hrc);
    163163    return S_OK;
    164164}
     
    186186
    187187    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    188     HRESULT rc = m->pVirtualBox->i_saveSettings();
    189     ComAssertComRCRetRC(rc);
     188    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     189    ComAssertComRCRetRC(hrc);
    190190    return S_OK;
    191191}
     
    208208
    209209    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    210     HRESULT rc = m->pVirtualBox->i_saveSettings();
    211     ComAssertComRCRetRC(rc);
     210    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     211    ComAssertComRCRetRC(hrc);
    212212    return S_OK;
    213213}
     
    237237
    238238    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    239     HRESULT rc = m->pVirtualBox->i_saveSettings();
    240     ComAssertComRCRetRC(rc);
     239    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     240    ComAssertComRCRetRC(hrc);
    241241    return S_OK;
    242242}
     
    259259
    260260    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    261     HRESULT rc = m->pVirtualBox->i_saveSettings();
    262     ComAssertComRCRetRC(rc);
     261    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     262    ComAssertComRCRetRC(hrc);
    263263    return S_OK;
    264264}
     
    281281
    282282    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
    283     HRESULT rc = m->pVirtualBox->i_saveSettings();
    284     ComAssertComRCRetRC(rc);
    285     return S_OK;
    286 }
    287 
     283    HRESULT hrc = m->pVirtualBox->i_saveSettings();
     284    ComAssertComRCRetRC(hrc);
     285    return S_OK;
     286}
     287
  • trunk/src/VBox/Main/src-server/HostPower.cpp

    r98103 r98288  
    5757    VirtualBox::InternalControlList controls;
    5858
    59     HRESULT rc = S_OK;
     59    HRESULT hrc = S_OK;
    6060
    6161    switch (aReason)
     
    8383                /* PauseWithReason() will simply return a failure if
    8484                 * the VM is in an inappropriate state */
    85                 rc = pControl->PauseWithReason(Reason_HostSuspend);
    86                 if (FAILED(rc))
     85                hrc = pControl->PauseWithReason(Reason_HostSuspend);
     86                if (FAILED(hrc))
    8787                    continue;
    8888
     
    108108                 * been somehow closed by this time already so that the
    109109                 * console reference we have is dead) */
    110                 rc = mSessionControls[i]->ResumeWithReason(Reason_HostResume);
    111                 if (FAILED(rc))
     110                hrc = mSessionControls[i]->ResumeWithReason(Reason_HostResume);
     111                if (FAILED(hrc))
    112112                    continue;
    113113
     
    134134
    135135            Bstr value;
    136             rc = mVirtualBox->GetExtraData(Bstr("VBoxInternal2/SavestateOnBatteryLow").raw(),
    137                                            value.asOutParam());
     136            hrc = mVirtualBox->GetExtraData(Bstr("VBoxInternal2/SavestateOnBatteryLow").raw(), value.asOutParam());
    138137            int fGlobal = 0;
    139             if (SUCCEEDED(rc) && !value.isEmpty())
     138            if (SUCCEEDED(hrc) && !value.isEmpty())
    140139            {
    141140                if (value != "0")
     
    154153            {
    155154                ComPtr<SessionMachine> pMachine = *it;
    156                 rc = pMachine->GetExtraData(Bstr("VBoxInternal2/SavestateOnBatteryLow").raw(),
    157                                             value.asOutParam());
     155                hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/SavestateOnBatteryLow").raw(), value.asOutParam());
    158156                int fPerVM = 0;
    159                 if (SUCCEEDED(rc) && !value.isEmpty())
     157                if (SUCCEEDED(hrc) && !value.isEmpty())
    160158                {
    161159                    /* per-VM overrides global */
     
    173171                    /* SessionMachine::i_saveStateWithReason() will return
    174172                     * a failure if the VM is in an inappropriate state */
    175                     rc = pMachine->i_saveStateWithReason(Reason_HostBatteryLow, progress);
    176                     if (FAILED(rc))
     173                    hrc = pMachine->i_saveStateWithReason(Reason_HostBatteryLow, progress);
     174                    if (FAILED(hrc))
    177175                    {
    178                         LogRel(("SaveState '%s' failed with %Rhrc\n", pMachine->i_getName().c_str(), rc));
     176                        LogRel(("SaveState '%s' failed with %Rhrc\n", pMachine->i_getName().c_str(), hrc));
    179177                        continue;
    180178                    }
    181179
    182180                    /* Wait until the operation has been completed. */
    183                     rc = progress->WaitForCompletion(-1);
    184                     if (SUCCEEDED(rc))
     181                    hrc = progress->WaitForCompletion(-1);
     182                    if (SUCCEEDED(hrc))
    185183                    {
    186184                        LONG iRc;
    187185                        progress->COMGETTER(ResultCode)(&iRc);
    188                         rc = (HRESULT)iRc;
     186                        hrc = (HRESULT)iRc;
    189187                    }
    190188
    191                     AssertMsg(SUCCEEDED(rc), ("SaveState WaitForCompletion failed with %Rhrc (%#08X)\n", rc, rc));
    192 
    193                     if (SUCCEEDED(rc))
     189                    AssertMsg(SUCCEEDED(hrc), ("SaveState WaitForCompletion failed with %Rhrc (%#08X)\n", hrc, hrc));
     190
     191                    if (SUCCEEDED(hrc))
    194192                    {
    195193                        LogRel(("SaveState '%s' succeeded\n", pMachine->i_getName().c_str()));
  • trunk/src/VBox/Main/src-server/HostUSBDeviceImpl.cpp

    r98262 r98288  
    755755
    756756    alock.release();
    757     int rc = mUSBProxyBackend->releaseDevice(this);
    758     if (RT_FAILURE(rc))
     757    int vrc = mUSBProxyBackend->releaseDevice(this);
     758    if (RT_FAILURE(vrc))
    759759    {
    760760        alock.acquire();
     
    808808
    809809    alock.release();
    810     int rc = mUSBProxyBackend->captureDevice(this);
    811     if (RT_FAILURE(rc))
     810    int vrc = mUSBProxyBackend->captureDevice(this);
     811    if (RT_FAILURE(vrc))
    812812    {
    813813        alock.acquire();
  • trunk/src/VBox/Main/src-server/HostVideoInputDeviceImpl.cpp

    r98103 r98288  
    157157#endif
    158158{
    159     int rc;
     159    int vrc;
    160160    if (RTPathHavePath(pszPath))
    161161    {
    162162        RTLDRMOD hmod = NIL_RTLDRMOD;
    163163        RTERRINFOSTATIC ErrInfo;
    164         rc = SUPR3HardenedLdrLoadPlugIn(pszPath, &hmod, RTErrInfoInitStatic(&ErrInfo));
    165         if (RT_SUCCESS(rc))
     164        vrc = SUPR3HardenedLdrLoadPlugIn(pszPath, &hmod, RTErrInfoInitStatic(&ErrInfo));
     165        if (RT_SUCCESS(vrc))
    166166        {
    167167            static const char s_szSymbol[] = "VBoxHostWebcamList";
    168             rc = RTLdrGetSymbol(hmod, s_szSymbol, (void **)ppfn);
    169             if (RT_SUCCESS(rc))
     168            vrc = RTLdrGetSymbol(hmod, s_szSymbol, (void **)ppfn);
     169            if (RT_SUCCESS(vrc))
    170170                *phmod = hmod;
    171171            else
    172172            {
    173                 if (rc != VERR_SYMBOL_NOT_FOUND)
    174                     LogRel(("Resolving symbol '%s': %Rrc\n", s_szSymbol, rc));
     173                if (vrc != VERR_SYMBOL_NOT_FOUND)
     174                    LogRel(("Resolving symbol '%s': %Rrc\n", s_szSymbol, vrc));
    175175                RTLdrClose(hmod);
    176176                hmod = NIL_RTLDRMOD;
     
    179179        else
    180180        {
    181             LogRel(("Loading the library '%s': %Rrc\n", pszPath, rc));
     181            LogRel(("Loading the library '%s': %Rrc\n", pszPath, vrc));
    182182            if (RTErrInfoIsSet(&ErrInfo.Core))
    183183                LogRel(("  %s\n", ErrInfo.Core.pszMsg));
     
    187187    {
    188188        LogRel(("Loading the library '%s': No path! Refusing to try loading it!\n", pszPath));
    189         rc = VERR_INVALID_PARAMETER;
    190     }
    191     return rc;
     189        vrc = VERR_INVALID_PARAMETER;
     190    }
     191    return vrc;
    192192}
    193193
  • trunk/src/VBox/Main/src-server/MachineImpl.cpp

    r98262 r98288  
    385385    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    386386
    387     HRESULT rc = initImpl(aParent, strConfigFile);
    388     if (FAILED(rc)) return rc;
     387    HRESULT hrc = initImpl(aParent, strConfigFile);
     388    if (FAILED(hrc)) return hrc;
    389389
    390390#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
     
    398398        /* Resolve the cryptographic interface. */
    399399        PCVBOXCRYPTOIF pCryptoIf = NULL;
    400         HRESULT hrc = aParent->i_retainCryptoIf(&pCryptoIf);
     400        hrc = aParent->i_retainCryptoIf(&pCryptoIf);
    401401        if (SUCCEEDED(hrc))
    402402        {
     
    450450#endif
    451451
    452     rc = i_tryCreateMachineConfigFile(fForceOverwrite);
    453     if (FAILED(rc)) return rc;
    454 
    455     if (SUCCEEDED(rc))
     452    hrc = i_tryCreateMachineConfigFile(fForceOverwrite);
     453    if (FAILED(hrc)) return hrc;
     454
     455    if (SUCCEEDED(hrc))
    456456    {
    457457        // create an empty machine config
    458458        mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
    459459
    460         rc = initDataAndChildObjects();
    461     }
    462 
    463     if (SUCCEEDED(rc))
     460        hrc = initDataAndChildObjects();
     461    }
     462
     463    if (SUCCEEDED(hrc))
    464464    {
    465465#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
     
    485485
    486486        // initialize the default snapshots folder
    487         rc = COMSETTER(SnapshotFolder)(NULL);
    488         AssertComRC(rc);
     487        hrc = COMSETTER(SnapshotFolder)(NULL);
     488        AssertComRC(hrc);
    489489
    490490        if (aOsType)
     
    500500            mHWData->mX2APIC = aOsType->i_recommendedX2APIC();
    501501
    502             rc = aOsType->COMGETTER(RecommendedFirmware)(&mHWData->mFirmwareType);
    503             AssertComRC(rc);
     502            hrc = aOsType->COMGETTER(RecommendedFirmware)(&mHWData->mFirmwareType);
     503            AssertComRC(hrc);
    504504        }
    505505        else if (!strOsType.isEmpty())
     
    540540
    541541#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
    542         rc = mNvramStore->i_updateEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
     542        hrc = mNvramStore->i_updateEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
    543543#endif
    544         if (SUCCEEDED(rc))
     544        if (SUCCEEDED(hrc))
    545545        {
    546546            /* At this point the changing of the current state modification
     
    554554
    555555    /* Confirm a successful initialization when it's the case */
    556     if (SUCCEEDED(rc))
     556    if (SUCCEEDED(hrc))
    557557    {
    558558#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
     
    571571    }
    572572
    573     LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
     573    LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, hrc=%08X\n",
    574574                     !!mUserData ? mUserData->s.strName.c_str() : "NULL",
    575575                     mData->mRegistered,
    576576                     mData->mAccessible,
    577                      rc));
     577                     hrc));
    578578
    579579    LogFlowThisFuncLeave();
    580580
    581     return rc;
     581    return hrc;
    582582}
    583583
     
    626626    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    627627
    628     HRESULT rc = initImpl(aParent, strConfigFile);
    629     if (FAILED(rc)) return rc;
     628    HRESULT hrc = initImpl(aParent, strConfigFile);
     629    if (FAILED(hrc)) return hrc;
    630630
    631631    if (aId)
     
    635635        mData->mRegistered = TRUE;
    636636        // now load the settings from XML:
    637         rc = i_registeredInit();
     637        hrc = i_registeredInit();
    638638            // this calls initDataAndChildObjects() and loadSettings()
    639639    }
     
    641641    {
    642642        // opening an unregistered VM (VirtualBox::OpenMachine()):
    643         rc = initDataAndChildObjects();
    644 
    645         if (SUCCEEDED(rc))
     643        hrc = initDataAndChildObjects();
     644        if (SUCCEEDED(hrc))
    646645        {
    647646            // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
     
    701700#endif
    702701
    703                     rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
    704                                                        NULL /* puuidRegistry */);
    705                     if (FAILED(rc)) throw rc;
     702                    hrc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile, NULL /* puuidRegistry */);
     703                    if (FAILED(hrc)) throw hrc;
    706704
    707705                    /* At this point the changing of the current state modification
     
    715713            {
    716714                /* we assume that error info is set by the thrower */
    717                 rc = err;
     715                hrc = err;
    718716            }
    719717            catch (...)
    720718            {
    721                 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     719                hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    722720            }
    723721        }
     
    725723
    726724    /* Confirm a successful initialization when it's the case */
    727     if (SUCCEEDED(rc))
     725    if (SUCCEEDED(hrc))
    728726    {
    729727        if (mData->mAccessible)
     
    747745#endif
    748746
    749     LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
    750                       "rc=%08X\n",
    751                       !!mUserData ? mUserData->s.strName.c_str() : "NULL",
    752                       mData->mRegistered, mData->mAccessible, rc));
     747    LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool hrc=%08X\n",
     748                     !!mUserData ? mUserData->s.strName.c_str() : "NULL", mData->mRegistered, mData->mAccessible, hrc));
    753749
    754750    LogFlowThisFuncLeave();
    755751
    756     return rc;
     752    return hrc;
    757753}
    758754
     
    780776    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    781777
    782     HRESULT rc = initImpl(aParent, strSettingsFilename);
    783     if (FAILED(rc)) return rc;
    784 
    785     rc = i_tryCreateMachineConfigFile(false /* fForceOverwrite */);
    786     if (FAILED(rc)) return rc;
    787 
    788     rc = initDataAndChildObjects();
    789 
    790     if (SUCCEEDED(rc))
     778    HRESULT hrc = initImpl(aParent, strSettingsFilename);
     779    if (FAILED(hrc)) return hrc;
     780
     781    hrc = i_tryCreateMachineConfigFile(false /* fForceOverwrite */);
     782    if (FAILED(hrc)) return hrc;
     783
     784    hrc = initDataAndChildObjects();
     785    if (SUCCEEDED(hrc))
    791786    {
    792787        // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
     
    799794        unconst(mData->mUuid).create();
    800795
    801         rc = i_loadMachineDataFromSettings(config,
    802                                            &mData->mUuid); // puuidRegistry: initialize media with this registry ID
     796        hrc = i_loadMachineDataFromSettings(config, &mData->mUuid); // puuidRegistry: initialize media with this registry ID
    803797
    804798        // override VM name as well, it may be different
    805799        mUserData->s.strName = strName;
    806800
    807         if (SUCCEEDED(rc))
     801        if (SUCCEEDED(hrc))
    808802        {
    809803            /* At this point the changing of the current state modification
     
    817811
    818812    /* Confirm a successful initialization when it's the case */
    819     if (SUCCEEDED(rc))
     813    if (SUCCEEDED(hrc))
    820814    {
    821815        if (mData->mAccessible)
     
    836830    }
    837831
    838     LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
    839                      "rc=%08X\n",
    840                       !!mUserData ? mUserData->s.strName.c_str() : "NULL",
    841                       mData->mRegistered, mData->mAccessible, rc));
     832    LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool hrc=%08X\n",
     833                     !!mUserData ? mUserData->s.strName.c_str() : "NULL", mData->mRegistered, mData->mAccessible, hrc));
    842834
    843835    LogFlowThisFuncLeave();
    844836
    845     return rc;
     837    return hrc;
    846838}
    847839
     
    860852    AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
    861853
    862     HRESULT rc = S_OK;
     854    HRESULT hrc = S_OK;
    863855
    864856    /* share the parent weakly */
     
    889881    LogFlowThisFuncLeave();
    890882
    891     return rc;
     883    return hrc;
    892884}
    893885
     
    900892HRESULT Machine::i_tryCreateMachineConfigFile(bool fForceOverwrite)
    901893{
    902     HRESULT rc = S_OK;
     894    HRESULT hrc = S_OK;
    903895
    904896    // when we create a new machine, we must be able to create the settings file
     
    912904            RTFileClose(f);
    913905        if (!fForceOverwrite)
    914             rc = setError(VBOX_E_FILE_ERROR,
    915                           tr("Machine settings file '%s' already exists"),
    916                           mData->m_strConfigFileFull.c_str());
     906            hrc = setError(VBOX_E_FILE_ERROR, tr("Machine settings file '%s' already exists"), mData->m_strConfigFileFull.c_str());
    917907        else
    918908        {
     
    925915              && vrc != VERR_PATH_NOT_FOUND
    926916            )
    927         rc = setErrorBoth(VBOX_E_FILE_ERROR, vrc,
    928                           tr("Invalid machine settings file name '%s' (%Rrc)"),
    929                           mData->m_strConfigFileFull.c_str(),
    930                           vrc);
    931     return rc;
     917        hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Invalid machine settings file name '%s' (%Rrc)"),
     918                           mData->m_strConfigFileFull.c_str(), vrc);
     919    return hrc;
    932920}
    933921
     
    951939    AssertReturn(!mData->mAccessible, E_FAIL);
    952940
    953     HRESULT rc = initDataAndChildObjects();
    954 
    955     if (SUCCEEDED(rc))
     941    HRESULT hrc = initDataAndChildObjects();
     942    if (SUCCEEDED(hrc))
    956943    {
    957944        /* Temporarily reset the registered flag in order to let setters
     
    969956        {
    970957            /* Get at the crpytographic interface. */
    971             rc = mParent->i_retainCryptoIf(&pCryptoIf);
    972             if (SUCCEEDED(rc))
     958            hrc = mParent->i_retainCryptoIf(&pCryptoIf);
     959            if (SUCCEEDED(hrc))
    973960            {
    974961                int vrc = mData->mpKeyStore->retainSecretKey(mData->mstrKeyId, &pKey);
     
    976963                    pszPassword = (const char *)pKey->getKeyBuffer();
    977964                else
    978                     rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to retain key for key ID '%s' with %Rrc"),
    979                                       mData->mstrKeyId.c_str(), vrc);
     965                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to retain key for key ID '%s' with %Rrc"),
     966                                       mData->mstrKeyId.c_str(), vrc);
    980967            }
    981968        }
     
    984971#endif
    985972
    986         if (SUCCEEDED(rc))
     973        if (SUCCEEDED(hrc))
    987974        {
    988975            try
     
    1007994
    1008995                if (mData->pMachineConfigFile->enmParseState == settings::MachineConfigFile::ParseState_PasswordError)
    1009                     rc = setError(VBOX_E_PASSWORD_INCORRECT,
    1010                                   tr("Config decryption of the machine {%RTuuid} failed. Incorrect or unknown password"),
    1011                                   mData->pMachineConfigFile->uuid.raw());
     996                    hrc = setError(VBOX_E_PASSWORD_INCORRECT,
     997                                   tr("Config decryption of the machine {%RTuuid} failed. Incorrect or unknown password"),
     998                                   mData->pMachineConfigFile->uuid.raw());
    1012999                else
    10131000#endif
    1014                     rc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile,
    1015                                                        NULL /* const Guid *puuidRegistry */);
    1016                 if (FAILED(rc)) throw rc;
     1001                    hrc = i_loadMachineDataFromSettings(*mData->pMachineConfigFile, NULL /* const Guid *puuidRegistry */);
     1002                if (FAILED(hrc)) throw hrc;
    10171003            }
    10181004            catch (HRESULT err)
    10191005            {
    10201006                /* we assume that error info is set by the thrower */
    1021                 rc = err;
     1007                hrc = err;
    10221008            }
    10231009            catch (...)
    10241010            {
    1025                 rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     1011                hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    10261012            }
    10271013
     
    10381024    }
    10391025
    1040     if (SUCCEEDED(rc))
     1026    if (SUCCEEDED(hrc))
    10411027    {
    10421028        /* Set mAccessible to TRUE only if we successfully locked and loaded
     
    10701056        uninitDataAndChildObjects();
    10711057
    1072         rc = S_OK;
    1073     }
    1074 
    1075     return rc;
     1058        hrc = S_OK;
     1059    }
     1060
     1061    return hrc;
    10761062}
    10771063
     
    12061192    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    12071193
    1208     HRESULT rc = S_OK;
     1194    HRESULT hrc = S_OK;
    12091195
    12101196    if (!mData->mAccessible)
     
    12281214        }
    12291215
    1230         rc = i_registeredInit();
    1231 
    1232         if (SUCCEEDED(rc) && mData->mAccessible)
     1216        hrc = i_registeredInit();
     1217
     1218        if (SUCCEEDED(hrc) && mData->mAccessible)
    12331219        {
    12341220            autoReinitSpan.setSucceeded();
     
    12411227    }
    12421228
    1243     if (SUCCEEDED(rc))
     1229    if (SUCCEEDED(hrc))
    12441230        *aAccessible = mData->mAccessible;
    12451231
    12461232    LogFlowThisFuncLeave();
    12471233
    1248     return rc;
     1234    return hrc;
    12491235}
    12501236
     
    12601246    }
    12611247
    1262     HRESULT rc = S_OK;
     1248    HRESULT hrc = S_OK;
    12631249
    12641250    ComObjPtr<VirtualBoxErrorInfo> errorInfo;
    1265     rc = errorInfo.createObject();
    1266     if (SUCCEEDED(rc))
     1251    hrc = errorInfo.createObject();
     1252    if (SUCCEEDED(hrc))
    12671253    {
    12681254        errorInfo->init(mData->mAccessError.getResultCode(),
     
    12731259    }
    12741260
    1275     return rc;
     1261    return hrc;
    12761262}
    12771263
     
    12961282    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    12971283
    1298     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    1299     if (FAILED(rc)) return rc;
     1284    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     1285    if (FAILED(hrc)) return hrc;
    13001286
    13011287    i_setModified(IsModified_MachineData);
     
    13221308    // significantly, but play safe by not messing around while complex
    13231309    // activities are going on
    1324     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    1325     if (FAILED(rc)) return rc;
     1310    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     1311    if (FAILED(hrc)) return hrc;
    13261312
    13271313    i_setModified(IsModified_MachineData);
     
    13581344{
    13591345    StringsList llGroups;
    1360     HRESULT rc = mParent->i_convertMachineGroups(aGroups, &llGroups);
    1361     if (FAILED(rc))
    1362         return rc;
     1346    HRESULT hrc = mParent->i_convertMachineGroups(aGroups, &llGroups);
     1347    if (FAILED(hrc))
     1348        return hrc;
    13631349
    13641350    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    13651351
    1366     rc = i_checkStateDependency(MutableOrSavedStateDep);
    1367     if (FAILED(rc)) return rc;
     1352    hrc = i_checkStateDependency(MutableOrSavedStateDep);
     1353    if (FAILED(hrc)) return hrc;
    13681354
    13691355    i_setModified(IsModified_MachineData);
     
    13961382    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    13971383
    1398     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1399     if (FAILED(rc)) return rc;
     1384    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1385    if (FAILED(hrc)) return hrc;
    14001386
    14011387    i_setModified(IsModified_MachineData);
     
    14191405    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    14201406
    1421     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1422     if (FAILED(rc)) return rc;
     1407    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1408    if (FAILED(hrc)) return hrc;
    14231409
    14241410    i_setModified(IsModified_MachineData);
     
    14461432    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    14471433
    1448     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1449     if (FAILED(rc)) return rc;
     1434    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1435    if (FAILED(hrc)) return hrc;
    14501436
    14511437    i_setModified(IsModified_MachineData);
     
    14691455    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    14701456
    1471     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1472     if (FAILED(rc)) return rc;
     1457    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1458    if (FAILED(hrc)) return hrc;
    14731459
    14741460    i_setModified(IsModified_MachineData);
     
    14921478    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    14931479
    1494     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1495     if (FAILED(rc)) return rc;
     1480    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1481    if (FAILED(hrc)) return hrc;
    14961482
    14971483    if (aChipsetType != mHWData->mChipsetType)
     
    15331519    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    15341520
    1535     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1536     if (FAILED(rc)) return rc;
     1521    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1522    if (FAILED(hrc)) return hrc;
    15371523
    15381524    if (aIommuType != mHWData->mIommuType)
     
    15661552    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    15671553
    1568     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1569     if (FAILED(rc)) return rc;
     1554    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1555    if (FAILED(hrc)) return hrc;
    15701556
    15711557    /** @todo Parse/validate options? */
     
    15931579    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    15941580
    1595     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1596     if (FAILED(rc)) return rc;
     1581    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1582    if (FAILED(hrc)) return hrc;
    15971583
    15981584    if (aParavirtProvider != mHWData->mParavirtProvider)
     
    17151701    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    17161702
    1717     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1718     if (FAILED(rc)) return rc;
     1703    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1704    if (FAILED(hrc)) return hrc;
    17191705
    17201706    i_setModified(IsModified_MachineData);
     
    17441730    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    17451731
    1746     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1747     if (FAILED(rc)) return rc;
     1732    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1733    if (FAILED(hrc)) return hrc;
    17481734
    17491735    i_setModified(IsModified_MachineData);
     
    17781764    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    17791765
    1780     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1781     if (FAILED(rc)) return rc;
     1766    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1767    if (FAILED(hrc)) return hrc;
    17821768
    17831769    i_setModified(IsModified_MachineData);
     
    18221808    }
    18231809
    1824     HRESULT rc = i_checkStateDependency(MutableStateDep);
    1825     if (FAILED(rc)) return rc;
     1810    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     1811    if (FAILED(hrc)) return hrc;
    18261812
    18271813    i_setModified(IsModified_MachineData);
     
    18431829HRESULT Machine::setCPUExecutionCap(ULONG aCPUExecutionCap)
    18441830{
    1845     HRESULT rc = S_OK;
    1846 
    18471831    /* check throttle limits */
    18481832    if (    aCPUExecutionCap < 1
     
    18551839    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    18561840
    1857     rc = i_checkStateDependency(MutableOrRunningStateDep);
    1858     if (FAILED(rc)) return rc;
     1841    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     1842    if (FAILED(hrc)) return hrc;
    18591843
    18601844    alock.release();
    1861     rc = i_onCPUExecutionCapChange(aCPUExecutionCap);
     1845    hrc = i_onCPUExecutionCapChange(aCPUExecutionCap);
    18621846    alock.acquire();
    1863     if (FAILED(rc)) return rc;
     1847    if (FAILED(hrc)) return hrc;
    18641848
    18651849    i_setModified(IsModified_MachineData);
     
    18851869HRESULT Machine::setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled)
    18861870{
    1887     HRESULT rc = S_OK;
     1871    HRESULT hrc = S_OK;
    18881872
    18891873    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    18901874
    1891     rc = i_checkStateDependency(MutableStateDep);
    1892     if (FAILED(rc)) return rc;
     1875    hrc = i_checkStateDependency(MutableStateDep);
     1876    if (FAILED(hrc)) return hrc;
    18931877
    18941878    if (mHWData->mCPUHotPlugEnabled != aCPUHotPlugEnabled)
     
    19331917    mHWData->mCPUHotPlugEnabled = aCPUHotPlugEnabled;
    19341918
    1935     return rc;
     1919    return hrc;
    19361920}
    19371921
     
    20021986    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    20031987
    2004     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    2005     if (FAILED(rc)) return rc;
     1988    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     1989    if (FAILED(hrc)) return hrc;
    20061990
    20071991    i_setModified(IsModified_MachineData);
     
    20272011HRESULT Machine::setHPETEnabled(BOOL aHPETEnabled)
    20282012{
    2029     HRESULT rc = S_OK;
    2030 
    20312013    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    20322014
    2033     rc = i_checkStateDependency(MutableStateDep);
    2034     if (FAILED(rc)) return rc;
     2015    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2016    if (FAILED(hrc)) return hrc;
    20352017
    20362018    i_setModified(IsModified_MachineData);
     
    20392021    mHWData->mHPETEnabled = aHPETEnabled;
    20402022
    2041     return rc;
     2023    return hrc;
    20422024}
    20432025
     
    20702052    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    20712053
    2072     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    2073     if (FAILED(rc)) return rc;
     2054    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     2055    if (FAILED(hrc)) return hrc;
    20742056
    20752057    i_setModified(IsModified_MachineData);
     
    20972079    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    20982080
    2099     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2100     if (FAILED(rc)) return rc;
     2081    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2082    if (FAILED(hrc)) return hrc;
    21012083
    21022084    /** @todo must support changes for running vms and keep this in sync with IGuest. */
     
    22532235    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    22542236
    2255     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2256     if (FAILED(rc)) return rc;
     2237    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2238    if (FAILED(hrc)) return hrc;
    22572239
    22582240    switch (aProperty)
     
    24182400
    24192401    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    2420     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2421     if (FAILED(rc)) return rc;
     2402    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2403    if (FAILED(hrc)) return hrc;
    24222404
    24232405    /*
     
    24592441    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    24602442
    2461     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2462     if (FAILED(rc)) return rc;
     2443    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2444    if (FAILED(hrc)) return hrc;
    24632445
    24642446    /*
     
    24982480    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    24992481
    2500     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2501     if (FAILED(rc)) return rc;
     2482    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2483    if (FAILED(hrc)) return hrc;
    25022484
    25032485    if (mHWData->mCpuIdLeafList.size() > 0)
     
    25592541    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    25602542
    2561     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2562     if (FAILED(rc)) return rc;
     2543    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2544    if (FAILED(hrc)) return hrc;
    25632545
    25642546    switch (aProperty)
     
    26402622    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    26412623
    2642     HRESULT rc = i_checkStateDependency(MutableStateDep);
    2643     if (FAILED(rc)) return rc;
     2624    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     2625    if (FAILED(hrc)) return hrc;
    26442626
    26452627    if (!mData->mCurrentSnapshot.isNull())
     
    27042686#ifdef VBOX_WITH_VUSB
    27052687    clearError();
    2706     MultiResult rc(S_OK);
     2688    MultiResult hrcMult(S_OK);
    27072689
    27082690# ifdef VBOX_WITH_USB
    2709     rc = mParent->i_host()->i_checkUSBProxyService();
    2710     if (FAILED(rc)) return rc;
     2691    hrcMult = mParent->i_host()->i_checkUSBProxyService();
     2692    if (FAILED(hrcMult)) return hrcMult;
    27112693# endif
    27122694
     
    27352717#ifdef VBOX_WITH_VUSB
    27362718    clearError();
    2737     MultiResult rc(S_OK);
     2719    MultiResult hrcMult(S_OK);
    27382720
    27392721# ifdef VBOX_WITH_USB
    2740     rc = mParent->i_host()->i_checkUSBProxyService();
    2741     if (FAILED(rc)) return rc;
     2722    hrcMult = mParent->i_host()->i_checkUSBProxyService();
     2723    if (FAILED(hrcMult)) return hrcMult;
    27422724# endif
    27432725
     
    27452727
    27462728    aUSBDeviceFilters = mUSBDeviceFilters;
    2747     return rc;
     2729    return hrcMult;
    27482730#else
    27492731    /* Note: The GUI depends on this method returning E_NOTIMPL with no
     
    27742756    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    27752757
    2776     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    2777     if (FAILED(rc)) return rc;
     2758    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     2759    if (FAILED(hrc)) return hrc;
    27782760
    27792761    if (!mData->pMachineConfigFile->fileExists())
     
    29112893HRESULT Machine::setClipboardMode(ClipboardMode_T aClipboardMode)
    29122894{
    2913     HRESULT rc = S_OK;
     2895    HRESULT hrc = S_OK;
    29142896
    29152897    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    29162898
    2917     rc = i_checkStateDependency(MutableOrRunningStateDep);
    2918     if (FAILED(rc)) return rc;
     2899    hrc = i_checkStateDependency(MutableOrRunningStateDep);
     2900    if (FAILED(hrc)) return hrc;
    29192901
    29202902    alock.release();
    2921     rc = i_onClipboardModeChange(aClipboardMode);
     2903    hrc = i_onClipboardModeChange(aClipboardMode);
    29222904    alock.acquire();
    2923     if (FAILED(rc)) return rc;
     2905    if (FAILED(hrc)) return hrc;
    29242906
    29252907    i_setModified(IsModified_MachineData);
     
    29452927HRESULT Machine::setClipboardFileTransfersEnabled(BOOL aEnabled)
    29462928{
    2947     HRESULT rc = S_OK;
    2948 
    29492929    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    29502930
    2951     rc = i_checkStateDependency(MutableOrRunningStateDep);
    2952     if (FAILED(rc)) return rc;
     2931    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     2932    if (FAILED(hrc)) return hrc;
    29532933
    29542934    alock.release();
    2955     rc = i_onClipboardFileTransferModeChange(aEnabled);
     2935    hrc = i_onClipboardFileTransferModeChange(aEnabled);
    29562936    alock.acquire();
    2957     if (FAILED(rc)) return rc;
     2937    if (FAILED(hrc)) return hrc;
    29582938
    29592939    i_setModified(IsModified_MachineData);
     
    29792959HRESULT Machine::setDnDMode(DnDMode_T aDnDMode)
    29802960{
    2981     HRESULT rc = S_OK;
    2982 
    29832961    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    29842962
    2985     rc = i_checkStateDependency(MutableOrRunningStateDep);
    2986     if (FAILED(rc)) return rc;
     2963    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     2964    if (FAILED(hrc)) return hrc;
    29872965
    29882966    alock.release();
    2989     rc = i_onDnDModeChange(aDnDMode);
     2967    hrc = i_onDnDModeChange(aDnDMode);
    29902968
    29912969    alock.acquire();
    2992     if (FAILED(rc)) return rc;
     2970    if (FAILED(hrc)) return hrc;
    29932971
    29942972    i_setModified(IsModified_MachineData);
     
    30693047    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    30703048
    3071     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    3072     if (FAILED(rc)) return rc;
     3049    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     3050    if (FAILED(hrc)) return hrc;
    30733051
    30743052    i_setModified(IsModified_MachineData);
     
    30923070    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    30933071
    3094     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    3095     if (FAILED(rc)) return rc;
     3072    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     3073    if (FAILED(hrc)) return hrc;
    30963074
    30973075    i_setModified(IsModified_MachineData);
     
    31873165    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    31883166
    3189     HRESULT rc = i_checkStateDependency(MutableStateDep);
    3190     if (FAILED(rc)) return rc;
     3167    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     3168    if (FAILED(hrc)) return hrc;
    31913169
    31923170    i_setModified(IsModified_MachineData);
     
    32103188    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    32113189
    3212     HRESULT rc = i_checkStateDependency(MutableStateDep);
    3213     if (FAILED(rc)) return rc;
     3190    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     3191    if (FAILED(hrc)) return hrc;
    32143192
    32153193    i_setModified(IsModified_MachineData);
     
    32883266    /* check the session state */
    32893267    SessionState_T state;
    3290     HRESULT rc = aSession->COMGETTER(State)(&state);
    3291     if (FAILED(rc)) return rc;
     3268    HRESULT hrc = aSession->COMGETTER(State)(&state);
     3269    if (FAILED(hrc)) return hrc;
    32923270
    32933271    if (state != SessionState_Unlocked)
     
    33573335        {
    33583336            LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
    3359             rc = pSessionW->COMGETTER(RemoteConsole)(pConsoleW.asOutParam());
    3360             LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
    3361             if (FAILED(rc))
     3337            hrc = pSessionW->COMGETTER(RemoteConsole)(pConsoleW.asOutParam());
     3338            LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", hrc));
     3339            if (FAILED(hrc))
    33623340                // the failure may occur w/o any error info (from RPC), so provide one
    3363                 return setError(VBOX_E_VM_ERROR,
    3364                                 tr("Failed to get a console object from the direct session (%Rhrc)"), rc);
     3341                return setError(VBOX_E_VM_ERROR, tr("Failed to get a console object from the direct session (%Rhrc)"), hrc);
    33653342            ComAssertRet(!pConsoleW.isNull(), E_FAIL);
    33663343        }
     
    33683345        // share the session machine and W's console with the caller's session
    33693346        LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
    3370         rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
    3371         LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
    3372 
    3373         if (FAILED(rc))
     3347        hrc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
     3348        LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", hrc));
     3349
     3350        if (FAILED(hrc))
    33743351            // the failure may occur w/o any error info (from RPC), so provide one
    3375             return setError(VBOX_E_VM_ERROR,
    3376                             tr("Failed to assign the machine to the session (%Rhrc)"), rc);
     3352            return setError(VBOX_E_VM_ERROR, tr("Failed to assign the machine to the session (%Rhrc)"), hrc);
    33773353        alock.acquire();
    33783354
     
    34583434        ComObjPtr<SessionMachine> sessionMachine;
    34593435        sessionMachine.createObject();
    3460         rc = sessionMachine->init(this);
    3461         AssertComRC(rc);
     3436        hrc = sessionMachine->init(this);
     3437        AssertComRC(hrc);
    34623438
    34633439        /* NOTE: doing return from this function after this point but
     
    34673443         * is possible due to the wrong lock order. */
    34683444
    3469         if (SUCCEEDED(rc))
     3445        if (SUCCEEDED(hrc))
    34703446        {
    34713447            /*
     
    35043480            LogFlowThisFunc(("Calling AssignMachine()...\n"));
    35053481#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
    3506             rc = pSessionControl->AssignMachine(sessionMachine, aLockType, Bstr(strTokenId).raw());
     3482            hrc = pSessionControl->AssignMachine(sessionMachine, aLockType, Bstr(strTokenId).raw());
    35073483#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
    3508             rc = pSessionControl->AssignMachine(sessionMachine, aLockType, pToken);
     3484            hrc = pSessionControl->AssignMachine(sessionMachine, aLockType, pToken);
    35093485            /* Now the token is owned by the client process. */
    35103486            pToken.setNull();
    35113487#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
    3512             LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
     3488            LogFlowThisFunc(("AssignMachine() returned %08X\n", hrc));
    35133489
    35143490            /* The failure may occur w/o any error info (from RPC), so provide one */
    3515             if (FAILED(rc))
    3516                 setError(VBOX_E_VM_ERROR,
    3517                          tr("Failed to assign the machine to the session (%Rhrc)"), rc);
     3491            if (FAILED(hrc))
     3492                setError(VBOX_E_VM_ERROR, tr("Failed to assign the machine to the session (%Rhrc)"), hrc);
    35183493
    35193494            // get session name, either to remember or to compare against
     
    35263501            }
    35273502
    3528             if (    SUCCEEDED(rc)
     3503            if (    SUCCEEDED(hrc)
    35293504                 && fLaunchingVMProcess
    35303505               )
     
    35343509                /* get the console from the direct session */
    35353510                ComPtr<IConsole> console;
    3536                 rc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
    3537                 ComAssertComRC(rc);
    3538 
    3539                 if (SUCCEEDED(rc) && !console)
     3511                hrc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
     3512                ComAssertComRC(hrc);
     3513
     3514                if (SUCCEEDED(hrc) && !console)
    35403515                {
    35413516                    ComAssert(!!console);
    3542                     rc = E_FAIL;
     3517                    hrc = E_FAIL;
    35433518                }
    35443519
    35453520                /* assign machine & console to the remote session */
    3546                 if (SUCCEEDED(rc))
     3521                if (SUCCEEDED(hrc))
    35473522                {
    35483523                    /*
     
    35513526                     */
    35523527                    LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
    3553                     rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
    3554                     LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
     3528                    hrc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
     3529                    LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", hrc));
    35553530
    35563531                    /* The failure may occur w/o any error info (from RPC), so provide one */
    3557                     if (FAILED(rc))
     3532                    if (FAILED(hrc))
    35583533                        setError(VBOX_E_VM_ERROR,
    3559                                  tr("Failed to assign the machine to the remote session (%Rhrc)"), rc);
     3534                                 tr("Failed to assign the machine to the remote session (%Rhrc)"), hrc);
    35603535                }
    35613536
    3562                 if (FAILED(rc))
     3537                if (FAILED(hrc))
    35633538                    pSessionControl->Uninitialize();
    35643539            }
     
    35743549        if (fLaunchingVMProcess)
    35753550        {
    3576             Assert(mData->mSession.mName == strSessionName || FAILED(rc));
     3551            Assert(mData->mSession.mName == strSessionName || FAILED(hrc));
    35773552            /* Note that the progress object is finalized later */
    35783553            /** @todo Consider checking mData->mSession.mProgress for cancellation
     
    35823557             * SessionMachine::uninit() to reap the child process later. */
    35833558
    3584             if (FAILED(rc))
     3559            if (FAILED(hrc))
    35853560            {
    35863561                /* Close the remote session, remove the remote control from the list
     
    36023577        {
    36033578            /* memorize PID of the directly opened session */
    3604             if (SUCCEEDED(rc))
     3579            if (SUCCEEDED(hrc))
    36053580                mData->mSession.mPID = pid;
    36063581        }
    36073582
    3608         if (SUCCEEDED(rc))
     3583        if (SUCCEEDED(hrc))
    36093584        {
    36103585            mData->mSession.mLockType = aLockType;
     
    36283603                /* get the console from the direct session */
    36293604                ComPtr<IConsole> console;
    3630                 rc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
    3631                 ComAssertComRC(rc);
     3605                hrc = pSessionControl->COMGETTER(RemoteConsole)(console.asOutParam());
     3606                ComAssertComRC(hrc);
    36323607                /* send passswords to console */
    36333608                for (SecretKeyStore::SecretKeyMap::iterator it = mData->mpKeyStore->begin();
     
    36523627
    36533628        /* uninitialize the created session machine on failure */
    3654         if (FAILED(rc))
     3629        if (FAILED(hrc))
    36553630            sessionMachine->uninit();
    36563631    }
    36573632
    3658     if (SUCCEEDED(rc))
     3633    if (SUCCEEDED(hrc))
    36593634    {
    36603635        /*
     
    36693644    }
    36703645
    3671     return rc;
     3646    return hrc;
    36723647}
    36733648
     
    36883663        CheckComArgNotNull(aSession);
    36893664
    3690     HRESULT rc = S_OK;
     3665    HRESULT hrc = S_OK;
    36913666    if (strFrontend.isEmpty())
    36923667    {
    36933668        Bstr bstrFrontend;
    3694         rc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
    3695         if (FAILED(rc))
    3696             return rc;
     3669        hrc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
     3670        if (FAILED(hrc))
     3671            return hrc;
    36973672        strFrontend = bstrFrontend;
    36983673        if (strFrontend.isEmpty())
    36993674        {
    37003675            ComPtr<ISystemProperties> systemProperties;
    3701             rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
    3702             if (FAILED(rc))
    3703                 return rc;
    3704             rc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
    3705             if (FAILED(rc))
    3706                 return rc;
     3676            hrc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
     3677            if (FAILED(hrc))
     3678                return hrc;
     3679            hrc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
     3680            if (FAILED(hrc))
     3681                return hrc;
    37073682            strFrontend = bstrFrontend;
    37083683        }
     
    37193694        /* check the session state */
    37203695        SessionState_T state;
    3721         rc = aSession->COMGETTER(State)(&state);
    3722         if (FAILED(rc))
    3723             return rc;
     3696        hrc = aSession->COMGETTER(State)(&state);
     3697        if (FAILED(hrc))
     3698            return hrc;
    37243699
    37253700        if (state != SessionState_Unlocked)
     
    37353710        /* get the teleporter enable state for the progress object init. */
    37363711        BOOL fTeleporterEnabled;
    3737         rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
    3738         if (FAILED(rc))
    3739             return rc;
     3712        hrc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
     3713        if (FAILED(hrc))
     3714            return hrc;
    37403715
    37413716        /* create a progress object */
    37423717        ComObjPtr<ProgressProxy> progress;
    37433718        progress.createObject();
    3744         rc = progress->init(mParent,
    3745                             static_cast<IMachine*>(this),
    3746                             Bstr(tr("Starting VM")).raw(),
    3747                             TRUE /* aCancelable */,
    3748                             fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
    3749                             BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"),
    3750                             mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
    3751                             2 /* uFirstOperationWeight */,
    3752                             fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
    3753 
    3754         if (SUCCEEDED(rc))
    3755         {
    3756             rc = i_launchVMProcess(control, strFrontend, aEnvironmentChanges, progress);
    3757             if (SUCCEEDED(rc))
     3719        hrc = progress->init(mParent,
     3720                             static_cast<IMachine*>(this),
     3721                             Bstr(tr("Starting VM")).raw(),
     3722                             TRUE /* aCancelable */,
     3723                             fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
     3724                             BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"),
     3725                             mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
     3726                             2 /* uFirstOperationWeight */,
     3727                             fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
     3728        if (SUCCEEDED(hrc))
     3729        {
     3730            hrc = i_launchVMProcess(control, strFrontend, aEnvironmentChanges, progress);
     3731            if (SUCCEEDED(hrc))
    37583732            {
    37593733                aProgress = progress;
     
    37953769    }
    37963770
    3797     return rc;
     3771    return hrc;
    37983772}
    37993773
     
    38113785    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    38123786
    3813     HRESULT rc = i_checkStateDependency(MutableStateDep);
    3814     if (FAILED(rc)) return rc;
     3787    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     3788    if (FAILED(hrc)) return hrc;
    38153789
    38163790    i_setModified(IsModified_MachineData);
     
    38503824    AutoWriteLock treeLock(&mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    38513825
    3852     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    3853     if (FAILED(rc)) return rc;
     3826    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     3827    if (FAILED(hrc)) return hrc;
    38543828
    38553829    /// @todo NEWMEDIA implicit machine registration
     
    38623836    /* Check for an existing controller. */
    38633837    ComObjPtr<StorageController> ctl;
    3864     rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
    3865     if (FAILED(rc)) return rc;
     3838    hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
     3839    if (FAILED(hrc)) return hrc;
    38663840
    38673841    StorageControllerType_T ctrlType;
    3868     rc = ctl->COMGETTER(ControllerType)(&ctrlType);
    3869     if (FAILED(rc))
    3870         return setError(E_FAIL,
    3871                         tr("Could not get type of controller '%s'"),
    3872                         aName.c_str());
     3842    hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
     3843    if (FAILED(hrc))
     3844        return setError(E_FAIL, tr("Could not get type of controller '%s'"), aName.c_str());
    38733845
    38743846    bool fSilent = false;
     
    38913863
    38923864    // check that the port and device are not out of range
    3893     rc = ctl->i_checkPortAndDeviceValid(aControllerPort, aDevice);
    3894     if (FAILED(rc)) return rc;
     3865    hrc = ctl->i_checkPortAndDeviceValid(aControllerPort, aDevice);
     3866    if (FAILED(hrc)) return hrc;
    38953867
    38963868    /* check if the device slot is already busy */
     
    40033975                        MediumLockList *pMediumLockList(new MediumLockList());
    40043976
    4005                         rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
    4006                                                             medium /* pToLockWrite */,
    4007                                                             false /* fMediumLockWriteAll */,
    4008                                                             NULL,
    4009                                                             *pMediumLockList);
     3977                        hrc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
     3978                                                             medium /* pToLockWrite */,
     3979                                                             false /* fMediumLockWriteAll */,
     3980                                                             NULL,
     3981                                                             *pMediumLockList);
    40103982                        alock.acquire();
    4011                         if (FAILED(rc))
     3983                        if (FAILED(hrc))
    40123984                            delete pMediumLockList;
    40133985                        else
     
    40163988                            mData->mSession.mLockedMedia.Unlock();
    40173989                            alock.release();
    4018                             rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
     3990                            hrc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
    40193991                            mData->mSession.mLockedMedia.Lock();
    40203992                            alock.acquire();
     
    40223994                        alock.release();
    40233995
    4024                         if (SUCCEEDED(rc))
     3996                        if (SUCCEEDED(hrc))
    40253997                        {
    4026                             rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
     3998                            hrc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
    40273999                            /* Remove lock list in case of error. */
    4028                             if (FAILED(rc))
     4000                            if (FAILED(hrc))
    40294001                            {
    40304002                                mData->mSession.mLockedMedia.Unlock();
     
    41054077                                MediumLockList *pMediumLockList(new MediumLockList());
    41064078
    4107                                 rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
    4108                                                                     medium /* pToLockWrite */,
    4109                                                                     false /* fMediumLockWriteAll */,
    4110                                                                     NULL,
    4111                                                                     *pMediumLockList);
     4079                                hrc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
     4080                                                                     medium /* pToLockWrite */,
     4081                                                                     false /* fMediumLockWriteAll */,
     4082                                                                     NULL,
     4083                                                                     *pMediumLockList);
    41124084                                alock.acquire();
    4113                                 if (FAILED(rc))
     4085                                if (FAILED(hrc))
    41144086                                    delete pMediumLockList;
    41154087                                else
     
    41184090                                    mData->mSession.mLockedMedia.Unlock();
    41194091                                    alock.release();
    4120                                     rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
     4092                                    hrc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
    41214093                                    mData->mSession.mLockedMedia.Lock();
    41224094                                    alock.acquire();
     
    41244096                                alock.release();
    41254097
    4126                                 if (SUCCEEDED(rc))
     4098                                if (SUCCEEDED(hrc))
    41274099                                {
    4128                                     rc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
     4100                                    hrc = i_onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
    41294101                                    /* Remove lock list in case of error. */
    4130                                     if (FAILED(rc))
     4102                                    if (FAILED(hrc))
    41314103                                    {
    41324104                                        mData->mSession.mLockedMedia.Unlock();
     
    42654237            medium->i_getFirstRegistryMachineId(uuidRegistryParent);
    42664238        }
    4267         rc = diff->init(mParent,
    4268                         medium->i_getPreferredDiffFormat(),
    4269                         strFullSnapshotFolder.append(RTPATH_SLASH_STR),
    4270                         uuidRegistryParent,
    4271                         DeviceType_HardDisk);
    4272         if (FAILED(rc)) return rc;
     4239        hrc = diff->init(mParent,
     4240                         medium->i_getPreferredDiffFormat(),
     4241                         strFullSnapshotFolder.append(RTPATH_SLASH_STR),
     4242                         uuidRegistryParent,
     4243                         DeviceType_HardDisk);
     4244        if (FAILED(hrc)) return hrc;
    42734245
    42744246        /* Apply the normal locking logic to the entire chain. */
     
    42764248        mediumLock.release();
    42774249        treeLock.release();
    4278         rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
    4279                                           diff /* pToLockWrite */,
    4280                                           false /* fMediumLockWriteAll */,
    4281                                           medium,
    4282                                           *pMediumLockList);
     4250        hrc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
     4251                                           diff /* pToLockWrite */,
     4252                                           false /* fMediumLockWriteAll */,
     4253                                           medium,
     4254                                           *pMediumLockList);
    42834255        treeLock.acquire();
    42844256        mediumLock.acquire();
    4285         if (SUCCEEDED(rc))
     4257        if (SUCCEEDED(hrc))
    42864258        {
    42874259            mediumLock.release();
    42884260            treeLock.release();
    4289             rc = pMediumLockList->Lock();
     4261            hrc = pMediumLockList->Lock();
    42904262            treeLock.acquire();
    42914263            mediumLock.acquire();
    4292             if (FAILED(rc))
    4293                 setError(rc,
     4264            if (FAILED(hrc))
     4265                setError(hrc,
    42944266                         tr("Could not lock medium when creating diff '%s'"),
    42954267                         diff->i_getLocationFull().c_str());
     
    43054277                alock.release();
    43064278
    4307                 rc = medium->i_createDiffStorage(diff,
    4308                                                  medium->i_getPreferredDiffVariant(),
    4309                                                  pMediumLockList,
    4310                                                  NULL /* aProgress */,
    4311                                                  true /* aWait */,
    4312                                                  false /* aNotify */);
     4279                hrc = medium->i_createDiffStorage(diff,
     4280                                                  medium->i_getPreferredDiffVariant(),
     4281                                                  pMediumLockList,
     4282                                                  NULL /* aProgress */,
     4283                                                  true /* aWait */,
     4284                                                  false /* aNotify */);
    43134285
    43144286                alock.acquire();
     
    43234295        delete pMediumLockList;
    43244296
    4325         if (FAILED(rc)) return rc;
     4297        if (FAILED(hrc)) return hrc;
    43264298
    43274299        /* use the created diff for the actual attachment */
     
    43354307    ComObjPtr<MediumAttachment> attachment;
    43364308    attachment.createObject();
    4337     rc = attachment->init(this,
    4338                           medium,
    4339                           aName,
    4340                           aControllerPort,
    4341                           aDevice,
    4342                           aType,
    4343                           fIndirect,
    4344                           false /* fPassthrough */,
    4345                           false /* fTempEject */,
    4346                           false /* fNonRotational */,
    4347                           false /* fDiscard */,
    4348                           fHotplug || ctrlType == StorageControllerType_USB /* fHotPluggable */,
    4349                           Utf8Str::Empty);
    4350     if (FAILED(rc)) return rc;
     4309    hrc = attachment->init(this,
     4310                           medium,
     4311                           aName,
     4312                           aControllerPort,
     4313                           aDevice,
     4314                           aType,
     4315                           fIndirect,
     4316                           false /* fPassthrough */,
     4317                           false /* fTempEject */,
     4318                           false /* fNonRotational */,
     4319                           false /* fDiscard */,
     4320                           fHotplug || ctrlType == StorageControllerType_USB /* fHotPluggable */,
     4321                           Utf8Str::Empty);
     4322    if (FAILED(hrc)) return hrc;
    43514323
    43524324    if (associate && !medium.isNull())
    43534325    {
    43544326        // as the last step, associate the medium to the VM
    4355         rc = medium->i_addBackReference(mData->mUuid);
     4327        hrc = medium->i_addBackReference(mData->mUuid);
    43564328        // here we can fail because of Deleting, or being in process of creating a Diff
    4357         if (FAILED(rc)) return rc;
     4329        if (FAILED(hrc)) return hrc;
    43584330
    43594331        mediumLock.release();
     
    43814353            MediumLockList *pMediumLockList(new MediumLockList());
    43824354
    4383             rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
    4384                                                 medium /* pToLockWrite */,
    4385                                                 false /* fMediumLockWriteAll */,
    4386                                                 NULL,
    4387                                                 *pMediumLockList);
     4355            hrc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
     4356                                                 medium /* pToLockWrite */,
     4357                                                 false /* fMediumLockWriteAll */,
     4358                                                 NULL,
     4359                                                 *pMediumLockList);
    43884360            alock.acquire();
    4389             if (FAILED(rc))
     4361            if (FAILED(hrc))
    43904362                delete pMediumLockList;
    43914363            else
     
    43944366                mData->mSession.mLockedMedia.Unlock();
    43954367                alock.release();
    4396                 rc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
     4368                hrc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
    43974369                mData->mSession.mLockedMedia.Lock();
    43984370                alock.acquire();
     
    44014373        }
    44024374
    4403         if (SUCCEEDED(rc))
    4404         {
    4405             rc = i_onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
     4375        if (SUCCEEDED(hrc))
     4376        {
     4377            hrc = i_onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
    44064378            /* Remove lock list in case of error. */
    4407             if (FAILED(rc))
     4379            if (FAILED(hrc))
    44084380            {
    44094381                mData->mSession.mLockedMedia.Unlock();
     
    44194391    mParent->i_saveModifiedRegistries();
    44204392
    4421     if (SUCCEEDED(rc))
     4393    if (SUCCEEDED(hrc))
    44224394    {
    44234395        if (fIndirect && medium != aM)
     
    44264398    }
    44274399
    4428     return rc;
     4400    return hrc;
    44294401}
    44304402
     
    44324404                              LONG aDevice)
    44334405{
    4434     LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n",
    4435                      aName.c_str(), aControllerPort, aDevice));
     4406    LogFlowThisFunc(("aControllerName=\"%s\" aControllerPort=%d aDevice=%d\n", aName.c_str(), aControllerPort, aDevice));
    44364407
    44374408    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    44384409
    4439     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    4440     if (FAILED(rc)) return rc;
     4410    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     4411    if (FAILED(hrc)) return hrc;
    44414412
    44424413    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
     
    44444415    /* Check for an existing controller. */
    44454416    ComObjPtr<StorageController> ctl;
    4446     rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
    4447     if (FAILED(rc)) return rc;
     4417    hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
     4418    if (FAILED(hrc)) return hrc;
    44484419
    44494420    StorageControllerType_T ctrlType;
    4450     rc = ctl->COMGETTER(ControllerType)(&ctrlType);
    4451     if (FAILED(rc))
    4452         return setError(E_FAIL,
    4453                         tr("Could not get type of controller '%s'"),
    4454                         aName.c_str());
     4421    hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
     4422    if (FAILED(hrc))
     4423        return setError(E_FAIL, tr("Could not get type of controller '%s'"), aName.c_str());
    44554424
    44564425    bool fSilent = false;
     
    44944463    {
    44954464        alock.release();
    4496         rc = i_onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
     4465        hrc = i_onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
    44974466        alock.acquire();
    44984467    }
    4499     if (FAILED(rc)) return rc;
     4468    if (FAILED(hrc)) return hrc;
    45004469
    45014470    /* If we are here everything went well and we can delete the implicit now. */
    4502     rc = i_detachDevice(pAttach, alock, NULL /* pSnapshot */);
     4471    hrc = i_detachDevice(pAttach, alock, NULL /* pSnapshot */);
    45034472
    45044473    alock.release();
     
    45094478    mParent->i_saveModifiedRegistries();
    45104479
    4511     if (SUCCEEDED(rc))
     4480    if (SUCCEEDED(hrc))
    45124481        mParent->i_onStorageDeviceChanged(pAttach, TRUE, fSilent);
    45134482
    4514     return rc;
     4483    return hrc;
    45154484}
    45164485
     
    45234492    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    45244493
    4525     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    4526     if (FAILED(rc)) return rc;
     4494    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     4495    if (FAILED(hrc)) return hrc;
    45274496
    45284497    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
     
    45304499    /* Check for an existing controller. */
    45314500    ComObjPtr<StorageController> ctl;
    4532     rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
    4533     if (FAILED(rc)) return rc;
     4501    hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
     4502    if (FAILED(hrc)) return hrc;
    45344503
    45354504    StorageControllerType_T ctrlType;
    4536     rc = ctl->COMGETTER(ControllerType)(&ctrlType);
    4537     if (FAILED(rc))
     4505    hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
     4506    if (FAILED(hrc))
    45384507        return setError(E_FAIL,
    45394508                        tr("Could not get type of controller '%s'"),
     
    45854554    attLock.release();
    45864555    alock.release();
    4587     rc = i_onStorageDeviceChange(pAttach, FALSE /* aRemove */, FALSE /* aSilent */);
    4588     if (SUCCEEDED(rc) && fValueChanged)
     4556    hrc = i_onStorageDeviceChange(pAttach, FALSE /* aRemove */, FALSE /* aSilent */);
     4557    if (SUCCEEDED(hrc) && fValueChanged)
    45894558        mParent->i_onStorageDeviceChanged(pAttach, FALSE, FALSE);
    45904559
    4591     return rc;
     4560    return hrc;
    45924561}
    45934562
     
    46014570    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    46024571
    4603     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    4604     if (FAILED(rc)) return rc;
     4572    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     4573    if (FAILED(hrc)) return hrc;
    46054574
    46064575    MediumAttachment *pAttach = i_findAttachment(*mMediumAttachments.data(),
     
    46374606    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    46384607
    4639     HRESULT rc = i_checkStateDependency(MutableStateDep);
    4640     if (FAILED(rc)) return rc;
     4608    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     4609    if (FAILED(hrc)) return hrc;
    46414610
    46424611    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
     
    46804649    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    46814650
    4682     HRESULT rc = i_checkStateDependency(MutableStateDep);
    4683     if (FAILED(rc)) return rc;
     4651    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     4652    if (FAILED(hrc)) return hrc;
    46844653
    46854654    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
     
    47224691    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    47234692
    4724     HRESULT rc = i_checkStateDependency(MutableStateDep);
    4725     if (FAILED(rc)) return rc;
     4693    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     4694    if (FAILED(hrc)) return hrc;
    47264695
    47274696    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
     
    47434712    /* Check for an existing controller. */
    47444713    ComObjPtr<StorageController> ctl;
    4745     rc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
    4746     if (FAILED(rc)) return rc;
     4714    hrc = i_getStorageControllerByName(aName, ctl, true /* aSetError */);
     4715    if (FAILED(hrc)) return hrc;
    47474716
    47484717    StorageControllerType_T ctrlType;
    4749     rc = ctl->COMGETTER(ControllerType)(&ctrlType);
    4750     if (FAILED(rc))
     4718    hrc = ctl->COMGETTER(ControllerType)(&ctrlType);
     4719    if (FAILED(hrc))
    47514720        return setError(E_FAIL,
    47524721                        tr("Could not get type of controller '%s'"),
     
    47934762    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    47944763
    4795     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    4796     if (FAILED(rc)) return rc;
     4764    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     4765    if (FAILED(hrc)) return hrc;
    47974766
    47984767    if (Global::IsOnlineOrTransient(mData->mMachineState))
     
    48264795        /* Get the bandwidth group object and release it - this must not fail. */
    48274796        ComObjPtr<BandwidthGroup> pBandwidthGroupOld;
    4828         rc = i_getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
    4829         Assert(SUCCEEDED(rc));
     4797        hrc = i_getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
     4798        Assert(SUCCEEDED(hrc));
    48304799
    48314800        pBandwidthGroupOld->i_release();
     
    49594928    mediumLock.release();
    49604929    multiLock.release();
    4961     HRESULT rc = i_onMediumChange(pAttach, aForce);
     4930    hrc = i_onMediumChange(pAttach, aForce);
    49624931    multiLock.acquire();
    49634932    mediumLock.acquire();
    49644933
    49654934    /* On error roll back this change only. */
    4966     if (FAILED(rc))
     4935    if (FAILED(hrc))
    49674936    {
    49684937        if (!pMedium.isNull())
     
    49744943        /* If the attachment is gone in the meantime, bail out. */
    49754944        if (pAttach.isNull())
    4976             return rc;
     4945            return hrc;
    49774946        AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
    49784947        if (!oldmedium.isNull())
     
    49894958    mParent->i_saveModifiedRegistries();
    49904959
    4991     return rc;
     4960    return hrc;
    49924961}
    49934962HRESULT Machine::getMedium(const com::Utf8Str &aName,
     
    51985167    AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
    51995168
    5200     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    5201     if (FAILED(rc)) return rc;
     5169    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     5170    if (FAILED(hrc)) return hrc;
    52025171
    52035172    /* the settings file path may never be null */
     
    52065175    /* save all VM data excluding snapshots */
    52075176    bool fNeedsGlobalSaveSettings = false;
    5208     rc = i_saveSettings(&fNeedsGlobalSaveSettings, mlock);
     5177    hrc = i_saveSettings(&fNeedsGlobalSaveSettings, mlock);
    52095178    mlock.release();
    52105179
    5211     if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
     5180    if (SUCCEEDED(hrc) && fNeedsGlobalSaveSettings)
    52125181    {
    52135182        // save the global settings; for that we should hold only the VirtualBox lock
    52145183        AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
    5215         rc = mParent->i_saveSettings();
    5216     }
    5217 
    5218     return rc;
     5184        hrc = mParent->i_saveSettings();
     5185    }
     5186
     5187    return hrc;
    52195188}
    52205189
     
    52725241    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    52735242
    5274     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    5275     if (FAILED(rc)) return rc;
     5243    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     5244    if (FAILED(hrc)) return hrc;
    52765245
    52775246    /*
     
    53185287    }
    53195288
    5320     HRESULT rc = S_OK;
     5289    HRESULT hrc = S_OK;
    53215290    mData->llFilesToDelete.clear();
    53225291
     
    53695338    }
    53705339
    5371     if (FAILED(rc))
     5340    if (FAILED(hrc))
    53725341    {
    53735342        i_rollbackMedia();
    5374         return rc;
     5343        return hrc;
    53755344    }
    53765345
     
    54585427        /* we might have been uninitialized because the session was accidentally
    54595428         * closed by the client, so don't assert */
    5460         HRESULT rc = setError(E_FAIL,
    5461                               tr("The session has been accidentally closed"));
    5462         task.m_pProgress->i_notifyComplete(rc);
     5429        HRESULT hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
     5430        task.m_pProgress->i_notifyComplete(hrc);
    54635431        LogFlowThisFuncLeave();
    54645432        return;
     
    54675435    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    54685436
    5469     HRESULT rc = S_OK;
    5470 
     5437    HRESULT hrc;
    54715438    try
    54725439    {
    54735440        ULONG uLogHistoryCount = 3;
    54745441        ComPtr<ISystemProperties> systemProperties;
    5475         rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
    5476         if (FAILED(rc)) throw rc;
     5442        hrc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
     5443        if (FAILED(hrc)) throw hrc;
    54775444
    54785445        if (!systemProperties.isNull())
    54795446        {
    5480             rc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
    5481             if (FAILED(rc)) throw rc;
     5447            hrc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
     5448            if (FAILED(hrc)) throw hrc;
    54825449        }
    54835450
     
    54935460                Utf8Str strLocation = pMedium->i_getLocationFull();
    54945461                LogFunc(("Deleting file %s\n", strLocation.c_str()));
    5495                 rc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
    5496                 if (FAILED(rc)) throw rc;
     5462                hrc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
     5463                if (FAILED(hrc)) throw hrc;
    54975464            }
    54985465            if (pMedium->i_isMediumFormatFile())
    54995466            {
    55005467                ComPtr<IProgress> pProgress2;
    5501                 rc = pMedium->DeleteStorage(pProgress2.asOutParam());
    5502                 if (FAILED(rc)) throw rc;
    5503                 rc = task.m_pProgress->WaitForOtherProgressCompletion(pProgress2, 0 /* indefinite wait */);
    5504                 if (FAILED(rc)) throw rc;
     5468                hrc = pMedium->DeleteStorage(pProgress2.asOutParam());
     5469                if (FAILED(hrc)) throw hrc;
     5470                hrc = task.m_pProgress->WaitForOtherProgressCompletion(pProgress2, 0 /* indefinite wait */);
     5471                if (FAILED(hrc)) throw hrc;
    55055472            }
    55065473
     
    55285495            const Utf8Str &strFile = *it;
    55295496            LogFunc(("Deleting file %s\n", strFile.c_str()));
    5530             rc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
    5531             if (FAILED(rc)) throw rc;
     5497            hrc = task.m_pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
     5498            if (FAILED(hrc)) throw hrc;
    55325499            i_deleteFile(strFile);
    55335500        }
    55345501
    5535         rc = task.m_pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
    5536         if (FAILED(rc)) throw rc;
     5502        hrc = task.m_pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
     5503        if (FAILED(hrc)) throw hrc;
    55375504
    55385505        /* delete the settings only when the file actually exists */
     
    56025569        mParent->i_saveModifiedRegistries();
    56035570    }
    5604     catch (HRESULT aRC) { rc = aRC; }
    5605 
    5606     task.m_pProgress->i_notifyComplete(rc);
     5571    catch (HRESULT hrcXcpt)
     5572    {
     5573        hrc = hrcXcpt;
     5574    }
     5575
     5576    task.m_pProgress->i_notifyComplete(hrc);
    56075577
    56085578    LogFlowThisFuncLeave();
     
    56135583    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    56145584
    5615     HRESULT rc = i_checkStateDependency(MutableStateDep);
    5616     if (FAILED(rc)) return rc;
     5585    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     5586    if (FAILED(hrc)) return hrc;
    56175587
    56185588    if (mData->mRegistered)
     
    56395609            return setError(E_INVALIDARG, tr("The given medium pointer with index %d is invalid"), i);
    56405610        SafeArray<BSTR> ids;
    5641         rc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
    5642         if (FAILED(rc)) return rc;
     5611        hrc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
     5612        if (FAILED(hrc)) return hrc;
    56435613        /* At this point the medium should not have any back references
    56445614         * anymore. If it has it is attached to another VM and *must* not
     
    56505620    ComObjPtr<Progress> pProgress;
    56515621    pProgress.createObject();
    5652     rc = pProgress->init(i_getVirtualBox(),
    5653                          static_cast<IMachine*>(this) /* aInitiator */,
    5654                          tr("Deleting files"),
    5655                          true /* fCancellable */,
    5656                          (ULONG)(1 + llMediums.size() + llFilesToDelete.size() + 1),    // cOperations
    5657                          tr("Collecting file inventory"));
    5658     if (FAILED(rc))
    5659         return rc;
     5622    hrc = pProgress->init(i_getVirtualBox(),
     5623                          static_cast<IMachine*>(this) /* aInitiator */,
     5624                          tr("Deleting files"),
     5625                          true /* fCancellable */,
     5626                          (ULONG)(1 + llMediums.size() + llFilesToDelete.size() + 1),    // cOperations
     5627                          tr("Collecting file inventory"));
     5628    if (FAILED(hrc))
     5629        return hrc;
    56605630
    56615631    /* create and start the task on a separate thread (note that it will not
    56625632     * start working until we release alock) */
    56635633    DeleteConfigTask *pTask = new DeleteConfigTask(this, pProgress, "DeleteVM", llMediums, llFilesToDelete);
    5664     rc = pTask->createThread();
     5634    hrc = pTask->createThread();
    56655635    pTask = NULL;
    5666     if (FAILED(rc))
    5667         return rc;
     5636    if (FAILED(hrc))
     5637        return hrc;
    56685638
    56695639    pProgress.queryInterfaceTo(aProgress.asOutParam());
     
    56795649
    56805650    ComObjPtr<Snapshot> pSnapshot;
    5681     HRESULT rc;
     5651    HRESULT hrc;
    56825652
    56835653    if (aNameOrId.isEmpty())
    56845654        // null case (caller wants root snapshot): i_findSnapshotById() handles this
    5685         rc = i_findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
     5655        hrc = i_findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
    56865656    else
    56875657    {
    56885658        Guid uuid(aNameOrId);
    56895659        if (uuid.isValid())
    5690             rc = i_findSnapshotById(uuid, pSnapshot, true /* aSetError */);
     5660            hrc = i_findSnapshotById(uuid, pSnapshot, true /* aSetError */);
    56915661        else
    5692             rc = i_findSnapshotByName(aNameOrId, pSnapshot, true /* aSetError */);
     5662            hrc = i_findSnapshotByName(aNameOrId, pSnapshot, true /* aSetError */);
    56935663    }
    56945664    pSnapshot.queryInterfaceTo(aSnapshot.asOutParam());
    56955665
    5696     return rc;
     5666    return hrc;
    56975667}
    56985668
     
    57025672    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    57035673
    5704     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    5705     if (FAILED(rc)) return rc;
     5674    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     5675    if (FAILED(hrc)) return hrc;
    57065676
    57075677    ComObjPtr<SharedFolder> sharedFolder;
    5708     rc = i_findSharedFolder(aName, sharedFolder, false /* aSetError */);
    5709     if (SUCCEEDED(rc))
     5678    hrc = i_findSharedFolder(aName, sharedFolder, false /* aSetError */);
     5679    if (SUCCEEDED(hrc))
    57105680        return setError(VBOX_E_OBJECT_IN_USE,
    57115681                        tr("Shared folder named '%s' already exists"),
     
    57135683
    57145684    sharedFolder.createObject();
    5715     rc = sharedFolder->init(i_getMachine(),
    5716                             aName,
    5717                             aHostPath,
    5718                             !!aWritable,
    5719                             !!aAutomount,
    5720                             aAutoMountPoint,
    5721                             true /* fFailOnError */);
    5722     if (FAILED(rc)) return rc;
     5685    hrc = sharedFolder->init(i_getMachine(),
     5686                             aName,
     5687                             aHostPath,
     5688                             !!aWritable,
     5689                             !!aAutomount,
     5690                             aAutoMountPoint,
     5691                             true /* fFailOnError */);
     5692    if (FAILED(hrc)) return hrc;
    57235693
    57245694    i_setModified(IsModified_SharedFolders);
     
    57375707    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    57385708
    5739     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    5740     if (FAILED(rc)) return rc;
     5709    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     5710    if (FAILED(hrc)) return hrc;
    57415711
    57425712    ComObjPtr<SharedFolder> sharedFolder;
    5743     rc = i_findSharedFolder(aName, sharedFolder, true /* aSetError */);
    5744     if (FAILED(rc)) return rc;
     5713    hrc = i_findSharedFolder(aName, sharedFolder, true /* aSetError */);
     5714    if (FAILED(hrc)) return hrc;
    57455715
    57465716    i_setModified(IsModified_SharedFolders);
     
    58395809                                          com::Utf8Str &aFlags) const
    58405810{
    5841     HRESULT rc = S_OK;
     5811    HRESULT hrc = S_OK;
    58425812    Bstr bstrValue;
    58435813    Bstr bstrFlags;
     
    58525822    /* ignore calls made after #OnSessionEnd() is called */
    58535823    if (!directControl)
    5854         rc = E_ACCESSDENIED;
     5824        hrc = E_ACCESSDENIED;
    58555825    else
    5856         rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr::Empty.raw(), Bstr::Empty.raw(),
    5857                                                 0 /* accessMode */,
    5858                                                 bstrValue.asOutParam(), aTimestamp, bstrFlags.asOutParam());
     5826        hrc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr::Empty.raw(), Bstr::Empty.raw(),
     5827                                                 0 /* accessMode */,
     5828                                                 bstrValue.asOutParam(), aTimestamp, bstrFlags.asOutParam());
    58595829
    58605830    aValue = bstrValue;
    58615831    aFlags = bstrFlags;
    58625832
    5863     return rc;
     5833    return hrc;
    58645834}
    58655835#endif // VBOX_WITH_GUEST_PROPS
     
    58745844#else // VBOX_WITH_GUEST_PROPS
    58755845
    5876     HRESULT rc = i_getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
    5877 
    5878     if (rc == E_ACCESSDENIED)
     5846    HRESULT hrc = i_getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
     5847
     5848    if (hrc == E_ACCESSDENIED)
    58795849        /* The VM is not running or the service is not (yet) accessible */
    5880         rc = i_getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
    5881     return rc;
     5850        hrc = i_getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
     5851    return hrc;
    58825852#endif // VBOX_WITH_GUEST_PROPS
    58835853}
     
    58875857    LONG64 dummyTimestamp;
    58885858    com::Utf8Str dummyFlags;
    5889     HRESULT rc = getGuestProperty(aProperty, aValue, &dummyTimestamp, dummyFlags);
    5890     return rc;
     5859    return getGuestProperty(aProperty, aValue, &dummyTimestamp, dummyFlags);
    58915860
    58925861}
     
    58955864    com::Utf8Str dummyFlags;
    58965865    com::Utf8Str dummyValue;
    5897     HRESULT rc = getGuestProperty(aProperty, dummyValue, aValue, dummyFlags);
    5898     return rc;
     5866    return getGuestProperty(aProperty, dummyValue, aValue, dummyFlags);
    58995867}
    59005868
     
    59075875{
    59085876    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    5909     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    5910     if (FAILED(rc)) return rc;
     5877    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     5878    if (FAILED(hrc)) return hrc;
    59115879
    59125880    try
     
    59395907            if (it->second.mFlags & (GUEST_PROP_F_RDONLYHOST))
    59405908            {
    5941                 rc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str());
     5909                hrc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str());
    59425910            }
    59435911            else
     
    59635931        }
    59645932
    5965         if (SUCCEEDED(rc))
     5933        if (SUCCEEDED(hrc))
    59665934        {
    59675935            alock.release();
     
    59725940    catch (std::bad_alloc &)
    59735941    {
    5974         rc = E_OUTOFMEMORY;
    5975     }
    5976 
    5977     return rc;
     5942        hrc = E_OUTOFMEMORY;
     5943    }
     5944
     5945    return hrc;
    59785946}
    59795947
     
    59875955                                        const com::Utf8Str &aFlags, bool fDelete)
    59885956{
    5989     HRESULT rc;
     5957    HRESULT hrc;
    59905958
    59915959    try
     
    60025970        LONG64 dummy64;
    60035971        if (!directControl)
    6004             rc = E_ACCESSDENIED;
     5972            hrc = E_ACCESSDENIED;
    60055973        else
    60065974            /** @todo Fix when adding DeleteGuestProperty(), see defect. */
    6007             rc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr(aValue).raw(), Bstr(aFlags).raw(),
    6008                                                     fDelete ? 2 : 1 /* accessMode */,
    6009                                                     dummy1.asOutParam(), &dummy64, dummy2.asOutParam());
     5975            hrc = directControl->AccessGuestProperty(Bstr(aName).raw(), Bstr(aValue).raw(), Bstr(aFlags).raw(),
     5976                                                     fDelete ? 2 : 1 /* accessMode */,
     5977                                                     dummy1.asOutParam(), &dummy64, dummy2.asOutParam());
    60105978    }
    60115979    catch (std::bad_alloc &)
    60125980    {
    6013         rc = E_OUTOFMEMORY;
    6014     }
    6015 
    6016     return rc;
     5981        hrc = E_OUTOFMEMORY;
     5982    }
     5983
     5984    return hrc;
    60175985}
    60185986#endif // VBOX_WITH_GUEST_PROPS
     
    60315999    AssertRCReturn(vrc, setErrorBoth(E_INVALIDARG, vrc));
    60326000
    6033     HRESULT rc = i_setGuestPropertyToVM(aProperty, aValue, aFlags, /* fDelete = */ false);
    6034     if (rc == E_ACCESSDENIED)
     6001    HRESULT hrc = i_setGuestPropertyToVM(aProperty, aValue, aFlags, /* fDelete = */ false);
     6002    if (hrc == E_ACCESSDENIED)
    60356003        /* The VM is not running or the service is not (yet) accessible */
    6036         rc = i_setGuestPropertyToService(aProperty, aValue, aFlags, /* fDelete = */ false);
    6037     return rc;
     6004        hrc = i_setGuestPropertyToService(aProperty, aValue, aFlags, /* fDelete = */ false);
     6005    return hrc;
    60386006#endif // VBOX_WITH_GUEST_PROPS
    60396007}
     
    60496017    ReturnComNotImplemented();
    60506018#else // VBOX_WITH_GUEST_PROPS
    6051     HRESULT rc = i_setGuestPropertyToVM(aName, "", "", /* fDelete = */ true);
    6052     if (rc == E_ACCESSDENIED)
     6019    HRESULT hrc = i_setGuestPropertyToVM(aName, "", "", /* fDelete = */ true);
     6020    if (hrc == E_ACCESSDENIED)
    60536021        /* The VM is not running or the service is not (yet) accessible */
    6054         rc = i_setGuestPropertyToService(aName, "", "", /* fDelete = */ true);
    6055     return rc;
     6022        hrc = i_setGuestPropertyToService(aName, "", "", /* fDelete = */ true);
     6023    return hrc;
    60566024#endif // VBOX_WITH_GUEST_PROPS
    60576025}
     
    61376105                                                std::vector<com::Utf8Str> &aFlags)
    61386106{
    6139     HRESULT rc;
     6107    HRESULT hrc;
    61406108    ComPtr<IInternalSessionControl> directControl;
    61416109    {
     
    61516119
    61526120    if (!directControl)
    6153         rc = E_ACCESSDENIED;
     6121        hrc = E_ACCESSDENIED;
    61546122    else
    6155         rc = directControl->EnumerateGuestProperties(Bstr(aPatterns).raw(),
    6156                                                      ComSafeArrayAsOutParam(bNames),
    6157                                                      ComSafeArrayAsOutParam(bValues),
    6158                                                      ComSafeArrayAsOutParam(bTimestamps),
    6159                                                      ComSafeArrayAsOutParam(bFlags));
     6123        hrc = directControl->EnumerateGuestProperties(Bstr(aPatterns).raw(),
     6124                                                      ComSafeArrayAsOutParam(bNames),
     6125                                                      ComSafeArrayAsOutParam(bValues),
     6126                                                      ComSafeArrayAsOutParam(bTimestamps),
     6127                                                      ComSafeArrayAsOutParam(bFlags));
    61606128    size_t i;
    61616129    aNames.resize(bNames.size());
     
    61726140        aFlags[i] = Utf8Str(bFlags[i]);
    61736141
    6174     return rc;
     6142    return hrc;
    61756143}
    61766144#endif // VBOX_WITH_GUEST_PROPS
     
    61856153#else // VBOX_WITH_GUEST_PROPS
    61866154
    6187     HRESULT rc = i_enumerateGuestPropertiesOnVM(aPatterns, aNames, aValues, aTimestamps, aFlags);
    6188 
    6189     if (rc == E_ACCESSDENIED)
     6155    HRESULT hrc = i_enumerateGuestPropertiesOnVM(aPatterns, aNames, aValues, aTimestamps, aFlags);
     6156
     6157    if (hrc == E_ACCESSDENIED)
    61906158        /* The VM is not running or the service is not (yet) accessible */
    6191         rc = i_enumerateGuestPropertiesInService(aPatterns, aNames, aValues, aTimestamps, aFlags);
    6192     return rc;
     6159        hrc = i_enumerateGuestPropertiesInService(aPatterns, aNames, aValues, aTimestamps, aFlags);
     6160    return hrc;
    61936161#endif // VBOX_WITH_GUEST_PROPS
    61946162}
     
    61996167    MediumAttachmentList atts;
    62006168
    6201     HRESULT rc = i_getMediumAttachmentsOfController(aName, atts);
    6202     if (FAILED(rc)) return rc;
     6169    HRESULT hrc = i_getMediumAttachmentsOfController(aName, atts);
     6170    if (FAILED(hrc)) return hrc;
    62036171
    62046172    aMediumAttachments.resize(atts.size());
     
    62526220    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    62536221
    6254     HRESULT rc = i_checkStateDependency(MutableStateDep);
    6255     if (FAILED(rc)) return rc;
     6222    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     6223    if (FAILED(hrc)) return hrc;
    62566224
    62576225    /* try to find one with the name first. */
    62586226    ComObjPtr<StorageController> ctrl;
    62596227
    6260     rc = i_getStorageControllerByName(aName, ctrl, false /* aSetError */);
    6261     if (SUCCEEDED(rc))
     6228    hrc = i_getStorageControllerByName(aName, ctrl, false /* aSetError */);
     6229    if (SUCCEEDED(hrc))
    62626230        return setError(VBOX_E_OBJECT_IN_USE,
    62636231                        tr("Storage controller named '%s' already exists"),
     
    62876255    }
    62886256
    6289     rc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
    6290     if (FAILED(rc)) return rc;
     6257    hrc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
     6258    if (FAILED(hrc)) return hrc;
    62916259
    62926260    i_setModified(IsModified_Storage);
     
    63106278    ComObjPtr<StorageController> ctrl;
    63116279
    6312     HRESULT rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
    6313     if (SUCCEEDED(rc))
     6280    HRESULT hrc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
     6281    if (SUCCEEDED(hrc))
    63146282        ctrl.queryInterfaceTo(aStorageController.asOutParam());
    63156283
    6316     return rc;
     6284    return hrc;
    63176285}
    63186286
     
    63456313    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    63466314
    6347     HRESULT rc = i_checkStateDependency(MutableStateDep);
    6348     if (FAILED(rc)) return rc;
     6315    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     6316    if (FAILED(hrc)) return hrc;
    63496317
    63506318    ComObjPtr<StorageController> ctrl;
    63516319
    6352     rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
    6353     if (SUCCEEDED(rc))
     6320    hrc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
     6321    if (SUCCEEDED(hrc))
    63546322    {
    63556323        /* Ensure that only one controller of each type is marked as bootable. */
     
    63746342        }
    63756343
    6376         if (SUCCEEDED(rc))
     6344        if (SUCCEEDED(hrc))
    63776345        {
    63786346            ctrl->i_setBootable(aBootable);
     
    63816349    }
    63826350
    6383     if (SUCCEEDED(rc))
     6351    if (SUCCEEDED(hrc))
    63846352    {
    63856353        /* inform the direct session if any */
     
    63886356    }
    63896357
    6390     return rc;
     6358    return hrc;
    63916359}
    63926360
     
    63956363    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    63966364
    6397     HRESULT rc = i_checkStateDependency(MutableStateDep);
    6398     if (FAILED(rc)) return rc;
     6365    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     6366    if (FAILED(hrc)) return hrc;
    63996367
    64006368    ComObjPtr<StorageController> ctrl;
    6401     rc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
    6402     if (FAILED(rc)) return rc;
     6369    hrc = i_getStorageControllerByName(aName, ctrl, true /* aSetError */);
     6370    if (FAILED(hrc)) return hrc;
    64036371
    64046372    MediumAttachmentList llDetachedAttachments;
     
    64246392            {
    64256393                llDetachedAttachments.push_back(pAttachTemp);
    6426                 rc = i_detachDevice(pAttachTemp, alock, NULL);
    6427                 if (FAILED(rc)) return rc;
     6394                hrc = i_detachDevice(pAttachTemp, alock, NULL);
     6395                if (FAILED(hrc)) return hrc;
    64286396            }
    64296397        }
     
    64656433    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    64666434
    6467     HRESULT rc = i_checkStateDependency(MutableStateDep);
    6468     if (FAILED(rc)) return rc;
     6435    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     6436    if (FAILED(hrc)) return hrc;
    64696437
    64706438    /* try to find one with the same type first. */
    64716439    ComObjPtr<USBController> ctrl;
    64726440
    6473     rc = i_getUSBControllerByName(aName, ctrl, false /* aSetError */);
    6474     if (SUCCEEDED(rc))
     6441    hrc = i_getUSBControllerByName(aName, ctrl, false /* aSetError */);
     6442    if (SUCCEEDED(hrc))
    64756443        return setError(VBOX_E_OBJECT_IN_USE,
    64766444                        tr("USB controller named '%s' already exists"),
     
    64796447    /* Check that we don't exceed the maximum number of USB controllers for the given type. */
    64806448    ULONG maxInstances;
    6481     rc = mParent->i_getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
    6482     if (FAILED(rc))
    6483         return rc;
     6449    hrc = mParent->i_getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
     6450    if (FAILED(hrc))
     6451        return hrc;
    64846452
    64856453    ULONG cInstances = i_getUSBControllerCountByType(aType);
     
    64906458    ctrl.createObject();
    64916459
    6492     rc = ctrl->init(this, aName, aType);
    6493     if (FAILED(rc)) return rc;
     6460    hrc = ctrl->init(this, aName, aType);
     6461    if (FAILED(hrc)) return hrc;
    64946462
    64956463    i_setModified(IsModified_USB);
     
    65126480    ComObjPtr<USBController> ctrl;
    65136481
    6514     HRESULT rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
    6515     if (SUCCEEDED(rc))
     6482    HRESULT hrc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
     6483    if (SUCCEEDED(hrc))
    65166484        ctrl.queryInterfaceTo(aController.asOutParam());
    65176485
    6518     return rc;
     6486    return hrc;
    65196487}
    65206488
     
    65426510    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    65436511
    6544     HRESULT rc = i_checkStateDependency(MutableStateDep);
    6545     if (FAILED(rc)) return rc;
     6512    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     6513    if (FAILED(hrc)) return hrc;
    65466514
    65476515    ComObjPtr<USBController> ctrl;
    6548     rc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
    6549     if (FAILED(rc)) return rc;
     6516    hrc = i_getUSBControllerByName(aName, ctrl, true /* aSetError */);
     6517    if (FAILED(hrc)) return hrc;
    65506518
    65516519    i_setModified(IsModified_USB);
     
    67916759HRESULT Machine::hotPlugCPU(ULONG aCpu)
    67926760{
    6793     HRESULT rc = S_OK;
    67946761    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    67956762
     
    68036770        return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
    68046771
    6805     rc = i_checkStateDependency(MutableOrRunningStateDep);
    6806     if (FAILED(rc)) return rc;
     6772    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     6773    if (FAILED(hrc)) return hrc;
    68076774
    68086775    alock.release();
    6809     rc = i_onCPUChange(aCpu, false);
     6776    hrc = i_onCPUChange(aCpu, false);
    68106777    alock.acquire();
    6811     if (FAILED(rc)) return rc;
     6778    if (FAILED(hrc)) return hrc;
    68126779
    68136780    i_setModified(IsModified_MachineData);
     
    68246791HRESULT Machine::hotUnplugCPU(ULONG aCpu)
    68256792{
    6826     HRESULT rc = S_OK;
    6827 
    68286793    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    68296794
     
    68436808        return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
    68446809
    6845     rc = i_checkStateDependency(MutableOrRunningStateDep);
    6846     if (FAILED(rc)) return rc;
     6810    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     6811    if (FAILED(hrc)) return hrc;
    68476812
    68486813    alock.release();
    6849     rc = i_onCPUChange(aCpu, true);
     6814    hrc = i_onCPUChange(aCpu, true);
    68506815    alock.acquire();
    6851     if (FAILED(rc)) return rc;
     6816    if (FAILED(hrc)) return hrc;
    68526817
    68536818    i_setModified(IsModified_MachineData);
     
    69026867    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    69036868
    6904     HRESULT rc = S_OK;
     6869    HRESULT hrc = S_OK;
    69056870    Utf8Str log = i_getLogFilename(aIdx);
    69066871
     
    69236888    {
    69246889        PCVBOXCRYPTOIF pCryptoIf = NULL;
    6925         rc = i_getVirtualBox()->i_retainCryptoIf(&pCryptoIf);
    6926         if (SUCCEEDED(rc))
     6890        hrc = i_getVirtualBox()->i_retainCryptoIf(&pCryptoIf);
     6891        if (SUCCEEDED(hrc))
    69276892        {
    69286893            alock.acquire();
     
    69666931            aData.resize(cbData);
    69676932        else
    6968             rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
    6969                               tr("Could not read log file '%s' (%Rrc)"),
    6970                               log.c_str(), vrc);
     6933            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not read log file '%s' (%Rrc)"), log.c_str(), vrc);
    69716934
    69726935        RTVfsIoStrmRelease(hVfsIosLog);
    69736936    }
    69746937    else
    6975         rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
    6976                           tr("Could not open log file '%s' (%Rrc)"),
    6977                           log.c_str(), vrc);
    6978 
    6979     if (FAILED(rc))
     6938        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open log file '%s' (%Rrc)"), log.c_str(), vrc);
     6939
     6940    if (FAILED(hrc))
    69806941        aData.resize(0);
    69816942
    6982     return rc;
     6943    return hrc;
    69836944}
    69846945
     
    69946955        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    69956956
    6996         HRESULT rc = i_checkStateDependency(MutableStateDep);
    6997         if (FAILED(rc)) return rc;
     6957        HRESULT hrc = i_checkStateDependency(MutableStateDep);
     6958        if (FAILED(hrc)) return hrc;
    69986959
    69996960        ChipsetType_T aChipset = ChipsetType_PIIX3;
     
    70447005    ComObjPtr<PCIDeviceAttachment> pAttach;
    70457006    bool fRemoved = false;
    7046     HRESULT rc;
     7007    HRESULT hrc;
    70477008
    70487009    // lock scope
     
    70507011        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    70517012
    7052         rc = i_checkStateDependency(MutableStateDep);
    7053         if (FAILED(rc)) return rc;
     7013        hrc = i_checkStateDependency(MutableStateDep);
     7014        if (FAILED(hrc)) return hrc;
    70547015
    70557016        for (HWData::PCIDeviceAssignmentList::const_iterator
     
    70787039        Assert(!pAttach.isNull());
    70797040        ComPtr<IEventSource> es;
    7080         rc = mParent->COMGETTER(EventSource)(es.asOutParam());
    7081         Assert(SUCCEEDED(rc));
     7041        hrc = mParent->COMGETTER(EventSource)(es.asOutParam());
     7042        Assert(SUCCEEDED(hrc));
    70827043        Bstr mid;
    7083         rc = this->COMGETTER(Id)(mid.asOutParam());
    7084         Assert(SUCCEEDED(rc));
     7044        hrc = this->COMGETTER(Id)(mid.asOutParam());
     7045        Assert(SUCCEEDED(hrc));
    70857046        ::FireHostPCIDevicePlugEvent(es, mid.raw(), false /* unplugged */, true /* success */, pAttach, NULL);
    70867047    }
     
    74317392    MachineCloneVM *pWorker = new MachineCloneVM(this, static_cast<Machine*>(pTarget), aMode, optList);
    74327393
    7433     HRESULT rc = pWorker->start(pProgress);
     7394    HRESULT hrc = pWorker->start(pProgress);
    74347395
    74357396    pP = static_cast<Progress *>(*pProgress);
    74367397    pP.queryInterfaceTo(aProgress.asOutParam());
    74377398
    7438     return rc;
     7399    return hrc;
    74397400
    74407401}
     
    74917452
    74927453    // This check should always fail.
    7493     HRESULT rc = i_checkStateDependency(MutableStateDep);
    7494     if (FAILED(rc)) return rc;
     7454    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     7455    if (FAILED(hrc)) return hrc;
    74957456
    74967457    AssertFailedReturn(E_NOTIMPL);
     
    75037464
    75047465    // This check should always fail.
    7505     HRESULT rc = i_checkStateDependency(MutableStateDep);
    7506     if (FAILED(rc)) return rc;
     7466    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     7467    if (FAILED(hrc)) return hrc;
    75077468
    75087469    AssertFailedReturn(E_NOTIMPL);
     
    75157476
    75167477    // This check should always fail.
    7517     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    7518     if (FAILED(rc)) return rc;
     7478    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     7479    if (FAILED(hrc)) return hrc;
    75197480
    75207481    AssertFailedReturn(E_NOTIMPL);
     
    78827843    {
    78837844        Utf8Str strHardeningLogFile = i_getHardeningLogFilename();
    7884         int vrc2;
    7885         /* ignore rc */ i_deleteFile(strHardeningLogFile, false /* fIgnoreFailures */, tr("hardening log file"), &vrc2);
     7845        int vrc2 = VERR_IPE_UNINITIALIZED_STATUS;
     7846        i_deleteFile(strHardeningLogFile, false /* fIgnoreFailures */, tr("hardening log file"), &vrc2); /* ignoring return code */
    78867847        if (vrc2 == VERR_PATH_NOT_FOUND || vrc2 == VERR_FILE_NOT_FOUND)
    78877848        {
     
    80508011        /* connect to VBoxSDS */
    80518012        ComPtr<IVirtualBoxSDS> pVBoxSDS;
    8052         HRESULT rc = pVBoxSDS.createLocalObject(CLSID_VirtualBoxSDS);
    8053         if (FAILED(rc))
    8054             return setError(rc, tr("Failed to start the machine '%s'. A connection to VBoxSDS cannot be established"),
     8013        HRESULT hrc = pVBoxSDS.createLocalObject(CLSID_VirtualBoxSDS);
     8014        if (FAILED(hrc))
     8015            return setError(hrc, tr("Failed to start the machine '%s'. A connection to VBoxSDS cannot be established"),
    80558016                            strMachineName.c_str());
    80568017
     
    80598020           elevates the impersonation level up to RPC_C_IMP_LEVEL_IMPERSONATE allowing the VBoxSDS
    80608021           service to access the files. */
    8061         rc = CoSetProxyBlanket(pVBoxSDS,
    8062                                RPC_C_AUTHN_DEFAULT,
    8063                                RPC_C_AUTHZ_DEFAULT,
    8064                                COLE_DEFAULT_PRINCIPAL,
    8065                                RPC_C_AUTHN_LEVEL_DEFAULT,
    8066                                RPC_C_IMP_LEVEL_IMPERSONATE,
    8067                                NULL,
    8068                                EOAC_DEFAULT);
    8069         if (FAILED(rc))
    8070             return setError(rc, tr("Failed to start the machine '%s'. CoSetProxyBlanket failed"), strMachineName.c_str());
     8022        hrc = CoSetProxyBlanket(pVBoxSDS,
     8023                                RPC_C_AUTHN_DEFAULT,
     8024                                RPC_C_AUTHZ_DEFAULT,
     8025                                COLE_DEFAULT_PRINCIPAL,
     8026                                RPC_C_AUTHN_LEVEL_DEFAULT,
     8027                                RPC_C_IMP_LEVEL_IMPERSONATE,
     8028                                NULL,
     8029                                EOAC_DEFAULT);
     8030        if (FAILED(hrc))
     8031            return setError(hrc, tr("Failed to start the machine '%s'. CoSetProxyBlanket failed"), strMachineName.c_str());
    80718032
    80728033        size_t const            cEnvVars = aEnvironmentChanges.size();
     
    80768037
    80778038        ULONG uPid = 0;
    8078         rc = pVBoxSDS->LaunchVMProcess(Bstr(idStr).raw(), Bstr(strMachineName).raw(), Bstr(strFrontend).raw(),
    8079                                        ComSafeArrayAsInParam(aBstrEnvironmentChanges), Bstr(strSupHardeningLogArg).raw(),
    8080                                        idCallerSession, &uPid);
    8081         if (FAILED(rc))
    8082             return setError(rc, tr("Failed to start the machine '%s'. Process creation failed"), strMachineName.c_str());
     8039        hrc = pVBoxSDS->LaunchVMProcess(Bstr(idStr).raw(), Bstr(strMachineName).raw(), Bstr(strFrontend).raw(),
     8040                                        ComSafeArrayAsInParam(aBstrEnvironmentChanges), Bstr(strSupHardeningLogArg).raw(),
     8041                                        idCallerSession, &uPid);
     8042        if (FAILED(hrc))
     8043            return setError(hrc, tr("Failed to start the machine '%s'. Process creation failed"), strMachineName.c_str());
    80838044        pid = (RTPROCESS)uPid;
    80848045    }
     
    81108071        LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
    81118072#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
    8112         HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
     8073        HRESULT hrc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
    81138074#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
    8114         HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, NULL);
     8075        HRESULT hrc = aControl->AssignMachine(NULL, LockType_Write, NULL);
    81158076#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
    8116         LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
    8117 
    8118         if (FAILED(rc))
     8077        LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", hrc));
     8078
     8079        if (FAILED(hrc))
    81198080        {
    81208081            /* restore the session state */
     
    81248085            /* The failure may occur w/o any error info (from RPC), so provide one */
    81258086            return setError(VBOX_E_VM_ERROR,
    8126                             tr("Failed to assign the machine to the session (%Rhrc)"), rc);
     8087                            tr("Failed to assign the machine to the session (%Rhrc)"), hrc);
    81278088        }
    81288089
     
    82538214    }
    82548215
    8255     HRESULT rc = S_OK;
    8256 
    82578216    /* PID not yet initialized, skip check. */
    82588217    if (mData->mSession.mPID == NIL_RTPROCESS)
    82598218        return false;
    82608219
     8220    HRESULT hrc = S_OK;
    82618221    RTPROCSTATUS status;
    82628222    int vrc = RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK, &status);
    8263 
    82648223    if (vrc != VERR_PROCESS_RUNNING)
    82658224    {
     
    82788237
    82798238        if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
    8280             rc = setError(E_FAIL,
    8281                           tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d (%#x)%s"),
    8282                           i_getName().c_str(), status.iStatus, status.iStatus, strExtraInfo.c_str());
     8239            hrc = setError(E_FAIL,
     8240                           tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d (%#x)%s"),
     8241                           i_getName().c_str(), status.iStatus, status.iStatus, strExtraInfo.c_str());
    82838242        else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
    8284             rc = setError(E_FAIL,
    8285                           tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d%s"),
    8286                           i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
     8243            hrc = setError(E_FAIL,
     8244                           tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d%s"),
     8245                           i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
    82878246        else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
    8288             rc = setError(E_FAIL,
    8289                           tr("The virtual machine '%s' has terminated abnormally (iStatus=%#x)%s"),
    8290                           i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
     8247            hrc = setError(E_FAIL,
     8248                           tr("The virtual machine '%s' has terminated abnormally (iStatus=%#x)%s"),
     8249                           i_getName().c_str(), status.iStatus, strExtraInfo.c_str());
    82918250        else
    8292             rc = setErrorBoth(E_FAIL, vrc,
    8293                               tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
    8294                               i_getName().c_str(), vrc, strExtraInfo.c_str());
    8295     }
    8296 
    8297     if (FAILED(rc))
     8251            hrc = setErrorBoth(E_FAIL, vrc,
     8252                               tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)%s"),
     8253                               i_getName().c_str(), vrc, strExtraInfo.c_str());
     8254    }
     8255
     8256    if (FAILED(hrc))
    82988257    {
    82998258        /* Close the remote session, remove the remote control from the list
     
    83148273        if (!mData->mSession.mProgress.isNull())
    83158274        {
    8316             mData->mSession.mProgress->notifyComplete(rc);
     8275            mData->mSession.mProgress->notifyComplete(hrc);
    83178276            mData->mSession.mProgress.setNull();
    83188277        }
     
    83608319                        mData->mUuid.toString().c_str());
    83618320
    8362     HRESULT rc = S_OK;
     8321    HRESULT hrc = S_OK;
    83638322
    83648323    // Ensure the settings are saved. If we are going to be registered and
     
    83688327       )
    83698328    {
    8370         rc = i_saveSettings(NULL, alock);
     8329        hrc = i_saveSettings(NULL, alock);
    83718330                // no need to check whether VirtualBox.xml needs saving too since
    83728331                // we can't have a machine XML file rename pending
    8373         if (FAILED(rc)) return rc;
     8332        if (FAILED(hrc)) return hrc;
    83748333    }
    83758334
    83768335    /* more config checking goes here */
    83778336
    8378     if (SUCCEEDED(rc))
     8337    if (SUCCEEDED(hrc))
    83798338    {
    83808339        /* we may have had implicit modifications we want to fix on success */
     
    83898348    }
    83908349
    8391     return rc;
     8350    return hrc;
    83928351}
    83938352
     
    84208379    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    84218380
    8422     HRESULT rc = i_checkStateDependency(aDepType);
    8423     if (FAILED(rc)) return rc;
     8381    HRESULT hrc = i_checkStateDependency(aDepType);
     8382    if (FAILED(hrc)) return hrc;
    84248383
    84258384    {
     
    88378796            if (pMedium.isNull())
    88388797                continue;
    8839             HRESULT rc = pMedium->i_removeBackReference(mData->mUuid, i_getSnapshotId());
    8840             AssertComRC(rc);
     8798            HRESULT hrc = pMedium->i_removeBackReference(mData->mUuid, i_getSnapshotId());
     8799            AssertComRC(hrc);
    88418800        }
    88428801    }
     
    89818940                                    bool aSetError /* = false */)
    89828941{
    8983     HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
     8942    HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
    89848943    for (HWData::SharedFolderList::const_iterator
    89858944         it = mHWData->mSharedFolders.begin();
     
    89928951        {
    89938952            aSharedFolder = pSF;
    8994             rc = S_OK;
     8953            hrc = S_OK;
    89958954            break;
    89968955        }
    89978956    }
    89988957
    8999     if (aSetError && FAILED(rc))
    9000         setError(rc, tr("Could not find a shared folder named '%s'"), aName.c_str());
    9001 
    9002     return rc;
     8958    if (aSetError && FAILED(hrc))
     8959        setError(hrc, tr("Could not find a shared folder named '%s'"), aName.c_str());
     8960
     8961    return hrc;
    90038962}
    90048963
     
    90639022
    90649023    // snapshot folder needs special processing so set it again
    9065     HRESULT rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
    9066     if (FAILED(rc)) return rc;
     9024    HRESULT hrc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
     9025    if (FAILED(hrc)) return hrc;
    90679026
    90689027    /* Copy the extra data items (config may or may not be the same as
     
    90909049        Utf8Str strMachineFolder = i_getSettingsFileFull();
    90919050        strMachineFolder.stripFilename();
    9092         rc = mParent->initMedia(i_getId(),       // media registry ID == machine UUID
    9093                                 config.mediaRegistry,
    9094                                 strMachineFolder);
    9095         if (FAILED(rc)) return rc;
     9051        hrc = mParent->initMedia(i_getId(),       // media registry ID == machine UUID
     9052                                 config.mediaRegistry,
     9053                                 strMachineFolder);
     9054        if (FAILED(hrc)) return hrc;
    90969055    }
    90979056
     
    91049063        const settings::Snapshot &snap = config.llFirstSnapshot.front();
    91059064
    9106         rc = i_loadSnapshot(snap,
    9107                             config.uuidCurrentSnapshot);
    9108         if (FAILED(rc)) return rc;
     9065        hrc = i_loadSnapshot(snap, config.uuidCurrentSnapshot);
     9066        if (FAILED(hrc)) return hrc;
    91099067    }
    91109068
    91119069    // hardware data
    9112     rc = i_loadHardware(puuidRegistry, NULL, config.hardwareMachine, &config.debugging, &config.autostart,
    9113                         config.recordingSettings);
    9114     if (FAILED(rc)) return rc;
     9070    hrc = i_loadHardware(puuidRegistry, NULL, config.hardwareMachine, &config.debugging, &config.autostart,
     9071                         config.recordingSettings);
     9072    if (FAILED(hrc)) return hrc;
    91159073
    91169074    /*
     
    91589116    AssertReturn(!i_isSessionMachine(), E_FAIL);
    91599117
    9160     HRESULT rc = S_OK;
     9118    HRESULT hrc = S_OK;
    91619119
    91629120    std::list<const settings::Snapshot *> llSettingsTodo;
     
    91899147        ComObjPtr<SnapshotMachine> pSnapshotMachine;
    91909148        pSnapshotMachine.createObject();
    9191         rc = pSnapshotMachine->initFromSettings(this,
    9192                                                 current->hardware,
    9193                                                 &current->debugging,
    9194                                                 &current->autostart,
    9195                                                 current->recordingSettings,
    9196                                                 current->uuid.ref(),
    9197                                                 strStateFile);
    9198         if (FAILED(rc)) break;
     9149        hrc = pSnapshotMachine->initFromSettings(this,
     9150                                                 current->hardware,
     9151                                                 &current->debugging,
     9152                                                 &current->autostart,
     9153                                                 current->recordingSettings,
     9154                                                 current->uuid.ref(),
     9155                                                 strStateFile);
     9156        if (FAILED(hrc)) break;
    91999157
    92009158        /* create a snapshot object */
     
    92029160        pSnapshot.createObject();
    92039161        /* initialize the snapshot */
    9204         rc = pSnapshot->init(mParent, // VirtualBox object
    9205                              current->uuid,
    9206                              current->strName,
    9207                              current->strDescription,
    9208                              current->timestamp,
    9209                              pSnapshotMachine,
    9210                              pParent);
    9211         if (FAILED(rc)) break;
     9162        hrc = pSnapshot->init(mParent, // VirtualBox object
     9163                              current->uuid,
     9164                              current->strName,
     9165                              current->strDescription,
     9166                              current->timestamp,
     9167                              pSnapshotMachine,
     9168                              pParent);
     9169        if (FAILED(hrc)) break;
    92129170
    92139171        /* memorize the first snapshot if necessary */
     
    92349192    }
    92359193
    9236     return rc;
     9194    return hrc;
    92379195}
    92389196
     
    92569214    AssertReturn(!i_isSessionMachine(), E_FAIL);
    92579215
    9258     HRESULT rc = S_OK;
     9216    HRESULT hrc = S_OK;
    92599217
    92609218    try
     
    93479305
    93489306        /* GraphicsAdapter */
    9349         rc = mGraphicsAdapter->i_loadSettings(data.graphicsAdapter);
    9350         if (FAILED(rc)) return rc;
     9307        hrc = mGraphicsAdapter->i_loadSettings(data.graphicsAdapter);
     9308        if (FAILED(hrc)) return hrc;
    93519309
    93529310        /* VRDEServer */
    9353         rc = mVRDEServer->i_loadSettings(data.vrdeSettings);
    9354         if (FAILED(rc)) return rc;
     9311        hrc = mVRDEServer->i_loadSettings(data.vrdeSettings);
     9312        if (FAILED(hrc)) return hrc;
    93559313
    93569314        /* BIOS */
    9357         rc = mBIOSSettings->i_loadSettings(data.biosSettings);
    9358         if (FAILED(rc)) return rc;
     9315        hrc = mBIOSSettings->i_loadSettings(data.biosSettings);
     9316        if (FAILED(hrc)) return hrc;
    93599317
    93609318        /* Recording */
    9361         rc = mRecordingSettings->i_loadSettings(recording);
    9362         if (FAILED(rc)) return rc;
     9319        hrc = mRecordingSettings->i_loadSettings(recording);
     9320        if (FAILED(hrc)) return hrc;
    93639321
    93649322        /* Trusted Platform Module */
    9365         rc = mTrustedPlatformModule->i_loadSettings(data.tpmSettings);
    9366         if (FAILED(rc)) return rc;
    9367 
    9368         rc = mNvramStore->i_loadSettings(data.nvramSettings);
    9369         if (FAILED(rc)) return rc;
     9323        hrc = mTrustedPlatformModule->i_loadSettings(data.tpmSettings);
     9324        if (FAILED(hrc)) return hrc;
     9325
     9326        hrc = mNvramStore->i_loadSettings(data.nvramSettings);
     9327        if (FAILED(hrc)) return hrc;
    93709328
    93719329        // Bandwidth control (must come before network adapters)
    9372         rc = mBandwidthControl->i_loadSettings(data.ioSettings);
    9373         if (FAILED(rc)) return rc;
     9330        hrc = mBandwidthControl->i_loadSettings(data.ioSettings);
     9331        if (FAILED(hrc)) return hrc;
    93749332
    93759333        /* USB controllers */
     
    93889346
    93899347        /* USB device filters */
    9390         rc = mUSBDeviceFilters->i_loadSettings(data.usbSettings);
    9391         if (FAILED(rc)) return rc;
     9348        hrc = mUSBDeviceFilters->i_loadSettings(data.usbSettings);
     9349        if (FAILED(hrc)) return hrc;
    93929350
    93939351        // network adapters (establish array size first and apply defaults, to
     
    94189376            /* slot uniqueness is guaranteed by XML Schema */
    94199377            AssertBreak(nic.ulSlot < mNetworkAdapters.size());
    9420             rc = mNetworkAdapters[nic.ulSlot]->i_loadSettings(mBandwidthControl, nic);
    9421             if (FAILED(rc)) return rc;
     9378            hrc = mNetworkAdapters[nic.ulSlot]->i_loadSettings(mBandwidthControl, nic);
     9379            if (FAILED(hrc)) return hrc;
    94229380        }
    94239381
     
    94349392
    94359393            AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
    9436             rc = mSerialPorts[s.ulSlot]->i_loadSettings(s);
    9437             if (FAILED(rc)) return rc;
     9394            hrc = mSerialPorts[s.ulSlot]->i_loadSettings(s);
     9395            if (FAILED(hrc)) return hrc;
    94389396        }
    94399397
     
    94509408
    94519409            AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
    9452             rc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
    9453             if (FAILED(rc)) return rc;
     9410            hrc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
     9411            if (FAILED(hrc)) return hrc;
    94549412        }
    94559413
    94569414        /* Audio settings */
    9457         rc = mAudioSettings->i_loadSettings(data.audioAdapter);
    9458         if (FAILED(rc)) return rc;
     9415        hrc = mAudioSettings->i_loadSettings(data.audioAdapter);
     9416        if (FAILED(hrc)) return hrc;
    94599417
    94609418        /* storage controllers */
    9461         rc = i_loadStorageControllers(data.storage,
    9462                                       puuidRegistry,
    9463                                       puuidSnapshot);
    9464         if (FAILED(rc)) return rc;
     9419        hrc = i_loadStorageControllers(data.storage, puuidRegistry, puuidSnapshot);
     9420        if (FAILED(hrc)) return hrc;
    94659421
    94669422        /* Shared folders */
     
    94749430            ComObjPtr<SharedFolder> sharedFolder;
    94759431            /* Check for double entries. Not allowed! */
    9476             rc = i_findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
    9477             if (SUCCEEDED(rc))
     9432            hrc = i_findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
     9433            if (SUCCEEDED(hrc))
    94789434                return setError(VBOX_E_OBJECT_IN_USE,
    94799435                                tr("Shared folder named '%s' already exists"),
     
    94839439             * reported when the machine starts. */
    94849440            sharedFolder.createObject();
    9485             rc = sharedFolder->init(i_getMachine(),
    9486                                     sf.strName,
    9487                                     sf.strHostPath,
    9488                                     RT_BOOL(sf.fWritable),
    9489                                     RT_BOOL(sf.fAutoMount),
    9490                                     sf.strAutoMountPoint,
    9491                                     false /* fFailOnError */);
    9492             if (FAILED(rc)) return rc;
     9441            hrc = sharedFolder->init(i_getMachine(),
     9442                                     sf.strName,
     9443                                     sf.strHostPath,
     9444                                     RT_BOOL(sf.fWritable),
     9445                                     RT_BOOL(sf.fAutoMount),
     9446                                     sf.strAutoMountPoint,
     9447                                     false /* fFailOnError */);
     9448            if (FAILED(hrc)) return hrc;
    94939449            mHWData->mSharedFolders.push_back(sharedFolder);
    94949450        }
     
    95639519#endif /* VBOX_WITH_GUEST_PROPS defined */
    95649520
    9565         rc = i_loadDebugging(pDbg);
    9566         if (FAILED(rc))
    9567             return rc;
     9521        hrc = i_loadDebugging(pDbg);
     9522        if (FAILED(hrc))
     9523            return hrc;
    95689524
    95699525        mHWData->mAutostart = *pAutostart;
     
    95779533    }
    95789534
    9579     AssertComRC(rc);
    9580     return rc;
     9535    AssertComRC(hrc);
     9536    return hrc;
    95819537}
    95829538
     
    95929548    /* no more processing currently required, this will probably change. */
    95939549
    9594     HRESULT rc = mGuestDebugControl->i_loadSettings(*pDbg);
    9595     if (FAILED(rc)) return rc;
     9550    HRESULT hrc = mGuestDebugControl->i_loadSettings(*pDbg);
     9551    if (FAILED(hrc)) return hrc;
    95969552
    95979553    return S_OK;
     
    96139569    AssertReturn(!i_isSessionMachine(), E_FAIL);
    96149570
    9615     HRESULT rc = S_OK;
     9571    HRESULT hrc = S_OK;
    96169572
    96179573    for (settings::StorageControllersList::const_iterator
     
    96249580        ComObjPtr<StorageController> pCtl;
    96259581        /* Try to find one with the name first. */
    9626         rc = i_getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
    9627         if (SUCCEEDED(rc))
     9582        hrc = i_getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
     9583        if (SUCCEEDED(hrc))
    96289584            return setError(VBOX_E_OBJECT_IN_USE,
    96299585                            tr("Storage controller named '%s' already exists"),
     
    96319587
    96329588        pCtl.createObject();
    9633         rc = pCtl->init(this,
    9634                         ctlData.strName,
    9635                         ctlData.storageBus,
    9636                         ctlData.ulInstance,
    9637                         ctlData.fBootable);
    9638         if (FAILED(rc)) return rc;
     9589        hrc = pCtl->init(this, ctlData.strName, ctlData.storageBus, ctlData.ulInstance, ctlData.fBootable);
     9590        if (FAILED(hrc)) return hrc;
    96399591
    96409592        mStorageControllers->push_back(pCtl);
    96419593
    9642         rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
    9643         if (FAILED(rc)) return rc;
    9644 
    9645         rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
    9646         if (FAILED(rc)) return rc;
    9647 
    9648         rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
    9649         if (FAILED(rc)) return rc;
     9594        hrc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
     9595        if (FAILED(hrc)) return hrc;
     9596
     9597        hrc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
     9598        if (FAILED(hrc)) return hrc;
     9599
     9600        hrc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
     9601        if (FAILED(hrc)) return hrc;
    96509602
    96519603        /* Load the attached devices now. */
    9652         rc = i_loadStorageDevices(pCtl,
    9653                                   ctlData,
    9654                                   puuidRegistry,
    9655                                   puuidSnapshot);
    9656         if (FAILED(rc)) return rc;
     9604        hrc = i_loadStorageDevices(pCtl, ctlData, puuidRegistry, puuidSnapshot);
     9605        if (FAILED(hrc)) return hrc;
    96579606    }
    96589607
     
    96759624                                      const Guid *puuidSnapshot)
    96769625{
    9677     HRESULT rc = S_OK;
     9626    HRESULT hrc = S_OK;
    96789627
    96799628    /* paranoia: detect duplicate attachments */
     
    97209669            case DeviceType_DVD:
    97219670                if (dev.strHostDriveSrc.isNotEmpty())
    9722                     rc = mParent->i_host()->i_findHostDriveByName(dev.deviceType, dev.strHostDriveSrc,
     9671                    hrc = mParent->i_host()->i_findHostDriveByName(dev.deviceType, dev.strHostDriveSrc,
    97239672                                                                  false /* fRefresh */, medium);
    97249673                else
    9725                     rc = mParent->i_findRemoveableMedium(dev.deviceType,
    9726                                                          dev.uuid,
    9727                                                          false /* fRefresh */,
    9728                                                          false /* aSetError */,
    9729                                                          medium);
    9730                 if (rc == VBOX_E_OBJECT_NOT_FOUND)
     9674                    hrc = mParent->i_findRemoveableMedium(dev.deviceType,
     9675                                                          dev.uuid,
     9676                                                          false /* fRefresh */,
     9677                                                          false /* aSetError */,
     9678                                                          medium);
     9679                if (hrc == VBOX_E_OBJECT_NOT_FOUND)
    97319680                    // This is not an error. The host drive or UUID might have vanished, so just go
    97329681                    // ahead without this removeable medium attachment
    9733                     rc = S_OK;
     9682                    hrc = S_OK;
    97349683            break;
    97359684
     
    97379686            {
    97389687                /* find a hard disk by UUID */
    9739                 rc = mParent->i_findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
    9740                 if (FAILED(rc))
     9688                hrc = mParent->i_findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
     9689                if (FAILED(hrc))
    97419690                {
    97429691                    if (i_isSnapshotMachine())
     
    97509699                                        info.getText().raw());
    97519700                    }
    9752                     else
    9753                         return rc;
     9701                    return hrc;
    97549702                }
    97559703
     
    98279775        }
    98289776
    9829         if (FAILED(rc))
     9777        if (FAILED(hrc))
    98309778            break;
    98319779
     
    98359783        if (!dev.strBwGroup.isEmpty())
    98369784        {
    9837             rc = mBandwidthControl->i_getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
    9838             if (FAILED(rc))
     9785            hrc = mBandwidthControl->i_getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
     9786            if (FAILED(hrc))
    98399787                return setError(E_FAIL,
    98409788                                tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
     
    98499797        ComObjPtr<MediumAttachment> pAttachment;
    98509798        pAttachment.createObject();
    9851         rc = pAttachment->init(this,
    9852                                medium,
    9853                                controllerName,
    9854                                dev.lPort,
    9855                                dev.lDevice,
    9856                                dev.deviceType,
    9857                                false,
    9858                                dev.fPassThrough,
    9859                                dev.fTempEject,
    9860                                dev.fNonRotational,
    9861                                dev.fDiscard,
    9862                                dev.fHotPluggable,
    9863                                pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->i_getName());
    9864         if (FAILED(rc)) break;
     9799        hrc = pAttachment->init(this,
     9800                                medium,
     9801                                controllerName,
     9802                                dev.lPort,
     9803                                dev.lDevice,
     9804                                dev.deviceType,
     9805                                false,
     9806                                dev.fPassThrough,
     9807                                dev.fTempEject,
     9808                                dev.fNonRotational,
     9809                                dev.fDiscard,
     9810                                dev.fHotPluggable,
     9811                                pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->i_getName());
     9812        if (FAILED(hrc)) break;
    98659813
    98669814        /* associate the medium with this machine and snapshot */
     
    98729820
    98739821            if (i_isSnapshotMachine())
    9874                 rc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
     9822                hrc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
    98759823            else
    9876                 rc = medium->i_addBackReference(mData->mUuid);
     9824                hrc = medium->i_addBackReference(mData->mUuid);
    98779825            /* If the medium->addBackReference fails it sets an appropriate
    98789826             * error message, so no need to do any guesswork here. */
     
    98839831        }
    98849832
    9885         if (FAILED(rc))
     9833        if (FAILED(hrc))
    98869834            break;
    98879835
     
    98939841    }
    98949842
    9895     return rc;
     9843    return hrc;
    98969844}
    98979845
     
    1010010048    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
    1010110049
    10102     HRESULT rc = S_OK;
     10050    HRESULT hrc = S_OK;
    1010310051
    1010410052    bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
     
    1017410122                    if (RT_FAILURE(vrc))
    1017510123                    {
    10176                         rc = setErrorBoth(E_FAIL, vrc,
    10177                                           tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
    10178                                           configDir.c_str(),
    10179                                           newConfigDir.c_str(),
    10180                                           vrc);
     10124                        hrc = setErrorBoth(E_FAIL, vrc,
     10125                                           tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
     10126                                           configDir.c_str(),
     10127                                           newConfigDir.c_str(),
     10128                                           vrc);
    1018110129                        break;
    1018210130                    }
     
    1021210160                    if (RT_FAILURE(vrc))
    1021310161                    {
    10214                         rc = setErrorBoth(E_FAIL, vrc,
    10215                                           tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
    10216                                           configFile.c_str(),
    10217                                           newConfigFile.c_str(),
    10218                                           vrc);
     10162                        hrc = setErrorBoth(E_FAIL, vrc,
     10163                                           tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
     10164                                           configFile.c_str(),
     10165                                           newConfigFile.c_str(),
     10166                                           vrc);
    1021910167                        break;
    1022010168                    }
     
    1027810226        while (0);
    1027910227
    10280         if (FAILED(rc))
     10228        if (FAILED(hrc))
    1028110229        {
    1028210230            /* silently try to rename everything back */
     
    1029210240        }
    1029310241
    10294         if (FAILED(rc)) return rc;
     10242        if (FAILED(hrc)) return hrc;
    1029510243    }
    1029610244
     
    1033010278        *pfSettingsFileIsNew = fSettingsFileIsNew;
    1033110279
    10332     return rc;
     10280    return hrc;
    1033310281}
    1033410282
     
    1037810326                        tr("The machine is not accessible, so cannot save settings"));
    1037910327
    10380     HRESULT rc = S_OK;
     10328    HRESULT hrc = S_OK;
    1038110329    PCVBOXCRYPTOIF pCryptoIf = NULL;
    1038210330    const char  *pszPassword = NULL;
     
    1038810336        /* VM is going to be encrypted. */
    1038910337        alock.release(); /** @todo Revise the locking. */
    10390         rc = mParent->i_retainCryptoIf(&pCryptoIf);
     10338        hrc = mParent->i_retainCryptoIf(&pCryptoIf);
    1039110339        alock.acquire();
    10392         if (FAILED(rc)) return rc; /* Error is set. */
     10340        if (FAILED(hrc)) return hrc; /* Error is set. */
    1039310341
    1039410342        int vrc = mData->mpKeyStore->retainSecretKey(mData->mstrKeyId, &pKey);
     
    1041310361     * settings directory and file if the machine name was changed and about
    1041410362     * creating a new settings file if this is a new machine. */
    10415     rc = i_prepareSaveSettings(pfNeedsGlobalSaveSettings,
    10416                                &fSettingsFileIsNew);
    10417     if (FAILED(rc))
     10363    hrc = i_prepareSaveSettings(pfNeedsGlobalSaveSettings, &fSettingsFileIsNew);
     10364    if (FAILED(hrc))
    1041810365    {
    1041910366#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
     
    1042710374            mData->mpKeyStore->releaseSecretKey(mData->mstrKeyId);
    1042810375#endif
    10429         return rc;
     10376        return hrc;
    1043010377    }
    1043110378
     
    1049710444    {
    1049810445        // we assume that error info is set by the thrower
    10499         rc = err;
     10446        hrc = err;
    1050010447
    1050110448        // delete any newly created settings file
     
    1050910456    catch (...)
    1051010457    {
    10511         rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     10458        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    1051210459    }
    1051310460
     
    1053410481    }
    1053510482
    10536     LogFlowThisFunc(("rc=%08X\n", rc));
     10483    LogFlowThisFunc(("hrc=%08X\n", hrc));
    1053710484    LogFlowThisFuncLeave();
    10538     return rc;
     10485    return hrc;
    1053910486}
    1054010487
     
    1064410591    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
    1064510592
    10646     HRESULT rc = S_OK;
     10593    HRESULT hrc = S_OK;
    1064710594
    1064810595    try
     
    1065710604            // get reference to the snapshot on the list and work on that
    1065810605            // element straight in the list to avoid excessive copying later
    10659             rc = mData->mFirstSnapshot->i_saveSnapshot(config.llFirstSnapshot.back());
    10660             if (FAILED(rc)) throw rc;
     10606            hrc = mData->mFirstSnapshot->i_saveSnapshot(config.llFirstSnapshot.back());
     10607            if (FAILED(hrc)) throw hrc;
    1066110608        }
    1066210609
     
    1066810615    {
    1066910616        /* we assume that error info is set by the thrower */
    10670         rc = err;
     10617        hrc = err;
    1067110618    }
    1067210619    catch (...)
    1067310620    {
    10674         rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    10675     }
    10676 
    10677     return rc;
     10621        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     10622    }
     10623
     10624    return hrc;
    1067810625}
    1067910626
     
    1069210639                                settings::Autostart *pAutostart, settings::RecordingSettings &recording)
    1069310640{
    10694     HRESULT rc = S_OK;
     10641    HRESULT hrc = S_OK;
    1069510642
    1069610643    try
     
    1078710734
    1078810735        /* VRDEServer settings (optional) */
    10789         rc = mVRDEServer->i_saveSettings(data.vrdeSettings);
    10790         if (FAILED(rc)) throw rc;
     10736        hrc = mVRDEServer->i_saveSettings(data.vrdeSettings);
     10737        if (FAILED(hrc)) throw hrc;
    1079110738
    1079210739        /* BIOS settings (required) */
    10793         rc = mBIOSSettings->i_saveSettings(data.biosSettings);
    10794         if (FAILED(rc)) throw rc;
     10740        hrc = mBIOSSettings->i_saveSettings(data.biosSettings);
     10741        if (FAILED(hrc)) throw hrc;
    1079510742
    1079610743        /* Recording settings. */
    10797         rc = mRecordingSettings->i_saveSettings(recording);
    10798         if (FAILED(rc)) throw rc;
     10744        hrc = mRecordingSettings->i_saveSettings(recording);
     10745        if (FAILED(hrc)) throw hrc;
    1079910746
    1080010747        /* Trusted Platform Module settings (required) */
    10801         rc = mTrustedPlatformModule->i_saveSettings(data.tpmSettings);
    10802         if (FAILED(rc)) throw rc;
     10748        hrc = mTrustedPlatformModule->i_saveSettings(data.tpmSettings);
     10749        if (FAILED(hrc)) throw hrc;
    1080310750
    1080410751        /* NVRAM settings (required) */
    10805         rc = mNvramStore->i_saveSettings(data.nvramSettings);
    10806         if (FAILED(rc)) throw rc;
     10752        hrc = mNvramStore->i_saveSettings(data.nvramSettings);
     10753        if (FAILED(hrc)) throw hrc;
    1080710754
    1080810755        /* GraphicsAdapter settings (required) */
    10809         rc = mGraphicsAdapter->i_saveSettings(data.graphicsAdapter);
    10810         if (FAILED(rc)) throw rc;
     10756        hrc = mGraphicsAdapter->i_saveSettings(data.graphicsAdapter);
     10757        if (FAILED(hrc)) throw hrc;
    1081110758
    1081210759        /* USB Controller (required) */
     
    1082710774
    1082810775        /* USB device filters (required) */
    10829         rc = mUSBDeviceFilters->i_saveSettings(data.usbSettings);
    10830         if (FAILED(rc)) throw rc;
     10776        hrc = mUSBDeviceFilters->i_saveSettings(data.usbSettings);
     10777        if (FAILED(hrc)) throw hrc;
    1083110778
    1083210779        /* Network adapters (required) */
     
    1084610793                    continue;
    1084710794
    10848                 rc = mNetworkAdapters[slot]->i_saveSettings(nic);
    10849                 if (FAILED(rc)) throw rc;
     10795                hrc = mNetworkAdapters[slot]->i_saveSettings(nic);
     10796                if (FAILED(hrc)) throw hrc;
    1085010797
    1085110798                data.llNetworkAdapters.push_back(nic);
     
    1086210809            settings::SerialPort s;
    1086310810            s.ulSlot = slot;
    10864             rc = mSerialPorts[slot]->i_saveSettings(s);
    10865             if (FAILED(rc)) return rc;
     10811            hrc = mSerialPorts[slot]->i_saveSettings(s);
     10812            if (FAILED(hrc)) return hrc;
    1086610813
    1086710814            data.llSerialPorts.push_back(s);
     
    1087710824            settings::ParallelPort p;
    1087810825            p.ulSlot = slot;
    10879             rc = mParallelPorts[slot]->i_saveSettings(p);
    10880             if (FAILED(rc)) return rc;
     10826            hrc = mParallelPorts[slot]->i_saveSettings(p);
     10827            if (FAILED(hrc)) return hrc;
    1088110828
    1088210829            data.llParallelPorts.push_back(p);
     
    1088410831
    1088510832        /* Audio settings */
    10886         rc = mAudioSettings->i_saveSettings(data.audioAdapter);
    10887         if (FAILED(rc)) return rc;
    10888 
    10889         rc = i_saveStorageControllers(data.storage);
    10890         if (FAILED(rc)) return rc;
     10833        hrc = mAudioSettings->i_saveSettings(data.audioAdapter);
     10834        if (FAILED(hrc)) return hrc;
     10835
     10836        hrc = i_saveStorageControllers(data.storage);
     10837        if (FAILED(hrc)) return hrc;
    1089110838
    1089210839        /* Shared folders */
     
    1092510872
    1092610873        /* BandwidthControl (required) */
    10927         rc = mBandwidthControl->i_saveSettings(data.ioSettings);
    10928         if (FAILED(rc)) throw rc;
     10874        hrc = mBandwidthControl->i_saveSettings(data.ioSettings);
     10875        if (FAILED(hrc)) throw hrc;
    1092910876
    1093010877        /* Host PCI devices */
     
    1093810885            settings::HostPCIDeviceAttachment hpda;
    1093910886
    10940             rc = pda->i_saveSettings(hpda);
    10941             if (FAILED(rc)) throw rc;
     10887            hrc = pda->i_saveSettings(hpda);
     10888            if (FAILED(hrc)) throw hrc;
    1094210889
    1094310890            data.pciAttachments.push_back(hpda);
     
    1097810925#endif /* VBOX_WITH_GUEST_PROPS defined */
    1097910926
    10980         rc = mGuestDebugControl->i_saveSettings(mHWData->mDebugging);
    10981         if (FAILED(rc)) throw rc;
     10927        hrc = mGuestDebugControl->i_saveSettings(mHWData->mDebugging);
     10928        if (FAILED(hrc)) throw hrc;
    1098210929
    1098310930        *pDbg = mHWData->mDebugging; /// @todo r=aeichner: Move this to guest debug control. */
     
    1099110938    }
    1099210939
    10993     AssertComRC(rc);
    10994     return rc;
     10940    AssertComRC(hrc);
     10941    return hrc;
    1099510942}
    1099610943
     
    1100910956         ++it)
    1101010957    {
    11011         HRESULT rc;
    1101210958        ComObjPtr<StorageController> pCtl = *it;
    1101310959
     
    1102110967        /* Save the port count. */
    1102210968        ULONG portCount;
    11023         rc = pCtl->COMGETTER(PortCount)(&portCount);
    11024         ComAssertComRCRet(rc, rc);
     10969        HRESULT hrc = pCtl->COMGETTER(PortCount)(&portCount);
     10970        ComAssertComRCRet(hrc, hrc);
    1102510971        ctl.ulPortCount = portCount;
    1102610972
    1102710973        /* Save fUseHostIOCache */
    1102810974        BOOL fUseHostIOCache;
    11029         rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
    11030         ComAssertComRCRet(rc, rc);
     10975        hrc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
     10976        ComAssertComRCRet(hrc, hrc);
    1103110977        ctl.fUseHostIOCache = !!fUseHostIOCache;
    1103210978
    1103310979        /* save the devices now. */
    11034         rc = i_saveStorageDevices(pCtl, ctl);
    11035         ComAssertComRCRet(rc, rc);
     10980        hrc = i_saveStorageDevices(pCtl, ctl);
     10981        ComAssertComRCRet(hrc, hrc);
    1103610982
    1103710983        data.llStorageControllers.push_back(ctl);
     
    1104910995    MediumAttachmentList atts;
    1105010996
    11051     HRESULT rc = i_getMediumAttachmentsOfController(aStorageController->i_getName(), atts);
    11052     if (FAILED(rc)) return rc;
     10997    HRESULT hrc = i_getMediumAttachmentsOfController(aStorageController->i_getName(), atts);
     10998    if (FAILED(hrc)) return hrc;
    1105310999
    1105411000    data.llAttachedDevices.clear();
     
    1110711053    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1110811054
    11109     HRESULT rc = S_OK;
     11055    HRESULT hrc = S_OK;
    1111011056
    1111111057    Assert(mData->pMachineConfigFile);
     
    1114111087    catch (...)
    1114211088    {
    11143         rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    11144     }
    11145 
    11146     return rc;
     11089        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     11090    }
     11091
     11092    return hrc;
    1114711093}
    1114811094
     
    1121511161 *                              VERR_FILE_NOT_FOUND and VERR_PATH_NOT_FOUND always will be ignored.
    1121611162 * @param   strWhat             File hint which will be used when setting an error. Optional.
    11217  * @param   prc                 Where to return IPRT's error code on failure. Optional and can be NULL.
     11163 * @param   prc                 Where to return IPRT's status code on failure.
     11164 *                              Optional and can be NULL.
    1121811165 */
    1121911166HRESULT Machine::i_deleteFile(const Utf8Str &strFile, bool fIgnoreFailures /* = false */,
     
    1124011187            Utf8StrFmt strError("Error deleting %s '%s' (%Rrc)",
    1124111188                                strWhat.isEmpty() ? tr("file") : strWhat.c_str(), strFile.c_str(), vrc);
    11242             hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, strError.c_str(),
    11243                                strFile.c_str(), vrc);
    11244         }
    11245 
    11246         if (prc)
    11247             *prc = vrc;
    11248     }
    11249 
     11189            hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, strError.c_str(), strFile.c_str(), vrc);
     11190        }
     11191    }
     11192
     11193    if (prc)
     11194        *prc = vrc;
    1125011195    return hrc;
    1125111196}
     
    1130411249                 , E_FAIL);
    1130511250
    11306     HRESULT rc = S_OK;
     11251    HRESULT hrc = S_OK;
    1130711252
    1130811253    // use appropriate locked media map (online or offline)
     
    1133311278                    MediumLockList *pMediumLockList(new MediumLockList());
    1133411279                    alock.release();
    11335                     rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
    11336                                                          NULL /* pToLockWrite */,
    11337                                                          false /* fMediumLockWriteAll */,
    11338                                                          NULL,
    11339                                                          *pMediumLockList);
     11280                    hrc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
     11281                                                          NULL /* pToLockWrite */,
     11282                                                          false /* fMediumLockWriteAll */,
     11283                                                          NULL,
     11284                                                          *pMediumLockList);
    1134011285                    alock.acquire();
    11341                     if (FAILED(rc))
     11286                    if (FAILED(hrc))
    1134211287                    {
    1134311288                        delete pMediumLockList;
    11344                         throw rc;
     11289                        throw hrc;
    1134511290                    }
    11346                     rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
    11347                     if (FAILED(rc))
    11348                     {
    11349                         throw setError(rc,
    11350                                        tr("Collecting locking information for all attached media failed"));
    11351                     }
     11291                    hrc = lockedMediaMap->Insert(pAtt, pMediumLockList);
     11292                    if (FAILED(hrc))
     11293                        throw setError(hrc, tr("Collecting locking information for all attached media failed"));
    1135211294                }
    1135311295            }
     
    1135511297            /* Now lock all media. If this fails, nothing is locked. */
    1135611298            alock.release();
    11357             rc = lockedMediaMap->Lock();
     11299            hrc = lockedMediaMap->Lock();
    1135811300            alock.acquire();
    11359             if (FAILED(rc))
    11360             {
    11361                 throw setError(rc,
    11362                                tr("Locking of attached media failed"));
    11363             }
     11301            if (FAILED(hrc))
     11302                throw setError(hrc, tr("Locking of attached media failed"));
    1136411303        }
    1136511304
     
    1142311362            bool fInRegistry = pMedium->i_getFirstRegistryMachineId(uuidRegistryParent);
    1142411363            Assert(fInRegistry); NOREF(fInRegistry);
    11425             rc = diff->init(mParent,
    11426                             pMedium->i_getPreferredDiffFormat(),
    11427                             strFullSnapshotFolder.append(RTPATH_SLASH_STR),
    11428                             uuidRegistryParent,
    11429                             DeviceType_HardDisk);
    11430             if (FAILED(rc)) throw rc;
     11364            hrc = diff->init(mParent,
     11365                             pMedium->i_getPreferredDiffFormat(),
     11366                             strFullSnapshotFolder.append(RTPATH_SLASH_STR),
     11367                             uuidRegistryParent,
     11368                             DeviceType_HardDisk);
     11369            if (FAILED(hrc)) throw hrc;
    1143111370
    1143211371            /** @todo r=bird: How is the locking and diff image cleaned up if we fail before
     
    1143711376            /* update the appropriate lock list */
    1143811377            MediumLockList *pMediumLockList;
    11439             rc = lockedMediaMap->Get(pAtt, pMediumLockList);
    11440             AssertComRCThrowRC(rc);
     11378            hrc = lockedMediaMap->Get(pAtt, pMediumLockList);
     11379            AssertComRCThrowRC(hrc);
    1144111380            if (aOnline)
    1144211381            {
     
    1144411383                /* The currently attached medium will be read-only, change
    1144511384                 * the lock type to read. */
    11446                 rc = pMediumLockList->Update(pMedium, false);
     11385                hrc = pMediumLockList->Update(pMedium, false);
    1144711386                alock.acquire();
    11448                 AssertComRCThrowRC(rc);
     11387                AssertComRCThrowRC(hrc);
    1144911388            }
    1145011389
    1145111390            /* release the locks before the potentially lengthy operation */
    1145211391            alock.release();
    11453             rc = pMedium->i_createDiffStorage(diff,
    11454                                               pMedium->i_getPreferredDiffVariant(),
    11455                                               pMediumLockList,
    11456                                               NULL /* aProgress */,
    11457                                               true /* aWait */,
    11458                                               false /* aNotify */);
     11392            hrc = pMedium->i_createDiffStorage(diff,
     11393                                               pMedium->i_getPreferredDiffVariant(),
     11394                                               pMediumLockList,
     11395                                               NULL /* aProgress */,
     11396                                               true /* aWait */,
     11397                                               false /* aNotify */);
    1145911398            alock.acquire();
    11460             if (FAILED(rc)) throw rc;
     11399            if (FAILED(hrc)) throw hrc;
    1146111400
    1146211401            /* actual lock list update is done in Machine::i_commitMedia */
    1146311402
    11464             rc = diff->i_addBackReference(mData->mUuid);
    11465             AssertComRCThrowRC(rc);
     11403            hrc = diff->i_addBackReference(mData->mUuid);
     11404            AssertComRCThrowRC(hrc);
    1146611405
    1146711406            /* add a new attachment */
    1146811407            ComObjPtr<MediumAttachment> attachment;
    1146911408            attachment.createObject();
    11470             rc = attachment->init(this,
    11471                                   diff,
    11472                                   pAtt->i_getControllerName(),
    11473                                   pAtt->i_getPort(),
    11474                                   pAtt->i_getDevice(),
    11475                                   DeviceType_HardDisk,
    11476                                   true /* aImplicit */,
    11477                                   false /* aPassthrough */,
    11478                                   false /* aTempEject */,
    11479                                   pAtt->i_getNonRotational(),
    11480                                   pAtt->i_getDiscard(),
    11481                                   pAtt->i_getHotPluggable(),
    11482                                   pAtt->i_getBandwidthGroup());
    11483             if (FAILED(rc)) throw rc;
    11484 
    11485             rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
    11486             AssertComRCThrowRC(rc);
     11409            hrc = attachment->init(this,
     11410                                   diff,
     11411                                   pAtt->i_getControllerName(),
     11412                                   pAtt->i_getPort(),
     11413                                   pAtt->i_getDevice(),
     11414                                   DeviceType_HardDisk,
     11415                                   true /* aImplicit */,
     11416                                   false /* aPassthrough */,
     11417                                   false /* aTempEject */,
     11418                                   pAtt->i_getNonRotational(),
     11419                                   pAtt->i_getDiscard(),
     11420                                   pAtt->i_getHotPluggable(),
     11421                                   pAtt->i_getBandwidthGroup());
     11422            if (FAILED(hrc)) throw hrc;
     11423
     11424            hrc = lockedMediaMap->ReplaceKey(pAtt, attachment);
     11425            AssertComRCThrowRC(hrc);
    1148711426            mMediumAttachments->push_back(attachment);
    1148811427        }
    1148911428    }
    11490     catch (HRESULT aRC) { rc = aRC; }
     11429    catch (HRESULT hrcXcpt)
     11430    {
     11431        hrc = hrcXcpt;
     11432    }
    1149111433
    1149211434    /* unlock all hard disks we locked when there is no VM */
     
    1149911441    }
    1150011442
    11501     return rc;
     11443    return hrc;
    1150211444}
    1150311445
     
    1155011492        return S_OK;
    1155111493
    11552     HRESULT rc = S_OK;
     11494    HRESULT hrc = S_OK;
    1155311495    MachineState_T oldState = mData->mMachineState;
    1155411496
     
    1159211534                    MediumLockList *pMediumLockList(new MediumLockList());
    1159311535                    alock.release();
    11594                     rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
    11595                                                          NULL /* pToLockWrite */,
    11596                                                          false /* fMediumLockWriteAll */,
    11597                                                          NULL,
    11598                                                          *pMediumLockList);
     11536                    hrc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
     11537                                                          NULL /* pToLockWrite */,
     11538                                                          false /* fMediumLockWriteAll */,
     11539                                                          NULL,
     11540                                                          *pMediumLockList);
    1159911541                    alock.acquire();
    1160011542
    11601                     if (FAILED(rc))
     11543                    if (FAILED(hrc))
    1160211544                    {
    1160311545                        delete pMediumLockList;
    11604                         throw rc;
     11546                        throw hrc;
    1160511547                    }
    1160611548
    11607                     rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
    11608                     if (FAILED(rc))
    11609                         throw rc;
     11549                    hrc = lockedMediaMap->Insert(pAtt, pMediumLockList);
     11550                    if (FAILED(hrc))
     11551                        throw hrc;
    1161011552                }
    1161111553            }
    1161211554
    11613             if (FAILED(rc))
    11614                 throw rc;
     11555            if (FAILED(hrc))
     11556                throw hrc;
    1161511557        } // end of offline
    1161611558
     
    1163611578                /* Deassociate and mark for deletion */
    1163711579                LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->i_getLogName()));
    11638                 rc = pMedium->i_removeBackReference(mData->mUuid);
    11639                 if (FAILED(rc))
    11640                    throw rc;
     11580                hrc = pMedium->i_removeBackReference(mData->mUuid);
     11581                if (FAILED(hrc))
     11582                   throw hrc;
    1164111583                implicitAtts.push_back(pAtt);
    1164211584                continue;
     
    1164811590                /* no: de-associate */
    1164911591                LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->i_getLogName()));
    11650                 rc = pMedium->i_removeBackReference(mData->mUuid);
    11651                 if (FAILED(rc))
    11652                     throw rc;
     11592                hrc = pMedium->i_removeBackReference(mData->mUuid);
     11593                if (FAILED(hrc))
     11594                    throw hrc;
    1165311595                continue;
    1165411596            }
     
    1169211634                Assert(pMedium);
    1169311635
    11694                 rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/, false /*aNotify*/);
     11636                hrc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/, false /*aNotify*/);
    1169511637                // continue on delete failure, just collect error messages
    11696                 AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(),
    11697                                           pMedium->i_getLocationFull().c_str() ));
    11698                 mrc = rc;
     11638                AssertMsg(SUCCEEDED(hrc), ("hrc=%Rhrc it=%s hd=%s\n", hrc, pAtt->i_getLogName(),
     11639                                           pMedium->i_getLocationFull().c_str() ));
     11640                mrc = hrc;
    1169911641            }
    1170011642            // Clear the list of deleted implicit attachments now, while not
     
    1171411656                {
    1171511657                    alock.release();
    11716                     rc = mData->mSession.mMachine->i_lockMedia();
     11658                    hrc = mData->mSession.mMachine->i_lockMedia();
    1171711659                    alock.acquire();
    11718                     if (FAILED(rc))
    11719                         throw rc;
     11660                    if (FAILED(hrc))
     11661                        throw hrc;
    1172011662                }
    1172111663            }
    1172211664        }
    1172311665    }
    11724     catch (HRESULT aRC) {rc = aRC;}
     11666    catch (HRESULT hrcXcpt)
     11667    {
     11668        hrc = hrcXcpt;
     11669    }
    1172511670
    1172611671    if (mData->mMachineState == MachineState_SettingUp)
     
    1173611681    }
    1173711682
    11738     return rc;
     11683    return hrc;
    1173911684}
    1174011685
     
    1185911804        writeLock.release();
    1186011805
    11861         HRESULT rc = oldmedium->i_deleteStorage(NULL /*aProgress*/,
    11862                                                 true /*aWait*/,
    11863                                                 false /*aNotify*/);
     11806        HRESULT hrc = oldmedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/, false /*aNotify*/);
    1186411807
    1186511808        writeLock.acquire();
     
    1186711810        i_setMachineState(oldState);
    1186811811
    11869         if (FAILED(rc)) return rc;
     11812        if (FAILED(hrc)) return hrc;
    1187011813    }
    1187111814
     
    1192511868    Assert(isWriteLockOnCurrentThread());
    1192611869
    11927     HRESULT rc;
     11870    HRESULT hrc;
    1192811871
    1192911872    // make a temporary list because i_detachDevice invalidates iterators into
     
    1199311936
    1199411937        // real machine: then we need to use the proper method
    11995         rc = i_detachDevice(pAttach, writeLock, pSnapshot);
    11996 
    11997         if (FAILED(rc))
    11998             return rc;
     11938        hrc = i_detachDevice(pAttach, writeLock, pSnapshot);
     11939
     11940        if (FAILED(hrc))
     11941            return hrc;
    1199911942    }
    1200011943
     
    1202511968    LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
    1202611969
    12027     HRESULT rc = S_OK;
     11970    HRESULT hrc = S_OK;
    1202811971
    1202911972    /* no attach/detach operations -- nothing to do */
     
    1206512008                /* update the appropriate lock list */
    1206612009                MediumLockList *pMediumLockList;
    12067                 rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
    12068                 AssertComRC(rc);
     12010                hrc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
     12011                AssertComRC(hrc);
    1206912012                if (pMediumLockList)
    1207012013                {
     
    1207312016                    {
    1207412017                        Assert(mData->mSession.mLockedMedia.IsLocked());
    12075                         rc = mData->mSession.mLockedMedia.Unlock();
    12076                         AssertComRC(rc);
     12018                        hrc = mData->mSession.mLockedMedia.Unlock();
     12019                        AssertComRC(hrc);
    1207712020                        fMediaNeedsLocking = true;
    1207812021                    }
    12079                     rc = pMediumLockList->Update(pMedium->i_getParent(), false);
    12080                     AssertComRC(rc);
    12081                     rc = pMediumLockList->Append(pMedium, true);
    12082                     AssertComRC(rc);
     12022                    hrc = pMediumLockList->Update(pMedium->i_getParent(), false);
     12023                    AssertComRC(hrc);
     12024                    hrc = pMediumLockList->Append(pMedium, true);
     12025                    AssertComRC(hrc);
    1208312026                }
    1208412027            }
     
    1212512068
    1212612069            /* now de-associate from the current machine state */
    12127             rc = pMedium->i_removeBackReference(mData->mUuid);
    12128             AssertComRC(rc);
     12070            hrc = pMedium->i_removeBackReference(mData->mUuid);
     12071            AssertComRC(hrc);
    1212912072
    1213012073            if (aOnline)
     
    1213212075                /* unlock since medium is not used anymore */
    1213312076                MediumLockList *pMediumLockList;
    12134                 rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
    12135                 if (RT_UNLIKELY(rc == VBOX_E_INVALID_OBJECT_STATE))
     12077                hrc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
     12078                if (RT_UNLIKELY(hrc == VBOX_E_INVALID_OBJECT_STATE))
    1213612079                {
    1213712080                    /* this happens for online snapshots, there the attachment
     
    1214212085                else
    1214312086                {
    12144                     AssertComRC(rc);
     12087                    AssertComRC(hrc);
    1214512088                    if (pMediumLockList)
    1214612089                    {
    12147                         rc = mData->mSession.mLockedMedia.Remove(pAttach);
    12148                         AssertComRC(rc);
     12090                        hrc = mData->mSession.mLockedMedia.Remove(pAttach);
     12091                        AssertComRC(hrc);
    1214912092                    }
    1215012093                }
     
    1215712100    {
    1215812101        Assert(aOnline);
    12159         rc = mData->mSession.mLockedMedia.Lock();
    12160         AssertComRC(rc);
     12102        hrc = mData->mSession.mLockedMedia.Lock();
     12103        AssertComRC(hrc);
    1216112104    }
    1216212105
     
    1220612149    LogFlowThisFunc(("Entering rollbackMedia\n"));
    1220712150
    12208     HRESULT rc = S_OK;
     12151    HRESULT hrc = S_OK;
    1220912152
    1221012153    /* no attach/detach operations -- nothing to do */
     
    1222512168            if (pMedium)
    1222612169            {
    12227                 rc = pMedium->i_removeBackReference(mData->mUuid);
    12228                 AssertComRC(rc);
     12170                hrc = pMedium->i_removeBackReference(mData->mUuid);
     12171                AssertComRC(hrc);
    1222912172            }
    1223012173        }
     
    1223912182            if (pMedium)
    1224012183            {
    12241                 rc = pMedium->i_addBackReference(mData->mUuid);
    12242                 AssertComRC(rc);
     12184                hrc = pMedium->i_addBackReference(mData->mUuid);
     12185                AssertComRC(hrc);
    1224312186            }
    1224412187        }
     
    1276612709        ComObjPtr<SharedFolder> folder;
    1276712710        folder.createObject();
    12768         HRESULT rc = folder->initCopy(i_getMachine(), *it);
    12769         AssertComRC(rc);
     12711        HRESULT hrc = folder->initCopy(i_getMachine(), *it);
     12712        AssertComRC(hrc);
    1277012713        *it = folder;
    1277112714    }
     
    1283712780{
    1283812781    ComPtr<ISystemProperties> systemProperties;
    12839     HRESULT rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
    12840     if (FAILED(rc))
     12782    HRESULT hrc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
     12783    if (FAILED(hrc))
    1284112784        return false;
    1284212785
     
    1308913032    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    1309013033
    13091     HRESULT rc = S_OK;
     13034    HRESULT hrc = S_OK;
    1309213035
    1309313036    RT_ZERO(mAuthLibCtx);
     
    1310113044            delete mClientToken;
    1310213045            mClientToken = NULL;
    13103             rc = E_FAIL;
     13046            hrc = E_FAIL;
    1310413047        }
    1310513048    }
    1310613049    catch (std::bad_alloc &)
    1310713050    {
    13108         rc = E_OUTOFMEMORY;
    13109     }
    13110     if (FAILED(rc))
    13111         return rc;
     13051        hrc = E_OUTOFMEMORY;
     13052    }
     13053    if (FAILED(hrc))
     13054        return hrc;
    1311213055
    1311313056    /* memorize the peer Machine */
     
    1321013153
    1321113154    LogFlowThisFuncLeave();
    13212     return rc;
     13155    return hrc;
    1321313156}
    1321413157
     
    1328713230         * This is identical to SessionMachine::DetachAllUSBDevices except
    1328813231         * for the aAbnormal argument. */
    13289         HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
    13290         AssertComRC(rc);
    13291         NOREF(rc);
     13232        HRESULT hrc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
     13233        AssertComRC(hrc);
     13234        NOREF(hrc);
    1329213235
    1329313236        USBProxyService *service = mParent->i_host()->i_usbProxyService();
     
    1337113314            multilock.release();
    1337213315            LogFlowThisFunc(("  Calling remoteControl->Uninitialize()...\n"));
    13373             HRESULT rc = pControl->Uninitialize();
    13374             LogFlowThisFunc(("  remoteControl->Uninitialize() returned %08X\n", rc));
    13375             if (FAILED(rc))
     13316            HRESULT hrc = pControl->Uninitialize();
     13317            LogFlowThisFunc(("  remoteControl->Uninitialize() returned %08X\n", hrc));
     13318            if (FAILED(hrc))
    1337613319                Log1WarningThisFunc(("Forgot to close the remote session?\n"));
    1337713320            multilock.acquire();
     
    1360713550        /* we might have been uninitialized because the session was accidentally
    1360813551         * closed by the client, so don't assert */
    13609         HRESULT rc = setError(E_FAIL,
    13610                               tr("The session has been accidentally closed"));
    13611         task.m_pProgress->i_notifyComplete(rc);
     13552        HRESULT hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
     13553        task.m_pProgress->i_notifyComplete(hrc);
    1361213554        LogFlowThisFuncLeave();
    1361313555        return;
     
    1361613558    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1361713559
    13618     HRESULT rc = S_OK;
     13560    HRESULT hrc = S_OK;
    1361913561
    1362013562    try
     
    1362813570        alock.release();
    1362913571        BOOL fSuspendedBySave;
    13630         rc = directControl->SaveStateWithReason(task.m_enmReason, task.m_pProgress, NULL, Bstr(task.m_strStateFilePath).raw(), task.m_machineStateBackup != MachineState_Paused, &fSuspendedBySave);
     13572        hrc = directControl->SaveStateWithReason(task.m_enmReason, task.m_pProgress, NULL, Bstr(task.m_strStateFilePath).raw(), task.m_machineStateBackup != MachineState_Paused, &fSuspendedBySave);
    1363113573        Assert(!fSuspendedBySave);
    1363213574        alock.acquire();
    1363313575
    13634         AssertStmt(   (SUCCEEDED(rc) && mData->mMachineState == MachineState_Saved)
    13635                    || (FAILED(rc) && mData->mMachineState == MachineState_Saving),
     13576        AssertStmt(   (SUCCEEDED(hrc) && mData->mMachineState == MachineState_Saved)
     13577                   || (FAILED(hrc) && mData->mMachineState == MachineState_Saving),
    1363613578                   throw E_FAIL);
    1363713579
    13638         if (SUCCEEDED(rc))
     13580        if (SUCCEEDED(hrc))
    1363913581        {
    1364013582            mSSData->strStateFilePath = task.m_strStateFilePath;
    1364113583
    1364213584            /* save all VM settings */
    13643             rc = i_saveSettings(NULL, alock);
     13585            hrc = i_saveSettings(NULL, alock);
    1364413586                    // no need to check whether VirtualBox.xml needs saving also since
    1364513587                    // we can't have a name change pending at this point
     
    1365713599        }
    1365813600    }
    13659     catch (HRESULT aRC) { rc = aRC; }
    13660 
    13661     task.m_pProgress->i_notifyComplete(rc);
     13601    catch (HRESULT hrcXcpt)
     13602    {
     13603        hrc = hrcXcpt;
     13604    }
     13605
     13606    task.m_pProgress->i_notifyComplete(hrc);
    1366213607
    1366313608    LogFlowThisFuncLeave();
     
    1367613621    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1367713622
    13678     HRESULT rc = i_checkStateDependency(MutableOrRunningStateDep);
    13679     if (FAILED(rc)) return rc;
     13623    HRESULT hrc = i_checkStateDependency(MutableOrRunningStateDep);
     13624    if (FAILED(hrc)) return hrc;
    1368013625
    1368113626    if (   mData->mMachineState != MachineState_Running
     
    1368813633    ComObjPtr<Progress> pProgress;
    1368913634    pProgress.createObject();
    13690     rc = pProgress->init(i_getVirtualBox(),
    13691                          static_cast<IMachine *>(this) /* aInitiator */,
    13692                          tr("Saving the execution state of the virtual machine"),
    13693                          FALSE /* aCancelable */);
    13694     if (FAILED(rc))
    13695         return rc;
     13635    hrc = pProgress->init(i_getVirtualBox(),
     13636                          static_cast<IMachine *>(this) /* aInitiator */,
     13637                          tr("Saving the execution state of the virtual machine"),
     13638                          FALSE /* aCancelable */);
     13639    if (FAILED(hrc))
     13640        return hrc;
    1369613641
    1369713642    Utf8Str strStateFilePath;
     
    1370113646     * start working until we release alock) */
    1370213647    SaveStateTask *pTask = new SaveStateTask(this, pProgress, "SaveState", aReason, strStateFilePath);
    13703     rc = pTask->createThread();
    13704     if (FAILED(rc))
    13705         return rc;
     13648    hrc = pTask->createThread();
     13649    if (FAILED(hrc))
     13650        return hrc;
    1370613651
    1370713652    /* set the state to Saving (expected by Session::SaveStateWithReason()) */
     
    1372113666    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1372213667
    13723     HRESULT rc = i_checkStateDependency(MutableStateDep);
    13724     if (FAILED(rc)) return rc;
     13668    HRESULT hrc = i_checkStateDependency(MutableStateDep);
     13669    if (FAILED(hrc)) return hrc;
    1372513670
    1372613671    if (   mData->mMachineState != MachineState_PoweredOff
     
    1375513700    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1375613701
    13757     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    13758     if (FAILED(rc)) return rc;
     13702    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     13703    if (FAILED(hrc)) return hrc;
    1375913704
    1376013705    if (   mData->mMachineState != MachineState_Saved
     
    1377013715     * and properly handled.
    1377113716     */
    13772     rc = i_setMachineState(MachineState_PoweredOff);
    13773     return rc;
     13717    hrc = i_setMachineState(MachineState_PoweredOff);
     13718    return hrc;
    1377413719}
    1377513720
     
    1398613931    /* if captureDeviceForVM() fails, it must have set extended error info */
    1398713932    clearError();
    13988     MultiResult rc = mParent->i_host()->i_checkUSBProxyService();
    13989     if (FAILED(rc) || SUCCEEDED_WARNING(rc))
    13990         return rc;
     13933    MultiResult hrc = mParent->i_host()->i_checkUSBProxyService();
     13934    if (FAILED(hrc) || SUCCEEDED_WARNING(hrc))
     13935        return hrc;
    1399113936
    1399213937    USBProxyService *service = mParent->i_host()->i_usbProxyService();
     
    1403113976
    1403213977#ifdef VBOX_WITH_USB
    14033     HRESULT rc = mUSBDeviceFilters->i_notifyProxy(true /* aInsertFilters */);
    14034     AssertComRC(rc);
    14035     NOREF(rc);
     13978    HRESULT hrc = mUSBDeviceFilters->i_notifyProxy(true /* aInsertFilters */);
     13979    AssertComRC(hrc);
     13980    NOREF(hrc);
    1403613981
    1403713982    USBProxyService *service = mParent->i_host()->i_usbProxyService();
     
    1405814003
    1405914004#ifdef VBOX_WITH_USB
    14060     HRESULT rc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
    14061     AssertComRC(rc);
    14062     NOREF(rc);
     14005    HRESULT hrc = mUSBDeviceFilters->i_notifyProxy(false /* aInsertFilters */);
     14006    AssertComRC(hrc);
     14007    NOREF(hrc);
    1406314008
    1406414009    USBProxyService *service = mParent->i_host()->i_usbProxyService();
     
    1523915184    AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
    1524015185
    15241     MultiResult mrc(S_OK);
     15186    MultiResult hrcMult(S_OK);
    1524215187
    1524315188    /* Collect locking information for all medium objects attached to the VM. */
     
    1526415209
    1526515210            alock.release();
    15266             mrc = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
    15267                                                   !fIsReadOnlyLock ? pMedium : NULL /* pToLockWrite */,
    15268                                                   false /* fMediumLockWriteAll */,
    15269                                                   NULL,
    15270                                                   *pMediumLockList);
     15211            hrcMult = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
     15212                                                      !fIsReadOnlyLock ? pMedium : NULL /* pToLockWrite */,
     15213                                                      false /* fMediumLockWriteAll */,
     15214                                                      NULL,
     15215                                                      *pMediumLockList);
    1527115216            alock.acquire();
    15272             if (FAILED(mrc))
     15217            if (FAILED(hrcMult))
    1527315218            {
    1527415219                delete pMediumLockList;
     
    1527815223        }
    1527915224
    15280         HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
    15281         if (FAILED(rc))
     15225        HRESULT hrc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
     15226        if (FAILED(hrc))
    1528215227        {
    1528315228            mData->mSession.mLockedMedia.Clear();
    15284             mrc = setError(rc,
    15285                            tr("Collecting locking information for all attached media failed"));
     15229            hrcMult = setError(hrc, tr("Collecting locking information for all attached media failed"));
    1528615230            break;
    1528715231        }
    1528815232    }
    1528915233
    15290     if (SUCCEEDED(mrc))
     15234    if (SUCCEEDED(hrcMult))
    1529115235    {
    1529215236        /* Now lock all media. If this fails, nothing is locked. */
    1529315237        alock.release();
    15294         HRESULT rc = mData->mSession.mLockedMedia.Lock();
     15238        HRESULT hrc = mData->mSession.mLockedMedia.Lock();
    1529515239        alock.acquire();
    15296         if (FAILED(rc))
    15297         {
    15298             mrc = setError(rc,
    15299                            tr("Locking of attached media failed. A possible reason is that one of the media is attached to a running VM"));
    15300         }
    15301     }
    15302 
    15303     return mrc;
     15240        if (FAILED(hrc))
     15241            hrcMult = setError(hrc,
     15242                               tr("Locking of attached media failed. A possible reason is that one of the media is attached to a running VM"));
     15243    }
     15244
     15245    return hrcMult;
    1530415246}
    1530515247
     
    1531815260    ErrorInfoKeeper eik;
    1531915261
    15320     HRESULT rc = mData->mSession.mLockedMedia.Clear();
    15321     AssertComRC(rc);
    15322     return rc;
     15262    HRESULT hrc = mData->mSession.mLockedMedia.Clear();
     15263    AssertComRC(hrc);
     15264    return hrc;
    1532315265}
    1532415266
     
    1534815290                    E_FAIL);
    1534915291
    15350     HRESULT rc = S_OK;
     15292    HRESULT hrc = S_OK;
    1535115293
    1535215294    int stsFlags = 0;
     
    1555615498#endif /* VBOX_WITH_GUEST_PROPS */
    1555715499
    15558     rc = i_saveStateSettings(stsFlags);
     15500    hrc = i_saveStateSettings(stsFlags);
    1555915501
    1556015502    if (   (   oldMachineState != MachineState_PoweredOff
     
    1557215514    }
    1557315515
    15574     LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, ::stringifyMachineState(mData->mMachineState) ));
     15516    LogFlowThisFunc(("hrc=%Rhrc [%s]\n", hrc, ::stringifyMachineState(mData->mMachineState) ));
    1557515517    LogFlowThisFuncLeave();
    15576     return rc;
     15518    return hrc;
    1557715519}
    1557815520
     
    1562015562    va_list args;
    1562115563    va_start(args, pcszMsg);
    15622     HRESULT rc = setErrorInternalV(aResultCode,
    15623                                    getStaticClassIID(),
    15624                                    getStaticComponentName(),
    15625                                    pcszMsg, args,
    15626                                    false /* aWarning */,
    15627                                    true /* aLogIt */);
     15564    HRESULT hrc = setErrorInternalV(aResultCode,
     15565                                    getStaticClassIID(),
     15566                                    getStaticComponentName(),
     15567                                    pcszMsg, args,
     15568                                    false /* aWarning */,
     15569                                    true /* aLogIt */);
    1562815570    va_end(args);
    15629     return rc;
     15571    return hrc;
    1563015572}
    1563115573
     
    1584815790    AssertComRCReturn(autoCaller.hrc(),autoCaller.hrc());
    1584915791
    15850     HRESULT rc = S_OK;
    15851 
    1585215792    /* get usb device filters from host, before any writes occurred to avoid deadlock */
    1585315793    ComPtr<IUSBDeviceFilters> usbDeviceFilters;
    15854     rc = getUSBDeviceFilters(usbDeviceFilters);
    15855     if (FAILED(rc)) return rc;
     15794    HRESULT hrc = getUSBDeviceFilters(usbDeviceFilters);
     15795    if (FAILED(hrc)) return hrc;
    1585615796
    1585715797    NOREF(aFlags);
     
    1586015800
    1586115801    /* Get the guest os type as a string from the VB. */
    15862     rc = getOSTypeId(osTypeId);
    15863     if (FAILED(rc)) return rc;
     15802    hrc = getOSTypeId(osTypeId);
     15803    if (FAILED(hrc)) return hrc;
    1586415804
    1586515805    /* Get the os type obj that coresponds, can be used to get
    1586615806     * the defaults for this guest OS. */
    15867     rc = mParent->i_findGuestOSType(Bstr(osTypeId), osType);
    15868     if (FAILED(rc)) return rc;
     15807    hrc = mParent->i_findGuestOSType(Bstr(osTypeId), osType);
     15808    if (FAILED(hrc)) return hrc;
    1586915809
    1587015810    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     
    1588815828    mHWData->mHWVirtExEnabled = true;
    1588915829
    15890     rc = osType->COMGETTER(RecommendedRAM)(&mHWData->mMemorySize);
    15891     if (FAILED(rc)) return rc;
    15892 
    15893     rc = osType->COMGETTER(RecommendedCPUCount)(&mHWData->mCPUCount);
    15894     if (FAILED(rc)) return rc;
     15830    hrc = osType->COMGETTER(RecommendedRAM)(&mHWData->mMemorySize);
     15831    if (FAILED(hrc)) return hrc;
     15832
     15833    hrc = osType->COMGETTER(RecommendedCPUCount)(&mHWData->mCPUCount);
     15834    if (FAILED(hrc)) return hrc;
    1589515835
    1589615836    /* Graphics stuff. */
    1589715837    GraphicsControllerType_T graphicsController;
    15898     rc = osType->COMGETTER(RecommendedGraphicsController)(&graphicsController);
    15899     if (FAILED(rc)) return rc;
    15900 
    15901     rc = mGraphicsAdapter->COMSETTER(GraphicsControllerType)(graphicsController);
    15902     if (FAILED(rc)) return rc;
     15838    hrc = osType->COMGETTER(RecommendedGraphicsController)(&graphicsController);
     15839    if (FAILED(hrc)) return hrc;
     15840
     15841    hrc = mGraphicsAdapter->COMSETTER(GraphicsControllerType)(graphicsController);
     15842    if (FAILED(hrc)) return hrc;
    1590315843
    1590415844    ULONG vramSize;
    15905     rc = osType->COMGETTER(RecommendedVRAM)(&vramSize);
    15906     if (FAILED(rc)) return rc;
    15907 
    15908     rc = mGraphicsAdapter->COMSETTER(VRAMSize)(vramSize);
    15909     if (FAILED(rc)) return rc;
     15845    hrc = osType->COMGETTER(RecommendedVRAM)(&vramSize);
     15846    if (FAILED(hrc)) return hrc;
     15847
     15848    hrc = mGraphicsAdapter->COMSETTER(VRAMSize)(vramSize);
     15849    if (FAILED(hrc)) return hrc;
    1591015850
    1591115851    BOOL fAccelerate2DVideoEnabled;
    15912     rc = osType->COMGETTER(Recommended2DVideoAcceleration)(&fAccelerate2DVideoEnabled);
    15913     if (FAILED(rc)) return rc;
    15914 
    15915     rc = mGraphicsAdapter->COMSETTER(Accelerate2DVideoEnabled)(fAccelerate2DVideoEnabled);
    15916     if (FAILED(rc)) return rc;
     15852    hrc = osType->COMGETTER(Recommended2DVideoAcceleration)(&fAccelerate2DVideoEnabled);
     15853    if (FAILED(hrc)) return hrc;
     15854
     15855    hrc = mGraphicsAdapter->COMSETTER(Accelerate2DVideoEnabled)(fAccelerate2DVideoEnabled);
     15856    if (FAILED(hrc)) return hrc;
    1591715857
    1591815858    BOOL fAccelerate3DEnabled;
    15919     rc = osType->COMGETTER(Recommended3DAcceleration)(&fAccelerate3DEnabled);
    15920     if (FAILED(rc)) return rc;
    15921 
    15922     rc = mGraphicsAdapter->COMSETTER(Accelerate3DEnabled)(fAccelerate3DEnabled);
    15923     if (FAILED(rc)) return rc;
    15924 
    15925     rc = osType->COMGETTER(RecommendedFirmware)(&mHWData->mFirmwareType);
    15926     if (FAILED(rc)) return rc;
    15927 
    15928     rc = osType->COMGETTER(RecommendedPAE)(&mHWData->mPAEEnabled);
    15929     if (FAILED(rc)) return rc;
    15930 
    15931     rc = osType->COMGETTER(RecommendedHPET)(&mHWData->mHPETEnabled);
    15932     if (FAILED(rc)) return rc;
     15859    hrc = osType->COMGETTER(Recommended3DAcceleration)(&fAccelerate3DEnabled);
     15860    if (FAILED(hrc)) return hrc;
     15861
     15862    hrc = mGraphicsAdapter->COMSETTER(Accelerate3DEnabled)(fAccelerate3DEnabled);
     15863    if (FAILED(hrc)) return hrc;
     15864
     15865    hrc = osType->COMGETTER(RecommendedFirmware)(&mHWData->mFirmwareType);
     15866    if (FAILED(hrc)) return hrc;
     15867
     15868    hrc = osType->COMGETTER(RecommendedPAE)(&mHWData->mPAEEnabled);
     15869    if (FAILED(hrc)) return hrc;
     15870
     15871    hrc = osType->COMGETTER(RecommendedHPET)(&mHWData->mHPETEnabled);
     15872    if (FAILED(hrc)) return hrc;
    1593315873
    1593415874    BOOL mRTCUseUTC;
    15935     rc = osType->COMGETTER(RecommendedRTCUseUTC)(&mRTCUseUTC);
    15936     if (FAILED(rc)) return rc;
     15875    hrc = osType->COMGETTER(RecommendedRTCUseUTC)(&mRTCUseUTC);
     15876    if (FAILED(hrc)) return hrc;
    1593715877
    1593815878    setRTCUseUTC(mRTCUseUTC);
    15939     if (FAILED(rc)) return rc;
     15879    if (FAILED(hrc)) return hrc;
    1594015880
    1594115881    /* the setter does more than just the assignment, so use it */
    1594215882    ChipsetType_T enmChipsetType;
    15943     rc = osType->COMGETTER(RecommendedChipset)(&enmChipsetType);
    15944     if (FAILED(rc)) return rc;
    15945 
    15946     rc = COMSETTER(ChipsetType)(enmChipsetType);
    15947     if (FAILED(rc)) return rc;
    15948 
    15949     rc = osType->COMGETTER(RecommendedTFReset)(&mHWData->mTripleFaultReset);
    15950     if (FAILED(rc)) return rc;
     15883    hrc = osType->COMGETTER(RecommendedChipset)(&enmChipsetType);
     15884    if (FAILED(hrc)) return hrc;
     15885
     15886    hrc = COMSETTER(ChipsetType)(enmChipsetType);
     15887    if (FAILED(hrc)) return hrc;
     15888
     15889    hrc = osType->COMGETTER(RecommendedTFReset)(&mHWData->mTripleFaultReset);
     15890    if (FAILED(hrc)) return hrc;
    1595115891
    1595215892    /* Apply IOMMU defaults. */
    1595315893    IommuType_T enmIommuType;
    15954     rc = osType->COMGETTER(RecommendedIommuType)(&enmIommuType);
    15955     if (FAILED(rc)) return rc;
    15956 
    15957     rc = COMSETTER(IommuType)(enmIommuType);
    15958     if (FAILED(rc)) return rc;
     15894    hrc = osType->COMGETTER(RecommendedIommuType)(&enmIommuType);
     15895    if (FAILED(hrc)) return hrc;
     15896
     15897    hrc = COMSETTER(IommuType)(enmIommuType);
     15898    if (FAILED(hrc)) return hrc;
    1595915899
    1596015900    /* Apply network adapters defaults */
     
    1597415914
    1597515915    /* This one covers secure boot. */
    15976     rc = mNvramStore->i_applyDefaults(osType);
    15977     if (FAILED(rc)) return rc;
     15916    hrc = mNvramStore->i_applyDefaults(osType);
     15917    if (FAILED(hrc)) return hrc;
    1597815918
    1597915919    /* Audio stuff. */
    15980     rc = mAudioSettings->i_applyDefaults(osType);
    15981     if (FAILED(rc)) return rc;
     15920    hrc = mAudioSettings->i_applyDefaults(osType);
     15921    if (FAILED(hrc)) return hrc;
    1598215922
    1598315923    /* Storage Controllers */
     
    1599615936
    1599715937    /* Floppy recommended? add one. */
    15998     rc = osType->COMGETTER(RecommendedFloppy(&recommendedFloppy));
    15999     if (FAILED(rc)) return rc;
     15938    hrc = osType->COMGETTER(RecommendedFloppy(&recommendedFloppy));
     15939    if (FAILED(hrc)) return hrc;
    1600015940    if (recommendedFloppy)
    1600115941    {
    16002         rc = addStorageController(strFloppyName,
    16003                                   StorageBus_Floppy,
    16004                                   floppyController);
    16005         if (FAILED(rc)) return rc;
     15942        hrc = addStorageController(strFloppyName, StorageBus_Floppy, floppyController);
     15943        if (FAILED(hrc)) return hrc;
    1600615944    }
    1600715945
    1600815946    /* Setup one DVD storage controller. */
    16009     rc = osType->COMGETTER(RecommendedDVDStorageController)(&dvdStorageControllerType);
    16010     if (FAILED(rc)) return rc;
    16011 
    16012     rc = osType->COMGETTER(RecommendedDVDStorageBus)(&dvdStorageBusType);
    16013     if (FAILED(rc)) return rc;
     15947    hrc = osType->COMGETTER(RecommendedDVDStorageController)(&dvdStorageControllerType);
     15948    if (FAILED(hrc)) return hrc;
     15949
     15950    hrc = osType->COMGETTER(RecommendedDVDStorageBus)(&dvdStorageBusType);
     15951    if (FAILED(hrc)) return hrc;
    1601415952
    1601515953    strDVDName = i_controllerNameFromBusType(dvdStorageBusType);
    1601615954
    16017     rc = addStorageController(strDVDName,
    16018                               dvdStorageBusType,
    16019                               dvdController);
    16020     if (FAILED(rc)) return rc;
    16021 
    16022     rc = dvdController->COMSETTER(ControllerType)(dvdStorageControllerType);
    16023     if (FAILED(rc)) return rc;
     15955    hrc = addStorageController(strDVDName, dvdStorageBusType, dvdController);
     15956    if (FAILED(hrc)) return hrc;
     15957
     15958    hrc = dvdController->COMSETTER(ControllerType)(dvdStorageControllerType);
     15959    if (FAILED(hrc)) return hrc;
    1602415960
    1602515961    /* Setup one HDD storage controller. */
    16026     rc = osType->COMGETTER(RecommendedHDStorageController)(&hdStorageControllerType);
    16027     if (FAILED(rc)) return rc;
    16028 
    16029     rc = osType->COMGETTER(RecommendedHDStorageBus)(&hdStorageBusType);
    16030     if (FAILED(rc)) return rc;
     15962    hrc = osType->COMGETTER(RecommendedHDStorageController)(&hdStorageControllerType);
     15963    if (FAILED(hrc)) return hrc;
     15964
     15965    hrc = osType->COMGETTER(RecommendedHDStorageBus)(&hdStorageBusType);
     15966    if (FAILED(hrc)) return hrc;
    1603115967
    1603215968    strHDName = i_controllerNameFromBusType(hdStorageBusType);
     
    1603415970    if (hdStorageBusType != dvdStorageBusType && hdStorageControllerType != dvdStorageControllerType)
    1603515971    {
    16036        rc = addStorageController(strHDName,
    16037                                  hdStorageBusType,
    16038                                  hdController);
    16039        if (FAILED(rc)) return rc;
    16040 
    16041        rc = hdController->COMSETTER(ControllerType)(hdStorageControllerType);
    16042        if (FAILED(rc)) return rc;
     15972       hrc = addStorageController(strHDName, hdStorageBusType, hdController);
     15973       if (FAILED(hrc)) return hrc;
     15974
     15975       hrc = hdController->COMSETTER(ControllerType)(hdStorageControllerType);
     15976       if (FAILED(hrc)) return hrc;
    1604315977    }
    1604415978    else
     
    1607316007
    1607416008    getUSBProxyAvailable(&usbProxyAvailable);
    16075     if (FAILED(rc)) return rc;
    16076 
    16077     rc = osType->COMGETTER(RecommendedUSB3)(&recommendedUSB3);
    16078     if (FAILED(rc)) return rc;
    16079     rc = osType->COMGETTER(RecommendedUSB)(&recommendedUSB);
    16080     if (FAILED(rc)) return rc;
     16009    if (FAILED(hrc)) return hrc;
     16010
     16011    hrc = osType->COMGETTER(RecommendedUSB3)(&recommendedUSB3);
     16012    if (FAILED(hrc)) return hrc;
     16013    hrc = osType->COMGETTER(RecommendedUSB)(&recommendedUSB);
     16014    if (FAILED(hrc)) return hrc;
    1608116015
    1608216016    if (!usbDeviceFilters.isNull() && recommendedUSB3 && usbProxyAvailable)
    1608316017    {
    16084         rc = addUSBController("XHCI", USBControllerType_XHCI, usbController);
    16085         if (FAILED(rc)) return rc;
     16018        hrc = addUSBController("XHCI", USBControllerType_XHCI, usbController);
     16019        if (FAILED(hrc)) return hrc;
    1608616020
    1608716021        /* xHci includes OHCI */
     
    1609116025        && !usbDeviceFilters.isNull() && recommendedUSB && usbProxyAvailable)
    1609216026    {
    16093         rc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
    16094         if (FAILED(rc)) return rc;
     16027        hrc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
     16028        if (FAILED(hrc)) return hrc;
    1609516029        ohciEnabled = true;
    1609616030
    16097         rc = addUSBController("EHCI", USBControllerType_EHCI, usbController);
    16098         if (FAILED(rc)) return rc;
     16031        hrc = addUSBController("EHCI", USBControllerType_EHCI, usbController);
     16032        if (FAILED(hrc)) return hrc;
    1609916033    }
    1610016034
    1610116035    /* Set recommended human interface device types: */
    1610216036    BOOL recommendedUSBHID;
    16103     rc = osType->COMGETTER(RecommendedUSBHID)(&recommendedUSBHID);
    16104     if (FAILED(rc)) return rc;
     16037    hrc = osType->COMGETTER(RecommendedUSBHID)(&recommendedUSBHID);
     16038    if (FAILED(hrc)) return hrc;
    1610516039
    1610616040    if (recommendedUSBHID)
     
    1611016044        if (!ohciEnabled && !usbDeviceFilters.isNull())
    1611116045        {
    16112             rc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
    16113             if (FAILED(rc)) return rc;
     16046            hrc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
     16047            if (FAILED(hrc)) return hrc;
    1611416048        }
    1611516049    }
    1611616050
    1611716051    BOOL recommendedUSBTablet;
    16118     rc = osType->COMGETTER(RecommendedUSBTablet)(&recommendedUSBTablet);
    16119     if (FAILED(rc)) return rc;
     16052    hrc = osType->COMGETTER(RecommendedUSBTablet)(&recommendedUSBTablet);
     16053    if (FAILED(hrc)) return hrc;
    1612016054
    1612116055    if (recommendedUSBTablet)
     
    1612416058        if (!ohciEnabled && !usbDeviceFilters.isNull())
    1612516059        {
    16126             rc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
    16127             if (FAILED(rc)) return rc;
     16060            hrc = addUSBController("OHCI", USBControllerType_OHCI, usbController);
     16061            if (FAILED(hrc)) return hrc;
    1612816062        }
    1612916063    }
     
    1613216066    if (osTypeId == "VBoxBS_64")
    1613316067    {
    16134         rc = setExtraData("VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", "1");
    16135         if (FAILED(rc))
    16136             return rc;
     16068        hrc = setExtraData("VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", "1");
     16069        if (FAILED(hrc))
     16070            return hrc;
    1613716071    }
    1613816072
     
    1622116155    RTDIR hDir;
    1622216156    size_t cbDirEntry = sizeof(RTDIRENTRYEX);
    16223     int rc = RTDirOpenFiltered(&hDir, pszFilePattern, RTDIRFILTER_WINNT, 0 /*fFlags*/);
    16224     if (RT_SUCCESS(rc))
     16157    int vrc = RTDirOpenFiltered(&hDir, pszFilePattern, RTDIRFILTER_WINNT, 0 /*fFlags*/);
     16158    if (RT_SUCCESS(vrc))
    1622516159    {
    1622616160        pDirEntry = (PRTDIRENTRYEX)RTMemAllocZ(sizeof(RTDIRENTRYEX));
    1622716161        if (pDirEntry)
    1622816162        {
    16229             while (   (rc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK))
     16163            while (   (vrc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK))
    1623016164                   != VERR_NO_MORE_FILES)
    1623116165            {
    1623216166                char *pszFilePath = NULL;
    1623316167
    16234                 if (rc == VERR_BUFFER_OVERFLOW)
     16168                if (vrc == VERR_BUFFER_OVERFLOW)
    1623516169                {
    1623616170                    /* allocate new buffer. */
     
    1623916173                    if (!pDirEntry)
    1624016174                    {
    16241                         rc = VERR_NO_MEMORY;
     16175                        vrc = VERR_NO_MEMORY;
    1624216176                        break;
    1624316177                    }
    1624416178                    /* Retry. */
    16245                     rc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
    16246                     if (RT_FAILURE(rc))
     16179                    vrc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
     16180                    if (RT_FAILURE(vrc))
    1624716181                        break;
    1624816182                }
    16249                 else if (RT_FAILURE(rc))
     16183                else if (RT_FAILURE(vrc))
    1625016184                    break;
    1625116185
     
    1625916193                    if (!pszSubDirPath)
    1626016194                    {
    16261                         rc = VERR_NO_STR_MEMORY;
     16195                        vrc = VERR_NO_STR_MEMORY;
    1626216196                        break;
    1626316197                    }
    16264                     rc = i_findFiles(lstFiles, pszSubDirPath, strPattern);
     16198                    vrc = i_findFiles(lstFiles, pszSubDirPath, strPattern);
    1626516199                    RTMemFree(pszSubDirPath);
    16266                     if (RT_FAILURE(rc))
     16200                    if (RT_FAILURE(vrc))
    1626716201                        break;
    1626816202                    continue;
     
    1628016214                if (!pszFilePath)
    1628116215                {
    16282                     rc = VERR_NO_STR_MEMORY;
     16216                    vrc = VERR_NO_STR_MEMORY;
    1628316217                    break;
    1628416218                }
     
    1629116225        }
    1629216226        else
    16293             rc = VERR_NO_MEMORY;
     16227            vrc = VERR_NO_MEMORY;
    1629416228
    1629516229        RTDirClose(hDir);
     
    1630216236    }
    1630316237
    16304     if (   rc == VERR_NO_MORE_FILES
    16305         || rc == VERR_FILE_NOT_FOUND
    16306         || rc == VERR_PATH_NOT_FOUND)
    16307         rc = VINF_SUCCESS;
     16238    if (   vrc == VERR_NO_MORE_FILES
     16239        || vrc == VERR_FILE_NOT_FOUND
     16240        || vrc == VERR_PATH_NOT_FOUND)
     16241        vrc = VINF_SUCCESS;
    1630816242    RTStrFree(pszFilePattern);
    16309     return rc;
     16243    return vrc;
    1631016244}
    1631116245
     
    1642416358
    1642516359    /* Reencryption required */
    16426     HRESULT rc = S_OK;
     16360    HRESULT hrc = S_OK;
    1642716361    int vrc = VINF_SUCCESS;
    1642816362
    1642916363    std::list<com::Utf8Str> lstFiles;
    16430     if (SUCCEEDED(rc))
     16364    if (SUCCEEDED(hrc))
    1643116365    {
    1643216366        vrc = i_findFiles(lstFiles, strDirectory, strFilePattern);
    1643316367        if (RT_FAILURE(vrc))
    16434             rc = setErrorBoth(E_FAIL, vrc, tr("Getting file list for '%s' files failed, (%Rrc)"),
    16435                               strFilePattern.c_str(), vrc);
     16368            hrc = setErrorBoth(E_FAIL, vrc, tr("Getting file list for '%s' files failed, (%Rrc)"), strFilePattern.c_str(), vrc);
    1643616369    }
    1643716370    com::Utf8Str strNewKeyStore;
    16438     if (SUCCEEDED(rc))
     16371    if (SUCCEEDED(hrc))
    1643916372    {
    1644016373        if (!fDecrypt)
     
    1647916412                                              fOpenForWrite, &hVfsIosNew);
    1648016413                if (RT_FAILURE(vrc))
    16481                     rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening file '%s' failed, (%Rrc)"),
     16414                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening file '%s' failed, (%Rrc)"),
    1648216415                                      (*it + ".tmp").c_str(), vrc);
    1648316416            }
    1648416417            else
    16485                 rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening file '%s' failed, (%Rrc)"),
    16486                                   (*it).c_str(), vrc);
     16418                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening file '%s' failed, (%Rrc)"), (*it).c_str(), vrc);
    1648716419
    1648816420            if (RT_SUCCESS(vrc))
     
    1649016422                vrc = RTVfsUtilPumpIoStreams(hVfsIosOld, hVfsIosNew, BUF_DATA_SIZE);
    1649116423                if (RT_FAILURE(vrc))
    16492                     rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Changing encryption of the file '%s' failed with %Rrc"),
    16493                                       (*it).c_str(), vrc);
     16424                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Changing encryption of the file '%s' failed with %Rrc"),
     16425                                       (*it).c_str(), vrc);
    1649416426            }
    1649516427
     
    1650116433    }
    1650216434
    16503     if (SUCCEEDED(rc))
     16435    if (SUCCEEDED(hrc))
    1650416436    {
    1650516437        for (std::list<com::Utf8Str>::iterator it = lstFiles.begin();
     
    1651016442            if (RT_FAILURE(vrc))
    1651116443            {
    16512                 rc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Renaming the file '%s' failed, (%Rrc)"),
    16513                                   (*it + ".tmp").c_str(), vrc);
     16444                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Renaming the file '%s' failed, (%Rrc)"), (*it + ".tmp").c_str(), vrc);
    1651416445                break;
    1651516446            }
     
    1651716448    }
    1651816449
    16519     if (SUCCEEDED(rc))
     16450    if (SUCCEEDED(hrc))
    1652016451    {
    1652116452        strKeyStore = strNewKeyStore;
     
    1652316454    }
    1652416455
    16525     return rc;
     16456    return hrc;
    1652616457}
    1652716458
     
    1654516476        /* we might have been uninitialized because the session was accidentally
    1654616477         * closed by the client, so don't assert */
    16547         HRESULT rc = setError(E_FAIL,
    16548                               tr("The session has been accidentally closed"));
    16549         task.m_pProgress->i_notifyComplete(rc);
     16478        HRESULT hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
     16479        task.m_pProgress->i_notifyComplete(hrc);
    1655016480        LogFlowThisFuncLeave();
    1655116481        return;
     
    1655416484    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1655516485
    16556     HRESULT rc = S_OK;
     16486    HRESULT hrc = S_OK;
    1655716487    com::Utf8Str strOldKeyId = mData->mstrKeyId;
    1655816488    com::Utf8Str strOldKeyStore = mData->mstrKeyStore;
    1655916489    try
    1656016490    {
    16561         rc = this->i_getVirtualBox()->i_retainCryptoIf(&task.m_pCryptoIf);
    16562         if (FAILED(rc))
    16563             throw rc;
     16491        hrc = this->i_getVirtualBox()->i_retainCryptoIf(&task.m_pCryptoIf);
     16492        if (FAILED(hrc))
     16493            throw hrc;
    1656416494
    1656516495        if (task.mstrCurrentPassword.isEmpty())
     
    1657416504                throw setError(VBOX_E_INVALID_OBJECT_STATE,
    1657516505                               tr("The VM is not configured for encryption"));
    16576             rc = checkEncryptionPassword(task.mstrCurrentPassword);
    16577             if (rc == VBOX_E_PASSWORD_INCORRECT)
     16506            hrc = checkEncryptionPassword(task.mstrCurrentPassword);
     16507            if (hrc == VBOX_E_PASSWORD_INCORRECT)
    1657816508                throw setError(VBOX_E_PASSWORD_INCORRECT,
    1657916509                               tr("The password to decrypt the VM is incorrect"));
     
    1666716597        {
    1666816598            ComPtr<IProgress> pProgress1;
    16669             HRESULT hrc = (*it)->ChangeEncryption(bstrCurrentPassword.raw(), bstrCipher.raw(),
    16670                                                   bstrNewPassword.raw(), bstrNewPasswordId.raw(),
    16671                                                   pProgress1.asOutParam());
     16599            hrc = (*it)->ChangeEncryption(bstrCurrentPassword.raw(), bstrCipher.raw(),
     16600                                          bstrNewPassword.raw(), bstrNewPasswordId.raw(),
     16601                                          pProgress1.asOutParam());
    1667216602            if (FAILED(hrc)) throw hrc;
    1667316603            hrc = task.m_pProgress->WaitForOtherProgressCompletion(pProgress1, 0 /* indefinite wait */);
     
    1668216612
    1668316613        /* .sav files (main and snapshots) */
    16684         rc = i_changeEncryptionForComponent(task, strFullSnapshotFolder, "*.sav",
    16685                                             mSSData->strStateKeyStore, mSSData->strStateKeyId, CipherModeGcm);
    16686         if (FAILED(rc))
     16614        hrc = i_changeEncryptionForComponent(task, strFullSnapshotFolder, "*.sav",
     16615                                             mSSData->strStateKeyStore, mSSData->strStateKeyId, CipherModeGcm);
     16616        if (FAILED(hrc))
    1668716617            /* the helper function already sets error object */
    16688             throw rc;
     16618            throw hrc;
    1668916619
    1669016620        task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of the NVRAM files")).raw(), 1);
     
    1669316623        com::Utf8Str strNVRAMKeyId;
    1669416624        com::Utf8Str strNVRAMKeyStore;
    16695         rc = mNvramStore->i_getEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
    16696         if (FAILED(rc))
    16697             throw setError(rc, tr("Getting NVRAM encryption settings failed (%Rhrc)"), rc);
     16625        hrc = mNvramStore->i_getEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
     16626        if (FAILED(hrc))
     16627            throw setError(hrc, tr("Getting NVRAM encryption settings failed (%Rhrc)"), hrc);
    1669816628
    1669916629        Utf8Str strMachineFolder;
    1670016630        i_calculateFullPath(".", strMachineFolder);
    1670116631
    16702         rc = i_changeEncryptionForComponent(task, strMachineFolder, "*.nvram",
    16703                                             strNVRAMKeyStore, strNVRAMKeyId, CipherModeGcm);
    16704         if (FAILED(rc))
     16632        hrc = i_changeEncryptionForComponent(task, strMachineFolder, "*.nvram", strNVRAMKeyStore, strNVRAMKeyId, CipherModeGcm);
     16633        if (FAILED(hrc))
    1670516634            /* the helper function already sets error object */
    16706             throw rc;
    16707 
    16708         rc = mNvramStore->i_updateEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
    16709         if (FAILED(rc))
    16710             throw setError(rc, tr("Setting NVRAM encryption settings failed (%Rhrc)"), rc);
     16635            throw hrc;
     16636
     16637        hrc = mNvramStore->i_updateEncryptionSettings(strNVRAMKeyId, strNVRAMKeyStore);
     16638        if (FAILED(hrc))
     16639            throw setError(hrc, tr("Setting NVRAM encryption settings failed (%Rhrc)"), hrc);
    1671116640
    1671216641        task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of log files")).raw(), 1);
     
    1671516644        com::Utf8Str strLogFolder;
    1671616645        i_getLogFolder(strLogFolder);
    16717         rc = i_changeEncryptionForComponent(task, strLogFolder, "VBox.log*",
    16718                                             mData->mstrLogKeyStore, mData->mstrLogKeyId, CipherModeCtr);
    16719         if (FAILED(rc))
     16646        hrc = i_changeEncryptionForComponent(task, strLogFolder, "VBox.log*",
     16647                                             mData->mstrLogKeyStore, mData->mstrLogKeyId, CipherModeCtr);
     16648        if (FAILED(hrc))
    1672016649            /* the helper function already sets error object */
    16721             throw rc;
     16650            throw hrc;
    1672216651
    1672316652        task.m_pProgress->SetNextOperation(Bstr(tr("Change encryption of the config file")).raw(), 1);
     
    1672516654        i_saveSettings(NULL, alock, fSave);
    1672616655    }
    16727     catch (HRESULT aRC)
    16728     {
    16729         rc = aRC;
     16656    catch (HRESULT hrcXcpt)
     16657    {
     16658        hrc = hrcXcpt;
    1673016659        mData->mstrKeyId = strOldKeyId;
    1673116660        mData->mstrKeyStore = strOldKeyStore;
    1673216661    }
    1673316662
    16734     task.m_pProgress->i_notifyComplete(rc);
     16663    task.m_pProgress->i_notifyComplete(hrc);
    1673516664
    1673616665    LogFlowThisFuncLeave();
     
    1675816687            return setError(E_ACCESSDENIED, tr("Machine is inaccessible"));
    1675916688
    16760         HRESULT rc = addEncryptionPassword(mData->mstrKeyId, aCurrentPassword);
    16761         if (FAILED(rc))
    16762             return rc;
     16689        HRESULT hrc = addEncryptionPassword(mData->mstrKeyId, aCurrentPassword);
     16690        if (FAILED(hrc))
     16691            return hrc;
    1676316692    }
    1676416693
     
    1684916778    ComObjPtr<Progress> pProgress;
    1685016779    pProgress.createObject();
    16851     HRESULT rc = pProgress->init(i_getVirtualBox(),
    16852                                  static_cast<IMachine*>(this) /* aInitiator */,
    16853                                  tr("Change encryption"),
    16854                                  TRUE /* fCancellable */,
    16855                                  (ULONG)(4 + + llMedia.size()), // cOperations
    16856                                  tr("Change encryption of the mediuma"));
    16857     if (FAILED(rc))
    16858         return rc;
     16780    HRESULT hrc = pProgress->init(i_getVirtualBox(),
     16781                                  static_cast<IMachine*>(this) /* aInitiator */,
     16782                                  tr("Change encryption"),
     16783                                  TRUE /* fCancellable */,
     16784                                  (ULONG)(4 + + llMedia.size()), // cOperations
     16785                                  tr("Change encryption of the mediuma"));
     16786    if (FAILED(hrc))
     16787        return hrc;
    1685916788
    1686016789    /* create and start the task on a separate thread (note that it will not
     
    1686316792                                                           aCurrentPassword, aCipher, aNewPassword,
    1686416793                                                           aNewPasswordId, aForce, llMedia);
    16865     rc = pTask->createThread();
     16794    hrc = pTask->createThread();
    1686616795    pTask = NULL;
    16867     if (FAILED(rc))
    16868         return rc;
     16796    if (FAILED(hrc))
     16797        return hrc;
    1686916798
    1687016799    pProgress.queryInterfaceTo(aProgress.asOutParam());
     
    1698116910        /* get the console from the direct session */
    1698216911        ComPtr<IConsole> console;
    16983         HRESULT rc = mData->mSession.mDirectControl->COMGETTER(RemoteConsole)(console.asOutParam());
    16984         ComAssertComRC(rc);
     16912        HRESULT hrc = mData->mSession.mDirectControl->COMGETTER(RemoteConsole)(console.asOutParam());
     16913        ComAssertComRC(hrc);
    1698516914        /* send passsword to console */
    1698616915        console->AddEncryptionPassword(Bstr(aId).raw(),
     
    1705316982        /* get the console from the direct session */
    1705416983        ComPtr<IConsole> console;
    17055         HRESULT rc = mData->mSession.mDirectControl->COMGETTER(RemoteConsole)(console.asOutParam());
    17056         ComAssertComRC(rc);
     16984        HRESULT hrc = mData->mSession.mDirectControl->COMGETTER(RemoteConsole)(console.asOutParam());
     16985        ComAssertComRC(hrc);
    1705716986        /* send passsword to console */
    1705816987        console->RemoveEncryptionPassword(Bstr(aId).raw());
     
    1711417043
    1711517044    uninit();
    17116     HRESULT rc = initFromSettings(pParent, strConfigFile, &id, com::Utf8Str());
     17045    HRESULT hrc = initFromSettings(pParent, strConfigFile, &id, com::Utf8Str());
    1711717046
    1711817047    alock.acquire();
    1711917048    mParent->i_onMachineStateChanged(mData->mUuid, mData->mMachineState);
    17120     return rc;
     17049    return hrc;
    1712117050}
    1712217051#endif
  • trunk/src/VBox/Main/src-server/MachineImplCloneVM.cpp

    r98262 r98288  
    104104        AssertReturn(pTask, VERR_INVALID_POINTER);
    105105
    106         HRESULT rc = pTask->q_ptr->run();
    107 
    108         pTask->pProgress->i_notifyComplete(rc);
     106        HRESULT hrc = pTask->q_ptr->run();
     107
     108        pTask->pProgress->i_notifyComplete(hrc);
    109109
    110110        pTask->q_ptr->destroy();
     
    162162                                                 RTCList< ComObjPtr<Machine> > &machineList) const
    163163{
    164     HRESULT rc = S_OK;
    165164    Bstr name;
    166     rc = pSnapshot->COMGETTER(Name)(name.asOutParam());
    167     if (FAILED(rc)) return rc;
     165    HRESULT hrc = pSnapshot->COMGETTER(Name)(name.asOutParam());
     166    if (FAILED(hrc)) return hrc;
    168167
    169168    ComPtr<IMachine> pMachine;
    170     rc = pSnapshot->COMGETTER(Machine)(pMachine.asOutParam());
    171     if (FAILED(rc)) return rc;
     169    hrc = pSnapshot->COMGETTER(Machine)(pMachine.asOutParam());
     170    if (FAILED(hrc)) return hrc;
    172171    machineList.append((Machine*)(IMachine*)pMachine);
    173172
    174173    SafeIfaceArray<ISnapshot> sfaChilds;
    175     rc = pSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(sfaChilds));
    176     if (FAILED(rc)) return rc;
     174    hrc = pSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(sfaChilds));
     175    if (FAILED(hrc)) return hrc;
    177176    for (size_t i = 0; i < sfaChilds.size(); ++i)
    178177    {
    179         rc = createMachineList(sfaChilds[i], machineList);
    180         if (FAILED(rc)) return rc;
    181     }
    182 
    183     return rc;
     178        hrc = createMachineList(sfaChilds[i], machineList);
     179        if (FAILED(hrc)) return hrc;
     180    }
     181
     182    return hrc;
    184183}
    185184
     
    222221{
    223222    Bstr bstrSrcSaveStatePath;
    224     HRESULT rc = machine->COMGETTER(StateFilePath)(bstrSrcSaveStatePath.asOutParam());
    225     if (FAILED(rc)) return rc;
     223    HRESULT hrc = machine->COMGETTER(StateFilePath)(bstrSrcSaveStatePath.asOutParam());
     224    if (FAILED(hrc)) return hrc;
    226225    if (!bstrSrcSaveStatePath.isEmpty())
    227226    {
     
    255254    Bstr bstrSrcNVRAMPath;
    256255    ComPtr<INvramStore> pNvramStore;
    257     HRESULT rc = machine->COMGETTER(NonVolatileStore)(pNvramStore.asOutParam());
    258     if (FAILED(rc)) return rc;
    259     rc = pNvramStore->COMGETTER(NonVolatileStorageFile)(bstrSrcNVRAMPath.asOutParam());
    260     if (FAILED(rc)) return rc;
     256    HRESULT hrc = machine->COMGETTER(NonVolatileStore)(pNvramStore.asOutParam());
     257    if (FAILED(hrc)) return hrc;
     258    hrc = pNvramStore->COMGETTER(NonVolatileStorageFile)(bstrSrcNVRAMPath.asOutParam());
     259    if (FAILED(hrc)) return hrc;
    261260    if (!bstrSrcNVRAMPath.isEmpty())
    262261    {
     
    291290{
    292291    ComPtr<IMedium> pBaseMedium;
    293     HRESULT rc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
    294     if (FAILED(rc)) return rc;
     292    HRESULT hrc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
     293    if (FAILED(hrc)) return hrc;
    295294    Bstr bstrBaseName;
    296     rc = pBaseMedium->COMGETTER(Name)(bstrBaseName.asOutParam());
    297     if (FAILED(rc)) return rc;
     295    hrc = pBaseMedium->COMGETTER(Name)(bstrBaseName.asOutParam());
     296    if (FAILED(hrc)) return hrc;
    298297    strBaseName = bstrBaseName;
    299     return rc;
     298    return hrc;
    300299}
    301300
     
    308307     * take than care to merge any (possibly) existing parents into the new
    309308     * image. */
    310     HRESULT rc = S_OK;
     309    HRESULT hrc = S_OK;
    311310    for (size_t i = 0; i < machineList.size(); ++i)
    312311    {
     
    317316        /* Add all attachments of the different machines to a worker list. */
    318317        SafeIfaceArray<IMediumAttachment> sfaAttachments;
    319         rc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
    320         if (FAILED(rc)) return rc;
     318        hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
     319        if (FAILED(hrc)) return hrc;
    321320        for (size_t a = 0; a < sfaAttachments.size(); ++a)
    322321        {
    323322            const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
    324323            DeviceType_T type;
    325             rc = pAtt->COMGETTER(Type)(&type);
    326             if (FAILED(rc)) return rc;
     324            hrc = pAtt->COMGETTER(Type)(&type);
     325            if (FAILED(hrc)) return hrc;
    327326
    328327            /* Only harddisks and floppies are of interest. */
     
    333332            /* Valid medium attached? */
    334333            ComPtr<IMedium> pSrcMedium;
    335             rc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
    336             if (FAILED(rc)) return rc;
     334            hrc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
     335            if (FAILED(hrc)) return hrc;
    337336
    338337            if (pSrcMedium.isNull())
     
    348347            /* Refresh the state so that the file size get read. */
    349348            MediumState_T e;
    350             rc = pSrcMedium->RefreshState(&e);
    351             if (FAILED(rc)) return rc;
     349            hrc = pSrcMedium->RefreshState(&e);
     350            if (FAILED(hrc)) return hrc;
    352351            LONG64 lSize;
    353             rc = pSrcMedium->COMGETTER(Size)(&lSize);
    354             if (FAILED(rc)) return rc;
     352            hrc = pSrcMedium->COMGETTER(Size)(&lSize);
     353            if (FAILED(hrc)) return hrc;
    355354
    356355            MEDIUMTASK mt;
     
    358357
    359358            /* Save the base name. */
    360             rc = queryBaseName(pSrcMedium, mt.strBaseName);
    361             if (FAILED(rc)) return rc;
     359            hrc = queryBaseName(pSrcMedium, mt.strBaseName);
     360            if (FAILED(hrc)) return hrc;
    362361
    363362            /* Save the current medium, for later cloning. */
     
    375374        }
    376375        /* Add the save state file of this machine if there is one. */
    377         rc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
    378         if (FAILED(rc)) return rc;
     376        hrc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
     377        if (FAILED(hrc)) return hrc;
    379378        /* Add the NVRAM file of this machine if there is one. */
    380         rc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
    381         if (FAILED(rc)) return rc;
    382     }
    383 
    384     return rc;
     379        hrc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
     380        if (FAILED(hrc)) return hrc;
     381    }
     382
     383    return hrc;
    385384}
    386385
     
    419418
    420419    Assert(!fAttachLinked);
    421     HRESULT rc = S_OK;
     420    HRESULT hrc = S_OK;
    422421    std::map<ComPtr<IMedium>, uint32_t> mediaHist; /* Our usage histogram for the medias */
    423422    for (size_t i = 0; i < machineList.size(); ++i)
     
    430429         * machines to a worker list. */
    431430        SafeIfaceArray<IMediumAttachment> sfaAttachments;
    432         rc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
    433         if (FAILED(rc)) return rc;
     431        hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
     432        if (FAILED(hrc)) return hrc;
    434433        for (size_t a = 0; a < sfaAttachments.size(); ++a)
    435434        {
    436435            const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
    437436            DeviceType_T type;
    438             rc = pAtt->COMGETTER(Type)(&type);
    439             if (FAILED(rc)) return rc;
     437            hrc = pAtt->COMGETTER(Type)(&type);
     438            if (FAILED(hrc)) return hrc;
    440439
    441440            /* Only harddisks and floppies are of interest. */
     
    446445            /* Valid medium attached? */
    447446            ComPtr<IMedium> pSrcMedium;
    448             rc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
    449             if (FAILED(rc)) return rc;
     447            hrc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
     448            if (FAILED(hrc)) return hrc;
    450449
    451450            if (pSrcMedium.isNull())
     
    464463                /* Refresh the state so that the file size get read. */
    465464                MediumState_T e;
    466                 rc = pSrcMedium->RefreshState(&e);
    467                 if (FAILED(rc)) return rc;
     465                hrc = pSrcMedium->RefreshState(&e);
     466                if (FAILED(hrc)) return hrc;
    468467                LONG64 lSize;
    469                 rc = pSrcMedium->COMGETTER(Size)(&lSize);
    470                 if (FAILED(rc)) return rc;
     468                hrc = pSrcMedium->COMGETTER(Size)(&lSize);
     469                if (FAILED(hrc)) return hrc;
    471470
    472471                MEDIUMTASK mt;
     
    477476
    478477                /* Query next parent. */
    479                 rc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
    480                 if (FAILED(rc)) return rc;
     478                hrc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
     479                if (FAILED(hrc)) return hrc;
    481480            }
    482481
     
    484483        }
    485484        /* Add the save state file of this machine if there is one. */
    486         rc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
    487         if (FAILED(rc)) return rc;
     485        hrc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
     486        if (FAILED(hrc)) return hrc;
    488487        /* Add the NVRAM file of this machine if there is one. */
    489         rc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
    490         if (FAILED(rc)) return rc;
     488        hrc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
     489        if (FAILED(hrc)) return hrc;
    491490        /* If this is the newly created current state, make sure that the
    492491         * saved state and NVRAM is also attached to it. */
    493492        if (fCreateDiffs)
    494493        {
    495             rc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
    496             if (FAILED(rc)) return rc;
    497             rc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
    498             if (FAILED(rc)) return rc;
     494            hrc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
     495            if (FAILED(hrc)) return hrc;
     496            hrc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
     497            if (FAILED(hrc)) return hrc;
    499498        }
    500499    }
     
    515514    {
    516515        Bstr bstrSrcName;
    517         rc = (*it).first->COMGETTER(Name)(bstrSrcName.asOutParam());
    518         if (FAILED(rc)) return rc;
     516        hrc = (*it).first->COMGETTER(Name)(bstrSrcName.asOutParam());
     517        if (FAILED(hrc)) return hrc;
    519518        RTPrintf("%ls: %d\n", bstrSrcName.raw(), (*it).second);
    520519    }
     
    536535#ifdef DEBUG_poetzsch
    537536            Bstr bstrSrcName;
    538             rc = mt.pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
    539             if (FAILED(rc)) return rc;
     537            hrc = mt.pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
     538            if (FAILED(hrc)) return hrc;
    540539            RTPrintf("%ls: %d (%d)\n", bstrSrcName.raw(), hist, used);
    541540#endif
     
    552551         * if the base is a differencing image in the source VM (with the UUID
    553552         * as name). */
    554         rc = queryBaseName(newChain.last().pMedium, newChain.last().strBaseName);
    555         if (FAILED(rc)) return rc;
     553        hrc = queryBaseName(newChain.last().pMedium, newChain.last().strBaseName);
     554        if (FAILED(hrc)) return hrc;
    556555        /* Update the old medium chain with the updated one. */
    557556        mtc.chain = newChain;
     
    560559    }
    561560
    562     return rc;
     561    return hrc;
    563562}
    564563
     
    570569     * list. */
    571570    Assert(!fAttachLinked);
    572     HRESULT rc = S_OK;
     571    HRESULT hrc = S_OK;
    573572    for (size_t i = 0; i < machineList.size(); ++i)
    574573    {
     
    580579         * machines to a worker list. */
    581580        SafeIfaceArray<IMediumAttachment> sfaAttachments;
    582         rc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
    583         if (FAILED(rc)) return rc;
     581        hrc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
     582        if (FAILED(hrc)) return hrc;
    584583        for (size_t a = 0; a < sfaAttachments.size(); ++a)
    585584        {
    586585            const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
    587586            DeviceType_T type;
    588             rc = pAtt->COMGETTER(Type)(&type);
    589             if (FAILED(rc)) return rc;
     587            hrc = pAtt->COMGETTER(Type)(&type);
     588            if (FAILED(hrc)) return hrc;
    590589
    591590            /* Only harddisks and floppies are of interest. */
     
    596595            /* Valid medium attached? */
    597596            ComPtr<IMedium> pSrcMedium;
    598             rc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
    599             if (FAILED(rc)) return rc;
     597            hrc = pAtt->COMGETTER(Medium)(pSrcMedium.asOutParam());
     598            if (FAILED(hrc)) return hrc;
    600599
    601600            if (pSrcMedium.isNull())
     
    614613                /* Refresh the state so that the file size get read. */
    615614                MediumState_T e;
    616                 rc = pSrcMedium->RefreshState(&e);
    617                 if (FAILED(rc)) return rc;
     615                hrc = pSrcMedium->RefreshState(&e);
     616                if (FAILED(hrc)) return hrc;
    618617                LONG64 lSize;
    619                 rc = pSrcMedium->COMGETTER(Size)(&lSize);
    620                 if (FAILED(rc)) return rc;
     618                hrc = pSrcMedium->COMGETTER(Size)(&lSize);
     619                if (FAILED(hrc)) return hrc;
    621620
    622621                /* Save the current medium, for later cloning. */
     
    628627
    629628                /* Query next parent. */
    630                 rc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
    631                 if (FAILED(rc)) return rc;
     629                hrc = pSrcMedium->COMGETTER(Parent)(pSrcMedium.asOutParam());
     630                if (FAILED(hrc)) return hrc;
    632631            }
    633632            /* Update the progress info. */
     
    637636        }
    638637        /* Add the save state file of this machine if there is one. */
    639         rc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
    640         if (FAILED(rc)) return rc;
     638        hrc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
     639        if (FAILED(hrc)) return hrc;
    641640        /* Add the NVRAM file of this machine if there is one. */
    642         rc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
    643         if (FAILED(rc)) return rc;
     641        hrc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
     642        if (FAILED(hrc)) return hrc;
    644643        /* If this is the newly created current state, make sure that the
    645644         * saved state is also attached to it. */
    646645        if (fCreateDiffs)
    647646        {
    648             rc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
    649             if (FAILED(rc)) return rc;
    650             rc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
    651             if (FAILED(rc)) return rc;
     647            hrc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
     648            if (FAILED(hrc)) return hrc;
     649            hrc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
     650            if (FAILED(hrc)) return hrc;
    652651        }
    653652    }
     
    663662    }
    664663
    665     return rc;
     664    return hrc;
    666665}
    667666
     
    775774                                                        ComObjPtr<Medium> *ppDiff) const
    776775{
    777     HRESULT rc = S_OK;
     776    HRESULT hrc = S_OK;
    778777    try
    779778    {
     
    782781            AutoReadLock alock(pParent COMMA_LOCKVAL_SRC_POS);
    783782            Bstr bstrSrcId;
    784             rc = pParent->COMGETTER(Id)(bstrSrcId.asOutParam());
    785             if (FAILED(rc)) throw rc;
     783            hrc = pParent->COMGETTER(Id)(bstrSrcId.asOutParam());
     784            if (FAILED(hrc)) throw hrc;
    786785        }
    787786        ComObjPtr<Medium> diff;
    788787        diff.createObject();
    789         rc = diff->init(p->i_getVirtualBox(),
    790                         pParent->i_getPreferredDiffFormat(),
    791                         Utf8StrFmt("%s%c", strSnapshotFolder.c_str(), RTPATH_DELIMITER),
    792                                    Guid::Empty /* empty media registry */,
    793                                    DeviceType_HardDisk);
    794         if (FAILED(rc)) throw rc;
     788        hrc = diff->init(p->i_getVirtualBox(),
     789                         pParent->i_getPreferredDiffFormat(),
     790                         Utf8StrFmt("%s%c", strSnapshotFolder.c_str(), RTPATH_DELIMITER),
     791                                    Guid::Empty /* empty media registry */,
     792                                    DeviceType_HardDisk);
     793        if (FAILED(hrc)) throw hrc;
    795794
    796795        MediumLockList *pMediumLockList(new MediumLockList());
    797         rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
    798                                           diff /* pToLockWrite */,
    799                                           false /* fMediumLockWriteAll */,
    800                                           pParent,
    801                                           *pMediumLockList);
    802         if (FAILED(rc)) throw rc;
    803         rc = pMediumLockList->Lock();
    804         if (FAILED(rc)) throw rc;
     796        hrc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
     797                                           diff /* pToLockWrite */,
     798                                           false /* fMediumLockWriteAll */,
     799                                           pParent,
     800                                           *pMediumLockList);
     801        if (FAILED(hrc)) throw hrc;
     802        hrc = pMediumLockList->Lock();
     803        if (FAILED(hrc)) throw hrc;
    805804
    806805        /* this already registers the new diff image */
    807         rc = pParent->i_createDiffStorage(diff,
    808                                           pParent->i_getPreferredDiffVariant(),
    809                                           pMediumLockList,
    810                                           NULL /* aProgress */,
    811                                           true /* aWait */,
    812                                           false /* aNotify */);
     806        hrc = pParent->i_createDiffStorage(diff,
     807                                           pParent->i_getPreferredDiffVariant(),
     808                                           pMediumLockList,
     809                                           NULL /* aProgress */,
     810                                           true /* aWait */,
     811                                           false /* aNotify */);
    813812        delete pMediumLockList;
    814         if (FAILED(rc)) throw rc;
     813        if (FAILED(hrc)) throw hrc;
    815814        /* Remember created medium. */
    816815        newMedia.append(diff);
    817816        *ppDiff = diff;
    818817    }
    819     catch (HRESULT rc2)
    820     {
    821         rc = rc2;
     818    catch (HRESULT rcXcpt)
     819    {
     820        hrc = rcXcpt;
    822821    }
    823822    catch (...)
    824823    {
    825         rc = VirtualBoxBase::handleUnexpectedExceptions(pMachine, RT_SRC_POS);
    826     }
    827 
    828     return rc;
     824        hrc = VirtualBoxBase::handleUnexpectedExceptions(pMachine, RT_SRC_POS);
     825    }
     826
     827    return hrc;
    829828}
    830829
     
    835834
    836835    BOOL fCanceled = false;
    837     HRESULT rc = pProgress->COMGETTER(Canceled)(&fCanceled);
    838     if (FAILED(rc)) return VERR_GENERAL_FAILURE;
     836    HRESULT hrc = pProgress->COMGETTER(Canceled)(&fCanceled);
     837    if (FAILED(hrc)) return VERR_GENERAL_FAILURE;
    839838    /* If canceled by the user tell it to the copy operation. */
    840839    if (fCanceled) return VERR_CANCELLED;
    841840    /* Set the new process. */
    842     rc = pProgress->SetCurrentOperationProgress(uPercentage);
    843     if (FAILED(rc)) return VERR_GENERAL_FAILURE;
     841    hrc = pProgress->SetCurrentOperationProgress(uPercentage);
     842    if (FAILED(hrc)) return VERR_GENERAL_FAILURE;
    844843
    845844    return VINF_SUCCESS;
     
    877876    ComObjPtr<Machine> &p = d->p;
    878877
    879     HRESULT rc;
     878    HRESULT hrc;
    880879    try
    881880    {
     
    893892        {
    894893            Bstr bstrSrcMachineId;
    895             rc = d->pSrcMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
    896             if (FAILED(rc)) throw rc;
     894            hrc = d->pSrcMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
     895            if (FAILED(hrc)) throw hrc;
    897896            ComPtr<IMachine> newSrcMachine;
    898             rc = d->pSrcMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
    899             if (FAILED(rc)) throw rc;
     897            hrc = d->pSrcMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
     898            if (FAILED(hrc)) throw hrc;
    900899            d->pSrcMachine = (Machine*)(IMachine*)newSrcMachine;
    901900        }
     
    908907                /* find machine object for current snapshot of current state */
    909908                Bstr bstrSrcMachineId;
    910                 rc = d->pSrcMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
    911                 if (FAILED(rc)) throw rc;
     909                hrc = d->pSrcMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
     910                if (FAILED(hrc)) throw hrc;
    912911                ComPtr<IMachine> pCurr;
    913                 rc = d->pSrcMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), pCurr.asOutParam());
    914                 if (FAILED(rc)) throw rc;
     912                hrc = d->pSrcMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), pCurr.asOutParam());
     913                if (FAILED(hrc)) throw hrc;
    915914                if (pCurr.isNull())
    916915                    throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
    917916                pCurrState = (Machine *)(IMachine *)pCurr;
    918917                ComPtr<ISnapshot> pSnapshot;
    919                 rc = pCurrState->COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam());
    920                 if (FAILED(rc)) throw rc;
     918                hrc = pCurrState->COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam());
     919                if (FAILED(hrc)) throw hrc;
    921920                if (pSnapshot.isNull())
    922921                    throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
    923922                ComPtr<IMachine> pCurrSnapMachine;
    924                 rc = pSnapshot->COMGETTER(Machine)(pCurrSnapMachine.asOutParam());
    925                 if (FAILED(rc)) throw rc;
     923                hrc = pSnapshot->COMGETTER(Machine)(pCurrSnapMachine.asOutParam());
     924                if (FAILED(hrc)) throw hrc;
    926925                if (pCurrSnapMachine.isNull())
    927926                    throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
     
    932931                {
    933932                    ComPtr<IMachine> pSnapMachine;
    934                     rc = pSnapshot->COMGETTER(Machine)(pSnapMachine.asOutParam());
    935                     if (FAILED(rc)) throw rc;
     933                    hrc = pSnapshot->COMGETTER(Machine)(pSnapMachine.asOutParam());
     934                    if (FAILED(hrc)) throw hrc;
    936935                    if (pSnapMachine.isNull())
    937936                        throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
     
    941940                        break;
    942941                    }
    943                     rc = pSnapshot->COMGETTER(Parent)(pSnapshot.asOutParam());
    944                     if (FAILED(rc)) throw rc;
     942                    hrc = pSnapshot->COMGETTER(Parent)(pSnapshot.asOutParam());
     943                    if (FAILED(hrc)) throw hrc;
    945944                }
    946945            }
     
    972971        {
    973972            ULONG cSnapshots = 0;
    974             rc = d->pSrcMachine->COMGETTER(SnapshotCount)(&cSnapshots);
    975             if (FAILED(rc)) throw rc;
     973            hrc = d->pSrcMachine->COMGETTER(SnapshotCount)(&cSnapshots);
     974            if (FAILED(hrc)) throw hrc;
    976975            if (cSnapshots > 0)
    977976            {
     
    980979                    id = d->snapshotId.toString();
    981980                ComPtr<ISnapshot> pSnapshot;
    982                 rc = d->pSrcMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
    983                 if (FAILED(rc)) throw rc;
    984                 rc = d->createMachineList(pSnapshot, machineList);
    985                 if (FAILED(rc)) throw rc;
     981                hrc = d->pSrcMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
     982                if (FAILED(hrc)) throw hrc;
     983                hrc = d->createMachineList(pSnapshot, machineList);
     984                if (FAILED(hrc)) throw hrc;
    986985                if (d->mode == CloneMode_MachineAndChildStates)
    987986                {
     
    994993                    else
    995994                    {
    996                         rc = pSnapshot->COMGETTER(Machine)(d->pOldMachineState.asOutParam());
    997                         if (FAILED(rc)) throw rc;
     995                        hrc = pSnapshot->COMGETTER(Machine)(d->pOldMachineState.asOutParam());
     996                        if (FAILED(hrc)) throw hrc;
    998997                    }
    999998                }
     
    10431042
    10441043        /* Now create the progress project, so the user knows whats going on. */
    1045         rc = d->pProgress.createObject();
    1046         if (FAILED(rc)) throw rc;
    1047         rc = d->pProgress->init(p->i_getVirtualBox(),
    1048                                 static_cast<IMachine*>(d->pSrcMachine) /* aInitiator */,
    1049                                 Bstr(tr("Cloning Machine")).raw(),
    1050                                 true /* fCancellable */,
    1051                                 uCount,
    1052                                 uTotalWeight,
    1053                                 Bstr(tr("Initialize Cloning")).raw(),
    1054                                 1);
    1055         if (FAILED(rc)) throw rc;
     1044        hrc = d->pProgress.createObject();
     1045        if (FAILED(hrc)) throw hrc;
     1046        hrc = d->pProgress->init(p->i_getVirtualBox(),
     1047                                 static_cast<IMachine*>(d->pSrcMachine) /* aInitiator */,
     1048                                 Bstr(tr("Cloning Machine")).raw(),
     1049                                 true /* fCancellable */,
     1050                                 uCount,
     1051                                 uTotalWeight,
     1052                                 Bstr(tr("Initialize Cloning")).raw(),
     1053                                 1);
     1054        if (FAILED(hrc)) throw hrc;
    10561055
    10571056        int vrc = d->startWorker();
     
    10601059            p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create machine clone thread (%Rrc)"), vrc);
    10611060    }
    1062     catch (HRESULT rc2)
    1063     {
    1064         rc = rc2;
    1065     }
    1066 
    1067     if (SUCCEEDED(rc))
     1061    catch (HRESULT hrcXcpt)
     1062    {
     1063        hrc = hrcXcpt;
     1064    }
     1065
     1066    if (SUCCEEDED(hrc))
    10681067        d->pProgress.queryInterfaceTo(pProgress);
    10691068
    1070     return rc;
     1069    return hrc;
    10711070}
    10721071
     
    10821081    AutoWriteLock trgLock(d->pTrgMachine COMMA_LOCKVAL_SRC_POS);
    10831082
    1084     HRESULT rc = S_OK;
     1083    HRESULT hrc = S_OK;
    10851084
    10861085    /*
     
    11741173
    11751174        Bstr bstrSrcSnapshotFolder;
    1176         rc = d->pSrcMachine->COMGETTER(SnapshotFolder)(bstrSrcSnapshotFolder.asOutParam());
    1177         if (FAILED(rc)) throw rc;
     1175        hrc = d->pSrcMachine->COMGETTER(SnapshotFolder)(bstrSrcSnapshotFolder.asOutParam());
     1176        if (FAILED(hrc)) throw hrc;
    11781177        /* The absolute name of the snapshot folder. */
    1179         strTrgSnapshotFolder = Utf8StrFmt("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER,
    1180                                           trgMCF.machineUserData.strSnapshotFolder.c_str());
     1178        strTrgSnapshotFolder.printf("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER,
     1179                                    trgMCF.machineUserData.strSnapshotFolder.c_str());
    11811180
    11821181        /* Should we rename the disk names. */
     
    12031202
    12041203                Bstr bstrSrcName;
    1205                 rc = pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
    1206                 if (FAILED(rc)) throw rc;
    1207 
    1208                 rc = d->pProgress->SetNextOperation(BstrFmt(tr("Cloning Disk '%ls' ..."), bstrSrcName.raw()).raw(),
    1209                                                     mt.uWeight);
    1210                 if (FAILED(rc)) throw rc;
     1204                hrc = pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
     1205                if (FAILED(hrc)) throw hrc;
     1206
     1207                hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Cloning Disk '%ls' ..."), bstrSrcName.raw()).raw(), mt.uWeight);
     1208                if (FAILED(hrc)) throw hrc;
    12111209
    12121210                Bstr bstrSrcId;
    1213                 rc = pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
    1214                 if (FAILED(rc)) throw rc;
     1211                hrc = pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
     1212                if (FAILED(hrc)) throw hrc;
    12151213
    12161214                if (mtc.fAttachLinked)
     
    12271225                        trgLock.release();
    12281226                        srcLock.release();
    1229                         rc = d->createDifferencingMedium(p, pLMedium, strTrgSnapshotFolder,
     1227                        hrc = d->createDifferencingMedium(p, pLMedium, strTrgSnapshotFolder,
    12301228                                                         newMedia, &pDiff);
    12311229                        srcLock.acquire();
    12321230                        trgLock.acquire();
    1233                         if (FAILED(rc)) throw rc;
     1231                        if (FAILED(hrc)) throw hrc;
    12341232                        map.insert(TStrMediumPair(Utf8Str(bstrSrcId), pDiff));
    12351233                        /* diff image has to be used... */
     
    12561254                    {
    12571255                        ComPtr<IMediumFormat> pSrcFormat;
    1258                         rc = pMedium->COMGETTER(MediumFormat)(pSrcFormat.asOutParam());
     1256                        hrc = pMedium->COMGETTER(MediumFormat)(pSrcFormat.asOutParam());
    12591257                        ULONG uSrcCaps = 0;
    12601258                        com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
    1261                         rc = pSrcFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
    1262 
    1263                         if (FAILED(rc)) throw rc;
     1259                        hrc = pSrcFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
     1260
     1261                        if (FAILED(hrc)) throw hrc;
    12641262                        else
    12651263                        {
     
    12851283                            /* Yes, just use the source format. Otherwise the defaults
    12861284                             * will be used. */
    1287                             rc = pMedium->COMGETTER(Format)(bstrSrcFormat.asOutParam());
    1288                             if (FAILED(rc)) throw rc;
    1289 
    1290                             rc = pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(mediumVariant));
    1291                             if (FAILED(rc)) throw rc;
     1285                            hrc = pMedium->COMGETTER(Format)(bstrSrcFormat.asOutParam());
     1286                            if (FAILED(hrc)) throw hrc;
     1287
     1288                            hrc = pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(mediumVariant));
     1289                            if (FAILED(hrc)) throw hrc;
    12921290                            else
    12931291                            {
     
    13361334                        Bstr bstrSrcPath;
    13371335                        Utf8Str strFile = Utf8StrFmt("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER, strNewName.c_str());
    1338                         rc = pMedium->COMGETTER(Location)(bstrSrcPath.asOutParam());
    1339                         if (FAILED(rc)) throw rc;
     1336                        hrc = pMedium->COMGETTER(Location)(bstrSrcPath.asOutParam());
     1337                        if (FAILED(hrc)) throw hrc;
    13401338                        if (   !bstrSrcPath.isEmpty()
    13411339                            &&  RTPathStartsWith(Utf8Str(bstrSrcPath).c_str(), Utf8Str(bstrSrcSnapshotFolder).c_str())
     
    13451343                        /* Start creating the clone. */
    13461344                        ComObjPtr<Medium> pTarget;
    1347                         rc = pTarget.createObject();
    1348                         if (FAILED(rc)) throw rc;
    1349 
    1350                         rc = pTarget->init(p->mParent,
    1351                                            Utf8Str(bstrSrcFormat),
    1352                                            strFile,
    1353                                            Guid::Empty /* empty media registry */,
    1354                                            mtc.devType);
    1355                         if (FAILED(rc)) throw rc;
     1345                        hrc = pTarget.createObject();
     1346                        if (FAILED(hrc)) throw hrc;
     1347
     1348                        hrc = pTarget->init(p->mParent, Utf8Str(bstrSrcFormat), strFile,
     1349                                            Guid::Empty /* empty media registry */, mtc.devType);
     1350                        if (FAILED(hrc)) throw hrc;
    13561351
    13571352                        /* Update the new uuid. */
     
    13631358                        ComObjPtr<Medium> pLMedium = static_cast<Medium*>((IMedium*)pMedium);
    13641359                        srcLock.release();
    1365                         rc = pLMedium->i_cloneToEx(pTarget,
    1366                                                    (MediumVariant_T)srcVar,
    1367                                                    pNewParent,
    1368                                                    progress2.asOutParam(),
    1369                                                    uSrcParentIdx,
    1370                                                    uTrgParentIdx,
    1371                                                    false /* aNotify */);
     1360                        hrc = pLMedium->i_cloneToEx(pTarget,
     1361                                                    (MediumVariant_T)srcVar,
     1362                                                    pNewParent,
     1363                                                    progress2.asOutParam(),
     1364                                                    uSrcParentIdx,
     1365                                                    uTrgParentIdx,
     1366                                                    false /* aNotify */);
    13721367                        srcLock.acquire();
    1373                         if (FAILED(rc)) throw rc;
     1368                        if (FAILED(hrc)) throw hrc;
    13741369
    13751370                        /* Wait until the async process has finished. */
    13761371                        srcLock.release();
    1377                         rc = d->pProgress->WaitForOtherProgressCompletion(progress2, 0 /* indefinite wait */);
     1372                        hrc = d->pProgress->WaitForOtherProgressCompletion(progress2, 0 /* indefinite wait */);
    13781373                        srcLock.acquire();
    1379                         if (FAILED(rc)) throw rc;
     1374                        if (FAILED(hrc)) throw hrc;
    13801375
    13811376                        /* Remember created medium. */
     
    13841379                         * new medium. */
    13851380                        MediumType_T type;
    1386                         rc = pMedium->COMGETTER(Type)(&type);
    1387                         if (FAILED(rc)) throw rc;
     1381                        hrc = pMedium->COMGETTER(Type)(&type);
     1382                        if (FAILED(hrc)) throw hrc;
    13881383                        trgLock.release();
    13891384                        srcLock.release();
    1390                         rc = pTarget->COMSETTER(Type)(type);
     1385                        hrc = pTarget->COMSETTER(Type)(type);
    13911386                        srcLock.acquire();
    13921387                        trgLock.acquire();
    1393                         if (FAILED(rc)) throw rc;
     1388                        if (FAILED(hrc)) throw hrc;
    13941389                        map.insert(TStrMediumPair(Utf8Str(bstrSrcId), pTarget));
    13951390                        /* register the new medium */
    13961391                        {
    13971392                            AutoWriteLock tlock(p->mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    1398                             rc = p->mParent->i_registerMedium(pTarget, &pTarget,
    1399                                                               tlock);
    1400                             if (FAILED(rc)) throw rc;
     1393                            hrc = p->mParent->i_registerMedium(pTarget, &pTarget, tlock);
     1394                            if (FAILED(hrc)) throw hrc;
    14011395                        }
    14021396                        /* This medium becomes the parent of the next medium in the
     
    14141408
    14151409            Bstr bstrSrcId;
    1416             rc = mtc.chain.first().pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
    1417             if (FAILED(rc)) throw rc;
     1410            hrc = mtc.chain.first().pMedium->COMGETTER(Id)(bstrSrcId.asOutParam());
     1411            if (FAILED(hrc)) throw hrc;
    14181412            Bstr bstrTrgId;
    1419             rc = pNewParent->COMGETTER(Id)(bstrTrgId.asOutParam());
    1420             if (FAILED(rc)) throw rc;
     1413            hrc = pNewParent->COMGETTER(Id)(bstrTrgId.asOutParam());
     1414            if (FAILED(hrc)) throw hrc;
    14211415            /* update snapshot configuration */
    14221416            d->updateSnapshotStorageLists(trgMCF.llFirstSnapshot, bstrSrcId, bstrTrgId);
     
    14351429                    trgLock.release();
    14361430                    srcLock.release();
    1437                     rc = d->createDifferencingMedium(p, pNewParent, strTrgSnapshotFolder,
    1438                                                      newMedia, &pDiff);
     1431                    hrc = d->createDifferencingMedium(p, pNewParent, strTrgSnapshotFolder, newMedia, &pDiff);
    14391432                    srcLock.acquire();
    14401433                    trgLock.acquire();
    1441                     if (FAILED(rc)) throw rc;
     1434                    if (FAILED(hrc)) throw hrc;
    14421435                    /* diff image has to be used... */
    14431436                    pNewParent = pDiff;
     
    14521445                }
    14531446
    1454                 rc = pNewParent->COMGETTER(Id)(bstrTrgId.asOutParam());
    1455                 if (FAILED(rc)) throw rc;
     1447                hrc = pNewParent->COMGETTER(Id)(bstrTrgId.asOutParam());
     1448                if (FAILED(hrc)) throw hrc;
    14561449            }
    14571450            /* update 'Current State' configuration */
     
    15111504
    15121505            /* Move to next sub-operation. */
    1513             rc = d->pProgress->SetNextOperation(BstrFmt(tr("Copy save state file '%s' ..."),
    1514                                                         RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
    1515             if (FAILED(rc)) throw rc;
     1506            hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Copy save state file '%s' ..."),
     1507                                                         RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
     1508            if (FAILED(hrc)) throw hrc;
    15161509            /* Copy the file only if it was not copied already. */
    15171510            if (!newFiles.contains(strTrgSaveState.c_str()))
     
    15461539
    15471540            /* Move to next sub-operation. */
    1548             rc = d->pProgress->SetNextOperation(BstrFmt(tr("Copy NVRAM file '%s' ..."),
    1549                                                         RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
    1550             if (FAILED(rc)) throw rc;
     1541            hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Copy NVRAM file '%s' ..."),
     1542                                                         RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
     1543            if (FAILED(hrc)) throw hrc;
    15511544            /* Copy the file only if it was not copied already. */
    15521545            if (!newFiles.contains(strTrgNVRAM.c_str()))
    15531546            {
    1554                 rc = p->i_getVirtualBox()->i_ensureFilePathExists(strTrgNVRAM.c_str(), true);
    1555                 if (FAILED(rc)) throw rc;
     1547                hrc = p->i_getVirtualBox()->i_ensureFilePathExists(strTrgNVRAM.c_str(), true);
     1548                if (FAILED(hrc)) throw hrc;
    15561549                int vrc = RTFileCopyEx(fct.strFile.c_str(), strTrgNVRAM.c_str(), 0,
    15571550                                       MachineCloneVMPrivate::copyFileProgress, &d->pProgress);
     
    15711564
    15721565        {
    1573             rc = d->pProgress->SetNextOperation(BstrFmt(tr("Create Machine Clone '%s' ..."),
    1574                                                 trgMCF.machineUserData.strName.c_str()).raw(), 1);
    1575             if (FAILED(rc)) throw rc;
     1566            hrc = d->pProgress->SetNextOperation(BstrFmt(tr("Create Machine Clone '%s' ..."),
     1567                                                 trgMCF.machineUserData.strName.c_str()).raw(), 1);
     1568            if (FAILED(hrc)) throw hrc;
    15761569            /* After modifying the new machine config, we can copy the stuff
    15771570             * over to the new machine. The machine have to be mutable for
    15781571             * this. */
    1579             rc = d->pTrgMachine->i_checkStateDependency(p->MutableStateDep);
    1580             if (FAILED(rc)) throw rc;
    1581             rc = d->pTrgMachine->i_loadMachineDataFromSettings(trgMCF, &d->pTrgMachine->mData->mUuid);
    1582             if (FAILED(rc)) throw rc;
     1572            hrc = d->pTrgMachine->i_checkStateDependency(p->MutableStateDep);
     1573            if (FAILED(hrc)) throw hrc;
     1574            hrc = d->pTrgMachine->i_loadMachineDataFromSettings(trgMCF, &d->pTrgMachine->mData->mUuid);
     1575            if (FAILED(hrc)) throw hrc;
    15831576
    15841577            /* Fix up the "current state modified" flag to what it should be,
     
    16101603            /* save all VM data */
    16111604            bool fNeedsGlobalSaveSettings = false;
    1612             rc = d->pTrgMachine->i_saveSettings(&fNeedsGlobalSaveSettings, trgLock, Machine::SaveS_Force);
    1613             if (FAILED(rc)) throw rc;
     1605            hrc = d->pTrgMachine->i_saveSettings(&fNeedsGlobalSaveSettings, trgLock, Machine::SaveS_Force);
     1606            if (FAILED(hrc)) throw hrc;
    16141607            /* Release all locks */
    16151608            trgLock.release();
     
    16201613                 * VirtualBox lock */
    16211614                AutoWriteLock vlock(p->mParent COMMA_LOCKVAL_SRC_POS);
    1622                 rc = p->mParent->i_saveSettings();
    1623                 if (FAILED(rc)) throw rc;
     1615                hrc = p->mParent->i_saveSettings();
     1616                if (FAILED(hrc)) throw hrc;
    16241617            }
    16251618        }
     
    16281621        p->mParent->i_saveModifiedRegistries();
    16291622    }
    1630     catch (HRESULT rc2)
     1623    catch (HRESULT hrcXctp)
    16311624    {
    16321625        /* Error handling code only works correctly without locks held. */
    16331626        trgLock.release();
    16341627        srcLock.release();
    1635         rc = rc2;
     1628        hrc = hrcXctp;
    16361629    }
    16371630    catch (...)
    16381631    {
    1639         rc = VirtualBoxBase::handleUnexpectedExceptions(p, RT_SRC_POS);
    1640     }
    1641 
    1642     MultiResult mrc(rc);
     1632        hrc = VirtualBoxBase::handleUnexpectedExceptions(p, RT_SRC_POS);
     1633    }
     1634
     1635    MultiResult mrc(hrc);
    16431636    /* Cleanup on failure (CANCEL also) */
    1644     if (FAILED(rc))
     1637    if (FAILED(hrc))
    16451638    {
    16461639        int vrc = VINF_SUCCESS;
  • trunk/src/VBox/Main/src-server/darwin/HostDnsServiceDarwin.cpp

    r98103 r98288  
    9090        return E_OUTOFMEMORY;
    9191
    92     int rc = RTSemEventCreate(&m->m_evtStop);
    93     AssertRCReturn(rc, E_FAIL);
     92    int vrc = RTSemEventCreate(&m->m_evtStop);
     93    AssertRCReturn(vrc, E_FAIL);
    9494
    9595    CFRunLoopSourceContext sctx;
     
    158158
    159159    /* Trigger initial update. */
    160     int rc = updateInfo();
    161     AssertRC(rc); /* Not fatal in release builds. */  /** @todo r=bird: The function always returns VINF_SUCCESS. */
     160    int vrc = updateInfo();
     161    AssertRC(vrc); /* Not fatal in release builds. */  /** @todo r=bird: The function always returns VINF_SUCCESS. */
    162162
    163163    while (!ASMAtomicReadBool(&m->m_fStop))
  • trunk/src/VBox/Main/src-server/darwin/HostPowerDarwin.cpp

    r98103 r98288  
    4747{
    4848    /* Create the new worker thread. */
    49     int rc = RTThreadCreate(&mThread, HostPowerServiceDarwin::powerChangeNotificationThread, this, 65536,
    50                             RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "MainPower");
    51 
    52     if (RT_FAILURE(rc))
    53         LogFlow(("RTThreadCreate failed with %Rrc\n", rc));
     49    int vrc = RTThreadCreate(&mThread, HostPowerServiceDarwin::powerChangeNotificationThread, this, 65536,
     50                             RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "MainPower");
     51    AssertLogRelRC(vrc);
    5452}
    5553
  • trunk/src/VBox/Main/src-server/darwin/NetIf-darwin.cpp

    r98103 r98288  
    7474    }
    7575    struct ifaddrs *IfAddrs, *pAddr;
    76     int rc = getifaddrs(&IfAddrs);
    77     if (rc)
     76    int iRc = getifaddrs(&IfAddrs);
     77    if (iRc)
    7878    {
    7979        close(sock);
    80         Log(("NetIfList: getifaddrs() -> %d\n", rc));
     80        Log(("NetIfList: getifaddrs() -> %d\n", iRc));
    8181        return VERR_INTERNAL_ERROR;
    8282    }
     
    253253            Log(("getDefaultIfaceIndex: Got message %u while expecting %u.\n",
    254254                 pRtMsg->rtm_type, RTM_GET));
    255             //rc = VERR_INTERNAL_ERROR;
     255            //vrc = VERR_INTERNAL_ERROR;
    256256            continue;
    257257        }
     
    286286int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
    287287{
    288     int rc = VINF_SUCCESS;
     288    int vrc = VINF_SUCCESS;
    289289    size_t cbNeeded;
    290290    char *pBuf, *pNext;
     
    293293
    294294    /* Get the index of the interface associated with default route. */
    295     rc = getDefaultIfaceIndex(&u16DefaultIface);
    296     if (RT_FAILURE(rc))
    297         return rc;
     295    vrc = getDefaultIfaceIndex(&u16DefaultIface);
     296    if (RT_FAILURE(vrc))
     297        return vrc;
    298298
    299299    aiMib[0] = CTL_NET;
     
    338338            Log(("NetIfList: Got message %u while expecting %u.\n",
    339339                 pIfMsg->ifm_type, RTM_IFINFO));
    340             rc = VERR_INTERNAL_ERROR;
     340            vrc = VERR_INTERNAL_ERROR;
    341341            break;
    342342        }
     
    355355        if (!pNew)
    356356        {
    357             rc = VERR_NO_MEMORY;
     357            vrc = VERR_NO_MEMORY;
    358358            break;
    359359        }
     
    439439    close(sock);
    440440    RTMemFree(pBuf);
    441     return rc;
     441    return vrc;
    442442}
    443443
    444444int NetIfGetConfigByName(PNETIFINFO pInfo)
    445445{
    446     int rc = VINF_SUCCESS;
     446    int vrc = VINF_SUCCESS;
    447447    size_t cbNeeded;
    448448    char *pBuf, *pNext;
     
    487487            Log(("NetIfList: Got message %u while expecting %u.\n",
    488488                 pIfMsg->ifm_type, RTM_IFINFO));
    489             rc = VERR_INTERNAL_ERROR;
     489            vrc = VERR_INTERNAL_ERROR;
    490490            break;
    491491        }
     
    539539    close(sock);
    540540    RTMemFree(pBuf);
    541     return rc;
     541    return vrc;
    542542}
    543543
  • trunk/src/VBox/Main/src-server/darwin/PerformanceDarwin.cpp

    r98103 r98288  
    8888{
    8989    uint64_t cb;
    90     int rc = RTSystemQueryTotalRam(&cb);
    91     if (RT_FAILURE(rc))
     90    int vrc = RTSystemQueryTotalRam(&cb);
     91    if (RT_FAILURE(vrc))
    9292        totalRAM = 0;
    9393    else
     
    128128    AssertReturn(totalRAM, VERR_INTERNAL_ERROR);
    129129    uint64_t cb;
    130     int rc = RTSystemQueryAvailableRam(&cb);
    131     if (RT_SUCCESS(rc))
     130    int vrc = RTSystemQueryAvailableRam(&cb);
     131    if (RT_SUCCESS(vrc))
    132132    {
    133133        *total = totalRAM;
     
    136136        *used = *total - *available;
    137137    }
    138     return rc;
     138    return vrc;
    139139}
    140140
     
    161161    struct proc_taskinfo tinfo;
    162162
    163     int rc = getProcessInfo(process, &tinfo);
    164     if (RT_SUCCESS(rc))
     163    int vrc = getProcessInfo(process, &tinfo);
     164    if (RT_SUCCESS(vrc))
    165165    {
    166166        /*
     
    172172        *total = mach_absolute_time();
    173173    }
    174     return rc;
     174    return vrc;
    175175}
    176176
     
    179179    struct proc_taskinfo tinfo;
    180180
    181     int rc = getProcessInfo(process, &tinfo);
    182     if (RT_SUCCESS(rc))
     181    int vrc = getProcessInfo(process, &tinfo);
     182    if (RT_SUCCESS(vrc))
    183183    {
    184184        uint64_t cKbResident = tinfo.pti_resident_size / 1024;
    185185        *used = cKbResident < ~(ULONG)0 ? (ULONG)cKbResident : ~(ULONG)0;
    186186    }
    187     return rc;
     187    return vrc;
    188188}
    189189
  • trunk/src/VBox/Main/src-server/darwin/iokit.cpp

    r98287 r98288  
    836836     */
    837837    io_iterator_t USBDevices = IO_OBJECT_NULL;
    838     IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
    839     AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), KERN_FAILURE);
     838    IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
     839    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), KERN_FAILURE);
    840840    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
    841841
     
    10871087     */
    10881088    io_iterator_t USBDevices = IO_OBJECT_NULL;
    1089     IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
    1090     AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
     1089    IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
     1090    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), NULL);
    10911091    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
    10921092
     
    11881188                SInt32 Score = 0;
    11891189                IOCFPlugInInterface **ppPlugInInterface = NULL;
    1190                 rc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
    1191                                                        kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
    1192                 if (rc == kIOReturnSuccess)
     1190                irc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
     1191                                                        kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
     1192                if (irc == kIOReturnSuccess)
    11931193                {
    11941194                    IOUSBDeviceInterface245 **ppUSBDevI = NULL;
     
    11961196                                                                       CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245),
    11971197                                                                       (LPVOID *)&ppUSBDevI);
    1198                     rc = IODestroyPlugInInterface(ppPlugInInterface); Assert(rc == kIOReturnSuccess);
     1198                    irc = IODestroyPlugInInterface(ppPlugInInterface); Assert(irc == kIOReturnSuccess);
    11991199                    ppPlugInInterface = NULL;
    12001200                    if (hrc == S_OK)
     
    13161316     */
    13171317    io_iterator_t DVDServices = IO_OBJECT_NULL;
    1318     IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &DVDServices);
    1319     AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
     1318    IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &DVDServices);
     1319    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), NULL);
    13201320    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
    13211321
     
    14471447     */
    14481448    io_iterator_t MediaServices = IO_OBJECT_NULL;
    1449     IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &MediaServices);
    1450     AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
     1449    IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &MediaServices);
     1450    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), NULL);
    14511451    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
    14521452
     
    16121612     */
    16131613    io_iterator_t EtherIfServices = IO_OBJECT_NULL;
    1614     IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &EtherIfServices);
    1615     AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
     1614    IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &EtherIfServices);
     1615    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), NULL);
    16161616    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
    16171617
  • trunk/src/VBox/Main/src-server/freebsd/HostHardwareFreeBSD.cpp

    r98103 r98288  
    126126{
    127127    LogFlowThisFunc(("entered\n"));
    128     int rc;
     128    int vrc;
    129129    try
    130130    {
     
    133133         * environment variable. */
    134134        bool fSuccess = false;  /* Have we succeeded in finding anything yet? */
    135         rc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */, &fSuccess);
    136         if (RT_SUCCESS(rc) && !fSuccess)
    137             rc = getDriveInfoFromCAM(&mDVDList, DVD, &fSuccess);
     135        vrc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */, &fSuccess);
     136        if (RT_SUCCESS(vrc) && !fSuccess)
     137            vrc = getDriveInfoFromCAM(&mDVDList, DVD, &fSuccess);
    138138    }
    139139    catch (std::bad_alloc &)
    140140    {
    141         rc = VERR_NO_MEMORY;
    142     }
    143     LogFlowThisFunc(("rc=%Rrc\n", rc));
    144     return rc;
     141        vrc = VERR_NO_MEMORY;
     142    }
     143    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
     144    return vrc;
    145145}
    146146
     
    148148{
    149149    LogFlowThisFunc(("entered\n"));
    150     int rc;
     150    int vrc;
    151151    try
    152152    {
     
    154154        mFloppyList.clear();
    155155        bool fSuccess = false;  /* ignored */
    156         rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */, &fSuccess);
     156        vrc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */, &fSuccess);
    157157    }
    158158    catch (std::bad_alloc &)
    159159    {
    160         rc = VERR_NO_MEMORY;
    161     }
    162     LogFlowThisFunc(("rc=%Rrc\n", rc));
    163     return rc;
     160        vrc = VERR_NO_MEMORY;
     161    }
     162    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
     163    return vrc;
    164164}
    165165
     
    167167{
    168168    LogFlowThisFunc(("entered\n"));
    169     int rc;
     169    int vrc;
    170170    try
    171171    {
    172172        mFixedDriveList.clear();
    173173        bool fSuccess = false;  /* ignored */
    174         rc = getDriveInfoFromCAM(&mFixedDriveList, Fixed, &fSuccess);
     174        vrc = getDriveInfoFromCAM(&mFixedDriveList, Fixed, &fSuccess);
    175175    }
    176176    catch (std::bad_alloc &)
    177177    {
    178         rc = VERR_NO_MEMORY;
    179     }
    180     LogFlowThisFunc(("rc=%Rrc\n", rc));
    181     return rc;
     178        vrc = VERR_NO_MEMORY;
     179    }
     180    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
     181    return vrc;
    182182}
    183183
     
    324324{
    325325    RTFILE hFileXpt = NIL_RTFILE;
    326     int rc = RTFileOpen(&hFileXpt, "/dev/xpt0", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    327     if (RT_SUCCESS(rc))
     326    int vrc = RTFileOpen(&hFileXpt, "/dev/xpt0", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
     327    if (RT_SUCCESS(vrc))
    328328    {
    329329        union ccb DeviceCCB;
     
    377377            do
    378378            {
    379                 rc = RTFileIoCtl(hFileXpt, CAMIOCOMMAND, &DeviceCCB, sizeof(union ccb), NULL);
    380                 if (RT_FAILURE(rc))
     379                vrc = RTFileIoCtl(hFileXpt, CAMIOCOMMAND, &DeviceCCB, sizeof(union ccb), NULL);
     380                if (RT_FAILURE(vrc))
    381381                {
    382                     Log(("Error while querying available CD/DVD devices rc=%Rrc\n", rc));
     382                    Log(("Error while querying available CD/DVD devices vrc=%Rrc\n", vrc));
    383383                    break;
    384384                }
     
    431431                        do
    432432                        {
    433                             rc = RTFileIoCtl(hFileXpt, CAMIOCOMMAND, &PeriphCCB, sizeof(union ccb), NULL);
    434                             if (RT_FAILURE(rc))
     433                            vrc = RTFileIoCtl(hFileXpt, CAMIOCOMMAND, &PeriphCCB, sizeof(union ccb), NULL);
     434                            if (RT_FAILURE(vrc))
    435435                            {
    436                                 Log(("Error while querying available periph devices rc=%Rrc\n", rc));
     436                                Log(("Error while querying available periph devices vrc=%Rrc\n", vrc));
    437437                                break;
    438438                            }
     
    479479                            {
    480480                                pList->clear();
    481                                 rc = VERR_NO_MEMORY;
     481                                vrc = VERR_NO_MEMORY;
    482482                                break;
    483483                            }
     
    489489            } while (   DeviceCCB.ccb_h.status == CAM_REQ_CMP
    490490                     && DeviceCCB.cdm.status == CAM_DEV_MATCH_MORE
    491                      && RT_SUCCESS(rc));
     491                     && RT_SUCCESS(vrc));
    492492
    493493            RTMemFree(paMatches);
    494494        }
    495495        else
    496             rc = VERR_NO_MEMORY;
     496            vrc = VERR_NO_MEMORY;
    497497
    498498        RTFileClose(hFileXpt);
    499499    }
    500500
    501     return rc;
     501    return vrc;
    502502}
    503503
     
    524524    AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
    525525    LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar, pList, isDVD, pfSuccess));
    526     int rc = VINF_SUCCESS;
     526    int vrc = VINF_SUCCESS;
    527527    bool success = false;
    528528    char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
     
    552552    catch (std::bad_alloc &)
    553553    {
    554         rc = VERR_NO_MEMORY;
     554        vrc = VERR_NO_MEMORY;
    555555    }
    556556    RTStrFree(pszFreeMe);
    557     LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
    558     return rc;
    559 }
    560 
     557    LogFlowFunc(("vrc=%Rrc, success=%d\n", vrc, success));
     558    return vrc;
     559}
     560
  • trunk/src/VBox/Main/src-server/freebsd/NetIf-freebsd.cpp

    r98103 r98288  
    124124            Log(("getDefaultIfaceIndex: Got message %u while expecting %u.\n",
    125125                 pRtMsg->rtm_type, RTM_GET));
    126             //rc = VERR_INTERNAL_ERROR;
     126            //vrc = VERR_INTERNAL_ERROR;
    127127            continue;
    128128        }
     
    212212int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
    213213{
    214     int rc = VINF_SUCCESS;
     214    int vrc = VINF_SUCCESS;
    215215    size_t cbNeeded;
    216216    char *pBuf, *pNext;
     
    220220
    221221    /* Get the index of the interface associated with default route. */
    222     rc = getDefaultIfaceIndex(&u16DefaultIface, PF_INET);
    223     if (RT_FAILURE(rc))
     222    vrc = getDefaultIfaceIndex(&u16DefaultIface, PF_INET);
     223    if (RT_FAILURE(vrc))
    224224    {
    225225        fDefaultIfaceExistent = false;
    226         rc = VINF_SUCCESS;
     226        vrc = VINF_SUCCESS;
    227227    }
    228228
     
    265265            Log(("NetIfList: Got message %u while expecting %u.\n",
    266266                 pIfMsg->ifm_type, RTM_IFINFO));
    267             rc = VERR_INTERNAL_ERROR;
     267            vrc = VERR_INTERNAL_ERROR;
    268268            break;
    269269        }
     
    274274        if (!pNew)
    275275        {
    276             rc = VERR_NO_MEMORY;
     276            vrc = VERR_NO_MEMORY;
    277277            break;
    278278        }
     
    342342    close(sock);
    343343    free(pBuf);
    344     return rc;
    345 
    346 
     344    return vrc;
    347345}
    348346
    349347int NetIfGetConfigByName(PNETIFINFO pInfo)
    350348{
    351     int rc = VINF_SUCCESS;
     349    int vrc = VINF_SUCCESS;
    352350    size_t cbNeeded;
    353351    char *pBuf, *pNext;
     
    392390            Log(("NetIfList: Got message %u while expecting %u.\n",
    393391                 pIfMsg->ifm_type, RTM_IFINFO));
    394             rc = VERR_INTERNAL_ERROR;
     392            vrc = VERR_INTERNAL_ERROR;
    395393            break;
    396394        }
     
    443441    close(sock);
    444442    free(pBuf);
    445     return rc;
     443    return vrc;
    446444}
    447445
  • trunk/src/VBox/Main/src-server/freebsd/PerformanceFreeBSD.cpp

    r98103 r98288  
    6969int CollectorFreeBSD::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
    7070{
    71     int rc = VINF_SUCCESS;
     71    int vrc = VINF_SUCCESS;
    7272    u_long cbMemPhys = 0;
    7373    u_int cPagesMemFree = 0;
     
    105105    }
    106106    else
    107         rc = VERR_NOT_SUPPORTED;
     107        vrc = VERR_NOT_SUPPORTED;
    108108
    109     return rc;
     109    return vrc;
    110110}
    111111
  • trunk/src/VBox/Main/src-server/freebsd/USBProxyBackendFreeBSD.cpp

    r98103 r98288  
    8888     * Create semaphore.
    8989     */
    90     int rc = RTSemEventCreate(&mNotifyEventSem);
    91     if (RT_FAILURE(rc))
    92         return rc;
     90    int vrc = RTSemEventCreate(&mNotifyEventSem);
     91    if (RT_FAILURE(vrc))
     92        return vrc;
    9393
    9494    /*
     
    222222    int iBus  = 0;
    223223    int iAddr = 1;
    224     int rc = VINF_SUCCESS;
     224    int vrc = VINF_SUCCESS;
    225225    char *pszDevicePath = NULL;
    226226    uint32_t PlugTime = 0;
     
    228228    for (;;)
    229229    {
    230         rc = RTStrAPrintf(&pszDevicePath, "/dev/%s%d.%d", USB_GENERIC_NAME, iBus, iAddr);
    231         if (RT_FAILURE(rc))
     230        vrc = RTStrAPrintf(&pszDevicePath, "/dev/%s%d.%d", USB_GENERIC_NAME, iBus, iAddr);
     231        if (RT_FAILURE(vrc))
    232232            break;
    233233
     
    260260        RT_ZERO(UsbDevInfo);
    261261
    262         rc = ioctl(FileUsb, USB_GET_DEVICEINFO, &UsbDevInfo);
    263         if (rc < 0)
     262        vrc = ioctl(FileUsb, USB_GET_DEVICEINFO, &UsbDevInfo);
     263        if (vrc < 0)
    264264        {
    265             LogFlowFunc((": Error querying device info rc=%Rrc\n", RTErrConvertFromErrno(errno)));
     265            LogFlowFunc((": Error querying device info vrc=%Rrc\n", RTErrConvertFromErrno(errno)));
    266266            close(FileUsb);
    267267            RTStrFree(pszDevicePath);
     
    331331                pDevice->u64SerialHash = USBLibHashSerial(UsbDevInfo.udi_serial);
    332332            }
    333             rc = ioctl(FileUsb, USB_GET_PLUGTIME, &PlugTime);
    334             if (rc == 0)
     333            vrc = ioctl(FileUsb, USB_GET_PLUGTIME, &PlugTime);
     334            if (vrc == 0)
    335335                pDevice->u64SerialHash  += PlugTime;
    336336
  • trunk/src/VBox/Main/src-server/generic/AutostartDb-generic.cpp

    r98103 r98288  
    4747int AutostartDb::autostartModifyDb(bool fAutostart, bool fAddVM)
    4848{
    49     int rc = VINF_SUCCESS;
     49    int vrc = VINF_SUCCESS;
    5050    char *pszUser = NULL;
    5151
     
    5454        return VERR_PATH_NOT_FOUND;
    5555
    56     rc = RTProcQueryUsernameA(RTProcSelf(), &pszUser);
    57     if (RT_SUCCESS(rc))
     56    vrc = RTProcQueryUsernameA(RTProcSelf(), &pszUser);
     57    if (RT_SUCCESS(vrc))
    5858    {
    5959        char *pszFile;
     
    6868            fOpen |= RTFILE_O_OPEN;
    6969
    70         rc = RTStrAPrintf(&pszFile, "%s/%s.%s",
    71                           m_pszAutostartDbPath, pszUser, fAutostart ? "start" : "stop");
    72         if (RT_SUCCESS(rc))
     70        vrc = RTStrAPrintf(&pszFile, "%s/%s.%s", m_pszAutostartDbPath, pszUser, fAutostart ? "start" : "stop");
     71        if (RT_SUCCESS(vrc))
    7372        {
    74             rc = RTFileOpen(&hAutostartFile, pszFile, fOpen);
    75             if (RT_SUCCESS(rc))
     73            vrc = RTFileOpen(&hAutostartFile, pszFile, fOpen);
     74            if (RT_SUCCESS(vrc))
    7675            {
    7776                uint64_t cbFile;
     
    8281                 * should be really really small. Anything else is bogus.
    8382                 */
    84                 rc = RTFileQuerySize(hAutostartFile, &cbFile);
    85                 if (   RT_SUCCESS(rc)
     83                vrc = RTFileQuerySize(hAutostartFile, &cbFile);
     84                if (   RT_SUCCESS(vrc)
    8685                    && cbFile <= 16)
    8786                {
     
    9493                    if (cbFile)
    9594                    {
    96                         rc = RTFileRead(hAutostartFile, abBuf, (size_t)cbFile, NULL);
    97                         if (RT_SUCCESS(rc))
     95                        vrc = RTFileRead(hAutostartFile, abBuf, (size_t)cbFile, NULL);
     96                        if (RT_SUCCESS(vrc))
    9897                        {
    99                             rc = RTStrToUInt32Ex(abBuf, NULL, 10 /* uBase */, &cAutostartVms);
    100                             if (   rc == VWRN_TRAILING_CHARS
    101                                 || rc == VWRN_TRAILING_SPACES)
    102                                 rc = VINF_SUCCESS;
     98                            vrc = RTStrToUInt32Ex(abBuf, NULL, 10 /* uBase */, &cAutostartVms);
     99                            if (   vrc == VWRN_TRAILING_CHARS
     100                                || vrc == VWRN_TRAILING_SPACES)
     101                                vrc = VINF_SUCCESS;
    103102                        }
    104103                    }
    105104
    106                     if (RT_SUCCESS(rc))
     105                    if (RT_SUCCESS(vrc))
    107106                    {
    108107                        size_t cbBuf;
     
    117116                        {
    118117                            cbBuf = RTStrPrintf(abBuf, sizeof(abBuf), "%u", cAutostartVms);
    119                             rc = RTFileSetSize(hAutostartFile, cbBuf);
    120                             if (RT_SUCCESS(rc))
    121                                 rc = RTFileWriteAt(hAutostartFile, 0, abBuf, cbBuf, NULL);
     118                            vrc = RTFileSetSize(hAutostartFile, cbBuf);
     119                            if (RT_SUCCESS(vrc))
     120                                vrc = RTFileWriteAt(hAutostartFile, 0, abBuf, cbBuf, NULL);
    122121                        }
    123122                        else
     
    130129                    }
    131130                }
    132                 else if (RT_SUCCESS(rc))
    133                     rc = VERR_FILE_TOO_BIG;
     131                else if (RT_SUCCESS(vrc))
     132                    vrc = VERR_FILE_TOO_BIG;
    134133
    135134                if (hAutostartFile != NIL_RTFILE)
     
    142141    }
    143142
    144     return rc;
     143    return vrc;
    145144}
    146145
     
    150149{
    151150#ifdef RT_OS_LINUX
    152     int rc = RTCritSectInit(&this->CritSect);
    153     NOREF(rc);
     151    int vrc = RTCritSectInit(&this->CritSect);
     152    NOREF(vrc);
    154153    m_pszAutostartDbPath = NULL;
    155154#endif
     
    192191int AutostartDb::addAutostartVM(const char *pszVMId)
    193192{
    194     int rc = VERR_NOT_SUPPORTED;
    195 
    196 #if defined(RT_OS_LINUX)
    197     NOREF(pszVMId); /* Not needed */
    198 
    199     RTCritSectEnter(&this->CritSect);
    200     rc = autostartModifyDb(true /* fAutostart */, true /* fAddVM */);
     193    int vrc = VERR_NOT_SUPPORTED;
     194
     195#if defined(RT_OS_LINUX)
     196    NOREF(pszVMId); /* Not needed */
     197
     198    RTCritSectEnter(&this->CritSect);
     199    vrc = autostartModifyDb(true /* fAutostart */, true /* fAddVM */);
    201200    RTCritSectLeave(&this->CritSect);
    202201#elif defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_WINDOWS)
    203202    NOREF(pszVMId); /* Not needed */
    204     rc = VINF_SUCCESS;
    205 #else
    206     NOREF(pszVMId);
    207     rc = VERR_NOT_SUPPORTED;
    208 #endif
    209 
    210     return rc;
     203    vrc = VINF_SUCCESS;
     204#else
     205    NOREF(pszVMId);
     206    vrc = VERR_NOT_SUPPORTED;
     207#endif
     208
     209    return vrc;
    211210}
    212211
    213212int AutostartDb::removeAutostartVM(const char *pszVMId)
    214213{
    215     int rc = VINF_SUCCESS;
    216 
    217 #if defined(RT_OS_LINUX)
    218     NOREF(pszVMId); /* Not needed */
    219     RTCritSectEnter(&this->CritSect);
    220     rc = autostartModifyDb(true /* fAutostart */, false /* fAddVM */);
     214    int vrc = VINF_SUCCESS;
     215
     216#if defined(RT_OS_LINUX)
     217    NOREF(pszVMId); /* Not needed */
     218    RTCritSectEnter(&this->CritSect);
     219    vrc = autostartModifyDb(true /* fAutostart */, false /* fAddVM */);
    221220    RTCritSectLeave(&this->CritSect);
    222221#elif defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_WINDOWS)
    223222    NOREF(pszVMId); /* Not needed */
    224     rc = VINF_SUCCESS;
    225 #else
    226     NOREF(pszVMId);
    227     rc = VERR_NOT_SUPPORTED;
    228 #endif
    229 
    230     return rc;
     223    vrc = VINF_SUCCESS;
     224#else
     225    NOREF(pszVMId);
     226    vrc = VERR_NOT_SUPPORTED;
     227#endif
     228
     229    return vrc;
    231230}
    232231
    233232int AutostartDb::addAutostopVM(const char *pszVMId)
    234233{
    235     int rc = VINF_SUCCESS;
    236 
    237 #if defined(RT_OS_LINUX)
    238     NOREF(pszVMId); /* Not needed */
    239     RTCritSectEnter(&this->CritSect);
    240     rc = autostartModifyDb(false /* fAutostart */, true /* fAddVM */);
     234    int vrc = VINF_SUCCESS;
     235
     236#if defined(RT_OS_LINUX)
     237    NOREF(pszVMId); /* Not needed */
     238    RTCritSectEnter(&this->CritSect);
     239    vrc = autostartModifyDb(false /* fAutostart */, true /* fAddVM */);
    241240    RTCritSectLeave(&this->CritSect);
    242241#elif defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS)
    243242    NOREF(pszVMId); /* Not needed */
    244     rc = VINF_SUCCESS;
    245 #else
    246     NOREF(pszVMId);
    247     rc = VERR_NOT_SUPPORTED;
    248 #endif
    249 
    250     return rc;
     243    vrc = VINF_SUCCESS;
     244#else
     245    NOREF(pszVMId);
     246    vrc = VERR_NOT_SUPPORTED;
     247#endif
     248
     249    return vrc;
    251250}
    252251
    253252int AutostartDb::removeAutostopVM(const char *pszVMId)
    254253{
    255     int rc = VINF_SUCCESS;
    256 
    257 #if defined(RT_OS_LINUX)
    258     NOREF(pszVMId); /* Not needed */
    259     RTCritSectEnter(&this->CritSect);
    260     rc = autostartModifyDb(false /* fAutostart */, false /* fAddVM */);
     254    int vrc = VINF_SUCCESS;
     255
     256#if defined(RT_OS_LINUX)
     257    NOREF(pszVMId); /* Not needed */
     258    RTCritSectEnter(&this->CritSect);
     259    vrc = autostartModifyDb(false /* fAutostart */, false /* fAddVM */);
    261260    RTCritSectLeave(&this->CritSect);
    262261#elif defined(RT_OS_DARWIN) || defined (RT_OS_WINDOWS)
    263262    NOREF(pszVMId); /* Not needed */
    264     rc = VINF_SUCCESS;
    265 #else
    266     NOREF(pszVMId);
    267     rc = VERR_NOT_SUPPORTED;
    268 #endif
    269 
    270     return rc;
    271 }
    272 
     263    vrc = VINF_SUCCESS;
     264#else
     265    NOREF(pszVMId);
     266    vrc = VERR_NOT_SUPPORTED;
     267#endif
     268
     269    return vrc;
     270}
     271
  • trunk/src/VBox/Main/src-server/generic/NetIf-generic.cpp

    r98103 r98288  
    6363
    6464    char szAdpCtl[RTPATH_MAX];
    65     int rc = RTPathExecDir(szAdpCtl, sizeof(szAdpCtl) - sizeof("/" VBOXNETADPCTL_NAME));
    66     if (RT_FAILURE(rc))
    67     {
    68         LogRel(("NetIfAdpCtl: failed to get program path, rc=%Rrc.\n", rc));
    69         return rc;
     65    int vrc = RTPathExecDir(szAdpCtl, sizeof(szAdpCtl) - sizeof("/" VBOXNETADPCTL_NAME));
     66    if (RT_FAILURE(vrc))
     67    {
     68        LogRel(("NetIfAdpCtl: failed to get program path, vrc=%Rrc.\n", vrc));
     69        return vrc;
    7070    }
    7171    strcat(szAdpCtl, "/" VBOXNETADPCTL_NAME);
     
    7979
    8080    RTPROCESS pid;
    81     rc = RTProcCreate(szAdpCtl, args, RTENV_DEFAULT, 0, &pid);
    82     if (RT_SUCCESS(rc))
     81    vrc = RTProcCreate(szAdpCtl, args, RTENV_DEFAULT, 0, &pid);
     82    if (RT_SUCCESS(vrc))
    8383    {
    8484        RTPROCSTATUS Status;
    85         rc = RTProcWait(pid, 0, &Status);
    86         if (RT_SUCCESS(rc))
     85        vrc = RTProcWait(pid, 0, &Status);
     86        if (RT_SUCCESS(vrc))
    8787        {
    8888            if (   Status.iStatus == 0
     
    9191            LogRel(("NetIfAdpCtl: failed to create process for %s: iStats=%d enmReason=%d\n",
    9292                    szAdpCtl, Status.iStatus, Status.enmReason));
    93             rc = -Status.iStatus;
     93            vrc = -Status.iStatus;
    9494        }
    9595    }
    9696    else
    97         LogRel(("NetIfAdpCtl: failed to create process for %s: %Rrc\n", szAdpCtl, rc));
    98     return rc;
     97        LogRel(("NetIfAdpCtl: failed to create process for %s: %Rrc\n", szAdpCtl, vrc));
     98    return vrc;
    9999}
    100100
     
    110110{
    111111    char szAdpCtl[RTPATH_MAX];
    112     int rc = RTPathExecDir(szAdpCtl, sizeof(szAdpCtl) - sizeof("/" VBOXNETADPCTL_NAME " ") - strlen(pcszCmd));
    113     if (RT_FAILURE(rc))
    114     {
    115         LogRel(("NetIfAdpCtlOut: Failed to get program path, rc=%Rrc\n", rc));
     112    int vrc = RTPathExecDir(szAdpCtl, sizeof(szAdpCtl) - sizeof("/" VBOXNETADPCTL_NAME " ") - strlen(pcszCmd));
     113    if (RT_FAILURE(vrc))
     114    {
     115        LogRel(("NetIfAdpCtlOut: Failed to get program path, vrc=%Rrc\n", vrc));
    116116        return VERR_INVALID_PARAMETER;
    117117    }
     
    138138            {
    139139                LogRel(("NetIfAdpCtlOut: %s", pszBuffer));
    140                 rc = VERR_INTERNAL_ERROR;
     140                vrc = VERR_INTERNAL_ERROR;
    141141            }
    142142        }
     
    144144        {
    145145            LogRel(("NetIfAdpCtlOut: No output from " VBOXNETADPCTL_NAME));
    146             rc = VERR_INTERNAL_ERROR;
     146            vrc = VERR_INTERNAL_ERROR;
    147147        }
    148148        pclose(fp);
    149149    }
    150     return rc;
     150    return vrc;
    151151}
    152152
  • trunk/src/VBox/Main/src-server/generic/USBProxyBackendUsbIp.cpp

    r98103 r98288  
    297297                               const com::Utf8Str &strAddress, bool fLoadingSettings)
    298298{
    299     int rc = VINF_SUCCESS;
     299    int vrc = VINF_SUCCESS;
    300300
    301301    USBProxyBackend::init(pUsbProxyService, strId, strAddress, fLoadingSettings);
     
    322322
    323323    /* Setup wakeup pipe and poll set first. */
    324     rc = RTSemFastMutexCreate(&m->hMtxDevices);
    325     if (RT_SUCCESS(rc))
    326     {
    327         rc = RTPipeCreate(&m->hWakeupPipeR, &m->hWakeupPipeW, 0);
    328         if (RT_SUCCESS(rc))
    329         {
    330             rc = RTPollSetCreate(&m->hPollSet);
    331             if (RT_SUCCESS(rc))
     324    vrc = RTSemFastMutexCreate(&m->hMtxDevices);
     325    if (RT_SUCCESS(vrc))
     326    {
     327        vrc = RTPipeCreate(&m->hWakeupPipeR, &m->hWakeupPipeW, 0);
     328        if (RT_SUCCESS(vrc))
     329        {
     330            vrc = RTPollSetCreate(&m->hPollSet);
     331            if (RT_SUCCESS(vrc))
    332332            {
    333                 rc = RTPollSetAddPipe(m->hPollSet, m->hWakeupPipeR,
    334                                       RTPOLL_EVT_READ, USBIP_POLL_ID_PIPE);
    335                 if (RT_SUCCESS(rc))
     333                vrc = RTPollSetAddPipe(m->hPollSet, m->hWakeupPipeR, RTPOLL_EVT_READ, USBIP_POLL_ID_PIPE);
     334                if (RT_SUCCESS(vrc))
    336335                {
    337336                    /*
     
    344343                     * reachable.
    345344                     */
    346                     rc = reconnect();
    347                     if (RT_SUCCESS(rc) || fLoadingSettings)
    348                         rc = start(); /* Start service thread. */
     345                    vrc = reconnect();
     346                    if (RT_SUCCESS(vrc) || fLoadingSettings)
     347                        vrc = start(); /* Start service thread. */
    349348                }
    350349
    351                 if (RT_FAILURE(rc))
     350                if (RT_FAILURE(vrc))
    352351                {
    353352                    RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
     
    358357            }
    359358
    360             if (RT_FAILURE(rc))
     359            if (RT_FAILURE(vrc))
    361360            {
    362361                int rc2 = RTPipeClose(m->hWakeupPipeR);
     
    367366            }
    368367        }
    369         if (RT_FAILURE(rc))
     368        if (RT_FAILURE(vrc))
    370369        {
    371370            RTSemFastMutexDestroy(m->hMtxDevices);
     
    374373    }
    375374
    376     return rc;
     375    return vrc;
    377376}
    378377
     
    397396        disconnect();
    398397
    399         int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
    400         AssertRC(rc);
    401         rc = RTPollSetDestroy(m->hPollSet);
    402         AssertRC(rc);
    403         rc = RTPipeClose(m->hWakeupPipeR);
    404         AssertRC(rc);
    405         rc = RTPipeClose(m->hWakeupPipeW);
    406         AssertRC(rc);
     398        int vrc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
     399        AssertRC(vrc);
     400        vrc = RTPollSetDestroy(m->hPollSet);
     401        AssertRC(vrc);
     402        vrc = RTPipeClose(m->hWakeupPipeR);
     403        AssertRC(vrc);
     404        vrc = RTPipeClose(m->hWakeupPipeW);
     405        AssertRC(vrc);
    407406
    408407        m->hPollSet = NIL_RTPOLLSET;
     
    468467int USBProxyBackendUsbIp::wait(RTMSINTERVAL aMillies)
    469468{
    470     int rc = VINF_SUCCESS;
     469    int vrc = VINF_SUCCESS;
    471470    bool fDeviceListChangedOrWokenUp = false;
    472471
     
    483482        && m->enmRecvState == kUsbIpRecvState_None)
    484483    {
    485         rc = startListExportedDevicesReq();
    486         if (RT_FAILURE(rc))
     484        vrc = startListExportedDevicesReq();
     485        if (RT_FAILURE(vrc))
    487486            disconnect();
    488487    }
     
    496495    while (   !fDeviceListChangedOrWokenUp
    497496           && (aMillies == RT_INDEFINITE_WAIT || aMillies > 0)
    498            && RT_SUCCESS(rc))
     497           && RT_SUCCESS(vrc))
    499498    {
    500499        RTMSINTERVAL msWait = aMillies;
     
    507506            msWait = RT_MIN(3000, aMillies);
    508507
    509         rc = RTPoll(m->hPollSet, msWait, &fEventsRecv, &uIdReady);
    510         if (RT_SUCCESS(rc))
     508        vrc = RTPoll(m->hPollSet, msWait, &fEventsRecv, &uIdReady);
     509        if (RT_SUCCESS(vrc))
    511510        {
    512511            if (uIdReady == USBIP_POLL_ID_PIPE)
     
    516515                size_t cbRead = 0;
    517516
    518                 rc = RTPipeRead(m->hWakeupPipeR, &bRead, 1, &cbRead);
    519                 Assert(RT_SUCCESS(rc) && cbRead == 1);
     517                vrc = RTPipeRead(m->hWakeupPipeR, &bRead, 1, &cbRead);
     518                Assert(RT_SUCCESS(vrc) && cbRead == 1);
    520519                fDeviceListChangedOrWokenUp = true;
    521520            }
     
    523522            {
    524523                if (fEventsRecv & RTPOLL_EVT_READ)
    525                     rc = receiveData();
    526                 if (   RT_SUCCESS(rc)
     524                    vrc = receiveData();
     525                if (   RT_SUCCESS(vrc)
    527526                    && (fEventsRecv & RTPOLL_EVT_ERROR))
    528                     rc = VERR_NET_SHUTDOWN;
     527                    vrc = VERR_NET_SHUTDOWN;
    529528
    530529                /*
     
    549548
    550549                /* Current USB/IP server closes the connection after each request, don't abort but try again. */
    551                 if (rc == VERR_NET_SHUTDOWN || rc == VERR_BROKEN_PIPE || rc == VERR_NET_CONNECTION_RESET_BY_PEER)
     550                if (vrc == VERR_NET_SHUTDOWN || vrc == VERR_BROKEN_PIPE || vrc == VERR_NET_CONNECTION_RESET_BY_PEER)
    552551                {
    553552                    Log(("USB/IP: Lost connection to host \"%s\", trying to reconnect...\n", m->pszHost));
    554553                    disconnect();
    555                     rc = VINF_SUCCESS;
     554                    vrc = VINF_SUCCESS;
    556555                }
    557556            }
     
    559558            {
    560559                AssertMsgFailed(("Invalid poll ID returned\n"));
    561                 rc = VERR_INVALID_STATE;
     560                vrc = VERR_INVALID_STATE;
    562561            }
    563562            aMillies -= (RTMSINTERVAL)(RTTimeMilliTS() - msPollStart);
    564563        }
    565         else if (rc == VERR_TIMEOUT)
     564        else if (vrc == VERR_TIMEOUT)
    566565        {
    567566            aMillies -= msWait;
     
    571570                if (m->hSocket == NIL_RTSOCKET)
    572571                {
    573                     rc = reconnect();
    574                     if (RT_SUCCESS(rc))
    575                         rc = startListExportedDevicesReq();
    576                     else if (   rc == VERR_NET_SHUTDOWN
    577                              || rc == VERR_BROKEN_PIPE
    578                              || rc == VERR_NET_CONNECTION_RESET_BY_PEER
    579                              || rc == VERR_NET_CONNECTION_REFUSED)
     572                    vrc = reconnect();
     573                    if (RT_SUCCESS(vrc))
     574                        vrc = startListExportedDevicesReq();
     575                    else if (   vrc == VERR_NET_SHUTDOWN
     576                             || vrc == VERR_BROKEN_PIPE
     577                             || vrc == VERR_NET_CONNECTION_RESET_BY_PEER
     578                             || vrc == VERR_NET_CONNECTION_REFUSED)
    580579                    {
    581580                        if (hasDevListChanged(m->pHead))
    582581                            fDeviceListChangedOrWokenUp = true;
    583                         rc = VINF_SUCCESS;
     582                        vrc = VINF_SUCCESS;
    584583                    }
    585584                }
     
    588587    }
    589588
    590     LogFlowFunc(("return rc=%Rrc\n", rc));
    591     return rc;
     589    LogFlowFunc(("return vrc=%Rrc\n", vrc));
     590    return vrc;
    592591}
    593592
     
    599598    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    600599
    601     int rc = RTPipeWriteBlocking(m->hWakeupPipeW, "", 1, NULL);
    602     if (RT_SUCCESS(rc))
     600    int vrc = RTPipeWriteBlocking(m->hWakeupPipeW, "", 1, NULL);
     601    if (RT_SUCCESS(vrc))
    603602        RTPipeFlush(m->hWakeupPipeW);
    604     LogFlowFunc(("returning %Rrc\n", rc));
    605     return rc;
     603    LogFlowFunc(("returning %Rrc\n", vrc));
     604    return vrc;
    606605}
    607606
     
    705704    if (m->hSocket != NIL_RTSOCKET)
    706705    {
    707         int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_SOCKET);
    708         NOREF(rc);
    709         Assert(RT_SUCCESS(rc) || rc == VERR_POLL_HANDLE_ID_NOT_FOUND);
     706        int vrc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_SOCKET);
     707        NOREF(vrc);
     708        Assert(RT_SUCCESS(vrc) || vrc == VERR_POLL_HANDLE_ID_NOT_FOUND);
    710709
    711710        RTTcpClientCloseEx(m->hSocket, false /*fGracefulShutdown*/);
     
    730729
    731730    /* Connect to the USB/IP host. */
    732     int rc = RTTcpClientConnect(m->pszHost, m->uPort, &m->hSocket);
    733     if (RT_SUCCESS(rc))
    734     {
    735         rc = RTTcpSetSendCoalescing(m->hSocket, false);
    736         if (RT_FAILURE(rc))
    737             LogRelMax(5, ("USB/IP: Disabling send coalescing failed (rc=%Rrc), continuing nevertheless but expect increased latency\n", rc));
    738 
    739         rc = RTPollSetAddSocket(m->hPollSet, m->hSocket, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR,
    740                                 USBIP_POLL_ID_SOCKET);
    741         if (RT_FAILURE(rc))
     731    int vrc = RTTcpClientConnect(m->pszHost, m->uPort, &m->hSocket);
     732    if (RT_SUCCESS(vrc))
     733    {
     734        vrc = RTTcpSetSendCoalescing(m->hSocket, false);
     735        if (RT_FAILURE(vrc))
     736            LogRelMax(5, ("USB/IP: Disabling send coalescing failed (vrc=%Rrc), continuing nevertheless but expect increased latency\n", vrc));
     737
     738        vrc = RTPollSetAddSocket(m->hPollSet, m->hSocket, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, USBIP_POLL_ID_SOCKET);
     739        if (RT_FAILURE(vrc))
    742740        {
    743741            RTTcpClientCloseEx(m->hSocket, false /*fGracefulShutdown*/);
     
    763761    }
    764762
    765     LogFlowFunc(("returns rc=%Rrc\n", rc));
    766     return rc;
     763    LogFlowFunc(("returns vrc=%Rrc\n", vrc));
     764    return vrc;
    767765}
    768766
     
    774772int USBProxyBackendUsbIp::startListExportedDevicesReq()
    775773{
    776     int rc = VINF_SUCCESS;
     774    int vrc = VINF_SUCCESS;
    777775
    778776    LogFlowFunc(("\n"));
     
    784782    Assert(m->enmRecvState == kUsbIpRecvState_None);
    785783    if (m->enmRecvState != kUsbIpRecvState_None)
    786         rc = reconnect();
    787 
    788     if (RT_SUCCESS(rc))
     784        vrc = reconnect();
     785
     786    if (RT_SUCCESS(vrc))
    789787    {
    790788        /* Send of the request. */
     
    794792        ReqDevList.i32Status  = RT_H2N_S32(0);
    795793
    796         rc = RTTcpWrite(m->hSocket, &ReqDevList, sizeof(ReqDevList));
    797         if (RT_SUCCESS(rc))
     794        vrc = RTTcpWrite(m->hSocket, &ReqDevList, sizeof(ReqDevList));
     795        if (RT_SUCCESS(vrc))
    798796            advanceState(kUsbIpRecvState_Hdr);
    799797    }
    800798
    801     LogFlowFunc(("returns rc=%Rrc\n", rc));
    802     return rc;
     799    LogFlowFunc(("returns vrc=%Rrc\n", vrc));
     800    return vrc;
    803801}
    804802
     
    852850int USBProxyBackendUsbIp::receiveData()
    853851{
    854     int rc = VINF_SUCCESS;
     852    int vrc = VINF_SUCCESS;
    855853    size_t cbRecvd = 0;
    856854
     
    859857    do
    860858    {
    861         rc = RTTcpReadNB(m->hSocket, m->pbRecvBuf, m->cbResidualRecv, &cbRecvd);
    862 
    863         LogFlowFunc(("RTTcpReadNB(%#p, %#p, %zu, %zu) -> %Rrc\n",
    864                      m->hSocket, m->pbRecvBuf, m->cbResidualRecv, cbRecvd, rc));
    865 
    866         if (   rc == VINF_SUCCESS
     859        vrc = RTTcpReadNB(m->hSocket, m->pbRecvBuf, m->cbResidualRecv, &cbRecvd);
     860
     861        LogFlowFunc(("RTTcpReadNB(%#p, %#p, %zu, %zu) -> %Rrc\n", m->hSocket, m->pbRecvBuf, m->cbResidualRecv, cbRecvd, vrc));
     862
     863        if (   vrc == VINF_SUCCESS
    867864            && cbRecvd > 0)
    868865        {
     
    872869            if (!m->cbResidualRecv)
    873870            {
    874                 rc = processData();
    875                 if (   RT_SUCCESS(rc)
     871                vrc = processData();
     872                if (   RT_SUCCESS(vrc)
    876873                    && m->enmRecvState == kUsbIpRecvState_None)
    877874                    break;
    878875            }
    879876        }
    880         else if (rc == VINF_TRY_AGAIN)
     877        else if (vrc == VINF_TRY_AGAIN)
    881878            Assert(!cbRecvd);
    882879
    883     } while (rc == VINF_SUCCESS && cbRecvd > 0);
    884 
    885     if (rc == VINF_TRY_AGAIN)
    886         rc = VINF_SUCCESS;
    887 
    888     LogFlowFunc(("returns rc=%Rrc\n", rc));
    889     return rc;
     880    } while (vrc == VINF_SUCCESS && cbRecvd > 0);
     881
     882    if (vrc == VINF_TRY_AGAIN)
     883        vrc = VINF_SUCCESS;
     884
     885    LogFlowFunc(("returns vrc=%Rrc\n", vrc));
     886    return vrc;
    890887}
    891888
     
    897894int USBProxyBackendUsbIp::processData()
    898895{
    899     int rc = VINF_SUCCESS;
     896    int vrc = VINF_SUCCESS;
    900897
    901898    switch (m->enmRecvState)
     
    924921                advanceState(kUsbIpRecvState_None);
    925922                disconnect();
    926                 rc = VERR_NET_SHUTDOWN;
     923                vrc = VERR_NET_SHUTDOWN;
    927924            }
    928925            break;
     
    932929            /* Create a new device and add it to the list. */
    933930            usbProxyBackendUsbIpExportedDeviceN2H(&m->Scratch.ExportedDevice);
    934             rc = addDeviceToList(&m->Scratch.ExportedDevice);
    935             if (RT_SUCCESS(rc))
     931            vrc = addDeviceToList(&m->Scratch.ExportedDevice);
     932            if (RT_SUCCESS(vrc))
    936933            {
    937934                m->cInterfacesLeft = m->Scratch.ExportedDevice.bNumInterfaces;
     
    974971    }
    975972
    976     return rc;
     973    return vrc;
    977974}
    978975
     
    986983int USBProxyBackendUsbIp::addDeviceToList(PUsbIpExportedDevice pDev)
    987984{
    988     int rc = VINF_SUCCESS;
     985    int vrc = VINF_SUCCESS;
    989986    PUSBDEVICE pNew = (PUSBDEVICE)RTMemAllocZ(sizeof(USBDEVICE));
    990987    if (!pNew)
     
    10551052    }
    10561053    else
    1057         rc = VERR_NO_STR_MEMORY;
    1058 
    1059     if (RT_FAILURE(rc))
     1054        vrc = VERR_NO_STR_MEMORY;
     1055
     1056    if (RT_FAILURE(vrc))
    10601057    {
    10611058        if (pNew->pszManufacturer)
     
    10701067    }
    10711068
    1072     return rc;
     1069    return vrc;
    10731070}
    10741071
  • trunk/src/VBox/Main/src-server/linux/HostDnsServiceLinux.cpp

    r98103 r98288  
    185185     */
    186186    int aiStopPair[2];
    187     int rc = socketpair(AF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0, aiStopPair);
     187    int iRc = socketpair(AF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0, aiStopPair);
    188188    int iErr = errno;
    189     AssertLogRelMsgReturn(rc == 0, ("socketpair: failed (%d: %s)\n", iErr, strerror(iErr)), RTErrConvertFromErrno(iErr));
     189    AssertLogRelMsgReturn(iRc == 0, ("socketpair: failed (%d: %s)\n", iErr, strerror(iErr)), RTErrConvertFromErrno(iErr));
    190190
    191191    m_fdShutdown = aiStopPair[0];
     
    241241         * Wait for something to happen.
    242242         */
    243         rc = poll(aFdPolls, RT_ELEMENTS(aFdPolls), -1 /*infinite timeout*/);
    244         if (rc == -1)
     243        iRc = poll(aFdPolls, RT_ELEMENTS(aFdPolls), -1 /*infinite timeout*/);
     244        if (iRc == -1)
    245245        {
    246246            if (errno != EINTR)
    247247            {
    248                 LogRelMax(32, ("HostDnsServiceLinux::monitorThreadProc: poll failed %d: errno=%d\n", rc, errno));
     248                LogRelMax(32, ("HostDnsServiceLinux::monitorThreadProc: poll failed %d: errno=%d\n", iRc, errno));
    249249                RTThreadSleep(1);
    250250            }
    251251            continue;
    252252        }
    253         Log5Func(("poll returns %d: [0]=%#x [1]=%#x\n", rc, aFdPolls[1].revents, aFdPolls[0].revents));
     253        Log5Func(("poll returns %d: [0]=%#x [1]=%#x\n", iRc, aFdPolls[1].revents, aFdPolls[0].revents));
    254254
    255255        AssertMsgBreakStmt(   (aFdPolls[0].revents & (POLLERR | POLLNVAL)) == 0 /* (ok for fd=-1 too, revents=0 then) */
     
    322322                        if (iWdFileNew != -1)
    323323                        {
    324                             rc = inotify_rm_watch(iNotifyFd, iWdFileNew);
    325                             AssertMsg(rc >= 0, ("%d/%d\n", rc, errno));
     324                            iRc = inotify_rm_watch(iNotifyFd, iWdFileNew);
     325                            AssertMsg(iRc >= 0, ("%d/%d\n", iRc, errno));
    326326                            iWdFileNew = -1;
    327327                        }
     
    350350                            if (iWdFileNew >= 0)
    351351                            {
    352                                 rc = inotify_rm_watch(iNotifyFd, iWdFileNew);
    353                                 Log5Func(("dir: moved / created / deleted: dropped file watch (%d - rc=%d/err=%d)\n",
    354                                           iWdFileNew, rc, errno));
     352                                iRc = inotify_rm_watch(iNotifyFd, iWdFileNew);
     353                                Log5Func(("dir: moved / created / deleted: dropped file watch (%d - iRc=%d/err=%d)\n",
     354                                          iWdFileNew, iRc, errno));
    355355                                iWdFileNew = -1;
    356356                            }
    357357                            if (iWdSymDirNew >= 0)
    358358                            {
    359                                 rc = inotify_rm_watch(iNotifyFd, iWdSymDirNew);
    360                                 Log5Func(("dir: moved / created / deleted: dropped symlinked dir watch (%d - %s/%s - rc=%d/err=%d)\n",
    361                                           iWdSymDirNew, szRealResolvConf, &szRealResolvConf[offRealResolvConfName], rc, errno));
     359                                iRc = inotify_rm_watch(iNotifyFd, iWdSymDirNew);
     360                                Log5Func(("dir: moved / created / deleted: dropped symlinked dir watch (%d - %s/%s - iRc=%d/err=%d)\n",
     361                                          iWdSymDirNew, szRealResolvConf, &szRealResolvConf[offRealResolvConfName], iRc, errno));
    362362                                iWdSymDirNew = -1;
    363363                                offRealResolvConfName = 0;
     
    397397                        if (iWdFileNew >= 0)
    398398                        {
    399                             rc = inotify_rm_watch(iNotifyFd, iWdFileNew);
    400                             Log5Func(("symdir: moved / created / deleted: drop file watch (%d - rc=%d/err=%d)\n",
    401                                       iWdFileNew, rc, errno));
     399                            iRc = inotify_rm_watch(iNotifyFd, iWdFileNew);
     400                            Log5Func(("symdir: moved / created / deleted: drop file watch (%d - iRc=%d/err=%d)\n",
     401                                      iWdFileNew, iRc, errno));
    402402                            iWdFileNew = -1;
    403403                        }
  • trunk/src/VBox/Main/src-server/linux/HostHardwareLinux.cpp

    r98103 r98288  
    148148    AssertReturn(Number <= 7, false);
    149149    RTFILE File;
    150     int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
    151     if (RT_SUCCESS(rc))
     150    int vrc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
     151    if (RT_SUCCESS(vrc))
    152152    {
    153153        int rcIoCtl;
    154         rc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
     154        vrc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
    155155        RTFileClose(File);
    156         if (RT_SUCCESS(rc) && rcIoCtl >= 0)
     156        if (RT_SUCCESS(vrc) && rcIoCtl >= 0)
    157157            return true;
    158158    }
     
    310310
    311311    RTFILE hFile = NIL_RTFILE;
    312     int rc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
    313     if (RT_SUCCESS(rc))
     312    int vrc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
     313    if (RT_SUCCESS(vrc))
    314314    {
    315315        int                             rcIoCtl          = 0;
     
    323323        CdromCommandReq.data_direction = CGC_DATA_READ;
    324324        CdromCommandReq.timeout        = 5000;  /* ms */
    325         rc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
    326         if (RT_SUCCESS(rc) && rcIoCtl < 0)
    327             rc = RTErrConvertFromErrno(-CdromCommandReq.stat);
     325        vrc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
     326        if (RT_SUCCESS(vrc) && rcIoCtl < 0)
     327            vrc = RTErrConvertFromErrno(-CdromCommandReq.stat);
    328328        RTFileClose(hFile);
    329329
    330         if (RT_SUCCESS(rc))
     330        if (RT_SUCCESS(vrc))
    331331        {
    332332            if (pbType)
     
    347347        }
    348348    }
    349     LogRelFlowFunc(("returning %Rrc\n", rc));
    350     return rc;
     349    LogRelFlowFunc(("returning %Rrc\n", vrc));
     350    return vrc;
    351351}
    352352
     
    432432    AssertPtrReturn(pcszNode, false);
    433433    RTFILE File;
    434     int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
    435     if (RT_SUCCESS(rc))
     434    int vrc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
     435    if (RT_SUCCESS(vrc))
    436436    {
    437437        int rcIoCtl;
    438         rc = RTFileIoCtl(File, NVME_IOCTL_ID, NULL, 0, &rcIoCtl);
     438        vrc = RTFileIoCtl(File, NVME_IOCTL_ID, NULL, 0, &rcIoCtl);
    439439        RTFileClose(File);
    440         if (RT_SUCCESS(rc) && rcIoCtl >= 0)
     440        if (RT_SUCCESS(vrc) && rcIoCtl >= 0)
    441441            return true;
    442442    }
     
    520520{
    521521    LogFlowThisFunc(("entered\n"));
    522     int rc;
     522    int vrc;
    523523    try
    524524    {
     
    527527         * environment variable. */
    528528        bool fSuccess = false;  /* Have we succeeded in finding anything yet? */
    529         rc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */, &fSuccess);
     529        vrc = getDriveInfoFromEnv("VBOX_CDROM", &mDVDList, true /* isDVD */, &fSuccess);
    530530        setNoProbe(false);
    531         if (RT_SUCCESS(rc) && (!fSuccess || testing()))
    532             rc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
    533         if (RT_SUCCESS(rc) && testing())
     531        if (RT_SUCCESS(vrc) && (!fSuccess || testing()))
     532            vrc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
     533        if (RT_SUCCESS(vrc) && testing())
    534534        {
    535535            setNoProbe(true);
    536             rc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
     536            vrc = getDriveInfoFromSysfs(&mDVDList, DVD, &fSuccess);
    537537        }
    538538    }
    539539    catch (std::bad_alloc &e)
    540540    {
    541         rc = VERR_NO_MEMORY;
    542     }
    543     LogFlowThisFunc(("rc=%Rrc\n", rc));
    544     return rc;
     541        vrc = VERR_NO_MEMORY;
     542    }
     543    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
     544    return vrc;
    545545}
    546546
     
    548548{
    549549    LogFlowThisFunc(("entered\n"));
    550     int rc;
     550    int vrc;
    551551    try
    552552    {
    553553        mFloppyList.clear();
    554554        bool fSuccess = false;  /* Have we succeeded in finding anything yet? */
    555         rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */, &fSuccess);
     555        vrc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList, false /* isDVD */, &fSuccess);
    556556        setNoProbe(false);
    557         if (RT_SUCCESS(rc) && (!fSuccess || testing()))
    558             rc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
    559         if (RT_SUCCESS(rc) && testing())
     557        if (RT_SUCCESS(vrc) && (!fSuccess || testing()))
     558            vrc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
     559        if (RT_SUCCESS(vrc) && testing())
    560560        {
    561561            setNoProbe(true);
    562             rc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
     562            vrc = getDriveInfoFromSysfs(&mFloppyList, Floppy, &fSuccess);
    563563        }
    564564    }
    565565    catch (std::bad_alloc &)
    566566    {
    567         rc = VERR_NO_MEMORY;
    568     }
    569     LogFlowThisFunc(("rc=%Rrc\n", rc));
    570     return rc;
     567        vrc = VERR_NO_MEMORY;
     568    }
     569    LogFlowThisFunc(("vrc=%Rrc\n", vrc));
     570    return vrc;
    571571}
    572572
     
    617617    AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
    618618    LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar, pList, isDVD, pfSuccess));
    619     int rc = VINF_SUCCESS;
     619    int vrc = VINF_SUCCESS;
    620620    bool success = false;
    621621    char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
     
    645645    catch (std::bad_alloc &)
    646646    {
    647         rc = VERR_NO_MEMORY;
     647        vrc = VERR_NO_MEMORY;
    648648    }
    649649    RTStrFree(pszFreeMe);
    650     LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
    651     return rc;
     650    LogFlowFunc(("vrc=%Rrc, success=%d\n", vrc, success));
     651    return vrc;
    652652}
    653653
     
    696696    {
    697697        dev_t dev = 0;
    698         int rc = RTLinuxSysFsReadDevNumFile(&dev, "block/%s/dev", mpcszName);
    699         if (RT_FAILURE(rc) || dev == 0)
     698        int vrc = RTLinuxSysFsReadDevNumFile(&dev, "block/%s/dev", mpcszName);
     699        if (RT_FAILURE(vrc) || dev == 0)
    700700        {
    701701            misConsistent = false;
    702702            return false;
    703703        }
    704         rc = RTLinuxCheckDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode, sizeof(mszNode), "%s", mpcszName);
    705         return RT_SUCCESS(rc);
     704        vrc = RTLinuxCheckDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode, sizeof(mszNode), "%s", mpcszName);
     705        return RT_SUCCESS(vrc);
    706706    }
    707707
     
    714714    {
    715715        int64_t type = 0;
    716         int rc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
    717         if (RT_SUCCESS(rc) && type != TYPE_ROM)
     716        int vrc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
     717        if (RT_SUCCESS(vrc) && type != TYPE_ROM)
    718718            return;
    719719        if (type == TYPE_ROM)
    720720        {
    721721            char szVendor[128];
    722             rc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), NULL, "block/%s/device/vendor", mpcszName);
    723             if (RT_SUCCESS(rc))
     722            vrc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), NULL, "block/%s/device/vendor", mpcszName);
     723            if (RT_SUCCESS(vrc))
    724724            {
    725725                char szModel[128];
    726                 rc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), NULL, "block/%s/device/model", mpcszName);
    727                 if (RT_SUCCESS(rc))
     726                vrc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), NULL, "block/%s/device/model", mpcszName);
     727                if (RT_SUCCESS(vrc))
    728728                {
    729729                    misValid = true;
     
    747747        char szVendor[128] = "";
    748748        char szModel[128] = "";
    749         int rc = cdromDoInquiry(mszNode, &bType, szVendor, sizeof(szVendor), szModel, sizeof(szModel));
    750         if (RT_SUCCESS(rc) && bType == TYPE_ROM)
     749        int vrc = cdromDoInquiry(mszNode, &bType, szVendor, sizeof(szVendor), szModel, sizeof(szModel));
     750        if (RT_SUCCESS(vrc) && bType == TYPE_ROM)
    751751        {
    752752            misValid = true;
     
    772772        if (!noProbe())
    773773            fHaveName = floppyGetName(mszNode, mpcszName[2] - '0', szName);
    774         int rc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s",
    775                                          mpcszName, "device/driver");
    776         if (RT_SUCCESS(rc))
     774        int vrc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s", mpcszName, "device/driver");
     775        if (RT_SUCCESS(vrc))
    777776        {
    778777            if (RTStrCmp(szDriver, "floppy"))
     
    795794         */
    796795        int64_t type = 0;
    797         int rc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
    798         if (!RT_SUCCESS(rc) || type != TYPE_DISK)
     796        int vrc = RTLinuxSysFsReadIntFile(10, &type, "block/%s/device/type", mpcszName);
     797        if (!RT_SUCCESS(vrc) || type != TYPE_DISK)
    799798        {
    800799            if (noProbe() || !probeNVME(mszNode))
    801800            {
    802801                char szDriver[16];
    803                 rc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s",
    804                                                  mpcszName, "device/device/driver");
    805                 if (RT_FAILURE(rc) || RTStrCmp(szDriver, "nvme"))
    806                         return;
     802                vrc = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), NULL, "block/%s/%s", mpcszName, "device/device/driver");
     803                if (RT_FAILURE(vrc) || RTStrCmp(szDriver, "nvme"))
     804                    return;
    807805            }
    808806        }
     
    810808        char szModel[128];
    811809        size_t cbRead = 0;
    812         rc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), &cbRead, "block/%s/device/vendor", mpcszName);
     810        vrc = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor), &cbRead, "block/%s/device/vendor", mpcszName);
    813811        szVendor[cbRead] = '\0';
    814812        /* Assume the model is always present. Vendor is not present for NVME disks */
    815813        cbRead = 0;
    816         rc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), &cbRead, "block/%s/device/model", mpcszName);
     814        vrc = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel), &cbRead, "block/%s/device/model", mpcszName);
    817815        szModel[cbRead] = '\0';
    818         if (RT_SUCCESS(rc))
     816        if (RT_SUCCESS(vrc))
    819817        {
    820818            misValid = true;
     
    870868    unsigned cFound = 0;
    871869    RTDIR hDir = NIL_RTDIR;
    872     int rc = RTDirOpen(&hDir, "/sys/block");
     870    int vrc = RTDirOpen(&hDir, "/sys/block");
    873871    /* This might mean that sysfs semantics have changed */
    874     AssertReturn(rc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
    875     if (RT_SUCCESS(rc))
     872    AssertReturn(vrc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
     873    if (RT_SUCCESS(vrc))
    876874    {
    877875        for (;;)
    878876        {
    879877            RTDIRENTRY entry;
    880             rc = RTDirRead(hDir, &entry, NULL);
    881             Assert(rc != VERR_BUFFER_OVERFLOW);  /* Should never happen... */
    882             if (RT_FAILURE(rc))  /* Including overflow and no more files */
     878            vrc = RTDirRead(hDir, &entry, NULL);
     879            Assert(vrc != VERR_BUFFER_OVERFLOW);  /* Should never happen... */
     880            if (RT_FAILURE(vrc))  /* Including overflow and no more files */
    883881                break;
    884882            if (entry.szName[0] == '.')
     
    895893            catch (std::bad_alloc &e)
    896894            {
    897                 rc = VERR_NO_MEMORY;
     895                vrc = VERR_NO_MEMORY;
    898896                break;
    899897            }
     
    902900        RTDirClose(hDir);
    903901    }
    904     if (rc == VERR_NO_MORE_FILES)
    905         rc = VINF_SUCCESS;
    906     else if (RT_FAILURE(rc))
     902    if (vrc == VERR_NO_MORE_FILES)
     903        vrc = VINF_SUCCESS;
     904    else if (RT_FAILURE(vrc))
    907905        /* Clean up again */
    908906        while (cFound-- > 0)
     
    910908    if (pfSuccess)
    911909        *pfSuccess = fSuccess;
    912     LogFlow (("rc=%Rrc, fSuccess=%u\n", rc, (unsigned)fSuccess));
    913     return rc;
     910    LogFlow (("vrc=%Rrc, fSuccess=%u\n", vrc, (unsigned)fSuccess));
     911    return vrc;
    914912}
    915913
     
    11811179#  endif
    11821180
    1183     int rc = iwInit(&mWatches);
    1184     if (RT_SUCCESS(rc))
    1185     {
    1186         rc = iwAddWatch(&mWatches, mpcszDevicesRoot);
    1187         if (RT_SUCCESS(rc))
    1188             rc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW);
    1189     }
    1190     mStatus = rc;
    1191     if (RT_FAILURE(rc))
     1181    int vrc = iwInit(&mWatches);
     1182    if (RT_SUCCESS(vrc))
     1183    {
     1184        vrc = iwAddWatch(&mWatches, mpcszDevicesRoot);
     1185        if (RT_SUCCESS(vrc))
     1186            vrc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW);
     1187    }
     1188    mStatus = vrc;
     1189    if (RT_FAILURE(vrc))
    11921190        term();
    11931191}
     
    12471245int hotplugInotifyImpl::Wait(RTMSINTERVAL aMillies)
    12481246{
    1249     int rc;
    1250 
    12511247    AssertRCReturn(mStatus, VERR_WRONG_ORDER);
    12521248    bool fEntered = ASMAtomicCmpXchgU32(&mfWaiting, 1, 0);
     
    12551251    VECTOR_PTR(char *) vecpchDevs;
    12561252    VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
    1257     rc = readFilePaths(mpcszDevicesRoot, &vecpchDevs, false);
    1258     if (RT_SUCCESS(rc))
     1253    int vrc = readFilePaths(mpcszDevicesRoot, &vecpchDevs, false);
     1254    if (RT_SUCCESS(vrc))
    12591255    {
    12601256        char **ppszEntry;
    12611257        VEC_FOR_EACH(&vecpchDevs, char *, ppszEntry)
    1262             if (RT_FAILURE(rc = iwAddWatch(&mWatches, *ppszEntry)))
     1258            if (RT_FAILURE(vrc = iwAddWatch(&mWatches, *ppszEntry)))
    12631259                break;
    12641260
    1265         if (RT_SUCCESS(rc))
     1261        if (RT_SUCCESS(vrc))
    12661262        {
    12671263            struct pollfd pollFD[MAX_POLLID];
     
    12751271            {
    12761272                Assert(errno > 0);
    1277                 rc = RTErrConvertFromErrno(errno);
     1273                vrc = RTErrConvertFromErrno(errno);
    12781274            }
    12791275            else if (pollFD[RPIPE_ID].revents)
    12801276            {
    1281                 rc = drainWakeupPipe();
    1282                 if (RT_SUCCESS(rc))
    1283                     rc = VERR_INTERRUPTED;
     1277                vrc = drainWakeupPipe();
     1278                if (RT_SUCCESS(vrc))
     1279                    vrc = VERR_INTERRUPTED;
    12841280            }
    12851281            else if ((pollFD[INOTIFY_ID].revents))
    12861282            {
    12871283                if (cPolled == 1)
    1288                     rc = drainInotify();
     1284                    vrc = drainInotify();
    12891285                else
    1290                     AssertFailedStmt(rc = VERR_INTERNAL_ERROR);
     1286                    AssertFailedStmt(vrc = VERR_INTERNAL_ERROR);
    12911287            }
    12921288            else
    12931289            {
    12941290                if (errno == 0 && cPolled == 0)
    1295                     rc = VERR_TIMEOUT;
     1291                    vrc = VERR_TIMEOUT;
    12961292                else
    1297                     AssertFailedStmt(rc = VERR_INTERNAL_ERROR);
     1293                    AssertFailedStmt(vrc = VERR_INTERNAL_ERROR);
    12981294            }
    12991295        }
     
    13021298    mfWaiting = 0;
    13031299    VEC_CLEANUP_PTR(&vecpchDevs);
    1304     return rc;
     1300    return vrc;
    13051301}
    13061302
  • trunk/src/VBox/Main/src-server/linux/HostPowerLinux.cpp

    r98103 r98288  
    5959{
    6060    DBusError error;
    61     int rc;
    6261
    63     rc = RTDBusLoadLib();
    64     if (RT_FAILURE(rc))
     62    int vrc = RTDBusLoadLib();
     63    if (RT_FAILURE(vrc))
    6564    {
    6665        LogRel(("HostPowerServiceLinux: DBus library not found.  Service not available.\n"));
     
    9291
    9392    /* Create the new worker thread. */
    94     rc = RTThreadCreate(&mThread, HostPowerServiceLinux::powerChangeNotificationThread, this, 0 /* cbStack */,
    95                         RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "MainPower");
    96     if (RT_FAILURE(rc))
     93    vrc = RTThreadCreate(&mThread, HostPowerServiceLinux::powerChangeNotificationThread, this, 0 /* cbStack */,
     94                         RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "MainPower");
     95    if (RT_FAILURE(vrc))
    9796    {
    98         LogRel(("HostPowerServiceLinux: RTThreadCreate failed with %Rrc\n", rc));
     97        LogRel(("HostPowerServiceLinux: RTThreadCreate failed with %Rrc\n", vrc));
    9998        dbus_connection_unref(mpConnection);
    10099    }
  • trunk/src/VBox/Main/src-server/linux/NetIf-linux.cpp

    r98103 r98288  
    126126    {
    127127        /* Failed to get speed via sysfs, go to plan B. */
    128         int rc = NetIfAdpCtlOut(pszName, "speed", szBuf, sizeof(szBuf));
    129         if (RT_SUCCESS(rc))
     128        int vrc = NetIfAdpCtlOut(pszName, "speed", szBuf, sizeof(szBuf));
     129        if (RT_SUCCESS(vrc))
    130130            uSpeed = RTStrToUInt32(szBuf);
    131131    }
     
    230230{
    231231    char szDefaultIface[256];
    232     int rc = getDefaultIfaceName(szDefaultIface, sizeof(szDefaultIface));
    233     if (RT_FAILURE(rc))
     232    int vrc = getDefaultIfaceName(szDefaultIface, sizeof(szDefaultIface));
     233    if (RT_FAILURE(vrc))
    234234    {
    235235        Log(("NetIfList: Failed to find default interface.\n"));
     
    253253                NETIFINFO Info;
    254254                RT_ZERO(Info);
    255                 rc = getInterfaceInfo(sock, pszName, &Info);
    256                 if (RT_FAILURE(rc))
     255                vrc = getInterfaceInfo(sock, pszName, &Info);
     256                if (RT_FAILURE(vrc))
    257257                    break;
    258258                if (Info.enmMediumType == NETIF_T_ETHERNET)
     
    282282    }
    283283    else
    284         rc = VERR_INTERNAL_ERROR;
    285 
    286     return rc;
     284        vrc = VERR_INTERNAL_ERROR;
     285
     286    return vrc;
    287287}
    288288
    289289int NetIfGetConfigByName(PNETIFINFO pInfo)
    290290{
    291     int rc = VINF_SUCCESS;
    292291    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    293292    if (sock < 0)
    294293        return VERR_NOT_IMPLEMENTED;
    295     rc = getInterfaceInfo(sock, pInfo->szShortName, pInfo);
     294    int vrc = getInterfaceInfo(sock, pInfo->szShortName, pInfo);
    296295    close(sock);
    297     return rc;
     296    return vrc;
    298297}
    299298
  • trunk/src/VBox/Main/src-server/linux/PerformanceLinux.cpp

    r98103 r98288  
    114114
    115115    uint64_t cb;
    116     int rc = RTSystemQueryTotalRam(&cb);
    117     if (RT_FAILURE(rc))
     116    int vrc = RTSystemQueryTotalRam(&cb);
     117    if (RT_FAILURE(vrc))
    118118        mTotalRAM = 0;
    119119    else
     
    130130    {
    131131        VMProcessStats vmStats;
    132         int rc = getRawProcessStats(*it, &vmStats.cpuUser, &vmStats.cpuKernel, &vmStats.pagesUsed);
     132        int vrc = getRawProcessStats(*it, &vmStats.cpuUser, &vmStats.cpuKernel, &vmStats.pagesUsed);
    133133        /* On failure, do NOT stop. Just skip the entry. Having the stats for
    134134         * one (probably broken) process frozen/zero is a minor issue compared
    135135         * to not updating many process stats and the host cpu stats. */
    136         if (RT_SUCCESS(rc))
     136        if (RT_SUCCESS(vrc))
    137137            mProcessStats[*it] = vmStats;
    138138    }
     
    146146int CollectorLinux::_getRawHostCpuLoad()
    147147{
    148     int rc = VINF_SUCCESS;
     148    int vrc = VINF_SUCCESS;
    149149    long long unsigned uUser, uNice, uKernel, uIdle, uIowait, uIrq, uSoftirq;
    150150    FILE *f = fopen("/proc/stat", "r");
     
    184184            }
    185185            else
    186                 rc = VERR_FILE_IO_ERROR;
     186                vrc = VERR_FILE_IO_ERROR;
    187187        }
    188188        else
    189             rc = VERR_FILE_IO_ERROR;
     189            vrc = VERR_FILE_IO_ERROR;
    190190        fclose(f);
    191191    }
    192192    else
    193         rc = VERR_ACCESS_DENIED;
    194 
    195     return rc;
     193        vrc = VERR_ACCESS_DENIED;
     194
     195    return vrc;
    196196}
    197197
     
    223223    AssertReturn(mTotalRAM, VERR_INTERNAL_ERROR);
    224224    uint64_t cb;
    225     int rc = RTSystemQueryAvailableRam(&cb);
    226     if (RT_SUCCESS(rc))
     225    int vrc = RTSystemQueryAvailableRam(&cb);
     226    if (RT_SUCCESS(vrc))
    227227    {
    228228        *total = mTotalRAM;
     
    230230        *used = *total - *available;
    231231    }
    232     return rc;
     232    return vrc;
    233233}
    234234
     
    257257    Assert(pszPath);
    258258
    259     int rc = VINF_SUCCESS;
     259    int vrc = VINF_SUCCESS;
    260260    if (!RTLinuxSysFsExists(pszPath))
    261         rc = VERR_FILE_NOT_FOUND;
     261        vrc = VERR_FILE_NOT_FOUND;
    262262    else
    263263    {
    264264        int64_t cSize = 0;
    265         rc = RTLinuxSysFsReadIntFile(0, &cSize, pszPath);
    266         if (RT_SUCCESS(rc))
     265        vrc = RTLinuxSysFsReadIntFile(0, &cSize, pszPath);
     266        if (RT_SUCCESS(vrc))
    267267            *size = cSize * 512;
    268268    }
    269269    RTStrFree(pszPath);
    270     return rc;
     270    return vrc;
    271271}
    272272
     
    286286int CollectorLinux::getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, ULONG *memPagesUsed)
    287287{
    288     int rc = VINF_SUCCESS;
     288    int vrc = VINF_SUCCESS;
    289289    char *pszName;
    290290    pid_t pid2;
     
    316316        }
    317317        else
    318             rc = VERR_FILE_IO_ERROR;
     318            vrc = VERR_FILE_IO_ERROR;
    319319        fclose(f);
    320320    }
    321321    else
    322         rc = VERR_ACCESS_DENIED;
    323 
    324     return rc;
     322        vrc = VERR_ACCESS_DENIED;
     323
     324    return vrc;
    325325}
    326326
     
    334334
    335335    int64_t cSize = 0;
    336     int rc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
    337     if (RT_FAILURE(rc))
    338         return rc;
     336    int vrc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
     337    if (RT_FAILURE(vrc))
     338        return vrc;
    339339
    340340    *rx = cSize;
     
    344344        return VERR_FILE_NOT_FOUND;
    345345
    346     rc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
    347     if (RT_FAILURE(rc))
    348         return rc;
     346    vrc = RTLinuxSysFsReadIntFile(0, &cSize, szIfName);
     347    if (RT_FAILURE(vrc))
     348        return vrc;
    349349
    350350    *tx = cSize;
     
    355355{
    356356#if 0
    357     int rc = VINF_SUCCESS;
     357    int vrc = VINF_SUCCESS;
    358358    char szIfName[/*IFNAMSIZ*/ 16 + 36];
    359359    long long unsigned int u64Busy, tmp;
     
    370370        }
    371371        else
    372             rc = VERR_FILE_IO_ERROR;
     372            vrc = VERR_FILE_IO_ERROR;
    373373        fclose(f);
    374374    }
    375375    else
    376         rc = VERR_ACCESS_DENIED;
     376        vrc = VERR_ACCESS_DENIED;
    377377#else
    378     int rc = VERR_MISSING;
     378    int vrc = VERR_MISSING;
    379379    FILE *f = fopen("/proc/diskstats", "r");
    380380    if (f)
     
    406406                    *disk_ms   = u64Busy;
    407407                    *total_ms  = (uint64_t)(mSingleUser + mSingleKernel + mSingleIdle) * 1000 / mHZ;
    408                     rc = VINF_SUCCESS;
     408                    vrc = VINF_SUCCESS;
    409409                }
    410410                else
    411                     rc = VERR_FILE_IO_ERROR;
     411                    vrc = VERR_FILE_IO_ERROR;
    412412                break;
    413413            }
     
    417417#endif
    418418
    419     return rc;
     419    return vrc;
    420420}
    421421
     
    525525{
    526526    char szVolInfo[RTPATH_MAX];
    527     int rc = RTPathAppPrivateArch(szVolInfo,
    528                                   sizeof(szVolInfo) - sizeof("/" VBOXVOLINFO_NAME " ") - strlen(pcszVolume));
    529     if (RT_FAILURE(rc))
    530     {
    531         LogRel(("VolInfo: Failed to get program path, rc=%Rrc\n", rc));
     527    int vrc = RTPathAppPrivateArch(szVolInfo, sizeof(szVolInfo) - sizeof("/" VBOXVOLINFO_NAME " ") - strlen(pcszVolume));
     528    if (RT_FAILURE(vrc))
     529    {
     530        LogRel(("VolInfo: Failed to get program path, vrc=%Rrc\n", vrc));
    532531        return;
    533532    }
     
    568567                char szFsName[1024];
    569568                /* Try to resolve symbolic link if necessary. Yes, we access the file system here! */
    570                 int rc = RTPathReal(mntent->mnt_fsname, szFsName, sizeof(szFsName));
    571                 if (RT_FAILURE(rc))
     569                int vrc = RTPathReal(mntent->mnt_fsname, szFsName, sizeof(szFsName));
     570                if (RT_FAILURE(vrc))
    572571                    continue; /* something got wrong, just ignore this path */
    573572                /* check against the actual mtab entry, NOT the real path as /dev/mapper/xyz is
  • trunk/src/VBox/Main/src-server/linux/USBGetDevices.cpp

    r98103 r98288  
    293293        }
    294294
    295         int rc = usbfsReadSkipSuffix(&pszNext);
    296         if (RT_FAILURE(rc))
    297             return rc;
     295        int vrc = usbfsReadSkipSuffix(&pszNext);
     296        if (RT_FAILURE(vrc))
     297            return vrc;
    298298
    299299        *ppszNext = pszNext;
     
    379379         * Validate and skip stuff following the number.
    380380         */
    381         int rc = usbfsReadSkipSuffix(&pszNext);
    382         if (RT_FAILURE(rc))
    383             return rc;
     381        int vrc = usbfsReadSkipSuffix(&pszNext);
     382        if (RT_FAILURE(vrc))
     383            return vrc;
    384384        *ppszNext = pszNext;
    385385
     
    471471/** Just a worker for USBProxyServiceLinux::getDevices that avoids some code duplication. */
    472472static int usbfsAddDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE *ppFirst, PUSBDEVICE **pppNext, const char *pszUsbfsRoot,
    473                                  bool fUnsupportedDevicesToo, int rc)
     473                                 bool fUnsupportedDevicesToo, int vrc)
    474474{
    475475    /* usbDeterminState requires the address. */
     
    495495        {
    496496            deviceFree(pDevNew);
    497             rc = VERR_NO_MEMORY;
     497            vrc = VERR_NO_MEMORY;
    498498        }
    499499    }
    500500    else
    501501    {
    502         rc = VERR_NO_MEMORY;
     502        vrc = VERR_NO_MEMORY;
    503503        deviceFreeMembers(pDev);
    504504    }
    505505
    506     return rc;
     506    return vrc;
    507507}
    508508
     
    535535    PUSBDEVICE pFirst = NULL;
    536536    FILE *pFile = NULL;
    537     int rc;
    538     rc = usbfsOpenDevicesFile(pszUsbfsRoot, &pFile);
    539     if (RT_SUCCESS(rc))
     537    int vrc = usbfsOpenDevicesFile(pszUsbfsRoot, &pFile);
     538    if (RT_SUCCESS(vrc))
    540539    {
    541540        PUSBDEVICE     *ppNext = NULL;
     
    547546
    548547        /* Set close on exit and hope no one is racing us. */
    549         rc = fcntl(fileno(pFile), F_SETFD, FD_CLOEXEC) >= 0
    550            ? VINF_SUCCESS
    551            : RTErrConvertFromErrno(errno);
    552         while (     RT_SUCCESS(rc)
    553                &&   fgets(szLine, sizeof(szLine), pFile))
     548        vrc = fcntl(fileno(pFile), F_SETFD, FD_CLOEXEC) >= 0
     549            ? VINF_SUCCESS
     550            : RTErrConvertFromErrno(errno);
     551        while (   RT_SUCCESS(vrc)
     552               && fgets(szLine, sizeof(szLine), pFile))
    554553        {
    555554            char   *psz;
     
    596595                    AssertMsg(cHits >= 3 || cHits == 0, ("cHits=%d\n", cHits));
    597596                    if (cHits >= 3)
    598                         rc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, rc);
     597                        vrc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, vrc);
    599598                    else
    600599                        deviceFreeMembers(&Dev);
     
    606605
    607606                    /* parse the line. */
    608                     while (*psz && RT_SUCCESS(rc))
     607                    while (*psz && RT_SUCCESS(vrc))
    609608                    {
    610609                        if (PREFIX("Bus="))
    611                             rc = usbfsRead8(pszValue, 10, &Dev.bBus, &psz);
     610                            vrc = usbfsRead8(pszValue, 10, &Dev.bBus, &psz);
    612611                        else if (PREFIX("Port="))
    613                             rc = usbfsRead8(pszValue, 10, &Dev.bPort, &psz);
     612                            vrc = usbfsRead8(pszValue, 10, &Dev.bPort, &psz);
    614613                        else if (PREFIX("Spd="))
    615                             rc = usbfsReadSpeed(pszValue, &Dev.enmSpeed, &psz);
     614                            vrc = usbfsReadSpeed(pszValue, &Dev.enmSpeed, &psz);
    616615                        else if (PREFIX("Dev#="))
    617                             rc = usbfsRead8(pszValue, 10, &Dev.bDevNum, &psz);
     616                            vrc = usbfsRead8(pszValue, 10, &Dev.bDevNum, &psz);
    618617                        else
    619618                            psz = usbfsReadSkip(psz);
     
    644643                 */
    645644                case 'D':
    646                     while (*psz && RT_SUCCESS(rc))
     645                    while (*psz && RT_SUCCESS(vrc))
    647646                    {
    648647                        if (PREFIX("Ver="))
    649                             rc = usbfsReadBCD(pszValue, 16, &Dev.bcdUSB, &psz);
     648                            vrc = usbfsReadBCD(pszValue, 16, &Dev.bcdUSB, &psz);
    650649                        else if (PREFIX("Cls="))
    651650                        {
    652                             rc = usbfsRead8(pszValue, 16, &Dev.bDeviceClass, &psz);
    653                             if (RT_SUCCESS(rc) && Dev.bDeviceClass == 9 /* HUB */)
     651                            vrc = usbfsRead8(pszValue, 16, &Dev.bDeviceClass, &psz);
     652                            if (RT_SUCCESS(vrc) && Dev.bDeviceClass == 9 /* HUB */)
    654653                                Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
    655654                        }
    656655                        else if (PREFIX("Sub="))
    657                             rc = usbfsRead8(pszValue, 16, &Dev.bDeviceSubClass, &psz);
     656                            vrc = usbfsRead8(pszValue, 16, &Dev.bDeviceSubClass, &psz);
    658657                        else if (PREFIX("Prot="))
    659                             rc = usbfsRead8(pszValue, 16, &Dev.bDeviceProtocol, &psz);
     658                            vrc = usbfsRead8(pszValue, 16, &Dev.bDeviceProtocol, &psz);
    660659                        //else if (PREFIX("MxPS="))
    661                         //    rc = usbRead16(pszValue, 10, &Dev.wMaxPacketSize, &psz);
     660                        //    vrc = usbRead16(pszValue, 10, &Dev.wMaxPacketSize, &psz);
    662661                        else if (PREFIX("#Cfgs="))
    663                             rc = usbfsRead8(pszValue, 10, &Dev.bNumConfigurations, &psz);
     662                            vrc = usbfsRead8(pszValue, 10, &Dev.bNumConfigurations, &psz);
    664663                        else
    665664                            psz = usbfsReadSkip(psz);
     
    677676                 */
    678677                case 'P':
    679                     while (*psz && RT_SUCCESS(rc))
     678                    while (*psz && RT_SUCCESS(vrc))
    680679                    {
    681680                        if (PREFIX("Vendor="))
    682                             rc = usbfsRead16(pszValue, 16, &Dev.idVendor, &psz);
     681                            vrc = usbfsRead16(pszValue, 16, &Dev.idVendor, &psz);
    683682                        else if (PREFIX("ProdID="))
    684                             rc = usbfsRead16(pszValue, 16, &Dev.idProduct, &psz);
     683                            vrc = usbfsRead16(pszValue, 16, &Dev.idProduct, &psz);
    685684                        else if (PREFIX("Rev="))
    686                             rc = usbfsReadBCD(pszValue, 16, &Dev.bcdDevice, &psz);
     685                            vrc = usbfsReadBCD(pszValue, 16, &Dev.bcdDevice, &psz);
    687686                        else
    688687                            psz = usbfsReadSkip(psz);
     
    697696                case 'S':
    698697                    if (PREFIX("Manufacturer="))
    699                         rc = usbfsReadStr(pszValue, &Dev.pszManufacturer);
     698                        vrc = usbfsReadStr(pszValue, &Dev.pszManufacturer);
    700699                    else if (PREFIX("Product="))
    701                         rc = usbfsReadStr(pszValue, &Dev.pszProduct);
     700                        vrc = usbfsReadStr(pszValue, &Dev.pszProduct);
    702701                    else if (PREFIX("SerialNumber="))
    703702                    {
    704                         rc = usbfsReadStr(pszValue, &Dev.pszSerialNumber);
    705                         if (RT_SUCCESS(rc))
     703                        vrc = usbfsReadStr(pszValue, &Dev.pszSerialNumber);
     704                        if (RT_SUCCESS(vrc))
    706705                            Dev.u64SerialHash = USBLibHashSerial(pszValue);
    707706                    }
     
    735734                {
    736735                    /* Check for thing we don't support.  */
    737                     while (*psz && RT_SUCCESS(rc))
     736                    while (*psz && RT_SUCCESS(vrc))
    738737                    {
    739738                        if (PREFIX("Driver="))
    740739                        {
    741740                            const char *pszDriver = NULL;
    742                             rc = usbfsReadStr(pszValue, &pszDriver);
     741                            vrc = usbfsReadStr(pszValue, &pszDriver);
    743742                            if (   !pszDriver
    744743                                || !*pszDriver
     
    756755                        {
    757756                            uint8_t bInterfaceClass;
    758                             rc = usbfsRead8(pszValue, 16, &bInterfaceClass, &psz);
    759                             if (RT_SUCCESS(rc) && bInterfaceClass == 9 /* HUB */)
     757                            vrc = usbfsRead8(pszValue, 16, &bInterfaceClass, &psz);
     758                            if (RT_SUCCESS(vrc) && bInterfaceClass == 9 /* HUB */)
    760759                                Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
    761760                        }
     
    789788        AssertMsg(cHits >= 3 || cHits == 0, ("cHits=%d\n", cHits));
    790789        if (cHits >= 3)
    791             rc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, rc);
     790            vrc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, vrc);
    792791
    793792        /*
    794793         * Success?
    795794         */
    796         if (RT_FAILURE(rc))
     795        if (RT_FAILURE(vrc))
    797796        {
    798797            while (pFirst)
     
    804803        }
    805804    }
    806     if (RT_FAILURE(rc))
    807         LogFlow(("USBProxyServiceLinux::getDevices: rc=%Rrc\n", rc));
     805    if (RT_FAILURE(vrc))
     806        LogFlow(("USBProxyServiceLinux::getDevices: vrc=%Rrc\n", vrc));
    808807    return pFirst;
    809808}
     
    892891
    893892    int64_t device;
    894     int rc = RTLinuxSysFsReadIntFile(10, &device, "%s/devnum", pszNode);
    895     if (RT_FAILURE(rc))
     893    int vrc = RTLinuxSysFsReadIntFile(10, &device, "%s/devnum", pszNode);
     894    if (RT_FAILURE(vrc))
    896895        return VINF_SUCCESS;
    897896
     
    901900
    902901    char szDevPath[RTPATH_MAX];
    903     rc = RTLinuxCheckDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
    904                                 szDevPath, sizeof(szDevPath),
    905                                 "%s/%.3d/%.3d",
    906                                 pszDevicesRoot, bus, device);
    907     if (RT_FAILURE(rc))
     902    vrc = RTLinuxCheckDevicePath(devnum, RTFS_TYPE_DEV_CHAR, szDevPath, sizeof(szDevPath),
     903                                 "%s/%.3d/%.3d", pszDevicesRoot, bus, device);
     904    if (RT_FAILURE(vrc))
    908905        return VINF_SUCCESS;
    909906
     
    911908    if (usbsysfsInitDevInfo(&info, szDevPath, pszNode))
    912909    {
    913         rc = VEC_PUSH_BACK_OBJ(pvecDevInfo, USBDeviceInfo, &info);
    914         if (RT_SUCCESS(rc))
     910        vrc = VEC_PUSH_BACK_OBJ(pvecDevInfo, USBDeviceInfo, &info);
     911        if (RT_SUCCESS(vrc))
    915912            return VINF_SUCCESS;
    916913    }
     
    991988    if (pszDup)
    992989    {
    993         int rc = VEC_PUSH_BACK_PTR(&pInfo->mvecpszInterfaces, char *, pszDup);
    994         if (RT_SUCCESS(rc))
     990        int vrc = VEC_PUSH_BACK_PTR(&pInfo->mvecpszInterfaces, char *, pszDup);
     991        if (RT_SUCCESS(vrc))
    995992            return VINF_SUCCESS;
    996993        RTStrFree(pszDup);
     
    10101007{
    10111008    struct dirent entry, *pResult;
    1012     int err, rc;
     1009    int err;
    10131010
    10141011#if RT_GNUC_PREREQ(4, 6)
     
    10331030        if (!pszPathCopy)
    10341031            return VERR_NO_MEMORY;
    1035         if (RT_FAILURE(rc = VEC_PUSH_BACK_PTR(pvecpchDevs, char *, pszPathCopy)))
    1036             return rc;
     1032        int vrc = VEC_PUSH_BACK_PTR(pvecpchDevs, char *, pszPathCopy);
     1033        if (RT_FAILURE(vrc))
     1034            return vrc;
    10371035    }
    10381036    return RTErrConvertFromErrno(err);
     
    10581056    if (!pDir)
    10591057        return RTErrConvertFromErrno(errno);
    1060     int rc = usbsysfsReadFilePathsFromDir(pszPath, pDir, pvecpchDevs);
    1061     if (closedir(pDir) < 0 && RT_SUCCESS(rc))
    1062         rc = RTErrConvertFromErrno(errno);
    1063     return rc;
     1058    int vrc = usbsysfsReadFilePathsFromDir(pszPath, pDir, pvecpchDevs);
     1059    if (closedir(pDir) < 0 && RT_SUCCESS(vrc))
     1060        vrc = RTErrConvertFromErrno(errno);
     1061    return vrc;
    10641062}
    10651063
     
    10811079    LogFlowFunc (("pvecDevInfo=%p\n", pvecDevInfo));
    10821080
    1083     int rc = usbsysfsReadFilePaths("/sys/bus/usb/devices", pvecpchDevs);
    1084     if (RT_FAILURE(rc))
    1085         return rc;
     1081    int vrc = usbsysfsReadFilePaths("/sys/bus/usb/devices", pvecpchDevs);
     1082    if (RT_FAILURE(vrc))
     1083        return vrc;
    10861084
    10871085    char **ppszEntry;
    10881086    VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
    10891087    {
    1090         rc = usbsysfsAddIfDevice(pszDevicesRoot, *ppszEntry, pvecDevInfo);
    1091         if (RT_FAILURE(rc))
    1092             return rc;
     1088        vrc = usbsysfsAddIfDevice(pszDevicesRoot, *ppszEntry, pvecDevInfo);
     1089        if (RT_FAILURE(vrc))
     1090            return vrc;
    10931091    }
    10941092
     
    10971095        VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
    10981096        {
    1099             rc = usbsysfsAddIfInterfaceOf(*ppszEntry, pInfo);
    1100             if (RT_FAILURE(rc))
    1101                 return rc;
     1097            vrc = usbsysfsAddIfInterfaceOf(*ppszEntry, pInfo);
     1098            if (RT_FAILURE(vrc))
     1099                return vrc;
    11021100        }
    11031101    return VINF_SUCCESS;
     
    11121110    LogFlowFunc(("entered\n"));
    11131111    VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
    1114     int rc = usbsysfsEnumerateHostDevicesWorker(pszDevicesRoot, pvecDevInfo, &vecpchDevs);
     1112    int vrc = usbsysfsEnumerateHostDevicesWorker(pszDevicesRoot, pvecDevInfo, &vecpchDevs);
    11151113    VEC_CLEANUP_PTR(&vecpchDevs);
    1116     LogFlowFunc(("rc=%Rrc\n", rc));
    1117     return rc;
     1114    LogFlowFunc(("vrc=%Rrc\n", vrc));
     1115    return vrc;
    11181116}
    11191117
     
    11851183                            ? pchDot  + 1
    11861184                            : pchDash + 1;
    1187     int rc = RTStrToUInt8Full(pszLastPort, 10, pu8Port);
    1188     if (rc != VINF_SUCCESS)
    1189     {
    1190         Log(("usbGetPortFromSysfsPath(%s): failed [3], rc=%Rrc\n", pszPath, rc));
     1185    int vrc = RTStrToUInt8Full(pszLastPort, 10, pu8Port);
     1186    if (vrc != VINF_SUCCESS)
     1187    {
     1188        Log(("usbGetPortFromSysfsPath(%s): failed [3], vrc=%Rrc\n", pszPath, vrc));
    11911189        return VERR_INVALID_PARAMETER;
    11921190    }
     
    12191217
    12201218    pszBuf = RTStrStripL(pszBuf);
    1221     int rc = RTStrToInt32Ex(pszBuf, &pszNext, 16, &i32);
    1222     if (   RT_FAILURE(rc)
    1223         || rc == VWRN_NUMBER_TOO_BIG
     1219    int vrc = RTStrToInt32Ex(pszBuf, &pszNext, 16, &i32);
     1220    if (   RT_FAILURE(vrc)
     1221        || vrc == VWRN_NUMBER_TOO_BIG
    12241222        || i32 < 0)
    12251223        return VERR_NUMBER_TOO_BIG;
     
    12291227            return VERR_NUMBER_TOO_BIG;
    12301228        int32_t i32Lo;
    1231         rc = RTStrToInt32Ex(pszNext+1, &pszNext, 16, &i32Lo);
    1232         if (   RT_FAILURE(rc)
    1233             || rc == VWRN_NUMBER_TOO_BIG
     1229        vrc = RTStrToInt32Ex(pszNext+1, &pszNext, 16, &i32Lo);
     1230        if (   RT_FAILURE(vrc)
     1231            || vrc == VWRN_NUMBER_TOO_BIG
    12341232            || i32Lo > 255
    12351233            || i32Lo < 0)
     
    12521250 * @returns uint8_t value of the given property.
    12531251 * @param   uBase       The base of the number in the sysfs property.
    1254  * @param   bDef        The default to set on error.
     1252 * @param   fDef        The default to set on error.
    12551253 * @param   pszFormat   The format string for the property.
    12561254 * @param   ...         Arguments for the format string.
    12571255 */
    1258 static uint8_t usbsysfsReadDevicePropertyU8Def(unsigned uBase, uint8_t bDef, const char *pszFormat, ...)
     1256static uint8_t usbsysfsReadDevicePropertyU8Def(unsigned uBase, uint8_t fDef, const char *pszFormat, ...)
    12591257{
    12601258    int64_t i64Tmp = 0;
     
    12621260    va_list va;
    12631261    va_start(va, pszFormat);
    1264     int rc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
     1262    int vrc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
    12651263    va_end(va);
    1266     if (RT_SUCCESS(rc))
     1264    if (RT_SUCCESS(vrc))
    12671265        return (uint8_t)i64Tmp;
    1268     else
    1269         return bDef;
     1266    return fDef;
    12701267}
    12711268
     
    12871284    va_list va;
    12881285    va_start(va, pszFormat);
    1289     int rc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
     1286    int vrc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
    12901287    va_end(va);
    1291     if (RT_SUCCESS(rc))
     1288    if (RT_SUCCESS(vrc))
    12921289        return (uint16_t)i64Tmp;
    1293     else
    1294         return u16Def;
     1290    return u16Def;
    12951291}
    12961292
     
    12981294static void usbsysfsFillInDevice(USBDEVICE *pDev, USBDeviceInfo *pInfo)
    12991295{
    1300     int rc;
     1296    int vrc;
    13011297    const char *pszSysfsPath = pInfo->mSysfsPath;
    13021298
     
    13191315
    13201316    /* For simplicity, we just do strcmps on the next one. */
    1321     rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/speed", pszSysfsPath);
    1322     if (RT_FAILURE(rc) || cchRead == sizeof(szBuf))
     1317    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/speed", pszSysfsPath);
     1318    if (RT_FAILURE(vrc) || cchRead == sizeof(szBuf))
    13231319        pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
    13241320    else
     
    13291325                       : USBDEVICESPEED_UNKNOWN;
    13301326
    1331     rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/version", pszSysfsPath);
    1332     if (RT_FAILURE(rc) || cchRead == sizeof(szBuf))
     1327    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/version", pszSysfsPath);
     1328    if (RT_FAILURE(vrc) || cchRead == sizeof(szBuf))
    13331329        pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
    13341330    else
    13351331    {
    1336         rc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdUSB);
    1337         if (RT_FAILURE(rc))
     1332        vrc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdUSB);
     1333        if (RT_FAILURE(vrc))
    13381334        {
    13391335            pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
     
    13421338    }
    13431339
    1344     rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/bcdDevice", pszSysfsPath);
    1345     if (RT_FAILURE(rc) || cchRead == sizeof(szBuf))
     1340    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/bcdDevice", pszSysfsPath);
     1341    if (RT_FAILURE(vrc) || cchRead == sizeof(szBuf))
    13461342        pDev->bcdDevice = UINT16_MAX;
    13471343    else
    13481344    {
    1349         rc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdDevice);
    1350         if (RT_FAILURE(rc))
     1345        vrc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdDevice);
     1346        if (RT_FAILURE(vrc))
    13511347            pDev->bcdDevice = UINT16_MAX;
    13521348    }
    13531349
    13541350    /* Now do things that need string duplication */
    1355     rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/product", pszSysfsPath);
    1356     if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
     1351    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/product", pszSysfsPath);
     1352    if (RT_SUCCESS(vrc) && cchRead < sizeof(szBuf))
    13571353    {
    13581354        USBLibPurgeEncoding(szBuf);
     
    13601356    }
    13611357
    1362     rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/serial", pszSysfsPath);
    1363     if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
     1358    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/serial", pszSysfsPath);
     1359    if (RT_SUCCESS(vrc) && cchRead < sizeof(szBuf))
    13641360    {
    13651361        USBLibPurgeEncoding(szBuf);
     
    13681364    }
    13691365
    1370     rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/manufacturer", pszSysfsPath);
    1371     if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
     1366    vrc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/manufacturer", pszSysfsPath);
     1367    if (RT_SUCCESS(vrc) && cchRead < sizeof(szBuf))
    13721368    {
    13731369        USBLibPurgeEncoding(szBuf);
     
    13831379    VEC_FOR_EACH(&pInfo->mvecpszInterfaces, char *, ppszIf)
    13841380    {
    1385         rc = RTLinuxSysFsGetLinkDest(szBuf, sizeof(szBuf), NULL, "%s/driver", *ppszIf);
    1386         if (RT_SUCCESS(rc) && pDev->enmState != USBDEVICESTATE_UNSUPPORTED)
     1381        vrc = RTLinuxSysFsGetLinkDest(szBuf, sizeof(szBuf), NULL, "%s/driver", *ppszIf);
     1382        if (RT_SUCCESS(vrc) && pDev->enmState != USBDEVICESTATE_UNSUPPORTED)
    13871383            pDev->enmState = (strcmp(szBuf, "hub") == 0)
    13881384                           ? USBDEVICESTATE_UNSUPPORTED
     
    14161412    VECTOR_OBJ(USBDeviceInfo) vecDevInfo;
    14171413    USBDeviceInfo *pInfo;
    1418     int rc;
    14191414
    14201415    VEC_INIT_OBJ(&vecDevInfo, USBDeviceInfo, usbsysfsCleanupDevInfo);
    1421     rc = usbsysfsEnumerateHostDevices(pszDevicesRoot, &vecDevInfo);
    1422     if (RT_FAILURE(rc))
     1416    int vrc = usbsysfsEnumerateHostDevices(pszDevicesRoot, &vecDevInfo);
     1417    if (RT_FAILURE(vrc))
    14231418        return NULL;
    14241419    VEC_FOR_EACH(&vecDevInfo, USBDeviceInfo, pInfo)
     
    14261421        USBDEVICE *pDev = (USBDEVICE *)RTMemAllocZ(sizeof(USBDEVICE));
    14271422        if (!pDev)
    1428             rc = VERR_NO_MEMORY;
    1429         if (RT_SUCCESS(rc))
     1423            vrc = VERR_NO_MEMORY;
     1424        if (RT_SUCCESS(vrc))
    14301425            usbsysfsFillInDevice(pDev, pInfo);
    1431         if (   RT_SUCCESS(rc)
     1426        if (   RT_SUCCESS(vrc)
    14321427            && (   pDev->enmState != USBDEVICESTATE_UNSUPPORTED
    14331428                || fUnsupportedDevicesToo)
     
    14451440        else
    14461441            deviceFree(pDev);
    1447         if (RT_FAILURE(rc))
     1442        if (RT_FAILURE(vrc))
    14481443            break;
    14491444    }
    1450     if (RT_FAILURE(rc))
     1445    if (RT_FAILURE(vrc))
    14511446        deviceListFree(&pFirst);
    14521447
  • trunk/src/VBox/Main/src-server/linux/USBProxyBackendLinux.cpp

    r98103 r98288  
    9999
    100100    const char *pcszDevicesRoot;
    101     int rc = USBProxyLinuxChooseMethod(&mUsingUsbfsDevices, &pcszDevicesRoot);
    102     if (RT_SUCCESS(rc))
     101    int vrc = USBProxyLinuxChooseMethod(&mUsingUsbfsDevices, &pcszDevicesRoot);
     102    if (RT_SUCCESS(vrc))
    103103    {
    104104        mDevicesRoot = pcszDevicesRoot;
    105         rc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
     105        vrc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
    106106        /* For the day when we have VBoxSVC release logging... */
    107         LogRel((RT_SUCCESS(rc) ? "Successfully initialised host USB using %s\n"
    108                                : "Failed to initialise host USB using %s\n",
     107        LogRel((RT_SUCCESS(vrc) ? "Successfully initialised host USB using %s\n"
     108                                : "Failed to initialise host USB using %s\n",
    109109                mUsingUsbfsDevices ? "USBFS" : "sysfs"));
    110110    }
    111111
    112     return rc;
     112    return vrc;
    113113}
    114114
     
    146146     * Open the devices file.
    147147     */
    148     int rc;
     148    int vrc;
    149149    char *pszDevices = RTPathJoinA(mDevicesRoot.c_str(), "devices");
    150150    if (pszDevices)
    151151    {
    152         rc = RTFileOpen(&mhFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    153         if (RT_SUCCESS(rc))
     152        vrc = RTFileOpen(&mhFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
     153        if (RT_SUCCESS(vrc))
    154154        {
    155             rc = RTPipeCreate(&mhWakeupPipeR, &mhWakeupPipeW, 0 /*fFlags*/);
    156             if (RT_SUCCESS(rc))
     155            vrc = RTPipeCreate(&mhWakeupPipeR, &mhWakeupPipeW, 0 /*fFlags*/);
     156            if (RT_SUCCESS(vrc))
    157157            {
    158158                /*
    159159                 * Start the poller thread.
    160160                 */
    161                 rc = start();
    162                 if (RT_SUCCESS(rc))
     161                vrc = start();
     162                if (RT_SUCCESS(vrc))
    163163                {
    164164                    RTStrFree(pszDevices);
     
    172172            }
    173173            else
    174                 Log(("USBProxyBackendLinux::USBProxyBackendLinux: RTFilePipe failed with rc=%Rrc\n", rc));
     174                Log(("USBProxyBackendLinux::USBProxyBackendLinux: RTFilePipe failed with vrc=%Rrc\n", vrc));
    175175            RTFileClose(mhFile);
    176176        }
     
    180180    else
    181181    {
    182         rc = VERR_NO_MEMORY;
     182        vrc = VERR_NO_MEMORY;
    183183        Log(("USBProxyBackendLinux::USBProxyBackendLinux: out of memory!\n"));
    184184    }
    185185
    186     LogFlowThisFunc(("returns failure!!! (rc=%Rrc)\n", rc));
    187     return rc;
     186    LogFlowThisFunc(("returns failure!!! (vrc=%Rrc)\n", vrc));
     187    return vrc;
    188188}
    189189
     
    207207        return VERR_NO_MEMORY;
    208208    }
    209     int rc = mpWaiter->getStatus();
    210     if (RT_SUCCESS(rc) || rc == VERR_TIMEOUT || rc == VERR_TRY_AGAIN)
    211         rc = start();
    212     else if (rc == VERR_NOT_SUPPORTED)
     209    int vrc = mpWaiter->getStatus();
     210    if (RT_SUCCESS(vrc) || vrc == VERR_TIMEOUT || vrc == VERR_TRY_AGAIN)
     211        vrc = start();
     212    else if (vrc == VERR_NOT_SUPPORTED)
    213213        /* This can legitimately happen if hal or DBus are not running, but of
    214214         * course we can't start in this case. */
    215         rc = VINF_SUCCESS;
    216     return rc;
     215        vrc = VINF_SUCCESS;
     216    return vrc;
    217217
    218218#else  /* !VBOX_USB_WITH_SYSFS */
     
    307307int USBProxyBackendLinux::wait(RTMSINTERVAL aMillies)
    308308{
    309     int rc;
     309    int vrc;
    310310    if (mUsingUsbfsDevices)
    311         rc = waitUsbfs(aMillies);
     311        vrc = waitUsbfs(aMillies);
    312312    else
    313         rc = waitSysfs(aMillies);
    314     return rc;
     313        vrc = waitSysfs(aMillies);
     314    return vrc;
    315315}
    316316
     
    338338    PollFds[1].events    = POLLIN | POLLERR | POLLHUP;
    339339
    340     int rc = poll(&PollFds[0], 2, aMillies);
    341     if (rc == 0)
     340    int iRc = poll(&PollFds[0], 2, aMillies);
     341    if (iRc == 0)
    342342        return VERR_TIMEOUT;
    343     if (rc > 0)
     343    if (iRc > 0)
    344344    {
    345345        /* drain the pipe */
     
    347347        {
    348348            char szBuf[WAKE_UP_STRING_LEN];
    349             rc = RTPipeReadBlocking(mhWakeupPipeR, szBuf, sizeof(szBuf), NULL);
    350             AssertRC(rc);
     349            int vrc2 = RTPipeReadBlocking(mhWakeupPipeR, szBuf, sizeof(szBuf), NULL);
     350            AssertRC(vrc2);
    351351        }
    352352        return VINF_SUCCESS;
     
    359359{
    360360#ifdef VBOX_USB_WITH_SYSFS
    361     int rc = mpWaiter->Wait(aMillies);
    362     if (rc == VERR_TRY_AGAIN)
     361    int vrc = mpWaiter->Wait(aMillies);
     362    if (vrc == VERR_TRY_AGAIN)
    363363    {
    364364        RTThreadYield();
    365         rc = VINF_SUCCESS;
    366     }
    367     return rc;
     365        vrc = VINF_SUCCESS;
     366    }
     367    return vrc;
    368368#else  /* !VBOX_USB_WITH_SYSFS */
    369369    return USBProxyService::wait(aMillies);
     
    386386    }
    387387#endif /* VBOX_USB_WITH_SYSFS */
    388     int rc = RTPipeWriteBlocking(mhWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL);
    389     if (RT_SUCCESS(rc))
     388    int vrc = RTPipeWriteBlocking(mhWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL);
     389    if (RT_SUCCESS(vrc))
    390390        RTPipeFlush(mhWakeupPipeW);
    391     LogFlowFunc(("returning %Rrc\n", rc));
    392     return rc;
     391    LogFlowFunc(("returning %Rrc\n", vrc));
     392    return vrc;
    393393}
    394394
Note: See TracChangeset for help on using the changeset viewer.

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