VirtualBox

Changeset 1015 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Feb 21, 2007 7:47:10 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
18872
Message:

Storage/Main/GUI: Implemented preliminary support of VMDK images version 3 and 4 (no separate Disk DescriptionFile support).

Location:
trunk/src/VBox/Main
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r903 r1015  
    48364836        if (hddType == HardDiskStorageType_VirtualDiskImage)
    48374837        {
     4838            ComPtr<IVirtualDiskImage> vdiDisk = hardDisk;
     4839            AssertBreak (!vdiDisk.isNull(), hrc = E_FAIL);
     4840
    48384841            rc = CFGMR3InsertNode(pLunL0,   "AttachedDriver", &pLunL1);                 RC_CHECK();
    4839             rc = CFGMR3InsertString(pLunL1, "Driver",           "VBoxHDD");             RC_CHECK();
     4842            rc = CFGMR3InsertString(pLunL1, "Driver",         "VBoxHDD");               RC_CHECK();
    48404843            rc = CFGMR3InsertNode(pLunL1,   "Config", &pCfg);                           RC_CHECK();
    4841             /// @todo (dmik) we temporarily use the location property to
    4842             //  determine the image file name. This is subject to change
    4843             //  when iSCSI disks are here (we should either query a
    4844             //  storage-specific interface from IHardDisk, or "standardize"
    4845             //  the location property)
    4846             hrc = hardDisk->COMGETTER(Location)(&str);                                  H();
     4844            hrc = vdiDisk->COMGETTER(FilePath)(&str);                                   H();
    48474845            STR_CONV();
    48484846            rc = CFGMR3InsertString(pCfg,   "Path",             psz);                   RC_CHECK();
    … …  
    48584856                    break;
    48594857
     4858                vdiDisk = curHardDisk;
     4859                AssertBreak (!vdiDisk.isNull(), hrc = E_FAIL);
     4860
    48604861                PCFGMNODE pCur;
    48614862                rc = CFGMR3InsertNode(pParent, "Parent", &pCur);                        RC_CHECK();
    4862                 /// @todo (dmik) we temporarily use the location property to
    4863                 //  determine the image file name. This is subject to change
    4864                 //  when iSCSI disks are here (we should either query a
    4865                 //  storage-specific interface from IHardDisk, or "standardize"
    4866                 //  the location property)
    4867                 hrc = curHardDisk->COMGETTER(Location)(&str);                           H();
     4863                hrc = vdiDisk->COMGETTER(FilePath)(&str);                               H();
    48684864                STR_CONV();
    48694865                rc = CFGMR3InsertString(pCur,  "Path", psz);                            RC_CHECK();
    … …  
    48784874        {
    48794875            ComPtr<IISCSIHardDisk> iSCSIDisk = hardDisk;
     4876            AssertBreak (!iSCSIDisk.isNull(), hrc = E_FAIL);
    48804877
    48814878            rc = CFGMR3InsertNode(pLunL0,   "AttachedDriver", &pLunL1);                 RC_CHECK();
    4882             rc = CFGMR3InsertString(pLunL1, "Driver",           "iSCSI");               RC_CHECK();
     4879            rc = CFGMR3InsertString(pLunL1, "Driver",         "iSCSI");                 RC_CHECK();
    48834880            rc = CFGMR3InsertNode(pLunL1,   "Config", &pCfg);                           RC_CHECK();
    48844881
    … …  
    49404937            rc = CFGMR3InsertString(pLunL2, "Driver",           "iSCSITCP");            RC_CHECK();
    49414938            /* Currently the transport driver has no config options. */
     4939        }
     4940        else if (hddType == HardDiskStorageType_VMDKImage)
     4941        {
     4942            ComPtr<IVMDKImage> vmdkDisk = hardDisk;
     4943            AssertBreak (!vmdkDisk.isNull(), hrc = E_FAIL);
     4944
     4945            rc = CFGMR3InsertNode(pLunL0,   "AttachedDriver", &pLunL1);                 RC_CHECK();
     4946            rc = CFGMR3InsertString(pLunL1, "Driver",         "VmdkHDD");               RC_CHECK();
     4947            rc = CFGMR3InsertNode(pLunL1,   "Config", &pCfg);                           RC_CHECK();
     4948            hrc = vmdkDisk->COMGETTER(FilePath)(&str);                                  H();
     4949            STR_CONV();
     4950            rc = CFGMR3InsertString(pCfg,   "Path",             psz);                   RC_CHECK();
     4951            STR_FREE();
    49424952        }
    49434953        else

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

    r953 r1015  
    10261026                                ComObjPtr <HardDisk> &hardDisk)
    10271027{
     1028    LogFlowFunc (("aLocation=\"%ls\"\n", aLocation));
     1029
    10281030    AssertReturn (aVirtualBox, E_POINTER);
    10291031
    … …  
    10401042    HardDiskStorageType_T order [2];
    10411043
    1042     if (RTPathCompare (ext, "vmdk") == 0)
     1044    if (RTPathCompare (ext, ".vmdk") == 0)
    10431045    {
    10441046        order [0] = HardDiskStorageType_VMDKImage;
    … …  
    10511053    }
    10521054
    1053     for (size_t i = 0; i < ELEMENTS (order) && SUCCEEDED (rc); ++ i)
     1055    for (size_t i = 0; i < ELEMENTS (order); ++ i)
    10541056    {
    10551057        switch (order [i])
    … …  
    10831085            default:
    10841086            {
    1085                 rc = E_FAIL;
    1086                 ComAssertComRCBreak (E_FAIL, rc = rc);
     1087                ComAssertComRCRetRC (E_FAIL);
    10871088            }
    10881089        }
    … …  
    28112812        /* we have to generate a new UUID */
    28122813        mId.create();
     2814        /* currently, all iSCSI hard disks are writethrough */
    28132815        mType = HardDiskType_WritethroughHardDisk;
    28142816        mRegistered = FALSE;
    … …  
    33333335        CheckComRCBreakRC (rc);
    33343336
     3337        if (mType != HardDiskType_WritethroughHardDisk)
     3338        {
     3339            rc = setError (E_FAIL,
     3340                tr ("Currently, non-Writethrough VMDK images are not "
     3341                    "allowed ('%ls')"),
     3342                toString().raw());
     3343            break;
     3344        }
     3345
    33353346        mState = Created;
    33363347        mRegistered = TRUE;
    … …  
    33633374                          const BSTR aFilePath, BOOL aRegistered /* = FALSE */)
    33643375{
    3365     LogFlowMember (("HVirtualDiskImage::init (aFilePath='%ls', aRegistered=%d)\n",
     3376    LogFlowMember (("HVMDKImage::init (aFilePath='%ls', aRegistered=%d)\n",
    33663377                    aFilePath, aRegistered));
    33673378
    … …  
    33713382    ComAssertRet (!isReady(), E_UNEXPECTED);
    33723383
    3373     mStorageType = HardDiskStorageType_VirtualDiskImage;
     3384    mStorageType = HardDiskStorageType_VMDKImage;
    33743385
    33753386    HRESULT rc = S_OK;
    … …  
    33853396        rc = setFilePath (aFilePath);
    33863397        CheckComRCBreakRC (rc);
     3398
     3399        /* currently, all VMDK hard disks are writethrough */
     3400        mType = HardDiskType_WritethroughHardDisk;
    33873401
    33883402        Assert (mId.isEmpty());
    … …  
    34663480
    34673481/// @todo (r=dmik) implement
    3468 
     3482//
    34693483//     if (mState >= Created)
    34703484//     {
    … …  
    34763490//                 toString().raw(), vrc);
    34773491//     }
    3478 
     3492//
    34793493//     mDescription = aDescription;
    34803494//     return S_OK;
    … …  
    34893503    CHECK_READY();
    34903504
    3491 /// @todo (r=dmik) later
    3492 
     3505/// @todo (r=dmik) will need this if we add suppord for differencing VMDKs
     3506//
    34933507//     /* only a non-differencing image knows the logical size */
    34943508//     if (isDifferencing())
    … …  
    35993613    CHECK_BUSY_AND_READERS();
    36003614
    3601     if (mRegistered)
    3602         return setError (E_ACCESSDENIED,
    3603              tr ("Cannot delete an image of the registered hard disk image '%ls"),
    3604              mFilePathFull.raw());
    3605     if (mState == NotCreated)
    3606         return setError (E_FAIL,
    3607              tr ("Hard disk image has been already deleted or never created"));
    3608 
    3609     int vrc = RTFileDelete (Utf8Str (mFilePathFull));
    3610     if (VBOX_FAILURE (vrc))
    3611         return setError (E_FAIL, tr ("Could not delete the image file '%ls' (%Vrc)"),
    3612                          mFilePathFull.raw(), vrc);
    3613 
    3614     mState = NotCreated;
    3615 
    3616     /* reset the fields */
    3617     mSize = 0;
    3618     mActualSize = 0;
    3619 
    3620     return S_OK;
     3615    return E_NOTIMPL;
     3616
     3617/// @todo (r=dmik) later
     3618// We will need to parse the file in order to delete all related delta and
     3619// sparse images etc. We may also want to obey the .vmdk.lck file
     3620// which is (as far as I understood) created when the VMware VM is
     3621// running or saved etc.
     3622//
     3623//     if (mRegistered)
     3624//         return setError (E_ACCESSDENIED,
     3625//              tr ("Cannot delete an image of the registered hard disk image '%ls"),
     3626//              mFilePathFull.raw());
     3627//     if (mState == NotCreated)
     3628//         return setError (E_FAIL,
     3629//              tr ("Hard disk image has been already deleted or never created"));
     3630//
     3631//     int vrc = RTFileDelete (Utf8Str (mFilePathFull));
     3632//     if (VBOX_FAILURE (vrc))
     3633//         return setError (E_FAIL, tr ("Could not delete the image file '%ls' (%Vrc)"),
     3634//                          mFilePathFull.raw(), vrc);
     3635//
     3636//     mState = NotCreated;
     3637//
     3638//     /* reset the fields */
     3639//     mSize = 0;
     3640//     mActualSize = 0;
     3641//
     3642//     return S_OK;
    36213643}
    36223644
    … …  
    36393661                tr ("Image file '%ls' is not yet created for this hard disk"),
    36403662                mFilePathFull.raw());
    3641 /// @todo (r=dmik) later?
     3663
     3664/// @todo (r=dmik) will need this if we add suppord for differencing VMDKs
    36423665//         if (isDifferencing())
    36433666//             return setError (E_FAIL,
    … …  
    38023825    return E_NOTIMPL;
    38033826
    3804 /// @todo (r=dmik) later?
     3827/// @todo (r=dmik) will need this if we add suppord for differencing VMDKs
    38053828//  Use code from HVirtualDiskImage::cloneToImage as an example.
    38063829}
    … …  
    38223845    return E_NOTIMPL;
    38233846
    3824 /// @todo (r=dmik) later?
     3847/// @todo (r=dmik) will need this if we add suppord for differencing VMDKs
    38253848//  Use code from HVirtualDiskImage::createDiffImage as an example.
    38263849}
    … …  
    39013924    do
    39023925    {
    3903 /// @todo (r=dmik) implement
     3926        /// @todo remove when the code below is implemented
     3927        if (mId.isEmpty())
     3928            mId.create();
     3929
     3930/// @todo  implement
    39043931//
    39053932//         /* check the image file */
    … …  
    40514078    return E_NOTIMPL;
    40524079
    4053 /// @todo (r=dmik) later?
     4080/// @todo (r=dmik) later
    40544081//  Use code from HVirtualDiskImage::createImage as an example.
    40554082}
    … …  
    40614088    return VERR_GENERAL_FAILURE;
    40624089
    4063 /// @todo (r=dmik) later?
     4090/// @todo (r=dmik) later
    40644091//  Use code from HVirtualDiskImage::vdiTaskThread as an example.
    40654092}

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

    r815 r1015  
    45894589                               bool aInformCallbacksAnyway /* = false */)
    45904590{
     4591    LogFlowThisFuncEnter();
     4592
    45914593    /// @todo (dmik) I guess we should lock all our child objects here
    45924594    //  (such as mVRDPServer etc.) to ensure they are not changed
    … …  
    48034805    }
    48044806
     4807    LogFlowThisFunc (("rc=%08X\n", rc));
     4808    LogFlowThisFuncLeave();
    48054809    return rc;
    48064810}

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

    r975 r1015  
    34923492                }
    34933493
     3494                CFGLDRGetChildNode (hdNode, "VMDKImage", 0, &storageNode);
     3495                if (storageNode)
     3496                {
     3497                    ComObjPtr <HVMDKImage> vmdk;
     3498                    vmdk.createObject();
     3499                    rc = vmdk->init (this, NULL, hdNode, storageNode);
     3500                    break;
     3501                }
     3502
    34943503                /// @todo (dmik) later
    34953504//                CFGLDRGetChildNode (hdNode, "PhysicalVolume", 0, &storageNode);
    … …  
    34993508//                }
    35003509
    3501                   ComAssertMsgFailedBreak (("No valid hard disk storage node!\n"),
    3502                                            rc = E_FAIL);
     3510                ComAssertMsgFailedBreak (("No valid hard disk storage node!\n"),
     3511                                         rc = E_FAIL);
    35033512            }
    35043513            while (0);
    … …  
    37393748            {
    37403749                CFGLDRAppendChildNode (hdNode, "ISCSIHardDisk", &storageNode);
     3750                ComAssertBreak (storageNode, rc = E_FAIL);
     3751                rc = hd->saveSettings (hdNode, storageNode);
     3752                break;
     3753            }
     3754
     3755            case HardDiskStorageType_VMDKImage:
     3756            {
     3757                CFGLDRAppendChildNode (hdNode, "VMDKImage", &storageNode);
    37413758                ComAssertBreak (storageNode, rc = E_FAIL);
    37423759                rc = hd->saveSettings (hdNode, storageNode);

  • trunk/src/VBox/Main/xml/VirtualBox-settings-common.xsd

    r922 r1015  
    212212        </xsd:complexType>
    213213      </xsd:element>
     214      <xsd:element name="VMDKImage">
     215        <xsd:complexType>
     216          <xsd:attribute name="filePath" type="TLocalFile" use="required"/>
     217        </xsd:complexType>
     218      </xsd:element>
    214219      <xsd:element name="PhysicalVolume">
    215220        <xsd:complexType>
Note: See TracChangeset for help on using the changeset viewer.

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