Index: /trunk/include/VBox/ssm.h =================================================================== --- /trunk/include/VBox/ssm.h (revision 23871) +++ /trunk/include/VBox/ssm.h (revision 23872) @@ -172,4 +172,9 @@ /** Old host context (HC) virtual address. */ SSMFIELDTRANS_OLD_HCPTR, + /** Old host context specific padding. + * The lower word is the size of 32-bit hosts, the upper for 64-bit hosts. */ + SSMFIELDTRANS_OLD_PAD_HC, + /** Old padding specific to the 32-bit Microsoft C Compiler. */ + SSMFIELDTRANS_OLD_PAD_MSC32, /** Padding that differs between 32-bit and 64-bit hosts. @@ -208,5 +213,5 @@ */ #define SSMFIELDTRANS_IS_OLD(pfn) \ - ( (uintptr_t)(pfn) >= SSMFIELDTRANS_OLD && (uintptr_t)(pfn) <= SSMFIELDTRANS_OLD_HCPTR ) + ( (uintptr_t)(pfn) >= SSMFIELDTRANS_OLD && (uintptr_t)(pfn) <= SSMFIELDTRANS_OLD_PAD_MSC32 ) /** @@ -227,50 +232,37 @@ /** Emit a SSMFIELD array entry. * @internal */ -#define SSMFIELD_ENTRY_INT(Type, Field, enmTransformer) \ - { \ - (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \ - RT_OFFSETOF(Type, Field), \ - RT_SIZEOFMEMB(Type, Field), \ - #Type "::" #Field \ - } +#define SSMFIELD_ENTRY_INT(Name, off, cb, enmTransformer) \ + { (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), (off), (cb), Name } +/** Emit a SSMFIELD array entry. + * @internal */ +#define SSMFIELD_ENTRY_TF_INT(Type, Field, enmTransformer) \ + SSMFIELD_ENTRY_INT(#Type "::" #Field, RT_OFFSETOF(Type, Field), RT_SIZEOFMEMB(Type, Field), enmTransformer) /** Emit a SSMFIELD array entry for an old field. * @internal */ -#define SSMFIELD_ENTRY_OLD_INT(cb, enmTransformer) \ - { \ - (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \ - UINT32_MAX / 2, \ - (cb), \ - "" \ - } +#define SSMFIELD_ENTRY_OLD_INT(Field, cb, enmTransformer) \ + SSMFIELD_ENTRY_INT("old::" #Field, UINT32_MAX / 2, (cb), enmTransformer) /** Emit a SSMFIELD array entry for an alignment padding. * @internal */ #define SSMFIELD_ENTRY_PAD_INT(Type, Field, cb32, cb64, enmTransformer) \ - { \ - (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \ - RT_OFFSETOF(Type, Field), \ - (RT_SIZEOFMEMB(Type, Field) << 16) | (cb32) | ((cb64) << 8), \ - #Type "::" #Field \ - } + SSMFIELD_ENTRY_INT(#Type "::" #Field, RT_OFFSETOF(Type, Field), \ + (RT_SIZEOFMEMB(Type, Field) << 16) | (cb32) | ((cb64) << 8), enmTransformer) /** Emit a SSMFIELD array entry for an alignment padding. * @internal */ #define SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, cb32, cb64, enmTransformer) \ - { \ - (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \ - UINT32_MAX / 2, \ - 0 | (cb32) | ((cb64) << 8), \ - #Type "::" #Field \ - } - + SSMFIELD_ENTRY_INT(#Type "::" #Field, UINT32_MAX / 2, 0 | (cb32) | ((cb64) << 8), enmTransformer) /** Emit a SSMFIELD array entry. */ -#define SSMFIELD_ENTRY(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_NO_TRANSFORMATION) +#define SSMFIELD_ENTRY(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_NO_TRANSFORMATION) +/** Emit a SSMFIELD array entry for a custom made field. This is intended + * for working around bitfields in old structures. */ +#define SSMFIELD_ENTRY_CUSTOM(Field, off, cb) SSMFIELD_ENTRY_INT("custom::" #Field, off, cb, SSMFIELDTRANS_NO_TRANSFORMATION) /** Emit a SSMFIELD array entry for a RTGCPHYS type. */ -#define SSMFIELD_ENTRY_GCPHYS(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_GCPHYS) +#define SSMFIELD_ENTRY_GCPHYS(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_GCPHYS) /** Emit a SSMFIELD array entry for a RTGCPTR type. */ -#define SSMFIELD_ENTRY_GCPTR(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_GCPTR) +#define SSMFIELD_ENTRY_GCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_GCPTR) /** Emit a SSMFIELD array entry for a raw-mode context pointer. */ -#define SSMFIELD_ENTRY_RCPTR(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_RCPTR) +#define SSMFIELD_ENTRY_RCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_RCPTR) /** Emit a SSMFIELD array entry for a raw-mode context pointer. */ -#define SSMFIELD_ENTRY_RCPTR_ARRAY(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_RCPTR_ARRAY) +#define SSMFIELD_ENTRY_RCPTR_ARRAY(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_RCPTR_ARRAY) /** Emit a SSMFIELD array entry for a ring-0 or ring-3 pointer type that is only * of interest as a NULL indicator. @@ -279,35 +271,44 @@ * SSMSTRUCT_FLAGS_DONT_IGNORE is set, the pointer will be saved in its * entirety, when clear it will be saved as a boolean. */ -#define SSMFIELD_ENTRY_HCPTR_NI(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI) +#define SSMFIELD_ENTRY_HCPTR_NI(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI) /** Same as SSMFIELD_ENTRY_HCPTR_NI, except it's an array of the buggers. */ -#define SSMFIELD_ENTRY_HCPTR_NI_ARRAY(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI_ARRAY) +#define SSMFIELD_ENTRY_HCPTR_NI_ARRAY(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI_ARRAY) /** Emit a SSMFIELD array entry for a ring-0 or ring-3 pointer type that has * been hacked such that it will never exceed 32-bit. No sign extenending. */ -#define SSMFIELD_ENTRY_HCPTR_HACK_U32(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR_HACK_U32) +#define SSMFIELD_ENTRY_HCPTR_HACK_U32(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_HCPTR_HACK_U32) /** Emit a SSMFIELD array entry for a field that can be ignored. * It is stored as zeros if SSMSTRUCT_FLAGS_DONT_IGNORE is specified to * SSMR3PutStructEx. The member is never touched upon restore. */ -#define SSMFIELD_ENTRY_IGNORE(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGNORE) +#define SSMFIELD_ENTRY_IGNORE(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGNORE) /** Emit a SSMFIELD array entry for an ignorable RTGCPHYS type. */ -#define SSMFIELD_ENTRY_IGN_GCPHYS(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGN_GCPHYS) +#define SSMFIELD_ENTRY_IGN_GCPHYS(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_GCPHYS) /** Emit a SSMFIELD array entry for an ignorable RTGCPHYS type. */ -#define SSMFIELD_ENTRY_IGN_GCPTR(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGN_GCPTR) +#define SSMFIELD_ENTRY_IGN_GCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_GCPTR) /** Emit a SSMFIELD array entry for an ignorable raw-mode context pointer. */ -#define SSMFIELD_ENTRY_IGN_RCPTR(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGN_RCPTR) +#define SSMFIELD_ENTRY_IGN_RCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_RCPTR) /** Emit a SSMFIELD array entry for an ignorable ring-3 or/and ring-0 pointer. */ -#define SSMFIELD_ENTRY_IGN_HCPTR(Type, Field) SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGN_HCPTR) +#define SSMFIELD_ENTRY_IGN_HCPTR(Type, Field) SSMFIELD_ENTRY_TF_INT(Type, Field, SSMFIELDTRANS_IGN_HCPTR) /** Emit a SSMFIELD array entry for an old field that should be ignored now. * It is stored as zeros and skipped on load. */ -#define SSMFIELD_ENTRY_OLD(cb) SSMFIELD_ENTRY_OLD_INT(cb, SSMFIELDTRANS_OLD) +#define SSMFIELD_ENTRY_OLD(Field, cb) SSMFIELD_ENTRY_OLD_INT(Field, cb, SSMFIELDTRANS_OLD) /** Same as SSMFIELD_ENTRY_IGN_GCPHYS, except there is no structure field. */ -#define SSMFIELD_ENTRY_OLD_GCPHYS() SSMFIELD_ENTRY_OLD_INT(sizeof(RTGCPHYS), SSMFIELDTRANS_OLD_GCPHYS) +#define SSMFIELD_ENTRY_OLD_GCPHYS(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTGCPHYS), SSMFIELDTRANS_OLD_GCPHYS) /** Same as SSMFIELD_ENTRY_IGN_GCPTR, except there is no structure field. */ -#define SSMFIELD_ENTRY_OLD_GCPTR() SSMFIELD_ENTRY_OLD_INT(sizeof(RTGCPTR), SSMFIELDTRANS_OLD_GCPTR) +#define SSMFIELD_ENTRY_OLD_GCPTR(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTGCPTR), SSMFIELDTRANS_OLD_GCPTR) /** Same as SSMFIELD_ENTRY_IGN_RCPTR, except there is no structure field. */ -#define SSMFIELD_ENTRY_OLD_RCPTR() SSMFIELD_ENTRY_OLD_INT(sizeof(RTRCPTR), SSMFIELDTRANS_OLD_RCPTR) +#define SSMFIELD_ENTRY_OLD_RCPTR(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTRCPTR), SSMFIELDTRANS_OLD_RCPTR) /** Same as SSMFIELD_ENTRY_IGN_HCPTR, except there is no structure field. */ -#define SSMFIELD_ENTRY_OLD_HCPTR() SSMFIELD_ENTRY_OLD_INT(sizeof(RTHCPTR), SSMFIELDTRANS_OLD_HCPTR) +#define SSMFIELD_ENTRY_OLD_HCPTR(Field) SSMFIELD_ENTRY_OLD_INT(Field, sizeof(RTHCPTR), SSMFIELDTRANS_OLD_HCPTR) +/** Same as SSMFIELD_ENTRY_PAD_HC, except there is no structure field. */ +#define SSMFIELD_ENTRY_OLD_PAD_HC(Field, cb32, cb64) \ + SSMFIELD_ENTRY_OLD_INT(Field, RT_MAKE_U32((cb32), (cb64)), SSMFIELDTRANS_OLD_PAD_HC) +/** Same as SSMFIELD_ENTRY_PAD_HC64, except there is no structure field. */ +#define SSMFIELD_ENTRY_OLD_PAD_HC64(Field, cb) SSMFIELD_ENTRY_OLD_PAD_HC(Field, 0, cb) +/** Same as SSMFIELD_ENTRY_PAD_HC32, except there is no structure field. */ +#define SSMFIELD_ENTRY_OLD_PAD_HC32(Field, cb) SSMFIELD_ENTRY_OLD_PAD_HC(Field, cb, 0) +/** Same as SSMFIELD_ENTRY_PAD_HC, except there is no structure field. */ +#define SSMFIELD_ENTRY_OLD_PAD_MSC32(Field, cb) SSMFIELD_ENTRY_OLD_INT(Field, cb, SSMFIELDTRANS_OLD_PAD_MSC32) /** Emit a SSMFIELD array entry for a padding that differs in size between Index: /trunk/src/VBox/VMM/SSM.cpp =================================================================== --- /trunk/src/VBox/VMM/SSM.cpp (revision 23871) +++ /trunk/src/VBox/VMM/SSM.cpp (revision 23872) @@ -838,4 +838,12 @@ /** Pointer to a const footer. */ typedef SSMFILEFTR const *PCSSMFILEFTR; + + +/******************************************************************************* +* Global Variables * +*******************************************************************************/ +/** Zeros used by the struct putter. + * This must be at least 8 bytes or the code breaks. */ +static uint8_t const g_abZero[_1K] = {0}; @@ -3295,4 +3303,25 @@ /** + * SSMR3PutStructEx helper that puts an arbitrary number of zeros. + * + * @returns VBox status code. + * @param pSSM The saved state handle. + * @param cbToFill The number of zeros to stuff into the state. + */ +static int ssmR3PutZeros(PSSMHANDLE pSSM, uint32_t cbToFill) +{ + while (cbToFill > 0) + { + size_t cb = RT_MIN(sizeof(g_abZero), cbToFill); + int rc = ssmR3DataWrite(pSSM, g_abZero, cb); + if (RT_FAILURE(rc)) + return rc; + cbToFill -= cb; + } + return VINF_SUCCESS; +} + + +/** * Puts a structure, extended API. * @@ -3310,5 +3339,4 @@ uint32_t fFlags, PCSSMFIELD paFields, void *pvUser) { - static uint8_t const s_abZero[_1K] = {0}; int rc; @@ -3360,4 +3388,5 @@ VERR_SSM_FIELD_NOT_CONSECUTIVE); + rc = VINF_SUCCESS; uint8_t const *pbField = (uint8_t const *)pvStruct + offField; switch ((uintptr_t)pCur->pfnGetPutOrTransformer) @@ -3386,5 +3415,4 @@ uint32_t const cEntries = cbField / sizeof(RTRCPTR); AssertMsgReturn(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); - rc = VINF_SUCCESS; for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++) rc = SSMR3PutRCPtr(pSSM, ((PRTRCPTR)pbField)[i]); @@ -3401,5 +3429,4 @@ uint32_t const cEntries = cbField / sizeof(void *); AssertMsgReturn(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); - rc = VINF_SUCCESS; for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++) rc = ssmR3PutHCPtrNI(pSSM, ((void * const *)pbField)[i], fFlags); @@ -3412,5 +3439,5 @@ rc = ssmR3DataWrite(pSSM, pbField, sizeof(uint32_t)); if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && sizeof(void *) != sizeof(uint32_t)) - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(uint32_t)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(uint32_t)); break; @@ -3418,12 +3445,5 @@ case SSMFIELDTRANS_IGNORE: if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) - { - uint32_t cb; - for (uint32_t cbLeft = cbField; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb) - { - cb = RT_MIN(sizeof(s_abZero), cbLeft); - rc = ssmR3DataWrite(pSSM, s_abZero, cb); - } - } + rc = ssmR3PutZeros(pSSM, cbField); break; @@ -3431,5 +3451,5 @@ AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPHYS)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPHYS)); break; @@ -3437,5 +3457,5 @@ AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPTR)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPTR)); break; @@ -3443,5 +3463,5 @@ AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTRCPTR)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTRCPTR)); break; @@ -3449,37 +3469,42 @@ AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(void *)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(void *)); break; case SSMFIELDTRANS_OLD: - { - uint32_t cb; - for (uint32_t cbLeft = pCur->cb; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb) - { - cb = RT_MIN(sizeof(s_abZero), cbLeft); - rc = ssmR3DataWrite(pSSM, s_abZero, cb); - } + AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); + rc = ssmR3PutZeros(pSSM, pCur->cb); break; - } case SSMFIELDTRANS_OLD_GCPHYS: 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); - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPHYS)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPHYS)); break; case SSMFIELDTRANS_OLD_GCPTR: 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); - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTGCPTR)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPTR)); break; case SSMFIELDTRANS_OLD_RCPTR: 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); - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(RTRCPTR)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTRCPTR)); break; case SSMFIELDTRANS_OLD_HCPTR: 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); - rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(void *)); + rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(void *)); + break; + + case SSMFIELDTRANS_OLD_PAD_HC: + AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); + rc = ssmR3PutZeros(pSSM, HC_ARCH_BITS == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb)); + break; + + case SSMFIELDTRANS_OLD_PAD_MSC32: + AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); + if (SSM_HOST_IS_MSC_32) + rc = ssmR3PutZeros(pSSM, pCur->cb); break; @@ -3514,12 +3539,5 @@ VERR_SSM_FIELD_INVALID_PADDING_SIZE); if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) - { - uint32_t cb; - for (uint32_t cbLeft = cbSaved; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb) - { - cb = RT_MIN(sizeof(s_abZero), cbLeft); - rc = ssmR3DataWrite(pSSM, s_abZero, cb); - } - } + rc = ssmR3PutZeros(pSSM, cbSaved); break; } @@ -6055,4 +6073,5 @@ VERR_SSM_FIELD_NOT_CONSECUTIVE); + rc = VINF_SUCCESS; uint8_t *pbField = (uint8_t *)pvStruct + offField; switch ((uintptr_t)pCur->pfnGetPutOrTransformer) @@ -6148,4 +6167,5 @@ case SSMFIELDTRANS_OLD: + AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); rc = SSMR3Skip(pSSM, pCur->cb); break; @@ -6169,4 +6189,15 @@ 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); rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) / 8); + break; + + case SSMFIELDTRANS_OLD_PAD_HC: + AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); + rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb)); + break; + + case SSMFIELDTRANS_OLD_PAD_MSC32: + AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE); + if (ssmR3IsHostMsc32(pSSM)) + rc = SSMR3Skip(pSSM, pCur->cb); break;