Changeset 37824 in vbox for trunk/src

Timestamp:

Jul 7, 2011 3:29:03 PM (13 years ago)

Author:

vboxsync

Message:

Main/Machine+MediumAttachment+Console: add method for marking a 'hard disk' as non-rotational, which optimizes performance in modern guest OSes
Frontends/VBoxManage+VirtualBox: support the new method
ChangeLog: add quite a few forgotten improvements and fixes

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageHelp.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageStorageController.cpp (modified) (9 diffs)
• Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.cpp (modified) (16 diffs)
• Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.h (modified) (7 diffs)
• Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.ui (modified) (1 diff)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/MachineImpl.h (modified) (1 diff)
• Main/include/MediumAttachmentImpl.h (modified) (4 diffs)
• Main/src-client/ConsoleImpl2.cpp (modified) (6 diffs)
• Main/src-server/MachineImpl.cpp (modified) (5 diffs)
• Main/src-server/MediumAttachmentImpl.cpp (modified) (7 diffs)
• Main/xml/Settings.cpp (modified) (3 diffs)

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

@@ -467 +467 @@
                      "                            [--passthrough on|off]\n"
                      "                            [--tempeject on|off]\n"
+                     "                            [--nonrotational on|off]\n"
                      "                            [--bandwidthgroup <name>]\n"
                      "                            [--forceunmount]\n"

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

@@ -53 +53 @@
     { "--passthrough",      'h', RTGETOPT_REQ_STRING },
     { "--tempeject",        'e', RTGETOPT_REQ_STRING },
+    { "--nonrotational",    'n', RTGETOPT_REQ_STRING },
     { "--bandwidthgroup",   'b', RTGETOPT_REQ_STRING },
     { "--forceunmount",     'f', RTGETOPT_REQ_NOTHING },
@@ -86 +87 @@
     const char *pszPassThrough = NULL;
     const char *pszTempEject = NULL;
+    const char *pszNonRotational = NULL;
     const char *pszBandwidthGroup = NULL;
     Bstr bstrNewUuid;
@@ -178 +180 @@
             }
 
+            case 'n':   // nonrotational <on|off>
+            {
+                if (ValueUnion.psz)
+                    pszNonRotational = ValueUnion.psz;
+                else
+                    rc = E_FAIL;
+                break;
+            }
+
             case 'b':   // bandwidthgroup <name>
             {
@@ -410 +421 @@
                 if (ctlType == StorageControllerType_I82078)        // floppy controller
                     devTypeRequested = DeviceType_Floppy;
-                else if (pszMedium)
+                else
                 {
                     /*
@@ -428 +439 @@
                         mediumAttachment->COMGETTER(Type)(&deviceType);
 
-                        ComPtr<IMedium> pExistingMedium;
-                        rc = findMedium(a, pszMedium, deviceType, true /* fSilent */,
-                                        pExistingMedium);
-                        if (SUCCEEDED(rc) && pExistingMedium)
+                        if (pszMedium)
                         {
-                            if (    (deviceType == DeviceType_DVD)
-                                 || (deviceType == DeviceType_HardDisk)
-                               )
-                                devTypeRequested = deviceType;
+                            ComPtr<IMedium> pExistingMedium;
+                            rc = findMedium(a, pszMedium, deviceType, true /* fSilent */,
+                                            pExistingMedium);
+                            if (SUCCEEDED(rc) && pExistingMedium)
+                            {
+                                if (    (deviceType == DeviceType_DVD)
+                                     || (deviceType == DeviceType_HardDisk)
+                                   )
+                                    devTypeRequested = deviceType;
+                            }
                         }
+                        else
+                            devTypeRequested = deviceType;
                     }
                 }
-                /* for all other cases lets ask the user what type of drive it is */
             }
 
@@ -573 +588 @@
             else
             {
-                Bstr bstrMedium(pszMedium);
-                if (bstrMedium.isEmpty())
-                    throw Utf8Str("Missing --medium argument");
-
-                rc = findOrOpenMedium(a, pszMedium, devTypeRequested,
-                                      pMedium2Mount, fSetNewUuid, NULL);
-                if (FAILED(rc) || !pMedium2Mount)
-                    throw Utf8StrFmt("Invalid UUID or filename \"%s\"", pszMedium);
+                if (!pszMedium)
+                {
+                    ComPtr<IMediumAttachment> mediumAttachment;
+                    rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
+                                                      device,
+                                                      mediumAttachment.asOutParam());
+                    if (FAILED(rc))
+                        throw Utf8Str("Missing --medium argument");
+                }
+                else
+                {
+                    Bstr bstrMedium(pszMedium);
+                    rc = findOrOpenMedium(a, pszMedium, devTypeRequested,
+                                          pMedium2Mount, fSetNewUuid, NULL);
+                    if (FAILED(rc) || !pMedium2Mount)
+                        throw Utf8StrFmt("Invalid UUID or filename \"%s\"", pszMedium);
+                }
             }
 
             // set medium/parent medium UUID, if so desired
-            if (fSetNewUuid || fSetNewParentUuid)
+            if (pMedium2Mount && (fSetNewUuid || fSetNewParentUuid))
             {
                 CHECK_ERROR(pMedium2Mount, SetIDs(fSetNewUuid, bstrNewUuid.raw(),
@@ -605 +629 @@
             }
 
-            switch (devTypeRequested)
-            {
-                case DeviceType_DVD:
-                case DeviceType_Floppy:
-                {
-                    if (!fRunTime)
+            if (pszMedium)
+            {
+                switch (devTypeRequested)
+                {
+                    case DeviceType_DVD:
+                    case DeviceType_Floppy:
                     {
-                        ComPtr<IMediumAttachment> mediumAttachment;
-                        // check if there is a dvd/floppy drive at the given location, if not attach one first
-                        rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(),
-                                                          port,
-                                                          device,
-                                                          mediumAttachment.asOutParam());
-                        if (SUCCEEDED(rc))
+                        if (!fRunTime)
                         {
-                            DeviceType_T deviceType;
-                            mediumAttachment->COMGETTER(Type)(&deviceType);
-                            if (deviceType != devTypeRequested)
+                            ComPtr<IMediumAttachment> mediumAttachment;
+                            // check if there is a dvd/floppy drive at the given location, if not attach one first
+                            rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(),
+                                                              port,
+                                                              device,
+                                                              mediumAttachment.asOutParam());
+                            if (SUCCEEDED(rc))
                             {
-                                machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
+                                DeviceType_T deviceType;
+                                mediumAttachment->COMGETTER(Type)(&deviceType);
+                                if (deviceType != devTypeRequested)
+                                {
+                                    machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
+                                    rc = machine->AttachDevice(Bstr(pszCtl).raw(),
+                                                               port,
+                                                               device,
+                                                               devTypeRequested,    // DeviceType_DVD or DeviceType_Floppy
+                                                               NULL);
+                                }
+                            }
+                            else
+                            {
                                 rc = machine->AttachDevice(Bstr(pszCtl).raw(),
                                                            port,
@@ -632 +667 @@
                             }
                         }
-                        else
+
+                        if (pMedium2Mount)
                         {
-                            rc = machine->AttachDevice(Bstr(pszCtl).raw(),
-                                                       port,
-                                                       device,
-                                                       devTypeRequested,    // DeviceType_DVD or DeviceType_Floppy
-                                                       NULL);
+                            CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(),
+                                                             port,
+                                                             device,
+                                                             pMedium2Mount,
+                                                             fForceUnmount));
                         }
+                    } // end DeviceType_DVD or DeviceType_Floppy:
+                    break;
+
+                    case DeviceType_HardDisk:
+                    {
+                        // if there is anything attached at the given location, remove it
+                        machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
+                        CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(),
+                                                          port,
+                                                          device,
+                                                          DeviceType_HardDisk,
+                                                          pMedium2Mount));
                     }
-
-                    if (pMedium2Mount)
-                    {
-                        CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(),
-                                                         port,
-                                                         device,
-                                                         pMedium2Mount,
-                                                         fForceUnmount));
-                    }
-                } // end DeviceType_DVD or DeviceType_Floppy:
-                break;
-
-                case DeviceType_HardDisk:
-                {
-                    // if there is anything attached at the given location, remove it
-                    machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
-                    CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(),
-                                                      port,
-                                                      device,
-                                                      DeviceType_HardDisk,
-                                                      pMedium2Mount));
-                }
-                break;
+                    break;
+                }
             }
         }
@@ -714 +741 @@
                 else
                     throw Utf8StrFmt("Invalid --tempeject argument '%s'", pszTempEject);
+            }
+            else
+                throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
+        }
+
+        if (   pszNonRotational
+            && (SUCCEEDED(rc)))
+        {
+            ComPtr<IMediumAttachment> mattach;
+            CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
+                                                     device, mattach.asOutParam()));
+
+            if (SUCCEEDED(rc))
+            {
+                if (!RTStrICmp(pszNonRotational, "on"))
+                {
+                    CHECK_ERROR(machine, NonRotationalDevice(Bstr(pszCtl).raw(),
+                                                             port, device, TRUE));
+                }
+                else if (!RTStrICmp(pszNonRotational, "off"))
+                {
+                    CHECK_ERROR(machine, NonRotationalDevice(Bstr(pszCtl).raw(),
+                                                             port, device, FALSE));
+                }
+                else
+                    throw Utf8StrFmt("Invalid --nonrotational argument '%s'", pszNonRotational);
             }
             else

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.cpp

@@ -552 +552 @@
     , mAttIsPassthrough (false)
     , mAttIsTempEject (false)
+    , mAttIsNonRotational (false)
 {
     /* Check for proper parent type */
@@ -610 +611 @@
 }
 
+bool AttachmentItem::attIsNonRotational() const
+{
+    return mAttIsNonRotational;
+}
+
 void AttachmentItem::setAttSlot (const StorageSlot &aAttSlot)
 {
@@ -635 +641 @@
 {
     mAttIsTempEject = aIsAttTempEject;
+}
+
+void AttachmentItem::setAttIsNonRotational (bool aIsAttNonRotational)
+{
+    mAttIsNonRotational = aIsAttNonRotational;
 }
 
@@ -1096 +1107 @@
             return false;
         }
+        case R_AttIsNonRotational:
+        {
+            if (AbstractItem *item = static_cast <AbstractItem*> (aIndex.internalPointer()))
+                if (item->rtti() == AbstractItem::Type_AttachmentItem)
+                    return static_cast <AttachmentItem*> (item)->attIsNonRotational();
+            return false;
+        }
         case R_AttSize:
         {
@@ -1311 +1329 @@
                 {
                     static_cast <AttachmentItem*> (item)->setAttIsTempEject (aValue.toBool());
+                    emit dataChanged (aIndex, aIndex);
+                    return true;
+                }
+            return false;
+        }
+        case R_AttIsNonRotational:
+        {
+            if (AbstractItem *item = static_cast <AbstractItem*> (aIndex.internalPointer()))
+                if (item->rtti() == AbstractItem::Type_AttachmentItem)
+                {
+                    static_cast <AttachmentItem*> (item)->setAttIsNonRotational (aValue.toBool());
                     emit dataChanged (aIndex, aIndex);
                     return true;
@@ -1801 +1830 @@
     connect (mCbPassthrough, SIGNAL (stateChanged (int)), this, SLOT (setInformation()));
     connect (mCbTempEject, SIGNAL (stateChanged (int)), this, SLOT (setInformation()));
+    connect (mCbNonRotational, SIGNAL (stateChanged (int)), this, SLOT (setInformation()));
 
     /* Applying language settings */
@@ -1865 +1895 @@
                     storageAttachmentData.m_fAttachmentPassthrough = attachment.GetPassthrough();
                     storageAttachmentData.m_fAttachmentTempEject = attachment.GetTemporaryEject();
+                    storageAttachmentData.m_fAttachmentNonRotational = attachment.GetNonRotational();
                     CMedium comMedium(attachment.GetMedium());
                     VBoxMedium vboxMedium;
@@ -1925 +1956 @@
             mStorageModel->setData(attachmentIndex, attachmentData.m_fAttachmentPassthrough, StorageModel::R_AttIsPassthrough);
             mStorageModel->setData(attachmentIndex, attachmentData.m_fAttachmentTempEject, StorageModel::R_AttIsTempEject);
+            mStorageModel->setData(attachmentIndex, attachmentData.m_fAttachmentNonRotational, StorageModel::R_AttIsNonRotational);
         }
     }
@@ -1977 +2009 @@
             attachmentData.m_fAttachmentPassthrough = mStorageModel->data(attachmentIndex, StorageModel::R_AttIsPassthrough).toBool();
             attachmentData.m_fAttachmentTempEject = mStorageModel->data(attachmentIndex, StorageModel::R_AttIsTempEject).toBool();
+            attachmentData.m_fAttachmentNonRotational = mStorageModel->data(attachmentIndex, StorageModel::R_AttIsNonRotational).toBool();
             attachmentData.m_strAttachmentMediumId = mStorageModel->data(attachmentIndex, StorageModel::R_AttMediumId).toString();
 
@@ -2417 +2450 @@
                 mCbTempEject->setChecked (!isHostDrive && mStorageModel->data (index, StorageModel::R_AttIsTempEject).toBool());
 
+                /* Getting NonRotational state */
+                mCbNonRotational->setVisible (device == KDeviceType_HardDisk);
+                mCbNonRotational->setChecked (mStorageModel->data (index, StorageModel::R_AttIsNonRotational).toBool());
+
                 /* Update optional widgets visibility */
                 updateAdditionalObjects (device);
@@ -2489 +2526 @@
                 if (!mStorageModel->data (index, StorageModel::R_AttIsHostDrive).toBool())
                     mStorageModel->setData (index, mCbTempEject->isChecked(), StorageModel::R_AttIsTempEject);
+            }
+            else if (sdr == mCbNonRotational)
+            {
+                mStorageModel->setData (index, mCbNonRotational->isChecked(), StorageModel::R_AttIsNonRotational);
             }
             break;
@@ -3397 +3438 @@
         bool fAttachmentPassthrough = attachmentData.m_fAttachmentPassthrough;
         bool fAttachmentTempEject = attachmentData.m_fAttachmentTempEject;
+        bool fAttachmentNonRotational = attachmentData.m_fAttachmentNonRotational;
         /* Get GUI medium object: */
         VBoxMedium vboxMedium = vboxGlobal().findMedium(strAttachmentMediumId);
@@ -3426 +3468 @@
                     }
                 }
+                else if (attachmentDeviceType == KDeviceType_HardDisk)
+                {
+                    m_machine.NonRotationalDevice(strControllerName, iAttachmentPort, iAttachmentDevice, fAttachmentNonRotational);
+                    /* Check that machine is OK: */
+                    fSuccess = m_machine.isOk();
+                }
             }
             else
@@ -3461 +3509 @@
         bool fAttachmentPassthrough = attachmentData.m_fAttachmentPassthrough;
         bool fAttachmentTempEject = attachmentData.m_fAttachmentTempEject;
+        bool fAttachmentNonRotational = attachmentData.m_fAttachmentNonRotational;
         KDeviceType attachmentDeviceType = attachmentData.m_attachmentType;
 
@@ -3497 +3546 @@
                     }
                 }
+                if (fSuccess)
+                {
+                    if (attachmentDeviceType == KDeviceType_DVD)
+                    {
+                        m_machine.NonRotationalDevice(strControllerName, iAttachmentPort, iAttachmentDevice, fAttachmentNonRotational);
+                        /* Check that machine is OK: */
+                        fSuccess = m_machine.isOk();
+                    }
+                }
             }
             else
@@ -3571 +3629 @@
     mCbPassthrough->setEnabled(isMachineOffline());
     mCbTempEject->setEnabled(isMachineInValidMode());
+    mCbNonRotational->setEnabled(isMachineOffline());
     mLsInformation->setEnabled(isMachineInValidMode());
     mLbHDFormat->setEnabled(isMachineInValidMode());

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.h

@@ -357 +357 @@
     bool attIsPassthrough() const;
     bool attIsTempEject() const;
+    bool attIsNonRotational() const;
 
     void setAttSlot (const StorageSlot &aAttSlot);
@@ -363 +364 @@
     void setAttIsPassthrough (bool aPassthrough);
     void setAttIsTempEject (bool aTempEject);
+    void setAttIsNonRotational (bool aNonRotational);
 
     QString attSize() const;
@@ -394 +396 @@
     bool mAttIsPassthrough;
     bool mAttIsTempEject;
+    bool mAttIsNonRotational;
 
     QString mAttName;
@@ -448 +451 @@
         R_AttIsPassthrough,
         R_AttIsTempEject,
+        R_AttIsNonRotational,
         R_AttSize,
         R_AttLogicalSize,
@@ -562 +566 @@
         , m_strAttachmentMediumId(QString())
         , m_fAttachmentPassthrough(false)
-        , m_fAttachmentTempEject(false) {}
+        , m_fAttachmentTempEject(false)
+        , m_fAttachmentNonRotational(false) {}
     /* Functions: */
     bool equal(const UIDataSettingsMachineStorageAttachment &other) const
@@ -571 +576 @@
                (m_strAttachmentMediumId == other.m_strAttachmentMediumId) &&
                (m_fAttachmentPassthrough == other.m_fAttachmentPassthrough) &&
-               (m_fAttachmentTempEject == other.m_fAttachmentTempEject);
+               (m_fAttachmentTempEject == other.m_fAttachmentTempEject) &&
+               (m_fAttachmentNonRotational == other.m_fAttachmentNonRotational);
     }
     /* Operators: */
@@ -583 +589 @@
     bool m_fAttachmentPassthrough;
     bool m_fAttachmentTempEject;
+    bool m_fAttachmentNonRotational;
 };
 typedef UISettingsCache<UIDataSettingsMachineStorageAttachment> UICacheSettingsMachineStorageAttachment;

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.ui

@@ -339 +339 @@
          </widget>
         </item>
+        <item row="2" column="2" >
+         <widget class="QCheckBox" name="mCbNonRotational" >
+          <property name="sizePolicy" >
+           <sizepolicy vsizetype="Fixed" hsizetype="MinimumExpanding" >
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="whatsThis" >
+           <string>When checked, this marks the medium as non-rotational storage (SSD).</string>
+          </property>
+          <property name="text" >
+           <string>&amp;Solid-state drive</string>
+          </property>
+         </widget>
+        </item>
         <item row="3" column="0" colspan="3" >
          <widget class="QILabelSeparator" native="1" name="mLsInformation" >

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

@@ -4691 +4691 @@
     </method>
 
+    <method name="nonRotationalDevice">
+      <desc>
+        Sets a flag in the device information which indicates that the medium
+        is not based on rotational technology, i.e. that the access times are
+        more or less independent of the position on the medium. This may or may
+        not be supported by a particular drive, and is silently ignored in the
+        latter case. At the moment only hard disks (which is a misnomer in this
+        context) accept this setting. Changing the setting while the VM is
+        running is forbidden. The device must already exist; see
+        <link to="IMachine::attachDevice"/> for how to attach a new device.
+
+        The @a controllerPort and @a device parameters specify the device slot and
+        have have the same meaning as with <link to="IMachine::attachDevice" />.
+
+        <result name="E_INVALIDARG">
+          SATA device, SATA port, IDE port or IDE slot out of range.
+        </result>
+        <result name="VBOX_E_INVALID_OBJECT_STATE">
+          Attempt to modify an unregistered virtual machine.
+        </result>
+        <result name="VBOX_E_INVALID_VM_STATE">
+          Invalid machine state.
+        </result>
+
+      </desc>
+      <param name="name" type="wstring" dir="in">
+        <desc>Name of the storage controller.</desc>
+      </param>
+      <param name="controllerPort" type="long" dir="in">
+        <desc>Storage controller port.</desc>
+      </param>
+      <param name="device" type="long" dir="in">
+        <desc>Device slot in the given port.</desc>
+      </param>
+      <param name="nonRotational" type="boolean" dir="in">
+        <desc>New value for the non-rotational device flag.</desc>
+      </param>
+    </method>
+
     <method name="setBandwidthGroupForDevice">
       <desc>
@@ -9840 +9879 @@
       <desc>Signals that the removable medium has been ejected. This is not
         necessarily equivalent to having a @c null medium association.</desc>
+    </attribute>
+
+    <attribute name="nonRotational" type="boolean" readonly="yes">
+      <desc>Whether the associated medium is non-rotational.</desc>
     </attribute>
 

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

@@ -478 +478 @@
     STDMETHOD(PassthroughDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aPassthrough);
     STDMETHOD(TemporaryEjectDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aTempEject);
+    STDMETHOD(NonRotationalDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aNonRotational);
     STDMETHOD(SetBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
                                           LONG aDevice, IBandwidthGroup *aBandwidthGroup);

trunk/src/VBox/Main/include/MediumAttachmentImpl.h

@@ -50 +50 @@
                  bool fPassthrough,
                  bool fTempEject,
+                 bool fNonRotational,
                  const Utf8Str &strBandwidthGroup);
     void uninit();
@@ -65 +66 @@
     STDMETHOD(COMGETTER(TemporaryEject))(BOOL *aTemporaryEject);
     STDMETHOD(COMGETTER(IsEjected))(BOOL *aIsEjected);
+    STDMETHOD(COMGETTER(NonRotational))(BOOL *aNonRotational);
     STDMETHOD(COMGETTER(BandwidthGroup))(IBandwidthGroup **aBwGroup);
 
@@ -83 +85 @@
     bool getPassthrough() const;
     bool getTempEject() const;
+    bool getNonRotational() const;
     const Utf8Str& getBandwidthGroup() const;
 
@@ -95 +98 @@
     /** Must be called from under this object's write lock. */
     void updateTempEject(bool aTempEject);
+
+    /** Must be called from under this object's write lock. */
+    void updateNonRotational(bool aNonRotational);
 
     /** Must be called from under this object's write lock. */

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

@@ -316 +316 @@
 #endif
 
+static const char *const g_apszIDEDrives[4] =
+    { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
 
 class ConfigError : public RTCError
@@ -1571 +1573 @@
                         for (uint32_t j = 0; j < 4; ++j)
                         {
-                            static const char * const s_apszConfig[4] =
-                            { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
                             static const char * const s_apszBiosConfig[4] =
                             { "SataPrimaryMasterLUN", "SataPrimarySlaveLUN", "SataSecondaryMasterLUN", "SataSecondarySlaveLUN" };
@@ -1578 +1578 @@
                             LONG lPortNumber = -1;
                             hrc = ctrls[i]->GetIDEEmulationPort(j, &lPortNumber);           H();
-                            InsertConfigInteger(pCfg, s_apszConfig[j], lPortNumber);
+                            InsertConfigInteger(pCfg, g_apszIDEDrives[j], lPortNumber);
                             if (pBiosCfg)
                                 InsertConfigInteger(pBiosCfg, s_apszBiosConfig[j], lPortNumber);
@@ -2861 +2861 @@
         DeviceType_T lType;
         hrc = pMediumAtt->COMGETTER(Type)(&lType);                                          H();
+        BOOL fNonRotational;
+        hrc = pMediumAtt->COMGETTER(NonRotational)(&fNonRotational);                        H();
 
         unsigned uLUN;
         PCFGMNODE pLunL0 = NULL;
-        PCFGMNODE pCfg = NULL;
         hrc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);                H();
 
@@ -2912 +2913 @@
         InsertConfigNode(pCtlInst, Utf8StrFmt("LUN#%u", uLUN).c_str(), &pLunL0);
 
+        PCFGMNODE pCfg = CFGMR3GetChild(pCtlInst, "Config");
+        if (pCfg)
+        {
+            if (!strcmp(pcszDevice, "piix3ide"))
+            {
+                PCFGMNODE pDrive = CFGMR3GetChild(pCfg, g_apszIDEDrives[uLUN]);
+                if (!pDrive)
+                    InsertConfigNode(pCfg, g_apszIDEDrives[uLUN], &pDrive);
+                PCFGMNODE pNonRot = CFGMR3GetChild(pCtlInst, "NonRotationalMedium");
+                if (pNonRot)
+                    CFGMR3RemoveNode(pNonRot);
+                InsertConfigInteger(pDrive, "NonRotationalMedium", !!fNonRotational);
+            }
+            else if (!strcmp(pcszDevice, "ahci"))
+            {
+                Utf8Str strPort = Utf8StrFmt("Port%u", uLUN);
+                PCFGMNODE pDrive = CFGMR3GetChild(pCfg, strPort.c_str());
+                if (!pDrive)
+                    InsertConfigNode(pCfg, strPort.c_str(), &pDrive);
+                PCFGMNODE pNonRot = CFGMR3GetChild(pCtlInst, "NonRotationalMedium");
+                if (pNonRot)
+                    CFGMR3RemoveNode(pNonRot);
+                InsertConfigInteger(pDrive, "NonRotationalMedium", !!fNonRotational);
+            }
+        }
+        /** @todo add SCSI/SAS support once the SSD support is there */
+
         Utf8Str devicePath = Utf8StrFmt("%s/%u/LUN#%u", pcszDevice, uInstance, uLUN);
         mapMediumAttachments[devicePath] = pMediumAtt;
@@ -2919 +2947 @@
         {
             InsertConfigString(pLunL0, "Driver", "SCSI");
-            InsertConfigNode(pLunL0, "Config", &pCfg);
+            PCFGMNODE pL1Cfg = NULL;
+            InsertConfigNode(pLunL0, "Config", &pL1Cfg);
 
             InsertConfigNode(pLunL0, "AttachedDriver", &pLunL0);

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

@@ -3804 +3804 @@
                           false /* fPassthrough */,
                           false /* fTempEject */,
+                          false /* fNonRotational */,
                           Utf8Str::Empty);
     if (FAILED(rc)) return rc;
@@ -3994 +3995 @@
     if (pAttach->getType() != DeviceType_DVD)
         return setError(E_INVALIDARG,
-                        tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
+                        tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
                         aDevice, aControllerPort, aControllerName);
     pAttach->updateTempEject(!!aTemporaryEject);
+
+    return S_OK;
+}
+
+STDMETHODIMP Machine::NonRotationalDevice(IN_BSTR aControllerName, LONG aControllerPort,
+                                          LONG aDevice, BOOL aNonRotational)
+{
+    CheckComArgStrNotEmptyOrNull(aControllerName);
+
+    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%ld aDevice=%ld aNonRotational=%d\n",
+                     aControllerName, aControllerPort, aDevice, aNonRotational));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT rc = checkStateDependency(MutableStateDep);
+    if (FAILED(rc)) return rc;
+
+    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
+
+    if (Global::IsOnlineOrTransient(mData->mMachineState))
+        return setError(VBOX_E_INVALID_VM_STATE,
+                        tr("Invalid machine state: %s"),
+                        Global::stringifyMachineState(mData->mMachineState));
+
+    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
+                                               aControllerName,
+                                               aControllerPort,
+                                               aDevice);
+    if (!pAttach)
+        return setError(VBOX_E_OBJECT_NOT_FOUND,
+                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
+                        aDevice, aControllerPort, aControllerName);
+
+
+    setModified(IsModified_Storage);
+    mMediaData.backup();
+
+    AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
+
+    if (pAttach->getType() != DeviceType_HardDisk)
+        return setError(E_INVALIDARG,
+                        tr("Setting the non-rotational medium flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a hard disk"),
+                        aDevice, aControllerPort, aControllerName);
+    pAttach->updateNonRotational(!!aNonRotational);
 
     return S_OK;
@@ -8098 +8146 @@
                                dev.fPassThrough,
                                dev.fTempEject,
+                               dev.fNonRotational,
                                pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->getName());
         if (FAILED(rc)) break;
@@ -9045 +9094 @@
             dev.fPassThrough = pAttach->getPassthrough();
             dev.fTempEject = pAttach->getTempEject();
+            dev.fNonRotational = pAttach->getNonRotational();
         }
 
@@ -9368 +9418 @@
                                   false /* aPassthrough */,
                                   false /* aTempEject */,
+                                  false /* aNonRotational */,
                                   pAtt->getBandwidthGroup());
             if (FAILED(rc)) throw rc;

trunk/src/VBox/Main/src-server/MediumAttachmentImpl.cpp

@@ -41 +41 @@
           fPassthrough(false),
           fTempEject(false),
+          fNonRotational(false),
           fImplicit(false)
     { }
@@ -58 +59 @@
     bool                fPassthrough;
     bool                fTempEject;
+    bool                fNonRotational;
     bool                fImplicit;
 };
@@ -117 +119 @@
                                bool aPassthrough,
                                bool aTempEject,
+                               bool aNonRotational,
                                const Utf8Str &strBandwidthGroup)
 {
     LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aParent=%p aMedium=%p aControllerName=%ls aPort=%d aDevice=%d aType=%d aImplicit=%d aPassthrough=%d aTempEject=%d\n", aParent, aMedium, aControllerName.raw(), aPort, aDevice, aType, aImplicit, aPassthrough, aTempEject));
+    LogFlowThisFunc(("aParent=%p aMedium=%p aControllerName=%ls aPort=%d aDevice=%d aType=%d aImplicit=%d aPassthrough=%d aTempEject=%d aNonRotational=%d strBandwithGroup=%s\n", aParent, aMedium, aControllerName.raw(), aPort, aDevice, aType, aImplicit, aPassthrough, aTempEject, aNonRotational, strBandwidthGroup.c_str()));
 
     if (aType == DeviceType_HardDisk)
@@ -143 +146 @@
     m->bd->fPassthrough = aPassthrough;
     m->bd->fTempEject = aTempEject;
+    m->bd->fNonRotational = aNonRotational;
     m->bd->fImplicit = aImplicit;
 
@@ -319 +323 @@
 }
 
+STDMETHODIMP MediumAttachment::COMGETTER(NonRotational)(BOOL *aNonRotational)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aNonRotational);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aNonRotational = m->bd->fNonRotational;
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
 STDMETHODIMP MediumAttachment::COMGETTER(BandwidthGroup) (IBandwidthGroup **aBwGroup)
 {
@@ -429 +450 @@
 }
 
+bool MediumAttachment::getNonRotational() const
+{
+    AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
+    return m->bd->fNonRotational;
+}
+
 const Utf8Str& MediumAttachment::getBandwidthGroup() const
 {
@@ -481 +508 @@
 }
 
+/** Must be called from under this object's write lock. */
+void MediumAttachment::updateNonRotational(bool aNonRotational)
+{
+    Assert(isWriteLockOnCurrentThread());
+
+    m->bd.backup();
+    m->bd->fNonRotational = aNonRotational;
+}
+
 void MediumAttachment::updateBandwidthGroup(const Utf8Str &aBandwidthGroup)
 {

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

@@ -1692 +1692 @@
                   && (fPassThrough              == a.fPassThrough)
                   && (fTempEject                == a.fTempEject)
+                  && (fNonRotational            == a.fNonRotational)
                   && (lPort                     == a.lPort)
                   && (lDevice                   == a.lDevice)
@@ -2984 +2985 @@
 
             if (strTemp == "HardDisk")
+            {
                 att.deviceType = DeviceType_HardDisk;
+                pelmAttached->getAttributeValue("nonrotational", att.fNonRotational);
+            }
             else if (m->sv >= SettingsVersion_v1_9)
             {
@@ -4229 +4233 @@
                 case DeviceType_HardDisk:
                     pcszType = "HardDisk";
+                    if (att.fNonRotational)
+                        pelmDevice->setAttribute("nonrotational", att.fNonRotational);
                 break;