1 | /* $Id: FTM.cpp 46420 2013-06-06 16:27:25Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * FTM - Fault Tolerance Manager
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2010-2013 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | */
|
---|
17 |
|
---|
18 |
|
---|
19 | /*******************************************************************************
|
---|
20 | * Header Files *
|
---|
21 | *******************************************************************************/
|
---|
22 | #define LOG_GROUP LOG_GROUP_FTM
|
---|
23 | #include <VBox/vmm/ftm.h>
|
---|
24 | #include <VBox/vmm/em.h>
|
---|
25 | #include <VBox/vmm/pdm.h>
|
---|
26 | #include <VBox/vmm/pgm.h>
|
---|
27 | #include <VBox/vmm/ssm.h>
|
---|
28 | #include <VBox/vmm/vmm.h>
|
---|
29 | #include "FTMInternal.h"
|
---|
30 | #include <VBox/vmm/vm.h>
|
---|
31 | #include <VBox/vmm/uvm.h>
|
---|
32 | #include <VBox/err.h>
|
---|
33 | #include <VBox/param.h>
|
---|
34 | #include <VBox/log.h>
|
---|
35 |
|
---|
36 | #include <iprt/assert.h>
|
---|
37 | #include <iprt/thread.h>
|
---|
38 | #include <iprt/string.h>
|
---|
39 | #include <iprt/mem.h>
|
---|
40 | #include <iprt/tcp.h>
|
---|
41 | #include <iprt/socket.h>
|
---|
42 | #include <iprt/semaphore.h>
|
---|
43 | #include <iprt/asm.h>
|
---|
44 |
|
---|
45 | #include "internal/pgm.h"
|
---|
46 |
|
---|
47 |
|
---|
48 | /*******************************************************************************
|
---|
49 | * Structures and Typedefs *
|
---|
50 | *******************************************************************************/
|
---|
51 |
|
---|
52 | /**
|
---|
53 | * TCP stream header.
|
---|
54 | *
|
---|
55 | * This is an extra layer for fixing the problem with figuring out when the SSM
|
---|
56 | * stream ends.
|
---|
57 | */
|
---|
58 | typedef struct FTMTCPHDR
|
---|
59 | {
|
---|
60 | /** Magic value. */
|
---|
61 | uint32_t u32Magic;
|
---|
62 | /** The size of the data block following this header.
|
---|
63 | * 0 indicates the end of the stream, while UINT32_MAX indicates
|
---|
64 | * cancelation. */
|
---|
65 | uint32_t cb;
|
---|
66 | } FTMTCPHDR;
|
---|
67 | /** Magic value for FTMTCPHDR::u32Magic. (Egberto Gismonti Amin) */
|
---|
68 | #define FTMTCPHDR_MAGIC UINT32_C(0x19471205)
|
---|
69 | /** The max block size. */
|
---|
70 | #define FTMTCPHDR_MAX_SIZE UINT32_C(0x00fffff8)
|
---|
71 |
|
---|
72 | /**
|
---|
73 | * TCP stream header.
|
---|
74 | *
|
---|
75 | * This is an extra layer for fixing the problem with figuring out when the SSM
|
---|
76 | * stream ends.
|
---|
77 | */
|
---|
78 | typedef struct FTMTCPHDRMEM
|
---|
79 | {
|
---|
80 | /** Magic value. */
|
---|
81 | uint32_t u32Magic;
|
---|
82 | /** Size (Uncompressed) of the pages following the header. */
|
---|
83 | uint32_t cbPageRange;
|
---|
84 | /** GC Physical address of the page(s) to sync. */
|
---|
85 | RTGCPHYS GCPhys;
|
---|
86 | /** The size of the data block following this header.
|
---|
87 | * 0 indicates the end of the stream, while UINT32_MAX indicates
|
---|
88 | * cancelation. */
|
---|
89 | uint32_t cb;
|
---|
90 | } FTMTCPHDRMEM;
|
---|
91 |
|
---|
92 | /*******************************************************************************
|
---|
93 | * Global Variables *
|
---|
94 | *******************************************************************************/
|
---|
95 | static const char g_szWelcome[] = "VirtualBox-Fault-Tolerance-Sync-1.0\n";
|
---|
96 |
|
---|
97 | static DECLCALLBACK(int) ftmR3PageTreeDestroyCallback(PAVLGCPHYSNODECORE pBaseNode, void *pvUser);
|
---|
98 |
|
---|
99 | /**
|
---|
100 | * Initializes the FTM.
|
---|
101 | *
|
---|
102 | * @returns VBox status code.
|
---|
103 | * @param pVM Pointer to the VM.
|
---|
104 | */
|
---|
105 | VMMR3_INT_DECL(int) FTMR3Init(PVM pVM)
|
---|
106 | {
|
---|
107 | /*
|
---|
108 | * Assert alignment and sizes.
|
---|
109 | */
|
---|
110 | AssertCompile(sizeof(pVM->ftm.s) <= sizeof(pVM->ftm.padding));
|
---|
111 | AssertCompileMemberAlignment(FTM, CritSect, sizeof(uintptr_t));
|
---|
112 |
|
---|
113 | /** @todo saved state for master nodes! */
|
---|
114 | pVM->ftm.s.pszAddress = NULL;
|
---|
115 | pVM->ftm.s.pszPassword = NULL;
|
---|
116 | pVM->fFaultTolerantMaster = false;
|
---|
117 | pVM->ftm.s.fIsStandbyNode = false;
|
---|
118 | pVM->ftm.s.standby.hServer = NIL_RTTCPSERVER;
|
---|
119 | pVM->ftm.s.hShutdownEvent = NIL_RTSEMEVENT;
|
---|
120 | pVM->ftm.s.hSocket = NIL_RTSOCKET;
|
---|
121 |
|
---|
122 | /*
|
---|
123 | * Initialize the PGM critical section.
|
---|
124 | */
|
---|
125 | int rc = PDMR3CritSectInit(pVM, &pVM->ftm.s.CritSect, RT_SRC_POS, "FTM");
|
---|
126 | AssertRCReturn(rc, rc);
|
---|
127 |
|
---|
128 | /*
|
---|
129 | * Register statistics.
|
---|
130 | */
|
---|
131 | STAM_REL_REG(pVM, &pVM->ftm.s.StatReceivedMem, STAMTYPE_COUNTER, "/FT/Received/Mem", STAMUNIT_BYTES, "The amount of memory pages that was received.");
|
---|
132 | STAM_REL_REG(pVM, &pVM->ftm.s.StatReceivedState, STAMTYPE_COUNTER, "/FT/Received/State", STAMUNIT_BYTES, "The amount of state information that was received.");
|
---|
133 | STAM_REL_REG(pVM, &pVM->ftm.s.StatSentMem, STAMTYPE_COUNTER, "/FT/Sent/Mem", STAMUNIT_BYTES, "The amount of memory pages that was sent.");
|
---|
134 | STAM_REL_REG(pVM, &pVM->ftm.s.StatSentState, STAMTYPE_COUNTER, "/FT/Sent/State", STAMUNIT_BYTES, "The amount of state information that was sent.");
|
---|
135 | STAM_REL_REG(pVM, &pVM->ftm.s.StatDeltaVM, STAMTYPE_COUNTER, "/FT/Sync/DeltaVM", STAMUNIT_OCCURENCES, "Number of delta vm syncs.");
|
---|
136 | STAM_REL_REG(pVM, &pVM->ftm.s.StatFullSync, STAMTYPE_COUNTER, "/FT/Sync/Full", STAMUNIT_OCCURENCES, "Number of full vm syncs.");
|
---|
137 | STAM_REL_REG(pVM, &pVM->ftm.s.StatDeltaMem, STAMTYPE_COUNTER, "/FT/Sync/DeltaMem", STAMUNIT_OCCURENCES, "Number of delta mem syncs.");
|
---|
138 | STAM_REL_REG(pVM, &pVM->ftm.s.StatCheckpointStorage, STAMTYPE_COUNTER, "/FT/Checkpoint/Storage", STAMUNIT_OCCURENCES, "Number of storage checkpoints.");
|
---|
139 | STAM_REL_REG(pVM, &pVM->ftm.s.StatCheckpointNetwork, STAMTYPE_COUNTER, "/FT/Checkpoint/Network", STAMUNIT_OCCURENCES, "Number of network checkpoints.");
|
---|
140 | #ifdef VBOX_WITH_STATISTICS
|
---|
141 | STAM_REG(pVM, &pVM->ftm.s.StatCheckpoint, STAMTYPE_PROFILE, "/FT/Checkpoint", STAMUNIT_TICKS_PER_CALL, "Profiling of FTMR3SetCheckpoint.");
|
---|
142 | STAM_REG(pVM, &pVM->ftm.s.StatCheckpointPause, STAMTYPE_PROFILE, "/FT/Checkpoint/Pause", STAMUNIT_TICKS_PER_CALL, "Profiling of FTMR3SetCheckpoint.");
|
---|
143 | STAM_REG(pVM, &pVM->ftm.s.StatCheckpointResume, STAMTYPE_PROFILE, "/FT/Checkpoint/Resume", STAMUNIT_TICKS_PER_CALL, "Profiling of FTMR3SetCheckpoint.");
|
---|
144 | STAM_REG(pVM, &pVM->ftm.s.StatSentMemRAM, STAMTYPE_COUNTER, "/FT/Sent/Mem/RAM", STAMUNIT_BYTES, "The amount of memory pages that was sent.");
|
---|
145 | STAM_REG(pVM, &pVM->ftm.s.StatSentMemMMIO2, STAMTYPE_COUNTER, "/FT/Sent/Mem/MMIO2", STAMUNIT_BYTES, "The amount of memory pages that was sent.");
|
---|
146 | STAM_REG(pVM, &pVM->ftm.s.StatSentMemShwROM, STAMTYPE_COUNTER, "/FT/Sent/Mem/ShwROM", STAMUNIT_BYTES, "The amount of memory pages that was sent.");
|
---|
147 | STAM_REG(pVM, &pVM->ftm.s.StatSentStateWrite, STAMTYPE_COUNTER, "/FT/Sent/State/Writes", STAMUNIT_BYTES, "The nr of write calls.");
|
---|
148 | #endif
|
---|
149 | return VINF_SUCCESS;
|
---|
150 | }
|
---|
151 |
|
---|
152 | /**
|
---|
153 | * Terminates the FTM.
|
---|
154 | *
|
---|
155 | * Termination means cleaning up and freeing all resources,
|
---|
156 | * the VM itself is at this point powered off or suspended.
|
---|
157 | *
|
---|
158 | * @returns VBox status code.
|
---|
159 | * @param pVM Pointer to the VM.
|
---|
160 | */
|
---|
161 | VMMR3_INT_DECL(int) FTMR3Term(PVM pVM)
|
---|
162 | {
|
---|
163 | if (pVM->ftm.s.hShutdownEvent != NIL_RTSEMEVENT)
|
---|
164 | {
|
---|
165 | RTSemEventDestroy(pVM->ftm.s.hShutdownEvent);
|
---|
166 | pVM->ftm.s.hShutdownEvent = NIL_RTSEMEVENT;
|
---|
167 | }
|
---|
168 | if (pVM->ftm.s.hSocket != NIL_RTSOCKET)
|
---|
169 | {
|
---|
170 | RTTcpClientClose(pVM->ftm.s.hSocket);
|
---|
171 | pVM->ftm.s.hSocket = NIL_RTSOCKET;
|
---|
172 | }
|
---|
173 | if (pVM->ftm.s.standby.hServer)
|
---|
174 | {
|
---|
175 | RTTcpServerDestroy(pVM->ftm.s.standby.hServer);
|
---|
176 | pVM->ftm.s.standby.hServer = NULL;
|
---|
177 | }
|
---|
178 | if (pVM->ftm.s.pszAddress)
|
---|
179 | RTMemFree(pVM->ftm.s.pszAddress);
|
---|
180 | if (pVM->ftm.s.pszPassword)
|
---|
181 | RTMemFree(pVM->ftm.s.pszPassword);
|
---|
182 |
|
---|
183 | /* Remove all pending memory updates. */
|
---|
184 | if (pVM->ftm.s.standby.pPhysPageTree)
|
---|
185 | {
|
---|
186 | RTAvlGCPhysDestroy(&pVM->ftm.s.standby.pPhysPageTree, ftmR3PageTreeDestroyCallback, NULL);
|
---|
187 | pVM->ftm.s.standby.pPhysPageTree = NULL;
|
---|
188 | }
|
---|
189 |
|
---|
190 | pVM->ftm.s.pszAddress = NULL;
|
---|
191 | pVM->ftm.s.pszPassword = NULL;
|
---|
192 |
|
---|
193 | PDMR3CritSectDelete(&pVM->ftm.s.CritSect);
|
---|
194 | return VINF_SUCCESS;
|
---|
195 | }
|
---|
196 |
|
---|
197 |
|
---|
198 | static int ftmR3TcpWriteACK(PVM pVM)
|
---|
199 | {
|
---|
200 | int rc = RTTcpWrite(pVM->ftm.s.hSocket, RT_STR_TUPLE("ACK\n"));
|
---|
201 | if (RT_FAILURE(rc))
|
---|
202 | {
|
---|
203 | LogRel(("FTSync: RTTcpWrite(,ACK,) -> %Rrc\n", rc));
|
---|
204 | }
|
---|
205 | return rc;
|
---|
206 | }
|
---|
207 |
|
---|
208 |
|
---|
209 | static int ftmR3TcpWriteNACK(PVM pVM, int32_t rc2, const char *pszMsgText = NULL)
|
---|
210 | {
|
---|
211 | char szMsg[256];
|
---|
212 | size_t cch;
|
---|
213 | if (pszMsgText && *pszMsgText)
|
---|
214 | {
|
---|
215 | cch = RTStrPrintf(szMsg, sizeof(szMsg), "NACK=%d;%s\n", rc2, pszMsgText);
|
---|
216 | for (size_t off = 6; off + 1 < cch; off++)
|
---|
217 | if (szMsg[off] == '\n')
|
---|
218 | szMsg[off] = '\r';
|
---|
219 | }
|
---|
220 | else
|
---|
221 | cch = RTStrPrintf(szMsg, sizeof(szMsg), "NACK=%d\n", rc2);
|
---|
222 | int rc = RTTcpWrite(pVM->ftm.s.hSocket, szMsg, cch);
|
---|
223 | if (RT_FAILURE(rc))
|
---|
224 | LogRel(("FTSync: RTTcpWrite(,%s,%zu) -> %Rrc\n", szMsg, cch, rc));
|
---|
225 | return rc;
|
---|
226 | }
|
---|
227 |
|
---|
228 | /**
|
---|
229 | * Reads a string from the socket.
|
---|
230 | *
|
---|
231 | * @returns VBox status code.
|
---|
232 | *
|
---|
233 | * @param pState The teleporter state structure.
|
---|
234 | * @param pszBuf The output buffer.
|
---|
235 | * @param cchBuf The size of the output buffer.
|
---|
236 | *
|
---|
237 | */
|
---|
238 | static int ftmR3TcpReadLine(PVM pVM, char *pszBuf, size_t cchBuf)
|
---|
239 | {
|
---|
240 | char *pszStart = pszBuf;
|
---|
241 | RTSOCKET Sock = pVM->ftm.s.hSocket;
|
---|
242 |
|
---|
243 | AssertReturn(cchBuf > 1, VERR_INTERNAL_ERROR);
|
---|
244 | *pszBuf = '\0';
|
---|
245 |
|
---|
246 | /* dead simple approach. */
|
---|
247 | for (;;)
|
---|
248 | {
|
---|
249 | char ch;
|
---|
250 | int rc = RTTcpRead(Sock, &ch, sizeof(ch), NULL);
|
---|
251 | if (RT_FAILURE(rc))
|
---|
252 | {
|
---|
253 | LogRel(("FTSync: RTTcpRead -> %Rrc while reading string ('%s')\n", rc, pszStart));
|
---|
254 | return rc;
|
---|
255 | }
|
---|
256 | if ( ch == '\n'
|
---|
257 | || ch == '\0')
|
---|
258 | return VINF_SUCCESS;
|
---|
259 | if (cchBuf <= 1)
|
---|
260 | {
|
---|
261 | LogRel(("FTSync: String buffer overflow: '%s'\n", pszStart));
|
---|
262 | return VERR_BUFFER_OVERFLOW;
|
---|
263 | }
|
---|
264 | *pszBuf++ = ch;
|
---|
265 | *pszBuf = '\0';
|
---|
266 | cchBuf--;
|
---|
267 | }
|
---|
268 | }
|
---|
269 |
|
---|
270 | /**
|
---|
271 | * Reads an ACK or NACK.
|
---|
272 | *
|
---|
273 | * @returns VBox status code.
|
---|
274 | * @param pVM Pointer to the VM.
|
---|
275 | * @param pszWhich Which ACK is this this?
|
---|
276 | * @param pszNAckMsg Optional NACK message.
|
---|
277 | */
|
---|
278 | static int ftmR3TcpReadACK(PVM pVM, const char *pszWhich, const char *pszNAckMsg = NULL)
|
---|
279 | {
|
---|
280 | char szMsg[256];
|
---|
281 | int rc = ftmR3TcpReadLine(pVM, szMsg, sizeof(szMsg));
|
---|
282 | if (RT_FAILURE(rc))
|
---|
283 | return rc;
|
---|
284 |
|
---|
285 | if (!strcmp(szMsg, "ACK"))
|
---|
286 | return VINF_SUCCESS;
|
---|
287 |
|
---|
288 | if (!strncmp(szMsg, RT_STR_TUPLE("NACK=")))
|
---|
289 | {
|
---|
290 | char *pszMsgText = strchr(szMsg, ';');
|
---|
291 | if (pszMsgText)
|
---|
292 | *pszMsgText++ = '\0';
|
---|
293 |
|
---|
294 | int32_t vrc2;
|
---|
295 | rc = RTStrToInt32Full(&szMsg[sizeof("NACK=") - 1], 10, &vrc2);
|
---|
296 | if (rc == VINF_SUCCESS)
|
---|
297 | {
|
---|
298 | /*
|
---|
299 | * Well formed NACK, transform it into an error.
|
---|
300 | */
|
---|
301 | if (pszNAckMsg)
|
---|
302 | {
|
---|
303 | LogRel(("FTSync: %s: NACK=%Rrc (%d)\n", pszWhich, vrc2, vrc2));
|
---|
304 | return VERR_INTERNAL_ERROR;
|
---|
305 | }
|
---|
306 |
|
---|
307 | if (pszMsgText)
|
---|
308 | {
|
---|
309 | pszMsgText = RTStrStrip(pszMsgText);
|
---|
310 | for (size_t off = 0; pszMsgText[off]; off++)
|
---|
311 | if (pszMsgText[off] == '\r')
|
---|
312 | pszMsgText[off] = '\n';
|
---|
313 |
|
---|
314 | LogRel(("FTSync: %s: NACK=%Rrc (%d) - '%s'\n", pszWhich, vrc2, vrc2, pszMsgText));
|
---|
315 | }
|
---|
316 | return VERR_INTERNAL_ERROR_2;
|
---|
317 | }
|
---|
318 |
|
---|
319 | if (pszMsgText)
|
---|
320 | pszMsgText[-1] = ';';
|
---|
321 | }
|
---|
322 | return VERR_INTERNAL_ERROR_3;
|
---|
323 | }
|
---|
324 |
|
---|
325 | /**
|
---|
326 | * Submitts a command to the destination and waits for the ACK.
|
---|
327 | *
|
---|
328 | * @returns VBox status code.
|
---|
329 | *
|
---|
330 | * @param pVM Pointer to the VM.
|
---|
331 | * @param pszCommand The command.
|
---|
332 | * @param fWaitForAck Whether to wait for the ACK.
|
---|
333 | */
|
---|
334 | static int ftmR3TcpSubmitCommand(PVM pVM, const char *pszCommand, bool fWaitForAck = true)
|
---|
335 | {
|
---|
336 | int rc = RTTcpSgWriteL(pVM->ftm.s.hSocket, 2, pszCommand, strlen(pszCommand), RT_STR_TUPLE("\n"));
|
---|
337 | if (RT_FAILURE(rc))
|
---|
338 | return rc;
|
---|
339 | if (!fWaitForAck)
|
---|
340 | return VINF_SUCCESS;
|
---|
341 | return ftmR3TcpReadACK(pVM, pszCommand);
|
---|
342 | }
|
---|
343 |
|
---|
344 | /**
|
---|
345 | * @copydoc SSMSTRMOPS::pfnWrite
|
---|
346 | */
|
---|
347 | static DECLCALLBACK(int) ftmR3TcpOpWrite(void *pvUser, uint64_t offStream, const void *pvBuf, size_t cbToWrite)
|
---|
348 | {
|
---|
349 | PVM pVM = (PVM)pvUser;
|
---|
350 | NOREF(offStream);
|
---|
351 |
|
---|
352 | AssertReturn(cbToWrite > 0, VINF_SUCCESS);
|
---|
353 | AssertReturn(cbToWrite < UINT32_MAX, VERR_OUT_OF_RANGE);
|
---|
354 | AssertReturn(pVM->fFaultTolerantMaster, VERR_INVALID_HANDLE);
|
---|
355 |
|
---|
356 | STAM_COUNTER_INC(&pVM->ftm.s.StatSentStateWrite);
|
---|
357 | for (;;)
|
---|
358 | {
|
---|
359 | FTMTCPHDR Hdr;
|
---|
360 | Hdr.u32Magic = FTMTCPHDR_MAGIC;
|
---|
361 | Hdr.cb = RT_MIN((uint32_t)cbToWrite, FTMTCPHDR_MAX_SIZE);
|
---|
362 | int rc = RTTcpSgWriteL(pVM->ftm.s.hSocket, 2, &Hdr, sizeof(Hdr), pvBuf, (size_t)Hdr.cb);
|
---|
363 | if (RT_FAILURE(rc))
|
---|
364 | {
|
---|
365 | LogRel(("FTSync/TCP: Write error: %Rrc (cb=%#x)\n", rc, Hdr.cb));
|
---|
366 | return rc;
|
---|
367 | }
|
---|
368 | pVM->ftm.s.StatSentState.c += Hdr.cb + sizeof(Hdr);
|
---|
369 | pVM->ftm.s.syncstate.uOffStream += Hdr.cb;
|
---|
370 | if (Hdr.cb == cbToWrite)
|
---|
371 | return VINF_SUCCESS;
|
---|
372 |
|
---|
373 | /* advance */
|
---|
374 | cbToWrite -= Hdr.cb;
|
---|
375 | pvBuf = (uint8_t const *)pvBuf + Hdr.cb;
|
---|
376 | }
|
---|
377 | }
|
---|
378 |
|
---|
379 |
|
---|
380 | /**
|
---|
381 | * Selects and poll for close condition.
|
---|
382 | *
|
---|
383 | * We can use a relatively high poll timeout here since it's only used to get
|
---|
384 | * us out of error paths. In the normal cause of events, we'll get a
|
---|
385 | * end-of-stream header.
|
---|
386 | *
|
---|
387 | * @returns VBox status code.
|
---|
388 | *
|
---|
389 | * @param pState The teleporter state data.
|
---|
390 | */
|
---|
391 | static int ftmR3TcpReadSelect(PVM pVM)
|
---|
392 | {
|
---|
393 | int rc;
|
---|
394 | do
|
---|
395 | {
|
---|
396 | rc = RTTcpSelectOne(pVM->ftm.s.hSocket, 1000);
|
---|
397 | if (RT_FAILURE(rc) && rc != VERR_TIMEOUT)
|
---|
398 | {
|
---|
399 | pVM->ftm.s.syncstate.fIOError = true;
|
---|
400 | LogRel(("FTSync/TCP: Header select error: %Rrc\n", rc));
|
---|
401 | break;
|
---|
402 | }
|
---|
403 | if (pVM->ftm.s.syncstate.fStopReading)
|
---|
404 | {
|
---|
405 | rc = VERR_EOF;
|
---|
406 | break;
|
---|
407 | }
|
---|
408 | } while (rc == VERR_TIMEOUT);
|
---|
409 | return rc;
|
---|
410 | }
|
---|
411 |
|
---|
412 |
|
---|
413 | /**
|
---|
414 | * @copydoc SSMSTRMOPS::pfnRead
|
---|
415 | */
|
---|
416 | static DECLCALLBACK(int) ftmR3TcpOpRead(void *pvUser, uint64_t offStream, void *pvBuf, size_t cbToRead, size_t *pcbRead)
|
---|
417 | {
|
---|
418 | PVM pVM = (PVM)pvUser;
|
---|
419 | AssertReturn(!pVM->fFaultTolerantMaster, VERR_INVALID_HANDLE);
|
---|
420 | NOREF(offStream);
|
---|
421 |
|
---|
422 | for (;;)
|
---|
423 | {
|
---|
424 | int rc;
|
---|
425 |
|
---|
426 | /*
|
---|
427 | * Check for various conditions and may have been signalled.
|
---|
428 | */
|
---|
429 | if (pVM->ftm.s.syncstate.fEndOfStream)
|
---|
430 | return VERR_EOF;
|
---|
431 | if (pVM->ftm.s.syncstate.fStopReading)
|
---|
432 | return VERR_EOF;
|
---|
433 | if (pVM->ftm.s.syncstate.fIOError)
|
---|
434 | return VERR_IO_GEN_FAILURE;
|
---|
435 |
|
---|
436 | /*
|
---|
437 | * If there is no more data in the current block, read the next
|
---|
438 | * block header.
|
---|
439 | */
|
---|
440 | if (!pVM->ftm.s.syncstate.cbReadBlock)
|
---|
441 | {
|
---|
442 | rc = ftmR3TcpReadSelect(pVM);
|
---|
443 | if (RT_FAILURE(rc))
|
---|
444 | return rc;
|
---|
445 | FTMTCPHDR Hdr;
|
---|
446 | rc = RTTcpRead(pVM->ftm.s.hSocket, &Hdr, sizeof(Hdr), NULL);
|
---|
447 | if (RT_FAILURE(rc))
|
---|
448 | {
|
---|
449 | pVM->ftm.s.syncstate.fIOError = true;
|
---|
450 | LogRel(("FTSync/TCP: Header read error: %Rrc\n", rc));
|
---|
451 | return rc;
|
---|
452 | }
|
---|
453 | pVM->ftm.s.StatReceivedState.c += sizeof(Hdr);
|
---|
454 |
|
---|
455 | if (RT_UNLIKELY( Hdr.u32Magic != FTMTCPHDR_MAGIC
|
---|
456 | || Hdr.cb > FTMTCPHDR_MAX_SIZE
|
---|
457 | || Hdr.cb == 0))
|
---|
458 | {
|
---|
459 | if ( Hdr.u32Magic == FTMTCPHDR_MAGIC
|
---|
460 | && ( Hdr.cb == 0
|
---|
461 | || Hdr.cb == UINT32_MAX)
|
---|
462 | )
|
---|
463 | {
|
---|
464 | pVM->ftm.s.syncstate.fEndOfStream = true;
|
---|
465 | pVM->ftm.s.syncstate.cbReadBlock = 0;
|
---|
466 | return Hdr.cb ? VERR_SSM_CANCELLED : VERR_EOF;
|
---|
467 | }
|
---|
468 | pVM->ftm.s.syncstate.fIOError = true;
|
---|
469 | LogRel(("FTSync/TCP: Invalid block: u32Magic=%#x cb=%#x\n", Hdr.u32Magic, Hdr.cb));
|
---|
470 | return VERR_IO_GEN_FAILURE;
|
---|
471 | }
|
---|
472 |
|
---|
473 | pVM->ftm.s.syncstate.cbReadBlock = Hdr.cb;
|
---|
474 | if (pVM->ftm.s.syncstate.fStopReading)
|
---|
475 | return VERR_EOF;
|
---|
476 | }
|
---|
477 |
|
---|
478 | /*
|
---|
479 | * Read more data.
|
---|
480 | */
|
---|
481 | rc = ftmR3TcpReadSelect(pVM);
|
---|
482 | if (RT_FAILURE(rc))
|
---|
483 | return rc;
|
---|
484 |
|
---|
485 | uint32_t cb = (uint32_t)RT_MIN(pVM->ftm.s.syncstate.cbReadBlock, cbToRead);
|
---|
486 | rc = RTTcpRead(pVM->ftm.s.hSocket, pvBuf, cb, pcbRead);
|
---|
487 | if (RT_FAILURE(rc))
|
---|
488 | {
|
---|
489 | pVM->ftm.s.syncstate.fIOError = true;
|
---|
490 | LogRel(("FTSync/TCP: Data read error: %Rrc (cb=%#x)\n", rc, cb));
|
---|
491 | return rc;
|
---|
492 | }
|
---|
493 | if (pcbRead)
|
---|
494 | {
|
---|
495 | cb = (uint32_t)*pcbRead;
|
---|
496 | pVM->ftm.s.StatReceivedState.c += cb;
|
---|
497 | pVM->ftm.s.syncstate.uOffStream += cb;
|
---|
498 | pVM->ftm.s.syncstate.cbReadBlock -= cb;
|
---|
499 | return VINF_SUCCESS;
|
---|
500 | }
|
---|
501 | pVM->ftm.s.StatReceivedState.c += cb;
|
---|
502 | pVM->ftm.s.syncstate.uOffStream += cb;
|
---|
503 | pVM->ftm.s.syncstate.cbReadBlock -= cb;
|
---|
504 | if (cbToRead == cb)
|
---|
505 | return VINF_SUCCESS;
|
---|
506 |
|
---|
507 | /* Advance to the next block. */
|
---|
508 | cbToRead -= cb;
|
---|
509 | pvBuf = (uint8_t *)pvBuf + cb;
|
---|
510 | }
|
---|
511 | }
|
---|
512 |
|
---|
513 |
|
---|
514 | /**
|
---|
515 | * @copydoc SSMSTRMOPS::pfnSeek
|
---|
516 | */
|
---|
517 | static DECLCALLBACK(int) ftmR3TcpOpSeek(void *pvUser, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
|
---|
518 | {
|
---|
519 | NOREF(pvUser); NOREF(offSeek); NOREF(uMethod); NOREF(poffActual);
|
---|
520 | return VERR_NOT_SUPPORTED;
|
---|
521 | }
|
---|
522 |
|
---|
523 |
|
---|
524 | /**
|
---|
525 | * @copydoc SSMSTRMOPS::pfnTell
|
---|
526 | */
|
---|
527 | static DECLCALLBACK(uint64_t) ftmR3TcpOpTell(void *pvUser)
|
---|
528 | {
|
---|
529 | PVM pVM = (PVM)pvUser;
|
---|
530 | return pVM->ftm.s.syncstate.uOffStream;
|
---|
531 | }
|
---|
532 |
|
---|
533 |
|
---|
534 | /**
|
---|
535 | * @copydoc SSMSTRMOPS::pfnSize
|
---|
536 | */
|
---|
537 | static DECLCALLBACK(int) ftmR3TcpOpSize(void *pvUser, uint64_t *pcb)
|
---|
538 | {
|
---|
539 | NOREF(pvUser); NOREF(pcb);
|
---|
540 | return VERR_NOT_SUPPORTED;
|
---|
541 | }
|
---|
542 |
|
---|
543 |
|
---|
544 | /**
|
---|
545 | * @copydoc SSMSTRMOPS::pfnIsOk
|
---|
546 | */
|
---|
547 | static DECLCALLBACK(int) ftmR3TcpOpIsOk(void *pvUser)
|
---|
548 | {
|
---|
549 | PVM pVM = (PVM)pvUser;
|
---|
550 |
|
---|
551 | if (pVM->fFaultTolerantMaster)
|
---|
552 | {
|
---|
553 | /* Poll for incoming NACKs and errors from the other side */
|
---|
554 | int rc = RTTcpSelectOne(pVM->ftm.s.hSocket, 0);
|
---|
555 | if (rc != VERR_TIMEOUT)
|
---|
556 | {
|
---|
557 | if (RT_SUCCESS(rc))
|
---|
558 | {
|
---|
559 | LogRel(("FTSync/TCP: Incoming data detect by IsOk, assuming it is a cancellation NACK.\n"));
|
---|
560 | rc = VERR_SSM_CANCELLED;
|
---|
561 | }
|
---|
562 | else
|
---|
563 | LogRel(("FTSync/TCP: RTTcpSelectOne -> %Rrc (IsOk).\n", rc));
|
---|
564 | return rc;
|
---|
565 | }
|
---|
566 | }
|
---|
567 |
|
---|
568 | return VINF_SUCCESS;
|
---|
569 | }
|
---|
570 |
|
---|
571 |
|
---|
572 | /**
|
---|
573 | * @copydoc SSMSTRMOPS::pfnClose
|
---|
574 | */
|
---|
575 | static DECLCALLBACK(int) ftmR3TcpOpClose(void *pvUser, bool fCanceled)
|
---|
576 | {
|
---|
577 | PVM pVM = (PVM)pvUser;
|
---|
578 |
|
---|
579 | if (pVM->fFaultTolerantMaster)
|
---|
580 | {
|
---|
581 | FTMTCPHDR EofHdr;
|
---|
582 | EofHdr.u32Magic = FTMTCPHDR_MAGIC;
|
---|
583 | EofHdr.cb = fCanceled ? UINT32_MAX : 0;
|
---|
584 | int rc = RTTcpWrite(pVM->ftm.s.hSocket, &EofHdr, sizeof(EofHdr));
|
---|
585 | if (RT_FAILURE(rc))
|
---|
586 | {
|
---|
587 | LogRel(("FTSync/TCP: EOF Header write error: %Rrc\n", rc));
|
---|
588 | return rc;
|
---|
589 | }
|
---|
590 | }
|
---|
591 | else
|
---|
592 | {
|
---|
593 | ASMAtomicWriteBool(&pVM->ftm.s.syncstate.fStopReading, true);
|
---|
594 | }
|
---|
595 |
|
---|
596 | return VINF_SUCCESS;
|
---|
597 | }
|
---|
598 |
|
---|
599 |
|
---|
600 | /**
|
---|
601 | * Method table for a TCP based stream.
|
---|
602 | */
|
---|
603 | static SSMSTRMOPS const g_ftmR3TcpOps =
|
---|
604 | {
|
---|
605 | SSMSTRMOPS_VERSION,
|
---|
606 | ftmR3TcpOpWrite,
|
---|
607 | ftmR3TcpOpRead,
|
---|
608 | ftmR3TcpOpSeek,
|
---|
609 | ftmR3TcpOpTell,
|
---|
610 | ftmR3TcpOpSize,
|
---|
611 | ftmR3TcpOpIsOk,
|
---|
612 | ftmR3TcpOpClose,
|
---|
613 | SSMSTRMOPS_VERSION
|
---|
614 | };
|
---|
615 |
|
---|
616 |
|
---|
617 | /**
|
---|
618 | * VMR3ReqCallWait callback
|
---|
619 | *
|
---|
620 | * @param pVM Pointer to the VM.
|
---|
621 | *
|
---|
622 | */
|
---|
623 | static DECLCALLBACK(void) ftmR3WriteProtectMemory(PVM pVM)
|
---|
624 | {
|
---|
625 | int rc = PGMR3PhysWriteProtectRAM(pVM);
|
---|
626 | AssertRC(rc);
|
---|
627 | }
|
---|
628 |
|
---|
629 |
|
---|
630 | /**
|
---|
631 | * Sync the VM state
|
---|
632 | *
|
---|
633 | * @returns VBox status code.
|
---|
634 | * @param pVM Pointer to the VM.
|
---|
635 | */
|
---|
636 | static int ftmR3PerformFullSync(PVM pVM)
|
---|
637 | {
|
---|
638 | bool fSuspended = false;
|
---|
639 |
|
---|
640 | int rc = VMR3Suspend(pVM->pUVM);
|
---|
641 | AssertRCReturn(rc, rc);
|
---|
642 |
|
---|
643 | STAM_REL_COUNTER_INC(&pVM->ftm.s.StatFullSync);
|
---|
644 |
|
---|
645 | RTSocketRetain(pVM->ftm.s.hSocket); /* For concurrent access by I/O thread and EMT. */
|
---|
646 |
|
---|
647 | /* Reset the sync state. */
|
---|
648 | pVM->ftm.s.syncstate.uOffStream = 0;
|
---|
649 | pVM->ftm.s.syncstate.cbReadBlock = 0;
|
---|
650 | pVM->ftm.s.syncstate.fStopReading = false;
|
---|
651 | pVM->ftm.s.syncstate.fIOError = false;
|
---|
652 | pVM->ftm.s.syncstate.fEndOfStream = false;
|
---|
653 |
|
---|
654 | rc = ftmR3TcpSubmitCommand(pVM, "full-sync");
|
---|
655 | AssertRC(rc);
|
---|
656 |
|
---|
657 | pVM->ftm.s.fDeltaLoadSaveActive = false;
|
---|
658 | rc = VMR3SaveFT(pVM->pUVM, &g_ftmR3TcpOps, pVM, &fSuspended, false /* fSkipStateChanges */);
|
---|
659 | AssertRC(rc);
|
---|
660 |
|
---|
661 | rc = ftmR3TcpReadACK(pVM, "full-sync-complete");
|
---|
662 | AssertRC(rc);
|
---|
663 |
|
---|
664 | RTSocketRelease(pVM->ftm.s.hSocket);
|
---|
665 |
|
---|
666 | /* Write protect all memory. */
|
---|
667 | rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)ftmR3WriteProtectMemory, 1, pVM);
|
---|
668 | AssertRCReturn(rc, rc);
|
---|
669 |
|
---|
670 | rc = VMR3Resume(pVM->pUVM);
|
---|
671 | AssertRC(rc);
|
---|
672 |
|
---|
673 | return rc;
|
---|
674 | }
|
---|
675 |
|
---|
676 |
|
---|
677 | /**
|
---|
678 | * PGMR3PhysEnumDirtyFTPages callback for syncing dirty physical pages
|
---|
679 | *
|
---|
680 | * @param pVM Pointer to the VM.
|
---|
681 | * @param GCPhys GC physical address
|
---|
682 | * @param pRange HC virtual address of the page(s)
|
---|
683 | * @param cbRange Size of the dirty range in bytes.
|
---|
684 | * @param pvUser User argument
|
---|
685 | */
|
---|
686 | static DECLCALLBACK(int) ftmR3SyncDirtyPage(PVM pVM, RTGCPHYS GCPhys, uint8_t *pRange, unsigned cbRange, void *pvUser)
|
---|
687 | {
|
---|
688 | NOREF(pvUser);
|
---|
689 | FTMTCPHDRMEM Hdr;
|
---|
690 | Hdr.u32Magic = FTMTCPHDR_MAGIC;
|
---|
691 | Hdr.GCPhys = GCPhys;
|
---|
692 | Hdr.cbPageRange = cbRange;
|
---|
693 | Hdr.cb = cbRange;
|
---|
694 | /** @todo compress page(s). */
|
---|
695 | int rc = RTTcpSgWriteL(pVM->ftm.s.hSocket, 2, &Hdr, sizeof(Hdr), pRange, (size_t)Hdr.cb);
|
---|
696 | if (RT_FAILURE(rc))
|
---|
697 | {
|
---|
698 | LogRel(("FTSync/TCP: Write error (ftmR3SyncDirtyPage): %Rrc (cb=%#x)\n", rc, Hdr.cb));
|
---|
699 | return rc;
|
---|
700 | }
|
---|
701 | pVM->ftm.s.StatSentMem.c += Hdr.cb + sizeof(Hdr);
|
---|
702 |
|
---|
703 | #ifdef VBOX_WITH_STATISTICS
|
---|
704 | switch (PGMPhysGetPageType(pVM, GCPhys))
|
---|
705 | {
|
---|
706 | case PGMPAGETYPE_RAM:
|
---|
707 | pVM->ftm.s.StatSentMemRAM.c += Hdr.cb + sizeof(Hdr);
|
---|
708 | break;
|
---|
709 |
|
---|
710 | case PGMPAGETYPE_MMIO2:
|
---|
711 | pVM->ftm.s.StatSentMemMMIO2.c += Hdr.cb + sizeof(Hdr);
|
---|
712 | break;
|
---|
713 |
|
---|
714 | case PGMPAGETYPE_ROM_SHADOW:
|
---|
715 | pVM->ftm.s.StatSentMemShwROM.c += Hdr.cb + sizeof(Hdr);
|
---|
716 | break;
|
---|
717 |
|
---|
718 | case PGMPAGETYPE_MMIO2_ALIAS_MMIO:
|
---|
719 | AssertFailed();
|
---|
720 | break;
|
---|
721 |
|
---|
722 | default:
|
---|
723 | AssertFailed();
|
---|
724 | break;
|
---|
725 | }
|
---|
726 | #endif
|
---|
727 |
|
---|
728 | return (pVM->ftm.s.fCheckpointingActive) ? VERR_INTERRUPTED : VINF_SUCCESS;
|
---|
729 | }
|
---|
730 |
|
---|
731 | /**
|
---|
732 | * Thread function which starts syncing process for this master VM
|
---|
733 | *
|
---|
734 | * @param hThread The thread handle.
|
---|
735 | * @param pvUser Pointer to the VM.
|
---|
736 | * @return VINF_SUCCESS (ignored).
|
---|
737 | *
|
---|
738 | */
|
---|
739 | static DECLCALLBACK(int) ftmR3MasterThread(RTTHREAD hThread, void *pvUser)
|
---|
740 | {
|
---|
741 | int rc = VINF_SUCCESS;
|
---|
742 | PVM pVM = (PVM)pvUser;
|
---|
743 | NOREF(hThread);
|
---|
744 |
|
---|
745 | for (;;)
|
---|
746 | {
|
---|
747 | /*
|
---|
748 | * Try connect to the standby machine.
|
---|
749 | */
|
---|
750 | Log(("ftmR3MasterThread: client connect to %s %d\n", pVM->ftm.s.pszAddress, pVM->ftm.s.uPort));
|
---|
751 | rc = RTTcpClientConnect(pVM->ftm.s.pszAddress, pVM->ftm.s.uPort, &pVM->ftm.s.hSocket);
|
---|
752 | if (RT_SUCCESS(rc))
|
---|
753 | {
|
---|
754 | Log(("ftmR3MasterThread: CONNECTED\n"));
|
---|
755 |
|
---|
756 | /* Disable Nagle. */
|
---|
757 | rc = RTTcpSetSendCoalescing(pVM->ftm.s.hSocket, false /*fEnable*/);
|
---|
758 | AssertRC(rc);
|
---|
759 |
|
---|
760 | /* Read and check the welcome message. */
|
---|
761 | char szLine[RT_MAX(128, sizeof(g_szWelcome))];
|
---|
762 | RT_ZERO(szLine);
|
---|
763 | rc = RTTcpRead(pVM->ftm.s.hSocket, szLine, sizeof(g_szWelcome) - 1, NULL);
|
---|
764 | if ( RT_SUCCESS(rc)
|
---|
765 | && !strcmp(szLine, g_szWelcome))
|
---|
766 | {
|
---|
767 | /* password */
|
---|
768 | if (pVM->ftm.s.pszPassword)
|
---|
769 | rc = RTTcpWrite(pVM->ftm.s.hSocket, pVM->ftm.s.pszPassword, strlen(pVM->ftm.s.pszPassword));
|
---|
770 |
|
---|
771 | if (RT_SUCCESS(rc))
|
---|
772 | {
|
---|
773 | /* ACK */
|
---|
774 | rc = ftmR3TcpReadACK(pVM, "password", "Invalid password");
|
---|
775 | if (RT_SUCCESS(rc))
|
---|
776 | {
|
---|
777 | /** todo: verify VM config. */
|
---|
778 | break;
|
---|
779 | }
|
---|
780 | }
|
---|
781 | }
|
---|
782 | /* Failed, so don't bother anymore. */
|
---|
783 | return VINF_SUCCESS;
|
---|
784 | }
|
---|
785 | rc = RTSemEventWait(pVM->ftm.s.hShutdownEvent, 1000 /* 1 second */);
|
---|
786 | if (rc != VERR_TIMEOUT)
|
---|
787 | return VINF_SUCCESS; /* told to quit */
|
---|
788 | }
|
---|
789 |
|
---|
790 | /* Successfully initialized the connection to the standby node.
|
---|
791 | * Start the sync process.
|
---|
792 | */
|
---|
793 |
|
---|
794 | /* First sync all memory and write protect everything so
|
---|
795 | * we can send changed pages later on.
|
---|
796 | */
|
---|
797 |
|
---|
798 | rc = ftmR3PerformFullSync(pVM);
|
---|
799 |
|
---|
800 | for (;;)
|
---|
801 | {
|
---|
802 | rc = RTSemEventWait(pVM->ftm.s.hShutdownEvent, pVM->ftm.s.uInterval);
|
---|
803 | if (rc != VERR_TIMEOUT)
|
---|
804 | break; /* told to quit */
|
---|
805 |
|
---|
806 | if (!pVM->ftm.s.fCheckpointingActive)
|
---|
807 | {
|
---|
808 | rc = PDMCritSectEnter(&pVM->ftm.s.CritSect, VERR_SEM_BUSY);
|
---|
809 | AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
|
---|
810 |
|
---|
811 | rc = ftmR3TcpSubmitCommand(pVM, "mem-sync");
|
---|
812 | AssertRC(rc);
|
---|
813 |
|
---|
814 | /* sync the changed memory with the standby node. */
|
---|
815 | /* Write protect all memory. */
|
---|
816 | if (!pVM->ftm.s.fCheckpointingActive)
|
---|
817 | {
|
---|
818 | rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)ftmR3WriteProtectMemory, 1, pVM);
|
---|
819 | AssertRC(rc);
|
---|
820 | }
|
---|
821 |
|
---|
822 | /* Enumerate all dirty pages and send them to the standby VM. */
|
---|
823 | if (!pVM->ftm.s.fCheckpointingActive)
|
---|
824 | {
|
---|
825 | rc = PGMR3PhysEnumDirtyFTPages(pVM, ftmR3SyncDirtyPage, NULL /* pvUser */);
|
---|
826 | Assert(rc == VINF_SUCCESS || rc == VERR_INTERRUPTED);
|
---|
827 | }
|
---|
828 |
|
---|
829 | /* Send last memory header to signal the end. */
|
---|
830 | FTMTCPHDRMEM Hdr;
|
---|
831 | Hdr.u32Magic = FTMTCPHDR_MAGIC;
|
---|
832 | Hdr.GCPhys = 0;
|
---|
833 | Hdr.cbPageRange = 0;
|
---|
834 | Hdr.cb = 0;
|
---|
835 | rc = RTTcpSgWriteL(pVM->ftm.s.hSocket, 1, &Hdr, sizeof(Hdr));
|
---|
836 | if (RT_FAILURE(rc))
|
---|
837 | LogRel(("FTSync/TCP: Write error (ftmR3MasterThread): %Rrc (cb=%#x)\n", rc, Hdr.cb));
|
---|
838 |
|
---|
839 | rc = ftmR3TcpReadACK(pVM, "mem-sync-complete");
|
---|
840 | AssertRC(rc);
|
---|
841 |
|
---|
842 | PDMCritSectLeave(&pVM->ftm.s.CritSect);
|
---|
843 | }
|
---|
844 | }
|
---|
845 | return rc;
|
---|
846 | }
|
---|
847 |
|
---|
848 | /**
|
---|
849 | * Syncs memory from the master VM
|
---|
850 | *
|
---|
851 | * @returns VBox status code.
|
---|
852 | * @param pVM Pointer to the VM.
|
---|
853 | */
|
---|
854 | static int ftmR3SyncMem(PVM pVM)
|
---|
855 | {
|
---|
856 | while (true)
|
---|
857 | {
|
---|
858 | FTMTCPHDRMEM Hdr;
|
---|
859 | RTGCPHYS GCPhys;
|
---|
860 |
|
---|
861 | /* Read memory header. */
|
---|
862 | int rc = RTTcpRead(pVM->ftm.s.hSocket, &Hdr, sizeof(Hdr), NULL);
|
---|
863 | if (RT_FAILURE(rc))
|
---|
864 | {
|
---|
865 | Log(("RTTcpRead failed with %Rrc\n", rc));
|
---|
866 | break;
|
---|
867 | }
|
---|
868 | pVM->ftm.s.StatReceivedMem.c += sizeof(Hdr);
|
---|
869 |
|
---|
870 | if (Hdr.cb == 0)
|
---|
871 | break; /* end of sync. */
|
---|
872 |
|
---|
873 | Assert(Hdr.cb == Hdr.cbPageRange); /** @todo uncompress */
|
---|
874 | GCPhys = Hdr.GCPhys;
|
---|
875 |
|
---|
876 | /* Must be a multiple of PAGE_SIZE. */
|
---|
877 | Assert((Hdr.cbPageRange & 0xfff) == 0);
|
---|
878 |
|
---|
879 | while (Hdr.cbPageRange)
|
---|
880 | {
|
---|
881 | PFTMPHYSPAGETREENODE pNode = (PFTMPHYSPAGETREENODE)RTAvlGCPhysGet(&pVM->ftm.s.standby.pPhysPageTree, GCPhys);
|
---|
882 | if (!pNode)
|
---|
883 | {
|
---|
884 | /* Allocate memory for the node and page. */
|
---|
885 | pNode = (PFTMPHYSPAGETREENODE)RTMemAllocZ(sizeof(*pNode) + PAGE_SIZE);
|
---|
886 | AssertBreak(pNode);
|
---|
887 |
|
---|
888 | /* Insert the node into the tree. */
|
---|
889 | pNode->Core.Key = GCPhys;
|
---|
890 | pNode->pPage = (void *)(pNode + 1);
|
---|
891 | bool fRet = RTAvlGCPhysInsert(&pVM->ftm.s.standby.pPhysPageTree, &pNode->Core);
|
---|
892 | Assert(fRet); NOREF(fRet);
|
---|
893 | }
|
---|
894 |
|
---|
895 | /* Fetch the page. */
|
---|
896 | rc = RTTcpRead(pVM->ftm.s.hSocket, pNode->pPage, PAGE_SIZE, NULL);
|
---|
897 | if (RT_FAILURE(rc))
|
---|
898 | {
|
---|
899 | Log(("RTTcpRead page data (%d bytes) failed with %Rrc\n", Hdr.cb, rc));
|
---|
900 | break;
|
---|
901 | }
|
---|
902 | pVM->ftm.s.StatReceivedMem.c += PAGE_SIZE;
|
---|
903 | Hdr.cbPageRange -= PAGE_SIZE;
|
---|
904 | GCPhys += PAGE_SIZE;
|
---|
905 | }
|
---|
906 | }
|
---|
907 | return VINF_SUCCESS;
|
---|
908 | }
|
---|
909 |
|
---|
910 |
|
---|
911 | /**
|
---|
912 | * Callback handler for RTAvlGCPhysDestroy
|
---|
913 | *
|
---|
914 | * @returns 0 to continue, otherwise stop
|
---|
915 | * @param pBaseNode Node to destroy
|
---|
916 | * @param pvUser Pointer to the VM.
|
---|
917 | */
|
---|
918 | static DECLCALLBACK(int) ftmR3PageTreeDestroyCallback(PAVLGCPHYSNODECORE pBaseNode, void *pvUser)
|
---|
919 | {
|
---|
920 | PVM pVM = (PVM)pvUser;
|
---|
921 | PFTMPHYSPAGETREENODE pNode = (PFTMPHYSPAGETREENODE)pBaseNode;
|
---|
922 |
|
---|
923 | if (pVM) /* NULL when the VM is destroyed. */
|
---|
924 | {
|
---|
925 | /* Update the guest memory of the standby VM. */
|
---|
926 | int rc = PGMR3PhysWriteExternal(pVM, pNode->Core.Key, pNode->pPage, PAGE_SIZE, "FTMemSync");
|
---|
927 | AssertRC(rc);
|
---|
928 | }
|
---|
929 | RTMemFree(pNode);
|
---|
930 | return 0;
|
---|
931 | }
|
---|
932 |
|
---|
933 | /**
|
---|
934 | * Thread function which monitors the health of the master VM
|
---|
935 | *
|
---|
936 | * @param hThread The thread handle.
|
---|
937 | * @param pvUser Pointer to the VM.
|
---|
938 | * @return VINF_SUCCESS (ignored).
|
---|
939 | *
|
---|
940 | */
|
---|
941 | static DECLCALLBACK(int) ftmR3StandbyThread(RTTHREAD hThread, void *pvUser)
|
---|
942 | {
|
---|
943 | PVM pVM = (PVM)pvUser;
|
---|
944 | NOREF(hThread);
|
---|
945 |
|
---|
946 | for (;;)
|
---|
947 | {
|
---|
948 | uint64_t u64TimeNow;
|
---|
949 |
|
---|
950 | int rc = RTSemEventWait(pVM->ftm.s.hShutdownEvent, pVM->ftm.s.uInterval);
|
---|
951 | if (rc != VERR_TIMEOUT)
|
---|
952 | break; /* told to quit */
|
---|
953 |
|
---|
954 | if (pVM->ftm.s.standby.u64LastHeartbeat)
|
---|
955 | {
|
---|
956 | u64TimeNow = RTTimeMilliTS();
|
---|
957 |
|
---|
958 | if (u64TimeNow > pVM->ftm.s.standby.u64LastHeartbeat + pVM->ftm.s.uInterval * 4)
|
---|
959 | {
|
---|
960 | /* Timeout; prepare to fallover. */
|
---|
961 | LogRel(("FTSync: TIMEOUT (%RX64 vs %RX64 ms): activate standby VM!\n", u64TimeNow, pVM->ftm.s.standby.u64LastHeartbeat + pVM->ftm.s.uInterval * 2));
|
---|
962 |
|
---|
963 | pVM->ftm.s.fActivateStandby = true;
|
---|
964 | /** todo: prevent split-brain. */
|
---|
965 | break;
|
---|
966 | }
|
---|
967 | }
|
---|
968 | }
|
---|
969 |
|
---|
970 | return VINF_SUCCESS;
|
---|
971 | }
|
---|
972 |
|
---|
973 |
|
---|
974 | /**
|
---|
975 | * Listen for incoming traffic destined for the standby VM.
|
---|
976 | *
|
---|
977 | * @copydoc FNRTTCPSERVE
|
---|
978 | *
|
---|
979 | * @returns VINF_SUCCESS or VERR_TCP_SERVER_STOP.
|
---|
980 | */
|
---|
981 | static DECLCALLBACK(int) ftmR3StandbyServeConnection(RTSOCKET Sock, void *pvUser)
|
---|
982 | {
|
---|
983 | PVM pVM = (PVM)pvUser;
|
---|
984 |
|
---|
985 | pVM->ftm.s.hSocket = Sock;
|
---|
986 |
|
---|
987 | /*
|
---|
988 | * Disable Nagle.
|
---|
989 | */
|
---|
990 | int rc = RTTcpSetSendCoalescing(Sock, false /*fEnable*/);
|
---|
991 | AssertRC(rc);
|
---|
992 |
|
---|
993 | /* Send the welcome message to the master node. */
|
---|
994 | rc = RTTcpWrite(Sock, g_szWelcome, sizeof(g_szWelcome) - 1);
|
---|
995 | if (RT_FAILURE(rc))
|
---|
996 | {
|
---|
997 | LogRel(("Teleporter: Failed to write welcome message: %Rrc\n", rc));
|
---|
998 | return VINF_SUCCESS;
|
---|
999 | }
|
---|
1000 |
|
---|
1001 | /*
|
---|
1002 | * Password.
|
---|
1003 | */
|
---|
1004 | const char *pszPassword = pVM->ftm.s.pszPassword;
|
---|
1005 | if (pszPassword)
|
---|
1006 | {
|
---|
1007 | unsigned off = 0;
|
---|
1008 | while (pszPassword[off])
|
---|
1009 | {
|
---|
1010 | char ch;
|
---|
1011 | rc = RTTcpRead(Sock, &ch, sizeof(ch), NULL);
|
---|
1012 | if ( RT_FAILURE(rc)
|
---|
1013 | || pszPassword[off] != ch)
|
---|
1014 | {
|
---|
1015 | if (RT_FAILURE(rc))
|
---|
1016 | LogRel(("FTSync: Password read failure (off=%u): %Rrc\n", off, rc));
|
---|
1017 | else
|
---|
1018 | LogRel(("FTSync: Invalid password (off=%u)\n", off));
|
---|
1019 | ftmR3TcpWriteNACK(pVM, VERR_AUTHENTICATION_FAILURE);
|
---|
1020 | return VINF_SUCCESS;
|
---|
1021 | }
|
---|
1022 | off++;
|
---|
1023 | }
|
---|
1024 | }
|
---|
1025 | rc = ftmR3TcpWriteACK(pVM);
|
---|
1026 | if (RT_FAILURE(rc))
|
---|
1027 | return VINF_SUCCESS;
|
---|
1028 |
|
---|
1029 | /** @todo verify VM config. */
|
---|
1030 |
|
---|
1031 | /*
|
---|
1032 | * Stop the server.
|
---|
1033 | *
|
---|
1034 | * Note! After this point we must return VERR_TCP_SERVER_STOP, while prior
|
---|
1035 | * to it we must not return that value!
|
---|
1036 | */
|
---|
1037 | RTTcpServerShutdown(pVM->ftm.s.standby.hServer);
|
---|
1038 |
|
---|
1039 | /*
|
---|
1040 | * Command processing loop.
|
---|
1041 | */
|
---|
1042 | //bool fDone = false;
|
---|
1043 | for (;;)
|
---|
1044 | {
|
---|
1045 | bool fFullSync = false;
|
---|
1046 | char szCmd[128];
|
---|
1047 |
|
---|
1048 | rc = ftmR3TcpReadLine(pVM, szCmd, sizeof(szCmd));
|
---|
1049 | if (RT_FAILURE(rc))
|
---|
1050 | break;
|
---|
1051 |
|
---|
1052 | pVM->ftm.s.standby.u64LastHeartbeat = RTTimeMilliTS();
|
---|
1053 | if (!strcmp(szCmd, "mem-sync"))
|
---|
1054 | {
|
---|
1055 | rc = ftmR3TcpWriteACK(pVM);
|
---|
1056 | AssertRC(rc);
|
---|
1057 | if (RT_FAILURE(rc))
|
---|
1058 | continue;
|
---|
1059 |
|
---|
1060 | rc = ftmR3SyncMem(pVM);
|
---|
1061 | AssertRC(rc);
|
---|
1062 |
|
---|
1063 | rc = ftmR3TcpWriteACK(pVM);
|
---|
1064 | AssertRC(rc);
|
---|
1065 | }
|
---|
1066 | else
|
---|
1067 | if ( !strcmp(szCmd, "checkpoint")
|
---|
1068 | || !strcmp(szCmd, "full-sync")
|
---|
1069 | || (fFullSync = true)) /* intended assignment */
|
---|
1070 | {
|
---|
1071 | rc = ftmR3TcpWriteACK(pVM);
|
---|
1072 | AssertRC(rc);
|
---|
1073 | if (RT_FAILURE(rc))
|
---|
1074 | continue;
|
---|
1075 |
|
---|
1076 | /* Flush all pending memory updates. */
|
---|
1077 | if (pVM->ftm.s.standby.pPhysPageTree)
|
---|
1078 | {
|
---|
1079 | RTAvlGCPhysDestroy(&pVM->ftm.s.standby.pPhysPageTree, ftmR3PageTreeDestroyCallback, pVM);
|
---|
1080 | pVM->ftm.s.standby.pPhysPageTree = NULL;
|
---|
1081 | }
|
---|
1082 |
|
---|
1083 | RTSocketRetain(pVM->ftm.s.hSocket); /* For concurrent access by I/O thread and EMT. */
|
---|
1084 |
|
---|
1085 | /* Reset the sync state. */
|
---|
1086 | pVM->ftm.s.syncstate.uOffStream = 0;
|
---|
1087 | pVM->ftm.s.syncstate.cbReadBlock = 0;
|
---|
1088 | pVM->ftm.s.syncstate.fStopReading = false;
|
---|
1089 | pVM->ftm.s.syncstate.fIOError = false;
|
---|
1090 | pVM->ftm.s.syncstate.fEndOfStream = false;
|
---|
1091 |
|
---|
1092 | pVM->ftm.s.fDeltaLoadSaveActive = (fFullSync == false);
|
---|
1093 | rc = VMR3LoadFromStreamFT(pVM->pUVM, &g_ftmR3TcpOps, pVM);
|
---|
1094 | pVM->ftm.s.fDeltaLoadSaveActive = false;
|
---|
1095 | RTSocketRelease(pVM->ftm.s.hSocket);
|
---|
1096 | AssertRC(rc);
|
---|
1097 | if (RT_FAILURE(rc))
|
---|
1098 | {
|
---|
1099 | LogRel(("FTSync: VMR3LoadFromStream -> %Rrc\n", rc));
|
---|
1100 | ftmR3TcpWriteNACK(pVM, rc);
|
---|
1101 | continue;
|
---|
1102 | }
|
---|
1103 |
|
---|
1104 | /* The EOS might not have been read, make sure it is. */
|
---|
1105 | pVM->ftm.s.syncstate.fStopReading = false;
|
---|
1106 | size_t cbRead;
|
---|
1107 | rc = ftmR3TcpOpRead(pVM, pVM->ftm.s.syncstate.uOffStream, szCmd, 1, &cbRead);
|
---|
1108 | if (rc != VERR_EOF)
|
---|
1109 | {
|
---|
1110 | LogRel(("FTSync: Draining teleporterTcpOpRead -> %Rrc\n", rc));
|
---|
1111 | ftmR3TcpWriteNACK(pVM, rc);
|
---|
1112 | continue;
|
---|
1113 | }
|
---|
1114 |
|
---|
1115 | rc = ftmR3TcpWriteACK(pVM);
|
---|
1116 | AssertRC(rc);
|
---|
1117 | }
|
---|
1118 | }
|
---|
1119 | LogFlowFunc(("returns mRc=%Rrc\n", rc));
|
---|
1120 | return VERR_TCP_SERVER_STOP;
|
---|
1121 | }
|
---|
1122 |
|
---|
1123 | /**
|
---|
1124 | * Powers on the fault tolerant virtual machine.
|
---|
1125 | *
|
---|
1126 | * @returns VBox status code.
|
---|
1127 | *
|
---|
1128 | * @param pUVM The user mode VM handle.
|
---|
1129 | * @param fMaster FT master or standby
|
---|
1130 | * @param uInterval FT sync interval
|
---|
1131 | * @param pszAddress Standby VM address
|
---|
1132 | * @param uPort Standby VM port
|
---|
1133 | * @param pszPassword FT password (NULL for none)
|
---|
1134 | *
|
---|
1135 | * @thread Any thread.
|
---|
1136 | * @vmstate Created
|
---|
1137 | * @vmstateto PoweringOn+Running (master), PoweringOn+Running_FT (standby)
|
---|
1138 | */
|
---|
1139 | VMMR3DECL(int) FTMR3PowerOn(PUVM pUVM, bool fMaster, unsigned uInterval,
|
---|
1140 | const char *pszAddress, unsigned uPort, const char *pszPassword)
|
---|
1141 | {
|
---|
1142 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
1143 | PVM pVM = pUVM->pVM;
|
---|
1144 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
1145 |
|
---|
1146 | VMSTATE enmVMState = VMR3GetState(pVM);
|
---|
1147 | AssertMsgReturn(enmVMState == VMSTATE_CREATED,
|
---|
1148 | ("%s\n", VMR3GetStateName(enmVMState)),
|
---|
1149 | VERR_INTERNAL_ERROR_4);
|
---|
1150 | AssertReturn(pszAddress, VERR_INVALID_PARAMETER);
|
---|
1151 |
|
---|
1152 | if (pVM->ftm.s.uInterval)
|
---|
1153 | pVM->ftm.s.uInterval = uInterval;
|
---|
1154 | else
|
---|
1155 | pVM->ftm.s.uInterval = 50; /* standard sync interval of 50ms */
|
---|
1156 |
|
---|
1157 | pVM->ftm.s.uPort = uPort;
|
---|
1158 | pVM->ftm.s.pszAddress = RTStrDup(pszAddress);
|
---|
1159 | if (pszPassword)
|
---|
1160 | pVM->ftm.s.pszPassword = RTStrDup(pszPassword);
|
---|
1161 |
|
---|
1162 | int rc = RTSemEventCreate(&pVM->ftm.s.hShutdownEvent);
|
---|
1163 | if (RT_FAILURE(rc))
|
---|
1164 | return rc;
|
---|
1165 |
|
---|
1166 | if (fMaster)
|
---|
1167 | {
|
---|
1168 | rc = RTThreadCreate(NULL, ftmR3MasterThread, pVM,
|
---|
1169 | 0, RTTHREADTYPE_IO /* higher than normal priority */, 0, "ftmMaster");
|
---|
1170 | if (RT_FAILURE(rc))
|
---|
1171 | return rc;
|
---|
1172 |
|
---|
1173 | pVM->fFaultTolerantMaster = true;
|
---|
1174 | if (PGMIsUsingLargePages(pVM))
|
---|
1175 | {
|
---|
1176 | /* Must disable large page usage as 2 MB pages are too big to write monitor. */
|
---|
1177 | LogRel(("FTSync: disabling large page usage.\n"));
|
---|
1178 | PGMSetLargePageUsage(pVM, false);
|
---|
1179 | }
|
---|
1180 | /** @todo might need to disable page fusion as well */
|
---|
1181 |
|
---|
1182 | return VMR3PowerOn(pVM->pUVM);
|
---|
1183 | }
|
---|
1184 |
|
---|
1185 |
|
---|
1186 | /* standby */
|
---|
1187 | rc = RTThreadCreate(NULL, ftmR3StandbyThread, pVM,
|
---|
1188 | 0, RTTHREADTYPE_DEFAULT, 0, "ftmStandby");
|
---|
1189 | if (RT_FAILURE(rc))
|
---|
1190 | return rc;
|
---|
1191 |
|
---|
1192 | rc = RTTcpServerCreateEx(pszAddress, uPort, &pVM->ftm.s.standby.hServer);
|
---|
1193 | if (RT_FAILURE(rc))
|
---|
1194 | return rc;
|
---|
1195 | pVM->ftm.s.fIsStandbyNode = true;
|
---|
1196 |
|
---|
1197 | rc = RTTcpServerListen(pVM->ftm.s.standby.hServer, ftmR3StandbyServeConnection, pVM);
|
---|
1198 | /** @todo deal with the exit code to check if we should activate this standby VM. */
|
---|
1199 | if (pVM->ftm.s.fActivateStandby)
|
---|
1200 | {
|
---|
1201 | /** @todo fallover. */
|
---|
1202 | }
|
---|
1203 |
|
---|
1204 | if (pVM->ftm.s.standby.hServer)
|
---|
1205 | {
|
---|
1206 | RTTcpServerDestroy(pVM->ftm.s.standby.hServer);
|
---|
1207 | pVM->ftm.s.standby.hServer = NULL;
|
---|
1208 | }
|
---|
1209 | if (rc == VERR_TCP_SERVER_SHUTDOWN)
|
---|
1210 | rc = VINF_SUCCESS; /* ignore this error; the standby process was cancelled. */
|
---|
1211 | return rc;
|
---|
1212 | }
|
---|
1213 |
|
---|
1214 | /**
|
---|
1215 | * Powers off the fault tolerant virtual machine (standby).
|
---|
1216 | *
|
---|
1217 | * @returns VBox status code.
|
---|
1218 | *
|
---|
1219 | * @param pUVM The user mode VM handle.
|
---|
1220 | */
|
---|
1221 | VMMR3DECL(int) FTMR3CancelStandby(PUVM pUVM)
|
---|
1222 | {
|
---|
1223 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
1224 | PVM pVM = pUVM->pVM;
|
---|
1225 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
1226 | AssertReturn(!pVM->fFaultTolerantMaster, VERR_NOT_SUPPORTED);
|
---|
1227 | Assert(pVM->ftm.s.standby.hServer);
|
---|
1228 |
|
---|
1229 | return RTTcpServerShutdown(pVM->ftm.s.standby.hServer);
|
---|
1230 | }
|
---|
1231 |
|
---|
1232 | /**
|
---|
1233 | * Rendezvous callback used by FTMR3SetCheckpoint
|
---|
1234 | * Sync state + changed memory with the standby node.
|
---|
1235 | *
|
---|
1236 | * This is only called on one of the EMTs while the other ones are waiting for
|
---|
1237 | * it to complete this function.
|
---|
1238 | *
|
---|
1239 | * @returns VINF_SUCCESS (VBox strict status code).
|
---|
1240 | * @param pVM Pointer to the VM.
|
---|
1241 | * @param pVCpu The VMCPU for the EMT we're being called on. Unused.
|
---|
1242 | * @param pvUser Not used.
|
---|
1243 | */
|
---|
1244 | static DECLCALLBACK(VBOXSTRICTRC) ftmR3SetCheckpointRendezvous(PVM pVM, PVMCPU pVCpu, void *pvUser)
|
---|
1245 | {
|
---|
1246 | int rc = VINF_SUCCESS;
|
---|
1247 | bool fSuspended = false;
|
---|
1248 | NOREF(pVCpu);
|
---|
1249 | NOREF(pvUser);
|
---|
1250 |
|
---|
1251 | /* We don't call VMR3Suspend here to avoid the overhead of state changes and notifications. This
|
---|
1252 | * is only a short suspend.
|
---|
1253 | */
|
---|
1254 | STAM_PROFILE_START(&pVM->ftm.s.StatCheckpointPause, a);
|
---|
1255 | PDMR3Suspend(pVM);
|
---|
1256 |
|
---|
1257 | /* Hack alert: as EM is responsible for dealing with the suspend state. We must do this here ourselves, but only for this EMT.*/
|
---|
1258 | EMR3NotifySuspend(pVM);
|
---|
1259 | STAM_PROFILE_STOP(&pVM->ftm.s.StatCheckpointPause, a);
|
---|
1260 |
|
---|
1261 | STAM_REL_COUNTER_INC(&pVM->ftm.s.StatDeltaVM);
|
---|
1262 |
|
---|
1263 | RTSocketRetain(pVM->ftm.s.hSocket); /* For concurrent access by I/O thread and EMT. */
|
---|
1264 |
|
---|
1265 | /* Reset the sync state. */
|
---|
1266 | pVM->ftm.s.syncstate.uOffStream = 0;
|
---|
1267 | pVM->ftm.s.syncstate.cbReadBlock = 0;
|
---|
1268 | pVM->ftm.s.syncstate.fStopReading = false;
|
---|
1269 | pVM->ftm.s.syncstate.fIOError = false;
|
---|
1270 | pVM->ftm.s.syncstate.fEndOfStream = false;
|
---|
1271 |
|
---|
1272 | rc = ftmR3TcpSubmitCommand(pVM, "checkpoint");
|
---|
1273 | AssertRC(rc);
|
---|
1274 |
|
---|
1275 | pVM->ftm.s.fDeltaLoadSaveActive = true;
|
---|
1276 | rc = VMR3SaveFT(pVM->pUVM, &g_ftmR3TcpOps, pVM, &fSuspended, true /* fSkipStateChanges */);
|
---|
1277 | pVM->ftm.s.fDeltaLoadSaveActive = false;
|
---|
1278 | AssertRC(rc);
|
---|
1279 |
|
---|
1280 | rc = ftmR3TcpReadACK(pVM, "checkpoint-complete");
|
---|
1281 | AssertRC(rc);
|
---|
1282 |
|
---|
1283 | RTSocketRelease(pVM->ftm.s.hSocket);
|
---|
1284 |
|
---|
1285 | /* Write protect all memory. */
|
---|
1286 | rc = PGMR3PhysWriteProtectRAM(pVM);
|
---|
1287 | AssertRC(rc);
|
---|
1288 |
|
---|
1289 | /* We don't call VMR3Resume here to avoid the overhead of state changes and notifications. This
|
---|
1290 | * is only a short suspend.
|
---|
1291 | */
|
---|
1292 | STAM_PROFILE_START(&pVM->ftm.s.StatCheckpointResume, b);
|
---|
1293 | PGMR3ResetNoMorePhysWritesFlag(pVM);
|
---|
1294 | PDMR3Resume(pVM);
|
---|
1295 |
|
---|
1296 | /* Hack alert as EM is responsible for dealing with the suspend state. We must do this here ourselves, but only for this EMT.*/
|
---|
1297 | EMR3NotifyResume(pVM);
|
---|
1298 | STAM_PROFILE_STOP(&pVM->ftm.s.StatCheckpointResume, b);
|
---|
1299 |
|
---|
1300 | return rc;
|
---|
1301 | }
|
---|
1302 |
|
---|
1303 | /**
|
---|
1304 | * Performs a full sync to the standby node
|
---|
1305 | *
|
---|
1306 | * @returns VBox status code.
|
---|
1307 | *
|
---|
1308 | * @param pVM Pointer to the VM.
|
---|
1309 | * @param enmCheckpoint Checkpoint type
|
---|
1310 | */
|
---|
1311 | VMMR3_INT_DECL(int) FTMR3SetCheckpoint(PVM pVM, FTMCHECKPOINTTYPE enmCheckpoint)
|
---|
1312 | {
|
---|
1313 | int rc;
|
---|
1314 |
|
---|
1315 | if (!pVM->fFaultTolerantMaster)
|
---|
1316 | return VINF_SUCCESS;
|
---|
1317 |
|
---|
1318 | switch (enmCheckpoint)
|
---|
1319 | {
|
---|
1320 | case FTMCHECKPOINTTYPE_NETWORK:
|
---|
1321 | STAM_REL_COUNTER_INC(&pVM->ftm.s.StatCheckpointNetwork);
|
---|
1322 | break;
|
---|
1323 |
|
---|
1324 | case FTMCHECKPOINTTYPE_STORAGE:
|
---|
1325 | STAM_REL_COUNTER_INC(&pVM->ftm.s.StatCheckpointStorage);
|
---|
1326 | break;
|
---|
1327 |
|
---|
1328 | default:
|
---|
1329 | AssertMsgFailedReturn(("%d\n", enmCheckpoint), VERR_INVALID_PARAMETER);
|
---|
1330 | }
|
---|
1331 |
|
---|
1332 | pVM->ftm.s.fCheckpointingActive = true;
|
---|
1333 | if (VM_IS_EMT(pVM))
|
---|
1334 | {
|
---|
1335 | PVMCPU pVCpu = VMMGetCpu(pVM);
|
---|
1336 |
|
---|
1337 | /* We must take special care here as the memory sync is competing with us and requires a responsive EMT. */
|
---|
1338 | while ((rc = PDMCritSectTryEnter(&pVM->ftm.s.CritSect)) == VERR_SEM_BUSY)
|
---|
1339 | {
|
---|
1340 | if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
|
---|
1341 | {
|
---|
1342 | rc = VMMR3EmtRendezvousFF(pVM, pVCpu);
|
---|
1343 | AssertRC(rc);
|
---|
1344 | }
|
---|
1345 |
|
---|
1346 | if (VM_FF_IS_PENDING(pVM, VM_FF_REQUEST))
|
---|
1347 | {
|
---|
1348 | rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, true /*fPriorityOnly*/);
|
---|
1349 | AssertRC(rc);
|
---|
1350 | }
|
---|
1351 | }
|
---|
1352 | }
|
---|
1353 | else
|
---|
1354 | rc = PDMCritSectEnter(&pVM->ftm.s.CritSect, VERR_SEM_BUSY);
|
---|
1355 |
|
---|
1356 | AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
|
---|
1357 |
|
---|
1358 | STAM_PROFILE_START(&pVM->ftm.s.StatCheckpoint, a);
|
---|
1359 |
|
---|
1360 | rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, ftmR3SetCheckpointRendezvous, NULL);
|
---|
1361 |
|
---|
1362 | STAM_PROFILE_STOP(&pVM->ftm.s.StatCheckpoint, a);
|
---|
1363 |
|
---|
1364 | PDMCritSectLeave(&pVM->ftm.s.CritSect);
|
---|
1365 | pVM->ftm.s.fCheckpointingActive = false;
|
---|
1366 |
|
---|
1367 | return rc;
|
---|
1368 | }
|
---|