VirtualBox

Changeset 17755 in vbox


Ignore:
Timestamp:
Mar 12, 2009 3:03:46 PM (16 years ago)
Author:
vboxsync
Message:

Main, OVF: add output IStorageController to IMachine::addStorageController(); add SCSI support to OVF import/export

Location:
trunk/src/VBox
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r17669 r17755  
    17711771            if (fSataEnabled)
    17721772            {
    1773                 CHECK_ERROR(machine, AddStorageController(Bstr("SATA"), StorageBus_SATA));
    17741773                ComPtr<IStorageController> ctl;
    1775                 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), ctl.asOutParam()));
     1774                CHECK_ERROR(machine, AddStorageController(Bstr("SATA"), StorageBus_SATA, ctl.asOutParam()));
    17761775                CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
    17771776            }
    … …  
    18471846            if (fLsiLogicEnabled)
    18481847            {
    1849                 CHECK_ERROR(machine, AddStorageController(Bstr("LsiLogic"), StorageBus_SCSI));
    18501848                ComPtr<IStorageController> ctl;
    1851                 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("LsiLogic"), ctl.asOutParam()));
     1849                CHECK_ERROR(machine, AddStorageController(Bstr("LsiLogic"), StorageBus_SCSI, ctl.asOutParam()));
    18521850                CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
    18531851            }

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

    r17747 r17755  
    753753                    else if (!strcmp(pcszItemChildName, "ResourceType"))
    754754                    {
    755                         int32_t iType; /** @todo how to fix correctly? (enum fun.) */
    756                         pelmItemChild->copyValue(iType);
    757                         i.resourceType = (OVFResourceType_T)iType;
     755                        uint32_t ulType;
     756                        pelmItemChild->copyValue(ulType);
     757                        i.resourceType = (OVFResourceType_T)ulType;
    758758                    }
    759759                    else if (!strcmp(pcszItemChildName, "OtherResourceType"))
    … …  
    12181218
    12191219    /* Clear any previous virtual system descriptions */
    1220     // @todo: have the entries deleted also?
    12211220    m->virtualSystemDescriptions.clear();
    12221221
    … …  
    13351334                /* Check for the constrains */
    13361335                if (vsysThis.llNetworkNames.size() > SchemaDefs::NetworkAdapterCount)
    1337                 {
    13381336                    pNewDesc->addWarning(tr("The virtual system claims support for %u network adapters, but VirtualBox has support for max %u network adapter only."),
    13391337                                         vsysThis.llNetworkNames.size(), SchemaDefs::NetworkAdapterCount);
    13401338
    1341                 }
    13421339                /* Get the default network adapter type for the selected guest OS */
    13431340                NetworkAdapterType_T nwAdapterVBox = NetworkAdapterType_Am79C970A;
    … …  
    14521449                            if (cSCSIused < 1)
    14531450                            {
    1454                                 // @todo: figure out the SCSI types
    14551451                                Utf8Str hdcController = "LsiLogic";
    1456                                 /* if (!RTStrICmp(hdc.strControllerType.c_str(), "LsiLogic"))
    1457                                    hdcController = "LsiLogic";
    1458                                    else*/
    14591452                                if (!RTStrICmp(hdc.strControllerType.c_str(), "BusLogic"))
    14601453                                    hdcController = "BusLogic";
    … …  
    14731466                            ++cSCSIused;
    14741467                            break;
    1475                         }
    1476                     default:
    1477                         {
    1478                             /* @todo: should we stop? */
    14791468                        }
    14801469                }
    … …  
    15311520                    }
    15321521                    else
    1533                     {
    1534                         /* @todo: should we stop here? */
    1535                         pNewDesc->addWarning(tr("The virtual system claims support for the following virtual disk image format which VirtualBox not support: %s"),
    1536                                              di.strFormat.c_str());
    1537                     }
     1522                        throw setError(VBOX_E_FILE_ERROR,
     1523                                       tr("Unsupported format for virtual disk image in OVF: \"%s\"", di.strFormat.c_str()));
    15381524                }
    15391525            }
    … …  
    19481934            /* Hard disk controller IDE */
    19491935            std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
    1950             /* @todo: we support one IDE controller only */
    1951             if (vsdeHDCIDE.size() > 0)
     1936            if (vsdeHDCIDE.size() > 1)
     1937                throw setError(VBOX_E_FILE_ERROR,
     1938                               tr("Too many IDE controllers in OVF; VirtualBox only supports one"));
     1939            if (vsdeHDCIDE.size() == 1)
    19521940            {
    1953                 /* Set the appropriate IDE controller in the virtual BIOS of the VM */
    1954                 ComPtr<IStorageController> ctl;
    1955                 rc = pNewMachine->GetStorageControllerByName(Bstr("IDE"), ctl.asOutParam());
     1941                ComPtr<IStorageController> pController;
     1942                rc = pNewMachine->GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
    19561943                if (FAILED(rc)) throw rc;
    19571944
    19581945                const char *pcszIDEType = vsdeHDCIDE.front()->strVbox.c_str();
    19591946                if (!strcmp(pcszIDEType, "PIIX3"))
    1960                     rc = ctl->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
     1947                    rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
    19611948                else if (!strcmp(pcszIDEType, "PIIX4"))
    1962                     rc = ctl->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
     1949                    rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
    19631950                else if (!strcmp(pcszIDEType, "ICH6"))
    1964                     rc = ctl->COMSETTER(ControllerType)(StorageControllerType_ICH6);
     1951                    rc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
    19651952                else
    19661953                    throw setError(VBOX_E_FILE_ERROR,
    … …  
    19721959            /* Hard disk controller SATA */
    19731960            std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
    1974             /* @todo: we support one SATA controller only */
     1961            if (vsdeHDCSATA.size() > 1)
     1962                throw setError(VBOX_E_FILE_ERROR,
     1963                               tr("Too many SATA controllers in OVF; VirtualBox only supports one"));
    19751964            if (vsdeHDCSATA.size() > 0)
    19761965            {
     1966                ComPtr<IStorageController> pController;
    19771967                const Utf8Str &hdcVBox = vsdeHDCIDE.front()->strVbox;
    19781968                if (hdcVBox == "AHCI")
    19791969                {
    1980                     /* For now we have just to enable the AHCI controller. */
    1981                     rc = pNewMachine->AddStorageController(Bstr("SATA"), StorageBus_SATA);
     1970                    rc = pNewMachine->AddStorageController(Bstr("SATA"), StorageBus_SATA, pController.asOutParam());
    19821971                    if (FAILED(rc)) throw rc;
    19831972                }
    19841973                else
    1985                 {
    19861974                    throw setError(VBOX_E_FILE_ERROR,
    19871975                                   tr("Invalid SATA controller type \"%s\""),
    19881976                                   hdcVBox.c_str());
    1989                 }
    19901977            }
    19911978#endif /* VBOX_WITH_AHCI */
    … …  
    19931980            /* Hard disk controller SCSI */
    19941981            std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
    1995             /* @todo: do we support more than one SCSI controller? */
     1982            if (vsdeHDCSATA.size() > 1)
     1983                throw setError(VBOX_E_FILE_ERROR,
     1984                               tr("Too many SCSI controllers in OVF; VirtualBox only supports one"));           // @todo is that true?
    19961985            if (vsdeHDCSCSI.size() > 0)
    19971986            {
    1998                 /* @todo: revisit when Main support for SCSI is ready */
     1987                ComPtr<IStorageController> pController;
     1988                StorageControllerType_T controllerType;
     1989                const Utf8Str &hdcVBox = vsdeHDCIDE.front()->strVbox;
     1990                if (hdcVBox == "LsiLogic")
     1991                    controllerType = StorageControllerType_LsiLogic;
     1992                else if (hdcVBox == "BusLogic")
     1993                    controllerType = StorageControllerType_BusLogic;
     1994                else
     1995                    throw setError(VBOX_E_FILE_ERROR,
     1996                                   tr("Invalid SCSI controller type \"%s\""),
     1997                                   hdcVBox.c_str());
     1998
     1999                rc = pNewMachine->AddStorageController(Bstr("SCSI"), StorageBus_SCSI, pController.asOutParam());
     2000                if (FAILED(rc)) throw rc;
     2001                rc = pController->COMSETTER(ControllerType)(controllerType);
     2002                if (FAILED(rc)) throw rc;
    19992003            }
    20002004
    … …  
    22302234
    22312235                            case HardDiskController::SCSI:
    2232 //                                 mhda.busType = StorageBus_SCSI;
    2233                                 throw setError(VBOX_E_NOT_SUPPORTED,
    2234                                                tr("SCSI controller support is not available yet in VirtualBox"));
    2235                                     // @todo
     2236                                mhda.controllerType = Bstr("SCSI");
     2237                                mhda.lChannel = (long)vd.ulAddressOnParent;
     2238                                mhda.lDevice = (long)0;
    22362239                            break;
    22372240
    … …  
    23982401        xml::ElementNode *pelmDiskSectionInfo = pelmDiskSection->createChild("Info");
    23992402        pelmDiskSectionInfo->addContent("List of the virtual disks used in the package");
    2400         // @todo for each disk:
    2401         // xml::ElementNode *pelmDisk = pelmDiskSection->createChild("Disk");
    24022403        // for now, set up a map so we have a list of unique disk names (to make
    24032404        // sure the same disk name is only added once)
    … …  
    24502451            xml::ElementNode *pelmOperatingSystemSection = pelmVirtualSystem->createChild("OperatingSystemSection");
    24512452            pelmOperatingSystemSection->setAttribute("ovf:id", llOS.front()->strOvf);
    2452                     // @todo convert vbox OS type into OVF ID
    24532453            pelmOperatingSystemSection->createChild("Info")->addContent("blah");        // @ŧodo
    24542454            pelmOperatingSystemSection->createChild("Description")->addContent("blah");        // @ŧodo
    … …  
    33583358        int32_t lIDEControllerIndex = 0;
    33593359        int32_t lSATAControllerIndex = 0;
     3360        int32_t lSCSIControllerIndex = 0;
    33603361
    33613362//     <const name="HardDiskControllerIDE" value="6" />
    3362         ComPtr<IStorageController> ctl;
    3363         rc = GetStorageControllerByName(Bstr("IDE"), ctl.asOutParam());
     3363        ComPtr<IStorageController> pController;
     3364        rc = GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
    33643365        if (FAILED(rc)) throw rc;
    33653366        Utf8Str strVbox;
    33663367        StorageControllerType_T ctlr;
    3367         rc = ctl->COMGETTER(ControllerType)(&ctlr);
     3368        rc = pController->COMGETTER(ControllerType)(&ctlr);
    33683369        if (FAILED(rc)) throw rc;
    33693370        switch(ctlr)
    … …  
    33773378        {
    33783379            lIDEControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
    3379             pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE, Utf8StrFmt("%d", lIDEControllerIndex), strVbox, "");
     3380            pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
     3381                               Utf8StrFmt("%d", lIDEControllerIndex),
     3382                               strVbox,
     3383                               "");
    33803384        }
    33813385
    33823386#ifdef VBOX_WITH_AHCI
    33833387//     <const name="HardDiskControllerSATA" value="7" />
    3384         rc = GetStorageControllerByName(Bstr("IDE"), ctl.asOutParam());
     3388        rc = GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
    33853389        if (SUCCEEDED(rc))
    33863390        {
    33873391            lSATAControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
    3388             pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA, Utf8StrFmt("%d", lSATAControllerIndex), strVbox, "");
     3392            pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
     3393                               Utf8StrFmt("%d", lSATAControllerIndex),
     3394                               strVbox,
     3395                               "");
    33893396        }
    33903397#endif // VBOX_WITH_AHCI
    33913398
    33923399//     <const name="HardDiskControllerSCSI" value="8" />
    3393         // @todo
     3400        rc = GetStorageControllerByName(Bstr("SCSI"), pController.asOutParam());
     3401        if (SUCCEEDED(rc))
     3402        {
     3403            lSCSIControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
     3404            pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
     3405                               Utf8StrFmt("%d", lSCSIControllerIndex),
     3406                               strVbox,
     3407                               "");
     3408        }
    33943409
    33953410//     <const name="HardDiskImage" value="9" />

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

    r17736 r17755  
    515515                 * not in the StorageDevice implementation at the moment)
    516516                 */
    517                 rc = AddStorageController(Bstr("IDE"), StorageBus_IDE);
     517                ComPtr<IStorageController> pController;
     518                rc = AddStorageController(Bstr("IDE"), StorageBus_IDE, pController.asOutParam());
    518519                CheckComRCReturnRC(rc);
    519520                ComObjPtr<StorageController> ctl;
    … …  
    32683269
    32693270STDMETHODIMP Machine::
    3270 AddStorageController(IN_BSTR aName, StorageBus_T aConnectionType)
     3271AddStorageController(IN_BSTR aName,
     3272                     StorageBus_T aConnectionType,
     3273                     IStorageController **controller)
    32713274{
    32723275    CheckComArgStrNotEmptyOrNull(aName);
    … …  
    33003303    mStorageControllers.backup();
    33013304    mStorageControllers->push_back (ctrl);
     3305
     3306    ctrl.queryInterfaceTo(controller);
    33023307
    33033308    /* inform the direct session if any */

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

    r17752 r17755  
    36583658  <interface
    36593659     name="IMachine" extends="$unknown"
    3660      uuid="ea6fb7ea-1993-4642-b113-f29eb39e0df0"
     3660     uuid="dcf6a64c-1466-4b5a-b822-9db04133dc74"
    36613661     wsmap="managed"
    36623662     >
    … …  
    44444444    <method name="addStorageController">
    44454445      <desc>
    4446         Adds a new storage controller (SCSI or SATA controller) to the machine.
     4446        Adds a new storage controller (SCSI or SATA controller) to the
     4447        machine and returns it as an instance of
     4448        <link to="IStorageController" />.
     4449
    44474450        @a name identifies the controller with subsequent calls such as
    44484451        <link to="#getStorageControllerByName" /> or
    … …  
    44504453        <link to="#attachHardDisk" />.
    44514454
     4455        After the controller has been added, you can set its exact
     4456        type by setting the <link to="IStorageController::controllerType" />.
     4457
    44524458        <result name="VBOX_E_OBJECT_IN_USE">
    44534459          A storage controller with given name exists already.
    … …  
    44594465      <param name="name" type="wstring" dir="in"/>
    44604466      <param name="connectionType" type="StorageBus" dir="in"/>
     4467      <param name="controller" type="IStorageController" dir="return"/>
    44614468    </method>
    44624469

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

    r17685 r17755  
    569569    STDMETHOD(EnumerateGuestProperties) (IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
    570570    STDMETHOD(GetHardDiskAttachmentsOfController)(IN_BSTR aName, ComSafeArrayOut (IHardDiskAttachment *, aAttachments));
    571     STDMETHOD(AddStorageController) (IN_BSTR aName, StorageBus_T aConnectionType);
     571    STDMETHOD(AddStorageController) (IN_BSTR aName, StorageBus_T aConnectionType, IStorageController **controller);
    572572    STDMETHOD(RemoveStorageController (IN_BSTR aName));
    573573    STDMETHOD(GetStorageControllerByName (IN_BSTR aName, IStorageController **storageController));
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