VirtualBox

Changeset 29480 in vbox


Ignore:
Timestamp:
May 14, 2010 3:24:19 PM (15 years ago)
Author:
vboxsync
Message:

Main: Remove IoBackendType in StorageController and have a boolean setting fUseAsyncHostIOMgr instead; change XML settings and frontends accordingly; change VBoxManage storagectl syntax to --hostiocache on|off as well

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r29463 r29480  
    764764          ulPortCount(2),
    765765          ulInstance(0),
    766           ioBackendType(IoBackendType_Buffered),
     766          fUseHostIOCache(true),
    767767          lIDE0MasterEmulationPort(0),
    768768          lIDE0SlaveEmulationPort(0),
    … …  
    778778    uint32_t                ulPortCount;
    779779    uint32_t                ulInstance;
    780     IoBackendType_T         ioBackendType;
     780    bool                    fUseHostIOCache;
    781781
    782782    // only for when controllerType == StorageControllerType_IntelAhci:

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

    r29465 r29480  
    447447                 "                            [--sataideemulation<1-4> <1-30>]\n"
    448448                 "                            [--sataportcount <1-30>]\n"
    449                  "                            [--iobackend Buffered|Unbuffered]\n"
     449                 "                            [--hostiocache on|off]\n"
    450450                 "                            [--remove]\n"
    451451                 "\n");

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

    r28800 r29480  
    653653    { "--sataportcount",    'p', RTGETOPT_REQ_UINT32 },
    654654    { "--remove",           'r', RTGETOPT_REQ_NOTHING },
    655     { "--iobackend",        'i', RTGETOPT_REQ_STRING },
     655    { "--hostiocache",      'i', RTGETOPT_REQ_STRING },
    656656};
    657657
    … …  
    663663    const char       *pszBusType     = NULL;
    664664    const char       *pszCtlType     = NULL;
    665     const char       *pszIoBackend  = NULL;
     665    const char       *pszHostIOCache = NULL;
    666666    ULONG             satabootdev    = ~0U;
    667667    ULONG             sataidedev     = ~0U;
    … …  
    732732            case 'i':
    733733            {
    734                 pszIoBackend = ValueUnion.psz;
     734                pszHostIOCache = ValueUnion.psz;
    735735                break;
    736736            }
    … …  
    921921        }
    922922
    923         if (   pszIoBackend
     923        if (   pszHostIOCache
    924924            && SUCCEEDED(rc))
    925925        {
    926                 ComPtr<IStorageController> ctl;
    927 
    928                 CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
    929 
    930                 if (!RTStrICmp(pszIoBackend, "buffered"))
    931                 {
    932                     CHECK_ERROR(ctl, COMSETTER(IoBackend)(IoBackendType_Buffered));
    933                 }
    934                 else if (!RTStrICmp(pszIoBackend, "unbuffered"))
    935                 {
    936                     CHECK_ERROR(ctl, COMSETTER(IoBackend)(IoBackendType_Unbuffered));
    937                 }
    938                 else
    939                 {
    940                     errorArgument("Invalid --type argument '%s'", pszIoBackend);
    941                     rc = E_FAIL;
    942                 }
     926            ComPtr<IStorageController> ctl;
     927
     928            CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
     929
     930            if (!RTStrICmp(pszHostIOCache, "on"))
     931            {
     932                CHECK_ERROR(ctl, COMSETTER(UseHostIOCache)(TRUE));
     933            }
     934            else if (!RTStrICmp(pszHostIOCache, "off"))
     935            {
     936                CHECK_ERROR(ctl, COMSETTER(UseHostIOCache)(FALSE));
     937            }
     938            else
     939            {
     940                errorArgument("Invalid --hostiocache argument '%s'", pszHostIOCache);
     941                rc = E_FAIL;
     942            }
    943943        }
    944944    }

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/vm/VBoxVMSettingsHD.cpp

    r29199 r29480  
    17961796        QUuid ctrId = QUuid (mStorageModel->data (ctrIndex, StorageModel::R_ItemId).toString());
    17971797
    1798         bool useIoCache = true;
    1799         if (controller.GetIoBackend() == KIoBackendType_Unbuffered)
    1800             useIoCache = false;
     1798        bool useIoCache = controller.GetUseHostIOCache();
    18011799
    18021800        mStorageModel->setData (ctrIndex, useIoCache, StorageModel::R_CtrIoCache);
    … …  
    18441842        CStorageController ctr = mMachine.AddStorageController (ctrName, ctrBusType);
    18451843        ctr.SetControllerType (ctrType);
    1846         ctr.SetIoBackend(useIoCache ? KIoBackendType_Buffered : KIoBackendType_Unbuffered);
     1844        ctr.SetUseHostIOCache(useIoCache);
    18471845        int maxUsedPort = -1;
    18481846        for (int j = 0; j < mStorageModel->rowCount (ctrIndex); ++ j)

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

    r29363 r29480  
    32153215    rc = ctrl->COMGETTER(Instance)(&uInstance);
    32163216    AssertComRC(rc);
    3217     IoBackendType_T enmIoBackend;
    3218     rc = ctrl->COMGETTER(IoBackend)(&enmIoBackend);
     3217    BOOL fUseHostIOCache;
     3218    rc = ctrl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
    32193219    AssertComRC(rc);
    32203220
    … …  
    32293229     */
    32303230    PVMREQ pReq;
    3231     int vrc = VMR3ReqCall(mpVM, VMCPUID_ANY, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    3232                           (PFNRT)Console::changeRemovableMedium, 7,
    3233                           this, pszDevice, uInstance, enmBus, enmIoBackend,
    3234                           aMediumAttachment, fForce);
     3231    int vrc = VMR3ReqCall(mpVM,
     3232                          VMCPUID_ANY,
     3233                          &pReq,
     3234                          0 /* no wait! */,
     3235                          VMREQFLAGS_VBOX_STATUS,
     3236                          (PFNRT)Console::changeRemovableMedium,
     3237                          7,
     3238                          this,
     3239                          pszDevice,
     3240                          uInstance,
     3241                          enmBus,
     3242                          fUseHostIOCache,
     3243                          aMediumAttachment,
     3244                          fForce);
    32353245
    32363246    /* leave the lock before waiting for a result (EMT will call us back!) */
    … …  
    32853295                                                 unsigned uInstance,
    32863296                                                 StorageBus_T enmBus,
    3287                                                  IoBackendType_T enmIoBackend,
     3297                                                 bool fUseHostIOCache,
    32883298                                                 IMediumAttachment *aMediumAtt,
    32893299                                                 bool fForce)
    … …  
    33483358                                             uInstance,
    33493359                                             enmBus,
    3350                                              enmIoBackend,
     3360                                             fUseHostIOCache,
    33513361                                             false /* fSetupMerge */,
    33523362                                             0 /* uMergeSource */,
    … …  
    44614471    rc = ctrl->COMGETTER(Instance)(&uInstance);
    44624472    AssertComRC(rc);
    4463     IoBackendType_T enmIoBackend;
    4464     rc = ctrl->COMGETTER(IoBackend)(&enmIoBackend);
     4473    BOOL fUseHostIOCache;
     4474    rc = ctrl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
    44654475    AssertComRC(rc);
    44664476
    … …  
    44924502                          uInstance,
    44934503                          enmBus,
    4494                           enmIoBackend,
     4504                          fUseHostIOCache,
    44954505                          true /* fSetupMerge */,
    44964506                          aSourceIdx,
    … …  
    45674577                          uInstance,
    45684578                          enmBus,
    4569                           enmIoBackend,
     4579                          fUseHostIOCache,
    45704580                          false /* fSetupMerge */,
    45714581                          0 /* uMergeSource */,
    … …  
    75657575                                                       unsigned uInstance,
    75667576                                                       StorageBus_T enmBus,
    7567                                                        IoBackendType_T enmIoBackend,
     7577                                                       bool fUseHostIOCache,
    75687578                                                       bool fSetupMerge,
    75697579                                                       unsigned uMergeSource,
    … …  
    75997609                                          uInstance,
    76007610                                          enmBus,
    7601                                           enmIoBackend,
     7611                                          fUseHostIOCache,
    76027612                                          fSetupMerge,
    76037613                                          uMergeSource,
    … …  
    77457755                StorageControllerType_T enmController;
    77467756                StorageBus_T enmBus;
    7747                 IoBackendType_T enmIoBackend;
     7757                BOOL fUseHostIOCache;
    77487758
    77497759                /*
    … …  
    77697779                if (FAILED(rc))
    77707780                    throw rc;
    7771                 rc = controller->COMGETTER(IoBackend)(&enmIoBackend);
     7781                rc = controller->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
    77727782                if (FAILED(rc))
    77737783                    throw rc;
    … …  
    77887798                                      lInstance,
    77897799                                      enmBus,
    7790                                       enmIoBackend,
     7800                                      fUseHostIOCache,
    77917801                                      false /* fSetupMerge */,
    77927802                                      0 /* uMergeSource */,

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

    r29444 r29480  
    10321032        rc = ctrls[i]->COMGETTER(Instance)(&ulInstance);                                H();
    10331033
    1034         IoBackendType_T enmIoBackend;
    1035         rc = ctrls[i]->COMGETTER(IoBackend)(&enmIoBackend);                             H();
     1034        BOOL fUseHostIOCache;
     1035        rc = ctrls[i]->COMGETTER(UseHostIOCache)(&fUseHostIOCache);                     H();
    10361036
    10371037        /* /Devices/<ctrldev>/ */
    … …  
    12261226                                                  ulInstance,
    12271227                                                  enmBus,
    1228                                                   enmIoBackend,
     1228                                                  fUseHostIOCache,
    12291229                                                  false /* fSetupMerge */,
    12301230                                                  0 /* uMergeSource */,
    … …  
    22362236                                    unsigned uInstance,
    22372237                                    StorageBus_T enmBus,
    2238                                     IoBackendType_T enmIoBackend,
     2238                                    bool fUseHostIOCache,
    22392239                                    bool fSetupMerge,
    22402240                                    unsigned uMergeSource,
    … …  
    23252325                      !!fPassthrough,
    23262326                      lType,
    2327                       enmIoBackend,
     2327                      fUseHostIOCache,
    23282328                      fSetupMerge,
    23292329                      uMergeSource,
    … …  
    23562356                          bool fPassthrough,
    23572357                          DeviceType_T enmType,
    2358                           IoBackendType_T enmIoBackend,
     2358                          bool fUseHostIOCache,
    23592359                          bool fSetupMerge,
    23602360                          unsigned uMergeSource,
    … …  
    25042504            }
    25052505
    2506             if (enmIoBackend == IoBackendType_Unbuffered)
     2506            if (!fUseHostIOCache)
    25072507            {
    25082508                rc = CFGMR3InsertInteger(pCfg, "UseNewIo", 1);                          RC_CHECK();

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

    r29470 r29480  
    69566956        if (FAILED(rc)) return rc;
    69576957
    6958         rc = pCtl->COMSETTER(IoBackend)(ctlData.ioBackendType);
     6958        rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
    69596959        if (FAILED(rc)) return rc;
    69606960
    … …  
    80338033        ctl.ulPortCount = portCount;
    80348034
    8035         /* Save I/O backend */
    8036         IoBackendType_T ioBackendType;
    8037         rc = pCtl->COMGETTER(IoBackend)(&ioBackendType);
     8035        /* Save fUseHostIOCache */
     8036        BOOL fUseHostIOCache;
     8037        rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
    80388038        ComAssertComRCRet(rc, rc);
    8039         ctl.ioBackendType = ioBackendType;
     8039        ctl.fUseHostIOCache = !!fUseHostIOCache;
    80408040
    80418041        /* Save IDE emulation settings. */

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

    r29002 r29480  
    4545          mInstance(0),
    4646          mPortCount(2),
    47           mIoBackendType(IoBackendType_Buffered),
     47          fUseHostIOCache(true),
    4848          mPortIde0Master(0),
    4949          mPortIde0Slave(1),
    … …  
    6262    /** Number of usable ports. */
    6363    ULONG mPortCount;
    64     /** I/O backend type */
    65     IoBackendType_T         mIoBackendType;
     64    /** Whether to use the host IO caches. */
     65    BOOL fUseHostIOCache;
    6666
    6767    /** The following is only for the SATA controller atm. */
    … …  
    145145    m->bd->mStorageBus = aStorageBus;
    146146    if (aStorageBus != StorageBus_IDE)
    147         m->bd->mIoBackendType = IoBackendType_Unbuffered;
     147        m->bd->fUseHostIOCache = false;
    148148    else
    149         m->bd->mIoBackendType = IoBackendType_Buffered;
     149        m->bd->fUseHostIOCache = true;
    150150
    151151    switch (aStorageBus)
    … …  
    608608}
    609609
    610 STDMETHODIMP StorageController::COMGETTER(IoBackend) (IoBackendType_T *aIoBackend)
     610STDMETHODIMP StorageController::COMGETTER(UseHostIOCache) (BOOL *fUseHostIOCache)
    611611{
    612612    AutoCaller autoCaller(this);
    … …  
    617617    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    618618
    619     *aIoBackend = m->bd->mIoBackendType;
    620 
    621     return S_OK;
    622 }
    623 
    624 STDMETHODIMP StorageController::COMSETTER(IoBackend) (IoBackendType_T aIoBackend)
     619    *fUseHostIOCache = m->bd->fUseHostIOCache;
     620
     621    return S_OK;
     622}
     623
     624STDMETHODIMP StorageController::COMSETTER(UseHostIOCache) (BOOL fUseHostIOCache)
    625625{
    626626    AutoCaller autoCaller(this);
    … …  
    633633    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    634634
    635     if (m->bd->mIoBackendType != aIoBackend)
     635    if (m->bd->fUseHostIOCache != !!fUseHostIOCache)
    636636    {
    637637        m->bd.backup();
    638         m->bd->mIoBackendType = aIoBackend;
     638        m->bd->fUseHostIOCache = !!fUseHostIOCache;
    639639
    640640        alock.release();

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

    r29460 r29480  
    10951095  </enum>
    10961096
    1097   <enum
     1097<!--  <enum
    10981098       name="IoBackendType"
    10991099       uuid="2a7e16d1-4e6b-4d5d-b0c9-b9bbe6c5b2ad"
    … …  
    11181118    </const>
    11191119  </enum>
    1120 
     1120-->
    11211121
    11221122  <!--
    … …  
    1375513755  <interface
    1375613756    name="IStorageController" extends="$unknown"
    13757     uuid="7635f4ec-8a28-44b5-9223-315a87b710fb"
     13757    uuid="fd93adc0-bbaa-4256-9e6e-00e29f9151c9"
    1375813758    wsmap="managed"
    1375913759  >
    … …  
    1383813838    </attribute>
    1383913839
    13840     <attribute name="ioBackend" type="IoBackendType">
    13841       <desc>
    13842         The I/O backend to use for the given storage controller.
     13840    <attribute name="useHostIOCache" type="boolean">
     13841      <desc>
     13842        If true, the storage controller emulation will use a dedicated I/O thread, enable the host I/O
     13843        caches and use synchronous file APIs on the host. This was the only option in the API before
     13844        VirtualBox 3.2 and is still the default for IDE controllers.
     13845
     13846        If false, the host I/O cache will be disabled for image files attached to this storage controller.
     13847        Instead, the storage controller emulation will use asynchronous I/O APIs on the host. This makes
     13848        it possible to turn off the host I/O caches because the emulation can handle unaligned access to
     13849        the file. This should be used on OS X and Linux hosts if a high I/O load is expected or many
     13850        virtual machines are running at the same time to prevent I/O cache related hangs.
     13851        This option new with the API of VirtualBox 3.2 and is now the default for non-IDE storage controllers.
    1384313852      </desc>
    1384413853    </attribute>

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

    r29385 r29480  
    442442                               unsigned uInstance,
    443443                               StorageBus_T enmBus,
    444                                IoBackendType_T enmIoBackend,
     444                               bool fUseHostIOCache,
    445445                               bool fSetupMerge,
    446446                               unsigned uMergeSource,
    … …  
    456456                     bool fPassthrough,
    457457                     DeviceType_T enmType,
    458                      IoBackendType_T enmIoBackend,
     458                     bool fUseHostIOCache,
    459459                     bool fSetupMerge,
    460460                     unsigned uMergeSource,
    … …  
    468468                                                         unsigned uInstance,
    469469                                                         StorageBus_T enmBus,
    470                                                          IoBackendType_T enmIoBackend,
     470                                                         bool fUseHostIOCache,
    471471                                                         bool fSetupMerge,
    472472                                                         unsigned uMergeSource,
    … …  
    479479                                                   unsigned uInstance,
    480480                                                   StorageBus_T enmBus,
    481                                                    IoBackendType_T enmIoBackend,
     481                                                   bool fUseHostIOCache,
    482482                                                   IMediumAttachment *aMediumAtt,
    483483                                                   bool fForce);

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

    r28800 r29480  
    7373    STDMETHOD(COMGETTER(Instance)) (ULONG *aInstance);
    7474    STDMETHOD(COMSETTER(Instance)) (ULONG aInstance);
    75     STDMETHOD(COMGETTER(IoBackend)) (IoBackendType_T *aIoBackend);
    76     STDMETHOD(COMSETTER(IoBackend)) (IoBackendType_T aIoBackend);
     75    STDMETHOD(COMGETTER(UseHostIOCache)) (BOOL *fUseHostIOCache);
     76    STDMETHOD(COMSETTER(UseHostIOCache)) (BOOL fUseHostIOCache);
    7777
    7878    // StorageController methods

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

    r29462 r29480  
    15861586                  && (ulPortCount               == s.ulPortCount)
    15871587                  && (ulInstance                == s.ulInstance)
    1588                   && (ioBackendType             == s.ioBackendType)
     1588                  && (fUseHostIOCache           == s.fUseHostIOCache)
    15891589                  && (lIDE0MasterEmulationPort  == s.lIDE0MasterEmulationPort)
    15901590                  && (lIDE0SlaveEmulationPort   == s.lIDE0SlaveEmulationPort)
    … …  
    20772077    elmStorageController.getAttributeValue("IDE1SlaveEmulationPort", sctl.lIDE1SlaveEmulationPort);
    20782078
    2079     Utf8Str strIoBackend;
    2080     if (elmStorageController.getAttributeValue("IoBackend", strIoBackend))
    2081     {
    2082         if (strIoBackend == "Buffered")
    2083             sctl.ioBackendType = IoBackendType_Buffered;
    2084         else if (strIoBackend == "Unbuffered")
    2085             sctl.ioBackendType = IoBackendType_Unbuffered;
    2086         else
    2087             throw ConfigFileError(this,
    2088                                   &elmStorageController,
    2089                                   N_("Invalid value '%s' in StorageController/@IoBackend"),
    2090                                   strIoBackend.c_str());
    2091     }
     2079    elmStorageController.getAttributeValue("useHostIOCache", sctl.fUseHostIOCache);
    20922080}
    20932081
    … …  
    37213709                pelmController->setAttribute("Instance", sc.ulInstance);
    37223710
    3723         if (m->sv >= SettingsVersion_v1_9)
    3724         {
    3725             const char *pcszIoBackend;
    3726             switch (sc.ioBackendType)
    3727             {
    3728                 case IoBackendType_Unbuffered: pcszIoBackend = "Unbuffered"; break;
    3729                 default: /*case IoBackendType_Buffered:*/ pcszIoBackend = "Buffered"; break;
    3730             }
    3731 
    3732             pelmController->setAttribute("IoBackend", pcszIoBackend);
    3733         }
     3711        if (m->sv >= SettingsVersion_v1_10)
     3712            pelmController->setAttribute("useHostIOCache", sc.fUseHostIOCache);
    37343713
    37353714        if (sc.controllerType == StorageControllerType_IntelAhci)
    … …  
    39963975                    ++cFloppies;
    39973976
    3998                 // The I/O backend setting is only supported with v.10
    3999                 if (sctl.ioBackendType != IoBackendType_Buffered)
     3977                // Disabling the host IO cache requires settings version 1.10
     3978                if (!sctl.fUseHostIOCache)
    40003979                {
    40013980                    m->sv = SettingsVersion_v1_10;
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