PATMInternal.h@ 1

Last change on this file since 1 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.1 KB

Line
1	/** @file
2	*
3	* PATM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22	#ifndef __PATMInternal_h__
23	#define __PATMInternal_h__
24
25	#include <VBox/cdefs.h>
26	#include <VBox/types.h>
27	#include <VBox/patm.h>
28	#include <VBox/stam.h>
29	#include <VBox/dis.h>
30	#include <iprt/avl.h>
31	#include <iprt/param.h>
32	#include <VBox/log.h>
33
34	#if !defined(IN_PATM_R3) && !defined(IN_PATM_R0) && !defined(IN_PATM_GC)
35	# error "Not in PATM! This is an internal header!"
36	#endif
37
38
39	#define PATM_SSM_VERSION 47
40
41	/* Enable for call patching. */
42	#define PATM_ENABLE_CALL
43	#define PATCH_MEMORY_SIZE (210241024)
44	#define MAX_PATCH_SIZE (1024*4)
45
46	/*
47	* Internal patch type flags (starts at BIT(11))
48	*/
49
50	#define PATMFL_CHECK_SIZE BIT64(11)
51	#define PATMFL_FOUND_PATCHEND BIT64(12)
52	#define PATMFL_SINGLE_INSTRUCTION BIT64(13)
53	#define PATMFL_SYSENTER_XP BIT64(14)
54	#define PATMFL_JUMP_CONFLICT BIT64(15)
55	#define PATMFL_READ_ORIGINAL_BYTES BIT64(16) /** opcode might have already been patched */
56	#define PATMFL_INT3_REPLACEMENT BIT64(17)
57	#define PATMFL_SUPPORT_CALLS BIT64(18)
58	#define PATMFL_SUPPORT_INDIRECT_CALLS BIT64(19)
59	#define PATMFL_IDTHANDLER_WITHOUT_ENTRYPOINT BIT64(20) /** internal flag to avoid duplicate entrypoints */
60	#define PATMFL_INHIBIT_IRQS BIT64(21) /** temporary internal flag */
61	#define PATMFL_GENERATE_JUMPTOGUEST BIT64(22) /** temporary internal flag */
62	#define PATMFL_RECOMPILE_NEXT BIT64(23) /** for recompilation of the next instruction */
63	#define PATMFL_CODE_MONITORED BIT64(24) /** code pages of guest monitored for self-modifying code. */
64	#define PATMFL_CALLABLE_AS_FUNCTION BIT64(25) /** cli and pushf blocks can be used as callable functions. */
65	#define PATMFL_GLOBAL_FUNCTIONS BIT64(26) /** fake patch for global patm functions. */
66	#define PATMFL_TRAMPOLINE BIT64(27) /** trampoline patch that clears PATM_INTERRUPTFLAG and jumps to patch destination */
67	#define PATMFL_GENERATE_SETPIF BIT64(28) /** generate set PIF for the next instruction */
68	#define PATMFL_INSTR_HINT BIT64(29) /** Generate patch, but don't activate it. */
69	#define PATMFL_PATCHED_GUEST_CODE BIT64(30) /** Patched guest code. */
70	#define PATMFL_MUST_INSTALL_PATCHJMP BIT64(31) /** Need to patch guest code in order to activate patch. */
71	#define PATMFL_INT3_REPLACEMENT_BLOCK BIT64(32) /** int 3 replacement block */
72
73	#define SIZEOF_NEARJUMP8 2 //opcode byte + 1 byte relative offset
74	#define SIZEOF_NEARJUMP16 3 //opcode byte + 2 byte relative offset
75	#define SIZEOF_NEARJUMP32 5 //opcode byte + 4 byte relative offset
76	#define SIZEOF_NEAR_COND_JUMP32 6 //0xF + opcode byte + 4 byte relative offset
77
78	#define MAX_INSTR_SIZE 16
79
80	//Patch states
81	#define PATCH_REFUSED 1
82	#define PATCH_DISABLED 2
83	#define PATCH_ENABLED 4
84	#define PATCH_UNUSABLE 8
85	#define PATCH_DIRTY 16
86	#define PATCH_DISABLE_PENDING 32
87
88
89	#define MAX_PATCH_TRAPS 4
90	#define PATM_MAX_CALL_DEPTH 32
91	/* Maximum nr of writes before a patch is marked dirty. (disabled) */
92	#define PATM_MAX_CODE_WRITES 16
93	/* Maximum nr of invalid writes before a patch is disabled. */
94	#define PATM_MAX_INVALID_WRITES 65536
95
96	#define FIXUP_ABSOLUTE 0
97	#define FIXUP_REL_JMPTOPATCH 1
98	#define FIXUP_REL_JMPTOGUEST 2
99
100	#define PATM_ILLEGAL_DESTINATION 0xDEADBEEF
101
102	/** Size of the instruction that's used for requests from patch code (currently only call) */
103	#define PATM_ILLEGAL_INSTR_SIZE 2
104
105
106	/** No statistics counter index allocated just yet */
107	#define PATM_STAT_INDEX_NONE (uint32_t)-1
108	/** Dummy counter to handle overflows */
109	#define PATM_STAT_INDEX_DUMMY 0
110	#define PATM_STAT_INDEX_IS_VALID(a) (a != PATM_STAT_INDEX_DUMMY && a != PATM_STAT_INDEX_NONE)
111
112	#ifdef VBOX_WITH_STATISTICS
113	#define PATM_STAT_RUN_INC(pPatch) \
114	if (PATM_STAT_INDEX_IS_VALID((pPatch)->uPatchIdx)) \
115	CTXSUFF(pVM->patm.s.pStats)[(pPatch)->uPatchIdx].u32A++;
116	#define PATM_STAT_FAULT_INC(pPatch) \
117	if (PATM_STAT_INDEX_IS_VALID((pPatch)->uPatchIdx)) \
118	CTXSUFF(pVM->patm.s.pStats)[(pPatch)->uPatchIdx].u32B++;
119	#else
120	#define PATM_STAT_RUN_INC(pPatch) do { } while (0)
121	#define PATM_STAT_FAULT_INC(pPatch) do { } while (0)
122	#endif
123
124	/** Maximum number of stat counters. */
125	#define PATM_STAT_MAX_COUNTERS 1024
126	/** Size of memory allocated for patch statistics. */
127	#define PATM_STAT_MEMSIZE (PATM_STAT_MAX_COUNTERS*sizeof(STAMRATIOU32))
128
129
130	typedef struct
131	{
132	/** The key is a HC virtual address. */
133	AVLPVNODECORE Core;
134
135	uint32_t uType;
136	HCPTRTYPE(uint8_t *)pRelocPos;
137	RTGCPTR pSource;
138	RTGCPTR pDest;
139	} RELOCREC, *PRELOCREC;
140
141	typedef struct
142	{
143	HCPTRTYPE(uint8_t *) pPatchLocStartHC;
144	HCPTRTYPE(uint8_t *) pPatchLocEndHC;
145	GCPTRTYPE(uint8_t *) pGuestLoc;
146	uint32_t opsize;
147	} P2GLOOKUPREC, *PP2GLOOKUPREC;
148
149	typedef struct
150	{
151	/** The key is a GC virtual address. */
152	AVLPVNODECORE Core;
153
154	HCPTRTYPE(uint8_t *)pJumpHC;
155	GCPTRTYPE(uint8_t *)pTargetGC;
156	uint32_t offDispl;
157	uint32_t opcode;
158	} JUMPREC, *PJUMPREC;
159
160	/**
161	* Patch to guest lookup type (single or both direction)
162	*/
163	typedef enum
164	{
165	PATM_LOOKUP_PATCH2GUEST, /* patch to guest */
166	PATM_LOOKUP_BOTHDIR /* guest to patch + patch to guest */
167	} PATM_LOOKUP_TYPE;
168
169	/**
170	* Patch to guest address lookup record
171	*/
172	typedef struct RECPATCHTOGUEST
173	{
174	/** The key is an offset inside the patch memory block. */
175	AVLPVNODECORE Core;
176
177	RTGCPTR pOrgInstrGC;
178	PATM_LOOKUP_TYPE enmType;
179	bool fDirty;
180	uint8_t u8DirtyOpcode; /* original opcode before writing 0xCC there to mark it dirty */
181	} RECPATCHTOGUEST, *PRECPATCHTOGUEST;
182
183	/**
184	* Guest to patch address lookup record
185	*/
186	typedef struct RECGUESTTOPATCH
187	{
188	/** The key is a GC virtual address. */
189	AVLPVNODECORE Core;
190
191	RTGCUINTPTR PatchOffset;
192	} RECGUESTTOPATCH, *PRECGUESTTOPATCH;
193
194	/**
195	* Temporary information used in ring 3 only; no need to waste memory in the patch record itself.
196	*/
197	typedef struct
198	{
199	/* Temporary tree for storing the addresses of illegal instructions. */
200	HCPTRTYPE(PAVLPVNODECORE) IllegalInstrTree;
201	uint32_t nrIllegalInstr;
202
203	int32_t nrJumps;
204	uint32_t nrRetInstr;
205
206	/* Temporary tree of encountered jumps. (debug only) */
207	HCPTRTYPE(PAVLPVNODECORE) DisasmJumpTree;
208
209	int32_t nrCalls;
210
211	/** Last original guest instruction pointer; used for disassmebly log. */
212	RTGCPTR pLastDisasmInstrGC;
213
214	/** Keeping track of multiple ret instructions. */
215	RTGCPTR pPatchRetInstrGC;
216	uint32_t uPatchRetParam1;
217	} PATCHINFOTEMP, *PPATCHINFOTEMP;
218
219	typedef struct _PATCHINFO
220	{
221	uint32_t uState;
222	uint32_t uOldState;
223	uint32_t uOpMode;
224
225	HCPTRTYPE(uint8_t *) pPrivInstrHC; //HC pointer of privileged instruction
226	GCPTRTYPE(uint8_t *) pPrivInstrGC; //GC pointer of privileged instruction
227	uint8_t aPrivInstr[MAX_INSTR_SIZE];
228	uint32_t cbPrivInstr;
229	uint32_t opcode; //opcode for priv instr (OP_*)
230	uint32_t cbPatchJump; //patch jump size
231
232	/* Only valid for PATMFL_JUMP_CONFLICT patches */
233	RTGCPTR pPatchJumpDestGC;
234
235	RTGCUINTPTR pPatchBlockOffset;
236	uint32_t cbPatchBlockSize;
237	uint32_t uCurPatchOffset;
238
239	uint64_t flags;
240
241	/**
242	* Lowest and highest patched GC instruction address. To optimize searches.
243	*/
244	RTGCPTR pInstrGCLowest;
245	RTGCPTR pInstrGCHighest;
246
247	/* Tree of fixup records for the patch. */
248	HCPTRTYPE(PAVLPVNODECORE) FixupTree;
249	int32_t nrFixups;
250
251	/* Tree of jumps inside the generated patch code. */
252	HCPTRTYPE(PAVLPVNODECORE) JumpTree;
253	int32_t nrJumpRecs;
254
255	/**
256	* Lookup trees for determining the corresponding guest address of an
257	* instruction in the patch block.
258	*/
259	HCPTRTYPE(PAVLPVNODECORE) Patch2GuestAddrTree;
260	HCPTRTYPE(PAVLPVNODECORE) Guest2PatchAddrTree;
261	uint32_t nrPatch2GuestRecs;
262
263	// Cache record for PATMGCVirtToHCVirt
264	P2GLOOKUPREC cacheRec;
265
266	/* Temporary information during patch creation. Don't waste hypervisor memory for this. */
267	PPATCHINFOTEMP pTempInfo;
268
269	/* Count the number of writes to the corresponding guest code. */
270	uint32_t cCodeWrites;
271
272	/* Count the number of invalid writes to pages monitored for the patch. */
273	//some statistics to determine if we should keep this patch activated
274	uint32_t cTraps;
275
276	uint32_t cInvalidWrites;
277
278	// Index into the uPatchRun and uPatchTrap arrays (0..MAX_PATCHES-1)
279	uint32_t uPatchIdx;
280
281	/* First opcode byte, that's overwritten when a patch is marked dirty. */
282	uint8_t bDirtyOpcode;
283	} PATCHINFO, *PPATCHINFO;
284
285	#define PATCHCODE_PTR_GC(pPatch) (RTGCPTR) (pVM->patm.s.pPatchMemGC + (pPatch)->pPatchBlockOffset)
286	#define PATCHCODE_PTR_HC(pPatch) (uint8_t *)(pVM->patm.s.pPatchMemHC + (pPatch)->pPatchBlockOffset)
287
288	/**
289	* Lookup record for patches
290	*/
291	typedef struct PATMPATCHREC
292	{
293	/** The key is a GC virtual address. */
294	AVLOGCPTRNODECORE Core;
295	/** The key is a patch offset. */
296	AVLOGCPTRNODECORE CoreOffset;
297
298	PATCHINFO patch;
299	} PATMPATCHREC, *PPATMPATCHREC;
300
301	/** Increment for allocating room for pointer array */
302	#define PATMPATCHPAGE_PREALLOC_INCREMENT 16
303
304	/**
305	* Lookup record for patch pages
306	*/
307	typedef struct PATMPATCHPAGE
308	{
309	/** The key is a GC virtual address. */
310	AVLOGCPTRNODECORE Core;
311	/** Region to monitor. */
312	RTGCPTR pLowestAddrGC;
313	RTGCPTR pHighestAddrGC;
314	/** Number of patches for this page. */
315	uint32_t cCount;
316	/** Maximum nr of pointers in the array. */
317	uint32_t cMaxPatches;
318	/** Array of patch pointers for this page. */
319	PPATCHINFO *aPatch;
320	} PATMPATCHPAGE, *PPATMPATCHPAGE;
321
322	#define PATM_PATCHREC_FROM_COREOFFSET(a) (PPATMPATCHREC)((uintptr_t)a - RT_OFFSETOF(PATMPATCHREC, CoreOffset))
323	#define PATM_PATCHREC_FROM_PATCHINFO(a) (PPATMPATCHREC)((uintptr_t)a - RT_OFFSETOF(PATMPATCHREC, patch))
324
325	typedef struct PATMTREES
326	{
327	/**
328	* AVL tree with all patches (active or disabled) sorted by guest instruction address
329	*/
330	AVLOGCPTRTREE PatchTree;
331
332	/**
333	* AVL tree with all patches sorted by patch address (offset actually)
334	*/
335	AVLOGCPTRTREE PatchTreeByPatchAddr;
336
337	/**
338	* AVL tree with all pages which were (partly) patched
339	*/
340	AVLOGCPTRTREE PatchTreeByPage;
341
342	uint32_t align[1];
343	} PATMTREES, *PPATMTREES;
344
345	/**
346	* PATM VM Instance data.
347	* Changes to this must checked against the padding of the patm union in VM!
348	*/
349	typedef struct PATM
350	{
351	/** Offset to the VM structure.
352	* See PATM2VM(). */
353	RTINT offVM;
354
355	GCPTRTYPE(uint8_t *) pPatchMemGC;
356	HCPTRTYPE(uint8_t *) pPatchMemHC;
357	uint32_t cbPatchMem;
358	uint32_t offPatchMem;
359	bool fOutOfMemory;
360
361	int32_t deltaReloc;
362
363	/* GC PATM state pointers */
364	GCPTRTYPE(PPATMGCSTATE) pGCStateGC;
365	HCPTRTYPE(PPATMGCSTATE) pGCStateHC;
366
367	/** PATM stack page for call instruction execution. (2 parts: one for our private stack and one to store the original return address */
368	GCPTRTYPE(RTGCPTR *) pGCStackGC;
369	HCPTRTYPE(RTGCPTR *) pGCStackHC;
370
371	/** GC pointer to CPUMCTX structure. */
372	GCPTRTYPE(PCPUMCTX) pCPUMCtxGC;
373
374	/* GC statistics pointers */
375	GCPTRTYPE(PSTAMRATIOU32) pStatsGC;
376	HCPTRTYPE(PSTAMRATIOU32) pStatsHC;
377
378	/* Current free index value (uPatchRun/uPatchTrap arrays). */
379	uint32_t uCurrentPatchIdx;
380
381	/* Temporary counter for patch installation call depth. (in order not to go on forever) */
382	uint32_t ulCallDepth;
383
384	/** Number of page lookup records. */
385	uint32_t cPageRecords;
386
387	/**
388	* Lowest and highest patched GC instruction addresses. To optimize searches.
389	*/
390	RTGCPTR pPatchedInstrGCLowest;
391	RTGCPTR pPatchedInstrGCHighest;
392
393	/** Pointer to the patch tree for instructions replaced by 'int 3'. */
394	HCPTRTYPE(PPATMTREES) PatchLookupTreeHC;
395	GCPTRTYPE(PPATMTREES) PatchLookupTreeGC;
396
397	/** Global PATM lookup and call function (used by call patches). */
398	RTGCPTR pfnHelperCallGC;
399	/** Global PATM return function (used by ret patches). */
400	RTGCPTR pfnHelperRetGC;
401	/** Global PATM jump function (used by indirect jmp patches). */
402	RTGCPTR pfnHelperJumpGC;
403
404	/** Fake patch record for global functions. */
405	PPATMPATCHREC pGlobalPatchRec;
406
407	/** Pointer to original sysenter handler */
408	RTGCPTR pfnSysEnterGC;
409	/** Pointer to sysenter handler trampoline */
410	RTGCPTR pfnSysEnterPatchGC;
411	/** Sysenter patch index (for stats only) */
412	uint32_t uSysEnterPatchIdx;
413
414	// GC address of fault in monitored page (set by PATMGCMonitorPage, used by PATMR3HandleMonitoredPage)
415	RTGCPTR pvFaultMonitor;
416
417	/* Temporary information for pending MMIO patch. Set in GC or R0 context. */
418	struct
419	{
420	RTGCPHYS GCPhys;
421	RTGCPTR pCachedData;
422	} mmio;
423
424	/* Temporary storage during load/save state */
425	struct
426	{
427	PSSMHANDLE pSSM;
428	uint32_t cPatches;
429	} savedstate;
430
431	STAMCOUNTER StatNrOpcodeRead;
432	STAMCOUNTER StatDisabled;
433	STAMCOUNTER StatUnusable;
434	STAMCOUNTER StatEnabled;
435	STAMCOUNTER StatInstalled;
436	STAMCOUNTER StatInstalledFunctionPatches;
437	STAMCOUNTER StatInstalledTrampoline;
438	STAMCOUNTER StatInstalledJump;
439	STAMCOUNTER StatInt3Callable;
440	STAMCOUNTER StatInt3BlockRun;
441	STAMCOUNTER StatOverwritten;
442	STAMCOUNTER StatFixedConflicts;
443	STAMCOUNTER StatFlushed;
444	STAMCOUNTER StatPageBoundaryCrossed;
445	STAMCOUNTER StatMonitored;
446	STAMPROFILEADV StatHandleTrap;
447	STAMCOUNTER StatSwitchBack;
448	STAMCOUNTER StatSwitchBackFail;
449	STAMCOUNTER StatPATMMemoryUsed;
450	STAMCOUNTER StatDuplicateREQSuccess;
451	STAMCOUNTER StatDuplicateREQFailed;
452	STAMCOUNTER StatDuplicateUseExisting;
453	STAMCOUNTER StatFunctionFound;
454	STAMCOUNTER StatFunctionNotFound;
455	STAMPROFILEADV StatPatchWrite;
456	STAMPROFILEADV StatPatchWriteDetect;
457	STAMCOUNTER StatDirty;
458	STAMCOUNTER StatPushTrap;
459	STAMCOUNTER StatPatchWriteInterpreted;
460	STAMCOUNTER StatPatchWriteInterpretedFailed;
461
462	STAMCOUNTER StatSysEnter;
463	STAMCOUNTER StatSysExit;
464
465	STAMCOUNTER StatInstrDirty;
466	STAMCOUNTER StatInstrDirtyGood;
467	STAMCOUNTER StatInstrDirtyBad;
468
469	STAMCOUNTER StatPatchPageInserted;
470	STAMCOUNTER StatPatchPageRemoved;
471
472	STAMCOUNTER StatGenRet;
473	STAMCOUNTER StatGenRetReused;
474	STAMCOUNTER StatGenJump;
475	STAMCOUNTER StatGenCall;
476	STAMCOUNTER StatGenPopf;
477
478	STAMCOUNTER StatCheckPendingIRQ;
479
480	STAMCOUNTER StatFunctionLookupReplace;
481	STAMCOUNTER StatFunctionLookupInsert;
482	uint32_t StatU32FunctionMaxSlotsUsed;
483	} PATM, *PPATM;
484
485
486	/**
487	* Execute state save operation.
488	*
489	* @returns VBox status code.
490	* @param pVM VM Handle.
491	* @param pSSM SSM operation handle.
492	*/
493	DECLCALLBACK(int) patmr3Save(PVM pVM, PSSMHANDLE pSSM);
494
495
496	/**
497	* Execute state load operation.
498	*
499	* @returns VBox status code.
500	* @param pVM VM Handle.
501	* @param pSSM SSM operation handle.
502	* @param u32Version Data layout version.
503	*/
504	DECLCALLBACK(int) patmr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
505
506	#ifdef IN_RING3
507	RTGCPTR patmPatchGCPtr2GuestGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pPatchGC);
508	RTGCPTR patmGuestGCPtrToPatchGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t*)pInstrGC);
509	#endif
510
511	/* Add a patch to guest lookup record
512	*
513	* @param pVM The VM to operate on.
514	* @param pPatch Patch structure ptr
515	* @param pPatchInstrHC Guest context pointer to patch block
516	* @param pInstrGC Guest context pointer to privileged instruction
517	* @param enmType Lookup type
518	* @param fDirty Dirty flag
519	*
520	*/
521	void patmr3AddP2GLookupRecord(PVM pVM, PPATCHINFO pPatch, uint8_t *pPatchInstrHC, RTGCPTR pInstrGC, PATM_LOOKUP_TYPE enmType, bool fDirty=false);
522
523	/**
524	* Insert page records for all guest pages that contain instructions that were recompiled for this patch
525	*
526	* @returns VBox status code.
527	* @param pVM The VM to operate on.
528	* @param pPatch Patch record
529	*/
530	int patmInsertPatchPages(PVM pVM, PPATCHINFO pPatch);
531
532	/**
533	* Remove page records for all guest pages that contain instructions that were recompiled for this patch
534	*
535	* @returns VBox status code.
536	* @param pVM The VM to operate on.
537	* @param pPatch Patch record
538	*/
539	int patmRemovePatchPages(PVM pVM, PPATCHINFO pPatch);
540
541	/**
542	* Returns the GC address of the corresponding patch statistics counter
543	*
544	* @returns Stat address
545	* @param pVM The VM to operate on.
546	* @param pPatch Patch structure
547	*/
548	RTGCPTR patmPatchQueryStatAddress(PVM pVM, PPATCHINFO pPatch);
549
550	/**
551	* Remove patch for privileged instruction at specified location
552	*
553	* @returns VBox status code.
554	* @param pVM The VM to operate on.
555	* @param pPatchRec Patch record
556	* @param fForceRemove Remove all patches
557	*/
558	int PATMRemovePatch(PVM pVM, PPATMPATCHREC pPatchRec, bool fForceRemove);
559
560	/**
561	* Call for analysing the instructions following the privileged instr. for compliance with our heuristics
562	*
563	* @returns VBox status code.
564	* @param pVM The VM to operate on.
565	* @param pCpu CPU disassembly state
566	* @param pInstrHC Guest context pointer to privileged instruction
567	* @param pCurInstrHC Guest context pointer to current instruction
568	* @param pUserData User pointer
569	*
570	*/
571	typedef int (VBOXCALL PFN_PATMR3ANALYSE)(PVM pVM, DISCPUSTATE pCpu, GCPTRTYPE(uint8_t ) pInstrGC, GCPTRTYPE(uint8_t ) pCurInstrGC, void *pUserData);
572
573	/**
574	* Install guest OS specific patch
575	*
576	* @returns VBox status code.
577	* @param pVM The VM to operate on
578	* @param pCpu Disassembly state of instruction.
579	* @param pInstrGC GC Instruction pointer for instruction
580	* @param pInstrHC GC Instruction pointer for instruction
581	* @param pPatchRec Patch structure
582	*
583	*/
584	int PATMInstallGuestSpecificPatch(PVM pVM, PDISCPUSTATE pCpu, RTGCPTR pInstrGC, uint8_t *pInstrHC, PPATMPATCHREC pPatchRec);
585
586	/**
587	* Convert guest context address to host context pointer
588	*
589	* @returns VBox status code.
590	* @param pVM The VM to operate on.
591	* @param pPatch Patch block structure pointer
592	* @param pGCPtr Guest context pointer
593	*
594	* @returns Host context pointer or NULL in case of an error
595	*
596	*/
597	HCPTRTYPE(uint8_t ) PATMGCVirtToHCVirt(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t )pGCPtr);
598
599
600	/**
601	* Check if the instruction is patched as a duplicated function
602	*
603	* @returns patch record
604	* @param pVM The VM to operate on.
605	* @param pInstrGC Guest context point to the instruction
606	*
607	*/
608	PATMDECL(PPATMPATCHREC) PATMQueryFunctionPatch(PVM pVM, RTGCPTR pInstrGC);
609
610
611	/* Empty the specified tree (PV tree, MMR3 heap)
612	*
613	* @param pVM The VM to operate on.
614	* @param ppTree Tree to empty
615	*/
616	void patmEmptyTree(PVM pVM, PAVLPVNODECORE *ppTree);
617
618
619	/**
620	* Return the name of the patched instruction
621	*
622	* @returns instruction name
623	*
624	* @param opcode DIS instruction opcode
625	* @param fPatchFlags Patch flags
626	*/
627	PATMDECL(char *)patmGetInstructionString(uint32_t opcode, uint32_t fPatchFlags);
628
629
630	/**
631	* Read callback for disassembly function; supports reading bytes that cross a page boundary
632	*
633	* @returns VBox status code.
634	* @param pSrc GC source pointer
635	* @param pDest HC destination pointer
636	* @param size Number of bytes to read
637	* @param dwUserdata Callback specific user data (pCpu)
638	*
639	*/
640	int32_t patmReadBytes(RTHCUINTPTR pSrc, uint8_t *pDest, uint32_t size, RTHCUINTPTR dwUserdata);
641
642
643	#ifndef IN_GC
644
645	#define PATMREAD_RAWCODE 1 /* read code as-is */
646	#define PATMREAD_ORGCODE 2 /* read original guest opcode bytes; not the patched bytes */
647
648	/*
649	* Private structure used during disassembly
650	*/
651	typedef struct
652	{
653	PVM pVM;
654	PPATCHINFO pPatchInfo;
655	HCPTRTYPE(uint8_t *) pInstrHC;
656	RTGCPTR pInstrGC;
657	uint32_t fReadFlags;
658	} PATMDISASM, *PPATMDISASM;
659
660	inline bool PATMR3DISInstr(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RTGCPTR InstrGC,
661	uint8_t InstrHC, uint32_t pOpsize, char *pszOutput,
662	uint32_t fReadFlags = PATMREAD_ORGCODE)
663	{
664	PATMDISASM disinfo;
665	disinfo.pVM = pVM;
666	disinfo.pPatchInfo = pPatch;
667	disinfo.pInstrHC = InstrHC;
668	disinfo.pInstrGC = InstrGC;
669	disinfo.fReadFlags = fReadFlags;
670	(pCpu)->pfnReadBytes = patmReadBytes;
671	(pCpu)->dwUserData[0] = (RTHCUINTPTR)&disinfo;
672	return DISInstr(pCpu, InstrGC, 0, pOpsize, pszOutput);
673	}
674	#endif /* !IN_GC */
675
676	__BEGIN_DECLS
677	/**
678	* #PF Virtual Handler callback for Guest access a page monitored by PATM
679	*
680	* @returns VBox status code (appropritate for trap handling and GC return).
681	* @param pVM VM Handle.
682	* @param uErrorCode CPU Error code.
683	* @param pRegFrame Trap register frame.
684	* @param pvFault The fault address (cr2).
685	* @param pvRange The base address of the handled virtual range.
686	* @param offRange The offset of the access into this range.
687	* (If it's a EIP range this's the EIP, if not it's pvFault.)
688	*/
689	PATMGCDECL(int) PATMGCMonitorPage(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, void pvFault, void pvRange, uintptr_t offRange);
690
691	/**
692	* Find patch for privileged instruction at specified location
693	*
694	* @returns Patch structure pointer if found; else NULL
695	* @param pVM The VM to operate on.
696	* @param pInstr Guest context point to instruction that might lie within 5 bytes of an existing patch jump
697	* @param fIncludeHints Include hinted patches or not
698	*
699	*/
700	PPATCHINFO PATMFindActivePatchByEntrypoint(PVM pVM, RTGCPTR pInstrGC, bool fIncludeHints=false);
701
702	/**
703	* Patch cli/sti pushf/popf instruction block at specified location
704	*
705	* @returns VBox status code.
706	* @param pVM The VM to operate on.
707	* @param pInstrGC Guest context point to privileged instruction
708	* @param pInstrHC Host context point to privileged instruction
709	* @param uOpcode Instruction opcodee
710	* @param uOpSize Size of starting instruction
711	* @param pPatchRec Patch record
712	*
713	* @note returns failure if patching is not allowed or possible
714	*
715	*/
716	PATMR3DECL(int) PATMR3PatchBlock(PVM pVM, RTGCPTR pInstrGC, HCPTRTYPE(uint8_t *) pInstrHC,
717	uint32_t uOpcode, uint32_t uOpSize, PPATMPATCHREC pPatchRec);
718
719
720	/**
721	* Mark patch as dirty
722	*
723	* @returns VBox status code.
724	* @param pVM The VM to operate on.
725	* @param pPatch Patch record
726	*
727	* @note returns failure if patching is not allowed or possible
728	*
729	*/
730	PATMR3DECL(int) PATMR3MarkDirtyPatch(PVM pVM, PPATCHINFO pPatch);
731
732	/**
733	* Calculate the branch destination
734	*
735	* @returns branch destination or 0 if failed
736	* @param pCpu Disassembly state of instruction.
737	* @param pBranchInstrGC GC pointer of branch instruction
738	*/
739	inline RTGCPTR PATMResolveBranch(PDISCPUSTATE pCpu, RTGCPTR pBranchInstrGC)
740	{
741	uint32_t disp;
742	if (pCpu->param1.flags & USE_IMMEDIATE8_REL)
743	{
744	disp = (int32_t)(char)pCpu->param1.parval;
745	}
746	else
747	if (pCpu->param1.flags & USE_IMMEDIATE16_REL)
748	{
749	disp = (int32_t)(uint16_t)pCpu->param1.parval;
750	}
751	else
752	if (pCpu->param1.flags & USE_IMMEDIATE32_REL)
753	{
754	disp = (int32_t)pCpu->param1.parval;
755	}
756	else
757	{
758	Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
759	return 0;
760	}
761	#ifdef IN_GC
762	return (RTGCPTR)((uint8_t *)pBranchInstrGC + pCpu->opsize + disp);
763	#else
764	return pBranchInstrGC + pCpu->opsize + disp;
765	#endif
766	}
767
768	__END_DECLS
769
770	#ifdef DEBUG
771	int patmr3DisasmCallback(PVM pVM, DISCPUSTATE pCpu, GCPTRTYPE(uint8_t ) pInstrGC, GCPTRTYPE(uint8_t ) pCurInstrGC, void pUserData);
772	int patmr3DisasmCodeStream(PVM pVM, GCPTRTYPE(uint8_t ) pInstrGC, GCPTRTYPE(uint8_t ) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Analyse, void *pUserData);
773	#endif
774
775	#endif

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/PATM/PATMInternal.h@ 1

Download in other formats: