VirtualBox

Changeset 23872 in vbox for trunk/src


Ignore:
Timestamp:
Oct 19, 2009 2:49:13 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
53643
Message:

SSM: Extended and fixed the SSMFIELD_ENTRY_OLD bits.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r23816 r23872  
    838838/** Pointer to a const footer. */
    839839typedef SSMFILEFTR const *PCSSMFILEFTR;
     840
     841
     842/*******************************************************************************
     843*   Global Variables                                                           *
     844*******************************************************************************/
     845/** Zeros used by the struct putter.
     846 * This must be at least 8 bytes or the code breaks. */
     847static uint8_t const    g_abZero[_1K] = {0};
    840848
    841849
    … …  
    32953303
    32963304/**
     3305 * SSMR3PutStructEx helper that puts an arbitrary number of zeros.
     3306 *
     3307 * @returns VBox status code.
     3308 * @param   pSSM            The saved state handle.
     3309 * @param   cbToFill        The number of zeros to stuff into the state.
     3310 */
     3311static int ssmR3PutZeros(PSSMHANDLE pSSM, uint32_t cbToFill)
     3312{
     3313    while (cbToFill > 0)
     3314    {
     3315        size_t cb = RT_MIN(sizeof(g_abZero), cbToFill);
     3316        int rc = ssmR3DataWrite(pSSM, g_abZero, cb);
     3317        if (RT_FAILURE(rc))
     3318            return rc;
     3319        cbToFill -= cb;
     3320    }
     3321    return VINF_SUCCESS;
     3322}
     3323
     3324
     3325/**
    32973326 * Puts a structure, extended API.
    32983327 *
    … …  
    33103339                                uint32_t fFlags, PCSSMFIELD paFields, void *pvUser)
    33113340{
    3312     static uint8_t const s_abZero[_1K] = {0};
    33133341    int rc;
    33143342
    … …  
    33603388                        VERR_SSM_FIELD_NOT_CONSECUTIVE);
    33613389
     3390        rc = VINF_SUCCESS;
    33623391        uint8_t const *pbField = (uint8_t const *)pvStruct + offField;
    33633392        switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
    … …  
    33863415                uint32_t const cEntries = cbField / sizeof(RTRCPTR);
    33873416                AssertMsgReturn(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3388                 rc = VINF_SUCCESS;
    33893417                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    33903418                    rc = SSMR3PutRCPtr(pSSM, ((PRTRCPTR)pbField)[i]);
    … …  
    34013429                uint32_t const cEntries = cbField / sizeof(void *);
    34023430                AssertMsgReturn(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3403                 rc = VINF_SUCCESS;
    34043431                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    34053432                    rc = ssmR3PutHCPtrNI(pSSM, ((void * const *)pbField)[i], fFlags);
    … …  
    34123439                rc = ssmR3DataWrite(pSSM, pbField, sizeof(uint32_t));
    34133440                if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && sizeof(void *) != sizeof(uint32_t))
    3414                     rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(uint32_t));
     3441                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(uint32_t));
    34153442                break;
    34163443
    … …  
    34183445            case SSMFIELDTRANS_IGNORE:
    34193446                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    3420                 {
    3421                     uint32_t cb;
    3422                     for (uint32_t cbLeft = cbField; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb)
    3423                     {
    3424                         cb = RT_MIN(sizeof(s_abZero), cbLeft);
    3425                         rc = ssmR3DataWrite(pSSM, s_abZero, cb);
    3426                     }
    3427                 }
     3447                    rc = ssmR3PutZeros(pSSM, cbField);
    34283448                break;
    34293449
    … …  
    34313451                AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    34323452                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    3433                     rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPHYS));
     3453                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPHYS));
    34343454                break;
    34353455
    … …  
    34373457                AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    34383458                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    3439                     rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPTR));
     3459                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPTR));
    34403460                break;
    34413461
    … …  
    34433463                AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    34443464                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    3445                     rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTRCPTR));
     3465                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTRCPTR));
    34463466                break;
    34473467
    … …  
    34493469                AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    34503470                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    3451                     rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(void *));
     3471                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(void *));
    34523472                break;
    34533473
    34543474
    34553475            case SSMFIELDTRANS_OLD:
    3456             {
    3457                 uint32_t cb;
    3458                 for (uint32_t cbLeft = pCur->cb; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb)
    3459                 {
    3460                     cb = RT_MIN(sizeof(s_abZero), cbLeft);
    3461                     rc = ssmR3DataWrite(pSSM, s_abZero, cb);
    3462                 }
     3476                AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3477                rc = ssmR3PutZeros(pSSM, pCur->cb);
    34633478                break;
    3464             }
    34653479
    34663480            case SSMFIELDTRANS_OLD_GCPHYS:
    34673481                AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3468                 rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPHYS));
     3482                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPHYS));
    34693483                break;
    34703484
    34713485            case SSMFIELDTRANS_OLD_GCPTR:
    34723486                AssertMsgReturn(pCur->cb == sizeof(RTGCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3473                 rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPTR));
     3487                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPTR));
    34743488                break;
    34753489
    34763490            case SSMFIELDTRANS_OLD_RCPTR:
    34773491                AssertMsgReturn(pCur->cb == sizeof(RTRCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3478                 rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTRCPTR));
     3492                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTRCPTR));
    34793493                break;
    34803494
    34813495            case SSMFIELDTRANS_OLD_HCPTR:
    34823496                AssertMsgReturn(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3483                 rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(void *));
     3497                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(void *));
     3498                break;
     3499
     3500            case SSMFIELDTRANS_OLD_PAD_HC:
     3501                AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3502                rc = ssmR3PutZeros(pSSM, HC_ARCH_BITS == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
     3503                break;
     3504
     3505            case SSMFIELDTRANS_OLD_PAD_MSC32:
     3506                AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3507                if (SSM_HOST_IS_MSC_32)
     3508                    rc = ssmR3PutZeros(pSSM, pCur->cb);
    34843509                break;
    34853510
    … …  
    35143539                                VERR_SSM_FIELD_INVALID_PADDING_SIZE);
    35153540                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    3516                 {
    3517                     uint32_t cb;
    3518                     for (uint32_t cbLeft = cbSaved; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb)
    3519                     {
    3520                         cb = RT_MIN(sizeof(s_abZero), cbLeft);
    3521                         rc = ssmR3DataWrite(pSSM, s_abZero, cb);
    3522                     }
    3523                 }
     3541                    rc = ssmR3PutZeros(pSSM, cbSaved);
    35243542                break;
    35253543            }
    … …  
    60556073                        VERR_SSM_FIELD_NOT_CONSECUTIVE);
    60566074
     6075        rc = VINF_SUCCESS;
    60576076        uint8_t       *pbField  = (uint8_t *)pvStruct + offField;
    60586077        switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
    … …  
    61486167
    61496168            case SSMFIELDTRANS_OLD:
     6169                AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    61506170                rc = SSMR3Skip(pSSM, pCur->cb);
    61516171                break;
    … …  
    61696189                AssertMsgReturn(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    61706190                rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) / 8);
     6191                break;
     6192
     6193            case SSMFIELDTRANS_OLD_PAD_HC:
     6194                AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6195                rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
     6196                break;
     6197
     6198            case SSMFIELDTRANS_OLD_PAD_MSC32:
     6199                AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6200                if (ssmR3IsHostMsc32(pSSM))
     6201                    rc = SSMR3Skip(pSSM, pCur->cb);
    61716202                break;
    61726203
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