VirtualBox

Changeset 47401 in vbox


Ignore:
Timestamp:
Jul 25, 2013 7:12:24 PM (12 years ago)
Author:
vboxsync
Message:

Main,Frontends: Second step of USB controller rework. There is one controller instance for every USB controller now. Adapt frontends and testsuite to work with the changed API

Location:
trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r47018 r47401  
    447447{
    448448    USBController()
    449         : fEnabled(false),
    450           fEnabledEHCI(false)
     449        : enmType(USBControllerType_Null)
    451450    {}
    452451
    453452    bool operator==(const USBController &u) const;
    454453
    455     bool                    fEnabled;
    456     bool                    fEnabledEHCI;
     454    com::Utf8Str            strName;
     455    USBControllerType_T     enmType;
     456};
     457typedef std::list<USBController> USBControllerList;
     458
     459struct USB
     460{
     461    USB() {}
     462
     463    bool operator==(const USB &u) const;
     464
     465    /** List of USB controllers present. */
     466    USBControllerList       llUSBControllers;
     467    /** List of USB device filters. */
    457468    USBDeviceFiltersList    llDeviceFilters;
    458469};
    … …  
    876887
    877888    BIOSSettings        biosSettings;
    878     USBController       usbController;
     889    USB                 usbSettings;
    879890    NetworkAdaptersList llNetworkAdapters;
    880891    SerialPortsList     llSerialPorts;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r47376 r47401  
    17491749     * USB.
    17501750     */
    1751     ComPtr<IUSBController> USBCtl;
    1752     rc = machine->COMGETTER(USBController)(USBCtl.asOutParam());
     1751    SafeIfaceArray<IUSBController> USBCtlColl;
     1752    rc = machine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(USBCtlColl));
    17531753    if (SUCCEEDED(rc))
    17541754    {
    1755         BOOL fEnabled;
    1756         BOOL fEHCIEnabled;
    1757         rc = USBCtl->COMGETTER(Enabled)(&fEnabled);
    1758         if (FAILED(rc))
    1759             fEnabled = false;
     1755        bool fOhciEnabled = false;
     1756        bool fEhciEnabled = false;
     1757
     1758        for (unsigned i = 0; i < USBCtlColl.size(); i++)
     1759        {
     1760            USBControllerType_T enmType;
     1761
     1762            rc = USBCtlColl[i]->COMGETTER(Type)(&enmType);
     1763            if (SUCCEEDED(rc))
     1764            {
     1765                switch (enmType)
     1766                {
     1767                    case USBControllerType_OHCI:
     1768                        fOhciEnabled = true;
     1769                        break;
     1770                    case USBControllerType_EHCI:
     1771                        fEhciEnabled = true;
     1772                        break;
     1773                    default:
     1774                        break;
     1775                }
     1776            }
     1777        }
     1778
    17601779        if (details == VMINFO_MACHINEREADABLE)
    1761             RTPrintf("usb=\"%s\"\n", fEnabled ? "on" : "off");
     1780            RTPrintf("usb=\"%s\"\n", fOhciEnabled ? "on" : "off");
    17621781        else
    1763             RTPrintf("USB:             %s\n", fEnabled ? "enabled" : "disabled");
    1764 
    1765         rc = USBCtl->COMGETTER(EnabledEHCI)(&fEHCIEnabled);
    1766         if (FAILED(rc))
    1767             fEHCIEnabled = false;
     1782            RTPrintf("USB:             %s\n", fOhciEnabled ? "enabled" : "disabled");
     1783
    17681784        if (details == VMINFO_MACHINEREADABLE)
    1769             RTPrintf("ehci=\"%s\"\n", fEHCIEnabled ? "on" : "off");
     1785            RTPrintf("ehci=\"%s\"\n", fEhciEnabled ? "on" : "off");
    17701786        else
    1771             RTPrintf("EHCI:            %s\n", fEHCIEnabled ? "enabled" : "disabled");
     1787            RTPrintf("EHCI:            %s\n", fEhciEnabled ? "enabled" : "disabled");
    17721788    }
    17731789

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r47246 r47401  
    17721772                {
    17731773                    /* Make sure the OHCI controller is enabled. */
    1774                     ComPtr<IUSBController> UsbCtl;
    1775                     rc = machine->COMGETTER(USBController)(UsbCtl.asOutParam());
    1776                     if (SUCCEEDED(rc))
     1774                    ULONG cOhciCtrls = 0;
     1775                    rc = machine->COMGETTER(USBControllerCountByType)(USBControllerType_OHCI, &cOhciCtrls);
     1776                    if (   SUCCEEDED(rc)
     1777                        && !cOhciCtrls)
    17771778                    {
    1778                         BOOL fEnabled;
    1779                         rc = UsbCtl->COMGETTER(Enabled)(&fEnabled);
    1780                         if (FAILED(rc))
    1781                             fEnabled = false;
    1782                         if (!fEnabled)
    1783                             CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(true));
     1779                        ComPtr<IUSBController> UsbCtl;
     1780                        CHECK_ERROR(machine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
     1781                                                              UsbCtl.asOutParam()));
    17841782                    }
    17851783                }
    … …  
    18081806                {
    18091807                    /* Make sure the OHCI controller is enabled. */
    1810                     ComPtr<IUSBController> UsbCtl;
    1811                     rc = machine->COMGETTER(USBController)(UsbCtl.asOutParam());
    1812                     if (SUCCEEDED(rc))
     1808                    ULONG cOhciCtrls = 0;
     1809                    rc = machine->COMGETTER(USBControllerCountByType)(USBControllerType_OHCI, &cOhciCtrls);
     1810                    if (   SUCCEEDED(rc)
     1811                        && !cOhciCtrls)
    18131812                    {
    1814                         BOOL fEnabled;
    1815                         rc = UsbCtl->COMGETTER(Enabled)(&fEnabled);
    1816                         if (FAILED(rc))
    1817                             fEnabled = false;
    1818                         if (!fEnabled)
    1819                             CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(true));
     1813                        ComPtr<IUSBController> UsbCtl;
     1814                        CHECK_ERROR(machine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
     1815                                                              UsbCtl.asOutParam()));
    18201816                    }
    18211817                }
    … …  
    23112307            case MODIFYVM_USBEHCI:
    23122308            {
    2313                 ComPtr<IUSBController> UsbCtl;
    2314                 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
     2309                ULONG cEhciCtrls = 0;
     2310                rc = machine->COMGETTER(USBControllerCountByType)(USBControllerType_EHCI, &cEhciCtrls);
    23152311                if (SUCCEEDED(rc))
    2316                     CHECK_ERROR(UsbCtl, COMSETTER(EnabledEHCI)(ValueUnion.f));
     2312                {
     2313                    if (!cEhciCtrls && ValueUnion.f)
     2314                    {
     2315                        ComPtr<IUSBController> UsbCtl;
     2316                        CHECK_ERROR(machine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI,
     2317                                                              UsbCtl.asOutParam()));
     2318                    }
     2319                    else if (cEhciCtrls && !ValueUnion.f)
     2320                        CHECK_ERROR(machine, RemoveUSBController(Bstr("EHCI").raw()));
     2321                }
    23172322                break;
    23182323            }
    … …  
    23202325            case MODIFYVM_USB:
    23212326            {
    2322                 ComPtr<IUSBController> UsbCtl;
    2323                 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
     2327                ULONG cOhciCtrls = 0;
     2328                rc = machine->COMGETTER(USBControllerCountByType)(USBControllerType_OHCI, &cOhciCtrls);
    23242329                if (SUCCEEDED(rc))
    2325                     CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(ValueUnion.f));
     2330                {
     2331                    if (!cOhciCtrls && ValueUnion.f)
     2332                    {
     2333                        ComPtr<IUSBController> UsbCtl;
     2334                        CHECK_ERROR(machine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
     2335                                                              UsbCtl.asOutParam()));
     2336                    }
     2337                    else if (cOhciCtrls && !ValueUnion.f)
     2338                        CHECK_ERROR(machine, RemoveUSBController(Bstr("OHCI").raw()));
     2339                }
    23262340                break;
    23272341            }

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

    r47376 r47401  
    15121512        QString item;
    15131513
    1514         CUSBController ctl = aMachine.GetUSBController();
    15151514        CUSBDeviceFilters flts = aMachine.GetUSBDeviceFilters();
    1516         if (   !ctl.isNull()
    1517             && !flts.isNull()
    1518             && ctl.GetProxyAvailable())
     1515        if (   !flts.isNull()
     1516            && aMachine.GetUSBProxyAvailable())
    15191517        {
    15201518            /* the USB controller may be unavailable (i.e. in VirtualBox OSE) */
    15211519
    1522             if (ctl.GetEnabled())
     1520            ULONG cOhciCtls = aMachine.GetUSBControllerCountByType(KUSBControllerType_OHCI);
     1521
     1522            if (cOhciCtls)
    15231523            {
    15241524                CUSBDeviceFilterVector coll = flts.GetDeviceFilters();

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIIndicatorsPool.cpp

    r47149 r47401  
    3939#include "CNetworkAdapter.h"
    4040#include "CUSBController.h"
     41#include "CUSBDeviceFilters.h"
    4142#include "CUSBDevice.h"
    4243#include "CSharedFolder.h"
    … …  
    388389        QString strFullData;
    389390
    390         const CUSBController &usbctl = machine.GetUSBController();
    391         setState(!usbctl.isNull() && usbctl.GetEnabled() && usbctl.GetProxyAvailable() ? KDeviceActivity_Idle : KDeviceActivity_Null);
    392         if (!usbctl.isNull() && usbctl.GetEnabled())
     391
     392        /*
     393         * Check whether there is at least one OHCI USB controllers with
     394         * an available proxy.
     395         */
     396        const CUSBDeviceFilters &filters = machine.GetUSBDeviceFilters();
     397        ULONG cOhciCtls = machine.GetUSBControllerCountByType(KUSBControllerType_OHCI);
     398        bool fUSBEnabled = !filters.isNull() && cOhciCtls && machine.GetUSBProxyAvailable();
     399
     400        setState(fUSBEnabled ? KDeviceActivity_Idle : KDeviceActivity_Null);
     401        if (fUSBEnabled)
    393402        {
    394403            const CConsole &console = m_session.GetConsole();

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

    r47396 r47401  
    6868#include "CVRDEServer.h"
    6969#include "CUSBController.h"
     70#include "CUSBDeviceFilters.h"
    7071#include "CSnapshot.h"
    7172
    … …  
    12961297    /* USB stuff: */
    12971298    {
    1298         /* Get USB controller: */
    1299         const CUSBController &usbController = machine.GetUSBController();
    1300         bool fUSBControllerEnabled = !usbController.isNull() && usbController.GetEnabled() && usbController.GetProxyAvailable();
     1299        /*
     1300         * Check whether there is at least one OHCI USB controllers with
     1301         * an available proxy.
     1302         */
     1303        const CUSBDeviceFilters &filters = machine.GetUSBDeviceFilters();
     1304        ULONG cOhciCtls = machine.GetUSBControllerCountByType(KUSBControllerType_OHCI);
     1305        bool fUSBEnabled = !filters.isNull() && cOhciCtls && machine.GetUSBProxyAvailable();
     1306
    13011307        /* Show/Hide USB menu depending on controller availability, activity and USB-proxy presence: */
    1302         gActionPool->action(UIActionIndexRuntime_Menu_USBDevices)->setVisible(fUSBControllerEnabled);
     1308        gActionPool->action(UIActionIndexRuntime_Menu_USBDevices)->setVisible(fUSBEnabled);
    13031309    }
    13041310}

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.cpp

    r46831 r47401  
    4747#include "CMediumAttachment.h"
    4848#include "CUSBController.h"
     49#include "CUSBDeviceFilters.h"
    4950
    5051UIMachineWindowNormal::UIMachineWindowNormal(UIMachineLogic *pMachineLogic, ulong uScreenId)
    … …  
    488489        if (indicatorsPool()->indicator(IndicatorType_USB))
    489490        {
    490             const CUSBController &usbController = m.GetUSBController();
    491             if (    usbController.isNull()
    492                 || !usbController.GetEnabled()
    493                 || !usbController.GetProxyAvailable())
     491            const CUSBDeviceFilters &filters = m.GetUSBDeviceFilters();
     492            ULONG cOhciCtls = m.GetUSBControllerCountByType(KUSBControllerType_OHCI);
     493            bool fUSBEnabled = !filters.isNull() && cOhciCtls && m.GetUSBProxyAvailable();
     494
     495            if (!fUSBEnabled)
    494496            {
    495497                /* Hide USB menu: */
    … …  
    499501            {
    500502                /* Toggle USB LED: */
    501                 indicatorsPool()->indicator(IndicatorType_USB)->setState(
    502                     usbController.GetEnabled() ? KDeviceActivity_Idle : KDeviceActivity_Null);
     503                indicatorsPool()->indicator(IndicatorType_USB)->setState(KDeviceActivity_Idle);
    503504            }
    504505        }

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsElements.cpp

    r47376 r47401  
    889889        {
    890890            /* Iterate over all the USB filters: */
    891             const CUSBController &ctl = machine().GetUSBController();
    892             if (!ctl.isNull() && ctl.GetProxyAvailable())
     891            const CUSBDeviceFilters &filters = machine().GetUSBDeviceFilters();
     892            if (!filters.isNull() && machine().GetUSBProxyAvailable())
    893893            {
    894894                const CUSBDeviceFilters &flts = machine().GetUSBDeviceFilters();
    895                 if (!flts.isNull() && ctl.GetEnabled())
     895                if (!flts.isNull() && machine().GetUSBControllerCountByType(KUSBControllerType_OHCI))
    896896                {
    897897                    const CUSBDeviceFilterVector &coll = flts.GetDeviceFilters();

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsSet.cpp

    r45287 r47401  
    2929/* COM includes: */
    3030#include "CUSBController.h"
     31#include "CUSBDeviceFilters.h"
    3132
    3233UIGDetailsSet::UIGDetailsSet(UIGDetailsItem *pParent)
    … …  
    9697
    9798    /* Fetch USB controller restrictions: */
    98     const CUSBController &ctl = m_machine.GetUSBController();
    99     if (ctl.isNull() || !ctl.GetProxyAvailable())
     99    const CUSBDeviceFilters &filters = m_machine.GetUSBDeviceFilters();
     100    if (filters.isNull() || !m_machine.GetUSBProxyAvailable())
    100101    {
    101102        QString strElementTypeOpened = gpConverter->toInternalString(DetailsElementType_USB);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDialogSpecific.cpp

    r47263 r47401  
    858858        if (pSystemPage && pSystemPage->isHIDEnabled())
    859859        {
    860             CUSBController controller = m_machine.GetUSBController();
    861             if (!controller.isNull())
    862                 controller.SetEnabled(true);
     860            ULONG cOhciCtls = m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI);
     861            if (!cOhciCtls)
     862                m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    863863        }
    864864
    … …  
    11241124            if (!isPageAvailable(MachineSettingsPageType_Ports))
    11251125                return false;
     1126            /* Check if USB is implemented: */
     1127            if (!m_machine.GetUSBProxyAvailable())
     1128                return false;
    11261129            /* Get the USB controller object: */
    1127             CUSBController controller = m_machine.GetUSBController();
     1130            CUSBControllerVector controllerColl = m_machine.GetUSBControllers();
    11281131            /* Show the machine error message if any: */
    1129             if (!m_machine.isReallyOk() && !controller.isNull() && controller.GetEnabled())
     1132            if (   !m_machine.isReallyOk()
     1133                && controllerColl.size() > 0
     1134                && m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI))
    11301135                msgCenter().warnAboutUnaccessibleUSB(m_machine, parentWidget());
    1131             /* Check if USB is implemented: */
    1132             if (controller.isNull() || !controller.GetProxyAvailable())
    1133                 return false;
    11341136            break;
    11351137        }

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsUSB.cpp

    r47376 r47401  
    294294
    295295            /* Check if controller is valid: */
    296             const CUSBController &controller = m_machine.GetUSBController();
    297             if (!controller.isNull())
     296            const CUSBDeviceFilters &filters = m_machine.GetUSBDeviceFilters();
     297            if (!filters.isNull())
    298298            {
    299299                /* Gather USB values: */
    300                 usbData.m_fUSBEnabled = controller.GetEnabled();
    301                 usbData.m_fEHCIEnabled = controller.GetEnabledEHCI();
     300                usbData.m_fUSBEnabled = m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI) > 0;
     301                usbData.m_fEHCIEnabled = m_machine.GetUSBControllerCountByType(KUSBControllerType_EHCI) > 0;
    302302
    303303                /* For each USB filter: */
    304                 const CUSBDeviceFilters &filters = m_machine.GetUSBDeviceFilters();
    305                 if (!filters.isNull())
     304                const CUSBDeviceFilterVector &coll = filters.GetDeviceFilters();
     305                for (int iFilterIndex = 0; iFilterIndex < coll.size(); ++iFilterIndex)
    306306                {
    307                     const CUSBDeviceFilterVector &coll = filters.GetDeviceFilters();
    308                     for (int iFilterIndex = 0; iFilterIndex < coll.size(); ++iFilterIndex)
     307                    /* Prepare USB filter data: */
     308                    UIDataSettingsMachineUSBFilter usbFilterData;
     309
     310                    /* Check if filter is valid: */
     311                    const CUSBDeviceFilter &filter = coll[iFilterIndex];
     312                    if (!filter.isNull())
    309313                    {
    310                         /* Prepare USB filter data: */
    311                         UIDataSettingsMachineUSBFilter usbFilterData;
    312 
    313                         /* Check if filter is valid: */
    314                         const CUSBDeviceFilter &filter = coll[iFilterIndex];
    315                         if (!filter.isNull())
    316                         {
    317                             usbFilterData.m_fActive = filter.GetActive();
    318                             usbFilterData.m_strName = filter.GetName();
    319                             usbFilterData.m_strVendorId = filter.GetVendorId();
    320                             usbFilterData.m_strProductId = filter.GetProductId();
    321                             usbFilterData.m_strRevision = filter.GetRevision();
    322                             usbFilterData.m_strManufacturer = filter.GetManufacturer();
    323                             usbFilterData.m_strProduct = filter.GetProduct();
    324                             usbFilterData.m_strSerialNumber = filter.GetSerialNumber();
    325                             usbFilterData.m_strPort = filter.GetPort();
    326                             usbFilterData.m_strRemote = filter.GetRemote();
    327                         }
    328 
    329                         /* Cache USB filter data: */
    330                         m_cache.child(iFilterIndex).cacheInitialData(usbFilterData);
     314                        usbFilterData.m_fActive = filter.GetActive();
     315                        usbFilterData.m_strName = filter.GetName();
     316                        usbFilterData.m_strVendorId = filter.GetVendorId();
     317                        usbFilterData.m_strProductId = filter.GetProductId();
     318                        usbFilterData.m_strRevision = filter.GetRevision();
     319                        usbFilterData.m_strManufacturer = filter.GetManufacturer();
     320                        usbFilterData.m_strProduct = filter.GetProduct();
     321                        usbFilterData.m_strSerialNumber = filter.GetSerialNumber();
     322                        usbFilterData.m_strPort = filter.GetPort();
     323                        usbFilterData.m_strRemote = filter.GetRemote();
    331324                    }
     325
     326                    /* Cache USB filter data: */
     327                    m_cache.child(iFilterIndex).cacheInitialData(usbFilterData);
    332328                }
    333329            }
    … …  
    491487            {
    492488                /* Check if controller is valid: */
    493                 CUSBController controller = m_machine.GetUSBController();
    494                 if (!controller.isNull())
     489                CUSBDeviceFilters filters = m_machine.GetUSBDeviceFilters();
     490                if (!filters.isNull())
    495491                {
    496492                    /* Get USB data from cache: */
    497                     CUSBDeviceFilters filters = m_machine.GetUSBDeviceFilters();
     493
    498494                    const UIDataSettingsMachineUSB &usbData = m_cache.data();
    499495                    /* Store USB data: */
    500496                    if (isMachineOffline())
    501497                    {
    502                         controller.SetEnabled(usbData.m_fUSBEnabled);
    503                         controller.SetEnabledEHCI(usbData.m_fEHCIEnabled);
     498                        ULONG cOhciCtls = m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI);
     499                        ULONG cEhciCtls = m_machine.GetUSBControllerCountByType(KUSBControllerType_EHCI);
     500
     501                        if (!cOhciCtls && usbData.m_fUSBEnabled)
     502                            m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
     503                        else if (cOhciCtls && !usbData.m_fUSBEnabled)
     504                            m_machine.RemoveUSBController("OHCI");
     505
     506                        if (!cEhciCtls && usbData.m_fEHCIEnabled)
     507                            m_machine.AddUSBController("EHCI", KUSBControllerType_EHCI);
     508                        else if (cEhciCtls && !usbData.m_fEHCIEnabled)
     509                            m_machine.RemoveUSBController("EHCI");
    504510                    }
    505511                    /* Store USB filters data: */
    506                     if (   isMachineInValidMode()
    507                         && !filters.isNull())
     512                    if (isMachineInValidMode())
    508513                    {
    509514                        /* For each USB filter data set: */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvm/UIWizardNewVM.cpp

    r45316 r47401  
    3030#include "CAudioAdapter.h"
    3131#include "CUSBController.h"
     32#include "CUSBDeviceFilters.h"
    3233#include "CExtPackManager.h"
    3334#include "CStorageController.h"
    … …  
    9495
    9596    /* Enable the OHCI and EHCI controller by default for new VMs. (new in 2.2): */
    96     CUSBController usbController = m_machine.GetUSBController();
    97     if (!usbController.isNull() && type.GetRecommendedUSB() && usbController.GetProxyAvailable())
    98     {
    99         usbController.SetEnabled(true);
     97    CUSBDeviceFilters usbDeviceFilters = m_machine.GetUSBDeviceFilters();
     98    bool fOhciEnabled = false;
     99    if (!usbDeviceFilters.isNull() && type.GetRecommendedUSB() && m_machine.GetUSBProxyAvailable())
     100    {
     101        m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
     102        fOhciEnabled = true;
    100103        /* USB 2.0 is only available if the proper ExtPack is installed.
    101104         * Note. Configuring EHCI here and providing messages about
    … …  
    105108        CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
    106109        if (manager.IsExtPackUsable(GUI_ExtPackName))
    107             usbController.SetEnabledEHCI(true);
     110            m_machine.AddUSBController("EHCI", KUSBControllerType_EHCI);
    108111    }
    109112
    … …  
    162165        m_machine.SetKeyboardHIDType(KKeyboardHIDType_USBKeyboard);
    163166        m_machine.SetPointingHIDType(KPointingHIDType_USBMouse);
    164         if (!usbController.isNull())
    165             usbController.SetEnabled(true);
     167        if (!fOhciEnabled && !usbDeviceFilters.isNull())
     168            m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    166169    }
    167170
    … …  
    169172    {
    170173        m_machine.SetPointingHIDType(KPointingHIDType_USBTablet);
    171         if (!usbController.isNull())
    172             usbController.SetEnabled(true);
     174        if (!fOhciEnabled && !usbDeviceFilters.isNull())
     175            m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    173176    }
    174177

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r47393 r47401  
    545545      <desc>Settings version "1.14", written by VirtualBox 4.3.x.</desc>
    546546      <!--
    547           Machine changes: default frontend.
     547          Machine changes: default frontend, USB rework.
    548548      -->
    549549    </const>
    … …  
    41274127  <interface
    41284128    name="IMachine" extends="$unknown"
    4129     uuid="00daa773-1d35-40ae-ac06-336aa64959ef"
     4129    uuid="b6057c6f-2176-4820-a8d6-cb6687ed1583"
    41304130    wsmap="managed"
    41314131    >
    … …  
    45244524    </attribute>
    45254525
    4526     <attribute name="USBController" type="IUSBController" readonly="yes">
    4527       <desc>
    4528         Associated USB controller object.
     4526    <attribute name="USBControllers" type="IUSBController" readonly="yes" safearray="yes">
     4527      <desc>
     4528        Array of USB controllers attached to this machine.
    45294529
    45304530        <note>
    … …  
    49094909    </attribute>
    49104910
     4911    <attribute name="USBProxyAvailable" type="boolean" readonly="yes">
     4912      <desc>
     4913        Returns whether there is an USB proxy available.
     4914      </desc>
     4915    </attribute>
     4916
    49114917    <method name="lockMachine">
    49124918      <desc>
    … …  
    59475953      <param name="name" type="wstring" dir="in"/>
    59485954      <param name="bootable" type="boolean" dir="in"/>
     5955    </method>
     5956
     5957    <method name="addUSBController">
     5958      <desc>
     5959        Adds a new USB controller to the machine and returns it as an instance of
     5960        <link to="IUSBController" />.
     5961
     5962        <result name="VBOX_E_OBJECT_IN_USE">
     5963          A USB controller with given type exists already.
     5964        </result>
     5965        <result name="E_INVALIDARG">
     5966          Invalid @a controllerType.
     5967        </result>
     5968      </desc>
     5969      <param name="name" type="wstring" dir="in"/>
     5970      <param name="type" type="USBControllerType" dir="in"/>
     5971      <param name="controller" type="IUSBController" dir="return"/>
     5972    </method>
     5973
     5974    <method name="removeUSBController">
     5975      <desc>
     5976        Removes a USB controller from the machine.
     5977
     5978        <result name="VBOX_E_OBJECT_NOT_FOUND">
     5979          A USB controller with given type doesn't exist.
     5980        </result>
     5981      </desc>
     5982      <param name="name" type="wstring" dir="in"/>
     5983    </method>
     5984
     5985    <method name="getUSBControllerByName" const="yes">
     5986      <desc>
     5987        Returns a USB controller with the given type.
     5988
     5989        <result name="VBOX_E_OBJECT_NOT_FOUND">
     5990          A USB controller with given name doesn't exist.
     5991        </result>
     5992      </desc>
     5993      <param name="name" type="wstring" dir="in"/>
     5994      <param name="controller" type="IUSBController" dir="return"/>
     5995    </method>
     5996
     5997    <method name="getUSBControllerCountByType" const="yes">
     5998      <desc>
     5999        Returns the number of USB controllers of the given type attached to the VM.
     6000      </desc>
     6001      <param name="type" type="USBControllerType" dir="in"/>
     6002      <param name="controllers" type="unsigned long" dir="return"/>
    59496003    </method>
    59506004
    … …  
    86548708    name="ISystemProperties"
    86558709    extends="$unknown"
    8656     uuid="55699910-cc50-11e2-8b8b-0800200c9a66"
     8710    uuid="856be1bc-0525-46b1-a27a-fe17d9a4939f"
    86578711    wsmap="managed"
    86588712    >
    … …  
    90599113      <param name="enabled" type="boolean" dir="return">
    90609114        <desc>Returned flag indicating the default value</desc>
     9115      </param>
     9116    </method>
     9117
     9118    <method name="getMaxInstancesOfUSBControllerType">
     9119      <desc>Returns the maximum number of USB controller instances which
     9120        can be configured for each VM. This corresponds to the number of
     9121        USB controllers one can have. Value may depend on chipset type
     9122        used.</desc>
     9123
     9124      <param name="chipset" type="ChipsetType" dir="in">
     9125        <desc>The chipset type to get the value for.</desc>
     9126      </param>
     9127
     9128      <param name="type" type="USBControllerType" dir="in">
     9129        <desc>The USB controller type to get the value for.</desc>
     9130      </param>
     9131
     9132      <param name="maxInstances" type="unsigned long" dir="return">
     9133        <desc>The maximum number of instances for the given USB controller type.</desc>
    90619134      </param>
    90629135    </method>
    … …  
    1645516528  -->
    1645616529
     16530  <enum
     16531    name="USBControllerType"
     16532    uuid="8fdd1c6a-5412-41da-ab07-7baed7d6e18e"
     16533    >
     16534    <desc>
     16535      The USB controller type. <link to="IUSBController::type" />.
     16536    </desc>
     16537    <const name="Null"      value="0">
     16538      <desc>@c null value. Never used by the API.</desc>
     16539    </const>
     16540    <const name="OHCI"      value="1"/>
     16541    <const name="EHCI"      value="2"/>
     16542    <const name="Last"      value="3">
     16543      <desc>Last element (invalid). Used for parameter checks.</desc>
     16544    </const>
     16545  </enum>
     16546
    1645716547  <interface
    1645816548    name="IUSBController" extends="$unknown"
    16459     uuid="f12e6dda-2bad-40c4-8f2e-2d08fe8b74d4"
     16549    uuid="d2745291-65f7-4d75-9556-38047d802319"
    1646016550    wsmap="managed"
    1646116551    >
    16462     <attribute name="enabled" type="boolean">
    16463       <desc>
    16464         Flag whether the USB controller is present in the
    16465         guest system. If disabled, the virtual guest hardware will
    16466         not contain any USB controller. Can only be changed when
    16467         the VM is powered off.
    16468       </desc>
    16469     </attribute>
    16470 
    16471     <attribute name="enabledEHCI" type="boolean">
    16472       <desc>
    16473         Flag whether the USB EHCI controller is present in the
    16474         guest system. If disabled, the virtual guest hardware will
    16475         not contain a USB EHCI controller. Can only be changed when
    16476         the VM is powered off.
    16477       </desc>
    16478     </attribute>
    16479 
    16480     <attribute name="proxyAvailable" type="boolean" readonly="yes">
    16481       <desc>
    16482         Flag whether there is an USB proxy available.
     16552
     16553    <attribute name="name" type="wstring" readonly="yes">
     16554      <desc>
     16555        The USB Controller name.
     16556      </desc>
     16557    </attribute>
     16558
     16559    <attribute name="type" type="USBControllerType" readonly="yes">
     16560      <desc>
     16561        The USB Controller type.
    1648316562      </desc>
    1648416563    </attribute>
    … …  
    2089920978    <desc>
    2090020979      Notification when a property of the virtual
    20901       <link to="IMachine::USBController">USB controller</link> changes.
     20980      <link to="IMachine::USBControllers">USB controllers</link> changes.
    2090220981      Interested callees should use IUSBController methods and attributes to
    2090320982      find out what has changed.

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

    r47376 r47401  
    457457    STDMETHOD(COMGETTER(VRDEServer))(IVRDEServer **vrdeServer);
    458458    STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
    459     STDMETHOD(COMGETTER(USBController))(IUSBController * *aUSBController);
     459    STDMETHOD(COMGETTER(USBControllers))(ComSafeArrayOut(IUSBController *, aUSBControllers));
    460460    STDMETHOD(COMGETTER(USBDeviceFilters))(IUSBDeviceFilters * *aUSBDeviceFilters);
    461461    STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aFilePath);
    … …  
    529529    STDMETHOD(COMGETTER(Icon))(ComSafeArrayOut(BYTE, aIcon));
    530530    STDMETHOD(COMSETTER(Icon))(ComSafeArrayIn(BYTE, aIcon));
     531    STDMETHOD(COMGETTER(USBProxyAvailable))(BOOL *aAvailable);
    531532
    532533    // IMachine methods
    … …  
    593594    STDMETHOD(GetStorageControllerByInstance(ULONG aInstance, IStorageController **storageController));
    594595    STDMETHOD(SetStorageControllerBootable)(IN_BSTR aName, BOOL fBootable);
     596    STDMETHOD(AddUSBController)(IN_BSTR aName, StorageBus_T aConnectionType, IUSBController **controller);
     597    STDMETHOD(RemoveUSBController(IN_BSTR aName));
     598    STDMETHOD(GetUSBControllerByName(IN_BSTR aName, IUSBController **usbController));
     599    STDMETHOD(GetUSBControllerCountByType(USBControllerType_T aType, ULONG *aControllers));
    595600    STDMETHOD(QuerySavedGuestScreenInfo)(ULONG uScreenId, ULONG *puOriginX, ULONG *puOriginY, ULONG *puWidth, ULONG *puHeight, BOOL *pfEnabled);
    596601    STDMETHOD(QuerySavedThumbnailSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
    … …  
    886891    HRESULT getMediumAttachmentsOfController(CBSTR aName,
    887892                                             MediaData::AttachmentList &aAttachments);
     893
     894    HRESULT getUSBControllerByName(const Utf8Str &aName,
     895                                   ComObjPtr<USBController> &aUSBController,
     896                                   bool aSetError = false);
     897
     898    ULONG   getUSBControllerCountByType(USBControllerType_T enmType);
    888899
    889900    enum
    … …  
    9981009    const ComObjPtr<ParallelPort>      mParallelPorts[SchemaDefs::ParallelPortCount];
    9991010    const ComObjPtr<AudioAdapter>      mAudioAdapter;
    1000     const ComObjPtr<USBController>     mUSBController;
    10011011    const ComObjPtr<USBDeviceFilters>  mUSBDeviceFilters;
    10021012    const ComObjPtr<BIOSSettings>      mBIOSSettings;
     1013    const ComObjPtr<BandwidthControl>  mBandwidthControl;
     1014
    10031015    typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
    1004     NetworkAdapterVector            mNetworkAdapters;
    1005     const ComObjPtr<BandwidthControl> mBandwidthControl;
     1016    NetworkAdapterVector               mNetworkAdapters;
    10061017
    10071018    typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
    1008     Backupable<StorageControllerList> mStorageControllers;
     1019    Backupable<StorageControllerList>  mStorageControllers;
     1020
     1021    typedef std::list<ComObjPtr<USBController> > USBControllerList;
     1022    Backupable<USBControllerList>      mUSBControllers;
    10091023
    10101024    uint64_t                        uRegistryNeedsSaving;

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

    r46367 r47401  
    109109    STDMETHOD(GetDeviceTypesForStorageBus)(StorageBus_T aBus, ComSafeArrayOut(DeviceType_T, aDeviceTypes));
    110110    STDMETHOD(GetDefaultIoCacheSettingForStorageController)(StorageControllerType_T aControllerType, BOOL *aEnabled);
     111    STDMETHOD(GetMaxInstancesOfUSBControllerType)(ChipsetType_T aChipset, USBControllerType_T aType, ULONG *aMaxInstances);
    111112
    112113    // public methods only for internal purposes

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

    r47376 r47401  
    5252
    5353    // public initializer/uninitializer for internal purposes only
    54     HRESULT init(Machine *aParent);
    55     HRESULT init(Machine *aParent, USBController *aThat);
     54    HRESULT init(Machine *aParent, const Utf8Str &aName, USBControllerType_T enmType);
     55    HRESULT init(Machine *aParent, USBController *aThat, bool fReshare = false);
    5656    HRESULT initCopy(Machine *aParent, USBController *aThat);
    5757    void uninit();
    5858
    5959    // IUSBController properties
    60     STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    61     STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    62     STDMETHOD(COMGETTER(EnabledEHCI))(BOOL *aEnabled);
    63     STDMETHOD(COMSETTER(EnabledEHCI))(BOOL aEnabled);
    64     STDMETHOD(COMGETTER(ProxyAvailable))(BOOL *aEnabled);
     60    STDMETHOD(COMGETTER(Name))(BSTR *aName);
     61    STDMETHOD(COMGETTER(Type))(USBControllerType_T *enmType);
    6562    STDMETHOD(COMGETTER(USBStandard))(USHORT *aUSBStandard);
    6663
    6764    // public methods only for internal purposes
    6865
    69     HRESULT loadSettings(const settings::USBController &data);
    70     HRESULT saveSettings(settings::USBController &data);
    71 
    7266    void rollback();
    7367    void commit();
    7468    void copyFrom(USBController *aThat);
     69    void unshare();
     70
     71    const Utf8Str &getName() const;
     72    USBControllerType_T getControllerType() const;
     73
     74    ComObjPtr<USBController> getPeer();
    7575
    7676private:

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

    r47377 r47401  
    2828namespace settings
    2929{
    30     struct USBController;
     30    struct USB;
    3131}
    3232
    … …  
    6767    // public methods only for internal purposes
    6868
    69     HRESULT loadSettings(const settings::USBController &data);
    70     HRESULT saveSettings(settings::USBController &data);
     69    HRESULT loadSettings(const settings::USB &data);
     70    HRESULT saveSettings(settings::USB &data);
    7171
    7272    void rollback();

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

    r47342 r47401  
    22662266
    22672267        /*
    2268          * The USB Controller.
     2268         * The USB Controllers.
    22692269         */
    2270         ComPtr<IUSBController> USBCtlPtr;
    2271         hrc = pMachine->COMGETTER(USBController)(USBCtlPtr.asOutParam());
    2272         if (USBCtlPtr)
    2273         {
    2274             BOOL fOhciEnabled;
    2275             hrc = USBCtlPtr->COMGETTER(Enabled)(&fOhciEnabled);                             H();
    2276             if (fOhciEnabled)
    2277             {
    2278                 InsertConfigNode(pDevices, "usb-ohci", &pDev);
    2279                 InsertConfigNode(pDev,     "0", &pInst);
    2280                 InsertConfigNode(pInst,    "Config", &pCfg);
    2281                 InsertConfigInteger(pInst, "Trusted",              1); /* boolean */
    2282                 hrc = pBusMgr->assignPCIDevice("usb-ohci", pInst);                          H();
    2283                 InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2284                 InsertConfigString(pLunL0, "Driver",               "VUSBRootHub");
    2285                 InsertConfigNode(pLunL0,   "Config", &pCfg);
    2286 
    2287                 /*
    2288                  * Attach the status driver.
    2289                  */
    2290                 attachStatusDriver(pInst, &mapUSBLed[0], 0, 0, NULL, NULL, 0);
    2291 
    2292                 mfVMHasUsbController = true;
     2270        com::SafeIfaceArray<IUSBController> usbCtrls;
     2271        hrc = pMachine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(usbCtrls));        H();
     2272        bool fOhciPresent = false; /**< Flag whether at least one OHCI controller is presnet. */
     2273
     2274        for (size_t i = 0; i < usbCtrls.size(); ++i)
     2275        {
     2276            USBControllerType_T enmCtrlType;
     2277            rc = usbCtrls[i]->COMGETTER(Type)(&enmCtrlType);                                   H();
     2278            if (enmCtrlType == USBControllerType_OHCI)
     2279            {
     2280                fOhciPresent = true;
     2281                break;
     2282            }
     2283        }
     2284
     2285        /*
     2286         * Currently EHCI is only enabled when a OHCI controller is present too.
     2287         * This might change when XHCI is supported.
     2288         */
     2289        if (fOhciPresent)
     2290            mfVMHasUsbController = true;
     2291
     2292        if (mfVMHasUsbController)
     2293        {
     2294            for (size_t i = 0; i < usbCtrls.size(); ++i)
     2295            {
     2296                USBControllerType_T enmCtrlType;
     2297                rc = usbCtrls[i]->COMGETTER(Type)(&enmCtrlType);                                   H();
     2298
     2299                if (enmCtrlType == USBControllerType_OHCI)
     2300                {
     2301                    InsertConfigNode(pDevices, "usb-ohci", &pDev);
     2302                    InsertConfigNode(pDev,     "0", &pInst);
     2303                    InsertConfigNode(pInst,    "Config", &pCfg);
     2304                    InsertConfigInteger(pInst, "Trusted",              1); /* boolean */
     2305                    hrc = pBusMgr->assignPCIDevice("usb-ohci", pInst);                          H();
     2306                    InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2307                    InsertConfigString(pLunL0, "Driver",               "VUSBRootHub");
     2308                    InsertConfigNode(pLunL0,   "Config", &pCfg);
     2309
     2310                    /*
     2311                     * Attach the status driver.
     2312                     */
     2313                    attachStatusDriver(pInst, &mapUSBLed[0], 0, 0, NULL, NULL, 0);
     2314                }
    22932315#ifdef VBOX_WITH_EHCI
    2294                 BOOL fEHCIEnabled;
    2295                 hrc = USBCtlPtr->COMGETTER(EnabledEHCI)(&fEHCIEnabled);                     H();
    2296                 if (fEHCIEnabled)
     2316                else if (enmCtrlType == USBControllerType_EHCI)
    22972317                {
    22982318                    /*
    … …  
    23402360                }
    23412361#endif
    2342 
     2362            } /* for every USB controller. */
     2363
     2364
     2365            /*
     2366             * Virtual USB Devices.
     2367             */
     2368            PCFGMNODE pUsbDevices = NULL;
     2369            InsertConfigNode(pRoot, "USB", &pUsbDevices);
     2370
     2371#ifdef VBOX_WITH_USB
     2372            {
    23432373                /*
    2344                  * Virtual USB Devices.
     2374                 * Global USB options, currently unused as we'll apply the 2.0 -> 1.1 morphing
     2375                 * on a per device level now.
    23452376                 */
    2346                 PCFGMNODE pUsbDevices = NULL;
    2347                 InsertConfigNode(pRoot, "USB", &pUsbDevices);
    2348 
    2349 #ifdef VBOX_WITH_USB
    2350                 {
    2351                     /*
    2352                     * Global USB options, currently unused as we'll apply the 2.0 -> 1.1 morphing
    2353                     * on a per device level now.
    2354                     */
    2355                     InsertConfigNode(pUsbDevices, "USBProxy", &pCfg);
    2356                     InsertConfigNode(pCfg, "GlobalConfig", &pCfg);
    2357                     // This globally enables the 2.0 -> 1.1 device morphing of proxied devices to keep windows quiet.
    2358                     //InsertConfigInteger(pCfg, "Force11Device", true);
    2359                     // The following breaks stuff, but it makes MSDs work in vista. (I include it here so
    2360                     // that it's documented somewhere.) Users needing it can use:
    2361                     //      VBoxManage setextradata "myvm" "VBoxInternal/USB/USBProxy/GlobalConfig/Force11PacketSize" 1
    2362                     //InsertConfigInteger(pCfg, "Force11PacketSize", true);
    2363                 }
     2377                InsertConfigNode(pUsbDevices, "USBProxy", &pCfg);
     2378                InsertConfigNode(pCfg, "GlobalConfig", &pCfg);
     2379                // This globally enables the 2.0 -> 1.1 device morphing of proxied devices to keep windows quiet.
     2380                //InsertConfigInteger(pCfg, "Force11Device", true);
     2381                // The following breaks stuff, but it makes MSDs work in vista. (I include it here so
     2382                // that it's documented somewhere.) Users needing it can use:
     2383                //      VBoxManage setextradata "myvm" "VBoxInternal/USB/USBProxy/GlobalConfig/Force11PacketSize" 1
     2384                //InsertConfigInteger(pCfg, "Force11PacketSize", true);
     2385            }
    23642386#endif
    23652387
    23662388#ifdef VBOX_WITH_USB_VIDEO
    2367                 BOOL aEmulatedUSBWebcamEnabled = FALSE;
    2368                 hrc = pMachine->COMGETTER(EmulatedUSBWebcameraEnabled)(&aEmulatedUSBWebcamEnabled);    H();
    2369                 if (aEmulatedUSBWebcamEnabled)
    2370                 {
    2371                     InsertConfigNode(pUsbDevices, "Webcam", &pDev);
    2372                     InsertConfigNode(pDev,     "0", &pInst);
    2373                     InsertConfigNode(pInst,    "Config", &pCfg);
    2374                     InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2375                     InsertConfigString(pLunL0, "Driver", "EmWebcam");
    2376                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2377                     InsertConfigInteger(pCfg,  "Object", (uintptr_t)mEmWebcam);
    2378                 }
    2379 #endif
    2380 
    2381 #ifdef VBOX_WITH_USB_CARDREADER
    2382                 BOOL aEmulatedUSBCardReaderEnabled = FALSE;
    2383                 hrc = pMachine->COMGETTER(EmulatedUSBCardReaderEnabled)(&aEmulatedUSBCardReaderEnabled);    H();
    2384                 if (aEmulatedUSBCardReaderEnabled)
    2385                 {
    2386                     InsertConfigNode(pUsbDevices, "CardReader", &pDev);
    2387                     InsertConfigNode(pDev,     "0", &pInst);
    2388                     InsertConfigNode(pInst,    "Config", &pCfg);
    2389 
    2390                     InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2391 # ifdef VBOX_WITH_USB_CARDREADER_TEST
    2392                     InsertConfigString(pLunL0, "Driver", "DrvDirectCardReader");
    2393                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2394 # else
    2395                     InsertConfigString(pLunL0, "Driver", "UsbCardReader");
    2396                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2397                     InsertConfigInteger(pCfg,  "Object", (uintptr_t)mUsbCardReader);
    2398 # endif
    2399                 }
    2400 #endif
    2401 
    2402 # if 0  /* Virtual MSD*/
    2403 
    2404                 InsertConfigNode(pUsbDevices, "Msd", &pDev);
     2389            BOOL aEmulatedUSBWebcamEnabled = FALSE;
     2390            hrc = pMachine->COMGETTER(EmulatedUSBWebcameraEnabled)(&aEmulatedUSBWebcamEnabled);    H();
     2391            if (aEmulatedUSBWebcamEnabled)
     2392            {
     2393                InsertConfigNode(pUsbDevices, "Webcam", &pDev);
    24052394                InsertConfigNode(pDev,     "0", &pInst);
    24062395                InsertConfigNode(pInst,    "Config", &pCfg);
    24072396                InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2408 
    2409                 InsertConfigString(pLunL0, "Driver", "SCSI");
     2397                InsertConfigString(pLunL0, "Driver", "EmWebcam");
    24102398                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2399                InsertConfigInteger(pCfg,  "Object", (uintptr_t)mEmWebcam);
     2400            }
     2401#endif
     2402
     2403#ifdef VBOX_WITH_USB_CARDREADER
     2404            BOOL aEmulatedUSBCardReaderEnabled = FALSE;
     2405            hrc = pMachine->COMGETTER(EmulatedUSBCardReaderEnabled)(&aEmulatedUSBCardReaderEnabled);    H();
     2406            if (aEmulatedUSBCardReaderEnabled)
     2407            {
     2408                InsertConfigNode(pUsbDevices, "CardReader", &pDev);
     2409                InsertConfigNode(pDev,     "0", &pInst);
     2410                InsertConfigNode(pInst,    "Config", &pCfg);
     2411
     2412                InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2413# ifdef VBOX_WITH_USB_CARDREADER_TEST
     2414                InsertConfigString(pLunL0, "Driver", "DrvDirectCardReader");
     2415                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2416# else
     2417                InsertConfigString(pLunL0, "Driver", "UsbCardReader");
     2418                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2419                InsertConfigInteger(pCfg,  "Object", (uintptr_t)mUsbCardReader);
     2420# endif
     2421             }
     2422#endif
     2423
     2424# if 0  /* Virtual MSD*/
     2425            InsertConfigNode(pUsbDevices, "Msd", &pDev);
     2426            InsertConfigNode(pDev,     "0", &pInst);
     2427            InsertConfigNode(pInst,    "Config", &pCfg);
     2428            InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2429
     2430            InsertConfigString(pLunL0, "Driver", "SCSI");
     2431            InsertConfigNode(pLunL0,   "Config", &pCfg);
     2432
     2433            InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
     2434            InsertConfigString(pLunL1, "Driver", "Block");
     2435            InsertConfigNode(pLunL1,   "Config", &pCfg);
     2436            InsertConfigString(pCfg,   "Type", "HardDisk");
     2437            InsertConfigInteger(pCfg,  "Mountable", 0);
     2438
     2439            InsertConfigNode(pLunL1,   "AttachedDriver", &pLunL2);
     2440            InsertConfigString(pLunL2, "Driver", "VD");
     2441            InsertConfigNode(pLunL2,   "Config", &pCfg);
     2442            InsertConfigString(pCfg,   "Path", "/Volumes/DataHFS/bird/VDIs/linux.vdi");
     2443            InsertConfigString(pCfg,   "Format", "VDI");
     2444# endif
     2445
     2446            /* Virtual USB Mouse/Tablet */
     2447            if (   aPointingHID == PointingHIDType_USBMouse
     2448                || aPointingHID == PointingHIDType_ComboMouse
     2449                || aPointingHID == PointingHIDType_USBTablet
     2450                || aPointingHID == PointingHIDType_USBMultiTouch)
     2451            {
     2452                InsertConfigNode(pUsbDevices, "HidMouse", &pDev);
     2453                InsertConfigNode(pDev,     "0", &pInst);
     2454                InsertConfigNode(pInst,    "Config", &pCfg);
     2455
     2456                InsertConfigString(pCfg,   "Mode", "relative");
     2457                InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2458                InsertConfigString(pLunL0, "Driver",        "MouseQueue");
     2459                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2460                InsertConfigInteger(pCfg,  "QueueSize",            128);
    24112461
    24122462                InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
    2413                 InsertConfigString(pLunL1, "Driver", "Block");
     2463                InsertConfigString(pLunL1, "Driver",        "MainMouse");
    24142464                InsertConfigNode(pLunL1,   "Config", &pCfg);
    2415                 InsertConfigString(pCfg,   "Type", "HardDisk");
    2416                 InsertConfigInteger(pCfg,  "Mountable", 0);
    2417 
    2418                 InsertConfigNode(pLunL1,   "AttachedDriver", &pLunL2);
    2419                 InsertConfigString(pLunL2, "Driver", "VD");
    2420                 InsertConfigNode(pLunL2,   "Config", &pCfg);
    2421                 InsertConfigString(pCfg,   "Path", "/Volumes/DataHFS/bird/VDIs/linux.vdi");
    2422                 InsertConfigString(pCfg,   "Format", "VDI");
    2423 # endif
    2424 
    2425                 /* Virtual USB Mouse/Tablet */
    2426                 if (   aPointingHID == PointingHIDType_USBMouse
    2427                     || aPointingHID == PointingHIDType_ComboMouse
    2428                     || aPointingHID == PointingHIDType_USBTablet
    2429                     || aPointingHID == PointingHIDType_USBMultiTouch)
    2430                 {
    2431                     InsertConfigNode(pUsbDevices, "HidMouse", &pDev);
    2432                     InsertConfigNode(pDev,     "0", &pInst);
    2433                     InsertConfigNode(pInst,    "Config", &pCfg);
    2434 
    2435                     InsertConfigString(pCfg,   "Mode", "relative");
    2436                     InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2437                     InsertConfigString(pLunL0, "Driver",        "MouseQueue");
    2438                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2439                     InsertConfigInteger(pCfg,  "QueueSize",            128);
    2440 
    2441                     InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
    2442                     InsertConfigString(pLunL1, "Driver",        "MainMouse");
    2443                     InsertConfigNode(pLunL1,   "Config", &pCfg);
    2444                     InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pMouse);
    2445                 }
    2446                 if (   aPointingHID == PointingHIDType_USBTablet
    2447                     || aPointingHID == PointingHIDType_USBMultiTouch)
    2448                 {
    2449                     InsertConfigNode(pDev,     "1", &pInst);
    2450                     InsertConfigNode(pInst,    "Config", &pCfg);
    2451 
    2452                     InsertConfigString(pCfg,   "Mode", "absolute");
    2453                     InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2454                     InsertConfigString(pLunL0, "Driver",        "MouseQueue");
    2455                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2456                     InsertConfigInteger(pCfg,  "QueueSize",            128);
    2457 
    2458                     InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
    2459                     InsertConfigString(pLunL1, "Driver",        "MainMouse");
    2460                     InsertConfigNode(pLunL1,   "Config", &pCfg);
    2461                     InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pMouse);
    2462                 }
    2463                 if (aPointingHID == PointingHIDType_USBMultiTouch)
    2464                 {
    2465                     InsertConfigNode(pDev,     "2", &pInst);
    2466                     InsertConfigNode(pInst,    "Config", &pCfg);
    2467 
    2468                     InsertConfigString(pCfg,   "Mode", "multitouch");
    2469                     InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2470                     InsertConfigString(pLunL0, "Driver",        "MouseQueue");
    2471                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2472                     InsertConfigInteger(pCfg,  "QueueSize",            128);
    2473 
    2474                     InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
    2475                     InsertConfigString(pLunL1, "Driver",        "MainMouse");
    2476                     InsertConfigNode(pLunL1,   "Config", &pCfg);
    2477                     InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pMouse);
    2478                 }
    2479 
    2480                 /* Virtual USB Keyboard */
    2481                 KeyboardHIDType_T aKbdHID;
    2482                 hrc = pMachine->COMGETTER(KeyboardHIDType)(&aKbdHID);                       H();
    2483                 if (aKbdHID == KeyboardHIDType_USBKeyboard)
    2484                 {
    2485                     InsertConfigNode(pUsbDevices, "HidKeyboard", &pDev);
    2486                     InsertConfigNode(pDev,     "0", &pInst);
    2487                     InsertConfigNode(pInst,    "Config", &pCfg);
    2488 
    2489                     InsertConfigNode(pInst,    "LUN#0", &pLunL0);
    2490                     InsertConfigString(pLunL0, "Driver",               "KeyboardQueue");
    2491                     InsertConfigNode(pLunL0,   "Config", &pCfg);
    2492                     InsertConfigInteger(pCfg,  "QueueSize",            64);
    2493 
    2494                     InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
    2495                     InsertConfigString(pLunL1, "Driver",               "MainKeyboard");
    2496                     InsertConfigNode(pLunL1,   "Config", &pCfg);
    2497                     pKeyboard = mKeyboard;
    2498                     InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pKeyboard);
    2499                 }
     2465                InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pMouse);
     2466            }
     2467            if (   aPointingHID == PointingHIDType_USBTablet
     2468                || aPointingHID == PointingHIDType_USBMultiTouch)
     2469            {
     2470                InsertConfigNode(pDev,     "1", &pInst);
     2471                InsertConfigNode(pInst,    "Config", &pCfg);
     2472
     2473                InsertConfigString(pCfg,   "Mode", "absolute");
     2474                InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2475                InsertConfigString(pLunL0, "Driver",        "MouseQueue");
     2476                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2477                InsertConfigInteger(pCfg,  "QueueSize",            128);
     2478
     2479                InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
     2480                InsertConfigString(pLunL1, "Driver",        "MainMouse");
     2481                InsertConfigNode(pLunL1,   "Config", &pCfg);
     2482                InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pMouse);
     2483            }
     2484            if (aPointingHID == PointingHIDType_USBMultiTouch)
     2485            {
     2486                InsertConfigNode(pDev,     "2", &pInst);
     2487                InsertConfigNode(pInst,    "Config", &pCfg);
     2488
     2489                InsertConfigString(pCfg,   "Mode", "multitouch");
     2490                InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2491                InsertConfigString(pLunL0, "Driver",        "MouseQueue");
     2492                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2493                InsertConfigInteger(pCfg,  "QueueSize",            128);
     2494
     2495                InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
     2496                InsertConfigString(pLunL1, "Driver",        "MainMouse");
     2497                InsertConfigNode(pLunL1,   "Config", &pCfg);
     2498                InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pMouse);
     2499            }
     2500
     2501            /* Virtual USB Keyboard */
     2502            KeyboardHIDType_T aKbdHID;
     2503            hrc = pMachine->COMGETTER(KeyboardHIDType)(&aKbdHID);                       H();
     2504            if (aKbdHID == KeyboardHIDType_USBKeyboard)
     2505            {
     2506                InsertConfigNode(pUsbDevices, "HidKeyboard", &pDev);
     2507                InsertConfigNode(pDev,     "0", &pInst);
     2508                InsertConfigNode(pInst,    "Config", &pCfg);
     2509
     2510                InsertConfigNode(pInst,    "LUN#0", &pLunL0);
     2511                InsertConfigString(pLunL0, "Driver",               "KeyboardQueue");
     2512                InsertConfigNode(pLunL0,   "Config", &pCfg);
     2513                InsertConfigInteger(pCfg,  "QueueSize",            64);
     2514
     2515                InsertConfigNode(pLunL0,   "AttachedDriver", &pLunL1);
     2516                InsertConfigString(pLunL1, "Driver",               "MainKeyboard");
     2517                InsertConfigNode(pLunL1,   "Config", &pCfg);
     2518                pKeyboard = mKeyboard;
     2519                InsertConfigInteger(pCfg,  "Object",     (uintptr_t)pKeyboard);
    25002520            }
    25012521        }

  • trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

    r46535 r47401  
    8888
    8989        // first, call the COM methods, as they request locks
    90         ComPtr<IUSBController> pUsbController;
    91         rc = COMGETTER(USBController)(pUsbController.asOutParam());
    92         BOOL fUSBEnabled;
    93         if (FAILED(rc))
    94             fUSBEnabled = false;
    95         else
    96         {
    97             rc = pUsbController->COMGETTER(Enabled)(&fUSBEnabled);
    98             if (FAILED(rc)) throw rc;
     90        BOOL fUSBEnabled = FALSE;
     91        com::SafeIfaceArray<IUSBController> usbControllers;
     92        rc = COMGETTER(USBControllers)(ComSafeArrayAsOutParam(usbControllers));
     93        if (SUCCEEDED(rc))
     94        {
     95            for (unsigned i = 0; i < usbControllers.size(); i++)
     96            {
     97                USBControllerType_T enmType;
     98
     99                rc = usbControllers[i]->COMGETTER(Type)(&enmType);
     100                if (FAILED(rc)) throw rc;
     101
     102                if (enmType == USBControllerType_OHCI)
     103                    fUSBEnabled = TRUE;
     104            }
    99105        }
    100106

  • trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

    r47340 r47401  
    354354            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    355355            if (   (   vsysThis.pelmVboxMachine
    356                     && pNewDesc->m->pConfig->hardwareMachine.usbController.fEnabled)
     356                    && pNewDesc->m->pConfig->hardwareMachine.usbSettings.llUSBControllers.size() > 0)
    357357                || vsysThis.fHasUsbController)
    358358                pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
    … …  
    26192619#ifdef VBOX_WITH_USB
    26202620    /* USB Controller */
    2621     ComPtr<IUSBController> usbController;
    2622     rc = pNewMachine->COMGETTER(USBController)(usbController.asOutParam());
    2623     if (FAILED(rc)) throw rc;
    2624     rc = usbController->COMSETTER(Enabled)(stack.fUSBEnabled);
    2625     if (FAILED(rc)) throw rc;
     2621    if (stack.fUSBEnabled)
     2622    {
     2623        ComPtr<IUSBController> usbController;
     2624        rc = pNewMachine->AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, usbController.asOutParam());
     2625        if (FAILED(rc)) throw rc;
     2626    }
    26262627#endif /* VBOX_WITH_USB */
    26272628
    … …  
    32563257#ifdef VBOX_WITH_USB
    32573258    /* USB controller */
    3258     config.hardwareMachine.usbController.fEnabled = stack.fUSBEnabled;
     3259    if (stack.fUSBEnabled)
     3260    {
     3261        settings::USBController ctrl;
     3262
     3263        ctrl.strName = "OHCI";
     3264        ctrl.enmType = USBControllerType_OHCI;
     3265
     3266        config.hardwareMachine.usbSettings.llUSBControllers.push_back(ctrl);
     3267    }
    32593268#endif
    32603269    /* Audio adapter */

  • trunk/src/VBox/Main/src-server/MachineImpl.cpp

    r47376 r47401  
    5252#include "MachineImplCloneVM.h"
    5353#include "AutostartDb.h"
     54#include "SystemPropertiesImpl.h"
    5455
    5556// generated header
    … …  
    27412742}
    27422743
    2743 STDMETHODIMP Machine::COMGETTER(USBController)(IUSBController **aUSBController)
     2744STDMETHODIMP Machine::COMGETTER(USBControllers)(ComSafeArrayOut(IUSBController *, aUSBControllers))
    27442745{
    27452746#ifdef VBOX_WITH_VUSB
    2746     CheckComArgOutPointerValid(aUSBController);
     2747    CheckComArgOutPointerValid(aUSBControllers);
    27472748
    27482749    AutoCaller autoCaller(this);
    … …  
    27592760    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    27602761
    2761     return rc = mUSBController.queryInterfaceTo(aUSBController);
     2762    SafeIfaceArray<IUSBController> ctrls(*mUSBControllers.data());
     2763    ctrls.detachTo(ComSafeArrayOutArg(aUSBControllers));
     2764    return S_OK;
    27622765#else
    27632766    /* Note: The GUI depends on this method returning E_NOTIMPL with no
    27642767     * extended error info to indicate that USB is simply not available
    27652768     * (w/o treating it as a failure), for example, as in OSE */
    2766     NOREF(aUSBController);
     2769    NOREF(aUSBControllers);
    27672770    ReturnComNotImplemented();
    27682771#endif /* VBOX_WITH_VUSB */
    … …  
    65546557}
    65556558
     6559STDMETHODIMP Machine::AddUSBController(IN_BSTR aName, USBControllerType_T aType,
     6560                                       IUSBController **controller)
     6561{
     6562    if (   (aType <= USBControllerType_Null)
     6563        || (aType >= USBControllerType_Last))
     6564        return setError(E_INVALIDARG,
     6565                        tr("Invalid USB controller type: %d"),
     6566                        aType);
     6567
     6568    AutoCaller autoCaller(this);
     6569    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     6570
     6571    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     6572
     6573    HRESULT rc = checkStateDependency(MutableStateDep);
     6574    if (FAILED(rc)) return rc;
     6575
     6576    /* try to find one with the same type first. */
     6577    ComObjPtr<USBController> ctrl;
     6578
     6579    rc = getUSBControllerByName(aName, ctrl, false /* aSetError */);
     6580    if (SUCCEEDED(rc))
     6581        return setError(VBOX_E_OBJECT_IN_USE,
     6582                        tr("USB controller named '%ls' already exists"),
     6583                        aName);
     6584
     6585    /* Check that we don't exceed the maximum number of USB controllers for the given type. */
     6586    ULONG maxInstances;
     6587    rc = mParent->getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
     6588    if (FAILED(rc))
     6589        return rc;
     6590
     6591    ULONG cInstances = getUSBControllerCountByType(aType);
     6592    if (cInstances >= maxInstances)
     6593        return setError(E_INVALIDARG,
     6594                        tr("Too many USB controllers of this type"));
     6595
     6596    ctrl.createObject();
     6597
     6598    rc = ctrl->init(this, aName, aType);
     6599    if (FAILED(rc)) return rc;
     6600
     6601    setModified(IsModified_USB);
     6602    mUSBControllers.backup();
     6603    mUSBControllers->push_back(ctrl);
     6604
     6605    ctrl.queryInterfaceTo(controller);
     6606
     6607    /* inform the direct session if any */
     6608    alock.release();
     6609    onUSBControllerChange();
     6610
     6611    return S_OK;
     6612}
     6613
     6614STDMETHODIMP Machine::GetUSBControllerByName(IN_BSTR aName, IUSBController **aUSBController)
     6615{
     6616    CheckComArgStrNotEmptyOrNull(aName);
     6617
     6618    AutoCaller autoCaller(this);
     6619    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     6620
     6621    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     6622
     6623    ComObjPtr<USBController> ctrl;
     6624
     6625    HRESULT rc = getUSBControllerByName(aName, ctrl, true /* aSetError */);
     6626    if (SUCCEEDED(rc))
     6627        ctrl.queryInterfaceTo(aUSBController);
     6628
     6629    return rc;
     6630}
     6631
     6632STDMETHODIMP Machine::GetUSBControllerCountByType(USBControllerType_T aType,
     6633                                                  ULONG *aControllers)
     6634{
     6635    CheckComArgOutPointerValid(aControllers);
     6636
     6637    if (   (aType <= USBControllerType_Null)
     6638        || (aType >= USBControllerType_Last))
     6639        return setError(E_INVALIDARG,
     6640                        tr("Invalid USB controller type: %d"),
     6641                        aType);
     6642
     6643    AutoCaller autoCaller(this);
     6644    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     6645
     6646    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     6647
     6648    ComObjPtr<USBController> ctrl;
     6649
     6650    *aControllers = getUSBControllerCountByType(aType);
     6651
     6652    return S_OK;
     6653}
     6654
     6655STDMETHODIMP Machine::RemoveUSBController(IN_BSTR aName)
     6656{
     6657    CheckComArgStrNotEmptyOrNull(aName);
     6658
     6659    AutoCaller autoCaller(this);
     6660    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     6661
     6662    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     6663
     6664    HRESULT rc = checkStateDependency(MutableStateDep);
     6665    if (FAILED(rc)) return rc;
     6666
     6667    ComObjPtr<USBController> ctrl;
     6668    rc = getUSBControllerByName(aName, ctrl, true /* aSetError */);
     6669    if (FAILED(rc)) return rc;
     6670
     6671    setModified(IsModified_USB);
     6672    mUSBControllers.backup();
     6673
     6674    ctrl->unshare();
     6675
     6676    mUSBControllers->remove(ctrl);
     6677
     6678    /* inform the direct session if any */
     6679    alock.release();
     6680    onUSBControllerChange();
     6681
     6682    return S_OK;
     6683}
     6684
    65566685STDMETHODIMP Machine::QuerySavedGuestScreenInfo(ULONG uScreenId,
    65576686                                                ULONG *puOriginX,
    … …  
    74777606}
    74787607
     7608STDMETHODIMP Machine::COMGETTER(USBProxyAvailable)(BOOL *aAvailable)
     7609{
     7610    CheckComArgOutPointerValid(aAvailable);
     7611
     7612    AutoCaller autoCaller(this);
     7613    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     7614
     7615#ifdef VBOX_WITH_USB
     7616    *aAvailable = true;
     7617#else
     7618    *aAvailable = false;
     7619#endif
     7620    return S_OK;
     7621}
     7622
    74797623STDMETHODIMP Machine::CloneTo(IMachine *pTarget, CloneMode_T mode, ComSafeArrayIn(CloneOptions_T, options), IProgress **pProgress)
    74807624{
    … …  
    77467890    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    77477891
    7748     BOOL fEnabled = FALSE;
    7749     HRESULT rc = mUSBController->COMGETTER(Enabled)(&fEnabled);
    7750     if (SUCCEEDED(rc))
    7751         return !!fEnabled;
    7752     else
    7753         return false;
     7892    return (mUSBControllers->size() > 0);
    77547893}
    77557894
    … …  
    84848623    mMediaData.allocate();
    84858624    mStorageControllers.allocate();
     8625    mUSBControllers.allocate();
    84868626
    84878627    /* initialize mOSTypeId */
    … …  
    85138653    unconst(mAudioAdapter).createObject();
    85148654    mAudioAdapter->init(this);
    8515 
    8516     /* create the USB controller object (always present, default is disabled) */
    8517     unconst(mUSBController).createObject();
    8518     mUSBController->init(this);
    85198655
    85208656    /* create the USB device filters object (always present) */
    … …  
    85678703            unconst(mNetworkAdapters[slot]).setNull();
    85688704        }
    8569     }
    8570 
    8571     if (mUSBController)
    8572     {
    8573         mUSBController->uninit();
    8574         unconst(mUSBController).setNull();
    85758705    }
    85768706
    … …  
    86618791    mMediaData.free();
    86628792    mStorageControllers.free();
     8793    mUSBControllers.free();
    86638794    mHWData.free();
    86648795    mUserData.free();
    … …  
    91749305        if (FAILED(rc)) return rc;
    91759306
    9176         /* USB Controller */
    9177         rc = mUSBController->loadSettings(data.usbController);
    9178         if (FAILED(rc)) return rc;
     9307        /* Shared folders */
     9308        for (settings::USBControllerList::const_iterator it = data.usbSettings.llUSBControllers.begin();
     9309             it != data.usbSettings.llUSBControllers.end();
     9310             ++it)
     9311        {
     9312            const settings::USBController &settingsCtrl = *it;
     9313            ComObjPtr<USBController> newCtrl;
     9314
     9315            newCtrl.createObject();
     9316            newCtrl->init(this, settingsCtrl.strName, settingsCtrl.enmType);
     9317            mUSBControllers->push_back(newCtrl);
     9318        }
    91799319
    91809320        /* USB device filters */
    9181         rc = mUSBDeviceFilters->loadSettings(data.usbController);
     9321        rc = mUSBDeviceFilters->loadSettings(data.usbSettings);
    91829322        if (FAILED(rc)) return rc;
    91839323
    … …  
    97469886                        aName.c_str());
    97479887    return VBOX_E_OBJECT_NOT_FOUND;
     9888}
     9889
     9890/**
     9891 * Returns a USB controller object with the given name.
     9892 *
     9893 *  @param aName                 USB controller name to find
     9894 *  @param aUSBController        where to return the found USB controller
     9895 *  @param aSetError             true to set extended error info on failure
     9896 */
     9897HRESULT Machine::getUSBControllerByName(const Utf8Str &aName,
     9898                                        ComObjPtr<USBController> &aUSBController,
     9899                                        bool aSetError /* = false */)
     9900{
     9901    AssertReturn(!aName.isEmpty(), E_INVALIDARG);
     9902
     9903    for (USBControllerList::const_iterator it = mUSBControllers->begin();
     9904         it != mUSBControllers->end();
     9905         ++it)
     9906    {
     9907        if ((*it)->getName() == aName)
     9908        {
     9909            aUSBController = (*it);
     9910            return S_OK;
     9911        }
     9912    }
     9913
     9914    if (aSetError)
     9915        return setError(VBOX_E_OBJECT_NOT_FOUND,
     9916                        tr("Could not find a storage controller named '%s'"),
     9917                        aName.c_str());
     9918    return VBOX_E_OBJECT_NOT_FOUND;
     9919}
     9920
     9921/**
     9922 * Returns the number of USB controller instance of the given type.
     9923 *
     9924 * @param enmType                USB controller type.
     9925 */
     9926ULONG Machine::getUSBControllerCountByType(USBControllerType_T enmType)
     9927{
     9928    ULONG cCtrls = 0;
     9929
     9930    for (USBControllerList::const_iterator it = mUSBControllers->begin();
     9931         it != mUSBControllers->end();
     9932         ++it)
     9933    {
     9934        if ((*it)->getControllerType() == enmType)
     9935            cCtrls++;
     9936    }
     9937
     9938    return cCtrls;
    97489939}
    97499940
    … …  
    1041610607
    1041710608        /* USB Controller (required) */
    10418         rc = mUSBController->saveSettings(data.usbController);
    10419         if (FAILED(rc)) throw rc;
     10609        for (USBControllerList::const_iterator it = mUSBControllers->begin();
     10610             it != mUSBControllers->end();
     10611             ++it)
     10612        {
     10613            ComObjPtr<USBController> ctrl = *it;
     10614            settings::USBController settingsCtrl;
     10615
     10616            settingsCtrl.strName = ctrl->getName();
     10617            settingsCtrl.enmType = ctrl->getControllerType();
     10618
     10619            data.usbSettings.llUSBControllers.push_back(settingsCtrl);
     10620        }
    1042010621
    1042110622        /* USB device filters (required) */
    10422         rc = mUSBDeviceFilters->saveSettings(data.usbController);
     10623        rc = mUSBDeviceFilters->saveSettings(data.usbSettings);
    1042310624        if (FAILED(rc)) throw rc;
    1042410625
    … …  
    1180912010    }
    1181012011
     12012    if (!mUSBControllers.isNull())
     12013    {
     12014        if (mUSBControllers.isBackedUp())
     12015        {
     12016            /* unitialize all new devices (absent in the backed up list). */
     12017            USBControllerList::const_iterator it = mUSBControllers->begin();
     12018            USBControllerList *backedList = mUSBControllers.backedUpData();
     12019            while (it != mUSBControllers->end())
     12020            {
     12021                if (   std::find(backedList->begin(), backedList->end(), *it)
     12022                    == backedList->end()
     12023                   )
     12024                {
     12025                    (*it)->uninit();
     12026                }
     12027                ++it;
     12028            }
     12029
     12030            /* restore the list */
     12031            mUSBControllers.rollback();
     12032        }
     12033
     12034        /* rollback any changes to devices after restoring the list */
     12035        if (mData->flModifications & IsModified_USB)
     12036        {
     12037            USBControllerList::const_iterator it = mUSBControllers->begin();
     12038            while (it != mUSBControllers->end())
     12039            {
     12040                (*it)->rollback();
     12041                ++it;
     12042            }
     12043        }
     12044    }
     12045
    1181112046    mUserData.rollback();
    1181212047
    … …  
    1182412059    if (mAudioAdapter)
    1182512060        mAudioAdapter->rollback();
    11826 
    11827     if (mUSBController && (mData->flModifications & IsModified_USB))
    11828         mUSBController->rollback();
    1182912061
    1183012062    if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
    … …  
    1193412166    mVRDEServer->commit();
    1193512167    mAudioAdapter->commit();
    11936     mUSBController->commit();
    1193712168    mUSBDeviceFilters->commit();
    1193812169    mBandwidthControl->commit();
    … …  
    1206512296    }
    1206612297
     12298    bool commitUSBControllers = false;
     12299
     12300    if (mUSBControllers.isBackedUp())
     12301    {
     12302        mUSBControllers.commit();
     12303
     12304        if (mPeer)
     12305        {
     12306            /* Commit all changes to new controllers (this will reshare data with
     12307             * peers for those who have peers) */
     12308            USBControllerList *newList = new USBControllerList();
     12309            USBControllerList::const_iterator it = mUSBControllers->begin();
     12310            while (it != mUSBControllers->end())
     12311            {
     12312                (*it)->commit();
     12313
     12314                /* look if this controller has a peer device */
     12315                ComObjPtr<USBController> peer = (*it)->getPeer();
     12316                if (!peer)
     12317                {
     12318                    /* no peer means the device is a newly created one;
     12319                     * create a peer owning data this device share it with */
     12320                    peer.createObject();
     12321                    peer->init(mPeer, *it, true /* aReshare */);
     12322                }
     12323                else
     12324                {
     12325                    /* remove peer from the old list */
     12326                    mPeer->mUSBControllers->remove(peer);
     12327                }
     12328                /* and add it to the new list */
     12329                newList->push_back(peer);
     12330
     12331                ++it;
     12332            }
     12333
     12334            /* uninit old peer's controllers that are left */
     12335            it = mPeer->mUSBControllers->begin();
     12336            while (it != mPeer->mUSBControllers->end())
     12337            {
     12338                (*it)->uninit();
     12339                ++it;
     12340            }
     12341
     12342            /* attach new list of controllers to our peer */
     12343            mPeer->mUSBControllers.attach(newList);
     12344        }
     12345        else
     12346        {
     12347            /* we have no peer (our parent is the newly created machine);
     12348             * just commit changes to devices */
     12349            commitUSBControllers = true;
     12350        }
     12351    }
     12352    else
     12353    {
     12354        /* the list of controllers itself is not changed,
     12355         * just commit changes to controllers themselves */
     12356        commitUSBControllers = true;
     12357    }
     12358
     12359    if (commitUSBControllers)
     12360    {
     12361        USBControllerList::const_iterator it = mUSBControllers->begin();
     12362        while (it != mUSBControllers->end())
     12363        {
     12364            (*it)->commit();
     12365            ++it;
     12366        }
     12367    }
     12368
    1206712369    if (isSessionMachine())
    1206812370    {
    … …  
    1211312415    mVRDEServer->copyFrom(aThat->mVRDEServer);
    1211412416    mAudioAdapter->copyFrom(aThat->mAudioAdapter);
    12115     mUSBController->copyFrom(aThat->mUSBController);
    1211612417    mUSBDeviceFilters->copyFrom(aThat->mUSBDeviceFilters);
    1211712418    mBandwidthControl->copyFrom(aThat->mBandwidthControl);
    … …  
    1212812429        ctrl->initCopy(this, *it);
    1212912430        mStorageControllers->push_back(ctrl);
     12431    }
     12432
     12433    /* create private copies of all USB controllers */
     12434    mUSBControllers.backup();
     12435    mUSBControllers->clear();
     12436    for (USBControllerList::iterator it = aThat->mUSBControllers->begin();
     12437         it != aThat->mUSBControllers->end();
     12438         ++it)
     12439    {
     12440        ComObjPtr<USBController> ctrl;
     12441        ctrl.createObject();
     12442        ctrl->initCopy(this, *it);
     12443        mUSBControllers->push_back(ctrl);
    1213012444    }
    1213112445
    … …  
    1251912833    }
    1252012834
     12835    mUSBControllers.allocate();
     12836    for (USBControllerList::const_iterator it = aMachine->mUSBControllers->begin();
     12837         it != aMachine->mUSBControllers->end();
     12838         ++it)
     12839    {
     12840        ComObjPtr<USBController> ctl;
     12841        ctl.createObject();
     12842        ctl->init(this, *it);
     12843        mUSBControllers->push_back(ctl);
     12844    }
     12845
    1252112846    unconst(mBIOSSettings).createObject();
    1252212847    mBIOSSettings->init(this, aMachine->mBIOSSettings);
    … …  
    1253912864        mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
    1254012865    }
    12541     /* create another USB controller object that will be mutable */
    12542     unconst(mUSBController).createObject();
    12543     mUSBController->init(this, aMachine->mUSBController);
    1254412866
    1254512867    /* create another USB device filters object that will be mutable */

  • trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

    r47376 r47401  
    10781078    mAudioAdapter->initCopy(this, pMachine->mAudioAdapter);
    10791079
    1080     unconst(mUSBController).createObject();
    1081     mUSBController->initCopy(this, pMachine->mUSBController);
     1080    /* create copies of all USB controllers (mUSBControllerData
     1081     * after attaching a copy contains just references to original objects) */
     1082    mUSBControllers.allocate();
     1083    for (USBControllerList::const_iterator
     1084         it = aSessionMachine->mUSBControllers->begin();
     1085         it != aSessionMachine->mUSBControllers->end();
     1086         ++it)
     1087    {
     1088        ComObjPtr<USBController> ctrl;
     1089        ctrl.createObject();
     1090        ctrl->initCopy(this, *it);
     1091        mUSBControllers->push_back(ctrl);
     1092    }
    10821093
    10831094    unconst(mUSBDeviceFilters).createObject();
    … …  
    11641175    mMediaData.allocate();
    11651176    mStorageControllers.allocate();
     1177    mUSBControllers.allocate();
    11661178
    11671179    /* SSData is always unique for SnapshotMachine */
    … …  
    11791191    unconst(mAudioAdapter).createObject();
    11801192    mAudioAdapter->init(this);
    1181 
    1182     unconst(mUSBController).createObject();
    1183     mUSBController->init(this);
    11841193
    11851194    unconst(mUSBDeviceFilters).createObject();

  • trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

    r46367 r47401  
    581581            AssertMsgFailed(("Invalid controller type %d\n", aControllerType));
    582582    }
     583    return S_OK;
     584}
     585
     586STDMETHODIMP SystemProperties::GetMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
     587                                                                  USBControllerType_T aType,
     588                                                                  ULONG *aMaxInstances)
     589{
     590    CheckComArgOutPointerValid(aMaxInstances);
     591
     592    AutoCaller autoCaller(this);
     593    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     594
     595    ULONG cCtrs = 0;
     596
     597    /* no need to lock, this is const */
     598    switch (aType)
     599    {
     600        case USBControllerType_OHCI:
     601        case USBControllerType_EHCI:
     602        {
     603            cCtrs = 1;
     604            break;
     605        }
     606        default:
     607            AssertMsgFailed(("Invalid bus type %d\n", aType));
     608    }
     609
     610    *aMaxInstances = cCtrs;
     611
    583612    return S_OK;
    584613}

  • trunk/src/VBox/Main/src-server/USBControllerImpl.cpp

    r47376 r47401  
    4242{
    4343    BackupableUSBData()
    44         : fEnabled(false),
    45           fEnabledEHCI(false)
     44        : enmType(USBControllerType_Null)
    4645    { }
    4746
    48     BOOL fEnabled;
    49     BOOL fEnabledEHCI;
     47    Utf8Str             strName;
     48    USBControllerType_T enmType;
    5049};
    5150
    … …  
    9392 * @returns COM result indicator.
    9493 * @param aParent       Pointer to our parent object.
    95  */
    96 HRESULT USBController::init(Machine *aParent)
    97 {
    98     LogFlowThisFunc(("aParent=%p\n", aParent));
    99 
    100     ComAssertRet(aParent, E_INVALIDARG);
     94 * @param aName         The name of the USB controller.
     95 * @param enmType       The USB controller type.
     96 */
     97HRESULT USBController::init(Machine *aParent, const Utf8Str &aName, USBControllerType_T enmType)
     98{
     99    LogFlowThisFunc(("aParent=%p aName=\"%s\"\n", aParent, aName.c_str()));
     100
     101    ComAssertRet(aParent && !aName.isEmpty(), E_INVALIDARG);
     102    if (   (enmType <= USBControllerType_Null)
     103        || (enmType >  USBControllerType_EHCI))
     104        return setError(E_INVALIDARG,
     105                        tr("Invalid USB controller type"));
    101106
    102107    /* Enclose the state transition NotReady->InInit->Ready */
    … …  
    109114
    110115    m->bd.allocate();
     116    m->bd->strName = aName;
     117    m->bd->enmType = enmType;
    111118
    112119    /* Confirm a successful initialization */
    … …  
    124131 * @param aParent       Pointer to our parent object.
    125132 * @param aPeer         The object to share.
    126  *
    127  * @note This object must be destroyed before the original object
    128  * it shares data with is destroyed.
    129  */
    130 HRESULT USBController::init(Machine *aParent, USBController *aPeer)
    131 {
    132     LogFlowThisFunc(("aParent=%p, aPeer=%p\n", aParent, aPeer));
     133 *  @param  aReshare
     134 *      When false, the original object will remain a data owner.
     135 *      Otherwise, data ownership will be transferred from the original
     136 *      object to this one.
     137 *
     138 *  @note This object must be destroyed before the original object
     139 *  it shares data with is destroyed.
     140 *
     141 *  @note Locks @a aThat object for writing if @a aReshare is @c true, or for
     142 *  reading if @a aReshare is false.
     143 */
     144HRESULT USBController::init(Machine *aParent, USBController *aPeer,
     145                            bool fReshare /* = false */)
     146{
     147    LogFlowThisFunc(("aParent=%p, aPeer=%p, fReshare=%RTbool\n",
     148                      aParent, aPeer, fReshare));
    133149
    134150    ComAssertRet(aParent && aPeer, E_INVALIDARG);
    … …  
    140156    m = new Data(aParent);
    141157
    142     unconst(m->pPeer) = aPeer;
    143 
    144     AutoWriteLock thatlock(aPeer COMMA_LOCKVAL_SRC_POS);
    145     m->bd.share(aPeer->m->bd);
     158    /* sanity */
     159    AutoCaller peerCaller(aPeer);
     160    AssertComRCReturnRC(peerCaller.rc());
     161
     162    if (fReshare)
     163    {
     164        AutoWriteLock peerLock(aPeer COMMA_LOCKVAL_SRC_POS);
     165
     166        unconst(aPeer->m->pPeer) = this;
     167        m->bd.attach (aPeer->m->bd);
     168    }
     169    else
     170    {
     171        unconst(m->pPeer) = aPeer;
     172
     173        AutoReadLock peerLock(aPeer COMMA_LOCKVAL_SRC_POS);
     174        m->bd.share (aPeer->m->bd);
     175    }
    146176
    147177    /* Confirm a successful initialization */
    … …  
    206236// IUSBController properties
    207237/////////////////////////////////////////////////////////////////////////////
    208 
    209 STDMETHODIMP USBController::COMGETTER(Enabled)(BOOL *aEnabled)
    210 {
    211     CheckComArgOutPointerValid(aEnabled);
     238STDMETHODIMP USBController::COMGETTER(Name) (BSTR *aName)
     239{
     240    CheckComArgOutPointerValid(aName);
    212241
    213242    AutoCaller autoCaller(this);
    214243    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    215244
     245    /* strName is constant during life time, no need to lock */
     246    m->bd->strName.cloneTo(aName);
     247
     248    return S_OK;
     249}
     250
     251STDMETHODIMP USBController::COMGETTER(Type)(USBControllerType_T *aType)
     252{
     253    CheckComArgOutPointerValid(aType);
     254
     255    AutoCaller autoCaller(this);
     256    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     257
    216258    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    217259
    218     *aEnabled = m->bd->fEnabled;
    219 
    220     return S_OK;
    221 }
    222 
    223 
    224 STDMETHODIMP USBController::COMSETTER(Enabled)(BOOL aEnabled)
    225 {
    226     LogFlowThisFunc(("aEnabled=%RTbool\n", aEnabled));
     260    *aType = m->bd->enmType;
     261
     262    return S_OK;
     263}
     264
     265STDMETHODIMP USBController::COMGETTER(USBStandard)(USHORT *aUSBStandard)
     266{
     267    CheckComArgOutPointerValid(aUSBStandard);
    227268
    228269    AutoCaller autoCaller(this);
    229270    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    230271
    231     /* the machine needs to be mutable */
    232     AutoMutableStateDependency adep(m->pParent);
    233     if (FAILED(adep.rc())) return adep.rc();
    234 
    235     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    236 
    237     if (m->bd->fEnabled != aEnabled)
     272    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     273
     274    switch (m->bd->enmType)
    238275    {
    239         m->bd.backup();
    240         m->bd->fEnabled = aEnabled;
    241 
    242         // leave the lock for safety
    243         alock.release();
    244 
    245         AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
    246         m->pParent->setModified(Machine::IsModified_USB);
    247         mlock.release();
    248 
    249         m->pParent->onUSBControllerChange();
     276        case USBControllerType_OHCI:
     277            *aUSBStandard = 0x0101;
     278            break;
     279        case USBControllerType_EHCI:
     280            *aUSBStandard = 0x0200;
     281            break;
     282        default:
     283            AssertMsgFailedReturn(("Invalid controller type %d\n", m->bd->enmType),
     284                                  E_FAIL);
    250285    }
    251286
    … …  
    253288}
    254289
    255 STDMETHODIMP USBController::COMGETTER(EnabledEHCI)(BOOL *aEnabled)
    256 {
    257     CheckComArgOutPointerValid(aEnabled);
    258 
    259     AutoCaller autoCaller(this);
    260     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    261 
    262     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    263 
    264     *aEnabled = m->bd->fEnabledEHCI;
    265 
    266     return S_OK;
    267 }
    268 
    269 STDMETHODIMP USBController::COMSETTER(EnabledEHCI)(BOOL aEnabled)
    270 {
    271     LogFlowThisFunc(("aEnabled=%RTbool\n", aEnabled));
    272 
    273     AutoCaller autoCaller(this);
    274     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    275 
    276     /* the machine needs to be mutable */
    277     AutoMutableStateDependency adep(m->pParent);
    278     if (FAILED(adep.rc())) return adep.rc();
    279 
    280     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    281 
    282     if (m->bd->fEnabledEHCI != aEnabled)
    283     {
    284         m->bd.backup();
    285         m->bd->fEnabledEHCI = aEnabled;
    286 
    287         // leave the lock for safety
    288         alock.release();
    289 
    290         AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);
    291         m->pParent->setModified(Machine::IsModified_USB);
    292         mlock.release();
    293 
    294         m->pParent->onUSBControllerChange();
    295     }
    296 
    297     return S_OK;
    298 }
    299 
    300 STDMETHODIMP USBController::COMGETTER(ProxyAvailable)(BOOL *aEnabled)
    301 {
    302     CheckComArgOutPointerValid(aEnabled);
    303 
    304     AutoCaller autoCaller(this);
    305     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    306 
    307     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    308 
    309 #ifdef VBOX_WITH_USB
    310     *aEnabled = true;
    311 #else
    312     *aEnabled = false;
    313 #endif
    314 
    315     return S_OK;
    316 }
    317 
    318 STDMETHODIMP USBController::COMGETTER(USBStandard)(USHORT *aUSBStandard)
    319 {
    320     CheckComArgOutPointerValid(aUSBStandard);
    321 
    322     AutoCaller autoCaller(this);
    323     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    324 
    325     /* not accessing data -- no need to lock */
    326 
    327     /** @todo This is no longer correct */
    328     *aUSBStandard = 0x0101;
    329 
    330     return S_OK;
    331 }
    332 
    333290// public methods only for internal purposes
    334291/////////////////////////////////////////////////////////////////////////////
    335 
    336 /**
    337  *  Loads settings from the given machine node.
    338  *  May be called once right after this object creation.
    339  *
    340  *  @param aMachineNode <Machine> node.
    341  *
    342  *  @note Does not lock "this" as Machine::loadHardware, which calls this, does not lock either.
    343  */
    344 HRESULT USBController::loadSettings(const settings::USBController &data)
    345 {
    346     AutoCaller autoCaller(this);
    347     AssertComRCReturnRC(autoCaller.rc());
    348 
    349     /* Note: we assume that the default values for attributes of optional
    350      * nodes are assigned in the Data::Data() constructor and don't do it
    351      * here. It implies that this method may only be called after constructing
    352      * a new BIOSSettings object while all its data fields are in the default
    353      * values. Exceptions are fields whose creation time defaults don't match
    354      * values that should be applied when these fields are not explicitly set
    355      * in the settings file (for backwards compatibility reasons). This takes
    356      * place when a setting of a newly created object must default to A while
    357      * the same setting of an object loaded from the old settings file must
    358      * default to B. */
    359 
    360     m->bd->fEnabled = data.fEnabled;
    361     m->bd->fEnabledEHCI = data.fEnabledEHCI;
    362 
    363     return S_OK;
    364 }
    365 
    366 /**
    367  *  Saves settings to the given machine node.
    368  *
    369  *  @param aMachineNode <Machine> node.
    370  *
    371  *  @note Locks this object for reading.
    372  */
    373 HRESULT USBController::saveSettings(settings::USBController &data)
    374 {
    375     AutoCaller autoCaller(this);
    376     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    377 
    378     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    379 
    380     data.fEnabled = !!m->bd->fEnabled;
    381     data.fEnabledEHCI = !!m->bd->fEnabledEHCI;
    382 
    383     return S_OK;
    384 }
    385292
    386293/** @note Locks objects for writing! */
    … …  
    460367}
    461368
     369/**
     370 *  Cancels sharing (if any) by making an independent copy of data.
     371 *  This operation also resets this object's peer to NULL.
     372 *
     373 *  @note Locks this object for writing, together with the peer object
     374 *  represented by @a aThat (locked for reading).
     375 */
     376void USBController::unshare()
     377{
     378    /* sanity */
     379    AutoCaller autoCaller(this);
     380    AssertComRCReturnVoid (autoCaller.rc());
     381
     382    /* sanity too */
     383    AutoCaller peerCaller (m->pPeer);
     384    AssertComRCReturnVoid (peerCaller.rc());
     385
     386    /* peer is not modified, lock it for reading (m->pPeer is "master" so locked
     387     * first) */
     388    AutoReadLock rl(m->pPeer COMMA_LOCKVAL_SRC_POS);
     389    AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
     390
     391    if (m->bd.isShared())
     392    {
     393        if (!m->bd.isBackedUp())
     394            m->bd.backup();
     395
     396        m->bd.commit();
     397    }
     398
     399    unconst(m->pPeer) = NULL;
     400}
     401
     402const Utf8Str& USBController::getName() const
     403{
     404    return m->bd->strName;
     405}
     406
     407USBControllerType_T USBController::getControllerType() const
     408{
     409    return m->bd->enmType;
     410}
     411
     412ComObjPtr<USBController> USBController::getPeer()
     413{
     414    return m->pPeer;
     415}
     416
    462417// private methods
    463418/////////////////////////////////////////////////////////////////////////////

  • trunk/src/VBox/Main/src-server/USBDeviceFiltersImpl.cpp

    r47390 r47401  
    497497 *  @note Does not lock "this" as Machine::loadHardware, which calls this, does not lock either.
    498498 */
    499 HRESULT USBDeviceFilters::loadSettings(const settings::USBController &data)
     499HRESULT USBDeviceFilters::loadSettings(const settings::USB &data)
    500500{
    501501    AutoCaller autoCaller(this);
    … …  
    540540 *  @note Locks this object for reading.
    541541 */
    542 HRESULT USBDeviceFilters::saveSettings(settings::USBController &data)
     542HRESULT USBDeviceFilters::saveSettings(settings::USB &data)
    543543{
    544544    AutoCaller autoCaller(this);

  • trunk/src/VBox/Main/xml/Settings.cpp

    r47246 r47401  
    17111711{
    17121712    return (    (this == &u)
    1713                  || (    (fEnabled          == u.fEnabled)
    1714                       && (fEnabledEHCI      == u.fEnabledEHCI)
    1715                       && (llDeviceFilters   == u.llDeviceFilters)
     1713                 || (    (strName == u.strName)
     1714                      && (enmType == u.enmType)
     1715                    )
     1716           );
     1717}
     1718
     1719/**
     1720 * Comparison operator. This gets called from MachineConfigFile::operator==,
     1721 * which in turn gets called from Machine::saveSettings to figure out whether
     1722 * machine settings have really changed and thus need to be written out to disk.
     1723 */
     1724bool USB::operator==(const USB &u) const
     1725{
     1726    return (    (this == &u)
     1727                 || (    (llUSBControllers == u.llUSBControllers)
     1728                      && (llDeviceFilters  == u.llDeviceFilters)
    17161729                    )
    17171730           );
    … …  
    19361949                  && (vrdeSettings              == h.vrdeSettings)
    19371950                  && (biosSettings              == h.biosSettings)
    1938                   && (usbController             == h.usbController)
     1951                  && (usbSettings               == h.usbSettings)
    19391952                  && (llNetworkAdapters         == h.llNetworkAdapters)
    19401953                  && (llSerialPorts             == h.llSerialPorts)
    … …  
    29682981            }
    29692982        }
    2970         else if (pelmHwChild->nameEquals("USBController"))
    2971         {
    2972             pelmHwChild->getAttributeValue("enabled", hw.usbController.fEnabled);
    2973             pelmHwChild->getAttributeValue("enabledEhci", hw.usbController.fEnabledEHCI);
     2983        else if (   (m->sv <= SettingsVersion_v1_14)
     2984                 && pelmHwChild->nameEquals("USBController"))
     2985        {
     2986            bool fEnabled = false;
     2987
     2988            pelmHwChild->getAttributeValue("enabled", fEnabled);
     2989            if (fEnabled)
     2990            {
     2991                /* Create OHCI controller with default name. */
     2992                USBController ctrl;
     2993
     2994                ctrl.strName = "OHCI";
     2995                ctrl.enmType = USBControllerType_OHCI;
     2996                hw.usbSettings.llUSBControllers.push_back(ctrl);
     2997            }
     2998
     2999            pelmHwChild->getAttributeValue("enabledEhci", fEnabled);
     3000            if (fEnabled)
     3001            {
     3002                /* Create OHCI controller with default name. */
     3003                USBController ctrl;
     3004
     3005                ctrl.strName = "EHCI";
     3006                ctrl.enmType = USBControllerType_EHCI;
     3007                hw.usbSettings.llUSBControllers.push_back(ctrl);
     3008            }
    29743009
    29753010            readUSBDeviceFilters(*pelmHwChild,
    2976                                  hw.usbController.llDeviceFilters);
     3011                                 hw.usbSettings.llDeviceFilters);
     3012        }
     3013        else if (pelmHwChild->nameEquals("USB"))
     3014        {
     3015            const xml::ElementNode *pelmUSBChild;
     3016
     3017            if ((pelmUSBChild = pelmHwChild->findChildElement("Controllers")))
     3018            {
     3019                xml::NodesLoop nl2(*pelmUSBChild, "Controller");
     3020                const xml::ElementNode *pelmCtrl;
     3021
     3022                while ((pelmCtrl = nl2.forAllNodes()))
     3023                {
     3024                    USBController ctrl;
     3025                    com::Utf8Str strCtrlType;
     3026
     3027                    pelmCtrl->getAttributeValue("name", ctrl.strName);
     3028
     3029                    if (pelmCtrl->getAttributeValue("type", strCtrlType))
     3030                    {
     3031                        if (strCtrlType == "OHCI")
     3032                            ctrl.enmType = USBControllerType_OHCI;
     3033                        else if (strCtrlType == "EHCI")
     3034                            ctrl.enmType = USBControllerType_EHCI;
     3035                        else
     3036                            throw ConfigFileError(this, pelmCtrl, N_("Invalid value '%s' for Controller/@type attribute"), strCtrlType.c_str());
     3037                    }
     3038
     3039                    hw.usbSettings.llUSBControllers.push_back(ctrl);
     3040                }
     3041            }
     3042
     3043            if ((pelmUSBChild = pelmHwChild->findChildElement("DeviceFilters")))
     3044                readUSBDeviceFilters(*pelmUSBChild, hw.usbSettings.llDeviceFilters);
    29773045        }
    29783046        else if (    (m->sv < SettingsVersion_v1_7)
    … …  
    42064274    }
    42074275
    4208     xml::ElementNode *pelmUSB = pelmHardware->createChild("USBController");
    4209     pelmUSB->setAttribute("enabled", hw.usbController.fEnabled);
    4210     pelmUSB->setAttribute("enabledEhci", hw.usbController.fEnabledEHCI);
    4211 
    4212     buildUSBDeviceFilters(*pelmUSB,
    4213                           hw.usbController.llDeviceFilters,
    4214                           false);               // fHostMode
     4276    if (m->sv < SettingsVersion_v1_14)
     4277    {
     4278        bool fOhciEnabled = false;
     4279        bool fEhciEnabled = false;
     4280        xml::ElementNode *pelmUSB = pelmHardware->createChild("USBController");
     4281
     4282        for (USBControllerList::const_iterator it = hardwareMachine.usbSettings.llUSBControllers.begin();
     4283             it != hardwareMachine.usbSettings.llUSBControllers.end();
     4284             ++it)
     4285        {
     4286            const USBController &ctrl = *it;
     4287
     4288            switch (ctrl.enmType)
     4289            {
     4290                case USBControllerType_OHCI:
     4291                    fOhciEnabled = true;
     4292                    break;
     4293                case USBControllerType_EHCI:
     4294                    fEhciEnabled = true;
     4295                    break;
     4296                default:
     4297                    AssertMsgFailed(("Unknown USB controller type %d\n", ctrl.enmType));
     4298            }
     4299        }
     4300
     4301        pelmUSB->setAttribute("enabled", fOhciEnabled);
     4302        pelmUSB->setAttribute("enabledEhci", fEhciEnabled);
     4303
     4304        buildUSBDeviceFilters(*pelmUSB, hw.usbSettings.llDeviceFilters, false /* fHostMode */);
     4305    }
     4306    else
     4307    {
     4308        xml::ElementNode *pelmUSB = pelmHardware->createChild("USB");
     4309        xml::ElementNode *pelmCtrls = pelmUSB->createChild("Controllers");
     4310
     4311        for (USBControllerList::const_iterator it = hardwareMachine.usbSettings.llUSBControllers.begin();
     4312             it != hardwareMachine.usbSettings.llUSBControllers.end();
     4313             ++it)
     4314        {
     4315            const USBController &ctrl = *it;
     4316            com::Utf8Str strType;
     4317            xml::ElementNode *pelmCtrl = pelmCtrls->createChild("Controller");
     4318
     4319            switch (ctrl.enmType)
     4320            {
     4321                case USBControllerType_OHCI:
     4322                    strType = "OHCI";
     4323                    break;
     4324                case USBControllerType_EHCI:
     4325                    strType = "EHCI";
     4326                    break;
     4327                default:
     4328                    AssertMsgFailed(("Unknown USB controller type %d\n", ctrl.enmType));
     4329            }
     4330
     4331            pelmCtrl->setAttribute("name", ctrl.strName);
     4332            pelmCtrl->setAttribute("type", strType);
     4333        }
     4334
     4335        xml::ElementNode *pelmFilters = pelmUSB->createChild("DeviceFilters");
     4336        buildUSBDeviceFilters(*pelmFilters, hw.usbSettings.llDeviceFilters, false /* fHostMode */);
     4337    }
    42154338
    42164339    xml::ElementNode *pelmNetwork = pelmHardware->createChild("Network");
    … …  
    51765299    }
    51775300
     5301    if (m->sv < SettingsVersion_v1_14)
     5302    {
     5303        unsigned cOhciCtrls = 0;
     5304        unsigned cEhciCtrls = 0;
     5305        bool fNonStdName = false;
     5306
     5307        for (USBControllerList::const_iterator it = hardwareMachine.usbSettings.llUSBControllers.begin();
     5308             it != hardwareMachine.usbSettings.llUSBControllers.end();
     5309             ++it)
     5310        {
     5311            const USBController &ctrl = *it;
     5312
     5313            switch (ctrl.enmType)
     5314            {
     5315                case USBControllerType_OHCI:
     5316                    cOhciCtrls++;
     5317                    if (ctrl.strName != "OHCI")
     5318                        fNonStdName = true;
     5319                    break;
     5320               case USBControllerType_EHCI:
     5321                    cEhciCtrls++;
     5322                    if (ctrl.strName != "EHCI")
     5323                        fNonStdName = true;
     5324                    break;
     5325                default:
     5326                    AssertMsgFailed(("Unknown USB controller type %d\n", ctrl.enmType));
     5327            }
     5328
     5329            /* Skip checking other controllers if the settings bump is necessary. */
     5330            if (cOhciCtrls > 1 || cEhciCtrls > 1 || fNonStdName)
     5331            {
     5332                m->sv = SettingsVersion_v1_14;
     5333                break;
     5334            }
     5335        }
     5336    }
     5337
    51785338    if (m->sv < SettingsVersion_v1_13)
    51795339    {
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