VirtualBox

Changeset 56843 in vbox


Ignore:
Timestamp:
Jul 7, 2015 4:03:53 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
101498
Message:

Frontends/VBoxManage: Add a modifyvm option to rename USB controllers, use "xHCI" as the default xHCI controller name, and remove USB controllers by type, not by hardcoded name.
Frontends/VirtualBox: Use "xHCI" as the default xHCI controller name, and remove USB controllers by type, not by hardcoded name.

Location:
trunk/src/VBox/Frontends
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r56831 r56843  
    851851                     "                            [--usbehci on|off]\n"
    852852                     "                            [--usbxhci on|off]\n"
     853                     "                            [--usbrename <oldname> <newname>]\n"
    853854                     "                            [--snapshotfolder default|<path>]\n"
    854855                     "                            [--teleporter on|off]\n"

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

    r56834 r56843  
    163163    MODIFYVM_VRDE,
    164164    MODIFYVM_RTCUSEUTC,
     165    MODIFYVM_USBRENAME,
    165166    MODIFYVM_USBXHCI,
    166167    MODIFYVM_USBEHCI,
    … …  
    332333    { "--vrdeextpack",              MODIFYVM_VRDE_EXTPACK,              RTGETOPT_REQ_STRING },
    333334    { "--vrde",                     MODIFYVM_VRDE,                      RTGETOPT_REQ_BOOL_ONOFF },
     335    { "--usbrename",                MODIFYVM_USBRENAME,                 RTGETOPT_REQ_STRING },
    334336    { "--usbxhci",                  MODIFYVM_USBXHCI,                   RTGETOPT_REQ_BOOL_ONOFF },
    335337    { "--usbehci",                  MODIFYVM_USBEHCI,                   RTGETOPT_REQ_BOOL_ONOFF },
    … …  
    25252527            }
    25262528
     2529            case MODIFYVM_USBRENAME:
     2530            {
     2531                const char *pszName = ValueUnion.psz;
     2532                int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
     2533                if (RT_FAILURE(vrc))
     2534                    return errorSyntax(USAGE_MODIFYVM,
     2535                                       "Missing or Invalid argument to '%s'",
     2536                                       GetOptState.pDef->pszLong);
     2537                const char *pszNewName = ValueUnion.psz;
     2538
     2539                SafeIfaceArray<IUSBController> ctrls;
     2540                CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
     2541                bool fRenamed = false;
     2542                for (size_t i = 0; i < ctrls.size(); i++)
     2543                {
     2544                    ComPtr<IUSBController> pCtrl = ctrls[i];
     2545                    Bstr bstrName;
     2546                    CHECK_ERROR(pCtrl, COMGETTER(Name)(bstrName.asOutParam()));
     2547                    if (bstrName == pszName)
     2548                    {
     2549                        bstrName = pszNewName;
     2550                        CHECK_ERROR(pCtrl, COMSETTER(Name)(bstrName.raw()));
     2551                        fRenamed = true;
     2552                    }
     2553                }
     2554                if (!fRenamed)
     2555                {
     2556                    errorArgument("Invalid --usbrename parameters, nothing renamed");
     2557                    rc = E_FAIL;
     2558                }
     2559                break;
     2560            }
     2561
    25272562            case MODIFYVM_USBXHCI:
    25282563            {
    … …  
    25342569                    {
    25352570                        ComPtr<IUSBController> UsbCtl;
    2536                         CHECK_ERROR(sessionMachine, AddUSBController(Bstr("XHCI").raw(), USBControllerType_XHCI,
     2571                        CHECK_ERROR(sessionMachine, AddUSBController(Bstr("xHCI").raw(), USBControllerType_XHCI,
    25372572                                                              UsbCtl.asOutParam()));
    25382573                    }
    25392574                    else if (cXhciCtrls && !ValueUnion.f)
    2540                         CHECK_ERROR(sessionMachine, RemoveUSBController(Bstr("XHCI").raw()));
     2575                    {
     2576                        SafeIfaceArray<IUSBController> ctrls;
     2577                        CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
     2578                        for (size_t i = 0; i < ctrls.size(); i++)
     2579                        {
     2580                            ComPtr<IUSBController> pCtrl = ctrls[i];
     2581                            USBControllerType_T enmType;
     2582                            CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
     2583                            if (enmType == USBControllerType_XHCI)
     2584                            {
     2585                                Bstr ctrlName;
     2586                                CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
     2587                                CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
     2588                            }
     2589                        }
     2590                    }
    25412591                }
    25422592                break;
    … …  
    25562606                    }
    25572607                    else if (cEhciCtrls && !ValueUnion.f)
    2558                         CHECK_ERROR(sessionMachine, RemoveUSBController(Bstr("EHCI").raw()));
     2608                    {
     2609                        SafeIfaceArray<IUSBController> ctrls;
     2610                        CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
     2611                        for (size_t i = 0; i < ctrls.size(); i++)
     2612                        {
     2613                            ComPtr<IUSBController> pCtrl = ctrls[i];
     2614                            USBControllerType_T enmType;
     2615                            CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
     2616                            if (enmType == USBControllerType_EHCI)
     2617                            {
     2618                                Bstr ctrlName;
     2619                                CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
     2620                                CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
     2621                            }
     2622                        }
     2623                    }
    25592624                }
    25602625                break;
    … …  
    25742639                    }
    25752640                    else if (cOhciCtrls && !ValueUnion.f)
    2576                         CHECK_ERROR(sessionMachine, RemoveUSBController(Bstr("OHCI").raw()));
     2641                    {
     2642                        SafeIfaceArray<IUSBController> ctrls;
     2643                        CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
     2644                        for (size_t i = 0; i < ctrls.size(); i++)
     2645                        {
     2646                            ComPtr<IUSBController> pCtrl = ctrls[i];
     2647                            USBControllerType_T enmType;
     2648                            CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
     2649                            if (enmType == USBControllerType_OHCI)
     2650                            {
     2651                                Bstr ctrlName;
     2652                                CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
     2653                                CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
     2654                            }
     2655                        }
     2656                    }
    25772657                }
    25782658                break;

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

    r56158 r56843  
    55
    66/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     7 * Copyright (C) 2006-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    400400                if (!usbData.m_fUSBEnabled)
    401401                {
    402                     if (cXhciCtls)
    403                         m_machine.RemoveUSBController("XHCI");
    404                     if (cEhciCtls)
    405                         m_machine.RemoveUSBController("EHCI");
    406                     if (cOhciCtls)
    407                         m_machine.RemoveUSBController("OHCI");
     402                    if (cXhciCtls | cEhciCtls | cOhciCtls)
     403                    {
     404                        CUSBControllerVector ctlvec = m_machine.GetUSBControllers();
     405                        for (int i = 0; i < ctlvec.size(); ++i)
     406                        {
     407                            CUSBController ctl = ctlvec[i];
     408                            QString strName = ctl.GetName();
     409                            m_machine.RemoveUSBController(strName);
     410                        }
     411                    }
    408412                }
    409413                /* Creating/replacing USB controllers: */
    … …  
    414418                        case KUSBControllerType_OHCI:
    415419                        {
    416                             if (cEhciCtls)
    417                                 m_machine.RemoveUSBController("EHCI");
    418                             if (cXhciCtls)
    419                                 m_machine.RemoveUSBController("XHCI");
     420                            if (cXhciCtls || cEhciCtls)
     421                            {
     422                                CUSBControllerVector ctlvec = m_machine.GetUSBControllers();
     423                                for (int i = 0; i < ctlvec.size(); ++i)
     424                                {
     425                                    CUSBController ctl = ctlvec[i];
     426                                    KUSBControllerType enmType = ctl.GetType();
     427                                    if (enmType == KUSBControllerType_XHCI || enmType == KUSBControllerType_EHCI)
     428                                    {
     429                                        QString strName = ctl.GetName();
     430                                        m_machine.RemoveUSBController(strName);
     431                                    }
     432                                }
     433                            }
    420434                            if (!cOhciCtls)
    421435                                m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    … …  
    425439                        {
    426440                            if (cXhciCtls)
    427                                 m_machine.RemoveUSBController("XHCI");
     441                            {
     442                                CUSBControllerVector ctlvec = m_machine.GetUSBControllers();
     443                                for (int i = 0; i < ctlvec.size(); ++i)
     444                                {
     445                                    CUSBController ctl = ctlvec[i];
     446                                    KUSBControllerType enmType = ctl.GetType();
     447                                    if (enmType == KUSBControllerType_XHCI)
     448                                    {
     449                                        QString strName = ctl.GetName();
     450                                        m_machine.RemoveUSBController(strName);
     451                                    }
     452                                }
     453                            }
    428454                            if (!cOhciCtls)
    429455                                m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    … …  
    434460                        case KUSBControllerType_XHCI:
    435461                        {
    436                             if (cEhciCtls)
    437                                 m_machine.RemoveUSBController("EHCI");
    438                             if (cOhciCtls)
    439                                 m_machine.RemoveUSBController("OHCI");
     462                            if (cEhciCtls || cOhciCtls)
     463                            {
     464                                CUSBControllerVector ctlvec = m_machine.GetUSBControllers();
     465                                for (int i = 0; i < ctlvec.size(); ++i)
     466                                {
     467                                    CUSBController ctl = ctlvec[i];
     468                                    KUSBControllerType enmType = ctl.GetType();
     469                                    if (enmType == KUSBControllerType_EHCI || enmType == KUSBControllerType_OHCI)
     470                                    {
     471                                        QString strName = ctl.GetName();
     472                                        m_machine.RemoveUSBController(strName);
     473                                    }
     474                                }
     475                            }
    440476                            if (!cXhciCtls)
    441                                 m_machine.AddUSBController("XHCI", KUSBControllerType_XHCI);
     477                                m_machine.AddUSBController("xHCI", KUSBControllerType_XHCI);
    442478                            break;
    443479                        }
Note: See TracChangeset for help on using the changeset viewer.

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