VirtualBox

Changeset 28764 in vbox


Ignore:
Timestamp:
Apr 26, 2010 4:12:49 PM (15 years ago)
Author:
vboxsync
Message:

Main: Introduce a per controller setting to switch to the unbuffered async I/O interface (UseNewIo). Configurable through VBoxManage, default is still buffered

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r28581 r28764  
    758758          ulPortCount(2),
    759759          ulInstance(0),
     760          ioBackendType(IoBackendType_Buffered),
    760761          lIDE0MasterEmulationPort(0),
    761762          lIDE0SlaveEmulationPort(0),
    … …  
    767768
    768769    com::Utf8Str            strName;
    769     StorageBus_T            storageBus;             // _SATA, _SCSI, _IDE
     770    StorageBus_T            storageBus;             // _SATA, _SCSI, _IDE, _SAS
    770771    StorageControllerType_T controllerType;
    771772    uint32_t                ulPortCount;
    772773    uint32_t                ulInstance;
     774    IoBackendType_T         ioBackendType;
    773775
    774776    // only for when controllerType == StorageControllerType_IntelAhci:

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

    r28734 r28764  
    442442                 "                            [--sataideemulation<1-4> <1-30>]\n"
    443443                 "                            [--sataportcount <1-30>]\n"
     444                 "                            [--iobackend Buffered|Unbuffered]\n"
    444445                 "                            [--remove]\n"
    445446                 "\n");

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

    r26517 r28764  
    657657    { "--sataportcount",    'p', RTGETOPT_REQ_UINT32 },
    658658    { "--remove",           'r', RTGETOPT_REQ_NOTHING },
     659    { "--iobackend",        'i', RTGETOPT_REQ_STRING },
    659660};
    660661
    … …  
    666667    const char       *pszBusType     = NULL;
    667668    const char       *pszCtlType     = NULL;
     669    const char       *pszIoBackend   = NULL;
    668670    ULONG             satabootdev    = ~0U;
    669671    ULONG             sataidedev     = ~0U;
    … …  
    732734            }
    733735
     736            case 'i':
     737            {
     738                pszIoBackend = ValueUnion.psz;
     739                break;
     740            }
     741
    734742            default:
    735743            {
    … …  
    916924            }
    917925        }
     926
     927        if (   pszIoBackend
     928            && SUCCEEDED(rc))
     929        {
     930                ComPtr<IStorageController> ctl;
     931
     932                CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
     933
     934                if (!RTStrICmp(pszIoBackend, "buffered"))
     935                {
     936                    CHECK_ERROR(ctl, COMSETTER(IoBackend)(IoBackendType_Buffered));
     937                }
     938                else if (!RTStrICmp(pszIoBackend, "unbuffered"))
     939                {
     940                    CHECK_ERROR(ctl, COMSETTER(IoBackend)(IoBackendType_Unbuffered));
     941                }
     942                else
     943                {
     944                    errorArgument("Invalid --type argument '%s'", pszIoBackend);
     945                    rc = E_FAIL;
     946                }
     947        }
    918948    }
    919949

  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r28727 r28764  
    30903090    rc = ctrl->COMGETTER(Instance)(&uInstance);
    30913091    AssertComRC(rc);
     3092    IoBackendType_T enmIoBackend;
     3093    rc = ctrl->COMGETTER(Bus)(&enmIoBackend);
     3094    AssertComRC(rc);
    30923095
    30933096    /* protect mpVM */
    … …  
    31023105    PVMREQ pReq;
    31033106    int vrc = VMR3ReqCall(mpVM, VMCPUID_ANY, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    3104                           (PFNRT)Console::changeRemovableMedium, 6,
    3105                           this, pszDevice, uInstance, enmBus, aMediumAttachment, fForce);
     3107                          (PFNRT)Console::changeRemovableMedium, 7,
     3108                          this, pszDevice, uInstance, enmBus, enmIoBackend,
     3109                          aMediumAttachment, fForce);
    31063110
    31073111    /* leave the lock before waiting for a result (EMT will call us back!) */
    … …  
    31563160                                                 unsigned uInstance,
    31573161                                                 StorageBus_T enmBus,
     3162                                                 IoBackendType_T enmIoBackend,
    31583163                                                 IMediumAttachment *aMediumAtt,
    31593164                                                 bool fForce)
    … …  
    32153220
    32163221    rcRet = Console::configMediumAttachment(pCtlInst, pcszDevice, uInstance,
    3217                                             enmBus, aMediumAtt,
     3222                                            enmBus, enmIoBackend, aMediumAtt,
    32183223                                            pThis->mMachineState,
    32193224                                            NULL /* phrc */,
    … …  
    72187223                                                       unsigned uInstance,
    72197224                                                       StorageBus_T enmBus,
     7225                                                       IoBackendType_T enmIoBackend,
    72207226                                                       IMediumAttachment *aMediumAtt,
    72217227                                                       MachineState_T aMachineState,
    … …  
    72457251    /* Update the device instance configuration. */
    72467252    rc = Console::configMediumAttachment(pCtlInst, pcszDevice, uInstance,
    7247                                          enmBus, aMediumAtt, aMachineState,
     7253                                         enmBus, enmIoBackend,
     7254                                         aMediumAtt, aMachineState,
    72487255                                         phrc, true /* fAttachDetach */,
    72497256                                         false /* fForceUnmount */, pVM,
    … …  
    73927399                StorageControllerType_T enmController;
    73937400                StorageBus_T enmBus;
     7401                IoBackendType_T enmIoBackend;
    73947402
    73957403                /*
    … …  
    74157423                if (FAILED(rc))
    74167424                    throw rc;
     7425                rc = controller->COMGETTER(IoBackend)(&enmIoBackend);
     7426                if (FAILED(rc))
     7427                    throw rc;
     7428
    74177429                const char *pcszDevice = Console::convertControllerTypeToDev(enmController);
    74187430
    … …  
    74247436                                      VMCPUID_ANY,
    74257437                                      (PFNRT)reconfigureMediumAttachment,
    7426                                       7,
     7438                                      8,
    74277439                                      that->mpVM,
    74287440                                      pcszDevice,
    74297441                                      lInstance,
    74307442                                      enmBus,
     7443                                      enmIoBackend,
    74317444                                      atts[i],
    74327445                                      that->mMachineState,

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

    r28727 r28764  
    10731073        rc = ctrls[i]->COMGETTER(Instance)(&ulInstance);                                        H();
    10741074
     1075        IoBackendType_T enmIoBackend;
     1076        rc = ctrls[i]->COMGETTER(IoBackend)(&enmIoBackend);                                     H();
     1077
    10751078        /* /Devices/<ctrldev>/ */
    10761079        const char *pszCtrlDev = pConsole->convertControllerTypeToDev(enmCtrlType);
    … …  
    12611264        {
    12621265            rc = Console::configMediumAttachment(pCtlInst, pszCtrlDev,
    1263                                                  ulInstance, enmBus, atts[j],
     1266                                                 ulInstance, enmBus, enmIoBackend,
     1267                                                 atts[j],
    12641268                                                 pConsole->mMachineState,
    12651269                                                 NULL /* phrc */,
    … …  
    22702274int Console::configMediumAttachment(PCFGMNODE pCtlInst, const char *pcszDevice,
    22712275                                    unsigned uInstance, StorageBus_T enmBus,
     2276                                    IoBackendType_T enmIoBackend,
    22722277                                    IMediumAttachment *pMediumAtt,
    22732278                                    MachineState_T aMachineState,
    … …  
    23522357    hrc = pMediumAtt->COMGETTER(Passthrough)(&fPassthrough);            H();
    23532358    rc = Console::configMedium(pLunL0, !!fPassthrough, lType,
     2359                               enmIoBackend,
    23542360                               pMedium, aMachineState, phrc);           RC_CHECK();
    23552361
    … …  
    23782384                          bool fPassthrough,
    23792385                          DeviceType_T enmType,
     2386                          IoBackendType_T enmIoBackend,
    23802387                          IMedium *pMedium,
    23812388                          MachineState_T aMachineState,
    … …  
    24752482            {
    24762483                rc = CFGMR3InsertInteger(pCfg, "TempReadOnly", 1);                      RC_CHECK();
     2484            }
     2485
     2486            if (enmIoBackend == IoBackendType_Unbuffered)
     2487            {
     2488                rc = CFGMR3InsertInteger(pCfg, "UseNewIo", 1);                          RC_CHECK();
    24772489            }
    24782490

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

    r28744 r28764  
    212212
    213213    mIoMgrType     = IoMgrType_Async;
    214 #if defined(RT_OS_LINUX)
    215214    mIoBackendType = IoBackendType_Unbuffered;
    216 #else
    217     mIoBackendType = IoBackendType_Buffered;
    218 #endif
    219215    mIoCacheEnabled = true;
    220216    mIoCacheSize    = 5; /* 5MB */
    … …  
    69696965        if (FAILED(rc)) return rc;
    69706966
     6967        rc = pCtl->COMSETTER(IoBackend)(ctlData.ioBackendType);
     6968        if (FAILED(rc)) return rc;
     6969
    69716970        /* Set IDE emulation settings (only for AHCI controller). */
    69726971        if (ctlData.controllerType == StorageControllerType_IntelAhci)
    … …  
    80278026        ComAssertComRCRet(rc, rc);
    80288027        ctl.ulPortCount = portCount;
     8028
     8029        /* Save I/O backend */
     8030        IoBackendType_T ioBackendType;
     8031        rc = pCtl->COMGETTER(IoBackend)(&ioBackendType);
     8032        ComAssertComRCRet(rc, rc);
     8033        ctl.ioBackendType = ioBackendType;
    80298034
    80308035        /* Save IDE emulation settings. */

  • trunk/src/VBox/Main/StorageControllerImpl.cpp

    r27607 r28764  
    4949          mInstance(0),
    5050          mPortCount(2),
     51          mIoBackendType(IoBackendType_Buffered),
    5152          mPortIde0Master(0),
    5253          mPortIde0Slave(1),
    … …  
    6566    /** Number of usable ports. */
    6667    ULONG mPortCount;
     68    /** I/O backend type */
     69    IoBackendType_T         mIoBackendType;
    6770
    6871    /** The following is only for the SATA controller atm. */
    … …  
    145148    m->bd->mInstance = aInstance;
    146149    m->bd->mStorageBus = aStorageBus;
     150    m->bd->mIoBackendType = IoBackendType_Buffered;
    147151
    148152    switch (aStorageBus)
    … …  
    605609}
    606610
     611STDMETHODIMP StorageController::COMGETTER(IoBackend) (IoBackendType_T *aIoBackend)
     612{
     613    AutoCaller autoCaller(this);
     614    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     615
     616    /* The machine doesn't need to be mutable. */
     617
     618    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     619
     620    *aIoBackend = m->bd->mIoBackendType;
     621
     622    return S_OK;
     623}
     624
     625STDMETHODIMP StorageController::COMSETTER(IoBackend) (IoBackendType_T aIoBackend)
     626{
     627    AutoCaller autoCaller(this);
     628    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     629
     630    /* the machine needs to be mutable */
     631    AutoMutableStateDependency adep(m->pParent);
     632    if (FAILED(adep.rc())) return adep.rc();
     633
     634    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     635
     636    if (m->bd->mIoBackendType != aIoBackend)
     637    {
     638        m->bd.backup();
     639        m->bd->mIoBackendType = aIoBackend;
     640
     641        alock.release();
     642        AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS);        // m->pParent is const, needs no locking
     643        m->pParent->setModified(Machine::IsModified_Storage);
     644        mlock.release();
     645
     646        m->pParent->onStorageControllerChange();
     647    }
     648
     649    return S_OK;
     650}
     651
    607652// IStorageController methods
    608653/////////////////////////////////////////////////////////////////////////////

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

    r28748 r28764  
    1348813488  <interface
    1348913489    name="IStorageController" extends="$unknown"
    13490     uuid="ce37b7a9-d895-4ee8-b9f8-9579bfc85813"
     13490    uuid="7635f4ec-8a28-44b5-9223-315a87b710fb"
    1349113491    wsmap="managed"
    1349213492  >
    … …  
    1356813568
    1356913569        For SCSI controllers, the default type is LsiLogic.
     13570      </desc>
     13571    </attribute>
     13572
     13573    <attribute name="ioBackend" type="IoBackendType">
     13574      <desc>
     13575        The I/O backend to use for the given storage controller.
    1357013576      </desc>
    1357113577    </attribute>

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

    r28727 r28764  
    439439                                      unsigned uInstance,
    440440                                      StorageBus_T enmBus,
     441                                      IoBackendType_T enmIoBackend,
    441442                                      IMediumAttachment *pMediumAtt,
    442443                                      MachineState_T aMachineState,
    … …  
    445446                                      DeviceType_T *paLedDevType);
    446447    static int configMedium(PCFGMNODE pLunL0, bool fPassthrough,
    447                             DeviceType_T enmType, IMedium *pMedium,
    448                             MachineState_T aMachineState, HRESULT *phrc);
     448                            DeviceType_T enmType, IoBackendType_T enmIoBackend,
     449                            IMedium *pMedium, MachineState_T aMachineState, HRESULT *phrc);
    449450    static DECLCALLBACK(int) reconfigureMediumAttachment(PVM pVM,
    450451                                                         const char *pcszDevice,
    451452                                                         unsigned uInstance,
    452453                                                         StorageBus_T enmBus,
     454                                                         IoBackendType_T enmIoBackend,
    453455                                                         IMediumAttachment *aMediumAtt,
    454456                                                         MachineState_T aMachineState,
    … …  
    458460                                                   unsigned uInstance,
    459461                                                   StorageBus_T enmBus,
     462                                                   IoBackendType_T enmIoBackend,
    460463                                                   IMediumAttachment *aMediumAtt,
    461464                                                   bool fForce);
    … …  
    610613        iLedScsi    = iLedSata + cLedSata,
    611614        cLedScsi    = 16,
    612         cLedStorage = cLedFloppy + cLedIde + cLedSata + cLedScsi,
     615        iLedSas     = iLedScsi + cLedScsi,
     616        cLedSas     = 8,
     617        cLedStorage = cLedFloppy + cLedIde + cLedSata + cLedScsi + cLedSas,
    613618    };
    614619    DeviceType_T maStorageDevType[cLedStorage];

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

    r27607 r28764  
    7777    STDMETHOD(COMGETTER(Instance)) (ULONG *aInstance);
    7878    STDMETHOD(COMSETTER(Instance)) (ULONG aInstance);
     79    STDMETHOD(COMGETTER(IoBackend)) (IoBackendType_T *aIoBackend);
     80    STDMETHOD(COMSETTER(IoBackend)) (IoBackendType_T aIoBackend);
    7981
    8082    // StorageController methods

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

    r28689 r28764  
    15761576                  && (ulPortCount               == s.ulPortCount)
    15771577                  && (ulInstance                == s.ulInstance)
     1578                  && (ioBackendType             == s.ioBackendType)
    15781579                  && (lIDE0MasterEmulationPort  == s.lIDE0MasterEmulationPort)
    15791580                  && (lIDE0SlaveEmulationPort   == s.lIDE0SlaveEmulationPort)
    … …  
    16231624{
    16241625    ioMgrType        = IoMgrType_Async;
    1625 #if defined(RT_OS_LINUX)
    16261626    ioBackendType    = IoBackendType_Unbuffered;
    1627 #else
    1628     ioBackendType    = IoBackendType_Buffered;
    1629 #endif
    16301627    fIoCacheEnabled  = true;
    16311628    ulIoCacheSize    = 5;
    … …  
    20642061    elmStorageController.getAttributeValue("IDE1MasterEmulationPort", sctl.lIDE1MasterEmulationPort);
    20652062    elmStorageController.getAttributeValue("IDE1SlaveEmulationPort", sctl.lIDE1SlaveEmulationPort);
     2063
     2064    Utf8Str strIoBackend;
     2065    if (elmStorageController.getAttributeValue("IoBackend", strIoBackend))
     2066    {
     2067        if (strIoBackend == "Buffered")
     2068            sctl.ioBackendType = IoBackendType_Buffered;
     2069        else if (strIoBackend == "Unbuffered")
     2070            sctl.ioBackendType = IoBackendType_Unbuffered;
     2071        else
     2072            throw ConfigFileError(this,
     2073                                  &elmStorageController,
     2074                                  N_("Invalid value '%s' in StorageController/@IoBackend"),
     2075                                  strIoBackend.c_str());
     2076    }
    20662077}
    20672078
    … …  
    37043715                pelmController->setAttribute("Instance", sc.ulInstance);
    37053716
     3717        if (m->sv >= SettingsVersion_v1_9)
     3718        {
     3719            const char *pcszIoBackend;
     3720            switch (sc.ioBackendType)
     3721            {
     3722                case IoBackendType_Unbuffered: pcszIoBackend = "Unbuffered"; break;
     3723                default: /*case IoBackendType_Buffered:*/ pcszIoBackend = "Buffered"; break;
     3724            }
     3725
     3726            pelmController->setAttribute("IoBackend", pcszIoBackend);
     3727        }
     3728
    37063729        if (sc.controllerType == StorageControllerType_IntelAhci)
    37073730        {
    … …  
    39503973                else if (att.deviceType == DeviceType_Floppy)
    39513974                    ++cFloppies;
     3975
     3976                // The I/O backend setting is only supported with v.10
     3977                if (sctl.ioBackendType != IoBackendType_Buffered)
     3978                {
     3979                    m->sv = SettingsVersion_v1_10;
     3980                    break;
     3981                }
    39523982            }
    39533983        }
    … …  
    40144044            || hardwareMachine.ioSettings.ulIoCacheSize != 5
    40154045            || hardwareMachine.ioSettings.ulIoBandwidthMax != 0
    4016             || hardwareMachine.ioSettings.ioMgrType != IoMgrType_Async)
     4046            || hardwareMachine.ioSettings.ioMgrType != IoMgrType_Async
     4047            || hardwareMachine.ioSettings.ioBackendType != IoBackendType_Unbuffered)
    40174048            m->sv = SettingsVersion_v1_10;
    4018 
    4019 #if defined(RT_OS_LINUX)
    4020         if (hardwareMachine.ioSettings.ioBackendType != IoBackendType_Unbuffered)
    4021             m->sv = SettingsVersion_v1_10;
    4022 #else
    4023         if (hardwareMachine.ioSettings.ioBackendType != IoBackendType_Buffered)
    4024             m->sv = SettingsVersion_v1_10;
    4025 #endif
    40264049    }
    40274050}
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