Index: /trunk/src/VBox/VMM/VMMR3/PATM.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PATM.cpp (revision 54763) +++ /trunk/src/VBox/VMM/VMMR3/PATM.cpp (revision 54764) @@ -784,5 +784,5 @@ { case FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL: - Assert(pRec->pDest == pRec->pSource); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource)); + Assert(pRec->pDest == pRec->pSource); Assert(PATM_IS_ASMFIX(pRec->pSource)); Log(("Absolute patch template fixup type %#x at %RHv -> %RHv at %RRv\n", pRec->pSource, *(RTRCUINTPTR *)pRec->pRelocPos, *(RTRCINTPTR*)pRec->pRelocPos + delta, pRec->pRelocPos)); *(RTRCUINTPTR *)pRec->pRelocPos += delta; @@ -942,5 +942,5 @@ /* Only applicable when loading state. */ Assert(pRec->pDest == pRec->pSource); - Assert(PATM_IS_FIXUP_TYPE(pRec->pSource)); + Assert(PATM_IS_ASMFIX(pRec->pSource)); break; @@ -3606,5 +3606,5 @@ if (pPatchTargetGC) { - /* Create a trampoline that also sets PATM_INTERRUPTFLAG. */ + /* Create a trampoline that also sets PATM_ASMFIX_INTERRUPTFLAG. */ rc = PATMR3InstallPatch(pVM, pBranchTarget, PATMFL_CODE32 | PATMFL_TRAMPOLINE); } Index: /trunk/src/VBox/VMM/VMMR3/PATMA.asm =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PATMA.asm (revision 54763) +++ /trunk/src/VBox/VMM/VMMR3/PATMA.asm (revision 54764) @@ -208,10 +208,10 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMStats - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf - inc dword [ss:PATM_ALLPATCHCALLS] - inc dword [ss:PATM_PERPATCHCALLS] + inc dword [ss:PATM_ASMFIX_ALLPATCHCALLS] + inc dword [ss:PATM_ASMFIX_PERPATCHCALLS] popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMStats @@ -220,8 +220,8 @@ GLOBALNAME g_patmStatsRecord PATCHASMRECORD_INIT PATMStats, 4 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_ALLPATCHCALLS, 0 - DD PATM_PERPATCHCALLS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_ALLPATCHCALLS, 0 + DD PATM_ASMFIX_PERPATCHCALLS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh %endif ; VBOX_WITH_STATISTICS @@ -229,20 +229,20 @@ ; -; Set PATM_INTERRUPTFLAG +; Set PATM_ASMFIX_INTERRUPTFLAG ; BEGIN_PATCH_CODE_SECTION BEGINPROC PATMSetPIF - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMSetPIF -; Patch record for setting PATM_INTERRUPTFLAG +; Patch record for setting PATM_ASMFIX_INTERRUPTFLAG BEGIN_PATCH_RODATA_SECTION GLOBALNAME g_patmSetPIFRecord PATCHASMRECORD_INIT PATMSetPIF, 1 - DD PATM_INTERRUPTFLAG, 0 - DD 0ffffffffh, 0ffffffffh - -; -; Clear PATM_INTERRUPTFLAG + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD 0ffffffffh, 0ffffffffh + +; +; Clear PATM_ASMFIX_INTERRUPTFLAG ; BEGIN_PATCH_CODE_SECTION @@ -251,39 +251,39 @@ not dword [esp-64] not dword [esp-64] - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 ENDPROC PATMClearPIF -; Patch record for clearing PATM_INTERRUPTFLAG +; Patch record for clearing PATM_ASMFIX_INTERRUPTFLAG BEGIN_PATCH_RODATA_SECTION GLOBALNAME g_patmClearPIFRecord PATCHASMRECORD_INIT PATMClearPIF, 1 - DD PATM_INTERRUPTFLAG, 0 - DD 0ffffffffh, 0ffffffffh - -; -; Clear PATM_INHIBITIRQADDR and fault if IF=0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD 0ffffffffh, 0ffffffffh + +; +; Clear PATM_ASMFIX_INHIBITIRQADDR and fault if IF=0 ; BEGIN_PATCH_CODE_SECTION BEGINPROC PATMClearInhibitIRQFaultIF0 - mov dword [ss:PATM_INTERRUPTFLAG], 0 - mov dword [ss:PATM_INHIBITIRQADDR], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INHIBITIRQADDR], 0 pushf - test dword [ss:PATM_VMFLAGS], X86_EFL_IF + test dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF jz PATMClearInhibitIRQFaultIF0_Fault ; if interrupts are pending, then we must go back to the host context to handle them! - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST jz PATMClearInhibitIRQFaultIF0_Continue ; Go to our hypervisor trap handler to dispatch the pending irq - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_EDI], edi - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EDI], edi + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI mov eax, PATM_ACTION_DISPATCH_PENDING_IRQ - lock or dword [ss:PATM_PENDINGACTION], eax - mov ecx, PATM_ACTION_MAGIC - mov edi, PATM_NEXTINSTRADDR + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax + mov ecx, PATM_ACTION_MAGIC + mov edi, PATM_ASMFIX_NEXTINSTRADDR popfd ; restore flags we pushed above (the or instruction changes the flags as well) db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -292,56 +292,56 @@ PATMClearInhibitIRQFaultIF0_Fault: popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 PATMClearInhibitIRQFaultIF0_Continue: popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMClearInhibitIRQFaultIF0 -; Patch record for clearing PATM_INHIBITIRQADDR +; Patch record for clearing PATM_ASMFIX_INHIBITIRQADDR BEGIN_PATCH_RODATA_SECTION GLOBALNAME g_patmClearInhibitIRQFaultIF0Record PATCHASMRECORD_INIT PATMClearInhibitIRQFaultIF0, 12 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INHIBITIRQADDR, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_EDI, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_NEXTINSTRADDR, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD 0ffffffffh, 0ffffffffh - - -; -; Clear PATM_INHIBITIRQADDR and continue if IF=0 (duplicated function only; never jump back to guest code afterwards!!) + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INHIBITIRQADDR, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_EDI, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_NEXTINSTRADDR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD 0ffffffffh, 0ffffffffh + + +; +; Clear PATM_ASMFIX_INHIBITIRQADDR and continue if IF=0 (duplicated function only; never jump back to guest code afterwards!!) ; BEGIN_PATCH_CODE_SECTION BEGINPROC PATMClearInhibitIRQContIF0 - mov dword [ss:PATM_INTERRUPTFLAG], 0 - mov dword [ss:PATM_INHIBITIRQADDR], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INHIBITIRQADDR], 0 pushf - test dword [ss:PATM_VMFLAGS], X86_EFL_IF + test dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF jz PATMClearInhibitIRQContIF0_Continue ; if interrupts are pending, then we must go back to the host context to handle them! - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST jz PATMClearInhibitIRQContIF0_Continue ; Go to our hypervisor trap handler to dispatch the pending irq - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_EDI], edi - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EDI], edi + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI mov eax, PATM_ACTION_DISPATCH_PENDING_IRQ - lock or dword [ss:PATM_PENDINGACTION], eax - mov ecx, PATM_ACTION_MAGIC - mov edi, PATM_NEXTINSTRADDR + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax + mov ecx, PATM_ACTION_MAGIC + mov edi, PATM_ASMFIX_NEXTINSTRADDR popfd ; restore flags we pushed above (the or instruction changes the flags as well) db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -350,22 +350,22 @@ PATMClearInhibitIRQContIF0_Continue: popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMClearInhibitIRQContIF0 -; Patch record for clearing PATM_INHIBITIRQADDR +; Patch record for clearing PATM_ASMFIX_INHIBITIRQADDR BEGIN_PATCH_RODATA_SECTION GLOBALNAME g_patmClearInhibitIRQContIF0Record PATCHASMRECORD_INIT PATMClearInhibitIRQContIF0, 11 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INHIBITIRQADDR, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_EDI, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_NEXTINSTRADDR, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INHIBITIRQADDR, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_EDI, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_NEXTINSTRADDR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -376,5 +376,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMCliReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf %ifdef PATM_LOG_PATCHINSTR @@ -382,5 +382,5 @@ push ecx mov eax, PATM_ACTION_LOG_CLI - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -389,11 +389,11 @@ %endif - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IF + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IF popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMCliJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMCliReplacement @@ -406,10 +406,10 @@ PATCHASMRECORD_INIT_JUMP PATMCliReplacement, PATMCliJump, 3 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -420,6 +420,6 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMStiReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 - mov dword [ss:PATM_INHIBITIRQADDR], PATM_NEXTINSTRADDR + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INHIBITIRQADDR], PATM_ASMFIX_NEXTINSTRADDR pushf %ifdef PATM_LOG_PATCHINSTR @@ -427,5 +427,5 @@ push ecx mov eax, PATM_ACTION_LOG_STI - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -433,7 +433,7 @@ pop eax %endif - or dword [ss:PATM_VMFLAGS], X86_EFL_IF + or dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMStiReplacement @@ -446,12 +446,12 @@ PATCHASMRECORD_INIT PATMStiReplacement, 5 %endif - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INHIBITIRQADDR, 0 - DD PATM_NEXTINSTRADDR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INHIBITIRQADDR, 0 + DD PATM_ASMFIX_NEXTINSTRADDR, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -472,5 +472,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMTrapEntry - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf @@ -481,5 +481,5 @@ lea edx, dword [ss:esp+12+4] ;3 dwords + pushed flags -> iret eip mov eax, PATM_ACTION_LOG_GATE_ENTRY - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -502,5 +502,5 @@ ; correct EFLAGS on the stack to include the current IOPL push eax - mov eax, dword [ss:PATM_VMFLAGS] + mov eax, dword [ss:PATM_ASMFIX_VMFLAGS] and eax, X86_EFL_IOPL and dword [esp+16], ~X86_EFL_IOPL ; esp+16 = eflags = esp+8+4(efl)+4(eax) @@ -509,8 +509,8 @@ popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMTrapEntryJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMTrapEntry @@ -523,10 +523,10 @@ PATCHASMRECORD_INIT_JUMP PATMTrapEntry, PATMTrapEntryJump, 3 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHIRET - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -549,5 +549,5 @@ BEGINPROC PATMTrapEntryErrorCode PATMTrapErrorCodeEntryStart: - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf @@ -558,5 +558,5 @@ lea edx, dword [ss:esp+12+4+4] ;3 dwords + pushed flags + error code -> iret eip mov eax, PATM_ACTION_LOG_GATE_ENTRY - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -579,5 +579,5 @@ ; correct EFLAGS on the stack to include the current IOPL push eax - mov eax, dword [ss:PATM_VMFLAGS] + mov eax, dword [ss:PATM_ASMFIX_VMFLAGS] and eax, X86_EFL_IOPL and dword [esp+20], ~X86_EFL_IOPL ; esp+20 = eflags = esp+8+4(efl)+4(error code)+4(eax) @@ -586,8 +586,8 @@ popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMTrapErrorCodeEntryJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMTrapEntryErrorCode @@ -600,10 +600,10 @@ PATCHASMRECORD_INIT_JUMP PATMTrapEntryErrorCode, PATMTrapErrorCodeEntryJump, 3 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHIRET - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -624,5 +624,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMIntEntry - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf @@ -633,5 +633,5 @@ lea edx, dword [ss:esp+12+4] ;3 dwords + pushed flags -> iret eip mov eax, PATM_ACTION_LOG_GATE_ENTRY - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -654,5 +654,5 @@ ; correct EFLAGS on the stack to include the current IOPL push eax - mov eax, dword [ss:PATM_VMFLAGS] + mov eax, dword [ss:PATM_ASMFIX_VMFLAGS] and eax, X86_EFL_IOPL and dword [esp+16], ~X86_EFL_IOPL ; esp+16 = eflags = esp+8+4(efl)+4(eax) @@ -661,5 +661,5 @@ popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMIntEntry @@ -672,10 +672,10 @@ PATCHASMRECORD_INIT PATMIntEntry, 3 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHIRET - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -697,5 +697,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMIntEntryErrorCode - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf @@ -706,5 +706,5 @@ lea edx, dword [ss:esp+12+4+4] ;3 dwords + pushed flags + error code -> iret eip mov eax, PATM_ACTION_LOG_GATE_ENTRY - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -727,5 +727,5 @@ ; correct EFLAGS on the stack to include the current IOPL push eax - mov eax, dword [ss:PATM_VMFLAGS] + mov eax, dword [ss:PATM_ASMFIX_VMFLAGS] and eax, X86_EFL_IOPL and dword [esp+20], ~X86_EFL_IOPL ; esp+20 = eflags = esp+8+4(efl)+4(eax)+4(error code) @@ -734,5 +734,5 @@ popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMIntEntryErrorCode @@ -745,10 +745,10 @@ PATCHASMRECORD_INIT PATMIntEntryErrorCode, 3 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHIRET - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -759,5 +759,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPopf32Replacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 %ifdef PATM_LOG_PATCHINSTR push eax @@ -769,5 +769,5 @@ PATMPopf32_Log: - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -778,5 +778,5 @@ test dword [esp], X86_EFL_IF jnz PATMPopf32_Ok - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -785,19 +785,19 @@ ; In this particular patch it's rather unlikely the pushf was included, so we have no way to check if the flags on the stack were correctly synced ; PATMPopf32Replacement_NoExit is different, because it's only used in IDT and function patches - or dword [ss:PATM_VMFLAGS], X86_EFL_IF + or dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF ; if interrupts are pending, then we must go back to the host context to handle them! - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST jz PATMPopf32_Continue ; Go to our hypervisor trap handler to dispatch the pending irq - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_EDI], edi - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EDI], edi + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI mov eax, PATM_ACTION_DISPATCH_PENDING_IRQ - lock or dword [ss:PATM_PENDINGACTION], eax - mov ecx, PATM_ACTION_MAGIC - mov edi, PATM_NEXTINSTRADDR + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax + mov ecx, PATM_ACTION_MAGIC + mov edi, PATM_ASMFIX_NEXTINSTRADDR popfd ; restore flags we pushed above (the or instruction changes the flags as well) @@ -807,8 +807,8 @@ PATMPopf32_Continue: popfd ; restore flags we pushed above - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMPopf32Jump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMPopf32Replacement @@ -821,18 +821,18 @@ PATCHASMRECORD_INIT_JUMP PATMPopf32Replacement, PATMPopf32Jump, 11 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_EDI, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_NEXTINSTRADDR, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_EDI, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_NEXTINSTRADDR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -843,5 +843,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPopf32Replacement_NoExit - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 %ifdef PATM_LOG_PATCHINSTR push eax @@ -853,5 +853,5 @@ PATMPopf32_NoExitLog: - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -863,19 +863,19 @@ ; if interrupts are pending, then we must go back to the host context to handle them! - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST jz PATMPopf32_NoExit_Continue ; Go to our hypervisor trap handler to dispatch the pending irq - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_EDI], edi - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EDI], edi + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI mov eax, PATM_ACTION_DISPATCH_PENDING_IRQ - lock or dword [ss:PATM_PENDINGACTION], eax - mov ecx, PATM_ACTION_MAGIC - mov edi, PATM_NEXTINSTRADDR - - pop dword [ss:PATM_VMFLAGS] ; restore flags now (the or instruction changes the flags as well) - push dword [ss:PATM_VMFLAGS] + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax + mov ecx, PATM_ACTION_MAGIC + mov edi, PATM_ASMFIX_NEXTINSTRADDR + + pop dword [ss:PATM_ASMFIX_VMFLAGS] ; restore flags now (the or instruction changes the flags as well) + push dword [ss:PATM_ASMFIX_VMFLAGS] popfd @@ -884,8 +884,8 @@ PATMPopf32_NoExit_Continue: - pop dword [ss:PATM_VMFLAGS] - push dword [ss:PATM_VMFLAGS] - popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + pop dword [ss:PATM_ASMFIX_VMFLAGS] + push dword [ss:PATM_ASMFIX_VMFLAGS] + popfd + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMPopf32Replacement_NoExit @@ -898,20 +898,20 @@ PATCHASMRECORD_INIT PATMPopf32Replacement_NoExit, 13 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_EDI, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_NEXTINSTRADDR, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_EDI, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_NEXTINSTRADDR, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -922,8 +922,8 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPopf16Replacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 test word [esp], X86_EFL_IF jnz PATMPopf16_Ok - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -931,23 +931,23 @@ ; if interrupts are pending, then we must go back to the host context to handle them! ; @note we destroy the flags here, but that should really not matter (PATM_INT3 case) - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST jz PATMPopf16_Continue - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 PATMPopf16_Continue: - pop word [ss:PATM_VMFLAGS] - push word [ss:PATM_VMFLAGS] - and dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK - or dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK + pop word [ss:PATM_ASMFIX_VMFLAGS] + push word [ss:PATM_ASMFIX_VMFLAGS] + and dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK + or dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK DB 0x66 ; size override popf ;after the and and or operations!! (flags must be preserved) - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMPopf16Jump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMPopf16Replacement @@ -956,13 +956,13 @@ GLOBALNAME g_patmPopf16Record PATCHASMRECORD_INIT_JUMP PATMPopf16Replacement, PATMPopf16Jump, 9 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -974,8 +974,8 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPopf16Replacement_NoExit - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 test word [esp], X86_EFL_IF jnz PATMPopf16_Ok_NoExit - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -983,19 +983,19 @@ ; if interrupts are pending, then we must go back to the host context to handle them! ; @note we destroy the flags here, but that should really not matter (PATM_INT3 case) - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST jz PATMPopf16_Continue_NoExit - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 PATMPopf16_Continue_NoExit: - pop word [ss:PATM_VMFLAGS] - push word [ss:PATM_VMFLAGS] - and dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK - or dword [ss:PATM_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK + pop word [ss:PATM_ASMFIX_VMFLAGS] + push word [ss:PATM_ASMFIX_VMFLAGS] + and dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK + or dword [ss:PATM_ASMFIX_VMFLAGS], PATM_VIRTUAL_FLAGS_MASK DB 0x66 ; size override popf ;after the and and or operations!! (flags must be preserved) - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMPopf16Replacement_NoExit @@ -1004,13 +1004,13 @@ GLOBALNAME g_patmPopf16Record_NoExit PATCHASMRECORD_INIT PATMPopf16Replacement_NoExit, 9 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1021,5 +1021,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPushf32Replacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushfd %ifdef PATM_LOG_PATCHINSTR @@ -1027,5 +1027,5 @@ push ecx mov eax, PATM_ACTION_LOG_PUSHF - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -1038,9 +1038,9 @@ mov eax, dword [esp+8] and eax, PATM_FLAGS_MASK - or eax, dword [ss:PATM_VMFLAGS] + or eax, dword [ss:PATM_ASMFIX_VMFLAGS] mov dword [esp+8], eax pop eax popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMPushf32Replacement @@ -1053,10 +1053,10 @@ PATCHASMRECORD_INIT PATMPushf32Replacement, 3 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1067,5 +1067,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPushf16Replacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 DB 0x66 ; size override pushf @@ -1076,5 +1076,5 @@ mov ax, word [esp+6] and eax, PATM_FLAGS_MASK - or eax, dword [ss:PATM_VMFLAGS] + or eax, dword [ss:PATM_ASMFIX_VMFLAGS] mov word [esp+6], ax pop eax @@ -1082,5 +1082,5 @@ DB 0x66 ; size override popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMPushf16Replacement @@ -1089,7 +1089,7 @@ GLOBALNAME g_patmPushf16Record PATCHASMRECORD_INIT PATMPushf16Replacement, 3 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1100,5 +1100,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMPushCSReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 push cs pushfd @@ -1113,8 +1113,8 @@ popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMPushCSJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMPushCSReplacement @@ -1123,6 +1123,6 @@ GLOBALNAME g_patmPushCSRecord PATCHASMRECORD_INIT_JUMP PATMPushCSReplacement, PATMPushCSJump, 2 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1163,5 +1163,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMIretReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushfd @@ -1172,5 +1172,5 @@ lea edx, dword [ss:esp+12+4] ;3 dwords + pushed flags -> iret eip mov eax, PATM_ACTION_LOG_IRET - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -1204,16 +1204,16 @@ ; Note: This is very important as pending pic interrupts can be overridden by apic interrupts if we don't check early enough (Fedora 5 boot) ; @@todo fix this properly, so we can dispatch pending interrupts in GC - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC jz iret_continue ; Go to our hypervisor trap handler to dispatch the pending irq - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_EDI], edi - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EDI], edi + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI mov eax, PATM_ACTION_PENDING_IRQ_AFTER_IRET - lock or dword [ss:PATM_PENDINGACTION], eax - mov ecx, PATM_ACTION_MAGIC - mov edi, PATM_CURINSTRADDR + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax + mov ecx, PATM_ACTION_MAGIC + mov edi, PATM_ASMFIX_CURINSTRADDR popfd @@ -1229,17 +1229,17 @@ mov eax, dword [esp+16] and eax, X86_EFL_IOPL - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL - or dword [ss:PATM_VMFLAGS], eax + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL + or dword [ss:PATM_ASMFIX_VMFLAGS], eax pop eax and dword [esp+12], ~X86_EFL_IOPL ; Set IF again; below we make sure this won't cause problems. - or dword [ss:PATM_VMFLAGS], X86_EFL_IF + or dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF ; make sure iret is executed fully (including the iret below; cli ... iret can otherwise be interrupted) - mov dword [ss:PATM_INHIBITIRQADDR], PATM_CURINSTRADDR - - popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INHIBITIRQADDR], PATM_ASMFIX_CURINSTRADDR + + popfd + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 iretd PATM_INT3 @@ -1247,5 +1247,5 @@ iret_fault: popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -1253,5 +1253,5 @@ nop popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -1260,7 +1260,7 @@ pushfd push eax - push PATM_FIXUP + push PATM_ASMFIX_FIXUP DB 0E8h ; call - DD PATM_IRET_FUNCTION + DD PATM_ASMFIX_IRET_FUNCTION add esp, 4 ; pushed address of jump table @@ -1282,14 +1282,14 @@ mov eax, dword [esp+16] and eax, X86_EFL_IOPL - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL - or dword [ss:PATM_VMFLAGS], eax + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL + or dword [ss:PATM_ASMFIX_VMFLAGS], eax pop eax and dword [esp+12], ~X86_EFL_IOPL ; Clear IF - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IF - popfd - - ; the patched destination code will set PATM_INTERRUPTFLAG after the return! + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IF + popfd + + ; the patched destination code will set PATM_ASMFIX_INTERRUPTFLAG after the return! iretd @@ -1299,9 +1299,9 @@ ; Go to our hypervisor trap handler to perform the iret to v86 code - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX mov eax, PATM_ACTION_DO_V86_IRET - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC @@ -1335,32 +1335,32 @@ PATCHASMRECORD_INIT PATMIretReplacement, 25 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHIRET - DD PATM_PENDINGACTION, 0 -%endif - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_EDI, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_CURINSTRADDR, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INHIBITIRQADDR, 0 - DD PATM_CURINSTRADDR, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_FIXUP, PATMIretTable - NAME(PATMIretReplacement) - DD PATM_IRET_FUNCTION, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 +%endif + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_EDI, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_CURINSTRADDR, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INHIBITIRQADDR, 0 + DD PATM_ASMFIX_CURINSTRADDR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_FIXUP, PATMIretTable - NAME(PATMIretReplacement) + DD PATM_ASMFIX_IRET_FUNCTION, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 DD 0ffffffffh, 0ffffffffh @@ -1401,5 +1401,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMIretRing1Replacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushfd @@ -1410,5 +1410,5 @@ lea edx, dword [ss:esp+12+4] ;3 dwords + pushed flags -> iret eip mov eax, PATM_ACTION_LOG_IRET - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC db 0fh, 0bh ; illegal instr (hardcoded assumption in PATMHandleIllegalInstrTrap) @@ -1440,16 +1440,16 @@ ; Note: This is very important as pending pic interrupts can be overridden by apic interrupts if we don't check early enough (Fedora 5 boot) ; @@todo fix this properly, so we can dispatch pending interrupts in GC - test dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC + test dword [ss:PATM_ASMFIX_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC jz iretring1_continue ; Go to our hypervisor trap handler to dispatch the pending irq - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_EDI], edi - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EDI], edi + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX | PATM_RESTORE_EDI mov eax, PATM_ACTION_PENDING_IRQ_AFTER_IRET - lock or dword [ss:PATM_PENDINGACTION], eax - mov ecx, PATM_ACTION_MAGIC - mov edi, PATM_CURINSTRADDR + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax + mov ecx, PATM_ACTION_MAGIC + mov edi, PATM_ASMFIX_CURINSTRADDR popfd @@ -1485,17 +1485,17 @@ mov eax, dword [esp+16] and eax, X86_EFL_IOPL - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL - or dword [ss:PATM_VMFLAGS], eax + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL + or dword [ss:PATM_ASMFIX_VMFLAGS], eax pop eax and dword [esp+12], ~X86_EFL_IOPL ; Set IF again; below we make sure this won't cause problems. - or dword [ss:PATM_VMFLAGS], X86_EFL_IF + or dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF ; make sure iret is executed fully (including the iret below; cli ... iret can otherwise be interrupted) - mov dword [ss:PATM_INHIBITIRQADDR], PATM_CURINSTRADDR - - popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INHIBITIRQADDR], PATM_ASMFIX_CURINSTRADDR + + popfd + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 iretd PATM_INT3 @@ -1503,5 +1503,5 @@ iretring1_fault: popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -1509,5 +1509,5 @@ nop popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -1516,7 +1516,7 @@ pushfd push eax - push PATM_FIXUP + push PATM_ASMFIX_FIXUP DB 0E8h ; call - DD PATM_IRET_FUNCTION + DD PATM_ASMFIX_IRET_FUNCTION add esp, 4 ; pushed address of jump table @@ -1535,11 +1535,11 @@ mov eax, dword [esp+16] and eax, X86_EFL_IOPL - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IOPL - or dword [ss:PATM_VMFLAGS], eax + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IOPL + or dword [ss:PATM_ASMFIX_VMFLAGS], eax pop eax and dword [esp+12], ~X86_EFL_IOPL ; Clear IF - and dword [ss:PATM_VMFLAGS], ~X86_EFL_IF + and dword [ss:PATM_ASMFIX_VMFLAGS], ~X86_EFL_IF popfd @@ -1553,5 +1553,5 @@ and dword [esp+20], ~1 ; SS or dword [esp+20], 2 - ; the patched destination code will set PATM_INTERRUPTFLAG after the return! + ; the patched destination code will set PATM_ASMFIX_INTERRUPTFLAG after the return! iretd @@ -1559,5 +1559,5 @@ ; force ring 1 CS RPL or dword [esp+8], 1 - ; the patched destination code will set PATM_INTERRUPTFLAG after the return! + ; the patched destination code will set PATM_ASMFIX_INTERRUPTFLAG after the return! iretd @@ -1567,9 +1567,9 @@ ; Go to our hypervisor trap handler to perform the iret to v86 code - mov dword [ss:PATM_TEMP_EAX], eax - mov dword [ss:PATM_TEMP_ECX], ecx - mov dword [ss:PATM_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX + mov dword [ss:PATM_ASMFIX_TEMP_EAX], eax + mov dword [ss:PATM_ASMFIX_TEMP_ECX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_RESTORE_FLAGS], PATM_RESTORE_EAX | PATM_RESTORE_ECX mov eax, PATM_ACTION_DO_V86_IRET - lock or dword [ss:PATM_PENDINGACTION], eax + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], eax mov ecx, PATM_ACTION_MAGIC @@ -1603,32 +1603,32 @@ PATCHASMRECORD_INIT PATMIretRing1Replacement, 25 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 %ifdef PATM_LOG_PATCHIRET - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 %endif - DD PATM_VM_FORCEDACTIONS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_EDI, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_CURINSTRADDR, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INHIBITIRQADDR, 0 - DD PATM_CURINSTRADDR, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_FIXUP, PATMIretRing1Table - NAME(PATMIretRing1Replacement) - DD PATM_IRET_FUNCTION, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_VMFLAGS, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_ECX, 0 - DD PATM_TEMP_RESTORE_FLAGS, 0 - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_VM_FORCEDACTIONS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_EDI, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_CURINSTRADDR, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INHIBITIRQADDR, 0 + DD PATM_ASMFIX_CURINSTRADDR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_FIXUP, PATMIretRing1Table - NAME(PATMIretRing1Replacement) + DD PATM_ASMFIX_IRET_FUNCTION, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_ECX, 0 + DD PATM_ASMFIX_TEMP_RESTORE_FLAGS, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 DD 0ffffffffh, 0ffffffffh @@ -1644,5 +1644,5 @@ ;( + 0 return address ) ; -; @note assumes PATM_INTERRUPTFLAG is zero +; @note assumes PATM_ASMFIX_INTERRUPTFLAG is zero ; @note assumes it can trash eax and eflags ; @@ -1680,5 +1680,5 @@ ; 2) Query return patch address from the hypervisor ; @todo private ugly interface, since we have nothing generic at the moment - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS mov eax, PATM_ACTION_LOOKUP_ADDRESS mov ecx, PATM_ACTION_MAGIC @@ -1696,5 +1696,5 @@ jz PATMIretFunction_Failure - add eax, PATM_PATCHBASE + add eax, PATM_ASMFIX_PATCHBASE pop edi @@ -1715,6 +1715,6 @@ GLOBALNAME g_patmIretFunctionRecord PATCHASMRECORD_INIT PATMIretFunction, 2 - DD PATM_PENDINGACTION, 0 - DD PATM_PATCHBASE, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_PATCHBASE, 0 DD 0ffffffffh, 0ffffffffh @@ -1732,6 +1732,6 @@ not dword [esp-32] - mov dword [ss:PATM_INTERRUPTFLAG], 0 -PATCH_FIXUP PATM_INTERRUPTFLAG + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 +PATCH_FIXUP PATM_ASMFIX_INTERRUPTFLAG pushf @@ -1741,6 +1741,6 @@ popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 -PATCH_FIXUP PATM_INTERRUPTFLAG + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 +PATCH_FIXUP PATM_ASMFIX_INTERRUPTFLAG END_PATCH g_patmCpuidRecord, PATMCpuidReplacement @@ -1751,5 +1751,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMJEcxReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushfd PATMJEcxSizeOverride: @@ -1759,12 +1759,12 @@ popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMJEcxJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA PATMJEcxContinue: popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMJEcxReplacement @@ -1773,7 +1773,7 @@ GLOBALNAME g_patmJEcxRecord PATCHASMRECORD_INIT_EX PATMJEcxReplacement, , PATMJEcxJump, PATMJEcxSizeOverride, 3 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1784,5 +1784,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMLoopReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushfd PATMLoopSizeOverride: @@ -1792,12 +1792,12 @@ popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMLoopJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA PATMLoopContinue: popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMLoopReplacement @@ -1806,7 +1806,7 @@ GLOBALNAME g_patmLoopRecord PATCHASMRECORD_INIT_EX PATMLoopReplacement, , PATMLoopJump, PATMLoopSizeOverride, 3 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1817,5 +1817,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMLoopZReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 jnz NAME(PATMLoopZReplacement_EndProc) pushfd @@ -1826,12 +1826,12 @@ popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMLoopZJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA PATMLoopZContinue: popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMLoopZReplacement @@ -1840,7 +1840,7 @@ GLOBALNAME g_patmLoopZRecord PATCHASMRECORD_INIT_EX PATMLoopZReplacement, , PATMLoopZJump, PATMLoopZSizeOverride, 3 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1851,5 +1851,5 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMLoopNZReplacement - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 jz NAME(PATMLoopNZReplacement_EndProc) pushfd @@ -1860,12 +1860,12 @@ popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMLoopNZJump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA PATMLoopNZContinue: popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ENDPROC PATMLoopNZReplacement @@ -1874,7 +1874,7 @@ GLOBALNAME g_patmLoopNZRecord PATCHASMRECORD_INIT_EX PATMLoopNZReplacement, , PATMLoopNZJump, PATMLoopNZSizeOverride, 3 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -1882,5 +1882,5 @@ ; ; Global patch function for indirect calls -; Caller is responsible for clearing PATM_INTERRUPTFLAG and doing: +; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and doing: ; + 20 push [pTargetGC] ; + 16 pushfd @@ -1900,5 +1900,5 @@ mov eax, dword [esp+16+4] ; guest return address - mov dword [ss:PATM_CALL_RETURN_ADDR], eax ; temporary storage + mov dword [ss:PATM_ASMFIX_CALL_RETURN_ADDR], eax ; temporary storage mov edx, dword [esp+16+20] ; pushed target address @@ -1920,5 +1920,5 @@ ; nothing found -> let our trap handler try to find it ; @todo private ugly interface, since we have nothing generic at the moment - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS mov eax, PATM_ACTION_LOOKUP_ADDRESS mov ecx, PATM_ACTION_MAGIC @@ -1947,7 +1947,7 @@ mov ecx, eax ; ECX = target address (relative!) - add ecx, PATM_PATCHBASE ; Make it absolute - - mov edx, dword PATM_STACKPTR + add ecx, PATM_ASMFIX_PATCHBASE ; Make it absolute + + mov edx, dword PATM_ASMFIX_STACKPTR cmp dword [ss:edx], PATM_STACK_SIZE ja near PATMLookupAndCall_Failure ; should never happen actually!!! @@ -1957,5 +1957,5 @@ ; save the patch return address on our private stack sub dword [ss:edx], 4 ; sizeof(RTGCPTR) - mov eax, dword PATM_STACKBASE + mov eax, dword PATM_ASMFIX_STACKBASE add eax, dword [ss:edx] ; stack base + stack position mov edi, dword [esp+16+8] ; PATM return address @@ -1963,10 +1963,10 @@ ; save the original return address as well (checked by ret to make sure the guest hasn't messed around with the stack) - mov edi, dword PATM_STACKBASE_GUEST + mov edi, dword PATM_ASMFIX_STACKBASE_GUEST add edi, dword [ss:edx] ; stack base (guest) + stack position mov eax, dword [esp+16+4] ; guest return address mov dword [ss:edi], eax - mov dword [ss:PATM_CALL_PATCH_TARGET_ADDR], ecx ; temporarily store the target address + mov dword [ss:PATM_ASMFIX_CALL_PATCH_TARGET_ADDR], ecx ; temporarily store the target address pop ecx pop edi @@ -1980,5 +1980,5 @@ push edx lea edx, [esp + 12 - 4] ; stack address to store return address - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_CALL + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_CALL mov eax, PATM_ACTION_LOG_CALL mov ecx, PATM_ACTION_MAGIC @@ -1989,8 +1989,8 @@ %endif - push dword [ss:PATM_CALL_RETURN_ADDR] ; push original guest return address - - ; the called function will set PATM_INTERRUPTFLAG (!!) - jmp dword [ss:PATM_CALL_PATCH_TARGET_ADDR] + push dword [ss:PATM_ASMFIX_CALL_RETURN_ADDR] ; push original guest return address + + ; the called function will set PATM_ASMFIX_INTERRUPTFLAG (!!) + jmp dword [ss:PATM_ASMFIX_CALL_PATCH_TARGET_ADDR] ; returning here -> do not add code here or after the jmp!!!!! ENDPROC PATMLookupAndCall @@ -2004,16 +2004,16 @@ PATCHASMRECORD_INIT PATMLookupAndCall, 9 %endif - DD PATM_CALL_RETURN_ADDR, 0 - DD PATM_PENDINGACTION, 0 - DD PATM_PATCHBASE, 0 - DD PATM_STACKPTR, 0 - DD PATM_STACKBASE, 0 - DD PATM_STACKBASE_GUEST, 0 - DD PATM_CALL_PATCH_TARGET_ADDR, 0 + DD PATM_ASMFIX_CALL_RETURN_ADDR, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_PATCHBASE, 0 + DD PATM_ASMFIX_STACKPTR, 0 + DD PATM_ASMFIX_STACKBASE, 0 + DD PATM_ASMFIX_STACKBASE_GUEST, 0 + DD PATM_ASMFIX_CALL_PATCH_TARGET_ADDR, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 %endif - DD PATM_CALL_RETURN_ADDR, 0 - DD PATM_CALL_PATCH_TARGET_ADDR, 0 + DD PATM_ASMFIX_CALL_RETURN_ADDR, 0 + DD PATM_ASMFIX_CALL_PATCH_TARGET_ADDR, 0 DD 0ffffffffh, 0ffffffffh @@ -2021,9 +2021,9 @@ ; ; Global patch function for indirect jumps -; Caller is responsible for clearing PATM_INTERRUPTFLAG and doing: +; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and doing: ; + 8 push [pTargetGC] ; + 4 push [JumpTableAddress] ;( + 0 return address ) -; And saving eflags in PATM_TEMP_EFLAGS +; And saving eflags in PATM_ASMFIX_TEMP_EFLAGS ; ; @note NEVER change this without bumping the SSM version @@ -2054,5 +2054,5 @@ ; nothing found -> let our trap handler try to find it ; @todo private ugly interface, since we have nothing generic at the moment - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS mov eax, PATM_ACTION_LOOKUP_ADDRESS mov ecx, PATM_ACTION_MAGIC @@ -2081,8 +2081,8 @@ mov ecx, eax ; ECX = target address (relative!) - add ecx, PATM_PATCHBASE ; Make it absolute + add ecx, PATM_ASMFIX_PATCHBASE ; Make it absolute ; save jump patch target - mov dword [ss:PATM_TEMP_EAX], ecx + mov dword [ss:PATM_ASMFIX_TEMP_EAX], ecx pop ecx pop edi @@ -2091,9 +2091,9 @@ add esp, 12 ; parameters + return address pushed by caller ; restore flags (just to be sure) - push dword [ss:PATM_TEMP_EFLAGS] - popfd - - ; the jump destination will set PATM_INTERRUPTFLAG (!!) - jmp dword [ss:PATM_TEMP_EAX] ; call duplicated patch destination address + push dword [ss:PATM_ASMFIX_TEMP_EFLAGS] + popfd + + ; the jump destination will set PATM_ASMFIX_INTERRUPTFLAG (!!) + jmp dword [ss:PATM_ASMFIX_TEMP_EAX] ; call duplicated patch destination address ENDPROC PATMLookupAndJump @@ -2102,9 +2102,9 @@ GLOBALNAME g_patmLookupAndJumpRecord PATCHASMRECORD_INIT PATMLookupAndJump, 5 - DD PATM_PENDINGACTION, 0 - DD PATM_PATCHBASE, 0 - DD PATM_TEMP_EAX, 0 - DD PATM_TEMP_EFLAGS, 0 - DD PATM_TEMP_EAX, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_PATCHBASE, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 + DD PATM_ASMFIX_TEMP_EFLAGS, 0 + DD PATM_ASMFIX_TEMP_EAX, 0 DD 0ffffffffh, 0ffffffffh @@ -2112,5 +2112,5 @@ ; Patch function for static calls ; @note static calls have only one lookup slot! -; Caller is responsible for clearing PATM_INTERRUPTFLAG and adding: +; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and adding: ; push [pTargetGC] ; @@ -2118,14 +2118,14 @@ BEGINPROC PATMCall pushfd - push PATM_FIXUP ; fixup for jump table below - push PATM_PATCHNEXTBLOCK - push PATM_RETURNADDR + push PATM_ASMFIX_FIXUP ; fixup for jump table below + push PATM_ASMFIX_PATCHNEXTBLOCK + push PATM_ASMFIX_RETURNADDR DB 0E8h ; call - DD PATM_LOOKUP_AND_CALL_FUNCTION + DD PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION ; we only return in case of a failure add esp, 12 ; pushed address of jump table popfd add esp, 4 ; pushed by caller (changes the flags, but that shouldn't matter (@todo)) - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 %ifdef DEBUG @@ -2148,14 +2148,14 @@ GLOBALNAME g_patmCallRecord PATCHASMRECORD_INIT PATMCall, 5 - DD PATM_FIXUP, PATMCallTable - NAME(PATMCall) - DD PATM_PATCHNEXTBLOCK, 0 - DD PATM_RETURNADDR, 0 - DD PATM_LOOKUP_AND_CALL_FUNCTION, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_FIXUP, PATMCallTable - NAME(PATMCall) + DD PATM_ASMFIX_PATCHNEXTBLOCK, 0 + DD PATM_ASMFIX_RETURNADDR, 0 + DD PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh ; Patch function for indirect calls -; Caller is responsible for clearing PATM_INTERRUPTFLAG and adding: +; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and adding: ; push [pTargetGC] ; @@ -2163,14 +2163,14 @@ BEGINPROC PATMCallIndirect pushfd - push PATM_FIXUP ; fixup for jump table below - push PATM_PATCHNEXTBLOCK - push PATM_RETURNADDR + push PATM_ASMFIX_FIXUP ; fixup for jump table below + push PATM_ASMFIX_PATCHNEXTBLOCK + push PATM_ASMFIX_RETURNADDR DB 0E8h ; call - DD PATM_LOOKUP_AND_CALL_FUNCTION + DD PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION ; we only return in case of a failure add esp, 12 ; pushed address of jump table popfd add esp, 4 ; pushed by caller (changes the flags, but that shouldn't matter (@todo)) - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 %ifdef DEBUG @@ -2193,9 +2193,9 @@ GLOBALNAME g_patmCallIndirectRecord PATCHASMRECORD_INIT PATMCallIndirect, 5 - DD PATM_FIXUP, PATMCallIndirectTable - NAME(PATMCallIndirect) - DD PATM_PATCHNEXTBLOCK, 0 - DD PATM_RETURNADDR, 0 - DD PATM_LOOKUP_AND_CALL_FUNCTION, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_FIXUP, PATMCallIndirectTable - NAME(PATMCallIndirect) + DD PATM_ASMFIX_PATCHNEXTBLOCK, 0 + DD PATM_ASMFIX_RETURNADDR, 0 + DD PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -2203,5 +2203,5 @@ ; ; Patch function for indirect jumps -; Caller is responsible for clearing PATM_INTERRUPTFLAG and adding: +; Caller is responsible for clearing PATM_ASMFIX_INTERRUPTFLAG and adding: ; push [pTargetGC] ; @@ -2210,17 +2210,17 @@ ; save flags (just to be sure) pushfd - pop dword [ss:PATM_TEMP_EFLAGS] - - push PATM_FIXUP ; fixup for jump table below + pop dword [ss:PATM_ASMFIX_TEMP_EFLAGS] + + push PATM_ASMFIX_FIXUP ; fixup for jump table below DB 0E8h ; call - DD PATM_LOOKUP_AND_JUMP_FUNCTION + DD PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION ; we only return in case of a failure add esp, 8 ; pushed address of jump table + pushed target address ; restore flags (just to be sure) - push dword [ss:PATM_TEMP_EFLAGS] - popfd - - mov dword [ss:PATM_INTERRUPTFLAG], 1 + push dword [ss:PATM_ASMFIX_TEMP_EFLAGS] + popfd + + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -2244,9 +2244,9 @@ GLOBALNAME g_patmJumpIndirectRecord PATCHASMRECORD_INIT PATMJumpIndirect, 5 - DD PATM_TEMP_EFLAGS, 0 - DD PATM_FIXUP, PATMJumpIndirectTable - NAME(PATMJumpIndirect) - DD PATM_LOOKUP_AND_JUMP_FUNCTION, 0 - DD PATM_TEMP_EFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_TEMP_EFLAGS, 0 + DD PATM_ASMFIX_FIXUP, PATMJumpIndirectTable - NAME(PATMJumpIndirect) + DD PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION, 0 + DD PATM_ASMFIX_TEMP_EFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -2260,10 +2260,10 @@ not dword [esp-32] not dword [esp-32] - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushfd push eax - push PATM_FIXUP + push PATM_ASMFIX_FIXUP DB 0E8h ; call - DD PATM_RETURN_FUNCTION + DD PATM_ASMFIX_RETURN_FUNCTION add esp, 4 ; pushed address of jump table @@ -2273,5 +2273,5 @@ pop eax popfd - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -2292,5 +2292,5 @@ popf ; caller will duplicate the ret or ret n instruction - ; the patched call will set PATM_INTERRUPTFLAG after the return! + ; the patched call will set PATM_ASMFIX_INTERRUPTFLAG after the return! ENDPROC PATMRet @@ -2298,8 +2298,8 @@ GLOBALNAME g_patmRetRecord PATCHASMRECORD_INIT PATMRet, 4 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_FIXUP, PATMRetTable - NAME(PATMRet) - DD PATM_RETURN_FUNCTION, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_FIXUP, PATMRetTable - NAME(PATMRet) + DD PATM_ASMFIX_RETURN_FUNCTION, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -2315,5 +2315,5 @@ ;( + 0 return address ) ; -; @note assumes PATM_INTERRUPTFLAG is zero +; @note assumes PATM_ASMFIX_INTERRUPTFLAG is zero ; @note assumes it can trash eax and eflags ; @@ -2337,11 +2337,11 @@ ; 1) Check if the return patch address was pushed on the PATM stack - cmp dword [ss:PATM_STACKPTR], PATM_STACK_SIZE + cmp dword [ss:PATM_ASMFIX_STACKPTR], PATM_STACK_SIZE jae near PATMRetFunction_FindReturnAddress - mov edx, dword PATM_STACKPTR + mov edx, dword PATM_ASMFIX_STACKPTR ; check if the return address is what we expect it to be - mov eax, dword PATM_STACKBASE_GUEST + mov eax, dword PATM_ASMFIX_STACKBASE_GUEST add eax, dword [ss:edx] ; stack base + stack position mov eax, dword [ss:eax] ; original return address @@ -2353,8 +2353,8 @@ ; found it, convert relative to absolute patch address and return the result to the caller - mov eax, dword PATM_STACKBASE + mov eax, dword PATM_ASMFIX_STACKBASE add eax, dword [ss:edx] ; stack base + stack position mov eax, dword [ss:eax] ; relative patm return address - add eax, PATM_PATCHBASE + add eax, PATM_ASMFIX_PATCHBASE %ifdef PATM_LOG_PATCHINSTR @@ -2365,5 +2365,5 @@ mov edx, eax ; return address lea ebx, [esp+16+12+16] ; stack address containing the return address - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_RET + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_RET mov eax, PATM_ACTION_LOG_RET mov ecx, PATM_ACTION_MAGIC @@ -2402,5 +2402,5 @@ ; 3) Query return patch address from the hypervisor ; @todo private ugly interface, since we have nothing generic at the moment - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOOKUP_ADDRESS mov eax, PATM_ACTION_LOOKUP_ADDRESS mov ecx, PATM_ACTION_MAGIC @@ -2418,5 +2418,5 @@ jz PATMRetFunction_Failure - add eax, PATM_PATCHBASE + add eax, PATM_ASMFIX_PATCHBASE %ifdef PATM_LOG_PATCHINSTR @@ -2427,5 +2427,5 @@ mov edx, eax ; return address lea ebx, [esp+16+12+16] ; stack address containing the return address - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_RET + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_RET mov eax, PATM_ACTION_LOG_RET mov ecx, PATM_ACTION_MAGIC @@ -2458,16 +2458,16 @@ PATCHASMRECORD_INIT PATMRetFunction, 7 %endif - DD PATM_STACKPTR, 0 - DD PATM_STACKPTR, 0 - DD PATM_STACKBASE_GUEST, 0 - DD PATM_STACKBASE, 0 - DD PATM_PATCHBASE, 0 + DD PATM_ASMFIX_STACKPTR, 0 + DD PATM_ASMFIX_STACKPTR, 0 + DD PATM_ASMFIX_STACKBASE_GUEST, 0 + DD PATM_ASMFIX_STACKBASE, 0 + DD PATM_ASMFIX_PATCHBASE, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 %endif - DD PATM_PENDINGACTION, 0 - DD PATM_PATCHBASE, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 + DD PATM_ASMFIX_PATCHBASE, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 %endif DD 0ffffffffh, 0ffffffffh @@ -2479,7 +2479,7 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMCheckIF - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf - test dword [ss:PATM_VMFLAGS], X86_EFL_IF + test dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF jnz PATMCheckIF_Safe nop @@ -2487,15 +2487,15 @@ ; IF=0 -> unsafe, so we must call the duplicated function (which we don't do here) popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 jmp NAME(PATMCheckIF_EndProc) PATMCheckIF_Safe: ; invalidate the PATM stack as we'll jump back to guest code - mov dword [ss:PATM_STACKPTR], PATM_STACK_SIZE + mov dword [ss:PATM_ASMFIX_STACKPTR], PATM_STACK_SIZE %ifdef PATM_LOG_PATCHINSTR push eax push ecx - lock or dword [ss:PATM_PENDINGACTION], PATM_ACTION_LOG_IF1 + lock or dword [ss:PATM_ASMFIX_PENDINGACTION], PATM_ACTION_LOG_IF1 mov eax, PATM_ACTION_LOG_IF1 mov ecx, PATM_ACTION_MAGIC @@ -2505,9 +2505,9 @@ %endif popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 ; IF=1 -> we can safely jump back to the original instruction DB 0xE9 PATMCheckIF_Jump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMCheckIF @@ -2520,12 +2520,12 @@ PATCHASMRECORD_INIT_JUMP PATMCheckIF, PATMCheckIF_Jump, 5 %endif - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_STACKPTR, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_STACKPTR, 0 %ifdef PATM_LOG_PATCHINSTR - DD PATM_PENDINGACTION, 0 + DD PATM_ASMFIX_PENDINGACTION, 0 %endif - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh @@ -2536,7 +2536,7 @@ BEGIN_PATCH_CODE_SECTION BEGINPROC PATMJumpToGuest_IF1 - mov dword [ss:PATM_INTERRUPTFLAG], 0 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 0 pushf - test dword [ss:PATM_VMFLAGS], X86_EFL_IF + test dword [ss:PATM_ASMFIX_VMFLAGS], X86_EFL_IF jnz PATMJumpToGuest_IF1_Safe nop @@ -2544,5 +2544,5 @@ ; IF=0 -> unsafe, so fault popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 PATM_INT3 @@ -2550,8 +2550,8 @@ ; IF=1 -> we can safely jump back to the original instruction popf - mov dword [ss:PATM_INTERRUPTFLAG], 1 + mov dword [ss:PATM_ASMFIX_INTERRUPTFLAG], 1 DB 0xE9 PATMJumpToGuest_IF1_Jump: - DD PATM_JUMPDELTA + DD PATM_ASMFIX_JUMPDELTA ENDPROC PATMJumpToGuest_IF1 @@ -2560,8 +2560,8 @@ GLOBALNAME PATMJumpToGuest_IF1Record PATCHASMRECORD_INIT_JUMP PATMJumpToGuest_IF1, PATMJumpToGuest_IF1_Jump, 4 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_VMFLAGS, 0 - DD PATM_INTERRUPTFLAG, 0 - DD PATM_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_VMFLAGS, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 + DD PATM_ASMFIX_INTERRUPTFLAG, 0 DD 0ffffffffh, 0ffffffffh Index: /trunk/src/VBox/VMM/VMMR3/PATMA.mac =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PATMA.mac (revision 54763) +++ /trunk/src/VBox/VMM/VMMR3/PATMA.mac (revision 54764) @@ -22,35 +22,35 @@ ; @remarks These fixups types are part of the saved state. ; @{ -%define PATM_VMFLAGS 0xF1ABCD00 +%define PATM_ASMFIX_VMFLAGS 0xF1ABCD00 %ifdef VBOX_WITH_STATISTICS - %define PATM_ALLPATCHCALLS 0xF1ABCD01 - %define PATM_PERPATCHCALLS 0xF1ABCD02 + %define PATM_ASMFIX_ALLPATCHCALLS 0xF1ABCD01 + %define PATM_ASMFIX_PERPATCHCALLS 0xF1ABCD02 %endif -%define PATM_JUMPDELTA 0xF1ABCD03 +%define PATM_ASMFIX_JUMPDELTA 0xF1ABCD03 %ifdef VBOX_WITH_STATISTICS - %define PATM_IRETEFLAGS 0xF1ABCD04 - %define PATM_IRETCS 0xF1ABCD05 - %define PATM_IRETEIP 0xF1ABCD06 + %define PATM_ASMFIX_IRETEFLAGS 0xF1ABCD04 + %define PATM_ASMFIX_IRETCS 0xF1ABCD05 + %define PATM_ASMFIX_IRETEIP 0xF1ABCD06 %endif -%define PATM_FIXUP 0xF1ABCD07 -%define PATM_PENDINGACTION 0xF1ABCD08 -%define PATM_CPUID_STD_PTR 0xF1ABCD09 -%define PATM_CPUID_EXT_PTR 0xF1ABCD0a -%define PATM_CPUID_DEF_PTR 0xF1ABCD0b -%define PATM_STACKBASE 0xF1ABCD0c ;;< Stack to store our private patch return addresses -%define PATM_STACKBASE_GUEST 0xF1ABCD0d ;;< Stack to store guest return addresses -%define PATM_STACKPTR 0xF1ABCD0e -%define PATM_PATCHBASE 0xF1ABCD0f -%define PATM_INTERRUPTFLAG 0xF1ABCD10 -%define PATM_INHIBITIRQADDR 0xF1ABCD11 -%define PATM_VM_FORCEDACTIONS 0xF1ABCD12 -%define PATM_TEMP_EAX 0xF1ABCD13 ;;< Location for original EAX register -%define PATM_TEMP_ECX 0xF1ABCD14 ;;< Location for original ECX register -%define PATM_TEMP_EDI 0xF1ABCD15 ;;< Location for original EDI register -%define PATM_TEMP_EFLAGS 0xF1ABCD16 ;;< Location for original eflags -%define PATM_TEMP_RESTORE_FLAGS 0xF1ABCD17 ;;< Which registers to restore -%define PATM_CALL_PATCH_TARGET_ADDR 0xF1ABCD18 -%define PATM_CALL_RETURN_ADDR 0xF1ABCD19 -%define PATM_CPUID_CENTAUR_PTR 0xF1ABCD1a +%define PATM_ASMFIX_FIXUP 0xF1ABCD07 +%define PATM_ASMFIX_PENDINGACTION 0xF1ABCD08 +%define PATM_ASMFIX_CPUID_STD_PTR 0xF1ABCD09 +%define PATM_ASMFIX_CPUID_EXT_PTR 0xF1ABCD0a +%define PATM_ASMFIX_CPUID_DEF_PTR 0xF1ABCD0b +%define PATM_ASMFIX_STACKBASE 0xF1ABCD0c ;;< Stack to store our private patch return addresses +%define PATM_ASMFIX_STACKBASE_GUEST 0xF1ABCD0d ;;< Stack to store guest return addresses +%define PATM_ASMFIX_STACKPTR 0xF1ABCD0e +%define PATM_ASMFIX_PATCHBASE 0xF1ABCD0f +%define PATM_ASMFIX_INTERRUPTFLAG 0xF1ABCD10 +%define PATM_ASMFIX_INHIBITIRQADDR 0xF1ABCD11 +%define PATM_ASMFIX_VM_FORCEDACTIONS 0xF1ABCD12 +%define PATM_ASMFIX_TEMP_EAX 0xF1ABCD13 ;;< Location for original EAX register +%define PATM_ASMFIX_TEMP_ECX 0xF1ABCD14 ;;< Location for original ECX register +%define PATM_ASMFIX_TEMP_EDI 0xF1ABCD15 ;;< Location for original EDI register +%define PATM_ASMFIX_TEMP_EFLAGS 0xF1ABCD16 ;;< Location for original eflags +%define PATM_ASMFIX_TEMP_RESTORE_FLAGS 0xF1ABCD17 ;;< Which registers to restore +%define PATM_ASMFIX_CALL_PATCH_TARGET_ADDR 0xF1ABCD18 +%define PATM_ASMFIX_CALL_RETURN_ADDR 0xF1ABCD19 +%define PATM_ASMFIX_CPUID_CENTAUR_PTR 0xF1ABCD1a %define PATM_ASMFIX_REUSE_LATER_0 0xF1ABCD1b %define PATM_ASMFIX_REUSE_LATER_1 0xF1ABCD1c @@ -60,17 +60,17 @@ ;/* Anything larger doesn't require a fixup */ -%define PATM_NO_FIXUP 0xF1ABCE00 -%define PATM_CPUID_STD_MAX 0xF1ABCE00 -%define PATM_CPUID_EXT_MAX 0xF1ABCE01 -%define PATM_RETURNADDR 0xF1ABCE02 -%define PATM_PATCHNEXTBLOCK 0xF1ABCE03 -%define PATM_CALLTARGET 0xF1ABCE04 ;;< relative call target -%define PATM_NEXTINSTRADDR 0xF1ABCE05 ;;< absolute guest address of the next instruction -%define PATM_CURINSTRADDR 0xF1ABCE06 ;;< absolute guest address of the current instruction -%define PATM_LOOKUP_AND_CALL_FUNCTION 0xF1ABCE07 ;;< Relative address of global PATM lookup and call function. -%define PATM_RETURN_FUNCTION 0xF1ABCE08 ;;< Relative address of global PATM return function. -%define PATM_LOOKUP_AND_JUMP_FUNCTION 0xF1ABCE09 ;;< Relative address of global PATM lookup and jump function. -%define PATM_IRET_FUNCTION 0xF1ABCE0A ;;< Relative address of global PATM iret function. -%define PATM_CPUID_CENTAUR_MAX 0xF1ABCE0B +%define PATM_ASMFIX_NO_FIXUP 0xF1ABCE00 +%define PATM_ASMFIX_CPUID_STD_MAX 0xF1ABCE00 +%define PATM_ASMFIX_CPUID_EXT_MAX 0xF1ABCE01 +%define PATM_ASMFIX_RETURNADDR 0xF1ABCE02 +%define PATM_ASMFIX_PATCHNEXTBLOCK 0xF1ABCE03 +%define PATM_ASMFIX_CALLTARGET 0xF1ABCE04 ;;< relative call target +%define PATM_ASMFIX_NEXTINSTRADDR 0xF1ABCE05 ;;< absolute guest address of the next instruction +%define PATM_ASMFIX_CURINSTRADDR 0xF1ABCE06 ;;< absolute guest address of the current instruction +%define PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION 0xF1ABCE07 ;;< Relative address of global PATM lookup and call function. +%define PATM_ASMFIX_RETURN_FUNCTION 0xF1ABCE08 ;;< Relative address of global PATM return function. +%define PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION 0xF1ABCE09 ;;< Relative address of global PATM lookup and jump function. +%define PATM_ASMFIX_IRET_FUNCTION 0xF1ABCE0A ;;< Relative address of global PATM iret function. +%define PATM_ASMFIX_CPUID_CENTAUR_MAX 0xF1ABCE0B ;; @} @@ -108,5 +108,5 @@ %define PATM_ACTION_MAGIC 0xABCD4321 -;; @name PATM_TEMP_RESTORE_FLAGS +;; @name PATM_ASMFIX_TEMP_RESTORE_FLAGS ;; @{ %define PATM_RESTORE_EAX RT_BIT(0) Index: /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp (revision 54763) +++ /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp (revision 54764) @@ -109,5 +109,5 @@ || uType == FIXUP_REL_HELPER_IN_PATCH_ASM_TMPL) && pSource == pDest - && PATM_IS_FIXUP_TYPE(pSource)) + && PATM_IS_ASMFIX(pSource)) || ((uType == FIXUP_REL_JMPTOPATCH || uType == FIXUP_REL_JMPTOGUEST) && pSource && pDest)); @@ -172,5 +172,5 @@ #ifdef VBOX_STRICT - if (pAsmRecord->aRelocs[i].uType == PATM_FIXUP) + if (pAsmRecord->aRelocs[i].uType == PATM_ASMFIX_FIXUP) Assert(pAsmRecord->aRelocs[i].uInfo != 0); else @@ -188,51 +188,51 @@ * PATMGCSTATE member fixups. */ - case PATM_VMFLAGS: + case PATM_ASMFIX_VMFLAGS: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uVMFlags); break; - case PATM_PENDINGACTION: + case PATM_ASMFIX_PENDINGACTION: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uPendingAction); break; - case PATM_STACKPTR: + case PATM_ASMFIX_STACKPTR: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Psp); break; - case PATM_INTERRUPTFLAG: + case PATM_ASMFIX_INTERRUPTFLAG: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, fPIF); break; - case PATM_INHIBITIRQADDR: + case PATM_ASMFIX_INHIBITIRQADDR: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, GCPtrInhibitInterrupts); break; - case PATM_TEMP_EAX: + case PATM_ASMFIX_TEMP_EAX: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uEAX); break; - case PATM_TEMP_ECX: + case PATM_ASMFIX_TEMP_ECX: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uECX); break; - case PATM_TEMP_EDI: + case PATM_ASMFIX_TEMP_EDI: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uEDI); break; - case PATM_TEMP_EFLAGS: + case PATM_ASMFIX_TEMP_EFLAGS: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.eFlags); break; - case PATM_TEMP_RESTORE_FLAGS: + case PATM_ASMFIX_TEMP_RESTORE_FLAGS: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, Restore.uFlags); break; - case PATM_CALL_PATCH_TARGET_ADDR: + case PATM_ASMFIX_CALL_PATCH_TARGET_ADDR: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, GCCallPatchTargetAddr); break; - case PATM_CALL_RETURN_ADDR: + case PATM_ASMFIX_CALL_RETURN_ADDR: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, GCCallReturnAddr); break; #ifdef VBOX_WITH_STATISTICS - case PATM_ALLPATCHCALLS: + case PATM_ASMFIX_ALLPATCHCALLS: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uPatchCalls); break; - case PATM_IRETEFLAGS: + case PATM_ASMFIX_IRETEFLAGS: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uIretEFlags); break; - case PATM_IRETCS: + case PATM_ASMFIX_IRETCS: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uIretCS); break; - case PATM_IRETEIP: + case PATM_ASMFIX_IRETEIP: dest = pVM->patm.s.pGCStateGC + RT_OFFSETOF(PATMGCSTATE, uIretEIP); break; @@ -240,5 +240,5 @@ - case PATM_FIXUP: + case PATM_ASMFIX_FIXUP: /* Offset in aRelocs[i].uInfo is from the base of the function. */ dest = (RTGCUINTPTR32)pVM->patm.s.pPatchMemGC + pAsmRecord->aRelocs[i].uInfo @@ -247,5 +247,5 @@ #ifdef VBOX_WITH_STATISTICS - case PATM_PERPATCHCALLS: + case PATM_ASMFIX_PERPATCHCALLS: dest = patmPatchQueryStatAddress(pVM, pPatch); break; @@ -255,19 +255,19 @@ * part to store the original return addresses. */ - case PATM_STACKBASE: + case PATM_ASMFIX_STACKBASE: dest = pVM->patm.s.pGCStackGC; break; - case PATM_STACKBASE_GUEST: + case PATM_ASMFIX_STACKBASE_GUEST: dest = pVM->patm.s.pGCStackGC + PATM_STACK_SIZE; break; - case PATM_RETURNADDR: /* absolute guest address; no fixup required */ - Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_NO_FIXUP); + case PATM_ASMFIX_RETURNADDR: /* absolute guest address; no fixup required */ + Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_ASMFIX_NO_FIXUP); dest = pCallInfo->pReturnGC; break; - case PATM_PATCHNEXTBLOCK: /* relative address of instruction following this block */ - Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_NO_FIXUP); + case PATM_ASMFIX_PATCHNEXTBLOCK: /* relative address of instruction following this block */ + Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_ASMFIX_NO_FIXUP); /** @note hardcoded assumption that we must return to the instruction following this block */ @@ -275,6 +275,6 @@ break; - case PATM_CALLTARGET: /* relative to patch address; no fixup required */ - Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_NO_FIXUP); + case PATM_ASMFIX_CALLTARGET: /* relative to patch address; no fixup required */ + Assert(pCallInfo && pAsmRecord->aRelocs[i].uType >= PATM_ASMFIX_NO_FIXUP); /* Address must be filled in later. (see patmr3SetBranchTargets) */ @@ -283,9 +283,9 @@ break; - case PATM_PATCHBASE: /* Patch GC base address */ + case PATM_ASMFIX_PATCHBASE: /* Patch GC base address */ dest = pVM->patm.s.pPatchMemGC; break; - case PATM_NEXTINSTRADDR: + case PATM_ASMFIX_NEXTINSTRADDR: Assert(pCallInfo); /* pNextInstrGC can be 0 if several instructions, that inhibit irqs, follow each other */ @@ -293,5 +293,5 @@ break; - case PATM_CURINSTRADDR: + case PATM_ASMFIX_CURINSTRADDR: Assert(pCallInfo); dest = pCallInfo->pCurInstrGC; @@ -299,5 +299,5 @@ /* Relative address of global patm lookup and call function. */ - case PATM_LOOKUP_AND_CALL_FUNCTION: + case PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION: { RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC @@ -311,5 +311,5 @@ } - case PATM_RETURN_FUNCTION: + case PATM_ASMFIX_RETURN_FUNCTION: { RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC @@ -323,5 +323,5 @@ } - case PATM_IRET_FUNCTION: + case PATM_ASMFIX_IRET_FUNCTION: { RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC @@ -335,5 +335,5 @@ } - case PATM_LOOKUP_AND_JUMP_FUNCTION: + case PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION: { RTRCPTR pInstrAfterCall = pVM->patm.s.pPatchMemGC @@ -347,11 +347,11 @@ } - case PATM_CPUID_STD_MAX: /* saved state only */ + case PATM_ASMFIX_CPUID_STD_MAX: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmStdMax(pVM); break; - case PATM_CPUID_EXT_MAX: /* saved state only */ + case PATM_ASMFIX_CPUID_EXT_MAX: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmExtMax(pVM); break; - case PATM_CPUID_CENTAUR_MAX: /* saved state only */ + case PATM_ASMFIX_CPUID_CENTAUR_MAX: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmCentaurMax(pVM); break; @@ -361,18 +361,18 @@ * Note! Earlier saved state versions had different hacks for detecting some of these. */ - case PATM_VM_FORCEDACTIONS: + case PATM_ASMFIX_VM_FORCEDACTIONS: dest = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions); break; - case PATM_CPUID_DEF_PTR: /* saved state only */ + case PATM_ASMFIX_CPUID_DEF_PTR: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM); break; - case PATM_CPUID_STD_PTR: /* saved state only */ + case PATM_ASMFIX_CPUID_STD_PTR: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM); break; - case PATM_CPUID_EXT_PTR: /* saved state only */ + case PATM_ASMFIX_CPUID_EXT_PTR: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM); break; - case PATM_CPUID_CENTAUR_PTR: /* saved state only */ + case PATM_ASMFIX_CPUID_CENTAUR_PTR: /* saved state only */ dest = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM); break; @@ -412,5 +412,5 @@ *(PRTRCPTR)&pPB[j] = dest; - if (pAsmRecord->aRelocs[i].uType < PATM_NO_FIXUP) + if (pAsmRecord->aRelocs[i].uType < PATM_ASMFIX_NO_FIXUP) { patmPatchAddReloc32(pVM, pPatch, &pPB[j], uRelocType, @@ -797,5 +797,5 @@ PATCHGEN_EPILOG(pPatch, size); - /* Need to set PATM_INTERRUPTFLAG after the patched ret returns here. */ + /* Need to set PATM_ASMFIX_INTERRUPTFLAG after the patched ret returns here. */ rc = patmPatchGenSetPIF(pVM, pPatch, pCurInstrGC); if (rc == VERR_NO_MEMORY) Index: /trunk/src/VBox/VMM/VMMR3/PATMSSM.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PATMSSM.cpp (revision 54763) +++ /trunk/src/VBox/VMM/VMMR3/PATMSSM.cpp (revision 54764) @@ -1111,5 +1111,5 @@ { Assert( pRec->uType != PATM_SAVED_STATE_VERSION_NO_RAW_MEM - || (pRec->pSource == pRec->pDest && PATM_IS_FIXUP_TYPE(pRec->pSource)) ); + || (pRec->pSource == pRec->pDest && PATM_IS_ASMFIX(pRec->pSource)) ); /* bird: What is this for exactly? Only the MMIO fixups used to have pSource set. */ @@ -1266,5 +1266,5 @@ LogFlow(("Changing fLocalForcedActions fixup from %RRv to %RRv\n", uFixup, pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions))); *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions); - pRec->pSource = pRec->pDest = PATM_VM_FORCEDACTIONS; + pRec->pSource = pRec->pDest = PATM_ASMFIX_VM_FORCEDACTIONS; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; } @@ -1279,20 +1279,20 @@ case 0: *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_DEF_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_DEF_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; break; case 1: *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_STD_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_STD_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; break; case 2: *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_EXT_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_EXT_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; break; case 3: *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_CENTAUR_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_CENTAUR_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; break; @@ -1313,5 +1313,5 @@ case PATM_FIXUP_CPU_FF_ACTION: *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions); - pRec->pSource = pRec->pDest = PATM_VM_FORCEDACTIONS; + pRec->pSource = pRec->pDest = PATM_ASMFIX_VM_FORCEDACTIONS; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; LogFlow(("Changing cpu ff action fixup from %x to %x\n", uFixup, *pFixup)); @@ -1319,5 +1319,5 @@ case PATM_FIXUP_CPUID_DEFAULT: *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_DEF_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_DEF_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; LogFlow(("Changing cpuid def fixup from %x to %x\n", uFixup, *pFixup)); @@ -1325,5 +1325,5 @@ case PATM_FIXUP_CPUID_STANDARD: *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_STD_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_STD_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; LogFlow(("Changing cpuid std fixup from %x to %x\n", uFixup, *pFixup)); @@ -1331,5 +1331,5 @@ case PATM_FIXUP_CPUID_EXTENDED: *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_EXT_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_EXT_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; LogFlow(("Changing cpuid ext fixup from %x to %x\n", uFixup, *pFixup)); @@ -1337,5 +1337,5 @@ case PATM_FIXUP_CPUID_CENTAUR: *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM); - pRec->pSource = pRec->pDest = PATM_CPUID_CENTAUR_PTR; + pRec->pSource = pRec->pDest = PATM_ASMFIX_CPUID_CENTAUR_PTR; pRec->uType = FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL; LogFlow(("Changing cpuid centaur fixup from %x to %x\n", uFixup, *pFixup)); @@ -1353,20 +1353,20 @@ && pRec->uType == FIXUP_ABSOLUTE_IN_PATCH_ASM_TMPL) { - Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource)); + Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_ASMFIX(pRec->pSource)); switch (pRec->pSource) { - case PATM_VM_FORCEDACTIONS: + case PATM_ASMFIX_VM_FORCEDACTIONS: *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions); break; - case PATM_CPUID_DEF_PTR: + case PATM_ASMFIX_CPUID_DEF_PTR: *pFixup = CPUMR3GetGuestCpuIdPatmDefRCPtr(pVM); break; - case PATM_CPUID_STD_PTR: /* Saved again patches only. */ + case PATM_ASMFIX_CPUID_STD_PTR: /* Saved again patches only. */ *pFixup = CPUMR3GetGuestCpuIdPatmStdRCPtr(pVM); break; - case PATM_CPUID_EXT_PTR: /* Saved again patches only. */ + case PATM_ASMFIX_CPUID_EXT_PTR: /* Saved again patches only. */ *pFixup = CPUMR3GetGuestCpuIdPatmExtRCPtr(pVM); break; - case PATM_CPUID_CENTAUR_PTR: /* Saved again patches only. */ + case PATM_ASMFIX_CPUID_CENTAUR_PTR: /* Saved again patches only. */ *pFixup = CPUMR3GetGuestCpuIdPatmCentaurRCPtr(pVM); break; @@ -1384,5 +1384,5 @@ { AssertLogRelReturn(uVersion > PATM_SAVED_STATE_VERSION_NO_RAW_MEM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED); - Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource)); + Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_ASMFIX(pRec->pSource)); switch (pRec->pSource) { @@ -1406,5 +1406,5 @@ { AssertLogRelReturn(uVersion > PATM_SAVED_STATE_VERSION_NO_RAW_MEM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED); - Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_FIXUP_TYPE(pRec->pSource)); + Assert(pRec->pSource == pRec->pDest); Assert(PATM_IS_ASMFIX(pRec->pSource)); int rc; RTRCPTR uRCPtrDest; Index: /trunk/src/VBox/VMM/include/PATMA.h =================================================================== --- /trunk/src/VBox/VMM/include/PATMA.h (revision 54763) +++ /trunk/src/VBox/VMM/include/PATMA.h (revision 54764) @@ -22,35 +22,35 @@ * @remarks These fixups types are part of the saved state. * @{ */ -#define PATM_VMFLAGS 0xF1ABCD00 +#define PATM_ASMFIX_VMFLAGS 0xF1ABCD00 #ifdef VBOX_WITH_STATISTICS -# define PATM_ALLPATCHCALLS 0xF1ABCD01 -# define PATM_PERPATCHCALLS 0xF1ABCD02 +# define PATM_ASMFIX_ALLPATCHCALLS 0xF1ABCD01 +# define PATM_ASMFIX_PERPATCHCALLS 0xF1ABCD02 #endif -#define PATM_JUMPDELTA 0xF1ABCD03 +#define PATM_ASMFIX_JUMPDELTA 0xF1ABCD03 #ifdef VBOX_WITH_STATISTICS -# define PATM_IRETEFLAGS 0xF1ABCD04 -# define PATM_IRETCS 0xF1ABCD05 -# define PATM_IRETEIP 0xF1ABCD06 +# define PATM_ASMFIX_IRETEFLAGS 0xF1ABCD04 +# define PATM_ASMFIX_IRETCS 0xF1ABCD05 +# define PATM_ASMFIX_IRETEIP 0xF1ABCD06 #endif -#define PATM_FIXUP 0xF1ABCD07 -#define PATM_PENDINGACTION 0xF1ABCD08 -#define PATM_CPUID_STD_PTR 0xF1ABCD09 /**< Legacy, saved state only. */ -#define PATM_CPUID_EXT_PTR 0xF1ABCD0a /**< Legacy, saved state only. */ -#define PATM_CPUID_DEF_PTR 0xF1ABCD0b /**< Legacy, saved state only. */ -#define PATM_STACKBASE 0xF1ABCD0c /**< Stack to store our private patch return addresses */ -#define PATM_STACKBASE_GUEST 0xF1ABCD0d /**< Stack to store guest return addresses */ -#define PATM_STACKPTR 0xF1ABCD0e -#define PATM_PATCHBASE 0xF1ABCD0f -#define PATM_INTERRUPTFLAG 0xF1ABCD10 -#define PATM_INHIBITIRQADDR 0xF1ABCD11 -#define PATM_VM_FORCEDACTIONS 0xF1ABCD12 -#define PATM_TEMP_EAX 0xF1ABCD13 /**< Location for original EAX register */ -#define PATM_TEMP_ECX 0xF1ABCD14 /**< Location for original ECX register */ -#define PATM_TEMP_EDI 0xF1ABCD15 /**< Location for original EDI register */ -#define PATM_TEMP_EFLAGS 0xF1ABCD16 /**< Location for original eflags */ -#define PATM_TEMP_RESTORE_FLAGS 0xF1ABCD17 /**< Which registers to restore */ -#define PATM_CALL_PATCH_TARGET_ADDR 0xF1ABCD18 -#define PATM_CALL_RETURN_ADDR 0xF1ABCD19 -#define PATM_CPUID_CENTAUR_PTR 0xF1ABCD1a /**< Legacy, saved state only. */ +#define PATM_ASMFIX_FIXUP 0xF1ABCD07 +#define PATM_ASMFIX_PENDINGACTION 0xF1ABCD08 +#define PATM_ASMFIX_CPUID_STD_PTR 0xF1ABCD09 /**< Legacy, saved state only. */ +#define PATM_ASMFIX_CPUID_EXT_PTR 0xF1ABCD0a /**< Legacy, saved state only. */ +#define PATM_ASMFIX_CPUID_DEF_PTR 0xF1ABCD0b /**< Legacy, saved state only. */ +#define PATM_ASMFIX_STACKBASE 0xF1ABCD0c /**< Stack to store our private patch return addresses */ +#define PATM_ASMFIX_STACKBASE_GUEST 0xF1ABCD0d /**< Stack to store guest return addresses */ +#define PATM_ASMFIX_STACKPTR 0xF1ABCD0e +#define PATM_ASMFIX_PATCHBASE 0xF1ABCD0f +#define PATM_ASMFIX_INTERRUPTFLAG 0xF1ABCD10 +#define PATM_ASMFIX_INHIBITIRQADDR 0xF1ABCD11 +#define PATM_ASMFIX_VM_FORCEDACTIONS 0xF1ABCD12 +#define PATM_ASMFIX_TEMP_EAX 0xF1ABCD13 /**< Location for original EAX register */ +#define PATM_ASMFIX_TEMP_ECX 0xF1ABCD14 /**< Location for original ECX register */ +#define PATM_ASMFIX_TEMP_EDI 0xF1ABCD15 /**< Location for original EDI register */ +#define PATM_ASMFIX_TEMP_EFLAGS 0xF1ABCD16 /**< Location for original eflags */ +#define PATM_ASMFIX_TEMP_RESTORE_FLAGS 0xF1ABCD17 /**< Which registers to restore */ +#define PATM_ASMFIX_CALL_PATCH_TARGET_ADDR 0xF1ABCD18 +#define PATM_ASMFIX_CALL_RETURN_ADDR 0xF1ABCD19 +#define PATM_ASMFIX_CPUID_CENTAUR_PTR 0xF1ABCD1a /**< Legacy, saved state only. */ #define PATM_ASMFIX_REUSE_LATER_0 0xF1ABCD1b #define PATM_ASMFIX_REUSE_LATER_1 0xF1ABCD1c @@ -60,20 +60,20 @@ /* Anything larger doesn't require a fixup */ -#define PATM_NO_FIXUP 0xF1ABCE00 -#define PATM_CPUID_STD_MAX 0xF1ABCE00 -#define PATM_CPUID_EXT_MAX 0xF1ABCE01 -#define PATM_RETURNADDR 0xF1ABCE02 -#define PATM_PATCHNEXTBLOCK 0xF1ABCE03 -#define PATM_CALLTARGET 0xF1ABCE04 /**< relative call target */ -#define PATM_NEXTINSTRADDR 0xF1ABCE05 /**< absolute guest address of the next instruction */ -#define PATM_CURINSTRADDR 0xF1ABCE06 /**< absolute guest address of the current instruction */ -#define PATM_LOOKUP_AND_CALL_FUNCTION 0xF1ABCE07 /**< Relative address of global PATM lookup and call function. */ -#define PATM_RETURN_FUNCTION 0xF1ABCE08 /**< Relative address of global PATM return function. */ -#define PATM_LOOKUP_AND_JUMP_FUNCTION 0xF1ABCE09 /**< Relative address of global PATM lookup and jump function. */ -#define PATM_IRET_FUNCTION 0xF1ABCE0A /**< Relative address of global PATM iret function. */ -#define PATM_CPUID_CENTAUR_MAX 0xF1ABCE0B +#define PATM_ASMFIX_NO_FIXUP 0xF1ABCE00 +#define PATM_ASMFIX_CPUID_STD_MAX 0xF1ABCE00 +#define PATM_ASMFIX_CPUID_EXT_MAX 0xF1ABCE01 +#define PATM_ASMFIX_RETURNADDR 0xF1ABCE02 +#define PATM_ASMFIX_PATCHNEXTBLOCK 0xF1ABCE03 +#define PATM_ASMFIX_CALLTARGET 0xF1ABCE04 /**< relative call target */ +#define PATM_ASMFIX_NEXTINSTRADDR 0xF1ABCE05 /**< absolute guest address of the next instruction */ +#define PATM_ASMFIX_CURINSTRADDR 0xF1ABCE06 /**< absolute guest address of the current instruction */ +#define PATM_ASMFIX_LOOKUP_AND_CALL_FUNCTION 0xF1ABCE07 /**< Relative address of global PATM lookup and call function. */ +#define PATM_ASMFIX_RETURN_FUNCTION 0xF1ABCE08 /**< Relative address of global PATM return function. */ +#define PATM_ASMFIX_LOOKUP_AND_JUMP_FUNCTION 0xF1ABCE09 /**< Relative address of global PATM lookup and jump function. */ +#define PATM_ASMFIX_IRET_FUNCTION 0xF1ABCE0A /**< Relative address of global PATM iret function. */ +#define PATM_ASMFIX_CPUID_CENTAUR_MAX 0xF1ABCE0B /** Identifies an patch fixup type value (with reasonable accuracy). */ -#define PATM_IS_FIXUP_TYPE(a_uValue) \ +#define PATM_IS_ASMFIX(a_uValue) \ ( ((a_uValue) & UINT32_C(0xfffffC00)) == UINT32_C(0xF1ABCC00) && ((a_uValue) & UINT32_C(0xff)) < UINT32_C(0x30) ) /** @} */ @@ -113,5 +113,5 @@ #define PATM_ACTION_MAGIC 0xABCD4321 -/** @name PATM_TEMP_RESTORE_FLAGS +/** @name PATM_ASMFIX_TEMP_RESTORE_FLAGS * @{ */ #define PATM_RESTORE_EAX RT_BIT(0) Index: /trunk/src/VBox/VMM/include/PATMInternal.h =================================================================== --- /trunk/src/VBox/VMM/include/PATMInternal.h (revision 54763) +++ /trunk/src/VBox/VMM/include/PATMInternal.h (revision 54764) @@ -70,5 +70,5 @@ #define PATMFL_CALLABLE_AS_FUNCTION RT_BIT_64(25) /** cli and pushf blocks can be used as callable functions. */ #define PATMFL_GLOBAL_FUNCTIONS RT_BIT_64(26) /** fake patch for global patm functions. */ -#define PATMFL_TRAMPOLINE RT_BIT_64(27) /** trampoline patch that clears PATM_INTERRUPTFLAG and jumps to patch destination */ +#define PATMFL_TRAMPOLINE RT_BIT_64(27) /** trampoline patch that clears PATM_ASMFIX_INTERRUPTFLAG and jumps to patch destination */ #define PATMFL_GENERATE_SETPIF RT_BIT_64(28) /** generate set PIF for the next instruction */ #define PATMFL_INSTR_HINT RT_BIT_64(29) /** Generate patch, but don't activate it. */ @@ -112,5 +112,5 @@ * * The source and desination addresses both set to the patch fixup type (see - * PATM_IS_FIXUP_TYPE and friends in PATMA.h). This is recent addition (CPUID + * PATM_IS_ASMFIX and friends in PATMA.h). This is recent addition (CPUID * subleaf code), so when loading older saved states this is usally represented * as FIXUP_ABSOLUTE. */