VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/PATMSSM.cpp@ 54737

最後變更 在這個檔案從54737是 54737,由 vboxsync 提交於 10 年 前

VMM,REM: CPUID revamp - almost there now.
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Id Revision
檔案大小: 68.0 KB
行 
1/* $Id: PATMSSM.cpp 54737 2015-03-12 21:02:21Z vboxsync $ */
2/** @file
3 * PATMSSM - Dynamic Guest OS Patching Manager; Save and load state
4 *
5 * NOTE: CSAM assumes patch memory is never reused!!
6 */
7
8/*
9 * Copyright (C) 2006-2014 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.alldomusa.eu.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20/*******************************************************************************
21* Header Files *
22*******************************************************************************/
23#define LOG_GROUP LOG_GROUP_PATM
24#include <VBox/vmm/patm.h>
25#include <VBox/vmm/cpum.h>
26#include <VBox/vmm/cpumctx-v1_6.h>
27#include <VBox/vmm/mm.h>
28#include <VBox/vmm/ssm.h>
29#include <VBox/param.h>
30#include <iprt/avl.h>
31#include "PATMInternal.h"
32#include "PATMPatch.h"
33#include "PATMA.h"
34#include <VBox/vmm/vm.h>
35#include <VBox/vmm/csam.h>
36#include "internal/pgm.h"
37#include <VBox/dbg.h>
38#include <VBox/err.h>
39#include <VBox/log.h>
40#include <iprt/assert.h>
41#include <iprt/asm.h>
42#include <iprt/string.h>
43#include <VBox/dis.h>
44#include <VBox/disopcode.h>
45#include <VBox/version.h>
46
47/**
48 * Patch information - SSM version.
49 *
50 * the difference is the missing pTrampolinePatchesHead member
51 * to avoid changing the saved state version for now (will come later).
52 */
53typedef struct PATCHINFOSSM
54{
55 uint32_t uState;
56 uint32_t uOldState;
57 DISCPUMODE uOpMode;
58
59 /* GC pointer of privileged instruction */
60 RCPTRTYPE(uint8_t *) pPrivInstrGC;
61 R3PTRTYPE(uint8_t *) unusedHC; /* todo Can't remove due to structure size dependencies in saved states. */
62 uint8_t aPrivInstr[MAX_INSTR_SIZE];
63 uint32_t cbPrivInstr;
64 uint32_t opcode; //opcode for priv instr (OP_*)
65 uint32_t cbPatchJump; //patch jump size
66
67 /* Only valid for PATMFL_JUMP_CONFLICT patches */
68 RTRCPTR pPatchJumpDestGC;
69
70 RTGCUINTPTR32 pPatchBlockOffset;
71 uint32_t cbPatchBlockSize;
72 uint32_t uCurPatchOffset;
73#if HC_ARCH_BITS == 64
74 uint32_t Alignment0; /**< Align flags correctly. */
75#endif
76
77 uint64_t flags;
78
79 /**
80 * Lowest and highest patched GC instruction address. To optimize searches.
81 */
82 RTRCPTR pInstrGCLowest;
83 RTRCPTR pInstrGCHighest;
84
85 /* Tree of fixup records for the patch. */
86 R3PTRTYPE(PAVLPVNODECORE) FixupTree;
87 uint32_t nrFixups;
88
89 /* Tree of jumps inside the generated patch code. */
90 uint32_t nrJumpRecs;
91 R3PTRTYPE(PAVLPVNODECORE) JumpTree;
92
93 /**
94 * Lookup trees for determining the corresponding guest address of an
95 * instruction in the patch block.
96 */
97 R3PTRTYPE(PAVLU32NODECORE) Patch2GuestAddrTree;
98 R3PTRTYPE(PAVLU32NODECORE) Guest2PatchAddrTree;
99 uint32_t nrPatch2GuestRecs;
100#if HC_ARCH_BITS == 64
101 uint32_t Alignment1;
102#endif
103
104 /* Unused, but can't remove due to structure size dependencies in the saved state. */
105 PATMP2GLOOKUPREC_OBSOLETE unused;
106
107 /* Temporary information during patch creation. Don't waste hypervisor memory for this. */
108 R3PTRTYPE(PPATCHINFOTEMP) pTempInfo;
109
110 /* Count the number of writes to the corresponding guest code. */
111 uint32_t cCodeWrites;
112
113 /* Count the number of invalid writes to pages monitored for the patch. */
114 //some statistics to determine if we should keep this patch activated
115 uint32_t cTraps;
116
117 uint32_t cInvalidWrites;
118
119 // Index into the uPatchRun and uPatchTrap arrays (0..MAX_PATCHES-1)
120 uint32_t uPatchIdx;
121
122 /* First opcode byte, that's overwritten when a patch is marked dirty. */
123 uint8_t bDirtyOpcode;
124 uint8_t Alignment2[7]; /**< Align the structure size on a 8-byte boundary. */
125} PATCHINFOSSM, *PPATCHINFOSSM;
126
127/**
128 * Lookup record for patches - SSM version.
129 */
130typedef struct PATMPATCHRECSSM
131{
132 /** The key is a GC virtual address. */
133 AVLOU32NODECORE Core;
134 /** The key is a patch offset. */
135 AVLOU32NODECORE CoreOffset;
136
137 PATCHINFOSSM patch;
138} PATMPATCHRECSSM, *PPATMPATCHRECSSM;
139
140
141/*******************************************************************************
142* Internal Functions *
143*******************************************************************************/
144static void patmCorrectFixup(PVM pVM, unsigned ulSSMVersion, PATM &patmInfo, PPATCHINFO pPatch, PRELOCREC pRec, int32_t offset, RTRCPTR *pFixup);
145
146/*******************************************************************************
147* Global Variables *
148*******************************************************************************/
149/**
150 * SSM descriptor table for the PATM structure.
151 */
152static SSMFIELD const g_aPatmFields[] =
153{
154 /** @todo there are a bunch more fields here which can be marked as ignored. */
155 SSMFIELD_ENTRY_IGNORE( PATM, offVM),
156 SSMFIELD_ENTRY_RCPTR( PATM, pPatchMemGC),
157 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pPatchMemHC),
158 SSMFIELD_ENTRY( PATM, cbPatchMem),
159 SSMFIELD_ENTRY( PATM, offPatchMem),
160 SSMFIELD_ENTRY( PATM, fOutOfMemory),
161 SSMFIELD_ENTRY_PAD_HC_AUTO( 3, 3),
162 SSMFIELD_ENTRY( PATM, deltaReloc),
163 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pGCStateHC),
164 SSMFIELD_ENTRY_RCPTR( PATM, pGCStateGC),
165 SSMFIELD_ENTRY_RCPTR( PATM, pGCStackGC),
166 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pGCStackHC),
167 SSMFIELD_ENTRY_RCPTR( PATM, pCPUMCtxGC),
168 SSMFIELD_ENTRY_RCPTR( PATM, pStatsGC),
169 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pStatsHC),
170 SSMFIELD_ENTRY( PATM, uCurrentPatchIdx),
171 SSMFIELD_ENTRY( PATM, ulCallDepth),
172 SSMFIELD_ENTRY( PATM, cPageRecords),
173 SSMFIELD_ENTRY_RCPTR( PATM, pPatchedInstrGCLowest),
174 SSMFIELD_ENTRY_RCPTR( PATM, pPatchedInstrGCHighest),
175 SSMFIELD_ENTRY_RCPTR( PATM, PatchLookupTreeGC),
176 SSMFIELD_ENTRY_IGN_HCPTR( PATM, PatchLookupTreeHC),
177 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperCallGC),
178 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperRetGC),
179 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperJumpGC),
180 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperIretGC),
181 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pGlobalPatchRec),
182 SSMFIELD_ENTRY_RCPTR( PATM, pfnSysEnterGC),
183 SSMFIELD_ENTRY_RCPTR( PATM, pfnSysEnterPatchGC),
184 SSMFIELD_ENTRY( PATM, uSysEnterPatchIdx),
185 SSMFIELD_ENTRY_RCPTR( PATM, pvFaultMonitor),
186 SSMFIELD_ENTRY_GCPHYS( PATM, mmio.GCPhys),
187 SSMFIELD_ENTRY_RCPTR( PATM, mmio.pCachedData),
188 SSMFIELD_ENTRY_IGN_RCPTR( PATM, mmio.Alignment0),
189 SSMFIELD_ENTRY_IGN_HCPTR( PATM, savedstate.pSSM),
190 SSMFIELD_ENTRY( PATM, savedstate.cPatches),
191 SSMFIELD_ENTRY_PAD_HC64( PATM, savedstate.Alignment0, sizeof(uint32_t)),
192 SSMFIELD_ENTRY_IGNORE( PATM, StatNrOpcodeRead),
193 SSMFIELD_ENTRY_IGNORE( PATM, StatDisabled),
194 SSMFIELD_ENTRY_IGNORE( PATM, StatUnusable),
195 SSMFIELD_ENTRY_IGNORE( PATM, StatEnabled),
196 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalled),
197 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalledFunctionPatches),
198 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalledTrampoline),
199 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalledJump),
200 SSMFIELD_ENTRY_IGNORE( PATM, StatInt3Callable),
201 SSMFIELD_ENTRY_IGNORE( PATM, StatInt3BlockRun),
202 SSMFIELD_ENTRY_IGNORE( PATM, StatOverwritten),
203 SSMFIELD_ENTRY_IGNORE( PATM, StatFixedConflicts),
204 SSMFIELD_ENTRY_IGNORE( PATM, StatFlushed),
205 SSMFIELD_ENTRY_IGNORE( PATM, StatPageBoundaryCrossed),
206 SSMFIELD_ENTRY_IGNORE( PATM, StatMonitored),
207 SSMFIELD_ENTRY_IGNORE( PATM, StatHandleTrap),
208 SSMFIELD_ENTRY_IGNORE( PATM, StatSwitchBack),
209 SSMFIELD_ENTRY_IGNORE( PATM, StatSwitchBackFail),
210 SSMFIELD_ENTRY_IGNORE( PATM, StatPATMMemoryUsed),
211 SSMFIELD_ENTRY_IGNORE( PATM, StatDuplicateREQSuccess),
212 SSMFIELD_ENTRY_IGNORE( PATM, StatDuplicateREQFailed),
213 SSMFIELD_ENTRY_IGNORE( PATM, StatDuplicateUseExisting),
214 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionFound),
215 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionNotFound),
216 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWrite),
217 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWriteDetect),
218 SSMFIELD_ENTRY_IGNORE( PATM, StatDirty),
219 SSMFIELD_ENTRY_IGNORE( PATM, StatPushTrap),
220 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWriteInterpreted),
221 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWriteInterpretedFailed),
222 SSMFIELD_ENTRY_IGNORE( PATM, StatSysEnter),
223 SSMFIELD_ENTRY_IGNORE( PATM, StatSysExit),
224 SSMFIELD_ENTRY_IGNORE( PATM, StatEmulIret),
225 SSMFIELD_ENTRY_IGNORE( PATM, StatEmulIretFailed),
226 SSMFIELD_ENTRY_IGNORE( PATM, StatInstrDirty),
227 SSMFIELD_ENTRY_IGNORE( PATM, StatInstrDirtyGood),
228 SSMFIELD_ENTRY_IGNORE( PATM, StatInstrDirtyBad),
229 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchPageInserted),
230 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchPageRemoved),
231 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchRefreshSuccess),
232 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchRefreshFailed),
233 SSMFIELD_ENTRY_IGNORE( PATM, StatGenRet),
234 SSMFIELD_ENTRY_IGNORE( PATM, StatGenRetReused),
235 SSMFIELD_ENTRY_IGNORE( PATM, StatGenJump),
236 SSMFIELD_ENTRY_IGNORE( PATM, StatGenCall),
237 SSMFIELD_ENTRY_IGNORE( PATM, StatGenPopf),
238 SSMFIELD_ENTRY_IGNORE( PATM, StatCheckPendingIRQ),
239 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionLookupReplace),
240 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionLookupInsert),
241 SSMFIELD_ENTRY_IGNORE( PATM, StatU32FunctionMaxSlotsUsed),
242 SSMFIELD_ENTRY_IGNORE( PATM, Alignment0),
243 SSMFIELD_ENTRY_TERM()
244};
245
246/**
247 * SSM descriptor table for the PATM structure starting with r86139.
248 */
249static SSMFIELD const g_aPatmFields86139[] =
250{
251 /** @todo there are a bunch more fields here which can be marked as ignored. */
252 SSMFIELD_ENTRY_IGNORE( PATM, offVM),
253 SSMFIELD_ENTRY_RCPTR( PATM, pPatchMemGC),
254 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pPatchMemHC),
255 SSMFIELD_ENTRY( PATM, cbPatchMem),
256 SSMFIELD_ENTRY( PATM, offPatchMem),
257 SSMFIELD_ENTRY( PATM, fOutOfMemory),
258 SSMFIELD_ENTRY_PAD_HC_AUTO( 3, 3),
259 SSMFIELD_ENTRY( PATM, deltaReloc),
260 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pGCStateHC),
261 SSMFIELD_ENTRY_RCPTR( PATM, pGCStateGC),
262 SSMFIELD_ENTRY_RCPTR( PATM, pGCStackGC),
263 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pGCStackHC),
264 SSMFIELD_ENTRY_RCPTR( PATM, pCPUMCtxGC),
265 SSMFIELD_ENTRY_RCPTR( PATM, pStatsGC),
266 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pStatsHC),
267 SSMFIELD_ENTRY( PATM, uCurrentPatchIdx),
268 SSMFIELD_ENTRY( PATM, ulCallDepth),
269 SSMFIELD_ENTRY( PATM, cPageRecords),
270 SSMFIELD_ENTRY_RCPTR( PATM, pPatchedInstrGCLowest),
271 SSMFIELD_ENTRY_RCPTR( PATM, pPatchedInstrGCHighest),
272 SSMFIELD_ENTRY_RCPTR( PATM, PatchLookupTreeGC),
273 SSMFIELD_ENTRY_IGN_HCPTR( PATM, PatchLookupTreeHC),
274 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperCallGC),
275 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperRetGC),
276 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperJumpGC),
277 SSMFIELD_ENTRY_RCPTR( PATM, pfnHelperIretGC),
278 SSMFIELD_ENTRY_IGN_HCPTR( PATM, pGlobalPatchRec),
279 SSMFIELD_ENTRY_RCPTR( PATM, pfnSysEnterGC),
280 SSMFIELD_ENTRY_RCPTR( PATM, pfnSysEnterPatchGC),
281 SSMFIELD_ENTRY( PATM, uSysEnterPatchIdx),
282 SSMFIELD_ENTRY_RCPTR( PATM, pvFaultMonitor),
283 SSMFIELD_ENTRY_GCPHYS( PATM, mmio.GCPhys),
284 SSMFIELD_ENTRY_RCPTR( PATM, mmio.pCachedData),
285 SSMFIELD_ENTRY_IGN_RCPTR( PATM, mmio.Alignment0),
286 SSMFIELD_ENTRY_IGN_HCPTR( PATM, savedstate.pSSM),
287 SSMFIELD_ENTRY( PATM, savedstate.cPatches),
288 SSMFIELD_ENTRY_PAD_HC64( PATM, savedstate.Alignment0, sizeof(uint32_t)),
289 SSMFIELD_ENTRY_IGN_HCPTR( PATM, hDbgModPatchMem),
290 SSMFIELD_ENTRY_PAD_HC32( PATM, Alignment0, sizeof(uint32_t)),
291 SSMFIELD_ENTRY_IGNORE( PATM, StatNrOpcodeRead),
292 SSMFIELD_ENTRY_IGNORE( PATM, StatDisabled),
293 SSMFIELD_ENTRY_IGNORE( PATM, StatUnusable),
294 SSMFIELD_ENTRY_IGNORE( PATM, StatEnabled),
295 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalled),
296 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalledFunctionPatches),
297 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalledTrampoline),
298 SSMFIELD_ENTRY_IGNORE( PATM, StatInstalledJump),
299 SSMFIELD_ENTRY_IGNORE( PATM, StatInt3Callable),
300 SSMFIELD_ENTRY_IGNORE( PATM, StatInt3BlockRun),
301 SSMFIELD_ENTRY_IGNORE( PATM, StatOverwritten),
302 SSMFIELD_ENTRY_IGNORE( PATM, StatFixedConflicts),
303 SSMFIELD_ENTRY_IGNORE( PATM, StatFlushed),
304 SSMFIELD_ENTRY_IGNORE( PATM, StatPageBoundaryCrossed),
305 SSMFIELD_ENTRY_IGNORE( PATM, StatMonitored),
306 SSMFIELD_ENTRY_IGNORE( PATM, StatHandleTrap),
307 SSMFIELD_ENTRY_IGNORE( PATM, StatSwitchBack),
308 SSMFIELD_ENTRY_IGNORE( PATM, StatSwitchBackFail),
309 SSMFIELD_ENTRY_IGNORE( PATM, StatPATMMemoryUsed),
310 SSMFIELD_ENTRY_IGNORE( PATM, StatDuplicateREQSuccess),
311 SSMFIELD_ENTRY_IGNORE( PATM, StatDuplicateREQFailed),
312 SSMFIELD_ENTRY_IGNORE( PATM, StatDuplicateUseExisting),
313 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionFound),
314 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionNotFound),
315 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWrite),
316 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWriteDetect),
317 SSMFIELD_ENTRY_IGNORE( PATM, StatDirty),
318 SSMFIELD_ENTRY_IGNORE( PATM, StatPushTrap),
319 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWriteInterpreted),
320 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchWriteInterpretedFailed),
321 SSMFIELD_ENTRY_IGNORE( PATM, StatSysEnter),
322 SSMFIELD_ENTRY_IGNORE( PATM, StatSysExit),
323 SSMFIELD_ENTRY_IGNORE( PATM, StatEmulIret),
324 SSMFIELD_ENTRY_IGNORE( PATM, StatEmulIretFailed),
325 SSMFIELD_ENTRY_IGNORE( PATM, StatInstrDirty),
326 SSMFIELD_ENTRY_IGNORE( PATM, StatInstrDirtyGood),
327 SSMFIELD_ENTRY_IGNORE( PATM, StatInstrDirtyBad),
328 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchPageInserted),
329 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchPageRemoved),
330 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchRefreshSuccess),
331 SSMFIELD_ENTRY_IGNORE( PATM, StatPatchRefreshFailed),
332 SSMFIELD_ENTRY_IGNORE( PATM, StatGenRet),
333 SSMFIELD_ENTRY_IGNORE( PATM, StatGenRetReused),
334 SSMFIELD_ENTRY_IGNORE( PATM, StatGenJump),
335 SSMFIELD_ENTRY_IGNORE( PATM, StatGenCall),
336 SSMFIELD_ENTRY_IGNORE( PATM, StatGenPopf),
337 SSMFIELD_ENTRY_IGNORE( PATM, StatCheckPendingIRQ),
338 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionLookupReplace),
339 SSMFIELD_ENTRY_IGNORE( PATM, StatFunctionLookupInsert),
340 SSMFIELD_ENTRY_IGNORE( PATM, StatU32FunctionMaxSlotsUsed),
341 SSMFIELD_ENTRY_IGNORE( PATM, Alignment0),
342 SSMFIELD_ENTRY_TERM()
343};
344
345/**
346 * SSM descriptor table for the PATMGCSTATE structure.
347 */
348static SSMFIELD const g_aPatmGCStateFields[] =
349{
350 SSMFIELD_ENTRY( PATMGCSTATE, uVMFlags),
351 SSMFIELD_ENTRY( PATMGCSTATE, uPendingAction),
352 SSMFIELD_ENTRY( PATMGCSTATE, uPatchCalls),
353 SSMFIELD_ENTRY( PATMGCSTATE, uScratch),
354 SSMFIELD_ENTRY( PATMGCSTATE, uIretEFlags),
355 SSMFIELD_ENTRY( PATMGCSTATE, uIretCS),
356 SSMFIELD_ENTRY( PATMGCSTATE, uIretEIP),
357 SSMFIELD_ENTRY( PATMGCSTATE, Psp),
358 SSMFIELD_ENTRY( PATMGCSTATE, fPIF),
359 SSMFIELD_ENTRY_RCPTR( PATMGCSTATE, GCPtrInhibitInterrupts),
360 SSMFIELD_ENTRY_RCPTR( PATMGCSTATE, GCCallPatchTargetAddr),
361 SSMFIELD_ENTRY_RCPTR( PATMGCSTATE, GCCallReturnAddr),
362 SSMFIELD_ENTRY( PATMGCSTATE, Restore.uEAX),
363 SSMFIELD_ENTRY( PATMGCSTATE, Restore.uECX),
364 SSMFIELD_ENTRY( PATMGCSTATE, Restore.uEDI),
365 SSMFIELD_ENTRY( PATMGCSTATE, Restore.eFlags),
366 SSMFIELD_ENTRY( PATMGCSTATE, Restore.uFlags),
367 SSMFIELD_ENTRY_TERM()
368};
369
370/**
371 * SSM descriptor table for the PATMPATCHREC structure.
372 */
373static SSMFIELD const g_aPatmPatchRecFields[] =
374{
375 SSMFIELD_ENTRY( PATMPATCHRECSSM, Core.Key),
376 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, Core.pLeft),
377 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, Core.pRight),
378 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, Core.uchHeight),
379 SSMFIELD_ENTRY_PAD_HC_AUTO( 3, 3),
380 SSMFIELD_ENTRY( PATMPATCHRECSSM, CoreOffset.Key),
381 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, CoreOffset.pLeft),
382 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, CoreOffset.pRight),
383 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, CoreOffset.uchHeight),
384 SSMFIELD_ENTRY_PAD_HC_AUTO( 3, 3),
385 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.uState),
386 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.uOldState),
387 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.uOpMode),
388 SSMFIELD_ENTRY_RCPTR( PATMPATCHRECSSM, patch.pPrivInstrGC),
389 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.unusedHC),
390 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.aPrivInstr),
391 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.cbPrivInstr),
392 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.opcode),
393 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.cbPatchJump),
394 SSMFIELD_ENTRY_RCPTR( PATMPATCHRECSSM, patch.pPatchJumpDestGC),
395 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.pPatchBlockOffset),
396 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.cbPatchBlockSize),
397 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.uCurPatchOffset),
398 SSMFIELD_ENTRY_PAD_HC64( PATMPATCHRECSSM, patch.Alignment0, sizeof(uint32_t)),
399 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.flags),
400 SSMFIELD_ENTRY_RCPTR( PATMPATCHRECSSM, patch.pInstrGCLowest),
401 SSMFIELD_ENTRY_RCPTR( PATMPATCHRECSSM, patch.pInstrGCHighest),
402 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.FixupTree),
403 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.nrFixups),
404 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.nrJumpRecs), // should be zero?
405 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.JumpTree),
406 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.Patch2GuestAddrTree),
407 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.Guest2PatchAddrTree),
408 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.nrPatch2GuestRecs),
409 SSMFIELD_ENTRY_PAD_HC64( PATMPATCHRECSSM, patch.Alignment1, sizeof(uint32_t)),
410 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.unused.pPatchLocStartHC), // saved as zero
411 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.unused.pPatchLocEndHC), // ditto
412 SSMFIELD_ENTRY_IGN_RCPTR( PATMPATCHRECSSM, patch.unused.pGuestLoc), // ditto
413 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, patch.unused.opsize), // ditto
414 SSMFIELD_ENTRY_IGN_HCPTR( PATMPATCHRECSSM, patch.pTempInfo),
415 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.cCodeWrites),
416 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.cTraps),
417 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.cInvalidWrites),
418 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.uPatchIdx),
419 SSMFIELD_ENTRY( PATMPATCHRECSSM, patch.bDirtyOpcode),
420 SSMFIELD_ENTRY_IGNORE( PATMPATCHRECSSM, patch.Alignment2),
421 SSMFIELD_ENTRY_TERM()
422};
423
424/**
425 * SSM descriptor table for the RELOCREC structure.
426 */
427static SSMFIELD const g_aPatmRelocRec[] =
428{
429 SSMFIELD_ENTRY_HCPTR_HACK_U32( RELOCREC, Core.Key), // Used to store the relocation type
430 SSMFIELD_ENTRY_IGN_HCPTR( RELOCREC, Core.pLeft),
431 SSMFIELD_ENTRY_IGN_HCPTR( RELOCREC, Core.pRight),
432 SSMFIELD_ENTRY_IGNORE( RELOCREC, Core.uchHeight),
433 SSMFIELD_ENTRY_PAD_HC_AUTO( 3, 7),
434 SSMFIELD_ENTRY( RELOCREC, uType),
435 SSMFIELD_ENTRY_PAD_HC_AUTO( 0, 4),
436 SSMFIELD_ENTRY_HCPTR_HACK_U32( RELOCREC, pRelocPos), // converted to a patch member offset.
437 SSMFIELD_ENTRY_RCPTR( RELOCREC, pSource),
438 SSMFIELD_ENTRY_RCPTR( RELOCREC, pDest),
439 SSMFIELD_ENTRY_TERM()
440};
441
442/**
443 * SSM descriptor table for the RECPATCHTOGUEST structure.
444 */
445static SSMFIELD const g_aPatmRecPatchToGuest[] =
446{
447 SSMFIELD_ENTRY( RECPATCHTOGUEST, Core.Key),
448 SSMFIELD_ENTRY_PAD_HC_AUTO( 0, 4),
449 SSMFIELD_ENTRY_IGN_HCPTR( RECPATCHTOGUEST, Core.pLeft),
450 SSMFIELD_ENTRY_IGN_HCPTR( RECPATCHTOGUEST, Core.pRight),
451 SSMFIELD_ENTRY_IGNORE( RECPATCHTOGUEST, Core.uchHeight),
452 SSMFIELD_ENTRY_PAD_HC_AUTO( 3, 7),
453 SSMFIELD_ENTRY_RCPTR( RECPATCHTOGUEST, pOrgInstrGC),
454 SSMFIELD_ENTRY( RECPATCHTOGUEST, enmType),
455 SSMFIELD_ENTRY( RECPATCHTOGUEST, fDirty),
456 SSMFIELD_ENTRY( RECPATCHTOGUEST, fJumpTarget),
457 SSMFIELD_ENTRY( RECPATCHTOGUEST, u8DirtyOpcode),
458 SSMFIELD_ENTRY_PAD_HC_AUTO( 1, 5),
459 SSMFIELD_ENTRY_TERM()
460};
461
462#ifdef VBOX_STRICT
463
464/**
465 * Callback function for RTAvlPVDoWithAll
466 *
467 * Counts the number of patches in the tree
468 *
469 * @returns VBox status code.
470 * @param pNode Current node
471 * @param pcPatches Pointer to patch counter (uint32_t)
472 */
473static DECLCALLBACK(int) patmCountLeafPV(PAVLPVNODECORE pNode, void *pcPatches)
474{
475 NOREF(pNode);
476 *(uint32_t *)pcPatches = *(uint32_t *)pcPatches + 1;
477 return VINF_SUCCESS;
478}
479
480/**
481 * Callback function for RTAvlU32DoWithAll
482 *
483 * Counts the number of patches in the tree
484 *
485 * @returns VBox status code.
486 * @param pNode Current node
487 * @param pcPatches Pointer to patch counter (uint32_t)
488 */
489static DECLCALLBACK(int) patmCountLeaf(PAVLU32NODECORE pNode, void *pcPatches)
490{
491 NOREF(pNode);
492 *(uint32_t *)pcPatches = *(uint32_t *)pcPatches + 1;
493 return VINF_SUCCESS;
494}
495
496#endif /* VBOX_STRICT */
497
498/**
499 * Callback function for RTAvloU32DoWithAll
500 *
501 * Counts the number of patches in the tree
502 *
503 * @returns VBox status code.
504 * @param pNode Current node
505 * @param pcPatches Pointer to patch counter
506 */
507static DECLCALLBACK(int) patmCountPatch(PAVLOU32NODECORE pNode, void *pcPatches)
508{
509 NOREF(pNode);
510 *(uint32_t *)pcPatches = *(uint32_t *)pcPatches + 1;
511 return VINF_SUCCESS;
512}
513
514/**
515 * Callback function for RTAvlU32DoWithAll
516 *
517 * Saves all patch to guest lookup records.
518 *
519 * @returns VBox status code.
520 * @param pNode Current node
521 * @param pVM1 Pointer to the VM
522 */
523static DECLCALLBACK(int) patmSaveP2GLookupRecords(PAVLU32NODECORE pNode, void *pVM1)
524{
525 PVM pVM = (PVM)pVM1;
526 PSSMHANDLE pSSM = pVM->patm.s.savedstate.pSSM;
527 PRECPATCHTOGUEST pPatchToGuestRec = (PRECPATCHTOGUEST)pNode;
528
529 /* Save the lookup record. */
530 int rc = SSMR3PutStructEx(pSSM, pPatchToGuestRec, sizeof(RECPATCHTOGUEST), 0 /*fFlags*/, &g_aPatmRecPatchToGuest[0], NULL);
531 AssertRCReturn(rc, rc);
532
533 return VINF_SUCCESS;
534}
535
536/**
537 * Callback function for RTAvlPVDoWithAll
538 *
539 * Saves all patch to guest lookup records.
540 *
541 * @returns VBox status code.
542 * @param pNode Current node
543 * @param pVM1 Pointer to the VM
544 */
545static DECLCALLBACK(int) patmSaveFixupRecords(PAVLPVNODECORE pNode, void *pVM1)
546{
547 PVM pVM = (PVM)pVM1;
548 PSSMHANDLE pSSM = pVM->patm.s.savedstate.pSSM;
549 RELOCREC rec = *(PRELOCREC)pNode;
550 RTRCPTR *pFixup = (RTRCPTR *)rec.pRelocPos;
551
552 /* Convert pointer to an offset into patch memory. May not be applicable
553 to all fixup types, thus the UINT32_MAX. */
554 Assert(rec.pRelocPos);
555 uintptr_t offRelocPos = (uintptr_t)rec.pRelocPos - (uintptr_t)pVM->patm.s.pPatchMemHC;
556 if (offRelocPos > pVM->patm.s.cbPatchMem)
557 offRelocPos = UINT32_MAX;
558 rec.pRelocPos = (uint8_t *)offRelocPos;
559
560 /* Zero rec.Core.Key since it's unused and may trigger SSM check due to the hack below. */
561 rec.Core.Key = 0;
562
563
564 /* Save the lookup record. */
565 int rc = SSMR3PutStructEx(pSSM, &rec, sizeof(rec), 0 /*fFlags*/, &g_aPatmRelocRec[0], NULL);
566 AssertRCReturn(rc, rc);
567
568 return VINF_SUCCESS;
569}
570
571/**
572 * Converts a saved state patch record to the memory record.
573 *
574 * @returns nothing.
575 * @param pPatch The memory record.
576 * @param pPatchSSM The SSM version of the patch record.
577 */
578static void patmR3PatchConvertSSM2Mem(PPATMPATCHREC pPatch, PPATMPATCHRECSSM pPatchSSM)
579{
580 /*
581 * Only restore the patch part of the tree record; not the internal data (except the key of course)
582 */
583 pPatch->Core.Key = pPatchSSM->Core.Key;
584 pPatch->CoreOffset.Key = pPatchSSM->CoreOffset.Key;
585 pPatch->patch.uState = pPatchSSM->patch.uState;
586 pPatch->patch.uOldState = pPatchSSM->patch.uOldState;
587 pPatch->patch.uOpMode = pPatchSSM->patch.uOpMode;
588 pPatch->patch.pPrivInstrGC = pPatchSSM->patch.pPrivInstrGC;
589 pPatch->patch.unusedHC = pPatchSSM->patch.unusedHC;
590 memcpy(&pPatch->patch.aPrivInstr[0], &pPatchSSM->patch.aPrivInstr[0], MAX_INSTR_SIZE);
591 pPatch->patch.cbPrivInstr = pPatchSSM->patch.cbPrivInstr;
592 pPatch->patch.opcode = pPatchSSM->patch.opcode;
593 pPatch->patch.cbPatchJump = pPatchSSM->patch.cbPatchJump;
594 pPatch->patch.pPatchJumpDestGC = pPatchSSM->patch.pPatchJumpDestGC;
595 pPatch->patch.pPatchBlockOffset = pPatchSSM->patch.pPatchBlockOffset;
596 pPatch->patch.cbPatchBlockSize = pPatchSSM->patch.cbPatchBlockSize;
597 pPatch->patch.uCurPatchOffset = pPatchSSM->patch.uCurPatchOffset;
598 pPatch->patch.flags = pPatchSSM->patch.flags;
599 pPatch->patch.pInstrGCLowest = pPatchSSM->patch.pInstrGCLowest;
600 pPatch->patch.pInstrGCHighest = pPatchSSM->patch.pInstrGCHighest;
601 pPatch->patch.FixupTree = pPatchSSM->patch.FixupTree;
602 pPatch->patch.nrFixups = pPatchSSM->patch.nrFixups;
603 pPatch->patch.nrJumpRecs = pPatchSSM->patch.nrJumpRecs;
604 pPatch->patch.JumpTree = pPatchSSM->patch.JumpTree;
605 pPatch->patch.Patch2GuestAddrTree = pPatchSSM->patch.Patch2GuestAddrTree;
606 pPatch->patch.Guest2PatchAddrTree = pPatchSSM->patch.Guest2PatchAddrTree;
607 pPatch->patch.nrPatch2GuestRecs = pPatchSSM->patch.nrPatch2GuestRecs;
608 pPatch->patch.unused = pPatchSSM->patch.unused;
609 pPatch->patch.pTempInfo = pPatchSSM->patch.pTempInfo;
610 pPatch->patch.cCodeWrites = pPatchSSM->patch.cCodeWrites;
611 pPatch->patch.cTraps = pPatchSSM->patch.cTraps;
612 pPatch->patch.cInvalidWrites = pPatchSSM->patch.cInvalidWrites;
613 pPatch->patch.uPatchIdx = pPatchSSM->patch.uPatchIdx;
614 pPatch->patch.bDirtyOpcode = pPatchSSM->patch.bDirtyOpcode;
615 pPatch->patch.pTrampolinePatchesHead = NULL;
616}
617
618/**
619 * Converts a memory patch record to the saved state version.
620 *
621 * @returns nothing.
622 * @param pPatchSSM The saved state record.
623 * @param pPatch The memory version to save.
624 */
625static void patmR3PatchConvertMem2SSM(PPATMPATCHRECSSM pPatchSSM, PPATMPATCHREC pPatch)
626{
627 pPatchSSM->Core = pPatch->Core;
628 pPatchSSM->CoreOffset = pPatch->CoreOffset;
629 pPatchSSM->patch.uState = pPatch->patch.uState;
630 pPatchSSM->patch.uOldState = pPatch->patch.uOldState;
631 pPatchSSM->patch.uOpMode = pPatch->patch.uOpMode;
632 pPatchSSM->patch.pPrivInstrGC = pPatch->patch.pPrivInstrGC;
633 pPatchSSM->patch.unusedHC = pPatch->patch.unusedHC;
634 memcpy(&pPatchSSM->patch.aPrivInstr[0], &pPatch->patch.aPrivInstr[0], MAX_INSTR_SIZE);
635 pPatchSSM->patch.cbPrivInstr = pPatch->patch.cbPrivInstr;
636 pPatchSSM->patch.opcode = pPatch->patch.opcode;
637 pPatchSSM->patch.cbPatchJump = pPatch->patch.cbPatchJump;
638 pPatchSSM->patch.pPatchJumpDestGC = pPatch->patch.pPatchJumpDestGC;
639 pPatchSSM->patch.pPatchBlockOffset = pPatch->patch.pPatchBlockOffset;
640 pPatchSSM->patch.cbPatchBlockSize = pPatch->patch.cbPatchBlockSize;
641 pPatchSSM->patch.uCurPatchOffset = pPatch->patch.uCurPatchOffset;
642 pPatchSSM->patch.flags = pPatch->patch.flags;
643 pPatchSSM->patch.pInstrGCLowest = pPatch->patch.pInstrGCLowest;
644 pPatchSSM->patch.pInstrGCHighest = pPatch->patch.pInstrGCHighest;
645 pPatchSSM->patch.FixupTree = pPatch->patch.FixupTree;
646 pPatchSSM->patch.nrFixups = pPatch->patch.nrFixups;
647 pPatchSSM->patch.nrJumpRecs = pPatch->patch.nrJumpRecs;
648 pPatchSSM->patch.JumpTree = pPatch->patch.JumpTree;
649 pPatchSSM->patch.Patch2GuestAddrTree = pPatch->patch.Patch2GuestAddrTree;
650 pPatchSSM->patch.Guest2PatchAddrTree = pPatch->patch.Guest2PatchAddrTree;
651 pPatchSSM->patch.nrPatch2GuestRecs = pPatch->patch.nrPatch2GuestRecs;
652 pPatchSSM->patch.unused = pPatch->patch.unused;
653 pPatchSSM->patch.pTempInfo = pPatch->patch.pTempInfo;
654 pPatchSSM->patch.cCodeWrites = pPatch->patch.cCodeWrites;
655 pPatchSSM->patch.cTraps = pPatch->patch.cTraps;
656 pPatchSSM->patch.cInvalidWrites = pPatch->patch.cInvalidWrites;
657 pPatchSSM->patch.uPatchIdx = pPatch->patch.uPatchIdx;
658 pPatchSSM->patch.bDirtyOpcode = pPatch->patch.bDirtyOpcode;
659}
660
661/**
662 * Callback function for RTAvloU32DoWithAll
663 *
664 * Saves the state of the patch that's being enumerated
665 *
666 * @returns VBox status code.
667 * @param pNode Current node
668 * @param pVM1 Pointer to the VM
669 */
670static DECLCALLBACK(int) patmSavePatchState(PAVLOU32NODECORE pNode, void *pVM1)
671{
672 PVM pVM = (PVM)pVM1;
673 PPATMPATCHREC pPatch = (PPATMPATCHREC)pNode;
674 PATMPATCHRECSSM patch;
675 PSSMHANDLE pSSM = pVM->patm.s.savedstate.pSSM;
676 int rc;
677
678 Assert(!(pPatch->patch.flags & PATMFL_GLOBAL_FUNCTIONS));
679
680 patmR3PatchConvertMem2SSM(&patch, pPatch);
681 Log4(("patmSavePatchState: cbPatchJump=%u uCurPathOffset=%#x pInstrGCLowest/Higest=%#x/%#x nrFixups=%#x nrJumpRecs=%#x\n",
682 patch.patch.cbPatchJump, patch.patch.uCurPatchOffset, patch.patch.pInstrGCLowest, patch.patch.pInstrGCHighest,
683 patch.patch.nrFixups, patch.patch.nrJumpRecs));
684
685 /*
686 * Reset HC pointers that need to be recalculated when loading the state
687 */
688 AssertMsg(patch.patch.uState == PATCH_REFUSED || (patch.patch.pPatchBlockOffset || (patch.patch.flags & (PATMFL_SYSENTER_XP|PATMFL_INT3_REPLACEMENT))),
689 ("State = %x pPatchBlockHC=%08x flags=%x\n", patch.patch.uState, PATCHCODE_PTR_HC(&patch.patch), patch.patch.flags));
690 Assert(pPatch->patch.JumpTree == 0);
691 Assert(!pPatch->patch.pTempInfo || pPatch->patch.pTempInfo->DisasmJumpTree == 0);
692 Assert(!pPatch->patch.pTempInfo || pPatch->patch.pTempInfo->IllegalInstrTree == 0);
693
694 /* Save the patch record itself */
695 rc = SSMR3PutStructEx(pSSM, &patch, sizeof(patch), 0 /*fFlags*/, &g_aPatmPatchRecFields[0], NULL);
696 AssertRCReturn(rc, rc);
697
698 /*
699 * Reset HC pointers in fixup records and save them.
700 */
701#ifdef VBOX_STRICT
702 uint32_t nrFixupRecs = 0;
703 RTAvlPVDoWithAll(&pPatch->patch.FixupTree, true, patmCountLeafPV, &nrFixupRecs);
704 AssertMsg(nrFixupRecs == pPatch->patch.nrFixups, ("Fixup inconsistency! counted %d vs %d\n", nrFixupRecs, pPatch->patch.nrFixups));
705#endif
706 rc = RTAvlPVDoWithAll(&pPatch->patch.FixupTree, true, patmSaveFixupRecords, pVM);
707 AssertRCReturn(rc, rc);
708
709#ifdef VBOX_STRICT
710 uint32_t nrLookupRecords = 0;
711 RTAvlU32DoWithAll(&pPatch->patch.Patch2GuestAddrTree, true, patmCountLeaf, &nrLookupRecords);
712 Assert(nrLookupRecords == pPatch->patch.nrPatch2GuestRecs);
713#endif
714
715 rc = RTAvlU32DoWithAll(&pPatch->patch.Patch2GuestAddrTree, true, patmSaveP2GLookupRecords, pVM);
716 AssertRCReturn(rc, rc);
717
718 return VINF_SUCCESS;
719}
720
721/**
722 * Execute state save operation.
723 *
724 * @returns VBox status code.
725 * @param pVM Pointer to the VM.
726 * @param pSSM SSM operation handle.
727 */
728DECLCALLBACK(int) patmR3Save(PVM pVM, PSSMHANDLE pSSM)
729{
730 PATM patmInfo = pVM->patm.s;
731 int rc;
732
733 pVM->patm.s.savedstate.pSSM = pSSM;
734
735 /*
736 * Reset HC pointers that need to be recalculated when loading the state
737 */
738 patmInfo.pPatchMemHC = NULL;
739 patmInfo.pGCStateHC = 0;
740 patmInfo.pvFaultMonitor = 0;
741
742 Assert(patmInfo.ulCallDepth == 0);
743
744 /*
745 * Count the number of patches in the tree (feeling lazy)
746 */
747 patmInfo.savedstate.cPatches = 0;
748 RTAvloU32DoWithAll(&pVM->patm.s.PatchLookupTreeHC->PatchTree, true, patmCountPatch, &patmInfo.savedstate.cPatches);
749
750 /*
751 * Save PATM structure
752 */
753 rc = SSMR3PutStructEx(pSSM, &patmInfo, sizeof(patmInfo), 0 /*fFlags*/, &g_aPatmFields[0], NULL);
754 AssertRCReturn(rc, rc);
755
756 /*
757 * Save patch memory contents
758 */
759 rc = SSMR3PutMem(pSSM, pVM->patm.s.pPatchMemHC, pVM->patm.s.cbPatchMem);
760 AssertRCReturn(rc, rc);
761
762 /*
763 * Save GC state memory
764 */
765 rc = SSMR3PutStructEx(pSSM, pVM->patm.s.pGCStateHC, sizeof(PATMGCSTATE), 0 /*fFlags*/, &g_aPatmGCStateFields[0], NULL);
766 AssertRCReturn(rc, rc);
767
768 /*
769 * Save PATM stack page
770 */
771 SSMR3PutU32(pSSM, PATM_STACK_TOTAL_SIZE);
772 rc = SSMR3PutMem(pSSM, pVM->patm.s.pGCStackHC, PATM_STACK_TOTAL_SIZE);
773 AssertRCReturn(rc, rc);
774
775 /*
776 * Save all patches
777 */
778 rc = RTAvloU32DoWithAll(&pVM->patm.s.PatchLookupTreeHC->PatchTree, true, patmSavePatchState, pVM);
779 AssertRCReturn(rc, rc);
780
781 /** @note patch statistics are not saved. */
782
783 return VINF_SUCCESS;
784}
785
786
787/**
788 * Execute state load operation.
789 *
790 * @returns VBox status code.
791 * @param pVM Pointer to the VM.
792 * @param pSSM SSM operation handle.
793 * @param uVersion Data layout version.
794 * @param uPass The data pass.
795 */
796DECLCALLBACK(int) patmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
797{
798 PATM patmInfo;
799 int rc;
800
801 if ( uVersion != PATM_SAVED_STATE_VERSION
802 && uVersion != PATM_SAVED_STATE_VERSION_MEM
803 && uVersion != PATM_SAVED_STATE_VERSION_FIXUP_HACK
804 && uVersion != PATM_SAVED_STATE_VERSION_VER16
805 )
806 {
807 AssertMsgFailed(("patmR3Load: Invalid version uVersion=%d!\n", uVersion));
808 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
809 }
810 uint32_t const fStructRestoreFlags = uVersion <= PATM_SAVED_STATE_VERSION_MEM ? SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED : 0;
811 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
812
813 pVM->patm.s.savedstate.pSSM = pSSM;
814
815 /*
816 * Restore PATM structure
817 */
818 RT_ZERO(patmInfo);
819 if ( uVersion == PATM_SAVED_STATE_VERSION_MEM
820 && SSMR3HandleRevision(pSSM) >= 86139
821 && SSMR3HandleVersion(pSSM) >= VBOX_FULL_VERSION_MAKE(4, 2, 51))
822 rc = SSMR3GetStructEx(pSSM, &patmInfo, sizeof(patmInfo), SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED,
823 &g_aPatmFields86139[0], NULL);
824 else
825 rc = SSMR3GetStructEx(pSSM, &patmInfo, sizeof(patmInfo), fStructRestoreFlags, &g_aPatmFields[0], NULL);
826 AssertRCReturn(rc, rc);
827
828 /* Relative calls are made to the helper functions. Therefor their relative location must not change! */
829 /* Note: we reuse the saved global helpers and assume they are identical, which is kind of dangerous. */
830 AssertLogRelReturn((pVM->patm.s.pfnHelperCallGC - pVM->patm.s.pPatchMemGC) == (patmInfo.pfnHelperCallGC - patmInfo.pPatchMemGC),
831 VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
832 AssertLogRelReturn((pVM->patm.s.pfnHelperRetGC - pVM->patm.s.pPatchMemGC) == (patmInfo.pfnHelperRetGC - patmInfo.pPatchMemGC),
833 VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
834 AssertLogRelReturn((pVM->patm.s.pfnHelperJumpGC - pVM->patm.s.pPatchMemGC) == (patmInfo.pfnHelperJumpGC - patmInfo.pPatchMemGC),
835 VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
836 AssertLogRelReturn((pVM->patm.s.pfnHelperIretGC - pVM->patm.s.pPatchMemGC) == (patmInfo.pfnHelperIretGC - patmInfo.pPatchMemGC),
837 VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
838 AssertLogRelReturn(pVM->patm.s.cbPatchMem == patmInfo.cbPatchMem, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
839
840 pVM->patm.s.offPatchMem = patmInfo.offPatchMem;
841 pVM->patm.s.deltaReloc = patmInfo.deltaReloc;
842 pVM->patm.s.uCurrentPatchIdx = patmInfo.uCurrentPatchIdx;
843 pVM->patm.s.fOutOfMemory = patmInfo.fOutOfMemory;
844
845 /* Lowest and highest patched instruction */
846 pVM->patm.s.pPatchedInstrGCLowest = patmInfo.pPatchedInstrGCLowest;
847 pVM->patm.s.pPatchedInstrGCHighest = patmInfo.pPatchedInstrGCHighest;
848
849 /* Sysenter handlers */
850 pVM->patm.s.pfnSysEnterGC = patmInfo.pfnSysEnterGC;
851 pVM->patm.s.pfnSysEnterPatchGC = patmInfo.pfnSysEnterPatchGC;
852 pVM->patm.s.uSysEnterPatchIdx = patmInfo.uSysEnterPatchIdx;
853
854 Assert(patmInfo.ulCallDepth == 0 && pVM->patm.s.ulCallDepth == 0);
855
856 Log(("pPatchMemGC %RRv vs old %RRv\n", pVM->patm.s.pPatchMemGC, patmInfo.pPatchMemGC));
857 Log(("pGCStateGC %RRv vs old %RRv\n", pVM->patm.s.pGCStateGC, patmInfo.pGCStateGC));
858 Log(("pGCStackGC %RRv vs old %RRv\n", pVM->patm.s.pGCStackGC, patmInfo.pGCStackGC));
859 Log(("pCPUMCtxGC %RRv vs old %RRv\n", pVM->patm.s.pCPUMCtxGC, patmInfo.pCPUMCtxGC));
860
861
862 /** @note patch statistics are not restored. */
863
864 /*
865 * Restore patch memory contents
866 */
867 Log(("Restore patch memory: new %RRv old %RRv\n", pVM->patm.s.pPatchMemGC, patmInfo.pPatchMemGC));
868 rc = SSMR3GetMem(pSSM, pVM->patm.s.pPatchMemHC, pVM->patm.s.cbPatchMem);
869 AssertRCReturn(rc, rc);
870
871 /*
872 * Restore GC state memory
873 */
874 RT_BZERO(pVM->patm.s.pGCStateHC, sizeof(PATMGCSTATE));
875 rc = SSMR3GetStructEx(pSSM, pVM->patm.s.pGCStateHC, sizeof(PATMGCSTATE), fStructRestoreFlags, &g_aPatmGCStateFields[0], NULL);
876 AssertRCReturn(rc, rc);
877
878 /*
879 * Restore PATM stack page
880 */
881 uint32_t cbStack = PATM_STACK_TOTAL_SIZE;
882 if (uVersion > PATM_SAVED_STATE_VERSION_MEM)
883 {
884 rc = SSMR3GetU32(pSSM, &cbStack);
885 AssertRCReturn(rc, rc);
886 }
887 AssertCompile(!(PATM_STACK_TOTAL_SIZE & 31));
888 AssertLogRelMsgReturn(cbStack > 0 && cbStack <= PATM_STACK_TOTAL_SIZE && !(cbStack & 31),
889 ("cbStack=%#x vs %#x", cbStack, PATM_STACK_TOTAL_SIZE),
890 VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
891 rc = SSMR3GetMem(pSSM, pVM->patm.s.pGCStackHC, cbStack);
892 AssertRCReturn(rc, rc);
893 if (cbStack < PATM_STACK_TOTAL_SIZE)
894 memset((uint8_t *)pVM->patm.s.pGCStackHC + cbStack, 0, PATM_STACK_TOTAL_SIZE - cbStack);
895
896 /*
897 * Load all patches
898 */
899 for (unsigned i = 0; i < patmInfo.savedstate.cPatches; i++)
900 {
901 PATMPATCHRECSSM patch;
902 PATMPATCHREC *pPatchRec;
903
904 RT_ZERO(patch);
905 rc = SSMR3GetStructEx(pSSM, &patch, sizeof(patch), fStructRestoreFlags, &g_aPatmPatchRecFields[0], NULL);
906 AssertRCReturn(rc, rc);
907 Log4(("patmR3Load: cbPatchJump=%u uCurPathOffset=%#x pInstrGCLowest/Higest=%#x/%#x nrFixups=%#x nrJumpRecs=%#x\n",
908 patch.patch.cbPatchJump, patch.patch.uCurPatchOffset, patch.patch.pInstrGCLowest, patch.patch.pInstrGCHighest,
909 patch.patch.nrFixups, patch.patch.nrJumpRecs));
910
911 Assert(!(patch.patch.flags & PATMFL_GLOBAL_FUNCTIONS));
912
913 rc = MMHyperAlloc(pVM, sizeof(PATMPATCHREC), 0, MM_TAG_PATM_PATCH, (void **)&pPatchRec);
914 if (RT_FAILURE(rc))
915 {
916 AssertMsgFailed(("Out of memory!!!!\n"));
917 return VERR_NO_MEMORY;
918 }
919
920 /* Convert SSM version to memory. */
921 patmR3PatchConvertSSM2Mem(pPatchRec, &patch);
922
923 Log(("Restoring patch %RRv -> %RRv state %x\n", pPatchRec->patch.pPrivInstrGC, patmInfo.pPatchMemGC + pPatchRec->patch.pPatchBlockOffset, pPatchRec->patch.uState));
924 bool ret = RTAvloU32Insert(&pVM->patm.s.PatchLookupTreeHC->PatchTree, &pPatchRec->Core);
925 Assert(ret);
926 if (pPatchRec->patch.uState != PATCH_REFUSED)
927 {
928 if (pPatchRec->patch.pPatchBlockOffset)
929 {
930 /* We actually generated code for this patch. */
931 ret = RTAvloU32Insert(&pVM->patm.s.PatchLookupTreeHC->PatchTreeByPatchAddr, &pPatchRec->CoreOffset);
932 AssertMsg(ret, ("Inserting patch %RRv offset %08RX32 failed!!\n", pPatchRec->patch.pPrivInstrGC, pPatchRec->CoreOffset.Key));
933 }
934 }
935 /* Set to zero as we don't need it anymore. */
936 pPatchRec->patch.pTempInfo = 0;
937
938 PATMP2GLOOKUPREC cacheRec;
939 RT_ZERO(cacheRec);
940 cacheRec.pPatch = &pPatchRec->patch;
941
942 uint8_t *pPrivInstrHC = patmR3GCVirtToHCVirt(pVM, &cacheRec, pPatchRec->patch.pPrivInstrGC);
943 /* Can fail due to page or page table not present. */
944
945 /*
946 * Restore fixup records and correct HC pointers in fixup records
947 */
948 pPatchRec->patch.FixupTree = 0;
949 pPatchRec->patch.nrFixups = 0; /* increased by patmPatchAddReloc32 */
950 for (unsigned j = 0; j < patch.patch.nrFixups; j++)
951 {
952 RELOCREC rec;
953 int32_t offset;
954 RTRCPTR *pFixup;
955
956 RT_ZERO(rec);
957 rc = SSMR3GetStructEx(pSSM, &rec, sizeof(rec), fStructRestoreFlags, &g_aPatmRelocRec[0], NULL);
958 AssertRCReturn(rc, rc);
959
960 if (pPrivInstrHC)
961 {
962 /* rec.pRelocPos now contains the relative position inside the hypervisor area. */
963 offset = (int32_t)(intptr_t)rec.pRelocPos;
964 /* Convert to HC pointer again. */
965 if ((uintptr_t)rec.pRelocPos < pVM->patm.s.cbPatchMem)
966 rec.pRelocPos = pVM->patm.s.pPatchMemHC + (uintptr_t)rec.pRelocPos;
967 else
968 rec.pRelocPos = NULL;
969 pFixup = (RTRCPTR *)rec.pRelocPos;
970
971 if (pPatchRec->patch.uState != PATCH_REFUSED)
972 {
973 if ( rec.uType == FIXUP_REL_JMPTOPATCH
974 && (pPatchRec->patch.flags & PATMFL_PATCHED_GUEST_CODE))
975 {
976 Assert(pPatchRec->patch.cbPatchJump == SIZEOF_NEARJUMP32 || pPatchRec->patch.cbPatchJump == SIZEOF_NEAR_COND_JUMP32);
977 unsigned offset2 = (pPatchRec->patch.cbPatchJump == SIZEOF_NEARJUMP32) ? 1 : 2;
978
979 rec.pRelocPos = pPrivInstrHC + offset2;
980 pFixup = (RTRCPTR *)rec.pRelocPos;
981 }
982
983 patmCorrectFixup(pVM, uVersion, patmInfo, &pPatchRec->patch, &rec, offset, pFixup);
984 }
985
986 rc = patmPatchAddReloc32(pVM, &pPatchRec->patch, rec.pRelocPos, rec.uType, rec.pSource, rec.pDest);
987 AssertRCReturn(rc, rc);
988 }
989 }
990 /* Release previous lock if any. */
991 if (cacheRec.Lock.pvMap)
992 PGMPhysReleasePageMappingLock(pVM, &cacheRec.Lock);
993
994 /* And all patch to guest lookup records */
995 Assert(pPatchRec->patch.nrPatch2GuestRecs || pPatchRec->patch.uState == PATCH_REFUSED || (pPatchRec->patch.flags & (PATMFL_SYSENTER_XP | PATMFL_IDTHANDLER | PATMFL_TRAPHANDLER | PATMFL_INT3_REPLACEMENT)));
996
997 pPatchRec->patch.Patch2GuestAddrTree = 0;
998 pPatchRec->patch.Guest2PatchAddrTree = 0;
999 if (pPatchRec->patch.nrPatch2GuestRecs)
1000 {
1001 RECPATCHTOGUEST rec;
1002 uint32_t nrPatch2GuestRecs = pPatchRec->patch.nrPatch2GuestRecs;
1003
1004 pPatchRec->patch.nrPatch2GuestRecs = 0; /* incremented by patmr3AddP2GLookupRecord */
1005 for (uint32_t j=0;j<nrPatch2GuestRecs;j++)
1006 {
1007 RT_ZERO(rec);
1008 rc = SSMR3GetStructEx(pSSM, &rec, sizeof(rec), fStructRestoreFlags, &g_aPatmRecPatchToGuest[0], NULL);
1009 AssertRCReturn(rc, rc);
1010
1011 patmR3AddP2GLookupRecord(pVM, &pPatchRec->patch, (uintptr_t)rec.Core.Key + pVM->patm.s.pPatchMemHC, rec.pOrgInstrGC, rec.enmType, rec.fDirty);
1012 }
1013 Assert(pPatchRec->patch.Patch2GuestAddrTree);
1014 }
1015
1016 if (pPatchRec->patch.flags & PATMFL_CODE_MONITORED)
1017 {
1018 /* Insert the guest page lookup records (for detection self-modifying code) */
1019 rc = patmInsertPatchPages(pVM, &pPatchRec->patch);
1020 AssertRCReturn(rc, rc);
1021 }
1022
1023#if 0 /* can fail def LOG_ENABLED */
1024 if ( pPatchRec->patch.uState != PATCH_REFUSED
1025 && !(pPatchRec->patch.flags & PATMFL_INT3_REPLACEMENT))
1026 {
1027 pPatchRec->patch.pTempInfo = (PPATCHINFOTEMP)MMR3HeapAllocZ(pVM, MM_TAG_PATM_PATCH, sizeof(PATCHINFOTEMP));
1028 Log(("Patch code ----------------------------------------------------------\n"));
1029 patmr3DisasmCodeStream(pVM, PATCHCODE_PTR_GC(&pPatchRec->patch), PATCHCODE_PTR_GC(&pPatchRec->patch), patmr3DisasmCallback, &pPatchRec->patch);
1030 Log(("Patch code ends -----------------------------------------------------\n"));
1031 MMR3HeapFree(pPatchRec->patch.pTempInfo);
1032 pPatchRec->patch.pTempInfo = NULL;
1033 }
1034#endif
1035 /* Remove the patch in case the gc mapping is not present. */
1036 if ( !pPrivInstrHC
1037 && pPatchRec->patch.uState == PATCH_ENABLED)
1038 {
1039 Log(("Remove patch %RGv due to failed HC address translation\n", pPatchRec->patch.pPrivInstrGC));
1040 PATMR3RemovePatch(pVM, pPatchRec->patch.pPrivInstrGC);
1041 }
1042 }
1043
1044 /*
1045 * Correct absolute fixups in the global patch. (helper functions)
1046 * Bit of a mess. Uses the new patch record, but restored patch functions.
1047 */
1048 PRELOCREC pRec = 0;
1049 AVLPVKEY key = 0;
1050
1051 Log(("Correct fixups in global helper functions\n"));
1052 while (true)
1053 {
1054 int32_t offset;
1055 RTRCPTR *pFixup;
1056
1057 /* Get the record that's closest from above */
1058 pRec = (PRELOCREC)RTAvlPVGetBestFit(&pVM->patm.s.pGlobalPatchRec->patch.FixupTree, key, true);
1059 if (pRec == 0)
1060 break;
1061
1062 key = (AVLPVKEY)(pRec->pRelocPos + 1); /* search for the next record during the next round. */
1063
1064 /* rec.pRelocPos now contains the relative position inside the hypervisor area. */
1065 offset = (int32_t)(pRec->pRelocPos - pVM->patm.s.pPatchMemHC);
1066 pFixup = (RTRCPTR *)pRec->pRelocPos;
1067
1068 /* Correct fixups that refer to PATM structures in the hypervisor region (their addresses might have changed). */
1069 patmCorrectFixup(pVM, uVersion, patmInfo, &pVM->patm.s.pGlobalPatchRec->patch, pRec, offset, pFixup);
1070 }
1071
1072#ifdef VBOX_WITH_STATISTICS
1073 /*
1074 * Restore relevant old statistics
1075 */
1076 pVM->patm.s.StatDisabled = patmInfo.StatDisabled;
1077 pVM->patm.s.StatUnusable = patmInfo.StatUnusable;
1078 pVM->patm.s.StatEnabled = patmInfo.StatEnabled;
1079 pVM->patm.s.StatInstalled = patmInfo.StatInstalled;
1080#endif
1081
1082 return VINF_SUCCESS;
1083}
1084
1085/**
1086 * Correct fixups to predefined hypervisor PATM regions. (their addresses might have changed)
1087 *
1088 * @returns VBox status code.
1089 * @param pVM Pointer to the VM.
1090 * @param uVersion Saved state version.
1091 * @param patmInfo Saved PATM structure
1092 * @param pPatch Patch record
1093 * @param pRec Relocation record
1094 * @param offset Offset of referenced data/code
1095 * @param pFixup Fixup address
1096 */
1097static void patmCorrectFixup(PVM pVM, unsigned uVersion, PATM &patmInfo, PPATCHINFO pPatch, PRELOCREC pRec,
1098 int32_t offset, RTRCPTR *pFixup)
1099{
1100 int32_t delta = pVM->patm.s.pPatchMemGC - patmInfo.pPatchMemGC;
1101
1102 switch (pRec->uType)
1103 {
1104 case FIXUP_ABSOLUTE:
1105 case FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL:
1106 {
1107 Assert( pRec->uType != PATM_SAVED_STATE_VERSION_NO_RAW_MEM
1108 || (pRec->pSource == pRec->pDest && PATM_IS_FIXUP_TYPE(pRec->pSource)) );
1109
1110 /* bird: What is this for exactly? Only the MMIO fixups used to have pSource set. */
1111 if ( pRec->pSource
1112 && !PATMIsPatchGCAddr(pVM, (RTRCUINTPTR)pRec->pSource)
1113 && pRec->uType != FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL)
1114 break;
1115
1116 RTRCPTR const uFixup = *pFixup;
1117 if ( uFixup >= patmInfo.pGCStateGC
1118 && uFixup < patmInfo.pGCStateGC + sizeof(PATMGCSTATE))
1119 {
1120 LogFlow(("Changing absolute GCState at %RRv from %RRv to %RRv\n", patmInfo.pPatchMemGC + offset, uFixup, (uFixup - patmInfo.pGCStateGC) + pVM->patm.s.pGCStateGC));
1121 *pFixup = (uFixup - patmInfo.pGCStateGC) + pVM->patm.s.pGCStateGC;
1122 }
1123 else if ( uFixup >= patmInfo.pCPUMCtxGC
1124 && uFixup < patmInfo.pCPUMCtxGC + sizeof(CPUMCTX))
1125 {
1126 LogFlow(("Changing absolute CPUMCTX at %RRv from %RRv to %RRv\n", patmInfo.pPatchMemGC + offset, uFixup, (uFixup - patmInfo.pCPUMCtxGC) + pVM->patm.s.pCPUMCtxGC));
1127
1128 /* The CPUMCTX structure has completely changed, so correct the offsets too. */
1129 if (uVersion == PATM_SAVED_STATE_VERSION_VER16)
1130 {
1131 unsigned offCpumCtx = uFixup - patmInfo.pCPUMCtxGC;
1132
1133 /* ''case RT_OFFSETOF()'' does not work as gcc refuses to use & as a constant expression.
1134 * Defining RT_OFFSETOF as __builtin_offsetof for gcc would make this possible. But this
1135 * function is not available in older gcc versions, at least not in gcc-3.3 */
1136 if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr0))
1137 {
1138 LogFlow(("Changing dr[0] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[0])));
1139 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[0]);
1140 }
1141 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr1))
1142 {
1143 LogFlow(("Changing dr[1] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[1])));
1144 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[1]);
1145 }
1146 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr2))
1147 {
1148 LogFlow(("Changing dr[2] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[2])));
1149 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[2]);
1150 }
1151 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr3))
1152 {
1153 LogFlow(("Changing dr[3] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[3])));
1154 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[3]);
1155 }
1156 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr4))
1157 {
1158 LogFlow(("Changing dr[4] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[4])));
1159 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[4]);
1160 }
1161 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr5))
1162 {
1163 LogFlow(("Changing dr[5] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[5])));
1164 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[5]);
1165 }
1166 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr6))
1167 {
1168 LogFlow(("Changing dr[6] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[6])));
1169 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[6]);
1170 }
1171 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, dr7))
1172 {
1173 LogFlow(("Changing dr[7] offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, dr[7])));
1174 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, dr[7]);
1175 }
1176 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, cr0))
1177 {
1178 LogFlow(("Changing cr0 offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, cr0)));
1179 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, cr0);
1180 }
1181 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, cr2))
1182 {
1183 LogFlow(("Changing cr2 offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, cr2)));
1184 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, cr2);
1185 }
1186 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, cr3))
1187 {
1188 LogFlow(("Changing cr3 offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, cr3)));
1189 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, cr3);
1190 }
1191 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, cr4))
1192 {
1193 LogFlow(("Changing cr4 offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, cr4)));
1194 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, cr4);
1195 }
1196 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, tr))
1197 {
1198 LogFlow(("Changing tr offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, tr)));
1199 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, tr);
1200 }
1201 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, ldtr))
1202 {
1203 LogFlow(("Changing ldtr offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, ldtr)));
1204 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, ldtr);
1205 }
1206 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, gdtr.pGdt))
1207 {
1208 LogFlow(("Changing pGdt offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, gdtr.pGdt)));
1209 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, gdtr.pGdt);
1210 }
1211 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, gdtr.cbGdt))
1212 {
1213 LogFlow(("Changing cbGdt offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, gdtr.cbGdt)));
1214 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, gdtr.cbGdt);
1215 }
1216 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, idtr.pIdt))
1217 {
1218 LogFlow(("Changing pIdt offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, idtr.pIdt)));
1219 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, idtr.pIdt);
1220 }
1221 else if (offCpumCtx == (unsigned)RT_OFFSETOF(CPUMCTX_VER1_6, idtr.cbIdt))
1222 {
1223 LogFlow(("Changing cbIdt offset from %x to %x\n", offCpumCtx, RT_OFFSETOF(CPUMCTX, idtr.cbIdt)));
1224 *pFixup = pVM->patm.s.pCPUMCtxGC + RT_OFFSETOF(CPUMCTX, idtr.cbIdt);
1225 }
1226 else
1227 AssertMsgFailed(("Unexpected CPUMCTX offset %x\n", offCpumCtx));
1228 }
1229 else
1230 *pFixup = (uFixup - patmInfo.pCPUMCtxGC) + pVM->patm.s.pCPUMCtxGC;
1231 }
1232 else if ( uFixup >= patmInfo.pStatsGC
1233 && uFixup < patmInfo.pStatsGC + PATM_STAT_MEMSIZE)
1234 {
1235 LogFlow(("Changing absolute Stats at %RRv from %RRv to %RRv\n", patmInfo.pPatchMemGC + offset, uFixup, (uFixup - patmInfo.pStatsGC) + pVM->patm.s.pStatsGC));
1236 *pFixup = (uFixup - patmInfo.pStatsGC) + pVM->patm.s.pStatsGC;
1237 }
1238 else if ( uFixup >= patmInfo.pGCStackGC
1239 && uFixup < patmInfo.pGCStackGC + PATM_STACK_TOTAL_SIZE)
1240 {
1241 LogFlow(("Changing absolute Stack at %RRv from %RRv to %RRv\n", patmInfo.pPatchMemGC + offset, uFixup, (uFixup - patmInfo.pGCStackGC) + pVM->patm.s.pGCStackGC));
1242 *pFixup = (uFixup - patmInfo.pGCStackGC) + pVM->patm.s.pGCStackGC;
1243 }
1244 else if ( uFixup >= patmInfo.pPatchMemGC
1245 && uFixup < patmInfo.pPatchMemGC + patmInfo.cbPatchMem)
1246 {
1247 LogFlow(("Changing absolute PatchMem at %RRv from %RRv to %RRv\n", patmInfo.pPatchMemGC + offset, uFixup, (uFixup - patmInfo.pPatchMemGC) + pVM->patm.s.pPatchMemGC));
1248 *pFixup = (uFixup - patmInfo.pPatchMemGC) + pVM->patm.s.pPatchMemGC;
1249 }
1250 /*
1251 * For PATM_SAVED_STATE_VERSION_FIXUP_HACK and earlier boldly ASSUME:
1252 * 1. That pCPUMCtxGC is in the VM structure and that its location is
1253 * at the first page of the same 4 MB chunk.
1254 * 2. That the forced actions were in the first 32 bytes of the VM
1255 * structure.
1256 * 3. That the CPUM leaves are less than 8KB into the structure.
1257 */
1258 else if ( uVersion <= PATM_SAVED_STATE_VERSION_FIXUP_HACK
1259 && uFixup - (patmInfo.pCPUMCtxGC & UINT32_C(0xffc00000)) < UINT32_C(32))
1260 {
1261 LogFlow(("Changing fLocalForcedActions fixup from %RRv to %RRv\n", uFixup, pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions)));
1262 *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
1263 pRec->pSource = pRec->pDest = PATM_VM_FORCEDACTIONS;
1264 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1265 }
1266 else if ( uVersion <= PATM_SAVED_STATE_VERSION_FIXUP_HACK
1267 && uFixup - (patmInfo.pCPUMCtxGC & UINT32_C(0xffc00000)) < UINT32_C(8192))
1268 {
1269 static int cCpuidFixup = 0;
1270
1271 /* Very dirty assumptions about the cpuid patch and cpuid ordering. */
1272 switch (cCpuidFixup & 3)
1273 {
1274 case 0:
1275 *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
1276 pRec->pSource = pRec->pDest = PATM_CPUID_DEF_PTR;
1277 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1278 break;
1279 case 1:
1280 *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
1281 pRec->pSource = pRec->pDest = PATM_CPUID_STD_PTR;
1282 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1283 break;
1284 case 2:
1285 *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
1286 pRec->pSource = pRec->pDest = PATM_CPUID_EXT_PTR;
1287 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1288 break;
1289 case 3:
1290 *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
1291 pRec->pSource = pRec->pDest = PATM_CPUID_CENTAUR_PTR;
1292 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1293 break;
1294 }
1295 LogFlow(("Changing cpuid fixup %d from %RRv to %RRv\n", cCpuidFixup, uFixup, *pFixup));
1296 cCpuidFixup++;
1297 }
1298 /*
1299 * For PATM_SAVED_STATE_VERSION_MEM thru PATM_SAVED_STATE_VERSION_NO_RAW_MEM
1300 * we abused Core.Key to store the type for fixups needing correcting on load.
1301 */
1302 else if ( uVersion >= PATM_SAVED_STATE_VERSION_MEM
1303 && uVersion <= PATM_SAVED_STATE_VERSION_NO_RAW_MEM)
1304 {
1305 /* Core.Key abused to store the type of fixup. */
1306 switch ((uintptr_t)pRec->Core.Key)
1307 {
1308 case PATM_FIXUP_CPU_FF_ACTION:
1309 *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
1310 pRec->pSource = pRec->pDest = PATM_VM_FORCEDACTIONS;
1311 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1312 LogFlow(("Changing cpu ff action fixup from %x to %x\n", uFixup, *pFixup));
1313 break;
1314 case PATM_FIXUP_CPUID_DEFAULT:
1315 *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
1316 pRec->pSource = pRec->pDest = PATM_CPUID_DEF_PTR;
1317 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1318 LogFlow(("Changing cpuid def fixup from %x to %x\n", uFixup, *pFixup));
1319 break;
1320 case PATM_FIXUP_CPUID_STANDARD:
1321 *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
1322 pRec->pSource = pRec->pDest = PATM_CPUID_STD_PTR;
1323 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1324 LogFlow(("Changing cpuid std fixup from %x to %x\n", uFixup, *pFixup));
1325 break;
1326 case PATM_FIXUP_CPUID_EXTENDED:
1327 *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
1328 pRec->pSource = pRec->pDest = PATM_CPUID_EXT_PTR;
1329 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1330 LogFlow(("Changing cpuid ext fixup from %x to %x\n", uFixup, *pFixup));
1331 break;
1332 case PATM_FIXUP_CPUID_CENTAUR:
1333 *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
1334 pRec->pSource = pRec->pDest = PATM_CPUID_CENTAUR_PTR;
1335 pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL;
1336 LogFlow(("Changing cpuid centaur fixup from %x to %x\n", uFixup, *pFixup));
1337 break;
1338 default:
1339 AssertMsgFailed(("Unexpected fixup value %p\n", (uintptr_t)pRec->Core.Key));
1340 break;
1341 }
1342 }
1343 /*
1344 * After PATM_SAVED_STATE_VERSION_NO_RAW_MEM we changed the fixup type
1345 * and instead put the patch fixup code in the source and target addresses.
1346 */
1347 else if ( uVersion > PATM_SAVED_STATE_VERSION_NO_RAW_MEM
1348 && pRec->uType == FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL)
1349 {
1350 Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource));
1351 switch (pRec->pSource)
1352 {
1353 case PATM_VM_FORCEDACTIONS:
1354 *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
1355 break;
1356 case PATM_CPUID_DEF_PTR:
1357 *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM);
1358 break;
1359 case PATM_CPUID_ARRAY_PTR:
1360 *pFixup = CPUMR3GetGuestCpuIdPatmArrayRCPtr(pVM);
1361 break;
1362 case PATM_CPUID_ARRAY_END_PTR:
1363 *pFixup = CPUMR3GetGuestCpuIdPatmArrayEndRCPtr(pVM);
1364 break;
1365 case PATM_CPUID_ARRAY_ENTRY_SIZE:
1366 *pFixup = sizeof(CPUMCPUIDLEAF);
1367 break;
1368 case PATM_CPUID_UNKNOWN_METHOD:
1369 *pFixup = CPUMR3GetGuestCpuIdPatmUnknownLeafMethod(pVM);
1370 break;
1371 case PATM_CPUID_STD_PTR: /* Saved again patches only. */
1372 *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM);
1373 break;
1374 case PATM_CPUID_EXT_PTR: /* Saved again patches only. */
1375 *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM);
1376 break;
1377 case PATM_CPUID_CENTAUR_PTR: /* Saved again patches only. */
1378 *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM);
1379 break;
1380 }
1381 }
1382
1383#ifdef RT_OS_WINDOWS
1384 AssertCompile(RT_OFFSETOF(VM, fGlobalForcedActions) < 32);
1385#endif
1386 break;
1387 }
1388
1389 case FIXUP_REL_JMPTOPATCH:
1390 {
1391 RTRCPTR pTarget = (RTRCPTR)((RTRCINTPTR)pRec->pDest + delta);
1392
1393 if ( pPatch->uState == PATCH_ENABLED
1394 && (pPatch->flags & PATMFL_PATCHED_GUEST_CODE))
1395 {
1396 uint8_t oldJump[SIZEOF_NEAR_COND_JUMP32];
1397 uint8_t temp[SIZEOF_NEAR_COND_JUMP32];
1398 RTRCPTR pJumpOffGC;
1399 RTRCINTPTR displ = (RTRCINTPTR)pTarget - (RTRCINTPTR)pRec->pSource;
1400 RTRCINTPTR displOld= (RTRCINTPTR)pRec->pDest - (RTRCINTPTR)pRec->pSource;
1401
1402 Log(("Relative fixup (g2p) %08X -> %08X at %08X (source=%08x, target=%08x)\n", *(int32_t*)pRec->pRelocPos, displ, pRec->pRelocPos, pRec->pSource, pRec->pDest));
1403
1404 Assert(pRec->pSource - pPatch->cbPatchJump == pPatch->pPrivInstrGC);
1405#ifdef PATM_RESOLVE_CONFLICTS_WITH_JUMP_PATCHES
1406 if (pPatch->cbPatchJump == SIZEOF_NEAR_COND_JUMP32)
1407 {
1408 Assert(pPatch->flags & PATMFL_JUMP_CONFLICT);
1409
1410 pJumpOffGC = pPatch->pPrivInstrGC + 2; //two byte opcode
1411 oldJump[0] = pPatch->aPrivInstr[0];
1412 oldJump[1] = pPatch->aPrivInstr[1];
1413 *(RTRCUINTPTR *)&oldJump[2] = displOld;
1414 }
1415 else
1416#endif
1417 if (pPatch->cbPatchJump == SIZEOF_NEARJUMP32)
1418 {
1419 pJumpOffGC = pPatch->pPrivInstrGC + 1; //one byte opcode
1420 oldJump[0] = 0xE9;
1421 *(RTRCUINTPTR *)&oldJump[1] = displOld;
1422 }
1423 else
1424 {
1425 AssertMsgFailed(("Invalid patch jump size %d\n", pPatch->cbPatchJump));
1426 break;
1427 }
1428 Assert(pPatch->cbPatchJump <= sizeof(temp));
1429
1430 /*
1431 * Read old patch jump and compare it to the one we previously installed
1432 */
1433 int rc = PGMPhysSimpleReadGCPtr(VMMGetCpu0(pVM), temp, pPatch->pPrivInstrGC, pPatch->cbPatchJump);
1434 Assert(RT_SUCCESS(rc) || rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT);
1435
1436 if (rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT)
1437 {
1438 RTRCPTR pPage = pPatch->pPrivInstrGC & PAGE_BASE_GC_MASK;
1439
1440 rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_ALL, pPage, pPage + (PAGE_SIZE - 1) /* inclusive! */, 0, patmVirtPageHandler, "PATMGCMonitorPage", 0, "PATMMonitorPatchJump");
1441 Assert(RT_SUCCESS(rc) || rc == VERR_PGM_HANDLER_VIRTUAL_CONFLICT);
1442 }
1443 else
1444 if (memcmp(temp, oldJump, pPatch->cbPatchJump))
1445 {
1446 Log(("PATM: Patch jump was overwritten -> disabling patch!!\n"));
1447 /*
1448 * Disable patch; this is not a good solution
1449 */
1450 /* @todo hopefully it was completely overwritten (if the read was successful)!!!! */
1451 pPatch->uState = PATCH_DISABLED;
1452 }
1453 else
1454 if (RT_SUCCESS(rc))
1455 {
1456 rc = PGMPhysSimpleDirtyWriteGCPtr(VMMGetCpu0(pVM), pJumpOffGC, &displ, sizeof(displ));
1457 AssertRC(rc);
1458 }
1459 else
1460 AssertMsgFailed(("Unexpected error %d from MMR3PhysReadGCVirt\n", rc));
1461 }
1462 else
1463 Log(("Skip the guest jump to patch code for this disabled patch %08X\n", pRec->pRelocPos));
1464
1465 pRec->pDest = pTarget;
1466 break;
1467 }
1468
1469 case FIXUP_REL_JMPTOGUEST:
1470 {
1471 RTRCPTR pSource = (RTRCPTR)((RTRCINTPTR)pRec->pSource + delta);
1472 RTRCINTPTR displ = (RTRCINTPTR)pRec->pDest - (RTRCINTPTR)pSource;
1473
1474 Assert(!(pPatch->flags & PATMFL_GLOBAL_FUNCTIONS));
1475 Log(("Relative fixup (p2g) %08X -> %08X at %08X (source=%08x, target=%08x)\n", *(int32_t*)pRec->pRelocPos, displ, pRec->pRelocPos, pRec->pSource, pRec->pDest));
1476 *(RTRCUINTPTR *)pRec->pRelocPos = displ;
1477 pRec->pSource = pSource;
1478 break;
1479
1480 }
1481}
1482}
1483
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette