VirtualBox

Changeset 23764 in vbox


Ignore:
Timestamp:
Oct 14, 2009 2:46:55 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
53500
Message:

SSM: More structure serialization and deserialization features.

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/err.h

    r23752 r23764  
    609609/** The field contains an invalid callback or transformation index. */
    610610#define VERR_SSM_FIELD_INVALID_CALLBACK         (-1868)
     611/** The field contains an invalid padding size. */
     612#define VERR_SSM_FIELD_INVALID_PADDING_SIZE     (-1869)
    611613/** @} */
    612614

  • trunk/include/VBox/ssm.h

    r23752 r23764  
    138138    /** Guest context (GC) physical address. */
    139139    SSMFIELDTRANS_GCPHYS,
     140    /** Raw-mode context (RC) virtual address. */
     141    SSMFIELDTRANS_RCPTR,
     142    /** Array of raw-mode context (RC) virtual addresses. */
     143    SSMFIELDTRANS_RCPTR_ARRAY,
     144    /** Host context (HC) virtual address used as a NULL indicator. See
     145     * SSMFIELD_ENTRY_HCPTR_NI. */
     146    SSMFIELDTRANS_HCPTR_NI,
     147    /** Array of SSMFIELDTRANS_HCPTR_NI. */
     148    SSMFIELDTRANS_HCPTR_NI_ARRAY,
    140149    /** Ignorable Host context (HC) virtual address. See SSMFIELD_ENTRY_HCPTR. */
    141150    SSMFIELDTRANS_HCPTR,
    142151    /** Ignorable field. See SSMFIELD_ENTRY_IGNORE. */
    143     SSMFIELDTRANS_IGNORE
     152    SSMFIELDTRANS_IGNORE,
     153    /** Padding that differs between 32-bit and 64-bit hosts.
     154     * The first  byte of SSMFIELD::cb contains the size for 32-bit hosts.
     155     * The second byte of SSMFIELD::cb contains the size for 64-bit hosts.
     156     * The upper  word of SSMFIELD::cb contains the actual field size.
     157     */
     158    SSMFIELDTRANS_PAD_HC,
     159    /** Padding for 32-bit hosts only.
     160     * SSMFIELD::cb has the same format as for SSMFIELDTRANS_PAD_HC. */
     161    SSMFIELDTRANS_PAD_HC32,
     162    /** Padding for 64-bit hosts only.
     163     * SSMFIELD::cb has the same format as for SSMFIELDTRANS_PAD_HC. */
     164    SSMFIELDTRANS_PAD_HC64,
     165    /** Automatic compiler padding that may differ between 32-bit and
     166     * 64-bit hosts. SSMFIELD::cb has the same format as for
     167     * SSMFIELDTRANS_PAD_HC. */
     168    SSMFIELDTRANS_PAD_HC_AUTO
    144169} SSMFIELDTRANS;
     170
     171/** Tests if it's a padding field with the special SSMFIELD::cb format.
     172 * @returns true / false.
     173 * @param   pfn     The SSMFIELD::pfnGetPutOrTransformer value.
     174 */
     175#define SSMFIELDTRANS_IS_PADDING(pfn)   \
     176    (   (uintptr_t)(pfn) >= SSMFIELDTRANS_PAD_HC && (uintptr_t)(pfn) <= SSMFIELDTRANS_PAD_HC_AUTO )
    145177
    146178/**
    … …  
    155187    /** The size of the field. */
    156188    uint32_t            cb;
     189    /** Field name. */
     190    const char         *pszName;
    157191} SSMFIELD;
    158192
    … …  
    163197        (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \
    164198        RT_OFFSETOF(Type, Field), \
    165         RT_SIZEOFMEMB(Type, Field) \
     199        RT_SIZEOFMEMB(Type, Field), \
     200        #Type "::" #Field \
    166201    }
     202/** Emit a SSMFIELD array entry for an alignment padding.
     203 * @internal  */
     204#define SSMFIELD_ENTRY_PAD_INT(Type, Field, cb32, cb64, enmTransformer) \
     205    { \
     206        (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \
     207        RT_OFFSETOF(Type, Field), \
     208        (RT_SIZEOFMEMB(Type, Field) << 16) | (cb32) | ((cb64) << 8), \
     209        #Type "::" #Field \
     210    }
     211/** Emit a SSMFIELD array entry for an alignment padding.
     212 * @internal  */
     213#define SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, cb32, cb64, enmTransformer) \
     214    { \
     215        (PFNSSMFIELDGETPUT)(uintptr_t)(enmTransformer), \
     216        UINT32_MAX / 2, \
     217        (0 | (cb32) | ((cb64) << 8), \
     218        #Type "::" #Field \
     219    }
     220
    167221/** Emit a SSMFIELD array entry. */
    168 #define SSMFIELD_ENTRY(Type, Field)         SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_NO_TRANSFORMATION)
     222#define SSMFIELD_ENTRY(Type, Field)                 SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_NO_TRANSFORMATION)
    169223/** Emit a SSMFIELD array entry for a RTGCPTR type. */
    170 #define SSMFIELD_ENTRY_GCPTR(Type, Field)   SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_GCPTR)
     224#define SSMFIELD_ENTRY_GCPTR(Type, Field)           SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_GCPTR)
    171225/** Emit a SSMFIELD array entry for a RTGCPHYS type. */
    172 #define SSMFIELD_ENTRY_GCPHYS(Type, Field)  SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_GCPHYS)
     226#define SSMFIELD_ENTRY_GCPHYS(Type, Field)          SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_GCPHYS)
     227/** Emit a SSMFIELD array entry for a raw-mode context pointer. */
     228#define SSMFIELD_ENTRY_RCPTR(Type, Field)           SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_RCPTR)
     229/** Emit a SSMFIELD array entry for a raw-mode context pointer. */
     230#define SSMFIELD_ENTRY_RCPTR_ARRAY(Type, Field)     SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_RCPTR_ARRAY)
     231/** Emit a SSMFIELD array entry for a ring-0 or ring-3 pointer type that is only
     232 * of interest as a NULL indicator.
     233 *
     234 * This is always restored as a 0 (NULL) or 1 value.  When
     235 * SSMSTRUCT_FLAGS_DONT_IGNORE is set, the pointer will be saved in its
     236 * entirety, when clear it will be saved as a boolean. */
     237#define SSMFIELD_ENTRY_HCPTR_NI(Type, Field)        SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI)
     238/** Same as SSMFIELD_ENTRY_HCPTR_NI, except it's an array of the buggers. */
     239#define SSMFIELD_ENTRY_HCPTR_NI_ARRAY(Type, Field)  SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR_NI_ARRAY)
    173240/** Emit a SSMFIELD array entry for a ring-0 or ring-3 pointer type that is
    174241 * of no real interest to the saved state.  It follows the same save and restore
    175242 * rules as SSMFIELD_ENTRY_IGNORE. */
    176 #define SSMFIELD_ENTRY_HCPTR(Type, Field)   SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR)
     243#define SSMFIELD_ENTRY_HCPTR(Type, Field)           SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_HCPTR)
    177244/** Emit a SSMFIELD array entry for a field that can be ignored.
    178245 * It is stored as zeros if SSMSTRUCT_FLAGS_DONT_IGNORE is specified to
    179246 * SSMR3PutStructEx.  The member is never touched upon restore. */
    180 #define SSMFIELD_ENTRY_IGNORE(Type, Field)  SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGNORE)
     247#define SSMFIELD_ENTRY_IGNORE(Type, Field)          SSMFIELD_ENTRY_INT(Type, Field, SSMFIELDTRANS_IGNORE)
     248/** Emit a SSMFIELD array entry for a padding that differs in size between
     249 * 64-bit and 32-bit hosts. */
     250#define SSMFIELD_ENTRY_PAD_HC(Type, Field, cb32, cb64) SSMFIELD_ENTRY_PAD_INT(   Type, Field, cb32, cb64, SSMFIELDTRANS_PAD_HC)
     251/** Emit a SSMFIELD array entry for a padding that is exclusive to 64-bit hosts. */
     252#if HC_ARCH_BITS == 64
     253# define SSMFIELD_ENTRY_PAD_HC64(Type, Field, cb)   SSMFIELD_ENTRY_PAD_INT(      Type, Field, 0, cb, SSMFIELDTRANS_PAD_HC64)
     254#else
     255# define SSMFIELD_ENTRY_PAD_HC64(Type, Field, cb)   SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, 0, cb, SSMFIELDTRANS_PAD_HC64)
     256#endif
     257/** Emit a SSMFIELD array entry for a 32-bit padding for on 64-bits hosts.  */
     258#if HC_ARCH_BITS == 32
     259# define SSMFIELD_ENTRY_PAD_HC32(Type, Field, cb)   SSMFIELD_ENTRY_PAD_INT(      Type, Field, cb, 0, SSMFIELDTRANS_PAD_HC32)
     260#else
     261# define SSMFIELD_ENTRY_PAD_HC32(Type, Field, cb)   SSMFIELD_ENTRY_PAD_OTHER_INT(Type, Field, cb, 0, SSMFIELDTRANS_PAD_HC32)
     262#endif
     263/** Emit a SSMFIELD array entry for an automatic compiler padding that may
     264 * differ in size between 64-bit and 32-bit hosts. */
     265#if HC_ARCH_BITS == 64
     266# define SSMFIELD_ENTRY_PAD_HC_AUTO(cb32, cb64) \
     267    { \
     268        (PFNSSMFIELDGETPUT)(uintptr_t)(SSMFIELDTRANS_PAD_HC_AUTO), \
     269        UINT32_MAX / 2, \
     270        (cb64 << 16) | (cb32) | ((cb64) << 8), \
     271        "<compiler-padding>" \
     272    }
     273#else
     274# define SSMFIELD_ENTRY_PAD_HC_AUTO(cb32, cb64) \
     275    { \
     276        (PFNSSMFIELDGETPUT)(uintptr_t)(SSMFIELDTRANS_PAD_HC_AUTO), \
     277        UINT32_MAX / 2, \
     278        (cb32 << 16) | (cb32) | ((cb64) << 8), \
     279        "<compiler-padding>" \
     280    }
     281#endif
     282
    181283/** Emit a SSMFIELD array entry for a field with a custom callback. */
    182284#define SSMFIELD_ENTRY_CALLBACK(Type, Field, pfnGetPut) \
    183     { (pfnGetPut), RT_OFFSETOF(Type, Field), RT_SIZEOFMEMB(Type, Field) }
     285    { (pfnGetPut), RT_OFFSETOF(Type, Field), RT_SIZEOFMEMB(Type, Field), #Type "::" #Field }
    184286/** Emit the terminating entry of a SSMFIELD array. */
    185 #define SSMFIELD_ENTRY_TERM()               { (PFNSSMFIELDGETPUT)(uintptr_t)SSMFIELDTRANS_INVALID, UINT32_MAX, UINT32_MAX }
     287#define SSMFIELD_ENTRY_TERM()               { (PFNSSMFIELDGETPUT)(uintptr_t)SSMFIELDTRANS_INVALID, UINT32_MAX, UINT32_MAX, NULL }
    186288
    187289
    … …  
    827929VMMR3DECL(SSMAFTER)     SSMR3HandleGetAfter(PSSMHANDLE pSSM);
    828930VMMR3DECL(bool)         SSMR3HandleIsLiveSave(PSSMHANDLE pSSM);
     931VMMR3DECL(uint32_t)     SSMR3HandleHostBits(PSSMHANDLE pSSM);
    829932VMMR3_INT_DECL(int)     SSMR3SetGCPtrSize(PSSMHANDLE pSSM, unsigned cbGCPtr);
    830933VMMR3DECL(int)          SSMR3Cancel(PVM pVM);

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

    r23761 r23764  
    20792079        if (pStrm->hIoThread != NIL_RTTHREAD)
    20802080        {
    2081             int rc2 = RTSemEventSignal(pStrm->hEvtHead);
     2081            int rc2 = RTSemEventSignal(pStrm->hEvtFree);
    20822082            AssertLogRelRC(rc2);
    20832083            int rc3 = RTThreadWait(pStrm->hIoThread, RT_INDEFINITE_WAIT, NULL);
    … …  
    28182818
    28192819/**
     2820 * Gets the host bit count.
     2821 *
     2822 * Works for on both save and load handles.
     2823 *
     2824 * @returns 32 or 64.
     2825 * @param   pSSM                The saved state handle.
     2826 */
     2827DECLINLINE(uint32_t) ssmR3GetHostBits(PSSMHANDLE pSSM)
     2828{
     2829    if (pSSM->enmOp >= SSMSTATE_LOAD_PREP)
     2830    {
     2831        uint32_t cBits = pSSM->u.Read.cHostBits;
     2832        if (cBits)
     2833            return cBits;
     2834    }
     2835    return HC_ARCH_BITS;
     2836}
     2837
     2838
     2839/**
    28202840 * Finishes a data unit.
    28212841 * All buffers and compressor instances are flushed and destroyed.
    28222842 *
    28232843 * @returns VBox status.
    2824  * @param   pSSM            SSM operation handle.
     2844 * @param   pSSM            The saved state handle.
    28252845 */
    28262846static int ssmR3DataWriteFinish(PSSMHANDLE pSSM)
    … …  
    31763196
    31773197            case SSMFIELDTRANS_GCPTR:
    3178                 AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     3198                AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    31793199                rc = SSMR3PutGCPtr(pSSM, *(PRTGCPTR)pbField);
    31803200                break;
    31813201
    31823202            case SSMFIELDTRANS_GCPHYS:
    3183                 AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     3203                AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    31843204                rc = SSMR3PutGCPhys(pSSM, *(PRTGCPHYS)pbField);
    31853205                break;
    31863206
     3207            case SSMFIELDTRANS_RCPTR:
     3208                AssertMsgReturn(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3209                rc = SSMR3PutRCPtr(pSSM, *(PRTRCPTR)pbField);
     3210                break;
     3211
     3212            case SSMFIELDTRANS_RCPTR_ARRAY:
     3213            {
     3214                uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
     3215                AssertMsgReturn(pCur->cb == cEntries * sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3216                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     3217                    rc = SSMR3PutRCPtr(pSSM, ((PRTRCPTR)pbField)[i]);
     3218                break;
     3219            }
     3220
    31873221            default:
    31883222                AssertMsgFailedReturn(("%#x\n", pCur->pfnGetPutOrTransformer), VERR_SSM_FIELD_COMPLEX);
    … …  
    31943228    /* end marker */
    31953229    return SSMR3PutU32(pSSM, SSMR3STRUCT_END);
     3230}
     3231
     3232
     3233/**
     3234 * SSMR3PutStructEx helper that puts a HCPTR that is used as a NULL indicator.
     3235 *
     3236 * @returns VBox status code.
     3237 *
     3238 * @param   pSSM            The saved state handle.
     3239 * @param   pv              The value to put.
     3240 * @param   fFlags          SSMSTRUCT_FLAGS_XXX.
     3241 */
     3242DECLINLINE(int) ssmR3PutHCPtrNI(PSSMHANDLE pSSM, void *pv, uint32_t fFlags)
     3243{
     3244    int rc;
     3245    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     3246        rc = ssmR3DataWrite(pSSM, &pv, sizeof(void *));
     3247    else
     3248        rc = SSMR3PutBool(pSSM, pv != NULL);
     3249    return rc;
    31963250}
    31973251
    … …  
    32443298         pCur++)
    32453299    {
    3246         AssertMsgReturn(   pCur->cb             <= cbStruct
    3247                         && pCur->off + pCur->cb <= cbStruct
    3248                         && pCur->off + pCur->cb >  pCur->off,
    3249                         ("off=%#x cb=%#x cbStruct=%#x\n", pCur->cb, pCur->off, cbStruct),
     3300        uint32_t const offField = !SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer) || pCur->off != UINT32_MAX / 2
     3301                                ? pCur->off
     3302                                : off;
     3303        uint32_t const cbField  = !SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer)
     3304                                ? pCur->cb
     3305                                : RT_HIWORD(pCur->cb);
     3306        AssertMsgReturn(   cbField            <= cbStruct
     3307                        && offField + cbField <= cbStruct
     3308                        && offField + cbField >= offField,
     3309                        ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
    32503310                        VERR_SSM_FIELD_OUT_OF_BOUNDS);
    32513311        AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    3252                         || off == pCur->off,
    3253                         ("off=%#x pCur->off=%#x\n", off, pCur->off),
     3312                        || off == offField,
     3313                        ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
    32543314                        VERR_SSM_FIELD_NOT_CONSECUTIVE);
    32553315
    3256         uint8_t const *pbField = (uint8_t const *)pvStruct + pCur->off;
     3316        uint8_t const *pbField = (uint8_t const *)pvStruct + offField;
    32573317        switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
    32583318        {
    32593319            case SSMFIELDTRANS_NO_TRANSFORMATION:
    3260                 rc = ssmR3DataWrite(pSSM, pbField, pCur->cb);
     3320                rc = ssmR3DataWrite(pSSM, pbField, cbField);
    32613321                break;
    32623322
    32633323            case SSMFIELDTRANS_GCPTR:
    3264                 AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     3324                AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    32653325                rc = SSMR3PutGCPtr(pSSM, *(PRTGCPTR)pbField);
    32663326                break;
    32673327
    32683328            case SSMFIELDTRANS_GCPHYS:
    3269                 AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     3329                AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    32703330                rc = SSMR3PutGCPhys(pSSM, *(PRTGCPHYS)pbField);
    32713331                break;
    32723332
     3333            case SSMFIELDTRANS_RCPTR:
     3334                AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3335                rc = SSMR3PutRCPtr(pSSM, *(PRTRCPTR)pbField);
     3336                break;
     3337
     3338            case SSMFIELDTRANS_RCPTR_ARRAY:
     3339            {
     3340                uint32_t const cEntries = cbField / sizeof(RTRCPTR);
     3341                AssertMsgReturn(cbField == cEntries * sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3342                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     3343                    rc = SSMR3PutRCPtr(pSSM, ((PRTRCPTR)pbField)[i]);
     3344                break;
     3345            }
     3346
     3347            case SSMFIELDTRANS_HCPTR_NI:
     3348                AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3349                rc = ssmR3PutHCPtrNI(pSSM, *(void * const *)pbField, fFlags);
     3350                break;
     3351
     3352            case SSMFIELDTRANS_HCPTR_NI_ARRAY:
     3353            {
     3354                uint32_t const cEntries = cbField / sizeof(void *);
     3355                AssertMsgReturn(cbField == cEntries * sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3356                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     3357                    rc = ssmR3PutHCPtrNI(pSSM, ((void * const *)pbField)[i], fFlags);
     3358                break;
     3359            }
     3360
    32733361            case SSMFIELDTRANS_HCPTR:
    3274                 AssertMsgReturn(pCur->cb == sizeof(void *), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     3362                AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    32753363                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    32763364                    rc = ssmR3DataWrite(pSSM, s_abZero, sizeof(void *));
    … …  
    32813369                {
    32823370                    uint32_t cb;
    3283                     for (uint32_t cbLeft = pCur->cb; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb)
     3371                    for (uint32_t cbLeft = cbField; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb)
    32843372                    {
    32853373                        cb = RT_MIN(sizeof(s_abZero), cbLeft);
    … …  
    32893377                break;
    32903378
     3379            case SSMFIELDTRANS_PAD_HC:
     3380            case SSMFIELDTRANS_PAD_HC32:
     3381            case SSMFIELDTRANS_PAD_HC64:
     3382            case SSMFIELDTRANS_PAD_HC_AUTO:
     3383            {
     3384                uint32_t cb32    = RT_BYTE1(pCur->cb);
     3385                uint32_t cb64    = RT_BYTE2(pCur->cb);
     3386                uint32_t cbCtx   = HC_ARCH_BITS           == 64 ? cb64 : cb32;
     3387                uint32_t cbSaved = ssmR3GetHostBits(pSSM) == 64 ? cb64 : cb32;
     3388                AssertMsgReturn(    cbField == cbCtx
     3389                                &&  (   (   pCur->off == UINT32_MAX / 2
     3390                                         && (   cbField == 0
     3391                                             || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO))
     3392                                     || (pCur->off != UINT32_MAX / 2 && cbField != 0)),
     3393                                ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
     3394                                 cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
     3395                                VERR_SSM_FIELD_INVALID_PADDING_SIZE);
     3396                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     3397                {
     3398                    uint32_t cb;
     3399                    for (uint32_t cbLeft = cbSaved; cbLeft > 0 && RT_SUCCESS(rc); cbLeft -= cb)
     3400                    {
     3401                        cb = RT_MIN(sizeof(s_abZero), cbLeft);
     3402                        rc = ssmR3DataWrite(pSSM, s_abZero, cb);
     3403                    }
     3404                }
     3405                break;
     3406            }
     3407
    32913408            default:
    32923409                AssertPtrReturn(pCur->pfnGetPutOrTransformer, VERR_SSM_FIELD_INVALID_CALLBACK);
    … …  
    32973414            return rc;
    32983415
    3299         off = pCur->off + pCur->cb;
     3416        off = offField + cbField;
    33003417    }
    33013418    AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    … …  
    33223439 *
    33233440 * @returns VBox status.
    3324  * @param   pSSM            SSM operation handle.
     3441 * @param   pSSM            The saved state handle.
    33253442 * @param   fBool           Item to save.
    33263443 */
    … …  
    33383455 *
    33393456 * @returns VBox status.
    3340  * @param   pSSM            SSM operation handle.
     3457 * @param   pSSM            The saved state handle.
    33413458 * @param   u8              Item to save.
    33423459 */
    … …  
    33533470 *
    33543471 * @returns VBox status.
    3355  * @param   pSSM            SSM operation handle.
     3472 * @param   pSSM            The saved state handle.
    33563473 * @param   i8              Item to save.
    33573474 */
    … …  
    33683485 *
    33693486 * @returns VBox status.
    3370  * @param   pSSM            SSM operation handle.
     3487 * @param   pSSM            The saved state handle.
    33713488 * @param   u16             Item to save.
    33723489 */
    … …  
    33833500 *
    33843501 * @returns VBox status.
    3385  * @param   pSSM            SSM operation handle.
     3502 * @param   pSSM            The saved state handle.
    33863503 * @param   i16             Item to save.
    33873504 */
    … …  
    33983515 *
    33993516 * @returns VBox status.
    3400  * @param   pSSM            SSM operation handle.
     3517 * @param   pSSM            The saved state handle.
    34013518 * @param   u32             Item to save.
    34023519 */
    … …  
    34133530 *
    34143531 * @returns VBox status.
    3415  * @param   pSSM            SSM operation handle.
     3532 * @param   pSSM            The saved state handle.
    34163533 * @param   i32             Item to save.
    34173534 */
    … …  
    34283545 *
    34293546 * @returns VBox status.
    3430  * @param   pSSM            SSM operation handle.
     3547 * @param   pSSM            The saved state handle.
    34313548 * @param   u64             Item to save.
    34323549 */
    … …  
    34433560 *
    34443561 * @returns VBox status.
    3445  * @param   pSSM            SSM operation handle.
     3562 * @param   pSSM            The saved state handle.
    34463563 * @param   i64             Item to save.
    34473564 */
    … …  
    34583575 *
    34593576 * @returns VBox status.
    3460  * @param   pSSM            SSM operation handle.
     3577 * @param   pSSM            The saved state handle.
    34613578 * @param   u128            Item to save.
    34623579 */
    … …  
    34733590 *
    34743591 * @returns VBox status.
    3475  * @param   pSSM            SSM operation handle.
     3592 * @param   pSSM            The saved state handle.
    34763593 * @param   i128            Item to save.
    34773594 */
    … …  
    34883605 *
    34893606 * @returns VBox status.
    3490  * @param   pSSM            SSM operation handle.
     3607 * @param   pSSM            The saved state handle.
    34913608 * @param   u               Item to save.
    34923609 */
    … …  
    35033620 *
    35043621 * @returns VBox status.
    3505  * @param   pSSM            SSM operation handle.
     3622 * @param   pSSM            The saved state handle.
    35063623 * @param   i               Item to save.
    35073624 */
    … …  
    35183635 *
    35193636 * @returns VBox status.
    3520  * @param   pSSM            SSM operation handle.
     3637 * @param   pSSM            The saved state handle.
    35213638 * @param   u               Item to save.
    35223639 *
    … …  
    35353652 *
    35363653 * @returns VBox status.
    3537  * @param   pSSM            SSM operation handle.
     3654 * @param   pSSM            The saved state handle.
    35383655 * @param   u               Item to save.
    35393656 */
    … …  
    35503667 *
    35513668 * @returns VBox status.
    3552  * @param   pSSM            SSM operation handle.
     3669 * @param   pSSM            The saved state handle.
    35533670 * @param   GCPhys          The item to save
    35543671 */
    … …  
    35653682 *
    35663683 * @returns VBox status.
    3567  * @param   pSSM            SSM operation handle.
     3684 * @param   pSSM            The saved state handle.
    35683685 * @param   GCPhys          The item to save
    35693686 */
    … …  
    35803697 *
    35813698 * @returns VBox status.
    3582  * @param   pSSM            SSM operation handle.
     3699 * @param   pSSM            The saved state handle.
    35833700 * @param   GCPhys          The item to save
    35843701 */
    … …  
    35953712 *
    35963713 * @returns VBox status.
    3597  * @param   pSSM            SSM operation handle.
     3714 * @param   pSSM            The saved state handle.
    35983715 * @param   GCPtr           The item to save.
    35993716 */
    … …  
    36103727 *
    36113728 * @returns VBox status.
    3612  * @param   pSSM            SSM operation handle.
     3729 * @param   pSSM            The saved state handle.
    36133730 * @param   RCPtr           The item to save.
    36143731 */
    … …  
    36253742 *
    36263743 * @returns VBox status.
    3627  * @param   pSSM            SSM operation handle.
     3744 * @param   pSSM            The saved state handle.
    36283745 * @param   GCPtr           The item to save.
    36293746 */
    … …  
    36403757 *
    36413758 * @returns VBox status.
    3642  * @param   pSSM            SSM operation handle.
     3759 * @param   pSSM            The saved state handle.
    36433760 * @param   IOPort          The item to save.
    36443761 */
    … …  
    36553772 *
    36563773 * @returns VBox status.
    3657  * @param   pSSM            SSM operation handle.
     3774 * @param   pSSM            The saved state handle.
    36583775 * @param   Sel             The item to save.
    36593776 */
    … …  
    36703787 *
    36713788 * @returns VBox status.
    3672  * @param   pSSM            SSM operation handle.
     3789 * @param   pSSM            The saved state handle.
    36733790 * @param   pv              Item to save.
    36743791 * @param   cb              Size of the item.
    … …  
    36863803 *
    36873804 * @returns VBox status.
    3688  * @param   pSSM            SSM operation handle.
     3805 * @param   pSSM            The saved state handle.
    36893806 * @param   psz             Item to save.
    36903807 */
    … …  
    49315048 *
    49325049 * @returns pSSM->rc.
    4933  * @param   pSSM            SSM operation handle.
     5050 * @param   pSSM            The saved state handle.
    49345051 */
    49355052static int ssmR3DataReadFinishV1(PSSMHANDLE pSSM)
    … …  
    49855102 * Internal read worker for reading data from a version 1 unit.
    49865103 *
    4987  * @param   pSSM            SSM operation handle.
     5104 * @param   pSSM            The saved state handle.
    49885105 * @param   pvBuf           Where to store the read data.
    49895106 * @param   cbBuf           Number of bytes to read.
    … …  
    50215138 * pSSM->rc will be set on error.
    50225139 *
    5023  * @param   pSSM            SSM operation handle.
     5140 * @param   pSSM            The saved state handle.
    50245141 */
    50255142static void ssmR3DataReadBeginV2(PSSMHANDLE pSSM)
    … …  
    50435160 *
    50445161 * @returns pSSM->rc.
    5045  * @param   pSSM            SSM operation handle.
     5162 * @param   pSSM            The saved state handle.
    50465163 */
    50475164static int ssmR3DataReadFinishV2(PSSMHANDLE pSSM)
    … …  
    53755492 * Buffer miss, do an unbuffered read.
    53765493 *
    5377  * @param   pSSM            SSM operation handle.
     5494 * @param   pSSM            The saved state handle.
    53785495 * @param   pvBuf           Where to store the read data.
    53795496 * @param   cbBuf           Number of bytes to read.
    … …  
    54925609 * Buffer miss, do a buffered read.
    54935610 *
    5494  * @param   pSSM            SSM operation handle.
     5611 * @param   pSSM            The saved state handle.
    54955612 * @param   pvBuf           Where to store the read data.
    54965613 * @param   cbBuf           Number of bytes to read.
    … …  
    55995716 * Inlined worker that handles format checks and buffered reads.
    56005717 *
    5601  * @param   pSSM            SSM operation handle.
     5718 * @param   pSSM            The saved state handle.
    56025719 * @param   pvBuf           Where to store the read data.
    56035720 * @param   cbBuf           Number of bytes to read.
    … …  
    56735790
    56745791            case SSMFIELDTRANS_GCPTR:
    5675                 AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     5792                AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    56765793                rc = SSMR3GetGCPtr(pSSM, (PRTGCPTR)pbField);
    56775794                break;
    56785795
    56795796            case SSMFIELDTRANS_GCPHYS:
    5680                 AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     5797                AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    56815798                rc = SSMR3GetGCPhys(pSSM, (PRTGCPHYS)pbField);
    56825799                break;
     5800
     5801            case SSMFIELDTRANS_RCPTR:
     5802                AssertMsgReturn(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     5803                rc = SSMR3GetRCPtr(pSSM, (PRTRCPTR)pbField);
     5804                break;
     5805
     5806            case SSMFIELDTRANS_RCPTR_ARRAY:
     5807            {
     5808                uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
     5809                AssertMsgReturn(pCur->cb == cEntries * sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     5810                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     5811                    rc = SSMR3GetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
     5812                break;
     5813            }
    56835814
    56845815            default:
    … …  
    56945825        return rc;
    56955826    AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
     5827    return rc;
     5828}
     5829
     5830
     5831/**
     5832 * SSMR3GetStructEx helper that gets a HCPTR that is used as a NULL indicator.
     5833 *
     5834 * @returns VBox status code.
     5835 *
     5836 * @param   pSSM            The saved state handle.
     5837 * @param   ppv             Where to return the value (0/1).
     5838 * @param   fFlags          SSMSTRUCT_FLAGS_XXX.
     5839 */
     5840DECLINLINE(int) ssmR3GetHCPtrNI(PSSMHANDLE pSSM, void **ppv, uint32_t fFlags)
     5841{
     5842    int rc;
     5843    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     5844    {
     5845        if (ssmR3GetHostBits(pSSM) == 64)
     5846        {
     5847            uint64_t u;
     5848            rc = ssmR3DataRead(pSSM, &u, sizeof(u));
     5849            if (RT_SUCCESS(rc))
     5850                *ppv = (void *)(u ? 1 : 0);
     5851        }
     5852        else
     5853        {
     5854            uint32_t u;
     5855            rc = ssmR3DataRead(pSSM, &u, sizeof(u));
     5856            if (RT_SUCCESS(rc))
     5857                *ppv = (void *)(u ? 1 : 0);
     5858        }
     5859    }
     5860    else
     5861    {
     5862        bool f;
     5863        rc = SSMR3GetBool(pSSM, &f);
     5864        if (RT_SUCCESS(rc))
     5865            *ppv = (void *)(f ? 1 : 0);
     5866    }
    56965867    return rc;
    56975868}
    … …  
    57455916         pCur++)
    57465917    {
    5747         AssertMsgReturn(   pCur->cb             <= cbStruct
    5748                         && pCur->off + pCur->cb <= cbStruct
    5749                         && pCur->off + pCur->cb >  pCur->off,
    5750                         ("off=%#x cb=%#x cbStruct=%#x\n", pCur->cb, pCur->off, cbStruct),
     5918        uint32_t const offField = !SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer) || pCur->off != UINT32_MAX / 2
     5919                                ? pCur->off
     5920                                : off;
     5921        uint32_t const cbField  = !SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer)
     5922                                ? pCur->cb
     5923                                : RT_HIWORD(pCur->cb);
     5924        AssertMsgReturn(   cbField            <= cbStruct
     5925                        && offField + cbField <= cbStruct
     5926                        && offField + cbField >= offField,
     5927                        ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
    57515928                        VERR_SSM_FIELD_OUT_OF_BOUNDS);
    57525929        AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    5753                         || off == pCur->off,
    5754                         ("off=%#x pCur->off=%#x\n", off, pCur->off),
     5930                        || off == offField,
     5931                        ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
    57555932                        VERR_SSM_FIELD_NOT_CONSECUTIVE);
    57565933
    5757         uint8_t *pbField = (uint8_t *)pvStruct + pCur->off;
     5934        uint8_t       *pbField  = (uint8_t *)pvStruct + offField;
    57585935        switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
    57595936        {
    57605937            case SSMFIELDTRANS_NO_TRANSFORMATION:
    5761                 rc = ssmR3DataRead(pSSM, pbField, pCur->cb);
     5938                rc = ssmR3DataRead(pSSM, pbField, cbField);
    57625939                break;
    57635940
    57645941            case SSMFIELDTRANS_GCPTR:
    5765                 AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     5942                AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    57665943                rc = SSMR3GetGCPtr(pSSM, (PRTGCPTR)pbField);
    57675944                break;
    57685945
    57695946            case SSMFIELDTRANS_GCPHYS:
    5770                 AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     5947                AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    57715948                rc = SSMR3GetGCPhys(pSSM, (PRTGCPHYS)pbField);
    57725949                break;
    57735950
     5951            case SSMFIELDTRANS_RCPTR:
     5952                AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     5953                rc = SSMR3GetRCPtr(pSSM, (PRTRCPTR)pbField);
     5954                break;
     5955
     5956            case SSMFIELDTRANS_RCPTR_ARRAY:
     5957            {
     5958                uint32_t const cEntries = cbField / sizeof(RTRCPTR);
     5959                AssertMsgReturn(cbField == cEntries * sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     5960                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     5961                    rc = SSMR3GetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
     5962                break;
     5963            }
     5964
     5965            case SSMFIELDTRANS_HCPTR_NI:
     5966                AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     5967                rc = ssmR3GetHCPtrNI(pSSM, (void **)pbField, fFlags);
     5968                break;
     5969
     5970            case SSMFIELDTRANS_HCPTR_NI_ARRAY:
     5971            {
     5972                uint32_t const cEntries = cbField / sizeof(void *);
     5973                AssertMsgReturn(cbField == cEntries * sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     5974                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     5975                    rc = ssmR3GetHCPtrNI(pSSM, &((void **)pbField)[i], fFlags);
     5976                break;
     5977            }
     5978
    57745979            case SSMFIELDTRANS_HCPTR:
    5775                 AssertMsgReturn(pCur->cb == sizeof(void *), ("%#x\n", pCur->cb), VERR_SSM_FIELD_INVALID_SIZE);
     5980                AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    57765981                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    5777                     rc = SSMR3Skip(pSSM, pSSM->u.Read.cHostBits / 8);
     5982                    rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) / 8);
    57785983                break;
    57795984
    57805985            case SSMFIELDTRANS_IGNORE:
    57815986                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    5782                     rc = SSMR3Skip(pSSM, pCur->cb);
     5987                    rc = SSMR3Skip(pSSM, cbField);
    57835988                break;
     5989
     5990            case SSMFIELDTRANS_PAD_HC:
     5991            case SSMFIELDTRANS_PAD_HC32:
     5992            case SSMFIELDTRANS_PAD_HC64:
     5993            case SSMFIELDTRANS_PAD_HC_AUTO:
     5994            {
     5995                uint32_t cb32    = RT_BYTE1(pCur->cb);
     5996                uint32_t cb64    = RT_BYTE2(pCur->cb);
     5997                uint32_t cbCtx   = HC_ARCH_BITS           == 64 ? cb64 : cb32;
     5998                uint32_t cbSaved = ssmR3GetHostBits(pSSM) == 64 ? cb64 : cb32;
     5999                AssertMsgReturn(    cbField == cbCtx
     6000                                &&  (   (   pCur->off == UINT32_MAX / 2
     6001                                         && (   cbField == 0
     6002                                             || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO))
     6003                                     || (pCur->off != UINT32_MAX / 2 && cbField != 0)),
     6004                                ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
     6005                                 cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
     6006                                VERR_SSM_FIELD_INVALID_PADDING_SIZE);
     6007                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     6008                    rc = SSMR3Skip(pSSM, cbSaved);
     6009                break;
     6010            }
    57846011
    57856012            default:
    … …  
    57916018            return rc;
    57926019
    5793         off = pCur->off + pCur->cb;
     6020        off = offField + cbField;
    57946021    }
    57956022    AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    … …  
    58176044 *
    58186045 * @returns VBox status.
    5819  * @param   pSSM            SSM operation handle.
     6046 * @param   pSSM            The saved state handle.
    58206047 * @param   pfBool          Where to store the item.
    58216048 */
    … …  
    58396066 *
    58406067 * @returns VBox status.
    5841  * @param   pSSM            SSM operation handle.
     6068 * @param   pSSM            The saved state handle.
    58426069 * @param   pu8             Where to store the item.
    58436070 */
    … …  
    58546081 *
    58556082 * @returns VBox status.
    5856  * @param   pSSM            SSM operation handle.
     6083 * @param   pSSM            The saved state handle.
    58576084 * @param   pi8             Where to store the item.
    58586085 */
    … …  
    58696096 *
    58706097 * @returns VBox status.
    5871  * @param   pSSM            SSM operation handle.
     6098 * @param   pSSM            The saved state handle.
    58726099 * @param   pu16            Where to store the item.
    58736100 */
    … …  
    58846111 *
    58856112 * @returns VBox status.
    5886  * @param   pSSM            SSM operation handle.
     6113 * @param   pSSM            The saved state handle.
    58876114 * @param   pi16            Where to store the item.
    58886115 */
    … …  
    58996126 *
    59006127 * @returns VBox status.
    5901  * @param   pSSM            SSM operation handle.
     6128 * @param   pSSM            The saved state handle.
    59026129 * @param   pu32            Where to store the item.
    59036130 */
    … …  
    59146141 *
    59156142 * @returns VBox status.
    5916  * @param   pSSM            SSM operation handle.
     6143 * @param   pSSM            The saved state handle.
    59176144 * @param   pi32            Where to store the item.
    59186145 */
    … …  
    59296156 *
    59306157 * @returns VBox status.
    5931  * @param   pSSM            SSM operation handle.
     6158 * @param   pSSM            The saved state handle.
    59326159 * @param   pu64            Where to store the item.
    59336160 */
    … …  
    59446171 *
    59456172 * @returns VBox status.
    5946  * @param   pSSM            SSM operation handle.
     6173 * @param   pSSM            The saved state handle.
    59476174 * @param   pi64            Where to store the item.
    59486175 */
    … …  
    59596186 *
    59606187 * @returns VBox status.
    5961  * @param   pSSM            SSM operation handle.
     6188 * @param   pSSM            The saved state handle.
    59626189 * @param   pu128           Where to store the item.
    59636190 */
    … …  
    59746201 *
    59756202 * @returns VBox status.
    5976  * @param   pSSM            SSM operation handle.
     6203 * @param   pSSM            The saved state handle.
    59776204 * @param   pi128           Where to store the item.
    59786205 */
    … …  
    59896216 *
    59906217 * @returns VBox status.
    5991  * @param   pSSM            SSM operation handle.
     6218 * @param   pSSM            The saved state handle.
    59926219 * @param   pu              Where to store the integer.
    59936220 */
    … …  
    60046231 *
    60056232 * @returns VBox status.
    6006  * @param   pSSM            SSM operation handle.
     6233 * @param   pSSM            The saved state handle.
    60076234 * @param   pi              Where to store the integer.
    60086235 */
    … …  
    60196246 *
    60206247 * @returns VBox status.
    6021  * @param   pSSM            SSM operation handle.
     6248 * @param   pSSM            The saved state handle.
    60226249 * @param   pu              Where to store the integer.
    60236250 *
    … …  
    60356262 *
    60366263 * @returns VBox status.
    6037  * @param   pSSM            SSM operation handle.
     6264 * @param   pSSM            The saved state handle.
    60386265 * @param   pu              Where to store the integer.
    60396266 */
    … …  
    60496276 *
    60506277 * @returns VBox status.
    6051  * @param   pSSM            SSM operation handle.
     6278 * @param   pSSM            The saved state handle.
    60526279 * @param   pGCPhys         Where to store the GC physical address.
    60536280 */
    … …  
    60646291 *
    60656292 * @returns VBox status.
    6066  * @param   pSSM            SSM operation handle.
     6293 * @param   pSSM            The saved state handle.
    60676294 * @param   pGCPhys         Where to store the GC physical address.
    60686295 */
    … …  
    60796306 *
    60806307 * @returns VBox status.
    6081  * @param   pSSM            SSM operation handle.
     6308 * @param   pSSM            The saved state handle.
    60826309 * @param   pGCPhys         Where to store the GC physical address.
    60836310 */
    … …  
    61296356 *
    61306357 * @returns VBox status.
    6131  * @param   pSSM            SSM operation handle.
     6358 * @param   pSSM            The saved state handle.
    61326359 * @param   cbGCPtr         Size of RTGCPTR
    61336360 *
    … …  
    61576384 *
    61586385 * @returns VBox status.
    6159  * @param   pSSM            SSM operation handle.
     6386 * @param   pSSM            The saved state handle.
    61606387 * @param   pGCPtr          Where to store the GC virtual address.
    61616388 */
    … …  
    61996426 *
    62006427 * @returns VBox status.
    6201  * @param   pSSM            SSM operation handle.
     6428 * @param   pSSM            The saved state handle.
    62026429 * @param   pGCPtr          Where to store the GC virtual address.
    62036430 */
    … …  
    62136440 *
    62146441 * @returns VBox status.
    6215  * @param   pSSM            SSM operation handle.
     6442 * @param   pSSM            The saved state handle.
    62166443 * @param   pRCPtr          Where to store the RC virtual address.
    62176444 */
    … …  
    62286455 *
    62296456 * @returns VBox status.
    6230  * @param   pSSM            SSM operation handle.
     6457 * @param   pSSM            The saved state handle.
    62316458 * @param   pIOPort         Where to store the I/O port address.
    62326459 */
    … …  
    62436470 *
    62446471 * @returns VBox status.
    6245  * @param   pSSM            SSM operation handle.
     6472 * @param   pSSM            The saved state handle.
    62466473 * @param   pSel            Where to store the selector.
    62476474 */
    … …  
    62586485 *
    62596486 * @returns VBox status.
    6260  * @param   pSSM            SSM operation handle.
     6487 * @param   pSSM            The saved state handle.
    62616488 * @param   pv              Where to store the item.
    62626489 * @param   cb              Size of the item.
    … …  
    62746501 *
    62756502 * @returns VBox status.
    6276  * @param   pSSM            SSM operation handle.
     6503 * @param   pSSM            The saved state handle.
    62776504 * @param   psz             Where to store the item.
    62786505 * @param   cbMax           Max size of the item (including '\\0').
    … …  
    62886515 *
    62896516 * @returns VBox status.
    6290  * @param   pSSM            SSM operation handle.
     6517 * @param   pSSM            The saved state handle.
    62916518 * @param   psz             Where to store the item.
    62926519 * @param   cbMax           Max size of the item (including '\\0').
    … …  
    79628189 *
    79638190 * @returns SSMAFTER enum value.
    7964  * @param   pSSM            SSM operation handle.
     8191 * @param   pSSM            The saved state handle.
    79658192 */
    79668193VMMR3DECL(int) SSMR3HandleGetStatus(PSSMHANDLE pSSM)
    … …  
    79798206 *
    79808207 * @returns VBox status code of the handle, or VERR_INVALID_PARAMETER.
    7981  * @param   pSSM            SSM operation handle.
     8208 * @param   pSSM            The saved state handle.
    79828209 * @param   iStatus         Failure status code. This MUST be a VERR_*.
    79838210 */
    … …  
    80028229 *
    80038230 * @returns SSMAFTER enum value.
    8004  * @param   pSSM            SSM operation handle.
     8231 * @param   pSSM            The saved state handle.
    80058232 */
    80068233VMMR3DECL(SSMAFTER) SSMR3HandleGetAfter(PSSMHANDLE pSSM)
    … …  
    80158242 *
    80168243 * @returns True if it is, false if it isn't.
    8017  * @param   pSSM            SSM operation handle.
     8244 * @param   pSSM            The saved state handle.
    80188245 */
    80198246VMMR3DECL(bool) SSMR3HandleIsLiveSave(PSSMHANDLE pSSM)
    … …  
    80218248    SSM_ASSERT_VALID_HANDLE(pSSM);
    80228249    return pSSM->fLiveSave;
     8250}
     8251
     8252
     8253/**
     8254 * Gets the host bit count of a saved state.
     8255 *
     8256 * @returns 32 or 64. If pSSM is invalid, 0 is returned.
     8257 * @param   pSSM            The saved state handle.
     8258 */
     8259VMMR3DECL(uint32_t) SSMR3HandleHostBits(PSSMHANDLE pSSM)
     8260{
     8261    SSM_ASSERT_VALID_HANDLE(pSSM);
     8262    return ssmR3GetHostBits(pSSM);
    80238263}
    80248264
Note: See TracChangeset for help on using the changeset viewer.

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