VirtualBox

Changeset 101462 in vbox


Ignore:
Timestamp:
Oct 17, 2023 8:38:52 AM (17 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
159531
Message:

Main/ConsoleImpl: Move the PDM configuration out of the x86 config constructor into a separate method and make use of it from the Armv8 constructor, bugref:10528

Location:
trunk/src/VBox/Main
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/include/ConsoleImpl.h

    r101459 r101462  
    839839                          bool fOsXGuest, bool *pfAudioEnabled);
    840840    int i_configVmmDev(ComPtr<IMachine> pMachine, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices);
     841    int i_configPdm(ComPtr<IMachine> pMachine, PCVMMR3VTABLE pVMM, PUVM pUVM, PCFGMNODE pRoot);
    841842
    842843    static DECLCALLBACK(void) i_vmstateChangeCallback(PUVM pUVM, PCVMMR3VTABLE pVMM, VMSTATE enmState,

  • trunk/src/VBox/Main/src-client/ConsoleImplConfigArmV8.cpp

    r101443 r101462  
    333333         *  Load drivers in VBoxC.[so|dll]
    334334         */
    335         PCFGMNODE pPDM;
    336         PCFGMNODE pNode;
    337         PCFGMNODE pMod;
    338         InsertConfigNode(pRoot,    "PDM", &pPDM);
    339         InsertConfigNode(pPDM,     "Devices", &pNode);
    340         InsertConfigNode(pPDM,     "Drivers", &pNode);
    341         InsertConfigNode(pNode,    "VBoxC", &pMod);
    342 #ifdef VBOX_WITH_XPCOM
    343         // VBoxC is located in the components subdirectory
    344         char szPathVBoxC[RTPATH_MAX];
    345         vrc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX);                                VRC();
    346         vrc = RTPathAppend(szPathVBoxC, RTPATH_MAX, "/components/VBoxC");                   VRC();
    347         InsertConfigString(pMod,   "Path",  szPathVBoxC);
    348 #else
    349         InsertConfigString(pMod,   "Path",  "VBoxC");
    350 #endif
    351 
    352 
    353         /*
    354          * Block cache settings.
    355          */
    356         PCFGMNODE pPDMBlkCache;
    357         InsertConfigNode(pPDM, "BlkCache", &pPDMBlkCache);
    358 
    359         /* I/O cache size */
    360         ULONG ioCacheSize = 5;
    361         hrc = pMachine->COMGETTER(IOCacheSize)(&ioCacheSize);                               H();
    362         InsertConfigInteger(pPDMBlkCache, "CacheSize", ioCacheSize * _1M);
    363 
    364         /*
    365          * Bandwidth groups.
    366          */
    367         ComPtr<IBandwidthControl> bwCtrl;
    368 
    369         hrc = pMachine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam());                   H();
    370 
    371         com::SafeIfaceArray<IBandwidthGroup> bwGroups;
    372         hrc = bwCtrl->GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups));              H();
    373 
    374         PCFGMNODE pAc;
    375         InsertConfigNode(pPDM, "AsyncCompletion", &pAc);
    376         PCFGMNODE pAcFile;
    377         InsertConfigNode(pAc,  "File", &pAcFile);
    378         PCFGMNODE pAcFileBwGroups;
    379         InsertConfigNode(pAcFile,  "BwGroups", &pAcFileBwGroups);
    380 #ifdef VBOX_WITH_NETSHAPER
    381         PCFGMNODE pNetworkShaper;
    382         InsertConfigNode(pPDM, "NetworkShaper",  &pNetworkShaper);
    383         PCFGMNODE pNetworkBwGroups;
    384         InsertConfigNode(pNetworkShaper, "BwGroups", &pNetworkBwGroups);
    385 #endif /* VBOX_WITH_NETSHAPER */
    386 
    387         for (size_t i = 0; i < bwGroups.size(); i++)
    388         {
    389             Bstr strName;
    390             hrc = bwGroups[i]->COMGETTER(Name)(strName.asOutParam());                       H();
    391             if (strName.isEmpty())
    392                 return pVMM->pfnVMR3SetError(pUVM, VERR_CFGM_NO_NODE, RT_SRC_POS, N_("No bandwidth group name specified"));
    393 
    394             BandwidthGroupType_T enmType = BandwidthGroupType_Null;
    395             hrc = bwGroups[i]->COMGETTER(Type)(&enmType);                                   H();
    396             LONG64 cMaxBytesPerSec = 0;
    397             hrc = bwGroups[i]->COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec);                 H();
    398 
    399             if (enmType == BandwidthGroupType_Disk)
    400             {
    401                 PCFGMNODE pBwGroup;
    402                 InsertConfigNode(pAcFileBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
    403                 InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
    404                 InsertConfigInteger(pBwGroup, "Start", cMaxBytesPerSec);
    405                 InsertConfigInteger(pBwGroup, "Step", 0);
    406             }
    407 #ifdef VBOX_WITH_NETSHAPER
    408             else if (enmType == BandwidthGroupType_Network)
    409             {
    410                 /* Network bandwidth groups. */
    411                 PCFGMNODE pBwGroup;
    412                 InsertConfigNode(pNetworkBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
    413                 InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
    414             }
    415 #endif /* VBOX_WITH_NETSHAPER */
    416         }
     335        vrc = i_configPdm(pMachine, pVMM, pUVM, pRoot);                                      VRC();
     336
    417337
    418338        /*

  • trunk/src/VBox/Main/src-client/ConsoleImplConfigCommon.cpp

    r101459 r101462  
    34293429#define VRC()   AssertLogRelMsgReturn(RT_SUCCESS(vrc), ("vrc=%Rrc\n", vrc), vrc)
    34303430
     3431int Console::i_configPdm(ComPtr<IMachine> pMachine, PCVMMR3VTABLE pVMM, PUVM pUVM, PCFGMNODE pRoot)
     3432{
     3433    PCFGMNODE pPDM;
     3434    PCFGMNODE pNode;
     3435    PCFGMNODE pMod;
     3436    InsertConfigNode(pRoot,    "PDM", &pPDM);
     3437    InsertConfigNode(pPDM,     "Devices", &pNode);
     3438    InsertConfigNode(pPDM,     "Drivers", &pNode);
     3439    InsertConfigNode(pNode,    "VBoxC", &pMod);
     3440#ifdef VBOX_WITH_XPCOM
     3441    // VBoxC is located in the components subdirectory
     3442    char szPathVBoxC[RTPATH_MAX];
     3443    int vrc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX);                            VRC();
     3444    vrc = RTPathAppend(szPathVBoxC, RTPATH_MAX, "/components/VBoxC");                   VRC();
     3445    InsertConfigString(pMod,   "Path",  szPathVBoxC);
     3446#else
     3447    InsertConfigString(pMod,   "Path",  "VBoxC");
     3448#endif
     3449
     3450
     3451    /*
     3452     * Block cache settings.
     3453     */
     3454    PCFGMNODE pPDMBlkCache;
     3455    InsertConfigNode(pPDM, "BlkCache", &pPDMBlkCache);
     3456
     3457    /* I/O cache size */
     3458    ULONG ioCacheSize = 5;
     3459    HRESULT hrc = pMachine->COMGETTER(IOCacheSize)(&ioCacheSize);                       H();
     3460    InsertConfigInteger(pPDMBlkCache, "CacheSize", ioCacheSize * _1M);
     3461
     3462    /*
     3463     * Bandwidth groups.
     3464     */
     3465    ComPtr<IBandwidthControl> bwCtrl;
     3466
     3467    hrc = pMachine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam());                   H();
     3468
     3469    com::SafeIfaceArray<IBandwidthGroup> bwGroups;
     3470    hrc = bwCtrl->GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups));              H();
     3471
     3472    PCFGMNODE pAc;
     3473    InsertConfigNode(pPDM, "AsyncCompletion", &pAc);
     3474    PCFGMNODE pAcFile;
     3475    InsertConfigNode(pAc,  "File", &pAcFile);
     3476    PCFGMNODE pAcFileBwGroups;
     3477    InsertConfigNode(pAcFile,  "BwGroups", &pAcFileBwGroups);
     3478#ifdef VBOX_WITH_NETSHAPER
     3479    PCFGMNODE pNetworkShaper;
     3480    InsertConfigNode(pPDM, "NetworkShaper",  &pNetworkShaper);
     3481    PCFGMNODE pNetworkBwGroups;
     3482    InsertConfigNode(pNetworkShaper, "BwGroups", &pNetworkBwGroups);
     3483#endif /* VBOX_WITH_NETSHAPER */
     3484
     3485    for (size_t i = 0; i < bwGroups.size(); i++)
     3486    {
     3487        Bstr strName;
     3488        hrc = bwGroups[i]->COMGETTER(Name)(strName.asOutParam());                       H();
     3489        if (strName.isEmpty())
     3490            return pVMM->pfnVMR3SetError(pUVM, VERR_CFGM_NO_NODE, RT_SRC_POS, N_("No bandwidth group name specified"));
     3491
     3492        BandwidthGroupType_T enmType = BandwidthGroupType_Null;
     3493        hrc = bwGroups[i]->COMGETTER(Type)(&enmType);                                   H();
     3494        LONG64 cMaxBytesPerSec = 0;
     3495        hrc = bwGroups[i]->COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec);                 H();
     3496
     3497        if (enmType == BandwidthGroupType_Disk)
     3498        {
     3499            PCFGMNODE pBwGroup;
     3500            InsertConfigNode(pAcFileBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
     3501            InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
     3502            InsertConfigInteger(pBwGroup, "Start", cMaxBytesPerSec);
     3503            InsertConfigInteger(pBwGroup, "Step", 0);
     3504        }
     3505#ifdef VBOX_WITH_NETSHAPER
     3506        else if (enmType == BandwidthGroupType_Network)
     3507        {
     3508            /* Network bandwidth groups. */
     3509            PCFGMNODE pBwGroup;
     3510            InsertConfigNode(pNetworkBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
     3511            InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
     3512        }
     3513#endif /* VBOX_WITH_NETSHAPER */
     3514    }
     3515
     3516    /** @todo r=aeichner Looks like this setting is completely unused in VMM/PDM. */
     3517    BOOL fAllowTracingToAccessVM;
     3518    hrc = pMachine->COMGETTER(AllowTracingToAccessVM)(&fAllowTracingToAccessVM);        H();
     3519    if (fAllowTracingToAccessVM)
     3520        InsertConfigInteger(pPDM, "AllowTracingToAccessVM", 1);
     3521
     3522    return VINF_SUCCESS;
     3523}
     3524
     3525
    34313526int Console::i_configAudioCtrl(ComPtr<IVirtualBox> pVBox, ComPtr<IMachine> pMachine, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices,
    34323527                               bool fOsXGuest, bool *pfAudioEnabled)

  • trunk/src/VBox/Main/src-client/ConsoleImplConfigX86.cpp

    r101461 r101462  
    11501150         *  Load drivers in VBoxC.[so|dll]
    11511151         */
    1152         PCFGMNODE pPDM;
    1153         PCFGMNODE pNode;
    1154         PCFGMNODE pMod;
    1155         InsertConfigNode(pRoot,    "PDM", &pPDM);
    1156         InsertConfigNode(pPDM,     "Devices", &pNode);
    1157         InsertConfigNode(pPDM,     "Drivers", &pNode);
    1158         InsertConfigNode(pNode,    "VBoxC", &pMod);
    1159 #ifdef VBOX_WITH_XPCOM
    1160         // VBoxC is located in the components subdirectory
    1161         char szPathVBoxC[RTPATH_MAX];
    1162         vrc = RTPathAppPrivateArch(szPathVBoxC, RTPATH_MAX);                                VRC();
    1163         vrc = RTPathAppend(szPathVBoxC, RTPATH_MAX, "/components/VBoxC");                   VRC();
    1164         InsertConfigString(pMod,   "Path",  szPathVBoxC);
    1165 #else
    1166         InsertConfigString(pMod,   "Path",  "VBoxC");
    1167 #endif
    1168 
    1169 
    1170         /*
    1171          * Block cache settings.
    1172          */
    1173         PCFGMNODE pPDMBlkCache;
    1174         InsertConfigNode(pPDM, "BlkCache", &pPDMBlkCache);
    1175 
    1176         /* I/O cache size */
    1177         ULONG ioCacheSize = 5;
    1178         hrc = pMachine->COMGETTER(IOCacheSize)(&ioCacheSize);                               H();
    1179         InsertConfigInteger(pPDMBlkCache, "CacheSize", ioCacheSize * _1M);
    1180 
    1181         /*
    1182          * Bandwidth groups.
    1183          */
    1184         ComPtr<IBandwidthControl> bwCtrl;
    1185 
    1186         hrc = pMachine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam());                   H();
    1187 
    1188         com::SafeIfaceArray<IBandwidthGroup> bwGroups;
    1189         hrc = bwCtrl->GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups));              H();
    1190 
    1191         PCFGMNODE pAc;
    1192         InsertConfigNode(pPDM, "AsyncCompletion", &pAc);
    1193         PCFGMNODE pAcFile;
    1194         InsertConfigNode(pAc,  "File", &pAcFile);
    1195         PCFGMNODE pAcFileBwGroups;
    1196         InsertConfigNode(pAcFile,  "BwGroups", &pAcFileBwGroups);
    1197 #ifdef VBOX_WITH_NETSHAPER
    1198         PCFGMNODE pNetworkShaper;
    1199         InsertConfigNode(pPDM, "NetworkShaper",  &pNetworkShaper);
    1200         PCFGMNODE pNetworkBwGroups;
    1201         InsertConfigNode(pNetworkShaper, "BwGroups", &pNetworkBwGroups);
    1202 #endif /* VBOX_WITH_NETSHAPER */
    1203 
    1204         for (size_t i = 0; i < bwGroups.size(); i++)
    1205         {
    1206             Bstr strName;
    1207             hrc = bwGroups[i]->COMGETTER(Name)(strName.asOutParam());                       H();
    1208             if (strName.isEmpty())
    1209                 return pVMM->pfnVMR3SetError(pUVM, VERR_CFGM_NO_NODE, RT_SRC_POS, N_("No bandwidth group name specified"));
    1210 
    1211             BandwidthGroupType_T enmType = BandwidthGroupType_Null;
    1212             hrc = bwGroups[i]->COMGETTER(Type)(&enmType);                                   H();
    1213             LONG64 cMaxBytesPerSec = 0;
    1214             hrc = bwGroups[i]->COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec);                 H();
    1215 
    1216             if (enmType == BandwidthGroupType_Disk)
    1217             {
    1218                 PCFGMNODE pBwGroup;
    1219                 InsertConfigNode(pAcFileBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
    1220                 InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
    1221                 InsertConfigInteger(pBwGroup, "Start", cMaxBytesPerSec);
    1222                 InsertConfigInteger(pBwGroup, "Step", 0);
    1223             }
    1224 #ifdef VBOX_WITH_NETSHAPER
    1225             else if (enmType == BandwidthGroupType_Network)
    1226             {
    1227                 /* Network bandwidth groups. */
    1228                 PCFGMNODE pBwGroup;
    1229                 InsertConfigNode(pNetworkBwGroups, Utf8Str(strName).c_str(), &pBwGroup);
    1230                 InsertConfigInteger(pBwGroup, "Max", cMaxBytesPerSec);
    1231             }
    1232 #endif /* VBOX_WITH_NETSHAPER */
    1233         }
     1152        vrc = i_configPdm(pMachine, pVMM, pUVM, pRoot);                                          VRC();
    12341153
    12351154        /*
    … …  
    29412860                InsertConfigString(pDbgf, "TracingConfig", bstr);
    29422861
    2943             BOOL fAllowTracingToAccessVM;
    2944             hrc = pMachine->COMGETTER(AllowTracingToAccessVM)(&fAllowTracingToAccessVM);    H();
    2945             if (fAllowTracingToAccessVM)
    2946                 InsertConfigInteger(pPDM, "AllowTracingToAccessVM", 1);
    2947 
    29482862            /* Debugger console config. */
    29492863            PCFGMNODE pDbgc;
Note: See TracChangeset for help on using the changeset viewer.

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