VirtualBox

Changeset 49800 in vbox


Ignore:
Timestamp:
Dec 5, 2013 11:43:10 PM (11 years ago)
Author:
vboxsync
Message:

SSM: Sticky failure statuses for SSMR3PutStruct, SSMR3PutStructEx, SSMR3GetStruct, SSMR3GetStructEx and a couple of other cases.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r48986 r49800  
    35593559
    35603560            case SSMFIELDTRANS_GCPTR:
    3561                 AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3561                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    35623562                rc = SSMR3PutGCPtr(pSSM, *(PRTGCPTR)pbField);
    35633563                break;
    35643564
    35653565            case SSMFIELDTRANS_GCPHYS:
    3566                 AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3566                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    35673567                rc = SSMR3PutGCPhys(pSSM, *(PRTGCPHYS)pbField);
    35683568                break;
    35693569
    35703570            case SSMFIELDTRANS_RCPTR:
    3571                 AssertMsgReturn(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3571                AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    35723572                rc = SSMR3PutRCPtr(pSSM, *(PRTRCPTR)pbField);
    35733573                break;
    … …  
    35763576            {
    35773577                uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
    3578                 AssertMsgReturn(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3578                AssertMsgBreakStmt(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName),
     3579                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    35793580                rc = VINF_SUCCESS;
    35803581                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    … …  
    35843585
    35853586            default:
    3586                 AssertMsgFailedReturn(("%#x\n", pCur->pfnGetPutOrTransformer), VERR_SSM_FIELD_COMPLEX);
     3587                AssertMsgFailedBreakStmt(("%#x\n", pCur->pfnGetPutOrTransformer), rc = VERR_SSM_FIELD_COMPLEX);
    35873588        }
    35883589        if (RT_FAILURE(rc))
     3590        {
     3591            if (RT_SUCCESS(pSSM->rc))
     3592                pSSM->rc = rc;
    35893593            return rc;
     3594        }
    35903595    }
    35913596
    … …  
    36593664    SSM_ASSERT_WRITEABLE_RET(pSSM);
    36603665    SSM_CHECK_CANCELLED_RET(pSSM);
    3661     AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
     3666    AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), pSSM->rc = VERR_INVALID_PARAMETER);
    36623667    AssertPtr(pvStruct);
    36633668    AssertPtr(paFields);
    … …  
    36773682     * Put the fields
    36783683     */
     3684    rc = VINF_SUCCESS;
    36793685    uint32_t    off          = 0;
    36803686    for (PCSSMFIELD pCur = paFields;
    … …  
    36913697                                ? RT_HIWORD(pCur->cb)
    36923698                                : pCur->cb;
    3693         AssertMsgReturn(   cbField            <= cbStruct
    3694                         && offField + cbField <= cbStruct
    3695                         && offField + cbField >= offField,
    3696                         ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
    3697                         VERR_SSM_FIELD_OUT_OF_BOUNDS);
    3698         AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    3699                         || off == offField,
    3700                         ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
    3701                         VERR_SSM_FIELD_NOT_CONSECUTIVE);
     3699        AssertMsgBreakStmt(   cbField            <= cbStruct
     3700                           && offField + cbField <= cbStruct
     3701                           && offField + cbField >= offField,
     3702                           ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
     3703                           rc = VERR_SSM_FIELD_OUT_OF_BOUNDS);
     3704        AssertMsgBreakStmt(   !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
     3705                           || off == offField,
     3706                           ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
     3707                           rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
    37023708
    37033709        rc = VINF_SUCCESS;
    … …  
    37103716
    37113717            case SSMFIELDTRANS_GCPHYS:
    3712                 AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3718                AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName),
     3719                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37133720                rc = SSMR3PutGCPhys(pSSM, *(PRTGCPHYS)pbField);
    37143721                break;
    37153722
    37163723            case SSMFIELDTRANS_GCPTR:
    3717                 AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3724                AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName),
     3725                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37183726                rc = SSMR3PutGCPtr(pSSM, *(PRTGCPTR)pbField);
    37193727                break;
    37203728
    37213729            case SSMFIELDTRANS_RCPTR:
    3722                 AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3730                AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName),
     3731                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37233732                rc = SSMR3PutRCPtr(pSSM, *(PRTRCPTR)pbField);
    37243733                break;
    … …  
    37273736            {
    37283737                uint32_t const cEntries = cbField / sizeof(RTRCPTR);
    3729                 AssertMsgReturn(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3738                AssertMsgBreakStmt(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName),
     3739                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37303740                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    37313741                    rc = SSMR3PutRCPtr(pSSM, ((PRTRCPTR)pbField)[i]);
    … …  
    37343744
    37353745            case SSMFIELDTRANS_HCPTR_NI:
    3736                 AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3746                AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName),
     3747                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37373748                rc = ssmR3PutHCPtrNI(pSSM, *(void * const *)pbField, fFlags);
    37383749                break;
    … …  
    37413752            {
    37423753                uint32_t const cEntries = cbField / sizeof(void *);
    3743                 AssertMsgReturn(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3754                AssertMsgBreakStmt(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName),
     3755                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37443756                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    37453757                    rc = ssmR3PutHCPtrNI(pSSM, ((void * const *)pbField)[i], fFlags);
    … …  
    37483760
    37493761            case SSMFIELDTRANS_HCPTR_HACK_U32:
    3750                 AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
    3751                 AssertMsgReturn(*(uintptr_t *)pbField <= UINT32_MAX, ("%p (%s)\n", *(uintptr_t *)pbField, pCur->pszName), VERR_SSM_FIELD_INVALID_VALUE);
     3762                AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     3763                AssertMsgBreakStmt(*(uintptr_t *)pbField <= UINT32_MAX, ("%p (%s)\n", *(uintptr_t *)pbField, pCur->pszName),
     3764                                   rc = VERR_SSM_FIELD_INVALID_VALUE);
    37523765                rc = ssmR3DataWrite(pSSM, pbField, sizeof(uint32_t));
    3753                 if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && sizeof(void *) != sizeof(uint32_t))
     3766                if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && sizeof(void *) != sizeof(uint32_t) && RT_SUCCESS(rc))
    37543767                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(uint32_t));
    37553768                break;
    37563769
    37573770            case SSMFIELDTRANS_U32_ZX_U64:
    3758                 AssertFailedReturn(VERR_SSM_FIELD_LOAD_ONLY_TRANSFORMATION);
     3771                AssertFailedBreakStmt(rc = VERR_SSM_FIELD_LOAD_ONLY_TRANSFORMATION);
    37593772                break;
    37603773
    … …  
    37653778
    37663779            case SSMFIELDTRANS_IGN_GCPHYS:
    3767                 AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3780                AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    37683781                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    37693782                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPHYS));
    … …  
    37713784
    37723785            case SSMFIELDTRANS_IGN_GCPTR:
    3773                 AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3786                AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    37743787                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    37753788                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPTR));
    … …  
    37773790
    37783791            case SSMFIELDTRANS_IGN_RCPTR:
    3779                 AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3792                AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    37803793                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    37813794                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTRCPTR));
    … …  
    37833796
    37843797            case SSMFIELDTRANS_IGN_HCPTR:
    3785                 AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3798                AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    37863799                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    37873800                    rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(void *));
    … …  
    37903803
    37913804            case SSMFIELDTRANS_OLD:
    3792                 AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3805                AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    37933806                rc = ssmR3PutZeros(pSSM, pCur->cb);
    37943807                break;
    37953808
    37963809            case SSMFIELDTRANS_OLD_GCPHYS:
    3797                 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);
     3810                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName),
     3811                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    37983812                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPHYS));
    37993813                break;
    38003814
    38013815            case SSMFIELDTRANS_OLD_GCPTR:
    3802                 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);
     3816                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName),
     3817                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    38033818                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTGCPTR));
    38043819                break;
    38053820
    38063821            case SSMFIELDTRANS_OLD_RCPTR:
    3807                 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);
     3822                AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName),
     3823                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    38083824                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(RTRCPTR));
    38093825                break;
    38103826
    38113827            case SSMFIELDTRANS_OLD_HCPTR:
    3812                 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);
     3828                AssertMsgBreakStmt(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName),
     3829                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    38133830                rc = ssmR3DataWrite(pSSM, g_abZero, sizeof(void *));
    38143831                break;
    38153832
    38163833            case SSMFIELDTRANS_OLD_PAD_HC:
    3817                 AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3834                AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName),
     3835                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    38183836                rc = ssmR3PutZeros(pSSM, HC_ARCH_BITS == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
    38193837                break;
    38203838
    38213839            case SSMFIELDTRANS_OLD_PAD_MSC32:
    3822                 AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     3840                AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName),
     3841                                   rc = VERR_SSM_FIELD_INVALID_SIZE);
    38233842                if (SSM_HOST_IS_MSC_32)
    38243843                    rc = ssmR3PutZeros(pSSM, pCur->cb);
    … …  
    38423861                                       && !ssmR3IsHostMsc32(pSSM))
    38433862                                 ? cb64 : cb32;
    3844                 AssertMsgReturn(    cbField == cbCtx
    3845                                 &&  (   (   pCur->off == UINT32_MAX / 2
    3846                                          && (   cbField == 0
    3847                                              || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
    3848                                              || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
    3849                                             )
     3863                AssertMsgBreakStmt(    cbField == cbCtx
     3864                                   &&  (   (   pCur->off == UINT32_MAX / 2
     3865                                            && (   cbField == 0
     3866                                                || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
     3867                                                || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
     3868                                               )
     3869                                           )
     3870                                        || (pCur->off != UINT32_MAX / 2 && cbField != 0)
    38503871                                        )
    3851                                      || (pCur->off != UINT32_MAX / 2 && cbField != 0)
    3852                                      )
    3853                                 , ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
    3854                                    cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
    3855                                 VERR_SSM_FIELD_INVALID_PADDING_SIZE);
     3872                                   , ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
     3873                                      cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
     3874                                   rc = VERR_SSM_FIELD_INVALID_PADDING_SIZE);
    38563875                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    38573876                    rc = ssmR3PutZeros(pSSM, cbSaved);
    … …  
    38603879
    38613880            default:
    3862                 AssertPtrReturn(pCur->pfnGetPutOrTransformer, VERR_SSM_FIELD_INVALID_CALLBACK);
     3881                AssertPtrBreakStmt(pCur->pfnGetPutOrTransformer, rc = VERR_SSM_FIELD_INVALID_CALLBACK);
    38633882                rc = pCur->pfnGetPutOrTransformer(pSSM, pCur, (void *)pvStruct, fFlags, false /*fGetOrPut*/, pvUser);
    38643883                break;
    38653884        }
    38663885        if (RT_FAILURE(rc))
    3867             return rc;
     3886            break; /* Deal with failures in one place (see below). */
    38683887
    38693888        off = offField + cbField;
    38703889    }
    3871     AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    3872                     || off == cbStruct,
    3873                     ("off=%#x cbStruct=%#x\n", off, cbStruct),
    3874                     VERR_SSM_FIELD_NOT_CONSECUTIVE);
     3890
     3891    if (RT_SUCCESS(rc))
     3892        AssertMsgStmt(   !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
     3893                      || off == cbStruct,
     3894                      ("off=%#x cbStruct=%#x\n", off, cbStruct),
     3895                      rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
     3896
     3897    if (RT_FAILURE(rc))
     3898    {
     3899        if (RT_SUCCESS(pSSM->rc))
     3900            pSSM->rc = rc;
     3901        return rc;
     3902    }
    38753903
    38763904    /*
    … …  
    59215949                          && pSSM->u.Read.cbRecLeft <= RT_SIZEOFMEMB(SSMHANDLE, u.Read.abComprBuffer) + 2,
    59225950                          ("%#x\n", pSSM->u.Read.cbRecLeft),
    5923                           VERR_SSM_INTEGRITY_DECOMPRESSION);
     5951                          pSSM->rc = VERR_SSM_INTEGRITY_DECOMPRESSION);
    59245952
    59255953    uint8_t cKB;
    … …  
    59335961                          && cbDecompr <= RT_SIZEOFMEMB(SSMHANDLE, u.Read.abDataBuffer),
    59345962                          ("%#x\n", cbDecompr),
    5935                           VERR_SSM_INTEGRITY_DECOMPRESSION);
     5963                          pSSM->rc = VERR_SSM_INTEGRITY_DECOMPRESSION);
    59365964
    59375965    *pcbDecompr = cbDecompr;
    … …  
    59816009    if (RT_SUCCESS(rc))
    59826010    {
    5983         AssertLogRelMsgReturn(cbDstActual == cbDecompr, ("%#x %#x\n", cbDstActual, cbDecompr), VERR_SSM_INTEGRITY_DECOMPRESSION);
     6011        AssertLogRelMsgReturn(cbDstActual == cbDecompr, ("%#x %#x\n", cbDstActual, cbDecompr), pSSM->rc = VERR_SSM_INTEGRITY_DECOMPRESSION);
    59846012        return VINF_SUCCESS;
    59856013    }
    … …  
    60006028{
    60016029    *pcbZero = 0; /* shuts up gcc. */
    6002     AssertLogRelMsgReturn(pSSM->u.Read.cbRecLeft == 1, ("%#x\n", pSSM->u.Read.cbRecLeft), VERR_SSM_INTEGRITY_DECOMPRESSION);
     6030    AssertLogRelMsgReturn(pSSM->u.Read.cbRecLeft == 1, ("%#x\n", pSSM->u.Read.cbRecLeft), pSSM->rc = VERR_SSM_INTEGRITY_DECOMPRESSION);
    60036031
    60046032    uint8_t cKB;
    … …  
    60106038    uint32_t cbZero = (uint32_t)cKB * _1K;
    60116039    AssertLogRelMsgReturn(cbZero <= RT_SIZEOFMEMB(SSMHANDLE, u.Read.abDataBuffer),
    6012                           ("%#x\n", cbZero), VERR_SSM_INTEGRITY_DECOMPRESSION);
     6040                          ("%#x\n", cbZero), pSSM->rc = VERR_SSM_INTEGRITY_DECOMPRESSION);
    60136041
    60146042    *pcbZero = cbZero;
    … …  
    61896217 * Buffer miss, do an unbuffered read.
    61906218 *
     6219 * @returns VBox status code. Sets pSSM->rc on error.
    61916220 * @param   pSSM            The saved state handle.
    61926221 * @param   pvBuf           Where to store the read data.
    … …  
    62906319
    62916320            default:
    6292                 AssertMsgFailedReturn(("%x\n", pSSM->u.Read.u8TypeAndFlags), VERR_SSM_BAD_REC_TYPE);
     6321                AssertMsgFailedReturn(("%x\n", pSSM->u.Read.u8TypeAndFlags), pSSM->rc = VERR_SSM_BAD_REC_TYPE);
    62936322        }
    62946323
    … …  
    63936422
    63946423            default:
    6395                 AssertMsgFailedReturn(("%x\n", pSSM->u.Read.u8TypeAndFlags), VERR_SSM_BAD_REC_TYPE);
     6424                AssertMsgFailedReturn(("%x\n", pSSM->u.Read.u8TypeAndFlags), pSSM->rc = VERR_SSM_BAD_REC_TYPE);
    63966425        }
    63976426        /*pSSM->u.Read.offDataBuffer = 0;*/
    … …  
    64786507    if (RT_FAILURE(rc))
    64796508        return rc;
    6480     AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
     6509    AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
    64816510
    64826511    /* get the fields */
    … …  
    64936522
    64946523            case SSMFIELDTRANS_GCPTR:
    6495                 AssertMsgReturn(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6524                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    64966525                rc = SSMR3GetGCPtr(pSSM, (PRTGCPTR)pbField);
    64976526                break;
    64986527
    64996528            case SSMFIELDTRANS_GCPHYS:
    6500                 AssertMsgReturn(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6529                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    65016530                rc = SSMR3GetGCPhys(pSSM, (PRTGCPHYS)pbField);
    65026531                break;
    65036532
    65046533            case SSMFIELDTRANS_RCPTR:
    6505                 AssertMsgReturn(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6534                AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    65066535                rc = SSMR3GetRCPtr(pSSM, (PRTRCPTR)pbField);
    65076536                break;
    … …  
    65106539            {
    65116540                uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
    6512                 AssertMsgReturn(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6541                AssertMsgBreakStmt(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    65136542                rc = VINF_SUCCESS;
    65146543                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    … …  
    65186547
    65196548            default:
    6520                 AssertMsgFailedReturn(("%#x\n", pCur->pfnGetPutOrTransformer), VERR_SSM_FIELD_COMPLEX);
     6549                AssertMsgFailedBreakStmt(("%#x\n", pCur->pfnGetPutOrTransformer), rc = VERR_SSM_FIELD_COMPLEX);
    65216550        }
    65226551        if (RT_FAILURE(rc))
     6552        {
     6553            if (RT_SUCCESS(pSSM->rc))
     6554                pSSM->rc = rc;
    65236555            return rc;
     6556        }
    65246557    }
    65256558
    … …  
    65286561    if (RT_FAILURE(rc))
    65296562        return rc;
    6530     AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
     6563    AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
    65316564    return rc;
    65326565}
    … …  
    66016634    SSM_ASSERT_READABLE_RET(pSSM);
    66026635    SSM_CHECK_CANCELLED_RET(pSSM);
    6603     AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
     6636    AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), pSSM->rc = VERR_INVALID_PARAMETER);
    66046637    AssertPtr(pvStruct);
    66056638    AssertPtr(paFields);
    … …  
    66136646        if (RT_FAILURE(rc))
    66146647            return rc;
    6615         AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
     6648        AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
    66166649    }
    66176650
    … …  
    66376670                        && offField + cbField >= offField,
    66386671                        ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
    6639                         VERR_SSM_FIELD_OUT_OF_BOUNDS);
     6672                        pSSM->rc = VERR_SSM_FIELD_OUT_OF_BOUNDS);
    66406673        AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    66416674                        || off == offField,
    66426675                        ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
    6643                         VERR_SSM_FIELD_NOT_CONSECUTIVE);
     6676                        pSSM->rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
    66446677
    66456678        rc = VINF_SUCCESS;
    … …  
    66526685
    66536686            case SSMFIELDTRANS_GCPHYS:
    6654                 AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6687                AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66556688                rc = SSMR3GetGCPhys(pSSM, (PRTGCPHYS)pbField);
    66566689                break;
    66576690
    66586691            case SSMFIELDTRANS_GCPTR:
    6659                 AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6692                AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66606693                rc = SSMR3GetGCPtr(pSSM, (PRTGCPTR)pbField);
    66616694                break;
    66626695
    66636696            case SSMFIELDTRANS_RCPTR:
    6664                 AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6697                AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66656698                rc = SSMR3GetRCPtr(pSSM, (PRTRCPTR)pbField);
    66666699                break;
    … …  
    66696702            {
    66706703                uint32_t const cEntries = cbField / sizeof(RTRCPTR);
    6671                 AssertMsgReturn(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6704                AssertMsgBreakStmt(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66726705                rc = VINF_SUCCESS;
    66736706                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    … …  
    66776710
    66786711            case SSMFIELDTRANS_HCPTR_NI:
    6679                 AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6712                AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66806713                rc = ssmR3GetHCPtrNI(pSSM, (void **)pbField, fFlags);
    66816714                break;
    … …  
    66846717            {
    66856718                uint32_t const cEntries = cbField / sizeof(void *);
    6686                 AssertMsgReturn(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6719                AssertMsgBreakStmt(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66876720                rc = VINF_SUCCESS;
    66886721                for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
    … …  
    66926725
    66936726            case SSMFIELDTRANS_HCPTR_HACK_U32:
    6694                 AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6727                AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    66956728                *(uintptr_t *)pbField = 0;
    66966729                rc = ssmR3DataRead(pSSM, pbField, sizeof(uint32_t));
    … …  
    66996732                    uint32_t u32;
    67006733                    rc = ssmR3DataRead(pSSM, &u32, sizeof(uint32_t));
    6701                     AssertMsgReturn(RT_FAILURE(rc) || u32 == 0 || (fFlags & SSMSTRUCT_FLAGS_SAVED_AS_MEM),
    6702                                     ("high=%#x low=%#x (%s)\n", u32, *(uint32_t *)pbField, pCur->pszName),
    6703                                     VERR_SSM_FIELD_INVALID_VALUE);
     6734                    AssertMsgBreakStmt(RT_FAILURE(rc) || u32 == 0 || (fFlags & SSMSTRUCT_FLAGS_SAVED_AS_MEM),
     6735                                       ("high=%#x low=%#x (%s)\n", u32, *(uint32_t *)pbField, pCur->pszName),
     6736                                       rc = VERR_SSM_FIELD_INVALID_VALUE);
    67046737                }
    67056738                break;
    67066739
    67076740            case SSMFIELDTRANS_U32_ZX_U64:
    6708                 AssertMsgReturn(cbField == sizeof(uint64_t), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6741                AssertMsgBreakStmt(cbField == sizeof(uint64_t), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67096742                ((uint32_t *)pbField)[1] = 0;
    67106743                rc = SSMR3GetU32(pSSM, (uint32_t *)pbField);
    … …  
    67186751
    67196752            case SSMFIELDTRANS_IGN_GCPHYS:
    6720                 AssertMsgReturn(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6753                AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67216754                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    67226755                    rc = SSMR3Skip(pSSM, pSSM->u.Read.cbGCPhys);
    … …  
    67246757
    67256758            case SSMFIELDTRANS_IGN_GCPTR:
    6726                 AssertMsgReturn(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6759                AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67276760                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    67286761                    rc = SSMR3Skip(pSSM, pSSM->u.Read.cbGCPtr);
    … …  
    67306763
    67316764            case SSMFIELDTRANS_IGN_RCPTR:
    6732                 AssertMsgReturn(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6765                AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67336766                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    67346767                    rc = SSMR3Skip(pSSM, sizeof(RTRCPTR));
    … …  
    67366769
    67376770            case SSMFIELDTRANS_IGN_HCPTR:
    6738                 AssertMsgReturn(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6771                AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67396772                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    67406773                    rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) / 8);
    … …  
    67436776
    67446777            case SSMFIELDTRANS_OLD:
    6745                 AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6778                AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67466779                rc = SSMR3Skip(pSSM, pCur->cb);
    67476780                break;
    67486781
    67496782            case SSMFIELDTRANS_OLD_GCPHYS:
    6750                 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);
     6783                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67516784                rc = SSMR3Skip(pSSM, pSSM->u.Read.cbGCPhys);
    67526785                break;
    67536786
    67546787            case SSMFIELDTRANS_OLD_GCPTR:
    6755                 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);
     6788                AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67566789                rc = SSMR3Skip(pSSM, pSSM->u.Read.cbGCPtr);
    67576790                break;
    67586791
    67596792            case SSMFIELDTRANS_OLD_RCPTR:
    6760                 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);
     6793                AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67616794                rc = SSMR3Skip(pSSM, sizeof(RTRCPTR));
    67626795                break;
    67636796
    67646797            case SSMFIELDTRANS_OLD_HCPTR:
    6765                 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);
     6798                AssertMsgBreakStmt(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67666799                rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) / 8);
    67676800                break;
    67686801
    67696802            case SSMFIELDTRANS_OLD_PAD_HC:
    6770                 AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6803                AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67716804                rc = SSMR3Skip(pSSM, ssmR3GetHostBits(pSSM) == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
    67726805                break;
    67736806
    67746807            case SSMFIELDTRANS_OLD_PAD_MSC32:
    6775                 AssertMsgReturn(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), VERR_SSM_FIELD_INVALID_SIZE);
     6808                AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
    67766809                if (ssmR3IsHostMsc32(pSSM))
    67776810                    rc = SSMR3Skip(pSSM, pCur->cb);
    … …  
    67956828                                       && !ssmR3IsHostMsc32(pSSM))
    67966829                                 ? cb64 : cb32;
    6797                 AssertMsgReturn(    cbField == cbCtx
    6798                                 &&  (   (   pCur->off == UINT32_MAX / 2
    6799                                          && (   cbField == 0
    6800                                              || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
    6801                                              || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
    6802                                             )
     6830                AssertMsgBreakStmt(    cbField == cbCtx
     6831                                   &&  (   (   pCur->off == UINT32_MAX / 2
     6832                                            && (   cbField == 0
     6833                                                || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
     6834                                                || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
     6835                                               )
     6836                                           )
     6837                                        || (pCur->off != UINT32_MAX / 2 && cbField != 0)
    68036838                                        )
    6804                                      || (pCur->off != UINT32_MAX / 2 && cbField != 0)
    6805                                      )
    6806                                 , ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
    6807                                    cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
    6808                                 VERR_SSM_FIELD_INVALID_PADDING_SIZE);
     6839                                   , ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
     6840                                      cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
     6841                                   rc = VERR_SSM_FIELD_INVALID_PADDING_SIZE);
    68096842                if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
    68106843                    rc = SSMR3Skip(pSSM, cbSaved);
    … …  
    68136846
    68146847            default:
    6815                 AssertPtrReturn(pCur->pfnGetPutOrTransformer, VERR_SSM_FIELD_INVALID_CALLBACK);
     6848                AssertBreakStmt(pCur->pfnGetPutOrTransformer, rc = VERR_SSM_FIELD_INVALID_CALLBACK);
    68166849                rc = pCur->pfnGetPutOrTransformer(pSSM, pCur, pvStruct, fFlags, true /*fGetOrPut*/, pvUser);
    68176850                break;
    68186851        }
    68196852        if (RT_FAILURE(rc))
    6820             return rc;
     6853            break;
    68216854
    68226855        off = offField + cbField;
    68236856    }
    6824     AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
    6825                     || off == cbStruct,
    6826                     ("off=%#x cbStruct=%#x\n", off, cbStruct),
    6827                     VERR_SSM_FIELD_NOT_CONSECUTIVE);
     6857
     6858    if (RT_SUCCESS(rc))
     6859        AssertMsgStmt(   !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
     6860                      || off == cbStruct,
     6861                      ("off=%#x cbStruct=%#x\n", off, cbStruct),
     6862                      rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
     6863
     6864    if (RT_FAILURE(rc))
     6865    {
     6866        if (RT_SUCCESS(pSSM->rc))
     6867            pSSM->rc = rc;
     6868        return rc;
     6869    }
    68286870
    68296871    /*
    … …  
    68356877        if (RT_FAILURE(rc))
    68366878            return rc;
    6837         AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), VERR_SSM_STRUCTURE_MAGIC);
     6879        AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
    68386880    }
    68396881
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