VirtualBox

Changeset 35830 in vbox for trunk


Ignore:
Timestamp:
Feb 3, 2011 10:49:26 AM (14 years ago)
Author:
vboxsync
Message:

ConsoleImpl2: Fixed some return code confusion, clean-ups.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

    r35753 r35830  
    224224};
    225225
    226 /*
    227  * VC++ 8 / amd64 has some serious trouble with this function.
    228  * As a temporary measure, we'll drop global optimizations.
    229  */
    230 #if defined(_MSC_VER) && defined(RT_ARCH_AMD64)
    231 # pragma optimize("g", off)
    232 #endif
    233 
    234 static int findEfiRom(IVirtualBox* vbox, FirmwareType_T aFirmwareType, Utf8Str& aEfiRomFile)
     226static int findEfiRom(IVirtualBox* vbox, FirmwareType_T aFirmwareType, Utf8Str *pEfiRomFile)
    235227{
    236     int rc;
     228    Bstr aFilePath, empty;
    237229    BOOL fPresent = FALSE;
    238     Bstr aFilePath, empty;
    239 
    240     rc = vbox->CheckFirmwarePresent(aFirmwareType, empty.raw(),
    241                                     empty.asOutParam(), aFilePath.asOutParam(), &fPresent);
    242     if (RT_FAILURE(rc))
    243         AssertComRCReturn(rc, VERR_FILE_NOT_FOUND);
     230    HRESULT hrc = vbox->CheckFirmwarePresent(aFirmwareType, empty.raw(),
     231                                             empty.asOutParam(), aFilePath.asOutParam(), &fPresent);
     232    AssertComRCReturn(hrc, Global::vboxStatusCodeFromCOM(hrc));
    244233
    245234    if (!fPresent)
    246235        return VERR_FILE_NOT_FOUND;
    247236
    248     aEfiRomFile = Utf8Str(aFilePath);
    249 
    250     return S_OK;
     237    *pEfiRomFile = Utf8Str(aFilePath);
     238
     239    return VINF_SUCCESS;
    251240}
    252241
     
    318307}
    319308
     309
     310/*
     311 * VC++ 8 / amd64 has some serious trouble with the next functions.
     312 * As a temporary measure, we'll drop global optimizations.
     313 */
     314#if defined(_MSC_VER) && defined(RT_ARCH_AMD64)
     315# pragma optimize("g", off)
     316#endif
     317
     318
    320319class ConfigError : public iprt::Error
    321320{
     
    533532{
    534533    LogFlowFuncEnter();
    535     PciBusAddress         PciAddr;
    536     bool fFdcEnabled = false;
    537     BOOL fIs64BitGuest = false;
    538534
    539535#if !defined(VBOX_WITH_XPCOM)
     
    589585    RTUUID HardwareUuid;
    590586    rc = RTUuidFromUtf16(&HardwareUuid, bstr.raw());
    591     AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc);
     587    AssertRCReturn(rc, rc);
    592588
    593589    ULONG cRamMBs;
     
    597593        cRamMBs = RTStrToUInt64(RTEnvGet("VBOX_RAM_SIZE"));
    598594#endif
    599     uint64_t const cbRam = cRamMBs * (uint64_t)_1M;
    600     uint32_t cbRamHole = MM_RAM_HOLE_SIZE_DEFAULT;
    601     uint64_t u64McfgBase   = 0;
    602     uint32_t u32McfgLength = 0;
     595    uint64_t const cbRam   = cRamMBs * (uint64_t)_1M;
     596    uint32_t cbRamHole     = MM_RAM_HOLE_SIZE_DEFAULT;
     597    uint64_t uMcfgBase     = 0;
     598    uint32_t cbMcfgLength = 0;
    603599
    604600    ChipsetType_T chipsetType;
     
    608604        /* We'd better have 0x10000000 region, to cover 256 buses
    609605           but this put too much load on hypervisor heap */
    610         u32McfgLength = 0x4000000; //0x10000000;
    611         cbRamHole += u32McfgLength;
    612         u64McfgBase = _4G - cbRamHole;
     606        cbMcfgLength = 0x4000000; //0x10000000;
     607        cbRamHole += cbMcfgLength;
     608        uMcfgBase = _4G - cbRamHole;
    613609    }
    614610
     
    649645         */
    650646        hrc = pMachine->COMGETTER(Name)(bstr.asOutParam());                                 H();
    651         InsertConfigString(pRoot, "Name",                 bstr);
     647        InsertConfigString(pRoot,  "Name",                 bstr);
    652648        InsertConfigBytes(pRoot,   "UUID", &HardwareUuid, sizeof(HardwareUuid));
    653649        InsertConfigInteger(pRoot, "RamSize",              cbRam);
     
    756752         * Hardware virtualization settings.
    757753         */
    758         PCFGMNODE pHWVirtExt;
     754        BOOL        fIsGuest64Bit = false;
     755        PCFGMNODE   pHWVirtExt;
    759756        InsertConfigNode(pRoot, "HWVirtExt", &pHWVirtExt);
    760757        if (fHWVirtExEnabled)
     
    769766            hrc = host->GetProcessorFeature(ProcessorFeature_LongMode,
    770767                                            &fSupportsLongMode);                            H();
    771             hrc = guestOSType->COMGETTER(Is64Bit)(&fIs64BitGuest);                          H();
    772 
    773             if (fSupportsLongMode && fIs64BitGuest)
     768            hrc = guestOSType->COMGETTER(Is64Bit)(&fIsGuest64Bit);                          H();
     769
     770            if (fSupportsLongMode && fIsGuest64Bit)
    774771            {
    775772                InsertConfigInteger(pHWVirtExt, "64bitEnabled", 1);
     
    788785
    789786            /** @todo Not exactly pretty to check strings; VBOXOSTYPE would be better, but that requires quite a bit of API change in Main. */
    790             if (    !fIs64BitGuest
     787            if (    !fIsGuest64Bit
    791788                &&  fIOAPIC
    792789                &&  (   osTypeId == "WindowsNT4"
     
    947944         * PCI buses.
    948945         */
    949         uint32_t u32IocPciAddress, u32HbcPciAddress;
     946        uint32_t uIocPciAddress, uHbcPciAddress;
    950947        switch (chipsetType)
    951948        {
     
    954951            case ChipsetType_PIIX3:
    955952                InsertConfigNode(pDevices, "pci", &pDev);
    956                 u32HbcPciAddress = (0x0 << 16) | 0;
    957                 u32IocPciAddress = (0x1 << 16) | 0; // ISA controller
     953                uHbcPciAddress = (0x0 << 16) | 0;
     954                uIocPciAddress = (0x1 << 16) | 0; // ISA controller
    958955                break;
    959956            case ChipsetType_ICH9:
    960957                InsertConfigNode(pDevices, "ich9pci", &pDev);
    961                 u32HbcPciAddress = (0x1e << 16) | 0;
    962                 u32IocPciAddress = (0x1f << 16) | 0; // LPC controller
     958                uHbcPciAddress = (0x1e << 16) | 0;
     959                uIocPciAddress = (0x1f << 16) | 0; // LPC controller
    963960                break;
    964961        }
     
    970967        {
    971968            /* Provide MCFG info */
    972             InsertConfigInteger(pCfg,  "McfgBase",   u64McfgBase);
    973             InsertConfigInteger(pCfg,  "McfgLength", u32McfgLength);
     969            InsertConfigInteger(pCfg,  "McfgBase",   uMcfgBase);
     970            InsertConfigInteger(pCfg,  "McfgLength", cbMcfgLength);
    974971
    975972
     
    10241021            Bstr bstrKey;
    10251022            rc = getSmcDeviceKey(pMachine, bstrKey.asOutParam(), &fGetKeyFromRealSMC);
    1026             AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc);
     1023            AssertRCReturn(rc, rc);
    10271024
    10281025            InsertConfigString(pCfg,   "DeviceKey", bstrKey);
     
    12421239            InsertConfigBytes(pBiosCfg,    "UUID", &HardwareUuid,sizeof(HardwareUuid));
    12431240            InsertConfigNode(pBiosCfg,     "NetBoot", &pNetBootCfg);
    1244             InsertConfigInteger(pBiosCfg,  "McfgBase",   u64McfgBase);
    1245             InsertConfigInteger(pBiosCfg,  "McfgLength", u32McfgLength);
     1241            InsertConfigInteger(pBiosCfg,  "McfgBase",   uMcfgBase);
     1242            InsertConfigInteger(pBiosCfg,  "McfgLength", cbMcfgLength);
    12461243
    12471244            DeviceType_T bootDevice;
     
    12881285        else
    12891286        {
    1290             Utf8Str efiRomFile;
    1291 
    12921287            /* Autodetect firmware type, basing on guest type */
    12931288            if (eFwType == FirmwareType_EFI)
    12941289            {
    1295                 eFwType =
    1296                         fIs64BitGuest ?
    1297                         (FirmwareType_T)FirmwareType_EFI64
    1298                         :
    1299                         (FirmwareType_T)FirmwareType_EFI32;
    1300             }
    1301             bool f64BitEntry = eFwType == FirmwareType_EFI64;
    1302 
    1303             rc = findEfiRom(virtualBox, eFwType, efiRomFile);
    1304             AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc);
     1290                eFwType = fIsGuest64Bit
     1291                        ? (FirmwareType_T)FirmwareType_EFI64
     1292                        : (FirmwareType_T)FirmwareType_EFI32;
     1293            }
     1294            bool const f64BitEntry = eFwType == FirmwareType_EFI64;
     1295
     1296            Utf8Str efiRomFile;
     1297            rc = findEfiRom(virtualBox, eFwType, &efiRomFile);
     1298            AssertRCReturn(rc, rc);
    13051299
    13061300            /* Get boot args */
     
    13111305            Bstr deviceProps;
    13121306            hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiDeviceProps").raw(), deviceProps.asOutParam()); H();
     1307
    13131308            /* Get GOP mode settings */
    13141309            uint32_t u32GopMode = UINT32_MAX;
     
    13631358        hrc = pMachine->COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(ctrls));       H();
    13641359
     1360        bool fFdcEnabled = false;
    13651361        for (size_t i = 0; i < ctrls.size(); ++i)
    13661362        {
     
    14611457                        {
    14621458                            static const char * const s_apszConfig[4] =
    1463                                     { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
     1459                            { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
    14641460                            static const char * const s_apszBiosConfig[4] =
    1465                                     { "SataPrimaryMasterLUN", "SataPrimarySlaveLUN", "SataSecondaryMasterLUN", "SataSecondarySlaveLUN" };
     1461                            { "SataPrimaryMasterLUN", "SataPrimarySlaveLUN", "SataSecondaryMasterLUN", "SataSecondarySlaveLUN" };
    14661462
    14671463                            LONG lPortNumber = -1;
     
    16871683                iPciDeviceNo = 3;
    16881684#endif
    1689             PciAddr = PciBusAddress(0, iPciDeviceNo, 0);
     1685            PciBusAddress PciAddr = PciBusAddress(0, iPciDeviceNo, 0);
    16901686            hrc = BusMgr->assignPciDevice(pszAdapterName, pInst, PciAddr);                               H();
    16911687
     
    24532449                }
    24542450            }
    2455             InsertConfigInteger(pCfg,  "IocPciAddress", u32IocPciAddress);
     2451            InsertConfigInteger(pCfg,  "IocPciAddress", uIocPciAddress);
    24562452            if (chipsetType == ChipsetType_ICH9)
    24572453            {
    2458                 InsertConfigInteger(pCfg,  "McfgBase",   u64McfgBase);
    2459                 InsertConfigInteger(pCfg,  "McfgLength", u32McfgLength);
    2460             }
    2461             InsertConfigInteger(pCfg,  "HostBusPciAddress", u32HbcPciAddress);
     2454                InsertConfigInteger(pCfg,  "McfgBase",   uMcfgBase);
     2455                InsertConfigInteger(pCfg,  "McfgLength", cbMcfgLength);
     2456            }
     2457            InsertConfigInteger(pCfg,  "HostBusPciAddress", uHbcPciAddress);
    24622458            InsertConfigInteger(pCfg,  "ShowCpu", fShowCpu);
    24632459            InsertConfigInteger(pCfg,  "CpuHotPlug", fCpuHotPlug);
     
    28032799                if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
    28042800                    rc = VINF_SUCCESS;
    2805                 AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc);
     2801                AssertRCReturn(rc, rc);
    28062802
    28072803                CFGMR3RemoveNode(pLunL0);
     
    30403036            rc = PDMR3DeviceAttach(pVM, pcszDevice, 0, uLUN,
    30413037                                PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /*ppBase*/);
    3042             AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc);
     3038            AssertRCReturn(rc, rc);
    30433039
    30443040            /* There is no need to handle removable medium mounting, as we
     
    30803076        HRESULT hrc;
    30813077        Bstr bstr;
    3082 
    3083 #define H()         AssertMsgReturnStmt(!FAILED(hrc), ("hrc=%Rhrc\n", hrc), if (phrc) *phrc = hrc, VERR_GENERAL_FAILURE)
    3084 
    30853078        PCFGMNODE pLunL1 = NULL;
    30863079        PCFGMNODE pCfg = NULL;
     3080
     3081#define H() \
     3082    AssertMsgReturnStmt(SUCCEEDED(hrc), ("hrc=%Rhrc\n", hrc), if (phrc) *phrc = hrc, Global::vboxStatusCodeFromCOM(hrc))
     3083
    30873084
    30883085        BOOL fHostDrive = FALSE;
     
    31383135            if (    pMedium
    31393136                && (   enmType == DeviceType_DVD
    3140                     || enmType == DeviceType_Floppy
    3141             ))
     3137                    || enmType == DeviceType_Floppy)
     3138               )
    31423139            {
    31433140                // if this medium represents an ISO image and this image is inaccessible,
     
    31483145                // would be to discard the VM state...
    31493146                MediumState_T mediumState;
    3150                 rc = pMedium->RefreshState(&mediumState);
    3151                 AssertMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc\n", rc), rc);
    3152 
     3147                hrc = pMedium->RefreshState(&mediumState);                              H();
    31533148                if (mediumState == MediumState_Inaccessible)
    31543149                {
    31553150                    Bstr loc;
    3156                     rc = pMedium->COMGETTER(Location)(loc.asOutParam());
    3157                     if (FAILED(rc)) return rc;
    3158 
     3151                    hrc = pMedium->COMGETTER(Location)(loc.asOutParam());               H();
    31593152                    setVMRuntimeErrorCallbackF(mpVM,
    31603153                                            this,
     
    32003193
    32013194                if (mediumType == MediumType_Readonly)
    3202                 {
    32033195                    InsertConfigInteger(pCfg, "ReadOnly", 1);
    3204                 }
    32053196                else if (enmType == DeviceType_Floppy)
    3206                 {
    32073197                    InsertConfigInteger(pCfg, "MaybeReadOnly", 1);
    3208                 }
    32093198
    32103199                /* Start without exclusive write access to the images. */
     
    32203209                    && (   aMachineState == MachineState_TeleportingIn
    32213210                        || aMachineState == MachineState_FaultTolerantSyncing))
    3222                 {
    32233211                    InsertConfigInteger(pCfg, "TempReadOnly", 1);
    3224                 }
    32253212
    32263213                /* Flag for opening the medium for sharing between VMs. This
     
    32283215                 * in the chain, as shared media can have no diffs. */
    32293216                if (mediumType == MediumType_Shareable)
    3230                 {
    32313217                    InsertConfigInteger(pCfg, "Shareable", 1);
    3232                 }
    32333218
    32343219                if (!fUseHostIOCache)
     
    32493234                    InsertConfigInteger(pCfg, "SetupMerge", 1);
    32503235                    if (uImage == uMergeSource)
    3251                     {
    32523236                        InsertConfigInteger(pCfg, "MergeSource", 1);
    3253                     }
    32543237                    else if (uImage == uMergeTarget)
    3255                     {
    32563238                        InsertConfigInteger(pCfg, "MergeTarget", 1);
    3257                     }
    32583239                }
    32593240
     
    33203301                    {
    33213302                        if (uImage == uMergeSource)
    3322                         {
    33233303                            InsertConfigInteger(pCur, "MergeSource", 1);
    3324                         }
    33253304                        else if (uImage == uMergeTarget)
    3326                         {
    33273305                            InsertConfigInteger(pCur, "MergeTarget", 1);
    3328                         }
    33293306                    }
    33303307
     
    33573334                     * configuration node. Simplifies life of DrvVD a bit. */
    33583335                    if (!fHostIP)
    3359                     {
    33603336                        InsertConfigInteger(pCfg, "HostIPStack", 0);
    3361                     }
    33623337
    33633338                    /* next */
     
    33673342            }
    33683343        }
     3344#undef H
    33693345    }
    33703346    catch (ConfigError &x)
     
    33733349        return x.m_vrc;
    33743350    }
    3375 
    3376 #undef H
    33773351
    33783352    return VINF_SUCCESS;
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