VirtualBox

Changeset 24265 in vbox


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

Devices,VMM: Replaced all VERR_SSM_LOAD_CONFIG_MISMATCH returns with SSMR3SetCfgError calls.

Location:
trunk/src/VBox
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/DevSB16.cpp

    r24019 r24265  
    17551755            || port != pThis->portCfg
    17561756            || ver  != pThis->verCfg )
    1757         {
    1758             LogRel(("SB16: config changed: irq=%x/%x dma=%x/%x hdma=%x/%x port=%x/%x ver=%x/%x (saved/config)\n",
    1759                     irq,  pThis->irqCfg,
    1760                     dma,  pThis->dmaCfg,
    1761                     hdma, pThis->hdmaCfg,
    1762                     port, pThis->portCfg,
    1763                     ver,  pThis->verCfg));
    1764             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    1765         }
     1757            return SSMR3SetCfgError(pSSM, RT_SRC_POS,
     1758                                    N_("config changed: irq=%x/%x dma=%x/%x hdma=%x/%x port=%x/%x ver=%x/%x (saved/config)"),
     1759                                    irq,  pThis->irqCfg,
     1760                                    dma,  pThis->dmaCfg,
     1761                                    hdma, pThis->hdmaCfg,
     1762                                    port, pThis->portCfg,
     1763                                    ver,  pThis->verCfg);
    17661764    }
    17671765    if (uPass != SSM_PASS_FINAL)

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r24146 r24265  
    12351235 * @param   pDevIns         Device instance of the PCI Bus.
    12361236 * @param   pPciDev         Pointer to PCI device.
    1237  * @param   pSSMHandle      The handle to save the state to.
    1238  */
    1239 static DECLCALLBACK(int) pciGenericSaveExec(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSMHandle)
    1240 {
    1241     return SSMR3PutMem(pSSMHandle, &pPciDev->config[0], sizeof(pPciDev->config));
     1237 * @param   pSSM            The handle to save the state to.
     1238 */
     1239static DECLCALLBACK(int) pciGenericSaveExec(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSM)
     1240{
     1241    return SSMR3PutMem(pSSM, &pPciDev->config[0], sizeof(pPciDev->config));
    12421242}
    12431243
    … …  
    12491249 * @param   pDevIns         Device instance of the PCI Bus.
    12501250 * @param   pPciDev         Pointer to PCI device.
    1251  * @param   pSSMHandle      The handle to the saved state.
    1252  */
    1253 static DECLCALLBACK(int) pciGenericLoadExec(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSMHandle)
    1254 {
    1255     return SSMR3GetMem(pSSMHandle, &pPciDev->config[0], sizeof(pPciDev->config));
     1251 * @param   pSSM            The handle to the saved state.
     1252 */
     1253static DECLCALLBACK(int) pciGenericLoadExec(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSM)
     1254{
     1255    return SSMR3GetMem(pSSM, &pPciDev->config[0], sizeof(pPciDev->config));
    12561256}
    12571257
    … …  
    12921292 * @param   pDevIns     The device instance.
    12931293 * @param   pPciDev     Pointer to PCI device.
    1294  * @param   pSSMHandle  The handle to save the state to.
    1295  */
    1296 static DECLCALLBACK(int) pciR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
     1294 * @param   pSSM  The handle to save the state to.
     1295 */
     1296static DECLCALLBACK(int) pciR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    12971297{
    12981298    uint32_t    i;
    … …  
    13021302     * Bus state data.
    13031303     */
    1304     SSMR3PutU32(pSSMHandle, pThis->uConfigReg);
    1305     SSMR3PutBool(pSSMHandle, pThis->fUseIoApic);
     1304    SSMR3PutU32(pSSM, pThis->uConfigReg);
     1305    SSMR3PutBool(pSSM, pThis->fUseIoApic);
    13061306
    13071307    /*
    … …  
    13091309     */
    13101310    for (i = 0; i < PCI_IRQ_PINS; i++)
    1311         SSMR3PutU32(pSSMHandle, pThis->pci_irq_levels[i]);
     1311        SSMR3PutU32(pSSM, pThis->pci_irq_levels[i]);
    13121312    for (i = 0; i < PCI_APIC_IRQ_PINS; i++)
    1313         SSMR3PutU32(pSSMHandle, pThis->pci_apic_irq_levels[i]);
    1314 
    1315     SSMR3PutU32(pSSMHandle, pThis->acpi_irq_level);
    1316     SSMR3PutS32(pSSMHandle, pThis->acpi_irq);
    1317 
    1318     SSMR3PutU32(pSSMHandle, ~0);        /* separator */
     1313        SSMR3PutU32(pSSM, pThis->pci_apic_irq_levels[i]);
     1314
     1315    SSMR3PutU32(pSSM, pThis->acpi_irq_level);
     1316    SSMR3PutS32(pSSM, pThis->acpi_irq);
     1317
     1318    SSMR3PutU32(pSSM, ~0);        /* separator */
    13191319
    13201320    /*
    13211321     * Join paths with pcibridgeR3SaveExec.
    13221322     */
    1323     return pciR3CommonSaveExec(&pThis->PciBus, pSSMHandle);
     1323    return pciR3CommonSaveExec(&pThis->PciBus, pSSM);
    13241324}
    13251325
    … …  
    14961496 * @returns VBox status code.
    14971497 * @param   pBus                The bus which data is being loaded.
    1498  * @param   pSSMHandle          The saved state handle.
     1498 * @param   pSSM                The saved state handle.
    14991499 * @param   uVersion            The data version.
    15001500 * @param   uPass               The pass.
    15011501 */
    1502 static DECLCALLBACK(int) pciR3CommonLoadExec(PPCIBUS pBus, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
     1502static DECLCALLBACK(int) pciR3CommonLoadExec(PPCIBUS pBus, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    15031503{
    15041504    uint32_t    u32;
    … …  
    15371537
    15381538        /* index / terminator */
    1539         rc = SSMR3GetU32(pSSMHandle, &u32);
     1539        rc = SSMR3GetU32(pSSM, &u32);
    15401540        if (RT_FAILURE(rc))
    15411541            return rc;
    … …  
    15561556                LogRel(("New device in slot %#x, %s (vendor=%#06x device=%#06x)\n", i, pBus->devices[i]->name,
    15571557                        PCIDevGetVendorId(pBus->devices[i]), PCIDevGetDeviceId(pBus->devices[i])));
    1558                 if (SSMR3HandleGetAfter(pSSMHandle) != SSMAFTER_DEBUG_IT)
    1559                     AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
     1558                if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
     1559                    return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("New device in slot %#x, %s (vendor=%#06x device=%#06x)"),
     1560                                            i, pBus->devices[i]->name, PCIDevGetVendorId(pBus->devices[i]), PCIDevGetDeviceId(pBus->devices[i]));
    15601561            }
    15611562        }
    … …  
    15631564        /* get the data */
    15641565        DevTmp.Int.s.uIrqPinState = ~0; /* Invalid value in case we have an older saved state to force a state change in pciSetIrq. */
    1565         SSMR3GetMem(pSSMHandle, DevTmp.config, sizeof(DevTmp.config));
     1566        SSMR3GetMem(pSSM, DevTmp.config, sizeof(DevTmp.config));
    15661567        if (uVersion < 3)
    15671568        {
    15681569            int32_t i32Temp;
    15691570            /* Irq value not needed anymore. */
    1570             rc = SSMR3GetS32(pSSMHandle, &i32Temp);
     1571            rc = SSMR3GetS32(pSSM, &i32Temp);
    15711572            if (RT_FAILURE(rc))
    15721573                return rc;
    … …  
    15741575        else
    15751576        {
    1576             rc = SSMR3GetS32(pSSMHandle, &DevTmp.Int.s.uIrqPinState);
     1577            rc = SSMR3GetS32(pSSM, &DevTmp.Int.s.uIrqPinState);
    15771578            if (RT_FAILURE(rc))
    15781579                return rc;
    … …  
    15851586            LogRel(("Device in slot %#x has been removed! vendor=%#06x device=%#06x\n", i,
    15861587                    PCIDevGetVendorId(&DevTmp), PCIDevGetDeviceId(&DevTmp)));
    1587             if (SSMR3HandleGetAfter(pSSMHandle) != SSMAFTER_DEBUG_IT)
    1588                 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
     1588            if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
     1589                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device in slot %#x has been removed! vendor=%#06x device=%#06x"),
     1590                                        i, PCIDevGetVendorId(&DevTmp), PCIDevGetDeviceId(&DevTmp));
    15891591            continue;
    15901592        }
    … …  
    15931595        if (    DevTmp.config[0] != pDev->config[0]
    15941596            ||  DevTmp.config[1] != pDev->config[1])
    1595         {
    1596             LogRel(("Device in slot %#x (%s) vendor id mismatch! saved=%.4Rhxs current=%.4Rhxs\n",
    1597                     i, pDev->name, DevTmp.config, pDev->config));
    1598             AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
    1599         }
     1597            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device in slot %#x (%s) vendor id mismatch! saved=%.4Rhxs current=%.4Rhxs"),
     1598                                     i, pDev->name, DevTmp.config, pDev->config);
    16001599
    16011600        /* commit the loaded device config. */
    … …  
    16141613 * @returns VBox status code.
    16151614 * @param   pDevIns     The device instance.
    1616  * @param   pSSMHandle  The handle to the saved state.
     1615 * @param   pSSM        The handle to the saved state.
    16171616 * @param   uVersion    The data unit version number.
    16181617 * @param   uPass       The data pass.
    16191618 */
    1620 static DECLCALLBACK(int) pciR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
     1619static DECLCALLBACK(int) pciR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    16211620{
    16221621    PPCIGLOBALS pThis = PDMINS_2_DATA(pDevIns, PPCIGLOBALS);
    … …  
    16351634     * Bus state data.
    16361635     */
    1637     SSMR3GetU32(pSSMHandle, &pThis->uConfigReg);
     1636    SSMR3GetU32(pSSM, &pThis->uConfigReg);
    16381637    if (uVersion > 1)
    1639         SSMR3GetBool(pSSMHandle, &pThis->fUseIoApic);
     1638        SSMR3GetBool(pSSM, &pThis->fUseIoApic);
    16401639
    16411640    /* Load IRQ states. */
    … …  
    16431642    {
    16441643        for (uint8_t i = 0; i < PCI_IRQ_PINS; i++)
    1645             SSMR3GetU32(pSSMHandle, (uint32_t *)&pThis->pci_irq_levels[i]);
     1644            SSMR3GetU32(pSSM, (uint32_t *)&pThis->pci_irq_levels[i]);
    16461645        for (uint8_t i = 0; i < PCI_APIC_IRQ_PINS; i++)
    1647             SSMR3GetU32(pSSMHandle, (uint32_t *)&pThis->pci_apic_irq_levels[i]);
    1648 
    1649         SSMR3GetU32(pSSMHandle, &pThis->acpi_irq_level);
    1650         SSMR3GetS32(pSSMHandle, &pThis->acpi_irq);
     1646            SSMR3GetU32(pSSM, (uint32_t *)&pThis->pci_apic_irq_levels[i]);
     1647
     1648        SSMR3GetU32(pSSM, &pThis->acpi_irq_level);
     1649        SSMR3GetS32(pSSM, &pThis->acpi_irq);
    16511650    }
    16521651
    16531652    /* separator */
    1654     rc = SSMR3GetU32(pSSMHandle, &u32);
     1653    rc = SSMR3GetU32(pSSM, &u32);
    16551654    if (RT_FAILURE(rc))
    16561655        return rc;
    … …  
    16611660     * The devices.
    16621661     */
    1663     return pciR3CommonLoadExec(pBus, pSSMHandle, uVersion, uPass);
     1662    return pciR3CommonLoadExec(pBus, pSSM, uVersion, uPass);
    16641663}
    16651664
    … …  
    21912190#endif /* IN_RING3 */
    21922191
     2192
    21932193/**
    21942194 * Set the IRQ for a PCI device on a secondary bus.
    … …  
    22862286}
    22872287
    2288 /**
    2289  * Saves a state of a PCI bridge device.
    2290  *
    2291  * @returns VBox status code.
    2292  * @param   pDevIns     The device instance.
    2293  * @param   pPciDev     Pointer to PCI device.
    2294  * @param   pSSMHandle  The handle to save the state to.
    2295  */
    2296 static DECLCALLBACK(int) pcibridgeR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
     2288
     2289/**
     2290 * @copydoc FNSSMDEVSAVEEXEC
     2291 */
     2292static DECLCALLBACK(int) pcibridgeR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    22972293{
    22982294    PPCIBUS pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
    2299     return pciR3CommonSaveExec(pThis, pSSMHandle);
    2300 }
    2301 
    2302 
    2303 /**
    2304  * Loads a saved PCI bridge device state.
    2305  *
    2306  * @returns VBox status code.
    2307  * @param   pDevIns     The device instance.
    2308  * @param   pSSMHandle  The handle to the saved state.
    2309  * @param   uVersion    The data unit version number.
    2310  * @param   uPass       The data pass.
    2311  */
    2312 static DECLCALLBACK(int) pcibridgeR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t uVersion, uint32_t uPass)
     2295    return pciR3CommonSaveExec(pThis, pSSM);
     2296}
     2297
     2298
     2299/**
     2300 * @copydoc FNSSMDEVLOADEXEC
     2301 */
     2302static DECLCALLBACK(int) pcibridgeR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    23132303{
    23142304    PPCIBUS pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
    23152305    if (uVersion > VBOX_PCI_SAVED_STATE_VERSION)
    23162306        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    2317     return pciR3CommonLoadExec(pThis, pSSMHandle, uVersion, uPass);
    2318 }
    2319 
    2320 /**
    2321  * @copydoc FNPDMDEVRESET
    2322  */
    2323 static DECLCALLBACK(void) pcibridgeReset(PPDMDEVINS pDevIns)
    2324 {
    2325     PPCIBUS pBus = PDMINS_2_DATA(pDevIns, PPCIBUS);
    2326 
    2327     /* Reset config space to default values. */
    2328     pBus->PciDev.config[VBOX_PCI_PRIMARY_BUS] = 0;
    2329     pBus->PciDev.config[VBOX_PCI_SECONDARY_BUS] = 0;
    2330     pBus->PciDev.config[VBOX_PCI_SUBORDINATE_BUS] = 0;
    2331 }
    2332 
    2333 /**
    2334  * @copydoc FNPDMDEVRELOCATE
    2335  */
    2336 static DECLCALLBACK(void) pcibridgeRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
    2337 {
    2338     PPCIBUS pBus = PDMINS_2_DATA(pDevIns, PPCIBUS);
    2339     pBus->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
    2340 
    2341     /* Relocate RC pointers for the attached pci devices. */
    2342     for (uint32_t i = 0; i < RT_ELEMENTS(pBus->devices); i++)
    2343     {
    2344         if (pBus->devices[i])
    2345             pBus->devices[i]->Int.s.pBusRC += offDelta;
    2346     }
    2347 }
     2307    return pciR3CommonLoadExec(pThis, pSSM, uVersion, uPass);
     2308}
     2309
    23482310
    23492311/**
    … …  
    23602322static DECLCALLBACK(int) pcibridgeRegister(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, const char *pszName, int iDev)
    23612323{
    2362     PPCIBUS     pBus = PDMINS_2_DATA(pDevIns, PPCIBUS);
     2324    PPCIBUS pBus = PDMINS_2_DATA(pDevIns, PPCIBUS);
    23632325
    23642326    /*
    … …  
    23782340    return pciRegisterInternal(pBus, iDev, pPciDev, pszName);
    23792341}
     2342
     2343
     2344/**
     2345 * @copydoc FNPDMDEVRESET
     2346 */
     2347static DECLCALLBACK(void) pcibridgeReset(PPDMDEVINS pDevIns)
     2348{
     2349    PPCIBUS pBus = PDMINS_2_DATA(pDevIns, PPCIBUS);
     2350
     2351    /* Reset config space to default values. */
     2352    pBus->PciDev.config[VBOX_PCI_PRIMARY_BUS] = 0;
     2353    pBus->PciDev.config[VBOX_PCI_SECONDARY_BUS] = 0;
     2354    pBus->PciDev.config[VBOX_PCI_SUBORDINATE_BUS] = 0;
     2355}
     2356
     2357
     2358/**
     2359 * @copydoc FNPDMDEVRELOCATE
     2360 */
     2361static DECLCALLBACK(void) pcibridgeRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
     2362{
     2363    PPCIBUS pBus = PDMINS_2_DATA(pDevIns, PPCIBUS);
     2364    pBus->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     2365
     2366    /* Relocate RC pointers for the attached pci devices. */
     2367    for (uint32_t i = 0; i < RT_ELEMENTS(pBus->devices); i++)
     2368    {
     2369        if (pBus->devices[i])
     2370            pBus->devices[i]->Int.s.pBusRC += offDelta;
     2371    }
     2372}
     2373
    23802374
    23812375/**
    … …  
    25052499    return VINF_SUCCESS;
    25062500}
     2501
    25072502
    25082503/**

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r23985 r24265  
    54225422        AssertRCReturn(rc, rc);
    54235423        if (pThis->vram_size != cbVRam)
    5424         {
    5425             LogRel(("DevVGA: VRAM size changed: config=%#x state=%#x\n", pThis->vram_size, cbVRam));
    5426             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    5427         }
     5424            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("VRAM size changed: config=%#x state=%#x"), pThis->vram_size, cbVRam);
    54285425
    54295426        uint32_t cMonitors;
    … …  
    54315428        AssertRCReturn(rc, rc);
    54325429        if (pThis->cMonitors != cMonitors)
    5433         {
    5434             LogRel(("DevVGA: Monitor count changed: config=%u state=%u\n", pThis->cMonitors, cMonitors));
    5435             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    5436         }
     5430            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Monitor count changed: config=%u state=%u"), pThis->cMonitors, cMonitors);
    54375431    }
    54385432
    … …  
    54545448            AssertRCReturn(rc, rc);
    54555449#else
    5456             AssertLogRelFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
     5450            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("HGSMI is not compiled in, but it is present in the saved state"));
    54575451#endif
    54585452        }

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r24191 r24265  
    45984598        AssertRCReturn(rc, rc);
    45994599        if (eChip != pState->eChip)
    4600         {
    4601             LogRel(("%s: The mac address differs: config=%u saved=%u\n", INSTANCE(pState), pState->eChip, eChip));
    4602             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    4603         }
     4600            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("The chip type differs: config=%u saved=%u"), pState->eChip, eChip);
    46044601    }
    46054602

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r24191 r24265  
    44184418    AssertRCReturn(rc, rc);
    44194419    if (pThis->fAm79C973 != fAm79C973)
    4420     {
    4421         LogRel(("PCNet#%u: The fAm79C973 flag differs: config=%RTbool saved=%RTbool\n", PCNET_INST_NR, pThis->fAm79C973, fAm79C973));
    4422         return VERR_SSM_LOAD_CONFIG_MISMATCH;
    4423     }
     4420        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("The fAm79C973 flag differs: config=%RTbool saved=%RTbool"), pThis->fAm79C973, fAm79C973);
    44244421
    44254422    uint32_t    u32LinkSpeed;

  • trunk/src/VBox/Devices/PC/DevAPIC.cpp

    r24195 r24265  
    26372637        int rc = SSMR3GetU32(pSSM, &cCpus); AssertRCReturn(rc, rc);
    26382638        if (cCpus != pThis->cCpus)
    2639         {
    2640             LogRel(("APIC: Config mismatch - cCpus: saved=%#x config=%#x\n", cCpus, pThis->cCpus));
    2641             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    2642         }
     2639            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - cCpus: saved=%#x config=%#x"), cCpus, pThis->cCpus);
    26432640        bool fIoApic;
    26442641        rc = SSMR3GetBool(pSSM, &fIoApic); AssertRCReturn(rc, rc);
    26452642        if (fIoApic != pThis->fIoApic)
    2646         {
    2647             LogRel(("APIC: Config mismatch - fIoApic: saved=%RTbool config=%RTbool\n", fIoApic, pThis->fIoApic));
    2648             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    2649         }
     2643            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fIoApic: saved=%RTbool config=%RTbool"), fIoApic, pThis->fIoApic);
    26502644        uint32_t uApicVersion;
    26512645        rc = SSMR3GetU32(pSSM, &uApicVersion); AssertRCReturn(rc, rc);
    26522646        if (uApicVersion != (uint32_t)pThis->enmVersion)
    2653         {
    2654             LogRel(("APIC: Config mismatch - uApicVersion: saved=%#x config=%#x\n", uApicVersion, pThis->enmVersion));
    2655             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    2656         }
     2647            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - uApicVersion: saved=%#x config=%#x"), uApicVersion, pThis->enmVersion);
    26572648    }
    26582649

  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r24087 r24265  
    789789        rc = SSMR3GetIOPort(pSSM, &IOPortBaseCfg); AssertRCReturn(rc, rc);
    790790        if (IOPortBaseCfg != pThis->IOPortBaseCfg)
    791         {
    792             LogRel(("PIT: Config mismatch - IOPortBaseCfg: saved=%RTiop config=%RTiop\n", IOPortBaseCfg, pThis->IOPortBaseCfg));
    793             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    794         }
     791            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - IOPortBaseCfg: saved=%RTiop config=%RTiop"),
     792                                    IOPortBaseCfg, pThis->IOPortBaseCfg);
    795793
    796794        uint8_t u8Irq;
    797795        rc = SSMR3GetU8(pSSM, &u8Irq); AssertRCReturn(rc, rc);
    798796        if (u8Irq != pThis->channels[0].irq)
    799         {
    800             LogRel(("PIT: Config mismatch - u8Irq: saved=%#x config=%#x\n", u8Irq, pThis->channels[0].irq));
    801             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    802         }
     797            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - u8Irq: saved=%#x config=%#x"),
     798                                    u8Irq, pThis->channels[0].irq);
    803799
    804800        bool fSpeakerCfg;
    805801        rc = SSMR3GetBool(pSSM, &fSpeakerCfg); AssertRCReturn(rc, rc);
    806802        if (fSpeakerCfg != pThis->fSpeakerCfg)
    807         {
    808             LogRel(("PIT: Config mismatch - fSpeakerCfg: saved=%RTbool config=%RTbool\n", fSpeakerCfg, pThis->fSpeakerCfg));
    809             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    810         }
     803            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fSpeakerCfg: saved=%RTbool config=%RTbool"),
     804                                    fSpeakerCfg, pThis->fSpeakerCfg);
    811805    }
    812806

  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r24089 r24265  
    665665        rc = SSMR3GetU8(pSSM, &u8Irq);          AssertRCReturn(rc, rc);
    666666        if (u8Irq != pThis->irq)
    667         {
    668             LogRel(("RTC: Config mismatch - u8Irq: saved=%#x config=%#x\n", u8Irq, pThis->irq));
    669             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    670         }
     667            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - u8Irq: saved=%#x config=%#x"), u8Irq, pThis->irq);
    671668
    672669        RTIOPORT IOPortBase;
    673670        rc = SSMR3GetIOPort(pSSM, &IOPortBase); AssertRCReturn(rc, rc);
    674671        if (IOPortBase != pThis->IOPortBase)
    675         {
    676             LogRel(("RTC: Config mismatch - IOPortBase: saved=%RTiop config=%RTiop\n", IOPortBase, pThis->IOPortBase));
    677             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    678         }
     672            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - IOPortBase: saved=%RTiop config=%RTiop"), IOPortBase, pThis->IOPortBase);
    679673
    680674        bool fUTC;

  • trunk/src/VBox/Devices/Parallel/DevParallel.cpp

    r23989 r24265  
    564564 */
    565565static DECLCALLBACK(int) parallelLiveExec(PPDMDEVINS pDevIns,
    566                                           PSSMHANDLE pSSMHandle,
     566                                          PSSMHANDLE pSSM,
    567567                                          uint32_t uPass)
    568568{
    569569    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
    570570
    571     SSMR3PutS32(pSSMHandle, pThis->irq);
    572     SSMR3PutU32(pSSMHandle, pThis->base);
    573     SSMR3PutU32(pSSMHandle, ~0); /* sanity/terminator */
     571    SSMR3PutS32(pSSM, pThis->irq);
     572    SSMR3PutU32(pSSM, pThis->base);
     573    SSMR3PutU32(pSSM, ~0); /* sanity/terminator */
    574574    return VINF_SSM_DONT_CALL_AGAIN;
    575575}
    … …  
    579579 */
    580580static DECLCALLBACK(int) parallelSaveExec(PPDMDEVINS pDevIns,
    581                                           PSSMHANDLE pSSMHandle)
     581                                          PSSMHANDLE pSSM)
    582582{
    583583    ParallelState *pThis = PDMINS_2_DATA(pDevIns, ParallelState *);
    584584
    585     SSMR3PutU8(pSSMHandle, pThis->reg_data);
    586     SSMR3PutU8(pSSMHandle, pThis->reg_status);
    587     SSMR3PutU8(pSSMHandle, pThis->reg_control);
    588 
    589     parallelLiveExec(pDevIns, pSSMHandle, 0);
     585    SSMR3PutU8(pSSM, pThis->reg_data);
     586    SSMR3PutU8(pSSM, pThis->reg_status);
     587    SSMR3PutU8(pSSM, pThis->reg_control);
     588
     589    parallelLiveExec(pDevIns, pSSM, 0);
    590590    return VINF_SUCCESS;
    591591}
    … …  
    595595 */
    596596static DECLCALLBACK(int) parallelLoadExec(PPDMDEVINS pDevIns,
    597                                           PSSMHANDLE pSSMHandle,
     597                                          PSSMHANDLE pSSM,
    598598                                          uint32_t uVersion,
    599599                                          uint32_t uPass)
    … …  
    605605    if (uPass == SSM_PASS_FINAL)
    606606    {
    607         SSMR3GetU8(pSSMHandle, &pThis->reg_data);
    608         SSMR3GetU8(pSSMHandle, &pThis->reg_status);
    609         SSMR3GetU8(pSSMHandle, &pThis->reg_control);
     607        SSMR3GetU8(pSSM, &pThis->reg_data);
     608        SSMR3GetU8(pSSM, &pThis->reg_status);
     609        SSMR3GetU8(pSSM, &pThis->reg_control);
    610610    }
    611611
    612612    /* the config */
    613613    int32_t  iIrq;
    614     SSMR3GetS32(pSSMHandle, &iIrq);
     614    SSMR3GetS32(pSSM, &iIrq);
    615615    uint32_t uIoBase;
    616     SSMR3GetU32(pSSMHandle, &uIoBase);
     616    SSMR3GetU32(pSSM, &uIoBase);
    617617    uint32_t u32;
    618     int rc = SSMR3GetU32(pSSMHandle, &u32);
     618    int rc = SSMR3GetU32(pSSM, &u32);
    619619    if (RT_FAILURE(rc))
    620620        return rc;
    … …  
    622622
    623623    if (pThis->irq != iIrq)
    624     {
    625         LogRel(("Parallel: IRQ changed: config=%#x state=%#x\n", pThis->irq, iIrq));
    626         return VERR_SSM_LOAD_CONFIG_MISMATCH;
    627     }
     624        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("IRQ changed: config=%#x state=%#x"), pThis->irq, iIrq);
    628625
    629626    if (pThis->base != uIoBase)
    630     {
    631         LogRel(("Parallel: IOBase changed: config=%#x state=%#x\n", pThis->base, uIoBase));
    632         return VERR_SSM_LOAD_CONFIG_MISMATCH;
    633     }
     627        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("IOBase changed: config=%#x state=%#x"), pThis->base, uIoBase);
    634628
    635629    /* not necessary... but it doesn't harm. */

  • trunk/src/VBox/Devices/Serial/DevSerial.cpp

    r24042 r24265  
    662662    if (    pThis->irq  != iIrq
    663663        ||  pThis->base != IOBase)
    664     {
    665         LogRel(("Serial#%u: Config mismatch - saved irq=%#x iobase=%#x; configured irq=%#x iobase=%#x\n",
    666                 pDevIns->iInstance, iIrq, IOBase, pThis->irq, pThis->base));
    667         return VERR_SSM_LOAD_CONFIG_MISMATCH;
    668     }
     664        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - saved irq=%#x iobase=%#x; configured irq=%#x iobase=%#x"),
     665                                iIrq, IOBase, pThis->irq, pThis->base);
    669666
    670667    if (uPass == SSM_PASS_FINAL)

  • trunk/src/VBox/Devices/Storage/ATAController.cpp

    r24096 r24265  
    52685268 * @returns VBox status code.
    52695269 * @param   pCtl        Controller instance.
    5270  * @param   pSSMHandle  The handle to save the state to.
     5270 * @param   pSSM  The handle to save the state to.
    52715271 */
    5272 int ataControllerSaveExec(PAHCIATACONTROLLER pCtl, PSSMHANDLE pSSMHandle)
    5273 {
    5274     SSMR3PutU32(pSSMHandle, ATA_CTL_SAVED_STATE_VERSION);
    5275     SSMR3PutU8(pSSMHandle, pCtl->iSelectedIf);
    5276     SSMR3PutU8(pSSMHandle, pCtl->iAIOIf);
    5277     SSMR3PutU8(pSSMHandle, pCtl->uAsyncIOState);
    5278     SSMR3PutBool(pSSMHandle, pCtl->fChainedTransfer);
    5279     SSMR3PutBool(pSSMHandle, pCtl->fReset);
    5280     SSMR3PutBool(pSSMHandle, pCtl->fRedo);
    5281     SSMR3PutBool(pSSMHandle, pCtl->fRedoIdle);
    5282     SSMR3PutBool(pSSMHandle, pCtl->fRedoDMALastDesc);
    5283     SSMR3PutMem(pSSMHandle, &pCtl->BmDma, sizeof(pCtl->BmDma));
    5284     SSMR3PutGCPhys32(pSSMHandle, pCtl->pFirstDMADesc);
    5285     SSMR3PutGCPhys32(pSSMHandle, pCtl->pLastDMADesc);
    5286     SSMR3PutGCPhys32(pSSMHandle, pCtl->pRedoDMABuffer);
    5287     SSMR3PutU32(pSSMHandle, pCtl->cbRedoDMABuffer);
     5272int ataControllerSaveExec(PAHCIATACONTROLLER pCtl, PSSMHANDLE pSSM)
     5273{
     5274    SSMR3PutU32(pSSM, ATA_CTL_SAVED_STATE_VERSION);
     5275    SSMR3PutU8(pSSM, pCtl->iSelectedIf);
     5276    SSMR3PutU8(pSSM, pCtl->iAIOIf);
     5277    SSMR3PutU8(pSSM, pCtl->uAsyncIOState);
     5278    SSMR3PutBool(pSSM, pCtl->fChainedTransfer);
     5279    SSMR3PutBool(pSSM, pCtl->fReset);
     5280    SSMR3PutBool(pSSM, pCtl->fRedo);
     5281    SSMR3PutBool(pSSM, pCtl->fRedoIdle);
     5282    SSMR3PutBool(pSSM, pCtl->fRedoDMALastDesc);
     5283    SSMR3PutMem(pSSM, &pCtl->BmDma, sizeof(pCtl->BmDma));
     5284    SSMR3PutGCPhys32(pSSM, pCtl->pFirstDMADesc);
     5285    SSMR3PutGCPhys32(pSSM, pCtl->pLastDMADesc);
     5286    SSMR3PutGCPhys32(pSSM, pCtl->pRedoDMABuffer);
     5287    SSMR3PutU32(pSSM, pCtl->cbRedoDMABuffer);
    52885288
    52895289    for (uint32_t j = 0; j < RT_ELEMENTS(pCtl->aIfs); j++)
    52905290    {
    5291         SSMR3PutBool(pSSMHandle, pCtl->aIfs[j].fLBA48);
    5292         SSMR3PutBool(pSSMHandle, pCtl->aIfs[j].fATAPI);
    5293         SSMR3PutBool(pSSMHandle, pCtl->aIfs[j].fIrqPending);
    5294         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].cMultSectors);
    5295         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].PCHSGeometry.cCylinders);
    5296         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].PCHSGeometry.cHeads);
    5297         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].PCHSGeometry.cSectors);
    5298         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].cSectorsPerIRQ);
    5299         SSMR3PutU64(pSSMHandle, pCtl->aIfs[j].cTotalSectors);
    5300         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegFeature);
    5301         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegFeatureHOB);
    5302         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegError);
    5303         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegNSector);
    5304         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegNSectorHOB);
    5305         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegSector);
    5306         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegSectorHOB);
    5307         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegLCyl);
    5308         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegLCylHOB);
    5309         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegHCyl);
    5310         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegHCylHOB);
    5311         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegSelect);
    5312         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegStatus);
    5313         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegCommand);
    5314         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATARegDevCtl);
    5315         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uATATransferMode);
    5316         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].uTxDir);
    5317         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].iBeginTransfer);
    5318         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].iSourceSink);
    5319         SSMR3PutBool(pSSMHandle, pCtl->aIfs[j].fDMA);
    5320         SSMR3PutBool(pSSMHandle, pCtl->aIfs[j].fATAPITransfer);
    5321         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].cbTotalTransfer);
    5322         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].cbElementaryTransfer);
    5323         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].iIOBufferCur);
    5324         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].iIOBufferEnd);
    5325         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].iIOBufferPIODataStart);
    5326         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].iIOBufferPIODataEnd);
    5327         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].iATAPILBA);
    5328         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].cbATAPISector);
    5329         SSMR3PutMem(pSSMHandle, &pCtl->aIfs[j].aATAPICmd, sizeof(pCtl->aIfs[j].aATAPICmd));
    5330         SSMR3PutMem(pSSMHandle, &pCtl->aIfs[j].abATAPISense, sizeof(pCtl->aIfs[j].abATAPISense));
    5331         SSMR3PutU8(pSSMHandle, pCtl->aIfs[j].cNotifiedMediaChange);
    5332         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].MediaEventStatus);
    5333         SSMR3PutMem(pSSMHandle, pCtl->aIfs[j].pLed, sizeof(PDMLED));
    5334         SSMR3PutU32(pSSMHandle, pCtl->aIfs[j].cbIOBuffer);
     5291        SSMR3PutBool(pSSM, pCtl->aIfs[j].fLBA48);
     5292        SSMR3PutBool(pSSM, pCtl->aIfs[j].fATAPI);
     5293        SSMR3PutBool(pSSM, pCtl->aIfs[j].fIrqPending);
     5294        SSMR3PutU8(pSSM, pCtl->aIfs[j].cMultSectors);
     5295        SSMR3PutU32(pSSM, pCtl->aIfs[j].PCHSGeometry.cCylinders);
     5296        SSMR3PutU32(pSSM, pCtl->aIfs[j].PCHSGeometry.cHeads);
     5297        SSMR3PutU32(pSSM, pCtl->aIfs[j].PCHSGeometry.cSectors);
     5298        SSMR3PutU32(pSSM, pCtl->aIfs[j].cSectorsPerIRQ);
     5299        SSMR3PutU64(pSSM, pCtl->aIfs[j].cTotalSectors);
     5300        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegFeature);
     5301        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegFeatureHOB);
     5302        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegError);
     5303        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegNSector);
     5304        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegNSectorHOB);
     5305        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegSector);
     5306        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegSectorHOB);
     5307        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegLCyl);
     5308        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegLCylHOB);
     5309        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegHCyl);
     5310        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegHCylHOB);
     5311        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegSelect);
     5312        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegStatus);
     5313        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegCommand);
     5314        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATARegDevCtl);
     5315        SSMR3PutU8(pSSM, pCtl->aIfs[j].uATATransferMode);
     5316        SSMR3PutU8(pSSM, pCtl->aIfs[j].uTxDir);
     5317        SSMR3PutU8(pSSM, pCtl->aIfs[j].iBeginTransfer);
     5318        SSMR3PutU8(pSSM, pCtl->aIfs[j].iSourceSink);
     5319        SSMR3PutBool(pSSM, pCtl->aIfs[j].fDMA);
     5320        SSMR3PutBool(pSSM, pCtl->aIfs[j].fATAPITransfer);
     5321        SSMR3PutU32(pSSM, pCtl->aIfs[j].cbTotalTransfer);
     5322        SSMR3PutU32(pSSM, pCtl->aIfs[j].cbElementaryTransfer);
     5323        SSMR3PutU32(pSSM, pCtl->aIfs[j].iIOBufferCur);
     5324        SSMR3PutU32(pSSM, pCtl->aIfs[j].iIOBufferEnd);
     5325        SSMR3PutU32(pSSM, pCtl->aIfs[j].iIOBufferPIODataStart);
     5326        SSMR3PutU32(pSSM, pCtl->aIfs[j].iIOBufferPIODataEnd);
     5327        SSMR3PutU32(pSSM, pCtl->aIfs[j].iATAPILBA);
     5328        SSMR3PutU32(pSSM, pCtl->aIfs[j].cbATAPISector);
     5329        SSMR3PutMem(pSSM, &pCtl->aIfs[j].aATAPICmd, sizeof(pCtl->aIfs[j].aATAPICmd));
     5330        SSMR3PutMem(pSSM, &pCtl->aIfs[j].abATAPISense, sizeof(pCtl->aIfs[j].abATAPISense));
     5331        SSMR3PutU8(pSSM, pCtl->aIfs[j].cNotifiedMediaChange);
     5332        SSMR3PutU32(pSSM, pCtl->aIfs[j].MediaEventStatus);
     5333        SSMR3PutMem(pSSM, pCtl->aIfs[j].pLed, sizeof(PDMLED));
     5334        SSMR3PutU32(pSSM, pCtl->aIfs[j].cbIOBuffer);
    53355335        if (pCtl->aIfs[j].cbIOBuffer)
    5336             SSMR3PutMem(pSSMHandle, pCtl->aIfs[j].CTX_SUFF(pbIOBuffer), pCtl->aIfs[j].cbIOBuffer);
     5336            SSMR3PutMem(pSSM, pCtl->aIfs[j].CTX_SUFF(pbIOBuffer), pCtl->aIfs[j].cbIOBuffer);
    53375337        else
    53385338            Assert(pCtl->aIfs[j].CTX_SUFF(pbIOBuffer) == NULL);
    53395339    }
    53405340
    5341     return SSMR3PutU32(pSSMHandle, ~0); /* sanity/terminator */
     5341    return SSMR3PutU32(pSSM, ~0); /* sanity/terminator */
    53425342}
    53435343
    … …  
    53485348 * @returns VBox status code.
    53495349 * @param   pDevIns     The device instance.
    5350  * @param   pSSMHandle  The handle to the saved state.
     5350 * @param   pSSM  The handle to the saved state.
    53515351 */
    5352 int ataControllerLoadExec(PAHCIATACONTROLLER pCtl, PSSMHANDLE pSSMHandle)
     5352int ataControllerLoadExec(PAHCIATACONTROLLER pCtl, PSSMHANDLE pSSM)
    53535353{
    53545354    int             rc;
    … …  
    53575357
    53585358    /* Test for correct version. */
    5359     rc = SSMR3GetU32(pSSMHandle, &u32Version);
     5359    rc = SSMR3GetU32(pSSM, &u32Version);
    53605360    AssertRCReturn(rc, rc);
    53615361
    … …  
    53755375    }
    53765376
    5377     SSMR3GetU8(pSSMHandle, &pCtl->iSelectedIf);
    5378     SSMR3GetU8(pSSMHandle, &pCtl->iAIOIf);
    5379     SSMR3GetU8(pSSMHandle, &pCtl->uAsyncIOState);
    5380     SSMR3GetBool(pSSMHandle, &pCtl->fChainedTransfer);
    5381     SSMR3GetBool(pSSMHandle, (bool *)&pCtl->fReset);
    5382     SSMR3GetBool(pSSMHandle, (bool *)&pCtl->fRedo);
    5383     SSMR3GetBool(pSSMHandle, (bool *)&pCtl->fRedoIdle);
    5384     SSMR3GetBool(pSSMHandle, (bool *)&pCtl->fRedoDMALastDesc);
    5385     SSMR3GetMem(pSSMHandle, &pCtl->BmDma, sizeof(pCtl->BmDma));
    5386     SSMR3GetGCPhys32(pSSMHandle, &pCtl->pFirstDMADesc);
    5387     SSMR3GetGCPhys32(pSSMHandle, &pCtl->pLastDMADesc);
    5388     SSMR3GetGCPhys32(pSSMHandle, &pCtl->pRedoDMABuffer);
    5389     SSMR3GetU32(pSSMHandle, &pCtl->cbRedoDMABuffer);
     5377    SSMR3GetU8(pSSM, &pCtl->iSelectedIf);
     5378    SSMR3GetU8(pSSM, &pCtl->iAIOIf);
     5379    SSMR3GetU8(pSSM, &pCtl->uAsyncIOState);
     5380    SSMR3GetBool(pSSM, &pCtl->fChainedTransfer);
     5381    SSMR3GetBool(pSSM, (bool *)&pCtl->fReset);
     5382    SSMR3GetBool(pSSM, (bool *)&pCtl->fRedo);
     5383    SSMR3GetBool(pSSM, (bool *)&pCtl->fRedoIdle);
     5384    SSMR3GetBool(pSSM, (bool *)&pCtl->fRedoDMALastDesc);
     5385    SSMR3GetMem(pSSM, &pCtl->BmDma, sizeof(pCtl->BmDma));
     5386    SSMR3GetGCPhys32(pSSM, &pCtl->pFirstDMADesc);
     5387    SSMR3GetGCPhys32(pSSM, &pCtl->pLastDMADesc);
     5388    SSMR3GetGCPhys32(pSSM, &pCtl->pRedoDMABuffer);
     5389    SSMR3GetU32(pSSM, &pCtl->cbRedoDMABuffer);
    53905390
    53915391    for (uint32_t j = 0; j < RT_ELEMENTS(pCtl->aIfs); j++)
    53925392    {
    5393         SSMR3GetBool(pSSMHandle, &pCtl->aIfs[j].fLBA48);
    5394         SSMR3GetBool(pSSMHandle, &pCtl->aIfs[j].fATAPI);
    5395         SSMR3GetBool(pSSMHandle, &pCtl->aIfs[j].fIrqPending);
    5396         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].cMultSectors);
    5397         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].PCHSGeometry.cCylinders);
    5398         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].PCHSGeometry.cHeads);
    5399         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].PCHSGeometry.cSectors);
    5400         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].cSectorsPerIRQ);
    5401         SSMR3GetU64(pSSMHandle, &pCtl->aIfs[j].cTotalSectors);
    5402         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegFeature);
    5403         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegFeatureHOB);
    5404         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegError);
    5405         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegNSector);
    5406         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegNSectorHOB);
    5407         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegSector);
    5408         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegSectorHOB);
    5409         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegLCyl);
    5410         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegLCylHOB);
    5411         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegHCyl);
    5412         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegHCylHOB);
    5413         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegSelect);
    5414         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegStatus);
    5415         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegCommand);
    5416         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATARegDevCtl);
    5417         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uATATransferMode);
    5418         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].uTxDir);
    5419         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].iBeginTransfer);
    5420         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].iSourceSink);
    5421         SSMR3GetBool(pSSMHandle, &pCtl->aIfs[j].fDMA);
    5422         SSMR3GetBool(pSSMHandle, &pCtl->aIfs[j].fATAPITransfer);
    5423         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].cbTotalTransfer);
    5424         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].cbElementaryTransfer);
    5425         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].iIOBufferCur);
    5426         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].iIOBufferEnd);
    5427         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].iIOBufferPIODataStart);
    5428         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].iIOBufferPIODataEnd);
    5429         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].iATAPILBA);
    5430         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].cbATAPISector);
    5431         SSMR3GetMem(pSSMHandle, &pCtl->aIfs[j].aATAPICmd, sizeof(pCtl->aIfs[j].aATAPICmd));
     5393        SSMR3GetBool(pSSM, &pCtl->aIfs[j].fLBA48);
     5394        SSMR3GetBool(pSSM, &pCtl->aIfs[j].fATAPI);
     5395        SSMR3GetBool(pSSM, &pCtl->aIfs[j].fIrqPending);
     5396        SSMR3GetU8(pSSM, &pCtl->aIfs[j].cMultSectors);
     5397        SSMR3GetU32(pSSM, &pCtl->aIfs[j].PCHSGeometry.cCylinders);
     5398        SSMR3GetU32(pSSM, &pCtl->aIfs[j].PCHSGeometry.cHeads);
     5399        SSMR3GetU32(pSSM, &pCtl->aIfs[j].PCHSGeometry.cSectors);
     5400        SSMR3GetU32(pSSM, &pCtl->aIfs[j].cSectorsPerIRQ);
     5401        SSMR3GetU64(pSSM, &pCtl->aIfs[j].cTotalSectors);
     5402        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegFeature);
     5403        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegFeatureHOB);
     5404        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegError);
     5405        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegNSector);
     5406        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegNSectorHOB);
     5407        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegSector);
     5408        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegSectorHOB);
     5409        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegLCyl);
     5410        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegLCylHOB);
     5411        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegHCyl);
     5412        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegHCylHOB);
     5413        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegSelect);
     5414        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegStatus);
     5415        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegCommand);
     5416        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATARegDevCtl);
     5417        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uATATransferMode);
     5418        SSMR3GetU8(pSSM, &pCtl->aIfs[j].uTxDir);
     5419        SSMR3GetU8(pSSM, &pCtl->aIfs[j].iBeginTransfer);
     5420        SSMR3GetU8(pSSM, &pCtl->aIfs[j].iSourceSink);
     5421        SSMR3GetBool(pSSM, &pCtl->aIfs[j].fDMA);
     5422        SSMR3GetBool(pSSM, &pCtl->aIfs[j].fATAPITransfer);
     5423        SSMR3GetU32(pSSM, &pCtl->aIfs[j].cbTotalTransfer);
     5424        SSMR3GetU32(pSSM, &pCtl->aIfs[j].cbElementaryTransfer);
     5425        SSMR3GetU32(pSSM, &pCtl->aIfs[j].iIOBufferCur);
     5426        SSMR3GetU32(pSSM, &pCtl->aIfs[j].iIOBufferEnd);
     5427        SSMR3GetU32(pSSM, &pCtl->aIfs[j].iIOBufferPIODataStart);
     5428        SSMR3GetU32(pSSM, &pCtl->aIfs[j].iIOBufferPIODataEnd);
     5429        SSMR3GetU32(pSSM, &pCtl->aIfs[j].iATAPILBA);
     5430        SSMR3GetU32(pSSM, &pCtl->aIfs[j].cbATAPISector);
     5431        SSMR3GetMem(pSSM, &pCtl->aIfs[j].aATAPICmd, sizeof(pCtl->aIfs[j].aATAPICmd));
    54325432        if (u32Version > ATA_CTL_SAVED_STATE_VERSION_WITHOUT_FULL_SENSE)
    54335433        {
    5434             SSMR3GetMem(pSSMHandle, &pCtl->aIfs[j].abATAPISense, sizeof(pCtl->aIfs[j].abATAPISense));
     5434            SSMR3GetMem(pSSM, &pCtl->aIfs[j].abATAPISense, sizeof(pCtl->aIfs[j].abATAPISense));
    54355435        }
    54365436        else
    … …  
    54405440            pCtl->aIfs[j].abATAPISense[0] = 0x70 | (1 << 7);
    54415441            pCtl->aIfs[j].abATAPISense[7] = 10;
    5442             SSMR3GetU8(pSSMHandle, &uATAPISenseKey);
    5443             SSMR3GetU8(pSSMHandle, &uATAPIASC);
     5442            SSMR3GetU8(pSSM, &uATAPISenseKey);
     5443            SSMR3GetU8(pSSM, &uATAPIASC);
    54445444            pCtl->aIfs[j].abATAPISense[2] = uATAPISenseKey & 0x0f;
    54455445            pCtl->aIfs[j].abATAPISense[12] = uATAPIASC;
    54465446        }
    54475447        /** @todo triple-check this hack after passthrough is working */
    5448         SSMR3GetU8(pSSMHandle, &pCtl->aIfs[j].cNotifiedMediaChange);
     5448        SSMR3GetU8(pSSM, &pCtl->aIfs[j].cNotifiedMediaChange);
    54495449        if (u32Version > ATA_CTL_SAVED_STATE_VERSION_WITHOUT_EVENT_STATUS)
    5450             SSMR3GetU32(pSSMHandle, (uint32_t*)&pCtl->aIfs[j].MediaEventStatus);
     5450            SSMR3GetU32(pSSM, (uint32_t*)&pCtl->aIfs[j].MediaEventStatus);
    54515451        else
    54525452            pCtl->aIfs[j].MediaEventStatus = ATA_EVENT_STATUS_UNCHANGED;
    54535453
    54545454        PDMLED Led;
    5455         SSMR3GetMem(pSSMHandle, &Led, sizeof(PDMLED));
    5456         SSMR3GetU32(pSSMHandle, &pCtl->aIfs[j].cbIOBuffer);
     5455        SSMR3GetMem(pSSM, &Led, sizeof(PDMLED));
     5456        SSMR3GetU32(pSSM, &pCtl->aIfs[j].cbIOBuffer);
    54575457        if (pCtl->aIfs[j].cbIOBuffer)
    54585458        {
    54595459            if (pCtl->aIfs[j].CTX_SUFF(pbIOBuffer))
    5460                 SSMR3GetMem(pSSMHandle, pCtl->aIfs[j].CTX_SUFF(pbIOBuffer), pCtl->aIfs[j].cbIOBuffer);
     5460                SSMR3GetMem(pSSM, pCtl->aIfs[j].CTX_SUFF(pbIOBuffer), pCtl->aIfs[j].cbIOBuffer);
    54615461            else
    54625462            {
    54635463                LogRel(("ATA: No buffer for %d\n", j));
    5464                 if (SSMR3HandleGetAfter(pSSMHandle) != SSMAFTER_DEBUG_IT)
    5465                     return VERR_SSM_LOAD_CONFIG_MISMATCH;
     5464                if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
     5465                    return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("No buffer for %d"), j);
    54665466
    54675467                /* skip the buffer if we're loading for the debugger / animator. */
    … …  
    54695469                size_t cbLeft = pCtl->aIfs[j].cbIOBuffer;
    54705470                while (cbLeft-- > 0)
    5471                     SSMR3GetU8(pSSMHandle, &u8Ignored);
     5471                    SSMR3GetU8(pSSM, &u8Ignored);
    54725472            }
    54735473        }
    … …  
    54765476    }
    54775477
    5478     rc = SSMR3GetU32(pSSMHandle, &u32);
     5478    rc = SSMR3GetU32(pSSM, &u32);
    54795479    if (RT_FAILURE(rc))
    54805480        return rc;

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r24257 r24265  
    61506150            if (    u32 < pThis->cPortsImpl
    61516151                ||  u32 > AHCI_MAX_NR_PORTS_IMPL)
    6152                 return VERR_SSM_LOAD_CONFIG_MISMATCH;
     6152                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch: cPortsImpl - saved=%u config=%u"),
     6153                                        u32, pThis->cPortsImpl);
    61536154        }
    61546155
    … …  
    61596160            AssertRCReturn(rc, rc);
    61606161            if (fInUse != (pThis->ahciPort[i].pDrvBase != NULL))
    6161             {
    6162                 LogRel(("AHCI: Port %u config mismatch: fInUse - saved=%RTbool config=%RTbool\n",
    6163                         i, fInUse, (pThis->ahciPort[i].pDrvBase != NULL)));
    6164                 return VERR_SSM_LOAD_CONFIG_MISMATCH;
    6165             }
     6162                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Port %u config mismatch: fInUse - saved=%RTbool config=%RTbool"),
     6163                                        i, fInUse, (pThis->ahciPort[i].pDrvBase != NULL));
    61666164
    61676165            char szSerialNumber[AHCI_SERIAL_NUMBER_LENGTH+1];
    … …  
    61996197
    62006198            if (iPortSaved != iPort)
    6201             {
    6202                 LogRel(("AHCI: IDE %s config mismatch: saved=%u config=%u\n",
    6203                         s_apszIdeEmuPortNames[i], iPortSaved, iPort));
    6204                 return VERR_SSM_LOAD_CONFIG_MISMATCH;
    6205             }
     6199                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("IDE %s config mismatch: saved=%u config=%u"),
     6200                                        s_apszIdeEmuPortNames[i], iPortSaved, iPort);
    62066201        }
    62076202    }

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r24173 r24265  
    61796179        AssertRCReturn(rc, rc);
    61806180        if (u8Type != pThis->u8Type)
    6181         {
    6182             LogRel(("PIIX3 ATA: Config mismatch: u8Type - saved=%u config=%u\n", u8Type, pThis->u8Type));
    6183             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    6184         }
     6181            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch: u8Type - saved=%u config=%u"), u8Type, pThis->u8Type);
    61856182
    61866183        for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
    … …  
    61906187            AssertRCReturn(rc, rc);
    61916188            if (!fEnabled)
    6192             {
    6193                 LogRel(("PIIX3 ATA: Ctr#%u onfig mismatch: fEnabled != true\n", i));
    6194                 return VERR_SSM_LOAD_CONFIG_MISMATCH;
    6195             }
     6189                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Ctr#%u onfig mismatch: fEnabled != true"), i);
    61966190
    61976191            for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
    … …  
    62036197                AssertRCReturn(rc, rc);
    62046198                if (fInUse != (pIf->pDrvBase != NULL))
    6205                 {
    6206                     LogRel(("PIIX3 ATA: LUN#%u config mismatch: fInUse - saved=%RTbool config=%RTbool\n",
    6207                             pIf->iLUN, fInUse, (pIf->pDrvBase != NULL)));
    6208                     return VERR_SSM_LOAD_CONFIG_MISMATCH;
    6209                 }
     6199                    return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("LUN#%u config mismatch: fInUse - saved=%RTbool config=%RTbool"),
     6200                                             pIf->iLUN, fInUse, (pIf->pDrvBase != NULL));
    62106201
    62116202                char szSerialNumber[ATA_SERIAL_NUMBER_LENGTH+1];
    … …  
    63336324                    LogRel(("ATA: No buffer for %d/%d\n", i, j));
    63346325                    if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
    6335                         return VERR_SSM_LOAD_CONFIG_MISMATCH;
     6326                        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("No buffer for %d/%d"), i, j);
    63366327
    63376328                    /* skip the buffer if we're loading for the debugger / animator. */

  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r24099 r24265  
    23472347        AssertRCReturn(rc, rc);
    23482348        if (pDevice->fPresent != fPresent)
    2349         {
    2350             LogRel(("BusLogic: Target %u config mismatch: config=%RTbool state=%RTbool\n", i, pDevice->fPresent, fPresent));
    2351             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    2352         }
     2349            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Target %u config mismatch: config=%RTbool state=%RTbool"), i, pDevice->fPresent, fPresent);
    23532350
    23542351        if (uPass == SSM_PASS_FINAL)

  • trunk/src/VBox/Devices/Storage/DevLsiLogicSCSI.cpp

    r24101 r24265  
    48734873            AssertRCReturn(rc, rc);
    48744874            if (fPresent != (pLsiLogic->aDeviceStates[i].pDrvBase != NULL))
    4875             {
    4876                 LogRel(("LsiLogic: Target %u config mismatch: config=%RTbool state=%RTbool\n",
    4877                         i, pLsiLogic->aDeviceStates[i].pDrvBase != NULL, fPresent));
    4878                 return VERR_SSM_LOAD_CONFIG_MISMATCH;
    4879             }
     4875                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Target %u config mismatch: config=%RTbool state=%RTbool"),
     4876                                         i, pLsiLogic->aDeviceStates[i].pDrvBase != NULL, fPresent);
    48804877        }
    48814878    }

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r24191 r24265  
    21962196        rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
    21972197        if (pThis->fKeepCredentials != f)
    2198         {
    2199             LogRel(("VMMDev: Config mismatch - fKeepCredentials: config=%RTbool saved=%RTbool\n", pThis->fKeepCredentials, f));
    2200             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    2201         }
     2198            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fKeepCredentials: config=%RTbool saved=%RTbool"),
     2199                                     pThis->fKeepCredentials, f);
    22022200        rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
    22032201        if (pThis->fHeapEnabled != f)
    2204         {
    2205             LogRel(("VMMDev: Config mismatch - fHeapEnabled: config=%RTbool saved=%RTbool\n", pThis->fHeapEnabled, f));
    2206             return VERR_SSM_LOAD_CONFIG_MISMATCH;
    2207         }
     2202            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fHeapEnabled: config=%RTbool saved=%RTbool"),
     2203                                    pThis->fHeapEnabled, f);
    22082204    }
    22092205

  • trunk/src/VBox/Main/DisplayImpl.cpp

    r24166 r24265  
    141141    int rc = SSMR3GetU32(pSSM, &cMonitors);
    142142    if (cMonitors != that->mcMonitors)
    143     {
    144         LogRel(("Display: Number of monitors changed (%d->%d)!\n",
    145                 cMonitors, that->mcMonitors));
    146         return VERR_SSM_LOAD_CONFIG_MISMATCH;
    147     }
     143        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Number of monitors changed (%d->%d)!"), cMonitors, that->mcMonitors);
    148144
    149145    for (uint32_t i = 0; i < cMonitors; i++)

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

    r24154 r24265  
    891891            LogRel(("Device '%s'/%d not found in current config\n", szDeviceName, iInstance));
    892892            if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
    893                 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
     893                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in current config"), szDeviceName, iInstance);
    894894        }
    895895    }
    … …  
    903903            LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    904904            if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
    905                 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
     905                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in the saved state"),
     906                                        pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
    906907        }
    907908

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

    r24239 r24265  
    324324            }
    325325        }
    326         AssertLogRelMsgReturn(pRom, ("GCPhys=%RGp %s\n", GCPhys, szDesc), VERR_SSM_LOAD_CONFIG_MISMATCH);
     326        if (!pRom)
     327            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("ROM at %RGp by the name '%s' was not found"), GCPhys, szDesc);
    327328    } /* forever */
    328329}
    … …  
    695696            }
    696697        }
    697         AssertLogRelMsgReturn(pMmio2, ("%s/%u/%u: %s\n", szDevName, uInstance, iRegion, szDesc), VERR_SSM_LOAD_CONFIG_MISMATCH);
     698        if (!pMmio2)
     699            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Failed to locate a MMIO2 range called '%s' owned by %s/%u, region %d"),
     700                                    szDesc, szDevName, uInstance, iRegion);
    698701
    699702        /*
    … …  
    706709                    pMmio2->RamRange.pszDesc, cb, pMmio2->RamRange.cb));
    707710            if (cb > pMmio2->RamRange.cb) /* bad idea? */
    708                 return VERR_SSM_LOAD_CONFIG_MISMATCH;
     711                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("MMIO2 region \"%s\" size mismatch: saved=%RGp config=%RGp"),
     712                                        pMmio2->RamRange.pszDesc, cb, pMmio2->RamRange.cb);
    709713        }
    710714    } /* forever */
    … …  
    21672171            if (    SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT
    21682172                ||  GCPhys < 8 * _1M)
    2169                 AssertFailedReturn(VERR_SSM_LOAD_CONFIG_MISMATCH);
     2173                return SSMR3SetCfgError(pSSM, RT_SRC_POS,
     2174                                        N_("RAM range mismatch; saved={%RGp-%RGp %RGp bytes %s %s} config={%RGp-%RGp %RGp bytes %s %s}"),
     2175                                        GCPhys, GCPhysLast, cb, fHaveBits ? "bits" : "nobits", szDesc,
     2176                                        pRam->GCPhys, pRam->GCPhysLast, pRam->cb, pRam->pvR3 ? "bits" : "nobits", pRam->pszDesc);
    21702177
    21712178            AssertMsgFailed(("debug skipping not implemented, sorry\n"));
    … …  
    24972504                if (enmProt != pRomPage->enmProt)
    24982505                {
    2499                     AssertLogRelMsgReturn(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED,
    2500                                           ("GCPhys=%RGp enmProt=%d %s\n", GCPhys, enmProt, pRom->pszDesc),
    2501                                           VERR_SSM_LOAD_CONFIG_MISMATCH);
     2506                    if (RT_UNLIKELY(!(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)))
     2507                        return SSMR3SetCfgError(pSSM, RT_SRC_POS,
     2508                                                N_("Protection change of unshadowed ROM page: GCPhys=%RGp enmProt=%d %s"),
     2509                                                GCPhys, enmProt, pRom->pszDesc);
    25022510                    rc = PGMR3PhysRomProtect(pVM, GCPhys, PAGE_SIZE, enmProt);
    25032511                    AssertLogRelMsgRCReturn(rc, ("GCPhys=%RGp rc=%Rrc\n", GCPhys, rc), rc);
    … …  
    25222530                    case PGM_STATE_REC_ROM_SHW_RAW:
    25232531                    case PGM_STATE_REC_ROM_SHW_ZERO:
    2524                         AssertLogRelMsgReturn(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED,
    2525                                               ("GCPhys=%RGp enmProt=%d %s\n", GCPhys, enmProt, pRom->pszDesc),
    2526                                               VERR_SSM_LOAD_CONFIG_MISMATCH);
     2532                        if (RT_UNLIKELY(!(pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)))
     2533                            return SSMR3SetCfgError(pSSM, RT_SRC_POS,
     2534                                                    N_("Shadowed / non-shadowed page type mismatch: GCPhys=%RGp enmProt=%d %s"),
     2535                                                    GCPhys, enmProt, pRom->pszDesc);
    25272536                        if (PGMROMPROT_IS_ROM(enmProt))
    25282537                            pRealPage = &pRomPage->Shadow;
    … …  
    27052714                &&  !strcmp(pMapping->pszDesc, szDesc))
    27062715                break;
    2707         AssertLogRelMsgReturn(pMapping, ("Couldn't find mapping: cPTs=%#x szDesc=%s (GCPtr=%RGv)\n",
    2708                                          cPTs, szDesc, GCPtr),
    2709                               VERR_SSM_LOAD_CONFIG_MISMATCH);
     2716        if (!pMapping)
     2717            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Couldn't find mapping: cPTs=%#x szDesc=%s (GCPtr=%RGv)"),
     2718                                    cPTs, szDesc, GCPtr);
    27102719
    27112720        /* relocate it. */
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