VirtualBox

Changeset 23598 in vbox


Ignore:
Timestamp:
Oct 7, 2009 3:00:16 PM (15 years ago)
Author:
vboxsync
Message:

VMM,Main,VBoxBFE: Split up VMR3Load into VMR3LoadFromFile and VMR3LoadFromStream; added VMR3Migrate.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/ssm.h

    r23595 r23598  
    702702    uint32_t    u32EndVersion;
    703703} SSMSTRMOPS;
    704 /** Pointer to a const SSM stream method table. */
    705 typedef SSMSTRMOPS const *PCSSMSTRMOPS;
    706704/** Struct magic + version (SSMSTRMOPS_VERSION). */
    707 #define SSMSTRMOPS_VERSION  UINT32_C(0x55aa0001)
     705#define SSMSTRMOPS_VERSION      UINT32_C(0x55aa0001)
    708706
    709707

  • trunk/include/VBox/types.h

    r23460 r23598  
    373373/** SSM Operation handle. */
    374374typedef struct SSMHANDLE *PSSMHANDLE;
     375/** Pointer to a const SSM stream method table. */
     376typedef struct SSMSTRMOPS const *PCSSMSTRMOPS;
    375377
    376378/** Pointer to a CPUMCTX. */

  • trunk/include/VBox/vmapi.h

    r23080 r23598  
    337337
    338338VMMR3DECL(int)  VMR3Save(PVM pVM, const char *pszFilename, bool fContinueAfterwards, PFNVMPROGRESS pfnProgress, void *pvUser);
    339 VMMR3DECL(int)  VMR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser);
     339VMMR3DECL(int)  VMR3Migrate(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, PFNVMPROGRESS pfnProgress, void *pvProgressUser);
     340VMMR3DECL(int)  VMR3LoadFromFile(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser);
     341VMMR3DECL(int)  VMR3LoadFromStream(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
     342                                   PFNVMPROGRESS pfnProgress, void *pvProgressUser);
    340343VMMR3DECL(int)  VMR3PowerOff(PVM pVM);
    341344VMMR3DECL(int)  VMR3Destroy(PVM pVM);

  • trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.cpp

    r23021 r23598  
    333333 * Update progress display.
    334334 */
    335 void callProgressInfo(PVM pVM, unsigned uPercent, void *pvUser)
     335int callProgressInfo(PVM pVM, unsigned uPercent, void *pvUser)
    336336{
    337337    if (gConsole)
    338338        gConsole->progressInfo(pVM, uPercent, pvUser);
     339    return VINF_SUCCESS;
    339340}
    340341
    … …  
    965966        {
    966967            /* Power off VM */
    967             rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMR3PowerOff, 1, pVM);
     968            rc = VMR3PowerOff(pVM);
    968969            AssertRC(rc);
    969970        }
    … …  
    12761277        {
    12771278            startProgressInfo("Restoring");
    1278             rc = VMR3ReqCallWait(pVM, VMCPUID_ANY,
    1279                              (PFNRT)VMR3Load, 4, pVM, g_pszStateFile, &callProgressInfo, (uintptr_t)NULL);
     1279            rc = VMR3LoadFromFile(pVM, g_pszStateFile, callProgressInfo, (uintptr_t)NULL);
    12801280            endProgressInfo();
    12811281            if (RT_SUCCESS(rc))
    12821282            {
    1283                 rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMR3Resume, 1, pVM);
     1283                rc = VMR3Resume(pVM);
    12841284                AssertRC(rc);
    12851285                gDisplay->setRunning();
    12861286            }
    12871287            else
    1288                 AssertMsgFailed(("VMR3Load failed, rc=%Rrc\n", rc));
     1288                AssertMsgFailed(("VMR3LoadFromFile failed, rc=%Rrc\n", rc));
    12891289        }
    12901290        else
    12911291        {
    1292             rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)VMR3PowerOn, 1, pVM);
     1292            rc = VMR3PowerOn(pVM);
    12931293            if (RT_FAILURE(rc))
    12941294                AssertMsgFailed(("VMR3PowerOn failed, rc=%Rrc\n", rc));

  • trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.h

    r8155 r23598  
    5555
    5656void   startProgressInfo(const char *pszStr);
    57 void   callProgressInfo(PVM pVM, unsigned uPercent, void *pvUser);
     57int    callProgressInfo(PVM pVM, unsigned uPercent, void *pvUser);
    5858void   endProgressInfo();
    5959bool   fActivateHGCM();

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

    r23567 r23598  
    10921092    AssertReturn(that, VERR_INVALID_PARAMETER);
    10931093
    1094     /* Currently, nothing to do when we've been called from VMR3Load. */
     1094    /* Currently, nothing to do when we've been called from VMR3Load*. */
    10951095    return SSMR3SkipToEndOfUnit(pSSM);
    10961096}
    … …  
    61676167
    61686168/**
    6169  * Process callback handler for VMR3Load and VMR3Save.
     6169 * Process callback handler for VMR3LoadFromFile, VMR3LoadFromStream, VMR3Save
     6170 * and VMR3Migrate.
    61706171 *
    61716172 * @param   pVM         The VM handle.
    … …  
    66896690                                 task->mSavedStateFile.raw()));
    66906691
    6691                     vrc = VMR3Load(pVM,
    6692                                    task->mSavedStateFile.c_str(),
    6693                                    Console::stateProgressCallback,
    6694                                    static_cast<VMProgressTask*>(task.get()));
     6692                    vrc = VMR3LoadFromFile(pVM,
     6693                                           task->mSavedStateFile.c_str(),
     6694                                           Console::stateProgressCallback,
     6695                                           static_cast<VMProgressTask*>(task.get()));
    66956696
    66966697                    if (RT_SUCCESS(vrc))

  • trunk/src/VBox/VMM/VM.cpp

    r23595 r23598  
    15621562
    15631563/**
    1564  * Worker for VMR3Save that validates the state and calls SSMR3Save.
     1564 * Worker for vmR3SaveMigrate that validates the state and calls SSMR3Save or
     1565 * SSMR3LiveSave.
    15651566 *
    15661567 * @returns VBox status code.
    15671568 *
    15681569 * @param   pVM             The VM handle.
    1569  * @param   pszFilename     The name of the save state file.
     1570 * @param   pszFilename     The name of the file.  NULL if pStreamOps is used.
     1571 * @param   pStreamOps      The stream methods.  NULL if pszFilename is used.
     1572 * @param   pvStreamOpsUser The user argument to the stream methods.
    15701573 * @param   enmAfter        What to do afterwards.
    15711574 * @param   pfnProgress     Progress callback. Optional.
    1572  * @param   pvUser          User argument for the progress callback.
     1575 * @param   pvProgressUser  User argument for the progress callback.
    15731576 * @param   ppSSM           Where to return the saved state handle in case of a
    15741577 *                          live snapshot scenario.
    15751578 * @thread  EMT
    15761579 */
    1577 static DECLCALLBACK(int) vmR3Save(PVM pVM, const char *pszFilename, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser, PSSMHANDLE *ppSSM)
    1578 {
    1579     LogFlow(("vmR3Save: pVM=%p pszFilename=%p:{%s} enmAfter=%d pfnProgress=%p pvUser=%p ppSSM=%p\n", pVM, pszFilename, pszFilename, enmAfter, pfnProgress, pvUser, ppSSM));
     1580static DECLCALLBACK(int) vmR3Save(PVM pVM, const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
     1581                                  SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser, PSSMHANDLE *ppSSM)
     1582{
     1583    LogFlow(("vmR3Save: pVM=%p pszFilename=%p:{%s} pStreamOps=%p pvStreamOpsUser=%p enmAfter=%d pfnProgress=%p pvProgressUser=%p ppSSM=%p\n",
     1584             pVM, pszFilename, pszFilename, pStreamOps, pvStreamOpsUser, enmAfter, pfnProgress, pvProgressUser, ppSSM));
    15801585
    15811586    /*
    … …  
    15961601    if (rc == 1)
    15971602    {
    1598         rc = SSMR3Save(pVM, pszFilename, enmAfter, pfnProgress, pvUser);
     1603        rc = SSMR3Save(pVM, pszFilename, enmAfter, pfnProgress, pvProgressUser);
    15991604        vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_SAVING);
    16001605    }
    16011606    else if (rc == 2)
    16021607    {
    1603         rc = SSMR3LiveSave(pVM, pszFilename, NULL /*pStreamOps*/, NULL /*pvStreamOpsUser*/,
    1604                            enmAfter, pfnProgress, pvUser, ppSSM);
     1608        rc = SSMR3LiveSave(pVM, pszFilename, pStreamOps, pvStreamOpsUser,
     1609                           enmAfter, pfnProgress, pvProgressUser, ppSSM);
    16051610        /* (We're not subject to cancellation just yet.) */
    16061611    }
    … …  
    16121617
    16131618/**
    1614  * Save current VM state.
    1615  *
    1616  * Can be used for both saving the state and creating snapshots.
    1617  *
    1618  * When called for a VM in the Running state, the saved state is created live
    1619  * and the VM is only suspended when the final part of the saving is preformed.
    1620  * The VM state will not be restored to Running in this case and it's up to the
    1621  * caller to call VMR3Resume if this is desirable.  (The rational is that the
    1622  * caller probably wish to reconfigure the disks before resuming the VM.)
     1619 * Commmon worker for VMR3Save and VMR3Migrate.
    16231620 *
    16241621 * @returns VBox status code.
    16251622 *
    1626  * @param   pVM                 The VM which state should be saved.
    1627  * @param   pszFilename         The name of the save state file.
    1628  * @param   fContinueAfterwards Whether continue execution afterwards or not.
    1629  *                              When in doubt, set this to true.
    1630  * @param   pfnProgress         Progress callback. Optional.
    1631  * @param   pvUser              User argument for the progress callback.
    1632  *
    1633  * @thread      Non-EMT.
    1634  * @vmstate     Suspended or Running
    1635  * @vmstateto   Saving+Suspended or
    1636  *              RunningLS+SuspeningLS+SuspendedLS+Saving+Suspended.
    1637  */
    1638 VMMR3DECL(int) VMR3Save(PVM pVM, const char *pszFilename, bool fContinueAfterwards, PFNVMPROGRESS pfnProgress, void *pvUser)
    1639 {
    1640     LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} fContinueAfterwards=%RTbool pfnProgress=%p pvUser=%p\n",
    1641              pVM, pszFilename, pszFilename, fContinueAfterwards, pfnProgress, pvUser));
    1642 
    1643     /*
    1644      * Validate input.
    1645      */
    1646     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    1647     VM_ASSERT_OTHER_THREAD(pVM);
    1648     AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
    1649     AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
    1650     AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
    1651 
     1623 * @param   pVM             The VM handle.
     1624 * @param   pszFilename     The name of the file.  NULL if pStreamOps is used.
     1625 * @param   pStreamOps      The stream methods.  NULL if pszFilename is used.
     1626 * @param   pvStreamOpsUser The user argument to the stream methods.
     1627 * @param   enmAfter        What to do afterwards.
     1628 * @param   pfnProgress     Progress callback. Optional.
     1629 * @param   pvProgressUser  User argument for the progress callback.
     1630 *
     1631 * @thread  Non-EMT
     1632 */
     1633static int vmR3SaveMigrate(PVM pVM, const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
     1634                           SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser)
     1635{
    16521636    /*
    16531637     * Request the operation in EMT(0).
    16541638     */
    1655     SSMAFTER    enmAfter = fContinueAfterwards ? SSMAFTER_CONTINUE : SSMAFTER_DESTROY;
    1656     PSSMHANDLE  pSSM;
     1639    PSSMHANDLE pSSM;
    16571640    int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/,
    1658                               (PFNRT)vmR3Save, 6, pVM, pszFilename, enmAfter, pfnProgress, pvUser, &pSSM);
     1641                              (PFNRT)vmR3Save, 8, pVM, pszFilename, pStreamOps, pvStreamOpsUser,
     1642                              enmAfter, pfnProgress, pvProgressUser, &pSSM);
    16591643    if (    RT_SUCCESS(rc)
    16601644        &&  pSSM)
    … …  
    16961680    }
    16971681
     1682    return rc;
     1683}
     1684
     1685
     1686/**
     1687 * Save current VM state.
     1688 *
     1689 * Can be used for both saving the state and creating snapshots.
     1690 *
     1691 * When called for a VM in the Running state, the saved state is created live
     1692 * and the VM is only suspended when the final part of the saving is preformed.
     1693 * The VM state will not be restored to Running in this case and it's up to the
     1694 * caller to call VMR3Resume if this is desirable.  (The rational is that the
     1695 * caller probably wish to reconfigure the disks before resuming the VM.)
     1696 *
     1697 * @returns VBox status code.
     1698 *
     1699 * @param   pVM                 The VM which state should be saved.
     1700 * @param   pszFilename         The name of the save state file.
     1701 * @param   fContinueAfterwards Whether continue execution afterwards or not.
     1702 *                              When in doubt, set this to true.
     1703 * @param   pfnProgress         Progress callback. Optional.
     1704 * @param   pvUser              User argument for the progress callback.
     1705 *
     1706 * @thread      Non-EMT.
     1707 * @vmstate     Suspended or Running
     1708 * @vmstateto   Saving+Suspended or
     1709 *              RunningLS+SuspeningLS+SuspendedLS+Saving+Suspended.
     1710 */
     1711VMMR3DECL(int) VMR3Save(PVM pVM, const char *pszFilename, bool fContinueAfterwards, PFNVMPROGRESS pfnProgress, void *pvUser)
     1712{
     1713    LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} fContinueAfterwards=%RTbool pfnProgress=%p pvUser=%p\n",
     1714             pVM, pszFilename, pszFilename, fContinueAfterwards, pfnProgress, pvUser));
     1715
     1716    /*
     1717     * Validate input.
     1718     */
     1719    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
     1720    VM_ASSERT_OTHER_THREAD(pVM);
     1721    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1722    AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
     1723    AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
     1724
     1725    /*
     1726     * Join paths with VMR3Migrate.
     1727     */
     1728    SSMAFTER enmAfter = fContinueAfterwards ? SSMAFTER_CONTINUE : SSMAFTER_DESTROY;
     1729    int rc = vmR3SaveMigrate(pVM, pszFilename, NULL /*pStreamOps*/, NULL /*pvStreamOpsUser*/,
     1730                             enmAfter, pfnProgress, pvUser);
    16981731    LogFlow(("VMR3Save: returns %Rrc\n", rc));
    16991732    return rc;
    … …  
    17021735
    17031736/**
    1704  * Loads a new VM state.
    1705  *
    1706  * To restore a saved state on VM startup, call this function and then
    1707  * resume the VM instead of powering it on.
     1737 * Migrate the VM.
    17081738 *
    17091739 * @returns VBox status code.
     1740 *
     1741 * @param   pVM                 The VM which state should be saved.
     1742 * @param   pStreamOps          The stream methods.
     1743 * @param   pvStreamOpsUser     The user argument to the stream methods.
     1744 * @param   pfnProgress         Progress callback. Optional.
     1745 * @param   pvProgressUser      User argument for the progress callback.
     1746 *
     1747 * @thread      Non-EMT.
     1748 * @vmstate     Suspended or Running
     1749 * @vmstateto   Saving+Suspended or
     1750 *              RunningLS+SuspeningLS+SuspendedLS+Saving+Suspended.
     1751 */
     1752VMMR3DECL(int) VMR3Migrate(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, PFNVMPROGRESS pfnProgress, void *pvProgressUser)
     1753{
     1754    LogFlow(("VMR3Migrate: pVM=%p pStreamOps=%p pvStreamOps=%p pfnProgress=%p pvProgressUser=%p\n",
     1755             pVM, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser));
     1756
     1757    /*
     1758     * Validate input.
     1759     */
     1760    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
     1761    VM_ASSERT_OTHER_THREAD(pVM);
     1762    AssertPtrReturn(pStreamOps, VERR_INVALID_POINTER);
     1763    AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
     1764
     1765    /*
     1766     * Join paths with VMR3Save.
     1767     */
     1768    int rc = vmR3SaveMigrate(pVM, NULL /*pszFilename*/, pStreamOps, pvStreamOpsUser,
     1769                             SSMAFTER_MIGRATE, pfnProgress, pvProgressUser);
     1770    LogFlow(("VMR3Migrate: returns %Rrc\n", rc));
     1771    return rc;
     1772}
     1773
     1774
     1775
     1776/**
     1777 * EMT(0) worker for VMR3LoadFromFile and VMR3LoadFromStream.
     1778 *
     1779 * @returns VBox status code.
     1780 *
    17101781 * @param   pVM             The VM handle.
    1711  * @param   pszFilename     The name of the save state file.
     1782 * @param   pszFilename     The name of the file.  NULL if pStreamOps is used.
     1783 * @param   pStreamOps      The stream methods.  NULL if pszFilename is used.
     1784 * @param   pvStreamOpsUser The user argument to the stream methods.
    17121785 * @param   pfnProgress     Progress callback. Optional.
    17131786 * @param   pvUser          User argument for the progress callback.
     1787 *
    17141788 * @thread  EMT.
    17151789 */
    1716 static DECLCALLBACK(int) vmR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
    1717 {
    1718     LogFlow(("vmR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
     1790static DECLCALLBACK(int) vmR3Load(PVM pVM, const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
     1791                                  PFNVMPROGRESS pfnProgress, void *pvProgressUser)
     1792{
     1793    LogFlow(("vmR3Load: pVM=%p pszFilename=%p:{%s} pStreamOps=%p pvStreamOpsUser=%p pfnProgress=%p pvProgressUser=%p\n",
     1794             pVM, pszFilename, pszFilename, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser));
    17191795
    17201796    /*
    … …  
    17221798     */
    17231799    AssertPtr(pVM);
    1724     AssertPtr(pszFilename);
     1800    AssertPtrNull(pszFilename);
     1801    AssertPtrNull(pStreamOps);
     1802    AssertPtrNull(pfnProgress);
    17251803
    17261804    /*
    … …  
    17361814        return rc;
    17371815
    1738     rc = SSMR3Load(pVM, pszFilename, NULL /*pStreamOps*/, NULL /*pStreamOpsUser*/, SSMAFTER_RESUME, pfnProgress, pvUser);
     1816    rc = SSMR3Load(pVM, pszFilename, pStreamOps, pvStreamOpsUser, SSMAFTER_RESUME, pfnProgress, pvProgressUser);
    17391817    if (RT_SUCCESS(rc))
    17401818    {
    … …  
    17711849 * @vmstateto   Loading+Suspended
    17721850 */
    1773 VMMR3DECL(int) VMR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
    1774 {
    1775     LogFlow(("VMR3Load: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n", pVM, pszFilename, pszFilename, pfnProgress, pvUser));
     1851VMMR3DECL(int) VMR3LoadFromFile(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser)
     1852{
     1853    LogFlow(("VMR3LoadFromFile: pVM=%p pszFilename=%p:{%s} pfnProgress=%p pvUser=%p\n",
     1854             pVM, pszFilename, pszFilename, pfnProgress, pvUser));
    17761855
    17771856    /*
    … …  
    17851864     * since there is no execution taking place when this call is allowed.
    17861865     */
    1787     int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/,
    1788                               (PFNRT)vmR3Load, 4, pVM, pszFilename, pfnProgress, pvUser);
    1789     LogFlow(("VMR3Load: returns %Rrc\n", rc));
     1866    int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/, (PFNRT)vmR3Load, 6,
     1867                              pVM, pszFilename, NULL /*pStreamOps*/, NULL /*pvStreamOpsUser*/, pfnProgress, pvUser);
     1868    LogFlow(("VMR3LoadFromFile: returns %Rrc\n", rc));
     1869    return rc;
     1870}
     1871
     1872
     1873/**
     1874 * VMR3LoadFromFile for arbritrary file streams.
     1875 *
     1876 * @returns VBox status code.
     1877 *
     1878 * @param   pVM             The VM handle.
     1879 * @param   pStreamOps      The stream methods.
     1880 * @param   pvStreamOpsUser The user argument to the stream methods.
     1881 * @param   pfnProgress     Progress callback. Optional.
     1882 * @param   pvProgressUser  User argument for the progress callback.
     1883 *
     1884 * @thread      Any thread.
     1885 * @vmstate     Created, Suspended
     1886 * @vmstateto   Loading+Suspended
     1887 */
     1888VMMR3DECL(int) VMR3LoadFromStream(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
     1889                                  PFNVMPROGRESS pfnProgress, void *pvProgressUser)
     1890{
     1891    LogFlow(("VMR3LoadFromStream: pVM=%p pStreamOps=%p pvStreamOpsUser=%p pfnProgress=%p pvProgressUser=%p\n",
     1892             pVM, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser));
     1893
     1894    /*
     1895     * Validate input.
     1896     */
     1897    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
     1898    AssertPtrReturn(pStreamOps, VERR_INVALID_POINTER);
     1899
     1900    /*
     1901     * Forward the request to EMT(0).  No need to setup a rendezvous here
     1902     * since there is no execution taking place when this call is allowed.
     1903     */
     1904    int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/, (PFNRT)vmR3Load, 6,
     1905                              pVM, NULL /*pszFilename*/, pStreamOps, pvStreamOpsUser, pfnProgress, pvProgressUser);
     1906    LogFlow(("VMR3LoadFromStream: returns %Rrc\n", rc));
    17901907    return rc;
    17911908}
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