VirtualBox

Changeset 24264 in vbox


Ignore:
Timestamp:
Nov 2, 2009 3:20:35 PM (15 years ago)
Author:
vboxsync
Message:

SSM: Added SSMR3SetLoadError[V] and SSMR3SetCfgError for setting log errors.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/ssm.h

    r23872 r24264  
    10851085VMMR3DECL(int) SSMR3Skip(PSSMHANDLE pSSM, size_t cb);
    10861086VMMR3DECL(int) SSMR3SkipToEndOfUnit(PSSMHANDLE pSSM);
     1087VMMR3DECL(int) SSMR3SetLoadError(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...);
     1088VMMR3DECL(int) SSMR3SetLoadErrorV(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va);
     1089VMMR3DECL(int) SSMR3SetCfgError(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...);
    10871090
    10881091/** @} */

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

    r24198 r24264  
    526526            /** V2: The type and flags byte fo the current record. */
    527527            uint8_t         u8TypeAndFlags;
     528
     529            /** @name Context info for SSMR3SetLoadError.
     530             * @{  */
     531            /** Pointer to the header for the current unit. */
     532            PSSMUNIT        pCurUnit;
     533            /** The version of the current unit if in the load exec stage. */
     534            uint32_t        uCurUnitVer;
     535            /** The pass number of the current unit if in the load exec stage. */
     536            uint32_t        uCurUnitPass;
     537            /** Whether SSMR3SetLoadError[V] has been called. */
     538            bool            fHaveSetError;
     539            /** @} */
    528540
    529541            /** RTGCPHYS size in bytes. (Only applicable when loading/reading.) */
    … …  
    68306842
    68316843/**
     6844 * VMSetError wrapper for load errors that inserts the saved state details.
     6845 *
     6846 * @returns rc.
     6847 * @param   pSSM                The saved state handle.
     6848 * @param   rc                  The status code of the error. Use RT_SRC_POS.
     6849 * @param   RT_SRC_POS_DECL     The source location.
     6850 * @param   pszFormat           The message format string.
     6851 * @param   ...                 Variable argument list.
     6852 */
     6853VMMR3DECL(int) SSMR3SetLoadError(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
     6854{
     6855    va_list va;
     6856    va_start(va, pszFormat);
     6857    rc = SSMR3SetLoadErrorV(pSSM, rc, RT_SRC_POS_ARGS, pszFormat, va);
     6858    va_end(va);
     6859    return rc;
     6860}
     6861
     6862
     6863/**
     6864 * VMSetError wrapper for load errors that inserts the saved state details.
     6865 *
     6866 * @returns rc.
     6867 * @param   pSSM                The saved state handle.
     6868 * @param   rc                  The status code of the error.
     6869 * @param   RT_SRC_POS_DECL     The error location, use RT_SRC_POS.
     6870 * @param   pszFormat           The message format string.
     6871 * @param   va                  Variable argument list.
     6872 */
     6873VMMR3DECL(int) SSMR3SetLoadErrorV(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
     6874{
     6875    /*
     6876     * Input validations.
     6877     */
     6878    SSM_ASSERT_READABLE_RET(pSSM);
     6879    AssertPtr(pszFormat);
     6880    Assert(RT_FAILURE_NP(rc));
     6881
     6882    /*
     6883     * Forward to VMSetError with the additional info.
     6884     */
     6885    PSSMUNIT    pUnit       = pSSM->u.Read.pCurUnit;
     6886    const char *pszName     = pUnit ? pUnit->szName      : "unknown";
     6887    uint32_t    uInstance   = pUnit ? pUnit->u32Instance : 0;
     6888    va_list     vaCopy;
     6889    va_copy(vaCopy, va);
     6890    if (   pSSM->enmOp == SSMSTATE_LOAD_EXEC
     6891        && pSSM->u.Read.uCurUnitPass == SSM_PASS_FINAL)
     6892        rc = VMSetError(pSSM->pVM, rc, RT_SRC_POS_ARGS, N_("%s#u: %N [ver=%u pass=final]"),
     6893                        pszName, uInstance,
     6894                        pszFormat, &vaCopy,
     6895                        pSSM->u.Read.uCurUnitVer);
     6896    else if (pSSM->enmOp == SSMSTATE_LOAD_EXEC)
     6897        rc = VMSetError(pSSM->pVM, rc, RT_SRC_POS_ARGS, N_("%s#u: %N [ver=%u pass=#%u]"),
     6898                        pszName, uInstance,
     6899                        pszFormat, &vaCopy,
     6900                        pSSM->u.Read.uCurUnitVer, pSSM->u.Read.uCurUnitPass);
     6901    else if (pSSM->enmOp == SSMSTATE_LOAD_PREP)
     6902        rc = VMSetError(pSSM->pVM, rc, RT_SRC_POS_ARGS, N_("%s#u: %N [prep]"),
     6903                        pszName, uInstance,
     6904                        pszFormat, &vaCopy);
     6905    else if (pSSM->enmOp == SSMSTATE_LOAD_DONE)
     6906        rc = VMSetError(pSSM->pVM, rc, RT_SRC_POS_ARGS, N_("%s#u: %N [done]"),
     6907                        pszName, uInstance,
     6908                        pszFormat, &vaCopy);
     6909    else if (pSSM->enmOp == SSMSTATE_OPEN_READ)
     6910        rc = VMSetError(pSSM->pVM, rc, RT_SRC_POS_ARGS, N_("%s#u: %N [read]"),
     6911                        pszName, uInstance,
     6912                        pszFormat, &vaCopy);
     6913    else
     6914        AssertFailed();
     6915    va_end(vaCopy);
     6916    pSSM->u.Read.fHaveSetError = true;
     6917    return rc;
     6918}
     6919
     6920
     6921/**
     6922 * SSMR3SetLoadError wrapper that returns VERR_SSM_LOAD_CONFIG_MISMATCH.
     6923 *
     6924 * @returns VERR_SSM_LOAD_CONFIG_MISMATCH.
     6925 * @param   pSSM                The saved state handle.
     6926 * @param   RT_SRC_POS_DECL     The error location, use RT_SRC_POS.
     6927 * @param   pszFormat           The message format string.
     6928 * @param   va                  Variable argument list.
     6929 */
     6930VMMR3DECL(int) SSMR3SetCfgError(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...)
     6931{
     6932    va_list va;
     6933    va_start(va, pszFormat);
     6934    int rc = SSMR3SetLoadErrorV(pSSM, VERR_SSM_LOAD_CONFIG_MISMATCH, RT_SRC_POS_ARGS, pszFormat, va);
     6935    va_end(va);
     6936    return rc;
     6937}
     6938
     6939
     6940/**
    68326941 * Calculate the checksum of a file portion.
    68336942 *
    … …  
    73407449    pSSM->u.Read.fEndOfData     = 0;
    73417450    pSSM->u.Read.u8TypeAndFlags = 0;
     7451
     7452    pSSM->u.Read.pCurUnit       = NULL;
     7453    pSSM->u.Read.uCurUnitVer    = UINT32_MAX;
     7454    pSSM->u.Read.uCurUnitPass   = 0;
     7455    pSSM->u.Read.fHaveSetError  = false;
    73427456
    73437457    /*
    … …  
    74637577                        pSSM->cbUnitLeftV1 = UnitHdr.cbUnit - RT_OFFSETOF(SSMFILEUNITHDRV1, szName[UnitHdr.cchName]);
    74647578                        pSSM->offUnit = 0;
     7579                        pSSM->u.Read.uCurUnitVer  = UnitHdr.u32Version;
     7580                        pSSM->u.Read.uCurUnitPass = SSM_PASS_FINAL;
     7581                        pSSM->u.Read.pCurUnit     = pUnit;
    74657582                        if (!pUnit->u.Common.pfnLoadExec)
    74667583                        {
    … …  
    75157632                            {
    75167633                                LogRel(("SSM: Unit '%s' read %lld bytes too much!\n", pszName, i64Diff));
    7517                                 rc = VMSetError(pVM, VERR_SSM_LOADED_TOO_MUCH, RT_SRC_POS,
    7518                                                 N_("Unit '%s' read %lld bytes too much"), pszName, i64Diff);
     7634                                if (!pSSM->u.Read.fHaveSetError)
     7635                                    rc = VMSetError(pVM, VERR_SSM_LOADED_TOO_MUCH, RT_SRC_POS,
     7636                                                    N_("Unit '%s' read %lld bytes too much"), pszName, i64Diff);
    75197637                                break;
    75207638                            }
    … …  
    75267644                            LogRel(("SSM: Load exec failed for '%s' instance #%u ! (version %u)\n",
    75277645                                    pszName, UnitHdr.u32Instance, UnitHdr.u32Version));
    7528                             VMSetError(pVM, rc, RT_SRC_POS, N_("Load exec failed for '%s' instance #%u (version %u)"),
    7529                                        pszName, UnitHdr.u32Instance, UnitHdr.u32Version);
     7646                            if (!pSSM->u.Read.fHaveSetError)
     7647                                VMSetError(pVM, rc, RT_SRC_POS, N_("Load exec failed for '%s' instance #%u (version %u)"),
     7648                                           pszName, UnitHdr.u32Instance, UnitHdr.u32Version);
    75307649                            break;
    75317650                        }
     7651
     7652                        pSSM->u.Read.pCurUnit       = NULL;
     7653                        pSSM->u.Read.uCurUnitVer    = UINT32_MAX;
     7654                        pSSM->u.Read.uCurUnitPass   = 0;
    75327655                    }
    75337656                    else
    … …  
    77497872                                  ("SSM: No load exec callback for unit '%s'!\n", UnitHdr.szName),
    77507873                                  VERR_SSM_NO_LOAD_EXEC);
     7874            pSSM->u.Read.uCurUnitVer  = UnitHdr.u32Version;
     7875            pSSM->u.Read.uCurUnitPass = UnitHdr.u32Pass;
     7876            pSSM->u.Read.pCurUnit     = pUnit;
    77517877            ssmR3DataReadBeginV2(pSSM);
    77527878            switch (pUnit->enmType)
    … …  
    77787904                LogRel(("SSM: LoadExec failed for '%s' instance #%u (version %u, pass %#x): %Rrc\n",
    77797905                        UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Version, UnitHdr.u32Pass, rc));
    7780                 return VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to load unit '%s'"), UnitHdr.szName);
     7906                if (!pSSM->u.Read.fHaveSetError)
     7907                    rc = VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to load unit '%s'"), UnitHdr.szName);
     7908                return rc;
    77817909            }
    77827910        }
    … …  
    79018029            if (pUnit->u.Common.pfnLoadPrep)
    79028030            {
     8031                Handle.u.Read.pCurUnit = pUnit;
    79038032                pUnit->fCalled = true;
    79048033                switch (pUnit->enmType)
    … …  
    79208049                        break;
    79218050                }
     8051                Handle.u.Read.pCurUnit = NULL;
    79228052                if (RT_FAILURE(rc) && RT_SUCCESS_NP(Handle.rc))
    79238053                    Handle.rc = rc;
    … …  
    79488078            else
    79498079                rc = ssmR3LoadExecV1(pVM, &Handle);
     8080            Handle.u.Read.pCurUnit       = NULL;
     8081            Handle.u.Read.uCurUnitVer    = UINT32_MAX;
     8082            Handle.u.Read.uCurUnitPass   = 0;
    79508083
    79518084            /* (progress should be pending 99% now) */
    … …  
    79668099                    || (!pUnit->u.Common.pfnLoadPrep && !pUnit->u.Common.pfnLoadExec)))
    79678100            {
     8101                Handle.u.Read.pCurUnit = pUnit;
    79688102                int const rcOld = Handle.rc;
    79698103                rc = VINF_SUCCESS;
    … …  
    79868120                        break;
    79878121                }
     8122                Handle.u.Read.pCurUnit = NULL;
    79888123                if (RT_SUCCESS(rc) && Handle.rc != rcOld)
    79898124                    rc = Handle.rc;
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