VirtualBox

Changeset 22793 in vbox


Ignore:
Timestamp:
Sep 5, 2009 1:29:24 AM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
51986
Message:

SSM,*: Renamed phase to pass (uPhase/SSM_PHASE_FINAL) and wrote the remainder of the live snapshot / migration SSM code.

Location:
trunk
Files:
46 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/err.h

    r22792 r22793  
    571571/** Vote for giving up.  */
    572572#define VERR_SSM_VOTE_FOR_GIVING_UP             (-1852)
     573/** Giving up a live snapshot/migration attempt because of too many passes. */
     574#define VERR_SSM_TOO_MANY_PASSES                (-1853)
     575/** Giving up a live snapshot/migration attempt because the state grew to
     576 * big. */
     577#define VERR_SSM_STATE_GREW_TOO_BIG             (-1854)
     578/** Giving up a live snapshot attempt because we're low on disk space.  */
     579#define VERR_SSM_LOW_ON_DISK_SPACE              (-1855)
    573580/** @} */
    574581

  • trunk/include/VBox/ssm.h

    r22792 r22793  
    6060#define SSM_VERSION_MAJOR_CHANGED(ver1,ver2)    (SSM_VERSION_MAJOR(ver1) != SSM_VERSION_MAJOR(ver2))
    6161
    62 /** The special value for the final phase.  */
    63 #define SSM_PHASE_FINAL                         UINT32_MAX
     62/** The special value for the final pass.  */
     63#define SSM_PASS_FINAL                          UINT32_MAX
    6464
    6565
    … …  
    154154 * @param   pDevIns         Device instance of the device which registered the data unit.
    155155 * @param   pSSM            SSM operation handle.
    156  * @param   uPhase          The phase.
    157  * @thread  Any.
    158  */
    159 typedef DECLCALLBACK(int) FNSSMDEVLIVEEXEC(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPhase);
     156 * @param   uPass           The pass.
     157 * @thread  Any.
     158 */
     159typedef DECLCALLBACK(int) FNSSMDEVLIVEEXEC(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass);
    160160/** Pointer to a FNSSMDEVLIVEEXEC() function. */
    161161typedef FNSSMDEVLIVEEXEC *PFNSSMDEVLIVEEXEC;
    … …  
    231231 * @param   pSSM            SSM operation handle.
    232232 * @param   uVersion        Data layout version.
    233  * @param   uPhase          The phase. This is always SSM_PHASE_FINAL for units
     233 * @param   uPass           The pass. This is always SSM_PASS_FINAL for units
    234234 *                          that doesn't specify a pfnSaveLive callback.
    235235 */
    236 typedef DECLCALLBACK(int) FNSSMDEVLOADEXEC(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     236typedef DECLCALLBACK(int) FNSSMDEVLOADEXEC(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    237237/** Pointer to a FNSSMDEVLOADEXEC() function. */
    238238typedef FNSSMDEVLOADEXEC *PFNSSMDEVLOADEXEC;
    … …  
    279279 *                          data unit.
    280280 * @param   pSSM            SSM operation handle.
    281  * @param   uPhase          The phase.
    282  * @thread  Any.
    283  */
    284 typedef DECLCALLBACK(int) FNSSMDRVLIVEEXEC(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uPhase);
     281 * @param   uPass           The data pass.
     282 * @thread  Any.
     283 */
     284typedef DECLCALLBACK(int) FNSSMDRVLIVEEXEC(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uPass);
    285285/** Pointer to a FNSSMDRVLIVEEXEC() function. */
    286286typedef FNSSMDRVLIVEEXEC *PFNSSMDRVLIVEEXEC;
    … …  
    358358 * @param   pSSM            SSM operation handle.
    359359 * @param   uVersion        Data layout version.
    360  * @param   uPhase          The phase. This is always SSM_PHASE_FINAL for units
     360 * @param   uPass           The pass. This is always SSM_PASS_FINAL for units
    361361 *                          that doesn't specify a pfnSaveLive callback.
    362362 */
    363 typedef DECLCALLBACK(int) FNSSMDRVLOADEXEC(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     363typedef DECLCALLBACK(int) FNSSMDRVLOADEXEC(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    364364/** Pointer to a FNSSMDRVLOADEXEC() function. */
    365365typedef FNSSMDRVLOADEXEC *PFNSSMDRVLOADEXEC;
    … …  
    405405 * @param   pVM             VM Handle.
    406406 * @param   pSSM            SSM operation handle.
    407  * @param   uPhase          The phase.
    408  * @thread  Any.
    409  */
    410 typedef DECLCALLBACK(int) FNSSMINTLIVEEXEC(PVM pVM, PSSMHANDLE pSSM, uint32_t uPhase);
     407 * @param   uPass           The data pass.
     408 * @thread  Any.
     409 */
     410typedef DECLCALLBACK(int) FNSSMINTLIVEEXEC(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass);
    411411/** Pointer to a FNSSMINTLIVEEXEC() function. */
    412412typedef FNSSMINTLIVEEXEC *PFNSSMINTLIVEEXEC;
    … …  
    482482 * @param   pSSM            SSM operation handle.
    483483 * @param   uVersion        Data layout version.
    484  * @param   uPhase          The phase. This is always SSM_PHASE_FINAL for units
     484 * @param   uPass           The pass. This is always SSM_PASS_FINAL for units
    485485 *                          that doesn't specify a pfnSaveLive callback.
    486486 */
    487 typedef DECLCALLBACK(int) FNSSMINTLOADEXEC(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     487typedef DECLCALLBACK(int) FNSSMINTLOADEXEC(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    488488/** Pointer to a FNSSMINTLOADEXEC() function. */
    489489typedef FNSSMINTLOADEXEC *PFNSSMINTLOADEXEC;
    … …  
    528528 * @param   pSSM            SSM operation handle.
    529529 * @param   pvUser          User argument.
    530  * @param   uPhase          The phase.
    531  * @thread  Any.
    532  */
    533 typedef DECLCALLBACK(int) FNSSMEXTLIVEEXEC(PSSMHANDLE pSSM, void *pvUser, uint32_t uPhase);
     530 * @param   uPass           The data pass.
     531 * @thread  Any.
     532 */
     533typedef DECLCALLBACK(int) FNSSMEXTLIVEEXEC(PSSMHANDLE pSSM, void *pvUser, uint32_t uPass);
    534534/** Pointer to a FNSSMEXTLIVEEXEC() function. */
    535535typedef FNSSMEXTLIVEEXEC *PFNSSMEXTLIVEEXEC;
    … …  
    601601 * @param   pvUser          User argument.
    602602 * @param   uVersion        Data layout version.
    603  * @param   uPhase          The phase. This is always SSM_PHASE_FINAL for units
     603 * @param   uPass           The pass. This is always SSM_PASS_FINAL for units
    604604 *                          that doesn't specify a pfnSaveLive callback.
    605605 * @remark  The odd return value is for legacy reasons.
    606606 */
    607 typedef DECLCALLBACK(int) FNSSMEXTLOADEXEC(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPhase);
     607typedef DECLCALLBACK(int) FNSSMEXTLOADEXEC(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
    608608/** Pointer to a FNSSMEXTLOADEXEC() function. */
    609609typedef FNSSMEXTLOADEXEC *PFNSSMEXTLOADEXEC;

  • trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

    r22480 r22793  
    14591459 * @param   pSSMHandle  The handle to the saved state.
    14601460 * @param   uVersion    The data unit version number.
    1461  * @param   uPhase      The data phase.
     1461 * @param   uPass       The data pass.
    14621462 */
    14631463static DECLCALLBACK(int) ichac97LoadExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle,
    1464                                           uint32_t uVersion, uint32_t uPhase)
     1464                                          uint32_t uVersion, uint32_t uPass)
    14651465{
    14661466    PCIAC97LinkState *pThis = PDMINS_2_DATA(pDevIns, PCIAC97LinkState *);
    … …  
    14701470
    14711471    AssertMsgReturn (uVersion == AC97_SSM_VERSION, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    1472     Assert (uPhase == SSM_PHASE_FINAL); NOREF (uPhase);
     1472    Assert (uPass == SSM_PASS_FINAL); NOREF(uPass);
    14731473
    14741474    SSMR3GetU32 (pSSMHandle, &s->glob_cnt);

  • trunk/src/VBox/Devices/Audio/DevSB16.cpp

    r22480 r22793  
    15511551#else  /* VBOX */
    15521552static DECLCALLBACK(int) sb16LoadExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle,
    1553                                        uint32_t uVersion, uint32_t uPhase)
     1553                                       uint32_t uVersion, uint32_t uPass)
    15541554{
    15551555    SB16State *s = PDMINS_2_DATA (pDevIns, SB16State *);
    … …  
    15571557
    15581558    AssertMsgReturn(uVersion == SB16_SSM_VERSION, ("%d\n", uVersion),  VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    1559     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     1559    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    15601560#endif /* VBOX */
    15611561

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r22493 r22793  
    15281528 * @param   pSSMHandle  The handle to the saved state.
    15291529 * @param   uVersion    The data unit version number.
    1530  * @param   uPhase      The data phase.
    1531  */
    1532 static DECLCALLBACK(int) pciR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     1530 * @param   uPass       The data pass.
     1531 */
     1532static DECLCALLBACK(int) pciR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    15331533{
    15341534    PPCIGLOBALS pThis = PDMINS_2_DATA(pDevIns, PPCIGLOBALS);
    … …  
    15431543    if (uVersion > VBOX_PCI_SAVED_STATE_VERSION)
    15441544        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    1545     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     1545    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    15461546
    15471547    /*
    … …  
    23322332 * @param   pSSMHandle  The handle to the saved state.
    23332333 * @param   uVersion    The data unit version number.
    2334  * @param   uPhase      The data phase.
    2335  */
    2336 static DECLCALLBACK(int) pcibridgeR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     2334 * @param   uPass       The data pass.
     2335 */
     2336static DECLCALLBACK(int) pcibridgeR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    23372337{
    23382338    PPCIBUS     pBus  = PDMINS_2_DATA(pDevIns, PPCIBUS);
    … …  
    23482348    if (uVersion > VBOX_PCI_SAVED_STATE_VERSION)
    23492349        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    2350     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2350    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    23512351
    23522352    /*

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r22584 r22793  
    53735373 * @param   pSSMHandle  The handle to the saved state.
    53745374 * @param   uVersion    The data unit version number.
    5375  * @param   uPhase      The data phase.
     5375 * @param   uPass       The data pass.
    53765376 */
    5377 static DECLCALLBACK(int) vgaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
    5378 {
    5379     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     5377static DECLCALLBACK(int) vgaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
     5378{
     5379    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    53805380    int rc = vga_load(pSSMHandle, PDMINS_2_DATA(pDevIns, PVGASTATE), uVersion);
    53815381    if (RT_FAILURE(rc))

  • trunk/src/VBox/Devices/Input/DevPS2.cpp

    r22584 r22793  
    14291429 * @param   pSSMHandle  The handle to the saved state.
    14301430 * @param   uVersion    The data unit version number.
    1431  * @param   uPhase      The data phase.
     1431 * @param   uPass       The data pass.
    14321432 */
    1433 static DECLCALLBACK(int) kbdLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
    1434 {
    1435     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     1433static DECLCALLBACK(int) kbdLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
     1434{
     1435    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    14361436    return kbd_load(pSSMHandle, PDMINS_2_DATA(pDevIns, KBDState *), uVersion);
    14371437}

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r22587 r22793  
    44764476 * @param   pSSMHandle  The handle to the saved state.
    44774477 * @param   uVersion    The data unit version number.
    4478  * @param   uPhase      The data phase.
    4479  */
    4480 static DECLCALLBACK(int) e1kLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     4478 * @param   uPass           The data pass.
     4479 */
     4480static DECLCALLBACK(int) e1kLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    44814481{
    44824482    if (uVersion != E1K_SAVEDSTATE_VERSION)
    44834483        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    4484     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     4484    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    44854485
    44864486    E1KSTATE* pState = PDMINS_2_DATA(pDevIns, E1KSTATE*);

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r22585 r22793  
    43314331 * @param   pSSMHandle  The handle to the saved state.
    43324332 * @param   uVersion  The data unit version number.
    4333  * @param   uPhase      The data phase.
    4334  */
    4335 static DECLCALLBACK(int) pcnetLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     4333 * @param   uPass       The data pass.
     4334 */
     4335static DECLCALLBACK(int) pcnetLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    43364336{
    43374337    PCNetState *pThis = PDMINS_2_DATA(pDevIns, PCNetState *);
    … …  
    43404340        || SSM_VERSION_MINOR(uVersion) < 7)
    43414341        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    4342     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     4342    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    43434343
    43444344    /* restore data */

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r22480 r22793  
    17741774
    17751775static DECLCALLBACK(int) acpi_load_state(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle,
    1776                                          uint32_t uVersion, uint32_t uPhase)
     1776                                         uint32_t uVersion, uint32_t uPass)
    17771777{
    17781778    ACPIState *s = PDMINS_2_DATA(pDevIns, ACPIState *);
    17791779
    1780     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
    1781 
     1780
     1781    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    17821782    /*
    17831783     * Unregister PM handlers, will register with actual base

  • trunk/src/VBox/Devices/PC/DevAPIC.cpp

    r22584 r22793  
    23572357 * @copydoc FNSSMDEVLOADEXEC
    23582358 */
    2359 static DECLCALLBACK(int) apicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     2359static DECLCALLBACK(int) apicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    23602360{
    23612361    APICDeviceInfo *dev = PDMINS_2_DATA(pDevIns, APICDeviceInfo *);
    2362     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2362    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    23632363
    23642364    /* load all APICs data */ /** @todo: is it correct? */
    … …  
    28082808 * @copydoc FNSSMDEVLOADEXEC
    28092809 */
    2810 static DECLCALLBACK(int) ioapicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     2810static DECLCALLBACK(int) ioapicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    28112811{
    28122812    IOAPICState *s = PDMINS_2_DATA(pDevIns, IOAPICState *);
    … …  
    28162816        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    28172817    }
    2818     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2818    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    28192819
    28202820    return VINF_SUCCESS;

  • trunk/src/VBox/Devices/PC/DevDMA.cpp

    r22480 r22793  
    864864                                      PSSMHANDLE pSSMHandle,
    865865                                      uint32_t uVersion,
    866                                       uint32_t uPhase)
     866                                      uint32_t uPass)
    867867{
    868868    DMAState *s = PDMINS_2_DATA (pDevIns, DMAState *);
    869869
    870870    AssertMsgReturn (uVersion == 1, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    871     Assert (uPhase == SSM_PHASE_FINAL);
     871    Assert (uPass == SSM_PASS_FINAL); NOREF(uPass);
    872872
    873873    dma_load (pSSMHandle, &s->dma_controllers[0], uVersion);

  • trunk/src/VBox/Devices/PC/DevPIC.cpp

    r22480 r22793  
    829829 * @param   pSSMHandle  The handle to the saved state.
    830830 * @param   uVersion    The data unit version number.
    831  * @param   uPhase      The data phase.
    832  */
    833 static DECLCALLBACK(int) picLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     831 * @param   uPass       The data pass.
     832 */
     833static DECLCALLBACK(int) picLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    834834{
    835835    PDEVPIC pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
    … …  
    837837    if (uVersion != 1)
    838838        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    839     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     839    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    840840
    841841    for (unsigned i = 0; i < RT_ELEMENTS(pThis->aPics); i++)

  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r22480 r22793  
    760760 * @param   pSSMHandle  The handle to the saved state.
    761761 * @param   uVersion    The data unit version number.
    762  * @param   uPhase      The data phase.
    763  */
    764 static DECLCALLBACK(int) pitLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     762 * @param   uPass       The data pass.
     763 */
     764static DECLCALLBACK(int) pitLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    765765{
    766766    PITState *pThis = PDMINS_2_DATA(pDevIns, PITState *);
    … …  
    768768    if (uVersion != PIT_SAVED_STATE_VERSION)
    769769        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    770     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     770    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    771771
    772772    for (unsigned i = 0; i < RT_ELEMENTS(pThis->channels); i++)

  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r22480 r22793  
    629629 * @param   pSSMHandle  The handle to the saved state.
    630630 * @param   uVersion    The data unit version number.
    631  * @param   uPhase      The data phase.
    632  */
    633 static DECLCALLBACK(int) rtcLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     631 * @param   uPass       The data pass.
     632 */
     633static DECLCALLBACK(int) rtcLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    634634{
    635635    RTCState *pThis = PDMINS_2_DATA(pDevIns, RTCState *);
    … …  
    637637    if (uVersion != 1)
    638638        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    639     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     639    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    640640
    641641    SSMR3GetMem(pSSMHandle, pThis->cmos_data, 128);

  • trunk/src/VBox/Devices/Parallel/DevParallel.cpp

    r22480 r22793  
    588588 * @param   pSSMHandle  The handle to the saved state.
    589589 * @param   uVersion    The data unit version number.
    590  * @param   uPhase      The data phase.
     590 * @param   uPass       The data pass.
    591591 */
    592592static DECLCALLBACK(int) parallelLoadExec(PPDMDEVINS pDevIns,
    593593                                          PSSMHANDLE pSSMHandle,
    594594                                          uint32_t uVersion,
    595                                           uint32_t uPhase)
     595                                          uint32_t uPass)
    596596{
    597597    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
    598598
    599599    AssertMsgReturn(uVersion == PARALLEL_SAVED_STATE_VERSION, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    600     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     600    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    601601
    602602    SSMR3GetU8(pSSMHandle, &pThis->reg_data);

  • trunk/src/VBox/Devices/Serial/DevSerial.cpp

    r22584 r22793  
    599599 * @param   pSSMHandle  The handle to the saved state.
    600600 * @param   uVersion    The data unit version number.
    601  * @param   uPhase      The data phase.
     601 * @param   uPass       The data pass.
    602602 */
    603603static DECLCALLBACK(int) serialLoadExec(PPDMDEVINS pDevIns,
    604604                                        PSSMHANDLE pSSMHandle,
    605605                                        uint32_t uVersion,
    606                                         uint32_t uPhase)
     606                                        uint32_t uPass)
    607607{
    608608    SerialState *pThis = PDMINS_2_DATA(pDevIns, SerialState *);
    609609
    610     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     610    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    611611    AssertMsgReturn(uVersion == SERIAL_SAVED_STATE_VERSION, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    612612

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r22731 r22793  
    59555955 * @param   pSSMHandle  The handle to the saved state.
    59565956 * @param   uVersion  The data unit version number.
    5957  * @param   uPhase      The data phase.
    5958  */
    5959 static DECLCALLBACK(int) ahciLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     5957 * @param   uPass           The data pass.
     5958 */
     5959static DECLCALLBACK(int) ahciLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    59605960{
    59615961    PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
    … …  
    59655965    if (uVersion != AHCI_SAVED_STATE_VERSION)
    59665966        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    5967     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     5967    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    59685968
    59695969    /* Restore data. */

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r22480 r22793  
    61056105 * @param   pDevIns     The device instance.
    61066106 * @param   pSSMHandle  The handle to the saved state.
    6107  * @param   uVersion  The data unit version number.
    6108  * @param   uPhase      The data phase.
     6107 * @param   uVersion    The data unit version number.
     6108 * @param   uPass       The data pass.
    61096109 */
    6110 static DECLCALLBACK(int) ataLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     6110static DECLCALLBACK(int) ataLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    61116111{
    61126112    PCIATAState    *pThis = PDMINS_2_DATA(pDevIns, PCIATAState *);
    … …  
    61226122        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    61236123    }
    6124     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     6124    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    61256125
    61266126    /*

  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r22480 r22793  
    23652365}
    23662366
    2367 static DECLCALLBACK(int) buslogicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     2367static DECLCALLBACK(int) buslogicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    23682368{
    23692369    PBUSLOGIC pBusLogic = PDMINS_2_DATA(pDevIns, PBUSLOGIC);
    … …  
    23722372    if (uVersion > BUSLOGIC_SAVED_STATE_MINOR_VERSION)
    23732373        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    2374     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2374    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    23752375
    23762376    /* Every device first. */

  • trunk/src/VBox/Devices/Storage/DevLsiLogicSCSI.cpp

    r22480 r22793  
    48964896}
    48974897
    4898 static DECLCALLBACK(int) lsilogicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     4898static DECLCALLBACK(int) lsilogicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    48994899{
    49004900    PLSILOGICSCSI pLsiLogic = PDMINS_2_DATA(pDevIns, PLSILOGICSCSI);
    … …  
    49034903    if (uVersion > LSILOGIC_SAVED_STATE_MINOR_VERSION)
    49044904        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    4905     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     4905    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    49064906
    49074907    /* Every device first. */

  • trunk/src/VBox/Devices/Storage/fdc.c

    r22480 r22793  
    24322432                                      PSSMHANDLE pSSMHandle,
    24332433                                      uint32_t uVersion,
    2434                                       uint32_t uPhase)
     2434                                      uint32_t uPass)
    24352435{
    24362436    fdctrl_t *s = PDMINS_2_DATA (pDevIns, fdctrl_t *);
    … …  
    24392439
    24402440    AssertMsgReturn(uVersion == 1, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    2441     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2441    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    24422442
    24432443    qemu_get_8s (f, &s->version);

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r22704 r22793  
    21612161 * @param   pSSMHandle  The handle to the saved state.
    21622162 * @param   uVersion    The data unit version number.
    2163  * @param   uPhase      The data phase.
     2163 * @param   uPass       The data pass.
    21642164 */
    2165 static DECLCALLBACK(int) vmmdevLoadState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPhase)
     2165static DECLCALLBACK(int) vmmdevLoadState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
    21662166{
    21672167    /** @todo The code load code is assuming we're always loaded into a freshly
    … …  
    21712171        || (SSM_VERSION_MINOR(uVersion) < 6))
    21722172        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    2173     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2173    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    21742174
    21752175    SSMR3GetU32(pSSMHandle, &pThis->hypervisorSize);

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

    r22480 r22793  
    318318 * @param   pSSM            SSM operation handle.
    319319 * @param   uVersion        Data layout version.
    320  * @param   uPhase          The data phase.
    321  */
    322 static DECLCALLBACK(int) iface_hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     320 * @param   uPass           The data pass.
     321 */
     322static DECLCALLBACK(int) iface_hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    323323{
    324324    LogFlowFunc(("Enter\n"));
    … …  
    326326    if (uVersion != HGCM_SSM_VERSION)
    327327        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    328     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     328    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    329329
    330330    return HGCMHostLoadState (pSSM);

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBQGL.cpp

    r22776 r22793  
    40454045}
    40464046
    4047 static DECLCALLBACK(int) vboxQGLLoadExec(PSSMHANDLE pSSM, void *pvUser, uint32_t u32Version, uint32_t uPhase)
    4048 {
    4049     Q_UNUSED(uPhase);
     4047static DECLCALLBACK(int) vboxQGLLoadExec(PSSMHANDLE pSSM, void *pvUser, uint32_t u32Version, uint32_t uPass)
     4048{
     4049    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    40504050    VBoxGLWidget * pw = (VBoxGLWidget*)pvUser;
    40514051    return pw->vhwaLoadExec(pSSM, u32Version);
    … …  
    42854285{
    42864286    Q_UNUSED(u32Version);
    4287    
     4287
    42884288    VBOXQGL_LOAD_OVERLAYSTART(pSSM);
    42894289

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

    r22784 r22793  
    10571057 *  @param uVersion     Console unit version.
    10581058 *                      Should match sSSMConsoleVer.
    1059  *  @param uPhase       The data phase.
     1059 *  @param uPass        The data pass.
    10601060 *
    10611061 *  @note Should locks the Console object for writing, if necessary.
    … …  
    10631063//static
    10641064DECLCALLBACK(int)
    1065 Console::loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPhase)
     1065Console::loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
    10661066{
    10671067    LogFlowFunc (("\n"));
    … …  
    10691069    if (SSM_VERSION_MAJOR_CHANGED(uVersion, sSSMConsoleVer))
    10701070        return VERR_VERSION_MISMATCH;
    1071     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     1071    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    10721072
    10731073    Console *that = static_cast<Console *>(pvUser);

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

    r22480 r22793  
    130130
    131131DECLCALLBACK(int)
    132 Display::displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPhase)
     132Display::displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
    133133{
    134134    Display *that = static_cast<Display*>(pvUser);
    … …  
    136136    if (uVersion != sSSMDisplayVer)
    137137        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
     138    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    138139
    139140    uint32_t cMonitors;

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

    r22480 r22793  
    602602 * @param   pSSM            SSM operation handle.
    603603 * @param   uVersion        Data layout version.
    604  * @param   uPhase          The data phase.
    605  */
    606 static DECLCALLBACK(int) iface_hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     604 * @param   uPass           The data pass.
     605 */
     606static DECLCALLBACK(int) iface_hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    607607{
    608608    LogFlowFunc(("Enter\n"));
    … …  
    610610    if (uVersion != HGCM_SSM_VERSION)
    611611        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    612     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     612    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    613613
    614614    return HGCMHostLoadState (pSSM);

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

    r22560 r22793  
    501501
    502502    static DECLCALLBACK(void)   saveStateFileExec (PSSMHANDLE pSSM, void *pvUser);
    503     static DECLCALLBACK(int)    loadStateFileExec (PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPhase);
     503    static DECLCALLBACK(int)    loadStateFileExec (PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
    504504
    505505#ifdef VBOX_WITH_GUEST_PROPS

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

    r22480 r22793  
    292292
    293293    static DECLCALLBACK(void)   displaySSMSave(PSSMHANDLE pSSM, void *pvUser);
    294     static DECLCALLBACK(int)    displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPhase);
     294    static DECLCALLBACK(int)    displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
    295295
    296296    const ComObjPtr<Console, ComWeakRef> mParent;

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

    r22480 r22793  
    100100static int cpumR3CpuIdInit(PVM pVM);
    101101static DECLCALLBACK(int)  cpumR3Save(PVM pVM, PSSMHANDLE pSSM);
    102 static DECLCALLBACK(int)  cpumR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     102static DECLCALLBACK(int)  cpumR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    103103static DECLCALLBACK(void) cpumR3InfoAll(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    104104static DECLCALLBACK(void) cpumR3InfoGuest(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    … …  
    992992 * @param   pSSM            SSM operation handle.
    993993 * @param   uVersion        Data layout version.
    994  */
    995 static DECLCALLBACK(int) cpumR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
    996 {
    997     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     994 * @param   uPass           The data pass.
     995 */
     996static DECLCALLBACK(int) cpumR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     997{
     998    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    998999
    9991000    /*

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

    r22480 r22793  
    8484*******************************************************************************/
    8585static DECLCALLBACK(int) emR3Save(PVM pVM, PSSMHANDLE pSSM);
    86 static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     86static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    8787static int emR3Debug(PVM pVM, PVMCPU pVCpu, int rc);
    8888static int emR3RemStep(PVM pVM, PVMCPU pVCpu);
    … …  
    518518 * @param   pSSM            SSM operation handle.
    519519 * @param   uVersion        Data layout version.
    520  * @param   uPhase          The data phase.
    521  */
    522 static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     520 * @param   uPass           The data pass.
     521 */
     522static DECLCALLBACK(int) emR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    523523{
    524524    /*
    … …  
    531531        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    532532    }
     533    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    533534
    534535    /*

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

    r22681 r22793  
    270270*******************************************************************************/
    271271static DECLCALLBACK(int) hwaccmR3Save(PVM pVM, PSSMHANDLE pSSM);
    272 static DECLCALLBACK(int) hwaccmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     272static DECLCALLBACK(int) hwaccmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    273273
    274274
    … …  
    24442444 * @param   pSSM            SSM operation handle.
    24452445 * @param   uVersion        Data layout version.
    2446  * @param   uPhase          The data phase.
    2447  */
    2448 static DECLCALLBACK(int) hwaccmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     2446 * @param   uPass           The data pass.
     2447 */
     2448static DECLCALLBACK(int) hwaccmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    24492449{
    24502450    int rc;
    24512451
    24522452    Log(("hwaccmR3Load:\n"));
    2453     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     2453    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    24542454
    24552455    /*

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

    r22480 r22793  
    177177*******************************************************************************/
    178178static DECLCALLBACK(int) mmR3Save(PVM pVM, PSSMHANDLE pSSM);
    179 static DECLCALLBACK(int) mmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     179static DECLCALLBACK(int) mmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    180180
    181181
    … …  
    530530 * @param   pSSM            SSM operation handle.
    531531 * @param   uVersion       Data layout version.
    532  * @param   uPhase          The data phase.
    533  */
    534 static DECLCALLBACK(int) mmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     532 * @param   uPass           The data pass.
     533 */
     534static DECLCALLBACK(int) mmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    535535{
    536536    LogFlow(("mmR3Load:\n"));
    537     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     537    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    538538
    539539    /*

  • trunk/src/VBox/VMM/PATM/CSAM.cpp

    r22480 r22793  
    7070*******************************************************************************/
    7171static DECLCALLBACK(int) csamr3Save(PVM pVM, PSSMHANDLE pSSM);
    72 static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     72static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    7373static DECLCALLBACK(int) CSAMCodePageWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
    7474static DECLCALLBACK(int) CSAMCodePageInvalidate(PVM pVM, RTGCPTR GCPtr);
    … …  
    442442 * @param   pSSM            SSM operation handle.
    443443 * @param   uVersion        Data layout version.
    444  * @param   uPhase          The data phase.
    445  */
    446 static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     444 * @param   uPass           The data pass.
     445 */
     446static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    447447{
    448448    int  rc;
    449449    CSAM csamInfo;
    450450
    451     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     451    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    452452    if (uVersion != CSAM_SSM_VERSION)
    453453    {

  • trunk/src/VBox/VMM/PATM/PATMInternal.h

    r22480 r22793  
    528528
    529529DECLCALLBACK(int) patmR3Save(PVM pVM, PSSMHANDLE pSSM);
    530 DECLCALLBACK(int) patmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     530DECLCALLBACK(int) patmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    531531
    532532#ifdef IN_RING3

  • trunk/src/VBox/VMM/PATM/PATMSSM.cpp

    r22480 r22793  
    300300 * @param   pSSM            SSM operation handle.
    301301 * @param   uVersion        Data layout version.
    302  * @param   uPhase          The data phase.
     302 * @param   uPass           The data pass.
    303303 */
    304 DECLCALLBACK(int) patmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     304DECLCALLBACK(int) patmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    305305{
    306306    PATM patmInfo;
    … …  
    319319        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    320320    }
     321    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    321322
    322323    pVM->patm.s.savedstate.pSSM = pSSM;

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

    r22480 r22793  
    288288*******************************************************************************/
    289289static DECLCALLBACK(int) pdmR3Save(PVM pVM, PSSMHANDLE pSSM);
    290 static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     290static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    291291static DECLCALLBACK(int) pdmR3LoadPrep(PVM pVM, PSSMHANDLE pSSM);
    292292
    … …  
    719719 * @param   pSSM            SSM operation handle.
    720720 * @param   uVersion        Data layout version.
    721  * @param   uPhase          The data phase.
    722  */
    723 static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     721 * @param   uPass           The data pass.
     722 */
     723static DECLCALLBACK(int) pdmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    724724{
    725725    int rc;
    726726
    727727    LogFlow(("pdmR3Load:\n"));
    728     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     728    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    729729
    730730    /*

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

    r22716 r22793  
    632632#endif
    633633static DECLCALLBACK(int)  pgmR3Save(PVM pVM, PSSMHANDLE pSSM);
    634 static DECLCALLBACK(int)  pgmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     634static DECLCALLBACK(int)  pgmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    635635static int                pgmR3ModeDataInit(PVM pVM, bool fResolveGCAndR0);
    636636static void               pgmR3ModeDataSwitch(PVM pVM, PVMCPU pVCpu, PGMMODE enmShw, PGMMODE enmGst);
    … …  
    30293029 * @param   pSSM            SSM operation handle.
    30303030 * @param   uVersion        Data layout version.
    3031  * @param   uPhase          The data phase.
    3032  */
    3033 static DECLCALLBACK(int) pgmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     3031 * @param   uPass           The data pass.
     3032 */
     3033static DECLCALLBACK(int) pgmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    30343034{
    30353035    int     rc;
    30363036    PPGM    pPGM = &pVM->pgm.s;
    3037     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     3037    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    30383038
    30393039    /*

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

    r22480 r22793  
    112112*******************************************************************************/
    113113static DECLCALLBACK(int)  selmR3Save(PVM pVM, PSSMHANDLE pSSM);
    114 static DECLCALLBACK(int)  selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     114static DECLCALLBACK(int)  selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    115115static DECLCALLBACK(int)  selmR3LoadDone(PVM pVM, PSSMHANDLE pSSM);
    116116static DECLCALLBACK(int)  selmR3GuestGDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
    … …  
    697697 * @param   pSSM            SSM operation handle.
    698698 * @param   uVersion        Data layout version.
    699  * @param   uPhase          The data phase.
    700  */
    701 static DECLCALLBACK(int) selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     699 * @param   uPass           The data pass.
     700 */
     701static DECLCALLBACK(int) selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    702702{
    703703    LogFlow(("selmR3Load:\n"));
    704     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     704    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    705705
    706706    /*

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

    r22792 r22793  
    5353 * is executed on a dedicated thread running at at the same priority as the EMTs
    5454 * so that the saving doesn't starve or lose in scheduling questions.  The final
    55  * phase is done on EMT(0).
     55 * pass is done on EMT(0).
    5656 *
    5757 * There are a couple of common reasons why LS and LM will fail:
    … …  
    8383 * The stream format starts with a header (SSMFILEHDR) that indicates the
    8484 * version and such things, it is followed by zero or more saved state units
    85  * (name + instance + phase), and the stream concludes with a footer
     85 * (name + instance + pass), and the stream concludes with a footer
    8686 * (SSMFILEFTR) that contains unit counts and optionally a checksum for the
    8787 * entire file.  (In version 1.2 and earlier, the checksum was in the header and
    … …  
    9090 *
    9191 * The saved state units each starts with a variable sized header
    92  * (SSMFILEUNITHDRV2) that contains the name, instance and phase.  The data
     92 * (SSMFILEUNITHDRV2) that contains the name, instance and pass.  The data
    9393 * follows the header and is encoded as records with a 2-8 byte record header
    9494 * indicating the type, flags and size.  The first byte in the record header
    … …  
    296296    SSMSTATE_INVALID = 0,
    297297    SSMSTATE_LIVE_PREP,
     298    SSMSTATE_LIVE_STEP1,
    298299    SSMSTATE_LIVE_EXEC,
    299300    SSMSTATE_LIVE_VOTE,
     301    SSMSTATE_LIVE_STEP2,
    300302    SSMSTATE_SAVE_PREP,
    301303    SSMSTATE_SAVE_EXEC,
    … …  
    638640    /** Instance number. */
    639641    uint32_t        u32Instance;
    640     /** Data phase number. */
    641     uint32_t        u32Phase;
     642    /** Data pass number. */
     643    uint32_t        u32Pass;
    642644    /** Flags reserved for future extensions. Must be zero. */
    643645    uint32_t        fFlags;
    … …  
    720722
    721723/**
    722  * Directory for the data units from the final phase.
     724 * Directory for the data units from the final pass.
    723725 *
    724726 * This is used to speed up SSMR3Seek (it would have to decompress and parse the
    … …  
    775777*******************************************************************************/
    776778static int                  ssmR3LazyInit(PVM pVM);
    777 static DECLCALLBACK(int)    ssmR3SelfLiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPhase);
     779static DECLCALLBACK(int)    ssmR3SelfLiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass);
    778780static DECLCALLBACK(int)    ssmR3SelfSaveExec(PVM pVM, PSSMHANDLE pSSM);
    779 static DECLCALLBACK(int)    ssmR3SelfLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     781static DECLCALLBACK(int)    ssmR3SelfLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    780782static int                  ssmR3Register(PVM pVM, const char *pszName, uint32_t uInstance, uint32_t uVersion, size_t cbGuess, const char *pszBefore, PSSMUNIT *ppUnit);
    781783
    … …  
    811813
    812814/**
    813  * Do ssmR3SelfSaveExec in phase 0.
     815 * Do ssmR3SelfSaveExec in pass 0.
    814816 *
    815817 * @returns VBox status code.
    816818 * @param   pVM             Pointer to the shared VM structure.
    817819 * @param   pSSM            The SSM handle.
    818  * @param   uPhase          The data phase number.
    819  */
    820 static DECLCALLBACK(int) ssmR3SelfLiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPhase)
    821 {
    822     if (uPhase == 0)
     820 * @param   uPass           The data pass number.
     821 */
     822static DECLCALLBACK(int) ssmR3SelfLiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass)
     823{
     824    if (uPass == 0)
    823825        return ssmR3SelfSaveExec(pVM, pSSM);
    824826    return VINF_SUCCESS;
    … …  
    862864 * @param   pSSM            The SSM handle.
    863865 * @param   uVersion        The version (1).
    864  * @param   uPhase          The phase.
    865  */
    866 static DECLCALLBACK(int) ssmR3SelfLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     866 * @param   uPass           The pass.
     867 */
     868static DECLCALLBACK(int) ssmR3SelfLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    867869{
    868870    AssertLogRelMsgReturn(uVersion == 1, ("%d", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    … …  
    35103512    UnitHdr.u32Version      = 0;
    35113513    UnitHdr.u32Instance     = 0;
    3512     UnitHdr.u32Phase        = SSM_PHASE_FINAL;
     3514    UnitHdr.u32Pass         = SSM_PASS_FINAL;
    35133515    UnitHdr.fFlags          = 0;
    35143516    UnitHdr.cbName          = 0;
    … …  
    35653567{
    35663568    VM_ASSERT_EMT0(pVM);
    3567     Assert(RT_SUCCESS(pSSM->rc));
    3568 
     3569    AssertRC(pSSM->rc);
     3570    pSSM->rc = VINF_SUCCESS;
    35693571    pSSM->enmOp = SSMSTATE_SAVE_EXEC;
    35703572    for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
    … …  
    35943596        UnitHdr.u32Version      = pUnit->u32Version;
    35953597        UnitHdr.u32Instance     = pUnit->u32Instance;
    3596         UnitHdr.u32Phase        = SSM_PHASE_FINAL;
     3598        UnitHdr.u32Pass         = SSM_PASS_FINAL;
    35973599        UnitHdr.fFlags          = 0;
    35983600        UnitHdr.cbName          = (uint32_t)pUnit->cchName + 1;
    35993601        memcpy(&UnitHdr.szName[0], &pUnit->szName[0], UnitHdr.cbName);
    36003602        UnitHdr.u32CRC          = RTCrc32(&UnitHdr, RT_OFFSETOF(SSMFILEUNITHDRV2, szName[UnitHdr.cbName]));
    3601         Log(("SSM: Unit at %#9llx: '%s', instance %u, phase %#x, version %u\n",
    3602              UnitHdr.offStream, UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Phase, UnitHdr.u32Version));
     3603        Log(("SSM: Unit at %#9llx: '%s', instance %u, pass %#x, version %u\n",
     3604             UnitHdr.offStream, UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Pass, UnitHdr.u32Version));
    36033605        int rc = ssmR3StrmWrite(&pSSM->Strm, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDRV2, szName[UnitHdr.cbName]));
    36043606        if (RT_FAILURE(rc))
    … …  
    36643666        if (RT_FAILURE(rc))
    36653667        {
    3666             LogRel(("SSM: Failed ending compression stream. rc=%Rrc\n", rc));
     3668            LogRel(("SSM: Failed terminating unit: %Rrc\n", rc));
    36673669            return pSSM->rc = rc;
    36683670        }
    … …  
    36923694    VM_ASSERT_EMT0(pVM);
    36933695    Assert(RT_SUCCESS(pSSM->rc));
    3694 
    3695     /*
    3696      * Do the prepare run.
    3697      */
    36983696    pSSM->enmOp = SSMSTATE_SAVE_PREP;
    36993697    for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
    … …  
    38033801                    ("%d\n", pSSM->enmAfter),
    38043802                    VERR_INVALID_PARAMETER);
    3805     AssertMsgReturn(pSSM->enmOp == SSMSTATE_SAVE_PREP, ("%d\n", pSSM->enmOp), VERR_INVALID_STATE);
     3803    AssertMsgReturn(pSSM->enmOp == SSMSTATE_LIVE_STEP2, ("%d\n", pSSM->enmOp), VERR_INVALID_STATE);
     3804    AssertRCReturn(pSSM->rc, pSSM->rc);
    38063805
    38073806    /*
    … …  
    39633962 *
    39643963 * @returns VBox status code (no need to check pSSM->rc).
     3964 * @retval  VINF_SUCCESS if we can pass on to step 2.
     3965 * @retval  VINF_SSM_VOTE_FOR_ANOTHER_PASS if we need another pass.
     3966 *
    39653967 * @param   pVM                 The VM handle.
    39663968 * @param   pSSM                The saved state handle.
    3967  */
    3968 static int ssmR3DoLiveVoteRun(PVM pVM, PSSMHANDLE pSSM)
    3969 {
    3970     /*
    3971      * Do the prepare run.
    3972      */
    3973     AssertRCReturn(pSSM->rc, pSSM->rc);
     3969 * @param   uPass               The current pass.
     3970 */
     3971static int ssmR3LiveDoVoteRun(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass)
     3972{
     3973    AssertRC(pSSM->rc);
    39743974    pSSM->rc = VINF_SUCCESS;
    39753975    pSSM->enmOp = SSMSTATE_LIVE_VOTE;
    … …  
    40044004                if (rc == VINF_SSM_VOTE_FOR_ANOTHER_PASS)
    40054005                {
    4006                     Log(("ssmR3DoLiveVoteRun: '%s'/#%u -> VINF_SSM_VOTE_FOR_ANOTHER_PASS\n", pUnit, pUnit->u32Instance));
     4006                    Log(("ssmR3DoLiveVoteRun: '%s'/#%u -> VINF_SSM_VOTE_FOR_ANOTHER_PASS (pass=%u)\n", pUnit->szName, pUnit->u32Instance, uPass));
    40074007                    return VINF_SSM_VOTE_FOR_ANOTHER_PASS;
    40084008                }
    4009                 Log(("ssmR3DoLiveVoteRun: '%s'/#%u -> %Rrc!!\n", pUnit, pUnit->u32Instance, rc));
     4009
     4010                /*
     4011                 * rc is usually VERR_SSM_VOTE_FOR_GIVING_UP here, but we allow
     4012                 * other status codes for better user feed back.  However, no
     4013                 * other non-error status is allowed.
     4014                 */
     4015                LogRel(("SSM: Error - '%s'/#%u voted %Rrc! (pass=%u)\n", pUnit->szName, pUnit->u32Instance, rc, uPass));
    40104016                AssertMsgReturn(RT_FAILURE(rc), ("%Rrc; '%s'\n", rc, pUnit->szName), pSSM->rc = VERR_IPE_UNEXPECTED_INFO_STATUS);
    4011                 return rc;
     4017                return pSSM->rc = rc;
    40124018            }
    40134019        }
    40144020    }
     4021
     4022    LogRel(("SSM: Step 1 completed after pass %u.\n", uPass));
    40154023    return VINF_SUCCESS;
    40164024}
    … …  
    40184026
    40194027/**
     4028 * Calls pfnLiveExec for all units.
     4029 *
     4030 * @returns VBox status code (no need to check pSSM->rc).
     4031 *
     4032 * @param   pVM                 The VM handle.
     4033 * @param   pSSM                The saved state handle.
     4034 * @param   uPass               The current pass.
     4035 */
     4036static int ssmR3LiveDoExecRun(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass)
     4037{
     4038    AssertRC(pSSM->rc);
     4039    pSSM->rc = VINF_SUCCESS;
     4040    pSSM->enmOp = SSMSTATE_LIVE_EXEC;
     4041    for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
     4042    {
     4043        /*
     4044         * Skip units without a callback (this is most).
     4045         */
     4046        if (!pUnit->u.Common.pfnLiveExec)
     4047            continue;
     4048        pUnit->offStream = ssmR3StrmTell(&pSSM->Strm);
     4049
     4050        /*
     4051         * Write data unit header.
     4052         */
     4053        SSMFILEUNITHDRV2 UnitHdr;
     4054        memcpy(&UnitHdr.szMagic[0], SSMFILEUNITHDR_MAGIC, sizeof(UnitHdr.szMagic));
     4055        UnitHdr.offStream       = pUnit->offStream;
     4056        UnitHdr.u32CurStreamCRC = ssmR3StrmCurCRC(&pSSM->Strm);
     4057        UnitHdr.u32CRC          = 0;
     4058        UnitHdr.u32Version      = pUnit->u32Version;
     4059        UnitHdr.u32Instance     = pUnit->u32Instance;
     4060        UnitHdr.u32Pass         = uPass;
     4061        UnitHdr.fFlags          = 0;
     4062        UnitHdr.cbName          = (uint32_t)pUnit->cchName + 1;
     4063        memcpy(&UnitHdr.szName[0], &pUnit->szName[0], UnitHdr.cbName);
     4064        UnitHdr.u32CRC          = RTCrc32(&UnitHdr, RT_OFFSETOF(SSMFILEUNITHDRV2, szName[UnitHdr.cbName]));
     4065        Log(("SSM: Unit at %#9llx: '%s', instance %u, pass %#x, version %u\n",
     4066             UnitHdr.offStream, UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Pass, UnitHdr.u32Version));
     4067        int rc = ssmR3StrmWrite(&pSSM->Strm, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDRV2, szName[UnitHdr.cbName]));
     4068        if (RT_FAILURE(rc))
     4069        {
     4070            LogRel(("SSM: Failed to write unit header. rc=%Rrc\n", rc));
     4071            return pSSM->rc = rc;
     4072        }
     4073
     4074        /*
     4075         * Call the execute handler.
     4076         */
     4077        ssmR3DataWriteBegin(pSSM);
     4078        switch (pUnit->enmType)
     4079        {
     4080            case SSMUNITTYPE_DEV:
     4081                rc = pUnit->u.Dev.pfnLiveExec(pUnit->u.Dev.pDevIns, pSSM, uPass);
     4082                break;
     4083            case SSMUNITTYPE_DRV:
     4084                rc = pUnit->u.Drv.pfnLiveExec(pUnit->u.Drv.pDrvIns, pSSM, uPass);
     4085                break;
     4086            case SSMUNITTYPE_INTERNAL:
     4087                rc = pUnit->u.Internal.pfnLiveExec(pVM, pSSM, uPass);
     4088                break;
     4089            case SSMUNITTYPE_EXTERNAL:
     4090                rc = pUnit->u.External.pfnLiveExec(pSSM, pUnit->u.External.pvUser, uPass);
     4091                break;
     4092            default:
     4093                rc = VERR_INTERNAL_ERROR;
     4094                break;
     4095        }
     4096        pUnit->fCalled = true;
     4097        if (RT_SUCCESS(rc))
     4098            rc = ssmR3DataFlushBuffer(pSSM); /* will return SSMHANDLE::rc if it is set */
     4099        if (RT_FAILURE(rc))
     4100        {
     4101            LogRel(("SSM: Execute save failed with rc=%Rrc for data unit '%s'/#%u.\n", rc, pUnit->szName, pUnit->u32Instance));
     4102            if (RT_SUCCESS(pSSM->rc))
     4103                pSSM->rc = rc;
     4104            return rc;
     4105        }
     4106
     4107        /*
     4108         * Write the termination record and flush the compression stream.
     4109         */
     4110        SSMRECTERM TermRec;
     4111        TermRec.u8TypeAndFlags   = SSM_REC_FLAGS_FIXED | SSM_REC_FLAGS_IMPORTANT | SSM_REC_TYPE_TERM;
     4112        TermRec.cbRec            = sizeof(TermRec) - 2;
     4113        if (pSSM->Strm.fChecksummed)
     4114        {
     4115            TermRec.fFlags       = SSMRECTERM_FLAGS_CRC32;
     4116            TermRec.u32StreamCRC = RTCrc32Finish(RTCrc32Process(ssmR3StrmCurCRC(&pSSM->Strm), &TermRec, 2));
     4117        }
     4118        else
     4119        {
     4120            TermRec.fFlags       = 0;
     4121            TermRec.u32StreamCRC = 0;
     4122        }
     4123        TermRec.cbUnit           = pSSM->offUnit + sizeof(TermRec);
     4124        rc = ssmR3DataWriteRaw(pSSM, &TermRec, sizeof(TermRec));
     4125        if (RT_SUCCESS(rc))
     4126            rc = ssmR3DataWriteFinish(pSSM);
     4127        if (RT_FAILURE(rc))
     4128        {
     4129            LogRel(("SSM: Failed terminating unit: %Rrc (pass=%u)\n", rc, uPass));
     4130            return pSSM->rc = rc;
     4131        }
     4132    } /* for each unit */
     4133
     4134    return VINF_SUCCESS;
     4135}
     4136
     4137
     4138
     4139/**
    40204140 * Continue a live state saving operation on the worker thread.
    4021  *
    4022  * The
    40234141 *
    40244142 * @returns VBox status.
    … …  
    40444162                    ("%d\n", pSSM->enmAfter),
    40454163                    VERR_INVALID_PARAMETER);
    4046     AssertMsgReturn(pSSM->enmOp == SSMSTATE_LIVE_EXEC, ("%d\n", pSSM->enmOp), VERR_INVALID_STATE);
    4047 
    4048     /*
    4049      * ...
    4050      */
    4051 
    4052     return VERR_NOT_IMPLEMENTED;
     4164    AssertMsgReturn(pSSM->enmOp == SSMSTATE_LIVE_STEP1, ("%d\n", pSSM->enmOp), VERR_INVALID_STATE);
     4165    AssertRCReturn(pSSM->rc, pSSM->rc);
     4166
     4167    /*
     4168     * Calc the max saved state size before we should give up because of insane
     4169     * amounts of data.
     4170     */
     4171#define SSM_MAX_GROWTH_FILE      10000
     4172#define SSM_MAX_GROWTH_REMOTE   100000
     4173    uint64_t cbSum = 0;
     4174    for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
     4175        cbSum += pUnit->cbGuess;
     4176    uint64_t cbMax = cbSum * (pSSM->pszFilename ? SSM_MAX_GROWTH_FILE : SSM_MAX_GROWTH_REMOTE);
     4177    AssertLogRelMsgReturn(cbMax > cbSum, ("cbMax=%#RX64, cbSum=%#RX64\n", cbMax, cbSum), pSSM->rc = VERR_OUT_OF_RANGE);
     4178    if (cbMax < _1G)
     4179        cbMax = _1G;
     4180
     4181    /*
     4182     * The pass loop.
     4183     *
     4184     * The number of interations is restricted for two reasons, first
     4185     * to make sure
     4186     */
     4187#define SSM_MAX_PASSES  _1M
     4188    for (uint32_t uPass = 0; uPass < SSM_MAX_PASSES; uPass++)
     4189    {
     4190        /*
     4191         * Save state and vote on whether we need more passes or not.
     4192         */
     4193        int rc = ssmR3LiveDoExecRun(pVM, pSSM, uPass);
     4194        if (RT_FAILURE(rc))
     4195            return rc;
     4196        rc = ssmR3LiveDoVoteRun(pVM, pSSM, uPass);
     4197        if (rc == VINF_SUCCESS)
     4198        {
     4199            pSSM->enmOp = SSMSTATE_LIVE_STEP2;
     4200            return VINF_SUCCESS;
     4201        }
     4202        if (RT_FAILURE(rc))
     4203            return rc;
     4204
     4205        /*
     4206         * Check that we're still within sane data amounts.
     4207         */
     4208        uint64_t cbSaved = ssmR3StrmTell(&pSSM->Strm);
     4209        if (cbSaved > cbMax)
     4210        {
     4211            LogRel(("SSM: Giving up: Exceeded max state size. (cbSaved=%#RX64, cbMax=%#RX64)\n", cbSaved, cbMax));
     4212            return pSSM->rc = VERR_SSM_STATE_GREW_TOO_BIG;
     4213        }
     4214
     4215        /*
     4216         * Check that there is still some space left on the disk.
     4217         */
     4218        /** @todo move this to the stream flushing code? It's not perfect when done
     4219         *        here, it could be way better if we did it there. */
     4220        if (pSSM->pszFilename)
     4221        {
     4222            RTFOFF cbFree;
     4223            rc = RTFsQuerySizes(pSSM->pszFilename, NULL, &cbFree, NULL, NULL);
     4224            AssertRC(rc);
     4225#define SSM_MIN_DISK_FREE    ((RTFOFF)( 10 * _1M ))
     4226            if (   RT_SUCCESS(rc)
     4227                && cbFree < SSM_MIN_DISK_FREE)
     4228            {
     4229                LogRel(("SSM: Giving up: Low on disk space. (cbFree=%RTfoff, SSM_MIN_DISK_FREE=%RTfoff).\n",
     4230                        cbFree, SSM_MIN_DISK_FREE));
     4231                return pSSM->rc = VERR_SSM_LOW_ON_DISK_SPACE;
     4232            }
     4233        }
     4234    }
     4235
     4236    LogRel(("SSM: Giving up: Too many passes! (%u)\n", SSM_MAX_PASSES));
     4237    return pSSM->rc = VERR_SSM_TOO_MANY_PASSES;
    40534238}
    40544239
    … …  
    41924377             * via SSMR3SaveFinishLive
    41934378             */
     4379            pSSM->enmOp = SSMSTATE_LIVE_STEP1;
    41944380            *ppSSM = pSSM;
    41954381            return VINF_SUCCESS;
    … …  
    61236309                        {
    61246310                            case SSMUNITTYPE_DEV:
    6125                                 rc = pUnit->u.Dev.pfnLoadExec(pUnit->u.Dev.pDevIns, pSSM, UnitHdr.u32Version, SSM_PHASE_FINAL);
     6311                                rc = pUnit->u.Dev.pfnLoadExec(pUnit->u.Dev.pDevIns, pSSM, UnitHdr.u32Version, SSM_PASS_FINAL);
    61266312                                break;
    61276313                            case SSMUNITTYPE_DRV:
    6128                                 rc = pUnit->u.Drv.pfnLoadExec(pUnit->u.Drv.pDrvIns, pSSM, UnitHdr.u32Version, SSM_PHASE_FINAL);
     6314                                rc = pUnit->u.Drv.pfnLoadExec(pUnit->u.Drv.pDrvIns, pSSM, UnitHdr.u32Version, SSM_PASS_FINAL);
    61296315                                break;
    61306316                            case SSMUNITTYPE_INTERNAL:
    6131                                 rc = pUnit->u.Internal.pfnLoadExec(pVM, pSSM, UnitHdr.u32Version, SSM_PHASE_FINAL);
     6317                                rc = pUnit->u.Internal.pfnLoadExec(pVM, pSSM, UnitHdr.u32Version, SSM_PASS_FINAL);
    61326318                                break;
    61336319                            case SSMUNITTYPE_EXTERNAL:
    6134                                 rc = pUnit->u.External.pfnLoadExec(pSSM, pUnit->u.External.pvUser, UnitHdr.u32Version, SSM_PHASE_FINAL);
     6320                                rc = pUnit->u.External.pfnLoadExec(pSSM, pUnit->u.External.pvUser, UnitHdr.u32Version, SSM_PASS_FINAL);
    61356321                                break;
    61366322                            default:
    … …  
    62736459                                  && UnitHdr.u32Instance  == 0
    62746460                                  && UnitHdr.u32Version   == 0
    6275                                   && UnitHdr.u32Phase     == SSM_PHASE_FINAL,
     6461                                  && UnitHdr.u32Pass      == SSM_PASS_FINAL,
    62766462                                  ("Unit at %#llx (%lld): Malformed END unit\n", offUnit, offUnit),
    62776463                                  VERR_SSM_INTEGRITY_UNIT);
    … …  
    62866472        AssertLogRelMsgReturn(UnitHdr.cbName > 1, ("Unit at %#llx (%lld): No name\n", offUnit, offUnit), VERR_SSM_INTEGRITY);
    62876473
    6288         Log(("SSM: Unit at %#9llx: '%s', instance %u, phase %#x, version %u\n",
    6289              offUnit, UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Phase, UnitHdr.u32Version));
     6474        Log(("SSM: Unit at %#9llx: '%s', instance %u, pass %#x, version %u\n",
     6475             offUnit, UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Pass, UnitHdr.u32Version));
    62906476
    62916477        /*
    … …  
    63056491            {
    63066492                case SSMUNITTYPE_DEV:
    6307                     rc = pUnit->u.Dev.pfnLoadExec(pUnit->u.Dev.pDevIns, pSSM, UnitHdr.u32Version, UnitHdr.u32Phase);
     6493                    rc = pUnit->u.Dev.pfnLoadExec(pUnit->u.Dev.pDevIns, pSSM, UnitHdr.u32Version, UnitHdr.u32Pass);
    63086494                    break;
    63096495                case SSMUNITTYPE_DRV:
    6310                     rc = pUnit->u.Drv.pfnLoadExec(pUnit->u.Drv.pDrvIns, pSSM, UnitHdr.u32Version, UnitHdr.u32Phase);
     6496                    rc = pUnit->u.Drv.pfnLoadExec(pUnit->u.Drv.pDrvIns, pSSM, UnitHdr.u32Version, UnitHdr.u32Pass);
    63116497                    break;
    63126498                case SSMUNITTYPE_INTERNAL:
    6313                     rc = pUnit->u.Internal.pfnLoadExec(pVM, pSSM, UnitHdr.u32Version, UnitHdr.u32Phase);
     6499                    rc = pUnit->u.Internal.pfnLoadExec(pVM, pSSM, UnitHdr.u32Version, UnitHdr.u32Pass);
    63146500                    break;
    63156501                case SSMUNITTYPE_EXTERNAL:
    6316                     rc = pUnit->u.External.pfnLoadExec(pSSM, pUnit->u.External.pvUser, UnitHdr.u32Version, UnitHdr.u32Phase);
     6502                    rc = pUnit->u.External.pfnLoadExec(pSSM, pUnit->u.External.pvUser, UnitHdr.u32Version, UnitHdr.u32Pass);
    63176503                    break;
    63186504                default:
    … …  
    63286514            else
    63296515            {
    6330                 LogRel(("SSM: LoadExec failed for '%s' instance #%u (version %u, phase %#x): %Rrc\n",
    6331                         UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Version, UnitHdr.u32Phase, rc));
     6516                LogRel(("SSM: LoadExec failed for '%s' instance #%u (version %u, pass %#x): %Rrc\n",
     6517                        UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Version, UnitHdr.u32Pass, rc));
    63326518                return VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to load unit '%s'"), UnitHdr.szName);
    63336519            }

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

    r22480 r22793  
    162162static uint64_t             tmR3CalibrateTSC(PVM pVM);
    163163static DECLCALLBACK(int)    tmR3Save(PVM pVM, PSSMHANDLE pSSM);
    164 static DECLCALLBACK(int)    tmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     164static DECLCALLBACK(int)    tmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    165165static DECLCALLBACK(void)   tmR3TimerCallback(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
    166166static void                 tmR3TimerQueueRun(PVM pVM, PTMTIMERQUEUE pQueue);
    … …  
    10901090 * @param   pSSM            SSM operation handle.
    10911091 * @param   uVersion        Data layout version.
    1092  * @param   uPhase          The data phase.
    1093  */
    1094 static DECLCALLBACK(int) tmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     1092 * @param   uPass           The data pass.
     1093 */
     1094static DECLCALLBACK(int) tmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    10951095{
    10961096    LogFlow(("tmR3Load:\n"));
    10971097
    1098     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     1098    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    10991099#ifdef VBOX_STRICT
    11001100    for (VMCPUID i = 0; i < pVM->cCPUs; i++)

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

    r22480 r22793  
    439439*******************************************************************************/
    440440static DECLCALLBACK(int) trpmR3Save(PVM pVM, PSSMHANDLE pSSM);
    441 static DECLCALLBACK(int) trpmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     441static DECLCALLBACK(int) trpmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    442442static DECLCALLBACK(int) trpmR3GuestIDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
    443443
    … …  
    820820 * @param   pSSM            SSM operation handle.
    821821 * @param   uVersion        Data layout version.
    822  * @param   uPhase          The data phase.
    823  */
    824 static DECLCALLBACK(int) trpmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     822 * @param   uPass           The data pass.
     823 */
     824static DECLCALLBACK(int) trpmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    825825{
    826826    LogFlow(("trpmR3Load:\n"));
    827     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     827    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    828828
    829829    /*

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

    r22480 r22793  
    110110static void                 vmmR3InitRegisterStats(PVM pVM);
    111111static DECLCALLBACK(int)    vmmR3Save(PVM pVM, PSSMHANDLE pSSM);
    112 static DECLCALLBACK(int)    vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     112static DECLCALLBACK(int)    vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    113113static DECLCALLBACK(void)   vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser);
    114114static int                  vmmR3ServiceCallRing3Request(PVM pVM, PVMCPU pVCpu);
    … …  
    936936 * @param   pSSM            SSM operation handle.
    937937 * @param   uVersion        Data layout version.
    938  * @param   uPhase          The data phase.
    939  */
    940 static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     938 * @param   uPass           The data pass.
     939 */
     940static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    941941{
    942942    LogFlow(("vmmR3Load:\n"));
    943     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     943    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    944944
    945945    /*

  • trunk/src/VBox/VMM/testcase/tstSSM.cpp

    r22480 r22793  
    187187 * @param   pSSM            SSM operation handle.
    188188 * @param   uVersion        The data layout version.
    189  * @param   uPhase          The data phase.
    190  */
    191 DECLCALLBACK(int) Item01Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     189 * @param   uPass           The data pass.
     190 */
     191DECLCALLBACK(int) Item01Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    192192{
    193193    if (uVersion != 0)
    … …  
    343343 * @param   pSSM            SSM operation handle.
    344344 * @param   uVersion        The data layout version.
    345  * @param   uPhase          The data phase.
    346  */
    347 DECLCALLBACK(int) Item02Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     345 * @param   uPass           The data pass.
     346 */
     347DECLCALLBACK(int) Item02Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    348348{
    349349    if (uVersion != 0)
    … …  
    457457 * @param   pSSM            SSM operation handle.
    458458 * @param   uVersion        The data layout version.
    459  * @param   uPhase          The data phase.
    460  */
    461 DECLCALLBACK(int) Item03Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     459 * @param   uPass           The data pass.
     460 */
     461DECLCALLBACK(int) Item03Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    462462{
    463463    if (uVersion != 123)
    … …  
    563563 * @param   pSSM            SSM operation handle.
    564564 * @param   uVersion        The data layout version.
    565  * @param   uPhase          The data phase.
    566  */
    567 DECLCALLBACK(int) Item04Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     565 * @param   uPass           The data pass.
     566 */
     567DECLCALLBACK(int) Item04Load(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    568568{
    569569    if (uVersion != 42)
    … …  
    851851    }
    852852    u64Start = RTTimeNanoTS();
    853     rc = Item02Load(NULL, pSSM, uVersion, SSM_PHASE_FINAL);
     853    rc = Item02Load(NULL, pSSM, uVersion, SSM_PASS_FINAL);
    854854    if (RT_FAILURE(rc))
    855855    {
    … …  
    869869    }
    870870    u64Start = RTTimeNanoTS();
    871     rc = Item01Load(NULL, pSSM, uVersion, SSM_PHASE_FINAL);
     871    rc = Item01Load(NULL, pSSM, uVersion, SSM_PASS_FINAL);
    872872    if (RT_FAILURE(rc))
    873873    {
    … …  
    887887    }
    888888    u64Start = RTTimeNanoTS();
    889     rc = Item03Load(NULL, pSSM, uVersion, SSM_PHASE_FINAL);
     889    rc = Item03Load(NULL, pSSM, uVersion, SSM_PASS_FINAL);
    890890    if (RT_FAILURE(rc))
    891891    {

  • trunk/src/recompiler/VBoxRecompiler.c

    r22480 r22793  
    8888*******************************************************************************/
    8989static DECLCALLBACK(int) remR3Save(PVM pVM, PSSMHANDLE pSSM);
    90 static DECLCALLBACK(int) remR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase);
     90static DECLCALLBACK(int) remR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    9191static void     remR3StateUpdate(PVM pVM, PVMCPU pVCpu);
    9292static int      remR3InitPhysRamSizeAndDirtyMap(PVM pVM, bool fGuarded);
    … …  
    661661 * @param   pSSM            SSM operation handle.
    662662 * @param   uVersion        Data layout version.
    663  * @param   uPhase          The data phase.
    664  */
    665 static DECLCALLBACK(int) remR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPhase)
     663 * @param   uPass           The data pass.
     664 */
     665static DECLCALLBACK(int) remR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    666666{
    667667    uint32_t u32Dummy;
    … …  
    673673
    674674    LogFlow(("remR3Load:\n"));
    675     Assert(uPhase == SSM_PHASE_FINAL); NOREF(uPhase);
     675    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    676676
    677677    /*
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