Changeset 13594 in vbox
- Timestamp:
- Oct 27, 2008 6:41:07 PM (16 years ago)
- svn:sync-xref-src-repo-rev:
- 38502
- Location:
- trunk
- Files:
-
- 4 edited
-
include/VBox/ssm.h (modified) (2 diffs)
-
src/VBox/VMM/PDMDevHlp.cpp (modified) (1 diff)
-
src/VBox/VMM/SSM.cpp (modified) (120 diffs)
-
src/VBox/VMM/testcase/tstSSM.cpp (modified) (4 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/VBox/ssm.h
r12989 r13594 407 407 408 408 409 VMMR3DECL(int) SSMR3Register (PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,409 VMMR3DECL(int) SSMR3RegisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, 410 410 PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone, 411 411 PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone); … … 419 419 PFNSSMEXTSAVEPREP pfnSavePrep, PFNSSMEXTSAVEEXEC pfnSaveExec, PFNSSMEXTSAVEDONE pfnSaveDone, 420 420 PFNSSMEXTLOADPREP pfnLoadPrep, PFNSSMEXTLOADEXEC pfnLoadExec, PFNSSMEXTLOADDONE pfnLoadDone, void *pvUser); 421 VMMR3DECL(int) SSMR3Deregister (PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance);421 VMMR3DECL(int) SSMR3DeregisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance); 422 422 VMMR3DECL(int) SSMR3DeregisterDriver(PVM pVM, PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance); 423 423 VMMR3DECL(int) SSMR3DeregisterInternal(PVM pVM, const char *pszName); -
trunk/src/VBox/VMM/PDMDevHlp.cpp
r13373 r13594 363 363 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pszName, pszName, u32Instance, u32Version, cbGuess, pfnSavePrep, pfnSaveExec, pfnSaveDone, pfnLoadPrep, pfnLoadExec, pfnLoadDone)); 364 364 365 int rc = SSMR3Register (pDevIns->Internal.s.pVMR3, pDevIns, pszName, u32Instance, u32Version, cbGuess,366 pfnSavePrep, pfnSaveExec, pfnSaveDone,367 pfnLoadPrep, pfnLoadExec, pfnLoadDone);365 int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pszName, u32Instance, u32Version, cbGuess, 366 pfnSavePrep, pfnSaveExec, pfnSaveDone, 367 pfnLoadPrep, pfnLoadExec, pfnLoadDone); 368 368 369 369 LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc)); -
trunk/src/VBox/VMM/SSM.cpp
r13005 r13594 23 23 /** @page pg_ssm SSM - The Saved State Manager 24 24 * 25 * The Saved State Manager (SSM) implements facilities for saving and loading 26 * a VM state in a structural manner using callbacks for each collection of 27 * data which needs saving. 28 * 29 * At init time each of the VM components will register data entities which 30 * they need to save and restore. Each entity have a unique name (ascii) and 31 * a set of callbacks associated with it. The name will be used to identify 32 * the entity during restore. The callbacks are for the two operations, save 33 * and restore. There are three callbacks for each of the two - a prepare, 34 * a execute and a what-now. 25 * The Saved State Manager (SSM) implements facilities for saving and loading a 26 * VM state in a structural manner using callbacks for each collection of data 27 * which needs saving. 28 * 29 * At init time each of the VMM components, Devices, Drivers and one or two 30 * other things will register data entities which they need to save and restore. 31 * Each entity have a unique name (ascii), instance number, and a set of 32 * callbacks associated with it. The name will be used to identify the entity 33 * during restore. The callbacks are for the two operations, save and restore. 34 * There are three callbacks for each of the two - a prepare, a execute and a 35 * complete - giving each component ample opportunity to perform actions both 36 * before and afterwards. 35 37 * 36 38 * The SSM provides a number of APIs for encoding and decoding the data. 37 39 * 38 40 * @see grp_ssm 41 * 42 * 43 * @section sec_ssm_future Future Changes 44 * 45 * There are plans to extend SSM to make it easier to be both backwards and 46 * (somewhat) forwards compatible. One of the new features will be being able 47 * to classify units and data items as unimportant, one example where this would 48 * be nice can be seen in with the SSM data unit. Another potentail feature is 49 * naming data items, perhaps by extending the SSMR3PutStruct API. 50 * 39 51 */ 40 52 … … 63 75 64 76 65 66 77 /******************************************************************************* 67 78 * Defined Constants And Macros * 68 79 *******************************************************************************/ 80 /** Saved state file magic base string. */ 81 #define SSMFILEHDR_MAGIC_BASE "\177VirtualBox SavedState " 82 /** Saved state file v1.0 magic. */ 83 #define SSMFILEHDR_MAGIC_V1_0 "\177VirtualBox SavedState V1.0\n" 84 /** Saved state file v1.1 magic. */ 85 #define SSMFILEHDR_MAGIC_V1_1 "\177VirtualBox SavedState V1.1\n" 86 87 /** Data unit magic. */ 88 #define SSMFILEUNITHDR_MAGIC "\nUnit\n" 89 /** Data end marker magic. */ 90 #define SSMFILEUNITHDR_END "\nTheEnd" 91 69 92 /** Start structure magic. (Isacc Asimov) */ 70 #define SSMR3STRUCT_BEGIN 0x1920010293 #define SSMR3STRUCT_BEGIN 0x19200102 71 94 /** End structure magic. (Isacc Asimov) */ 72 #define SSMR3STRUCT_END 0x1992040695 #define SSMR3STRUCT_END 0x19920406 73 96 74 97 … … 76 99 * Structures and Typedefs * 77 100 *******************************************************************************/ 78 101 /** SSM state. */ 79 102 typedef enum SSMSTATE 80 103 { … … 145 168 typedef struct SSMFILEHDR 146 169 { 147 /** Magic string which identifies this file as a version of VBox saved state file format. */ 148 char achMagic[32]; 170 /** Magic string which identifies this file as a version of VBox saved state 171 * file format (SSMFILEHDR_MAGIC_V1_1). */ 172 char achMagic[32]; 149 173 /** The size of this file. Used to check 150 174 * whether the save completed and that things are fine otherwise. */ 151 uint64_t cbFile;175 uint64_t cbFile; 152 176 /** File checksum. The actual calculation skips past the u32CRC field. */ 153 uint32_t u32CRC;177 uint32_t u32CRC; 154 178 /** Padding. */ 155 uint32_t u32Reserved;179 uint32_t u32Reserved; 156 180 /** The machine UUID. (Ignored if NIL.) */ 157 RTUUID MachineUuid;158 } SSMFILEHDR , *PSSMFILEHDR;181 RTUUID MachineUuid; 182 } SSMFILEHDR; 159 183 AssertCompileSize(SSMFILEHDR, 64); 184 /** Pointer to a saved state file header. */ 185 typedef SSMFILEHDR *PSSMFILEHDR; 160 186 161 187 … … 166 192 typedef struct SSMFILEHDRV10X86 167 193 { 168 /** Magic string which identifies this file as a version of VBox saved state file format. */ 169 char achMagic[32]; 194 /** Magic string which identifies this file as a version of VBox saved state 195 * file format (SSMFILEHDR_MAGIC_V1_0). */ 196 char achMagic[32]; 170 197 /** The size of this file. Used to check 171 198 * whether the save completed and that things are fine otherwise. */ 172 uint64_t cbFile;199 uint64_t cbFile; 173 200 /** File checksum. The actual calculation skips past the u32CRC field. */ 174 uint32_t u32CRC;201 uint32_t u32CRC; 175 202 /** The machine UUID. (Ignored if NIL.) */ 176 RTUUID MachineUuid;177 } SSMFILEHDRV10X86 , *PSSMFILEHDRV10X86;203 RTUUID MachineUuid; 204 } SSMFILEHDRV10X86; 178 205 #pragma pack() 206 /** Pointer to a SSMFILEHDRV10X86. */ 207 typedef SSMFILEHDRV10X86 *PSSMFILEHDRV10X86; 179 208 180 209 /** 181 210 * The amd64 edition of the 1.0 header. 182 211 */ 183 typedef SSMFILEHDR SSMFILEHDRV10AMD64, *PSSMFILEHDRV10AMD64; 184 185 /** Saved state file magic base string. */ 186 #define SSMFILEHDR_MAGIC_BASE "\177VirtualBox SavedState " 187 /** Saved state file v1.0 magic. */ 188 #define SSMFILEHDR_MAGIC_V1_0 "\177VirtualBox SavedState V1.0\n" 189 /** Saved state file v1.1 magic. */ 190 #define SSMFILEHDR_MAGIC_V1_1 "\177VirtualBox SavedState V1.1\n" 191 192 212 typedef SSMFILEHDR SSMFILEHDRV10AMD64; 213 /** Pointer to SSMFILEHDRV10AMD64. */ 214 typedef SSMFILEHDRV10AMD64 *PSSMFILEHDRV10AMD64; 193 215 194 216 … … 198 220 typedef struct SSMFILEUNITHDR 199 221 { 200 /** Magic . */201 char achMagic[8];222 /** Magic (SSMFILEUNITHDR_MAGIC or SSMFILEUNITHDR_END). */ 223 char achMagic[8]; 202 224 /** Number of bytes in this data unit including the header. */ 203 uint64_t cbUnit;225 uint64_t cbUnit; 204 226 /** Data version. */ 205 uint32_t u32Version;227 uint32_t u32Version; 206 228 /** Instance number. */ 207 uint32_t u32Instance;229 uint32_t u32Instance; 208 230 /** Size of the data unit name including the terminator. (bytes) */ 209 uint32_t cchName;231 uint32_t cchName; 210 232 /** Data unit name. */ 211 char szName[1]; 212 } SSMFILEUNITHDR, *PSSMFILEUNITHDR; 213 214 /** Data unit magic. */ 215 #define SSMFILEUNITHDR_MAGIC "\nUnit\n" 216 /** Data end marker magic. */ 217 #define SSMFILEUNITHDR_END "\nTheEnd" 218 233 char szName[1]; 234 } SSMFILEUNITHDR; 235 /** Pointer to SSMFILEUNITHDR. */ 236 typedef SSMFILEUNITHDR *PSSMFILEUNITHDR; 219 237 220 238 … … 225 243 static DECLCALLBACK(int) ssmR3SelfSaveExec(PVM pVM, PSSMHANDLE pSSM); 226 244 static DECLCALLBACK(int) ssmR3SelfLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version); 227 static int smmr3Register(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, PSSMUNIT *ppUnit);228 static int ssmr3CalcChecksum(RTFILE File, uint64_t cbFile, uint32_t *pu32CRC);229 static void ssmR3Progress(PSSMHANDLE pSSM, uint64_t cbAdvance);230 static int ssmr3Validate(RTFILE File, PSSMFILEHDR pHdr, size_t *pcbFileHdr);231 static PSSMUNIT ssmr3Find(PVM pVM, const char *pszName, uint32_t u32Instance);232 static int ssmr3WriteFinish(PSSMHANDLE pSSM);233 static int ssmr3Write(PSSMHANDLE pSSM, const void *pvBuf, size_t cbBuf);234 static DECLCALLBACK(int) ssmr3WriteOut(void *pvSSM, const void *pvBuf, size_t cbBuf);235 static void ssmr3ReadFinish(PSSMHANDLE pSSM);236 static int ssmr3Read(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf);237 static DECLCALLBACK(int) ssmr3ReadIn(void *pvSSM, void *pvBuf, size_t cbBuf, size_t *pcbRead);245 static int ssmR3Register(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, PSSMUNIT *ppUnit); 246 static int ssmR3CalcChecksum(RTFILE File, uint64_t cbFile, uint32_t *pu32CRC); 247 static void ssmR3Progress(PSSMHANDLE pSSM, uint64_t cbAdvance); 248 static int ssmR3Validate(RTFILE File, PSSMFILEHDR pHdr, size_t *pcbFileHdr); 249 static PSSMUNIT ssmR3Find(PVM pVM, const char *pszName, uint32_t u32Instance); 250 static int ssmR3WriteFinish(PSSMHANDLE pSSM); 251 static int ssmR3Write(PSSMHANDLE pSSM, const void *pvBuf, size_t cbBuf); 252 static DECLCALLBACK(int) ssmR3WriteOut(void *pvSSM, const void *pvBuf, size_t cbBuf); 253 static void ssmR3ReadFinish(PSSMHANDLE pSSM); 254 static int ssmR3Read(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf); 255 static DECLCALLBACK(int) ssmR3ReadIn(void *pvSSM, void *pvBuf, size_t cbBuf, size_t *pcbRead); 238 256 239 257 … … 246 264 static int ssmR3LazyInit(PVM pVM) 247 265 { 248 #if 1 /* if we want 2.0.2 to remain forward compatible with 2.0.x, disable this. */249 266 /* 250 267 * Register a saved state unit which we use to put the VirtualBox version, … … 257 274 pVM->ssm.s.fInitialized = RT_SUCCESS(rc); 258 275 return rc; 259 #else260 pVM->ssm.s.fInitialized = true;261 return VINF_SUCCESS;262 #endif263 276 } 264 277 … … 340 353 * Caller must fill in the missing details. 341 354 */ 342 static int s mmr3Register(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, PSSMUNIT *ppUnit)355 static int ssmR3Register(PVM pVM, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, PSSMUNIT *ppUnit) 343 356 { 344 357 /* … … 404 417 * 405 418 * @returns VBox status. 419 * 406 420 * @param pVM The VM handle. 407 421 * @param pDevIns Device instance. … … 419 433 * @param pfnLoadDone Done load callback, optional. 420 434 */ 421 VMMR3DECL(int) SSMR3Register (PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,435 VMMR3DECL(int) SSMR3RegisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess, 422 436 PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone, 423 437 PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone) 424 438 { 425 439 PSSMUNIT pUnit; 426 int rc = s mmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);440 int rc = ssmR3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit); 427 441 if (VBOX_SUCCESS(rc)) 428 442 { … … 444 458 * 445 459 * @returns VBox status. 460 * 446 461 * @param pVM The VM handle. 447 462 * @param pDrvIns Driver instance. … … 464 479 { 465 480 PSSMUNIT pUnit; 466 int rc = s mmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);481 int rc = ssmR3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit); 467 482 if (VBOX_SUCCESS(rc)) 468 483 { … … 484 499 * 485 500 * @returns VBox status. 501 * 486 502 * @param pVM The VM handle. 487 503 * @param pszName Data unit name. … … 503 519 { 504 520 PSSMUNIT pUnit; 505 int rc = s mmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);521 int rc = ssmR3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit); 506 522 if (VBOX_SUCCESS(rc)) 507 523 { … … 522 538 * 523 539 * @returns VBox status. 540 * 524 541 * @param pVM The VM handle. 525 542 * @param pszName Data unit name. … … 542 559 { 543 560 PSSMUNIT pUnit; 544 int rc = s mmr3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit);561 int rc = ssmR3Register(pVM, pszName, u32Instance, u32Version, cbGuess, &pUnit); 545 562 if (VBOX_SUCCESS(rc)) 546 563 { … … 562 579 * 563 580 * @returns VBox status. 581 * 564 582 * @param pVM The VM handle. 565 583 * @param pDevIns Device instance. … … 570 588 * @remark Only for dynmaic data units and dynamic unloaded modules. 571 589 */ 572 VMMR3DECL(int) SSMR3Deregister (PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance)590 VMMR3DECL(int) SSMR3DeregisterDevice(PVM pVM, PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance) 573 591 { 574 592 /* … … 705 723 } 706 724 725 707 726 /** 708 727 * Deregister a data unit. … … 799 818 * @param pu32CRC Where to store the calculated checksum. 800 819 */ 801 static int ssm r3CalcChecksum(RTFILE File, uint64_t cbFile, uint32_t *pu32CRC)820 static int ssmR3CalcChecksum(RTFILE File, uint64_t cbFile, uint32_t *pu32CRC) 802 821 { 803 822 /* … … 811 830 * Loop reading and calculating CRC32. 812 831 */ 813 int 814 uint32_t u32CRC = RTCrc32Start();832 int rc = VINF_SUCCESS; 833 uint32_t u32CRC = RTCrc32Start(); 815 834 while (cbFile) 816 835 { … … 864 883 pSSM->pfnProgress(pSSM->pVM, pSSM->uPercent, pSSM->pvUser); 865 884 pSSM->uPercent++; 866 pSSM->offEstProgress = (pSSM->uPercent - pSSM->uPercentPrepare) * pSSM->cbEstTotal /867 (100-pSSM->uPercentDone-pSSM->uPercentPrepare);885 pSSM->offEstProgress = (pSSM->uPercent - pSSM->uPercentPrepare) * pSSM->cbEstTotal 886 / (100 - pSSM->uPercentDone - pSSM->uPercentPrepare); 868 887 } 869 888 } … … 872 891 /** 873 892 * Start VM save operation. 874 * The caller must be the emulation thread!875 * 876 * @returns VBox status.893 * 894 * @returns VBox status. 895 * 877 896 * @param pVM The VM handle. 878 897 * @param pszFilename Name of the file to save the state in. … … 880 899 * @param pfnProgress Progress callback. Optional. 881 900 * @param pvUser User argument for the progress callback. 901 * 902 * @thread EMT 882 903 */ 883 904 VMMR3DECL(int) SSMR3Save(PVM pVM, const char *pszFilename, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser) 884 905 { 885 906 LogFlow(("SSMR3Save: pszFilename=%p:{%s} enmAfter=%d pfnProgress=%p pvUser=%p\n", pszFilename, pszFilename, enmAfter, pfnProgress, pvUser)); 907 VM_ASSERT_EMT(pVM); 886 908 887 909 /* … … 896 918 897 919 /* 898 * Try open the file. 899 */ 900 SSMHANDLE Handle = {0}; 901 Handle.enmAfter = enmAfter; 902 Handle.pVM = pVM; 903 Handle.cbFileHdr = sizeof(SSMFILEHDR); 904 Handle.pfnProgress = pfnProgress; 905 Handle.pvUser = pvUser; 906 /* 907 * The 'done' part might take much time: 908 * (1) Call the SaveDone function of each module 909 * (2) Calculate the Checksum 910 * (3) RTFileClose() will probably flush the write cache 911 */ 920 * Create the handle and try open the file. 921 * 922 * Note that there might be quite some work to do after executing the saving, 923 * so we reserve 20% for the 'Done' period. The checksumming and closing of 924 * the saved state file might take a long time. 925 */ 926 SSMHANDLE Handle = {0}; 927 Handle.enmAfter = enmAfter; 928 Handle.pVM = pVM; 929 Handle.cbFileHdr = sizeof(SSMFILEHDR); 930 Handle.pfnProgress = pfnProgress; 931 Handle.pvUser = pvUser; 912 932 Handle.uPercentPrepare = 2; 913 Handle.uPercentDone = 20; /* reserve substantial time for crc-checking the image */ 933 Handle.uPercentDone = 20; 934 914 935 int rc = RTFileOpen(&Handle.File, pszFilename, RTFILE_O_READWRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE); 915 936 if (VBOX_FAILURE(rc)) … … 1058 1079 */ 1059 1080 if (Handle.pZipComp) 1060 rc = ssm r3WriteFinish(&Handle);1081 rc = ssmR3WriteFinish(&Handle); 1061 1082 if (VBOX_SUCCESS(rc)) 1062 1083 { … … 1163 1184 rc = RTFileSeek(Handle.File, RT_OFFSETOF(SSMFILEHDR, u32CRC) + sizeof(Hdr.u32CRC), RTFILE_SEEK_BEGIN, NULL); 1164 1185 if (VBOX_SUCCESS(rc)) 1165 rc = ssm r3CalcChecksum(Handle.File, Hdr.cbFile - sizeof(Hdr), &Hdr.u32CRC);1186 rc = ssmR3CalcChecksum(Handle.File, Hdr.cbFile - sizeof(Hdr), &Hdr.u32CRC); 1166 1187 if (VBOX_SUCCESS(rc)) 1167 1188 { … … 1222 1243 * @param pcbFileHdr Where to store the file header size. 1223 1244 */ 1224 static int ssm r3Validate(RTFILE File, PSSMFILEHDR pHdr, size_t *pcbFileHdr)1245 static int ssmR3Validate(RTFILE File, PSSMFILEHDR pHdr, size_t *pcbFileHdr) 1225 1246 { 1226 1247 /* … … 1261 1282 else 1262 1283 { 1263 /* (It's identical, but this doesn't harm us and will continue working after future changes.) */ 1284 /* (It's identical to the current, but this doesn't harm us and will 1285 continue working after future changes.) */ 1264 1286 SSMFILEHDRV10AMD64 OldHdr; 1265 1287 memcpy(&OldHdr, pHdr, sizeof(OldHdr)); … … 1305 1327 } 1306 1328 uint32_t u32CRC; 1307 rc = ssm r3CalcChecksum(File, pHdr->cbFile - *pcbFileHdr, &u32CRC);1329 rc = ssmR3CalcChecksum(File, pHdr->cbFile - *pcbFileHdr, &u32CRC); 1308 1330 if (VBOX_FAILURE(rc)) 1309 1331 return rc; … … 1336 1358 * @returns Pointer to the unit. 1337 1359 * @returns NULL if not found. 1360 * 1338 1361 * @param pVM VM handle. 1339 1362 * @param pszName Data unit name. 1340 1363 * @param u32Instance The data unit instance id. 1341 1364 */ 1342 static PSSMUNIT ssm r3Find(PVM pVM, const char *pszName, uint32_t u32Instance)1365 static PSSMUNIT ssmR3Find(PVM pVM, const char *pszName, uint32_t u32Instance) 1343 1366 { 1344 1367 size_t cchName = strlen(pszName); … … 1355 1378 /** 1356 1379 * Load VM save operation. 1357 * The caller must be the emulation thread!1358 * 1359 * @returns VBox status.1380 * 1381 * @returns VBox status. 1382 * 1360 1383 * @param pVM The VM handle. 1361 1384 * @param pszFilename Name of the file to save the state in. … … 1364 1387 * @param pfnProgress Progress callback. Optional. 1365 1388 * @param pvUser User argument for the progress callback. 1389 * 1390 * @thread EMT 1366 1391 */ 1367 1392 VMMR3DECL(int) SSMR3Load(PVM pVM, const char *pszFilename, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser) 1368 1393 { 1369 1394 LogFlow(("SSMR3Load: pszFilename=%p:{%s} enmAfter=%d pfnProgress=%p pvUser=%p\n", pszFilename, pszFilename, enmAfter, pfnProgress, pvUser)); 1395 VM_ASSERT_EMT(pVM); 1370 1396 1371 1397 /* … … 1380 1406 1381 1407 /* 1382 * Open the file. 1408 * Create the handle and open the file. 1409 * Note that we reserve 20% of the time on validating the image since this might 1410 * take a long time. 1383 1411 */ 1384 1412 SSMHANDLE Handle = {0}; … … 1388 1416 Handle.pfnProgress = pfnProgress; 1389 1417 Handle.pvUser = pvUser; 1390 Handle.uPercentPrepare = 20; /* reserve substantial time for validating the image */1418 Handle.uPercentPrepare = 20; 1391 1419 Handle.uPercentDone = 2; 1420 1392 1421 int rc = RTFileOpen(&Handle.File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); 1393 1422 if (VBOX_FAILURE(rc)) … … 1401 1430 */ 1402 1431 SSMFILEHDR Hdr; 1403 rc = ssm r3Validate(Handle.File, &Hdr, &Handle.cbFileHdr);1432 rc = ssmR3Validate(Handle.File, &Hdr, &Handle.cbFileHdr); 1404 1433 if (VBOX_SUCCESS(rc)) 1405 1434 { … … 1529 1558 * Find the data unit in our internal table. 1530 1559 */ 1531 pUnit = ssm r3Find(pVM, pszName, UnitHdr.u32Instance);1560 pUnit = ssmR3Find(pVM, pszName, UnitHdr.u32Instance); 1532 1561 if (pUnit) 1533 1562 { … … 1582 1611 */ 1583 1612 if (Handle.pZipDecomp) 1584 ssm r3ReadFinish(&Handle);1613 ssmR3ReadFinish(&Handle); 1585 1614 1586 1615 pUnit->fCalled = true; … … 1752 1781 * @returns VINF_SUCCESS if valid. 1753 1782 * @returns VBox status code on other failures. 1783 * 1754 1784 * @param pszFilename The path to the file to validate. 1785 * 1786 * @thread Any. 1755 1787 */ 1756 1788 VMMR3DECL(int) SSMR3ValidateFile(const char *pszFilename) … … 1767 1799 size_t cbFileHdr; 1768 1800 SSMFILEHDR Hdr; 1769 rc = ssm r3Validate(File, &Hdr, &cbFileHdr);1801 rc = ssmR3Validate(File, &Hdr, &cbFileHdr); 1770 1802 RTFileClose(File); 1771 1803 } … … 1780 1812 * 1781 1813 * @returns VBox status code. 1814 * 1782 1815 * @param pszFilename The path to the saved state file. 1783 1816 * @param fFlags Open flags. Reserved, must be 0. 1784 1817 * @param ppSSM Where to store the SSM handle. 1818 * 1819 * @thread Any. 1785 1820 */ 1786 1821 VMMR3DECL(int) SSMR3Open(const char *pszFilename, unsigned fFlags, PSSMHANDLE *ppSSM) … … 1809 1844 SSMFILEHDR Hdr; 1810 1845 size_t cbFileHdr; 1811 rc = ssm r3Validate(pSSM->File, &Hdr, &cbFileHdr);1846 rc = ssmR3Validate(pSSM->File, &Hdr, &cbFileHdr); 1812 1847 if (VBOX_SUCCESS(rc)) 1813 1848 { … … 1816 1851 pSSM->enmOp = SSMSTATE_OPEN_READ; 1817 1852 pSSM->enmAfter = SSMAFTER_OPENED; 1818 pSSM->uPercentPrepare = 20; /* reserve substantial time for validating the image */1853 pSSM->uPercentPrepare = 20; 1819 1854 pSSM->uPercentDone = 2; 1820 1855 //pSSM->rc = VINF_SUCCESS; … … 1848 1883 * 1849 1884 * @returns VBox status code. 1885 * 1850 1886 * @param pSSM The SSM handle returned by SSMR3Open(). 1887 * 1888 * @thread Any, but the caller is responsible for serializing calls per handle. 1851 1889 */ 1852 1890 VMMR3DECL(int) SSMR3Close(PSSMHANDLE pSSM) … … 1879 1917 * @returns VBox status code. 1880 1918 * @returns VERR_SSM_UNIT_NOT_FOUND if the unit+instance wasn't found. 1919 * 1881 1920 * @param pSSM The SSM handle returned by SSMR3Open(). 1882 1921 * @param pszUnit The name of the data unit. 1883 1922 * @param iInstance The instance number. 1884 1923 * @param piVersion Where to store the version number. (Optional) 1924 * 1925 * @thread Any, but the caller is responsible for serializing calls per handle. 1885 1926 */ 1886 1927 VMMR3DECL(int) SSMR3Seek(PSSMHANDLE pSSM, const char *pszUnit, uint32_t iInstance, uint32_t *piVersion) … … 2003 2044 * @param pSSM SSM operation handle. 2004 2045 */ 2005 static int ssm r3WriteFinish(PSSMHANDLE pSSM)2006 { 2007 //Log2(("ssm r3WriteFinish: %#010llx start\n", RTFileTell(pSSM->File)));2046 static int ssmR3WriteFinish(PSSMHANDLE pSSM) 2047 { 2048 //Log2(("ssmR3WriteFinish: %#010llx start\n", RTFileTell(pSSM->File))); 2008 2049 if (!pSSM->pZipComp) 2009 2050 return VINF_SUCCESS; … … 2016 2057 { 2017 2058 pSSM->pZipComp = NULL; 2018 //Log2(("ssm r3WriteFinish: %#010llx done\n", RTFileTell(pSSM->File)));2059 //Log2(("ssmR3WriteFinish: %#010llx done\n", RTFileTell(pSSM->File))); 2019 2060 return VINF_SUCCESS; 2020 2061 } … … 2022 2063 if (VBOX_SUCCESS(pSSM->rc)) 2023 2064 pSSM->rc = rc; 2024 Log2(("ssm r3WriteFinish: failure rc=%Vrc\n", rc));2065 Log2(("ssmR3WriteFinish: failure rc=%Vrc\n", rc)); 2025 2066 return rc; 2026 2067 } 2068 2027 2069 2028 2070 /** … … 2034 2076 * @param cbBuf The number of bytes to write. 2035 2077 */ 2036 static int ssm r3Write(PSSMHANDLE pSSM, const void *pvBuf, size_t cbBuf)2037 { 2038 Log2(("ssm r3Write: pvBuf=%p cbBuf=%#x %.*Vhxs%s\n", pvBuf, cbBuf, RT_MIN(cbBuf, 128), pvBuf, cbBuf > 128 ? "..." : ""));2078 static int ssmR3Write(PSSMHANDLE pSSM, const void *pvBuf, size_t cbBuf) 2079 { 2080 Log2(("ssmR3Write: pvBuf=%p cbBuf=%#x %.*Vhxs%s\n", pvBuf, cbBuf, RT_MIN(cbBuf, 128), pvBuf, cbBuf > 128 ? "..." : "")); 2039 2081 2040 2082 /* … … 2048 2090 if (!pSSM->pZipComp) 2049 2091 { 2050 //int rc = RTZipCompCreate(&pSSM->pZipComp, pSSM, ssm r3WriteOut, RTZIPTYPE_ZLIB, RTZIPLEVEL_FAST);2051 int rc = RTZipCompCreate(&pSSM->pZipComp, pSSM, ssm r3WriteOut, RTZIPTYPE_LZF, RTZIPLEVEL_FAST);2092 //int rc = RTZipCompCreate(&pSSM->pZipComp, pSSM, ssmR3WriteOut, RTZIPTYPE_ZLIB, RTZIPLEVEL_FAST); 2093 int rc = RTZipCompCreate(&pSSM->pZipComp, pSSM, ssmR3WriteOut, RTZIPTYPE_LZF, RTZIPLEVEL_FAST); 2052 2094 if (VBOX_FAILURE(rc)) 2053 2095 return rc; … … 2078 2120 * @returns VBox status. 2079 2121 * @param pvSSM SSM operation handle. 2080 * @param pvBuf Compressed data.2081 * @param cbBuf Size of the compressed data.2082 */ 2083 static DECLCALLBACK(int) ssm r3WriteOut(void *pvSSM, const void *pvBuf, size_t cbBuf)2084 { 2085 //Log2(("ssm r3WriteOut: %#010llx cbBuf=%#x\n", RTFileTell(((PSSMHANDLE)pvSSM)->File), cbBuf));2122 * @param pvBuf Compressed data. 2123 * @param cbBuf Size of the compressed data. 2124 */ 2125 static DECLCALLBACK(int) ssmR3WriteOut(void *pvSSM, const void *pvBuf, size_t cbBuf) 2126 { 2127 //Log2(("ssmR3WriteOut: %#010llx cbBuf=%#x\n", RTFileTell(((PSSMHANDLE)pvSSM)->File), cbBuf)); 2086 2128 int rc = RTFileWrite(((PSSMHANDLE)pvSSM)->File, pvBuf, cbBuf, NULL); 2087 2129 if (VBOX_SUCCESS(rc)) 2088 2130 return rc; 2089 Log(("ssm r3WriteOut: RTFileWrite(,,%d) -> %d\n", cbBuf, rc));2131 Log(("ssmR3WriteOut: RTFileWrite(,,%d) -> %d\n", cbBuf, rc)); 2090 2132 return rc; 2091 2133 } … … 2113 2155 pCur++) 2114 2156 { 2115 rc = ssm r3Write(pSSM, (uint8_t *)pvStruct + pCur->off, pCur->cb);2157 rc = ssmR3Write(pSSM, (uint8_t *)pvStruct + pCur->off, pCur->cb); 2116 2158 if (VBOX_FAILURE(rc)) 2117 2159 return rc; … … 2135 2177 { 2136 2178 uint8_t u8 = fBool; /* enforce 1 byte size */ 2137 return ssmr3Write(pSSM, &u8, sizeof(u8)); 2138 } 2139 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2140 return VERR_SSM_INVALID_STATE; 2141 } 2179 return ssmR3Write(pSSM, &u8, sizeof(u8)); 2180 } 2181 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2182 return VERR_SSM_INVALID_STATE; 2183 } 2184 2142 2185 2143 2186 /** … … 2151 2194 { 2152 2195 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2153 return ssmr3Write(pSSM, &u8, sizeof(u8)); 2154 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2155 return VERR_SSM_INVALID_STATE; 2156 } 2196 return ssmR3Write(pSSM, &u8, sizeof(u8)); 2197 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2198 return VERR_SSM_INVALID_STATE; 2199 } 2200 2157 2201 2158 2202 /** … … 2166 2210 { 2167 2211 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2168 return ssmr3Write(pSSM, &i8, sizeof(i8)); 2169 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2170 return VERR_SSM_INVALID_STATE; 2171 } 2212 return ssmR3Write(pSSM, &i8, sizeof(i8)); 2213 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2214 return VERR_SSM_INVALID_STATE; 2215 } 2216 2172 2217 2173 2218 /** … … 2181 2226 { 2182 2227 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2183 return ssmr3Write(pSSM, &u16, sizeof(u16)); 2184 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2185 return VERR_SSM_INVALID_STATE; 2186 } 2228 return ssmR3Write(pSSM, &u16, sizeof(u16)); 2229 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2230 return VERR_SSM_INVALID_STATE; 2231 } 2232 2187 2233 2188 2234 /** … … 2196 2242 { 2197 2243 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2198 return ssmr3Write(pSSM, &i16, sizeof(i16)); 2199 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2200 return VERR_SSM_INVALID_STATE; 2201 } 2244 return ssmR3Write(pSSM, &i16, sizeof(i16)); 2245 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2246 return VERR_SSM_INVALID_STATE; 2247 } 2248 2202 2249 2203 2250 /** … … 2211 2258 { 2212 2259 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2213 return ssmr3Write(pSSM, &u32, sizeof(u32)); 2214 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2215 return VERR_SSM_INVALID_STATE; 2216 } 2260 return ssmR3Write(pSSM, &u32, sizeof(u32)); 2261 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2262 return VERR_SSM_INVALID_STATE; 2263 } 2264 2217 2265 2218 2266 /** … … 2226 2274 { 2227 2275 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2228 return ssmr3Write(pSSM, &i32, sizeof(i32)); 2229 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2230 return VERR_SSM_INVALID_STATE; 2231 } 2276 return ssmR3Write(pSSM, &i32, sizeof(i32)); 2277 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2278 return VERR_SSM_INVALID_STATE; 2279 } 2280 2232 2281 2233 2282 /** … … 2241 2290 { 2242 2291 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2243 return ssmr3Write(pSSM, &u64, sizeof(u64)); 2244 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2245 return VERR_SSM_INVALID_STATE; 2246 } 2292 return ssmR3Write(pSSM, &u64, sizeof(u64)); 2293 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2294 return VERR_SSM_INVALID_STATE; 2295 } 2296 2247 2297 2248 2298 /** … … 2256 2306 { 2257 2307 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2258 return ssmr3Write(pSSM, &i64, sizeof(i64)); 2259 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2260 return VERR_SSM_INVALID_STATE; 2261 } 2308 return ssmR3Write(pSSM, &i64, sizeof(i64)); 2309 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2310 return VERR_SSM_INVALID_STATE; 2311 } 2312 2262 2313 2263 2314 /** … … 2271 2322 { 2272 2323 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2273 return ssmr3Write(pSSM, &u128, sizeof(u128)); 2274 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2275 return VERR_SSM_INVALID_STATE; 2276 } 2324 return ssmR3Write(pSSM, &u128, sizeof(u128)); 2325 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2326 return VERR_SSM_INVALID_STATE; 2327 } 2328 2277 2329 2278 2330 /** … … 2286 2338 { 2287 2339 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2288 return ssmr3Write(pSSM, &i128, sizeof(i128)); 2289 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2290 return VERR_SSM_INVALID_STATE; 2291 } 2340 return ssmR3Write(pSSM, &i128, sizeof(i128)); 2341 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2342 return VERR_SSM_INVALID_STATE; 2343 } 2344 2292 2345 2293 2346 /** … … 2301 2354 { 2302 2355 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2303 return ssm r3Write(pSSM, &u, sizeof(u));2356 return ssmR3Write(pSSM, &u, sizeof(u)); 2304 2357 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2305 2358 return VERR_SSM_INVALID_STATE; … … 2317 2370 { 2318 2371 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2319 return ssm r3Write(pSSM, &i, sizeof(i));2372 return ssmR3Write(pSSM, &i, sizeof(i)); 2320 2373 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2321 2374 return VERR_SSM_INVALID_STATE; … … 2333 2386 { 2334 2387 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2335 return ssm r3Write(pSSM, &u, sizeof(u));2388 return ssmR3Write(pSSM, &u, sizeof(u)); 2336 2389 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2337 2390 return VERR_SSM_INVALID_STATE; … … 2349 2402 { 2350 2403 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2351 return ssm r3Write(pSSM, &i, sizeof(i));2404 return ssmR3Write(pSSM, &i, sizeof(i)); 2352 2405 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2353 2406 return VERR_SSM_INVALID_STATE; … … 2365 2418 { 2366 2419 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2367 return ssm r3Write(pSSM, &GCPhys, sizeof(GCPhys));2420 return ssmR3Write(pSSM, &GCPhys, sizeof(GCPhys)); 2368 2421 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2369 2422 return VERR_SSM_INVALID_STATE; … … 2381 2434 { 2382 2435 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2383 return ssm r3Write(pSSM, &GCPhys, sizeof(GCPhys));2436 return ssmR3Write(pSSM, &GCPhys, sizeof(GCPhys)); 2384 2437 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2385 2438 return VERR_SSM_INVALID_STATE; … … 2397 2450 { 2398 2451 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2399 return ssm r3Write(pSSM, &GCPhys, sizeof(GCPhys));2452 return ssmR3Write(pSSM, &GCPhys, sizeof(GCPhys)); 2400 2453 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2401 2454 return VERR_SSM_INVALID_STATE; … … 2413 2466 { 2414 2467 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2415 return ssm r3Write(pSSM, &GCPtr, sizeof(GCPtr));2468 return ssmR3Write(pSSM, &GCPtr, sizeof(GCPtr)); 2416 2469 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2417 2470 return VERR_SSM_INVALID_STATE; … … 2429 2482 { 2430 2483 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2431 return ssm r3Write(pSSM, &RCPtr, sizeof(RCPtr));2484 return ssmR3Write(pSSM, &RCPtr, sizeof(RCPtr)); 2432 2485 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2433 2486 return VERR_SSM_INVALID_STATE; … … 2445 2498 { 2446 2499 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2447 return ssm r3Write(pSSM, &GCPtr, sizeof(GCPtr));2500 return ssmR3Write(pSSM, &GCPtr, sizeof(GCPtr)); 2448 2501 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2449 2502 return VERR_SSM_INVALID_STATE; … … 2461 2514 { 2462 2515 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2463 return ssm r3Write(pSSM, &u, sizeof(u));2516 return ssmR3Write(pSSM, &u, sizeof(u)); 2464 2517 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2465 2518 return VERR_SSM_INVALID_STATE; … … 2477 2530 { 2478 2531 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2479 return ssm r3Write(pSSM, &i, sizeof(i));2532 return ssmR3Write(pSSM, &i, sizeof(i)); 2480 2533 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2481 2534 return VERR_SSM_INVALID_STATE; … … 2493 2546 { 2494 2547 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2495 return ssm r3Write(pSSM, &IOPort, sizeof(IOPort));2548 return ssmR3Write(pSSM, &IOPort, sizeof(IOPort)); 2496 2549 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2497 2550 return VERR_SSM_INVALID_STATE; … … 2509 2562 { 2510 2563 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2511 return ssm r3Write(pSSM, &Sel, sizeof(Sel));2564 return ssmR3Write(pSSM, &Sel, sizeof(Sel)); 2512 2565 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2513 2566 return VERR_SSM_INVALID_STATE; … … 2526 2579 { 2527 2580 if (pSSM->enmOp == SSMSTATE_SAVE_EXEC) 2528 return ssmr3Write(pSSM, pv, cb); 2529 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2530 return VERR_SSM_INVALID_STATE; 2531 } 2581 return ssmR3Write(pSSM, pv, cb); 2582 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2583 return VERR_SSM_INVALID_STATE; 2584 } 2585 2532 2586 2533 2587 /** … … 2549 2603 } 2550 2604 uint32_t u32 = (uint32_t)cch; 2551 int rc = ssm r3Write(pSSM, &u32, sizeof(u32));2605 int rc = ssmR3Write(pSSM, &u32, sizeof(u32)); 2552 2606 if (rc) 2553 2607 return rc; 2554 return ssm r3Write(pSSM, psz, cch);2608 return ssmR3Write(pSSM, psz, cch); 2555 2609 } 2556 2610 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); … … 2567 2621 * @param pSSM SSM operation handle. 2568 2622 */ 2569 static void ssm r3ReadFinish(PSSMHANDLE pSSM)2623 static void ssmR3ReadFinish(PSSMHANDLE pSSM) 2570 2624 { 2571 2625 int rc = RTZipDecompDestroy(pSSM->pZipDecomp); … … 2574 2628 } 2575 2629 2630 2576 2631 /** 2577 2632 * Internal read worker. … … 2581 2636 * @param cbBuf Number of bytes to read. 2582 2637 */ 2583 static int ssm r3Read(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf)2638 static int ssmR3Read(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf) 2584 2639 { 2585 2640 /* … … 2593 2648 if (!pSSM->pZipDecomp) 2594 2649 { 2595 pSSM->rc = RTZipDecompCreate(&pSSM->pZipDecomp, pSSM, ssm r3ReadIn);2650 pSSM->rc = RTZipDecompCreate(&pSSM->pZipDecomp, pSSM, ssmR3ReadIn); 2596 2651 if (VBOX_FAILURE(pSSM->rc)) 2597 2652 return pSSM->rc; … … 2604 2659 pSSM->rc = RTZipDecompress(pSSM->pZipDecomp, pvBuf, cbBuf, NULL); 2605 2660 if (VBOX_SUCCESS(pSSM->rc)) 2606 Log2(("ssm r3Read: pvBuf=%p cbBuf=%#x %.*Vhxs%s\n", pvBuf, cbBuf, RT_MIN(cbBuf, 128), pvBuf, cbBuf > 128 ? "..." : ""));2661 Log2(("ssmR3Read: pvBuf=%p cbBuf=%#x %.*Vhxs%s\n", pvBuf, cbBuf, RT_MIN(cbBuf, 128), pvBuf, cbBuf > 128 ? "..." : "")); 2607 2662 else 2608 2663 AssertMsgFailed(("rc=%Vrc cbBuf=%#x\n", pSSM->rc, cbBuf)); … … 2611 2666 return pSSM->rc; 2612 2667 } 2668 2613 2669 2614 2670 /** … … 2622 2678 * @param pcbRead Number of bytes actually stored in the buffer. 2623 2679 */ 2624 static DECLCALLBACK(int) ssm r3ReadIn(void *pvSSM, void *pvBuf, size_t cbBuf, size_t *pcbRead)2680 static DECLCALLBACK(int) ssmR3ReadIn(void *pvSSM, void *pvBuf, size_t cbBuf, size_t *pcbRead) 2625 2681 { 2626 2682 PSSMHANDLE pSSM = (PSSMHANDLE)pvSSM; … … 2630 2686 if (cbRead) 2631 2687 { 2632 //Log2(("ssm r3ReadIn: %#010llx cbBug=%#x cbRead=%#x\n", RTFileTell(pSSM->File), cbBuf, cbRead));2688 //Log2(("ssmR3ReadIn: %#010llx cbBug=%#x cbRead=%#x\n", RTFileTell(pSSM->File), cbBuf, cbRead)); 2633 2689 int rc = RTFileRead(pSSM->File, pvBuf, cbRead, NULL); 2634 2690 if (VBOX_SUCCESS(rc)) … … 2640 2696 return VINF_SUCCESS; 2641 2697 } 2642 Log(("ssm r3ReadIn: RTFileRead(,,%d) -> %d\n", cbRead, rc));2698 Log(("ssmR3ReadIn: RTFileRead(,,%d) -> %d\n", cbRead, rc)); 2643 2699 return rc; 2644 2700 } … … 2675 2731 pCur++) 2676 2732 { 2677 rc = ssm r3Read(pSSM, (uint8_t *)pvStruct + pCur->off, pCur->cb);2733 rc = ssmR3Read(pSSM, (uint8_t *)pvStruct + pCur->off, pCur->cb); 2678 2734 if (VBOX_FAILURE(rc)) 2679 2735 return rc; … … 2702 2758 { 2703 2759 uint8_t u8; /* see SSMR3PutBool */ 2704 int rc = ssm r3Read(pSSM, &u8, sizeof(u8));2760 int rc = ssmR3Read(pSSM, &u8, sizeof(u8)); 2705 2761 if (VBOX_SUCCESS(rc)) 2706 2762 { … … 2714 2770 } 2715 2771 2772 2716 2773 /** 2717 2774 * Loads a 8-bit unsigned integer item from the current data unit. … … 2724 2781 { 2725 2782 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2726 return ssmr3Read(pSSM, pu8, sizeof(*pu8)); 2727 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2728 return VERR_SSM_INVALID_STATE; 2729 } 2783 return ssmR3Read(pSSM, pu8, sizeof(*pu8)); 2784 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2785 return VERR_SSM_INVALID_STATE; 2786 } 2787 2730 2788 2731 2789 /** … … 2739 2797 { 2740 2798 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2741 return ssmr3Read(pSSM, pi8, sizeof(*pi8)); 2742 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2743 return VERR_SSM_INVALID_STATE; 2744 } 2799 return ssmR3Read(pSSM, pi8, sizeof(*pi8)); 2800 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2801 return VERR_SSM_INVALID_STATE; 2802 } 2803 2745 2804 2746 2805 /** … … 2754 2813 { 2755 2814 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2756 return ssmr3Read(pSSM, pu16, sizeof(*pu16)); 2757 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2758 return VERR_SSM_INVALID_STATE; 2759 } 2815 return ssmR3Read(pSSM, pu16, sizeof(*pu16)); 2816 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2817 return VERR_SSM_INVALID_STATE; 2818 } 2819 2760 2820 2761 2821 /** … … 2769 2829 { 2770 2830 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2771 return ssmr3Read(pSSM, pi16, sizeof(*pi16)); 2772 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2773 return VERR_SSM_INVALID_STATE; 2774 } 2831 return ssmR3Read(pSSM, pi16, sizeof(*pi16)); 2832 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2833 return VERR_SSM_INVALID_STATE; 2834 } 2835 2775 2836 2776 2837 /** … … 2784 2845 { 2785 2846 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2786 return ssmr3Read(pSSM, pu32, sizeof(*pu32)); 2787 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2788 return VERR_SSM_INVALID_STATE; 2789 } 2847 return ssmR3Read(pSSM, pu32, sizeof(*pu32)); 2848 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2849 return VERR_SSM_INVALID_STATE; 2850 } 2851 2790 2852 2791 2853 /** … … 2799 2861 { 2800 2862 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2801 return ssmr3Read(pSSM, pi32, sizeof(*pi32)); 2802 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2803 return VERR_SSM_INVALID_STATE; 2804 } 2863 return ssmR3Read(pSSM, pi32, sizeof(*pi32)); 2864 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2865 return VERR_SSM_INVALID_STATE; 2866 } 2867 2805 2868 2806 2869 /** … … 2814 2877 { 2815 2878 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2816 return ssmr3Read(pSSM, pu64, sizeof(*pu64)); 2817 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2818 return VERR_SSM_INVALID_STATE; 2819 } 2879 return ssmR3Read(pSSM, pu64, sizeof(*pu64)); 2880 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2881 return VERR_SSM_INVALID_STATE; 2882 } 2883 2820 2884 2821 2885 /** … … 2829 2893 { 2830 2894 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2831 return ssmr3Read(pSSM, pi64, sizeof(*pi64)); 2832 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2833 return VERR_SSM_INVALID_STATE; 2834 } 2895 return ssmR3Read(pSSM, pi64, sizeof(*pi64)); 2896 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2897 return VERR_SSM_INVALID_STATE; 2898 } 2899 2835 2900 2836 2901 /** … … 2844 2909 { 2845 2910 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2846 return ssm r3Read(pSSM, pu128, sizeof(*pu128));2911 return ssmR3Read(pSSM, pu128, sizeof(*pu128)); 2847 2912 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2848 2913 return VERR_SSM_INVALID_STATE; … … 2860 2925 { 2861 2926 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2862 return ssm r3Read(pSSM, pi128, sizeof(*pi128));2927 return ssmR3Read(pSSM, pi128, sizeof(*pi128)); 2863 2928 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2864 2929 return VERR_SSM_INVALID_STATE; … … 2876 2941 { 2877 2942 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2878 return ssm r3Read(pSSM, pu, sizeof(*pu));2943 return ssmR3Read(pSSM, pu, sizeof(*pu)); 2879 2944 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2880 2945 return VERR_SSM_INVALID_STATE; … … 2892 2957 { 2893 2958 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2894 return ssm r3Read(pSSM, pi, sizeof(*pi));2959 return ssmR3Read(pSSM, pi, sizeof(*pi)); 2895 2960 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2896 2961 return VERR_SSM_INVALID_STATE; … … 2915 2980 uint32_t val; 2916 2981 Assert(sizeof(*pu) == sizeof(uint64_t) && pSSM->cbGCPtr == sizeof(uint32_t)); 2917 int rc = ssm r3Read(pSSM, &val, pSSM->cbGCPtr);2982 int rc = ssmR3Read(pSSM, &val, pSSM->cbGCPtr); 2918 2983 *pu = val; 2919 2984 return rc; 2920 2985 } 2921 return ssm r3Read(pSSM, pu, sizeof(*pu));2986 return ssmR3Read(pSSM, pu, sizeof(*pu)); 2922 2987 } 2923 2988 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); … … 2943 3008 int32_t val; 2944 3009 Assert(sizeof(*pi) == sizeof(uint64_t) && pSSM->cbGCPtr == sizeof(uint32_t)); 2945 int rc = ssm r3Read(pSSM, &val, pSSM->cbGCPtr);3010 int rc = ssmR3Read(pSSM, &val, pSSM->cbGCPtr); 2946 3011 *pi = val; 2947 3012 return rc; 2948 3013 } 2949 return ssm r3Read(pSSM, pi, sizeof(*pi));3014 return ssmR3Read(pSSM, pi, sizeof(*pi)); 2950 3015 } 2951 3016 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); … … 2964 3029 { 2965 3030 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2966 return ssm r3Read(pSSM, pGCPhys, sizeof(*pGCPhys));3031 return ssmR3Read(pSSM, pGCPhys, sizeof(*pGCPhys)); 2967 3032 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2968 3033 return VERR_SSM_INVALID_STATE; … … 2980 3045 { 2981 3046 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2982 return ssm r3Read(pSSM, pGCPhys, sizeof(*pGCPhys));3047 return ssmR3Read(pSSM, pGCPhys, sizeof(*pGCPhys)); 2983 3048 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 2984 3049 return VERR_SSM_INVALID_STATE; … … 2996 3061 { 2997 3062 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 2998 return ssm r3Read(pSSM, pGCPhys, sizeof(*pGCPhys));3063 return ssmR3Read(pSSM, pGCPhys, sizeof(*pGCPhys)); 2999 3064 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3000 3065 return VERR_SSM_INVALID_STATE; … … 3005 3070 * Loads a GC virtual address item from the current data unit. 3006 3071 * 3007 * Note: only applies to:3008 * - SSMR3GetGCPtr3009 * - SSMR3GetGCUIntPtr3010 * - SSMR3GetGCSInt3011 * - SSMR3GetGCUInt3072 * Only applies to: 3073 * - SSMR3GetGCPtr 3074 * - SSMR3GetGCUIntPtr 3075 * - SSMR3GetGCSInt 3076 * - SSMR3GetGCUInt 3012 3077 * 3013 3078 * Put functions are not affected. … … 3025 3090 } 3026 3091 3092 3027 3093 /** 3028 3094 * Loads a GC virtual address item from the current data unit. … … 3042 3108 RTGCPTR32 val; 3043 3109 Assert(sizeof(*pGCPtr) == sizeof(uint64_t) && pSSM->cbGCPtr == sizeof(uint32_t)); 3044 int rc = ssm r3Read(pSSM, &val, pSSM->cbGCPtr);3110 int rc = ssmR3Read(pSSM, &val, pSSM->cbGCPtr); 3045 3111 *pGCPtr = val; 3046 3112 return rc; 3047 3113 } 3048 return ssmr3Read(pSSM, pGCPtr, pSSM->cbGCPtr); 3049 } 3050 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3051 return VERR_SSM_INVALID_STATE; 3052 } 3114 return ssmR3Read(pSSM, pGCPtr, pSSM->cbGCPtr); 3115 } 3116 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3117 return VERR_SSM_INVALID_STATE; 3118 } 3119 3053 3120 3054 3121 /** … … 3062 3129 { 3063 3130 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 3064 return ssmr3Read(pSSM, pRCPtr, sizeof(*pRCPtr)); 3065 3066 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3067 return VERR_SSM_INVALID_STATE; 3068 } 3131 return ssmR3Read(pSSM, pRCPtr, sizeof(*pRCPtr)); 3132 3133 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3134 return VERR_SSM_INVALID_STATE; 3135 } 3136 3069 3137 3070 3138 /** … … 3085 3153 RTGCUINTPTR32 val; 3086 3154 Assert(sizeof(*pGCPtr) == sizeof(uint64_t) && pSSM->cbGCPtr == sizeof(uint32_t)); 3087 int rc = ssm r3Read(pSSM, &val, pSSM->cbGCPtr);3155 int rc = ssmR3Read(pSSM, &val, pSSM->cbGCPtr); 3088 3156 *pGCPtr = val; 3089 3157 return rc; 3090 3158 } 3091 return ssm r3Read(pSSM, pGCPtr, pSSM->cbGCPtr);3159 return ssmR3Read(pSSM, pGCPtr, pSSM->cbGCPtr); 3092 3160 } 3093 3161 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); … … 3106 3174 { 3107 3175 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 3108 return ssm r3Read(pSSM, pIOPort, sizeof(*pIOPort));3176 return ssmR3Read(pSSM, pIOPort, sizeof(*pIOPort)); 3109 3177 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3110 3178 return VERR_SSM_INVALID_STATE; … … 3122 3190 { 3123 3191 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 3124 return ssm r3Read(pSSM, pSel, sizeof(*pSel));3192 return ssmR3Read(pSSM, pSel, sizeof(*pSel)); 3125 3193 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3126 3194 return VERR_SSM_INVALID_STATE; … … 3139 3207 { 3140 3208 if (pSSM->enmOp == SSMSTATE_LOAD_EXEC || pSSM->enmOp == SSMSTATE_OPEN_READ) 3141 return ssm r3Read(pSSM, pv, cb);3209 return ssmR3Read(pSSM, pv, cb); 3142 3210 AssertMsgFailed(("Invalid state %d\n", pSSM->enmOp)); 3143 3211 return VERR_SSM_INVALID_STATE; … … 3183 3251 /* terminate and read string content. */ 3184 3252 psz[u32] = '\0'; 3185 return ssm r3Read(pSSM, psz, u32);3253 return ssmR3Read(pSSM, psz, u32); 3186 3254 } 3187 3255 return VERR_TOO_MUCH_DATA; … … 3210 3278 } 3211 3279 3280 3212 3281 /** 3213 3282 * Fail the load operation. -
trunk/src/VBox/VMM/testcase/tstSSM.cpp
r11822 r13594 634 634 * Register a few callbacks. 635 635 */ 636 rc = SSMR3Register (pVM, NULL, "SSM Testcase Data Item no.1 (all types)", 1, 0, 256,636 rc = SSMR3RegisterDevice(pVM, NULL, "SSM Testcase Data Item no.1 (all types)", 1, 0, 256, 637 637 NULL, Item01Save, NULL, 638 638 NULL, Item01Load, NULL); … … 643 643 } 644 644 645 rc = SSMR3Register (pVM, NULL, "SSM Testcase Data Item no.2 (rand mem)", 2, 0, _1M * 8,645 rc = SSMR3RegisterDevice(pVM, NULL, "SSM Testcase Data Item no.2 (rand mem)", 2, 0, _1M * 8, 646 646 NULL, Item02Save, NULL, 647 647 NULL, Item02Load, NULL); … … 652 652 } 653 653 654 rc = SSMR3Register (pVM, NULL, "SSM Testcase Data Item no.3 (big mem)", 0, 123, 512*_1M,654 rc = SSMR3RegisterDevice(pVM, NULL, "SSM Testcase Data Item no.3 (big mem)", 0, 123, 512*_1M, 655 655 NULL, Item03Save, NULL, 656 656 NULL, Item03Load, NULL); … … 661 661 } 662 662 663 rc = SSMR3Register (pVM, NULL, "SSM Testcase Data Item no.4 (big zero mem)", 0, 42, 512*_1M,663 rc = SSMR3RegisterDevice(pVM, NULL, "SSM Testcase Data Item no.4 (big zero mem)", 0, 42, 512*_1M, 664 664 NULL, Item04Save, NULL, 665 665 NULL, Item04Load, NULL);
Note:
See TracChangeset
for help on using the changeset viewer.
