able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/dpmi32/modesw.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

911 lines
18 KiB
C
Raw Blame History

/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
modesw.c
Abstract:
This module provides support for performing mode switching on the 32 bit
side.
Author:
Dave Hastings (daveh) 24-Nov-1992
Revision History:
Neil Sandlin (neilsa) 31-Jul-1995 - Updates for the 486 emulator
--*/
#include "precomp.h"
#pragma hdrstop
#include "softpc.h"
RMCB_INFO DpmiRmcb[MAX_RMCBS];
USHORT RMCallBackBopSeg;
USHORT RMCallBackBopOffset;
#define SAVE_ALT_REGS(Regs) { \
Regs.Eip = getEIP(); \
Regs.Esp = getESP(); \
Regs.Cs = getCS(); \
Regs.Ds = getDS(); \
Regs.Es = getES(); \
Regs.Fs = getFS(); \
Regs.Gs = getGS(); \
Regs.Ss = getSS(); \
}
#define SET_ALT_REGS(Regs) { \
setEIP(Regs.Eip); \
setESP(Regs.Esp); \
setCS(Regs.Cs); \
setDS(Regs.Ds); \
setES(Regs.Es); \
setFS(Regs.Fs); \
setGS(Regs.Gs); \
setSS(Regs.Ss); \
}
typedef struct _ALT_REGS {
ULONG Eip;
ULONG Esp;
USHORT Cs;
USHORT Ss;
USHORT Es;
USHORT Ds;
USHORT Fs;
USHORT Gs;
} ALT_REGS, *PALT_REGS;
ALT_REGS AltRegs = {0};
VOID
DpmiSetAltRegs(
VOID
)
{
DECLARE_LocalVdmContext;
SAVE_ALT_REGS(AltRegs);
}
VOID
SetV86Exec(
VOID
)
/*++
Routine Description:
This routine performs a mode switch to real (v86) mode.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
setMSW(getMSW() & ~MSW_PE);
#ifndef _X86_
//BUGBUG This is a workaround to reload a 64k limit into SS for the
// emulator, now that we are in real mode.
// Not doing this would cause the emulator to do a hardware reset
setSS_BASE_LIMIT_AR(getSS_BASE(), 0xffff, getSS_AR());
#else
//
// If we have v86 mode fast IF emulation set the RealInstruction bit
//
if (VdmFeatureBits & V86_VIRTUAL_INT_EXTENSIONS) {
_asm {
mov eax,FIXED_NTVDMSTATE_LINEAR ; get pointer to VDM State
lock or dword ptr [eax], dword ptr RI_BIT_MASK
}
} else {
_asm {
mov eax,FIXED_NTVDMSTATE_LINEAR ; get pointer to VDM State
lock and dword ptr [eax], dword ptr ~RI_BIT_MASK
}
}
//
// turn on real mode bit
//
_asm {
mov eax,FIXED_NTVDMSTATE_LINEAR ; get pointer to VDM State
lock or dword ptr [eax], dword ptr RM_BIT_MASK
}
#endif
setEFLAGS((getEFLAGS() & ~(EFLAGS_RF_MASK | EFLAGS_NT_MASK)));
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_IN_V86, 0, 0);
}
VOID
SetPMExec(
VOID
)
/*++
Routine Description:
This routine performs a mode switch to protected mode.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
setMSW(getMSW() | MSW_PE);
#ifndef _X86_
//BUGBUG This is a workaround to make sure the emulator goes back
// to privilege level 3 now that we are in protect mode.
// Not doing this would cause an access violation in dpmi32.
setCPL(3);
#else
//
// If we have fast if emulation in PM set the RealInstruction bit
//
if (VdmFeatureBits & PM_VIRTUAL_INT_EXTENSIONS) {
_asm {
mov eax,FIXED_NTVDMSTATE_LINEAR ; get pointer to VDM State
lock or dword ptr [eax], dword ptr RI_BIT_MASK
}
} else {
_asm {
mov eax, FIXED_NTVDMSTATE_LINEAR ; get pointer to VDM State
lock and dword ptr [eax], dword ptr ~RI_BIT_MASK
}
}
//
// Turn off real mode bit
//
_asm {
mov eax,FIXED_NTVDMSTATE_LINEAR ; get pointer to VDM State
lock and dword ptr [eax], dword ptr ~RM_BIT_MASK
}
#endif
setEFLAGS((getEFLAGS() & ~(EFLAGS_RF_MASK | EFLAGS_NT_MASK)));
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_IN_PM, 0, 0);
}
VOID
switch_to_protected_mode(
VOID
)
/*++
Routine Description:
This routine is called via BOP from DOSX to transition to
protected mode.
Arguments:
None
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PCHAR StackPointer;
StackPointer = VdmMapFlat(getSS(), getSP(), getMODE());
setCS(*(PUSHORT)(StackPointer + 12));
setEIP(*(PULONG)(StackPointer + 8));
setSS(*(PUSHORT)(StackPointer + 6));
setESP(*(PULONG)(StackPointer + 2));
setDS(*(PUSHORT)(StackPointer));
//
// Necessary to prevent loads of invalid selectors in FastEnterPM
//
setES((USHORT)0);
setGS((USHORT)0);
setFS((USHORT)0);
SetPMExec();
}
VOID
switch_to_real_mode(
VOID
)
/*++
Routine Description:
This routine services the switch to real mode bop. It is included in
DPMI.c so that all of the mode switching services are in the same place
Arguments:
None
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PCHAR StackPointer;
StackPointer = VdmMapFlat(getSS(), getSP(), getMODE());
LastLockedPMStackESP = getESP();
LastLockedPMStackSS = getSS();
setDS(*(PUSHORT)(StackPointer));
setESP((ULONG) *(PUSHORT)(StackPointer + 2));
setSS(*(PUSHORT)(StackPointer + 4));
setEIP((ULONG) *(PUSHORT)(StackPointer + 6));
setCS(*(PUSHORT)(StackPointer + 8));
SetV86Exec();
}
VOID
DpmiSwitchToRealMode(
VOID
)
/*++
Routine Description:
This routine is called internally from DPMI32 (i.e. Int21map)
to switch to real mode.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PWORD16 Data;
// HACK ALERT
Data = (PWORD16) VdmMapFlat(DosxRmCodeSegment, 4, VDM_V86);
*(Data) = DosxStackSegment;
LastLockedPMStackESP = getESP();
LastLockedPMStackSS = getSS();
setCS(DosxRmCodeSegment);
SetV86Exec();
}
VOID
DpmiSwitchToProtectedMode(
VOID
)
/*++
Routine Description:
This routine is called internally from DPMI32 (i.e. Int21map)
to switch to real mode.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PWORD16 Data;
// HACK ALERT
Data = (PWORD16) VdmMapFlat(DosxRmCodeSegment, 4, VDM_V86);
*(Data) = 0xb7;
setESP(LastLockedPMStackESP);
setSS(LastLockedPMStackSS);
SetPMExec();
}
VOID
DpmiAllocateRMCallBack(
VOID
)
/*++
Routine Description:
Service 03/03 -- Allocate Real Mode Call-Back Address
In: ax = selector to use to point to rm stack
ds:si -> pMode CS:IP to be called when rMode
call-back address executed
es:di -> client register structure to be updated
when call-back address executed
NOTE: client's DS and ES register values are on stack
Out: cx:dx -> SEGMENT:offset of real mode call-back hook
CY clear if successful, CY set if can't allocate
call back
--*/
{
DECLARE_LocalVdmContext;
int i;
for (i=0; i<MAX_RMCBS; i++) {
if (!DpmiRmcb[i].bInUse) {
break;
}
}
if (i == MAX_RMCBS) {
// no more rmcbs
setCF(1);
return;
}
DpmiRmcb[i].StackSel = ALLOCATE_SELECTOR();
if (!DpmiRmcb[i].StackSel) {
// no more selectors
setCF(1);
return;
}
SetDescriptor(DpmiRmcb[i].StackSel, 0, 0xffff, STD_DATA);
DpmiRmcb[i].bInUse = TRUE;
DpmiRmcb[i].StrucSeg = getES(); // get client ES register
DpmiRmcb[i].StrucOffset = (*GetDIRegister)();
DpmiRmcb[i].ProcSeg = getDS();
DpmiRmcb[i].ProcOffset = (*GetSIRegister)();
setCX(RMCallBackBopSeg - i);
setDX(RMCallBackBopOffset + (i*16));
setCF(0);
}
VOID
DpmiFreeRMCallBack(
VOID
)
/*++
Routine Description:
Service 03/04 -- Free Real Mode Call-Back Address
In: cx:dx -> SEGMENT:offset of rMode call-back to free
Out: CY clear if successful, CY set if failure
ax = utility selector which should be freed
--*/
{
DECLARE_LocalVdmContext;
USHORT i = RMCallBackBopSeg - getCX();
if ((i >= MAX_RMCBS) || !DpmiRmcb[i].bInUse) {
// already free or invalid callback address
setCF(1);
return;
}
DpmiRmcb[i].bInUse = FALSE;
FreeSelector(DpmiRmcb[i].StackSel);
setCF(0);
}
VOID
GetRMClientRegs(
PDPMI_RMCALLSTRUCT pcs
)
{
DECLARE_LocalVdmContext;
pcs->Edi = getEDI();
pcs->Esi = getESI();
pcs->Ebp = getEBP();
pcs->Ebx = getEBX();
pcs->Edx = getEDX();
pcs->Ecx = getECX();
pcs->Eax = getEAX();
pcs->Flags = (WORD) getEFLAGS();
pcs->Es = getES();
pcs->Ds = getDS();
pcs->Fs = getFS();
pcs->Gs = getGS();
}
VOID
SetRMClientRegs(
PDPMI_RMCALLSTRUCT pcs
)
{
DECLARE_LocalVdmContext;
setEDI(pcs->Edi);
setESI(pcs->Esi);
setEBP(pcs->Ebp);
setEBX(pcs->Ebx);
setEDX(pcs->Edx);
setECX(pcs->Ecx);
setEAX(pcs->Eax);
setEFLAGS((getEFLAGS()&0xffff0000) + (ULONG)pcs->Flags);
setES(pcs->Es);
setDS(pcs->Ds);
setFS(pcs->Fs);
setGS(pcs->Gs);
}
VOID
DpmiRMCallBackCall(
VOID
)
/*++
Routine Description:
This routine gets control when the application executes the
callback address allocated by DPMI func 0x303. Its job is
to switch the processor into protect mode as defined by the
DPMI spec.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PDPMI_RMCALLSTRUCT pcs;
ULONG StackBase;
ULONG CurBase;
BOOL bStackBaseRestore = FALSE;
USHORT StackSel;
PUCHAR VdmStackPointer;
ULONG NewSP;
USHORT i = RMCallBackBopSeg - getCS();
if ((i >= MAX_RMCBS) || !DpmiRmcb[i].bInUse) {
// already free or invalid callback address
return;
}
//
// Point ip back to BOP (per dpmi)
//
setIP(getIP()-4);
pcs = (PDPMI_RMCALLSTRUCT) VdmMapFlat(DpmiRmcb[i].StrucSeg,
DpmiRmcb[i].StrucOffset,
VDM_PM);
GetRMClientRegs(pcs);
pcs->Ip = getIP();
pcs->Cs = getCS();
pcs->Sp = getSP();
pcs->Ss = getSS();
// Win31 saves DS-GS on the stack here.
StackBase = (ULONG)(pcs->Ss<<4);
StackSel = DpmiRmcb[i].StackSel;
CurBase = GET_SELECTOR_BASE(StackSel);
if (StackBase != CurBase) {
bStackBaseRestore = TRUE;
SetDescriptorBase(StackSel, StackBase);
}
setESI(getSP());
setEDI(DpmiRmcb[i].StrucOffset);
DpmiSwitchToProtectedMode();
BeginUseLockedPMStack();
setDS(DpmiRmcb[i].StackSel);
setES(DpmiRmcb[i].StrucSeg);
BuildStackFrame(3, &VdmStackPointer, &NewSP);
if (Frame32) {
*(PDWORD16)(VdmStackPointer-4) = 0x202;
*(PDWORD16)(VdmStackPointer-8) = PmBopFe >> 16;
*(PDWORD16)(VdmStackPointer-12) = PmBopFe & 0x0000FFFF;
setESP(NewSP);
} else {
*(PWORD16)(VdmStackPointer-2) = 0x202;
*(PWORD16)(VdmStackPointer-4) = (USHORT) (PmBopFe >> 16);
*(PWORD16)(VdmStackPointer-6) = (USHORT) PmBopFe;
setSP((WORD)NewSP);
}
setEIP(DpmiRmcb[i].ProcOffset);
setCS(DpmiRmcb[i].ProcSeg);
#ifndef _X86_
// preserve iopl
setEFLAGS(getEFLAGS() | 0x3000);
#endif
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_REFLECT_TO_PM, 0, 0);
host_simulate(); // execute PM callback
//
// restore stack descriptor if need be
//
if (bStackBaseRestore) {
SetDescriptorBase(StackSel, CurBase);
}
pcs = (PDPMI_RMCALLSTRUCT) VdmMapFlat(getES(),
(*GetDIRegister)(),
VDM_PM);
// win31 restores GS-DS here. Is this only for End_Nest_Exec?
EndUseLockedPMStack();
DpmiSwitchToRealMode();
SetRMClientRegs(pcs);
setSP(pcs->Sp);
setSS(pcs->Ss);
setCS(pcs->Cs);
setIP(pcs->Ip);
}
VOID
DpmiReflectIntrToPM(
VOID
)
/*++
Routine Description:
This routine gets control when a real mode interrupt is executed that is hooked
in protected mode. The responsibility of this routine is to switch into PM, reflect
the interrupt, and return to real mode.
The actual interrupt number is encoded into CS by subtracting the interrupt number
from the normal dosx real mode code segment. IP is then adjusted accordingly to
point to the same place.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PUCHAR VdmCodePointer;
ULONG IntNumber;
PUCHAR VdmStackPointer;
ULONG NewSP;
ULONG ISRFlags;
ULONG SaveEFlags = getEFLAGS();
USHORT SaveBP;
ALT_REGS RMSave;
IntNumber = (ULONG) (HIWORD(DosxRMReflector) - getCS());
SAVE_ALT_REGS(RMSave);
DpmiSwitchToProtectedMode();
setES((USHORT)0);
setDS((USHORT)0);
setFS((USHORT)0);
setGS((USHORT)0);
BeginUseLockedPMStack();
DpmiSwIntHandler(IntNumber);
//
// Put unsimulate bop on the stack so we get control after the handler's iret
//
BuildStackFrame(3, &VdmStackPointer, &NewSP);
if (Frame32) {
*(PDWORD16)(VdmStackPointer-4) = getEFLAGS();
*(PDWORD16)(VdmStackPointer-8) = PmBopFe >> 16;
*(PDWORD16)(VdmStackPointer-12) = PmBopFe & 0x0000FFFF;
setESP(NewSP);
} else {
*(PWORD16)(VdmStackPointer-2) = LOWORD(getEFLAGS());
*(PWORD16)(VdmStackPointer-4) = (USHORT) (PmBopFe >> 16);
*(PWORD16)(VdmStackPointer-6) = (USHORT) PmBopFe;
setSP((WORD)NewSP);
}
// Do special case processing for int24
if (IntNumber == 0x24) {
SaveBP = getBP();
setBP(SegmentToSelector(SaveBP, STD_DATA));
}
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_REFLECT_TO_PM, 0, 0);
host_simulate(); // execute interrupt
if (IntNumber == 0x24) {
setBP(SaveBP);
}
//
// simulate an iret for the frame generated by the SwIntHandler
//
if (Frame32) {
setEIP(*(PDWORD16)(VdmStackPointer));
setCS((USHORT)*(PDWORD16)(VdmStackPointer+4));
setEFLAGS(*(PDWORD16)(VdmStackPointer+8));
setESP(getESP()+12);
} else {
setIP(*(PWORD16)(VdmStackPointer));
setCS(*(PWORD16)(VdmStackPointer+2));
setEFLAGS((getEFLAGS()&0xffff0000) + *(PWORD16)(VdmStackPointer+4));
setSP(getSP()+6);
}
ISRFlags = getEFLAGS();
EndUseLockedPMStack();
DpmiSwitchToRealMode();
//
// do the final iret back to the app
//
setESP(RMSave.Esp);
setSS(RMSave.Ss);
setDS(RMSave.Ds);
setES(RMSave.Es);
setFS(RMSave.Fs);
setGS(RMSave.Gs);
SimulateIret(PASS_FLAGS);
}
VOID
DpmiReflectIntrToV86(
VOID
)
/*++
Routine Description:
This routine gets control when the end of the interrupt chain is reached
in protected mode. The responsibility of this routine is to switch into V86 mode,
reflect the interrupt, and return to protected mode.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
PUCHAR VdmCodePointer;
ULONG IntNumber;
PUCHAR VdmStackPointer;
USHORT SaveSS, SaveSP;
USHORT SaveCS, SaveIP;
ALT_REGS PMSave;
ULONG IntHandler;
VdmCodePointer = VdmMapFlat(getCS(), getIP(), VDM_PM);
IntNumber = (ULONG) *VdmCodePointer;
if (DispatchPMInt((UCHAR)IntNumber)) {
return;
}
SAVE_ALT_REGS(PMSave);
DpmiSwitchToRealMode();
//
// find a safe stack to run on in v86 mode
//
SaveSS = getSS();
SaveSP = getSP();
SWITCH_TO_DOSX_RMSTACK();
//
// Put unsimulate bop on the stack so we get control after the handler's iret
//
VdmStackPointer = VdmMapFlat(getSS(), getSP(), VDM_V86);
SaveCS = getCS();
SaveIP = getIP();
*(PWORD16)(VdmStackPointer-2) = LOWORD(getEFLAGS());
*(PWORD16)(VdmStackPointer-4) = (USHORT) (RmBopFe >> 16);
*(PWORD16)(VdmStackPointer-6) = (USHORT) RmBopFe;
setSP(getSP() - 6);
IntHandler = *(PDWORD16) (IntelBase + IntNumber*4);
setIP(LOWORD(IntHandler));
setCS(HIWORD(IntHandler));
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_REFLECT_TO_V86, 0, 0);
host_simulate(); // execute interrupt
setIP(SaveIP);
setCS(SaveCS);
setSP(SaveSP);
setSS(SaveSS);
SWITCH_FROM_DOSX_RMSTACK();
DpmiSwitchToProtectedMode();
//
// do the final iret back to the app
//
setESP(PMSave.Esp);
setSS(PMSave.Ss);
setDS(PMSave.Ds);
setES(PMSave.Es);
setFS(PMSave.Fs);
setGS(PMSave.Gs);
SimulateIret(PASS_FLAGS);
}
VOID
DpmiRMCall(
UCHAR mode
)
/*++
Routine Description:
This routine gets control when an Int31 func 300-302 is executed.
The responsibility of this routine is to switch into V86 mode,
reflect the interrupt, and return to protected mode.
Arguments:
None.
Return Value:
None.
--*/
{
DECLARE_LocalVdmContext;
CLIENT_REGS SaveRegs;
PDPMI_RMCALLSTRUCT pcs;
BOOL bUsingOurStack;
PUCHAR RmStackPointer, PmStackPointer;
USHORT CopyLen;
ULONG PmSp = (*GetSPRegister)();
pcs = (PDPMI_RMCALLSTRUCT) VdmMapFlat(getES(),
(*GetDIRegister)(),
VDM_PM);
SAVE_CLIENT_REGS(SaveRegs);
DpmiSwitchToRealMode();
//
// This bop will get us back from host_simulate
//
setCS((USHORT)(RmBopFe >> 16));
setIP((USHORT)RmBopFe);
SetRMClientRegs(pcs);
if (!pcs->Ss && !pcs->Sp) {
SWITCH_TO_DOSX_RMSTACK();
bUsingOurStack = TRUE;
} else {
setSS(pcs->Ss);
setSP(pcs->Sp);
bUsingOurStack = FALSE;
}
if (CopyLen = LOWORD(SaveRegs.Ecx)) {
CopyLen *= 2;
setSP(getSP() - CopyLen);
PmStackPointer = VdmMapFlat(SaveRegs.Ss, PmSp, VDM_PM);
RmStackPointer = VdmMapFlat(getSS(), getSP(), VDM_V86);
RtlCopyMemory(RmStackPointer, PmStackPointer, CopyLen);
}
//
// switch on MODE
//
switch(mode) {
case 0:
// Simulate Int
EmulateV86Int((UCHAR)SaveRegs.Ebx);
break;
case 1:
// Call with FAR return frame
SimulateFarCall(pcs->Cs, pcs->Ip);
break;
case 2:
// Call with IRET frame
SimulateCallWithIretFrame(pcs->Cs, pcs->Ip);
break;
}
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_REFLECT_TO_V86, 0, 0);
host_simulate(); // execute interrupt
if (bUsingOurStack) {
SWITCH_FROM_DOSX_RMSTACK();
}
GetRMClientRegs(pcs);
DpmiSwitchToProtectedMode();
SET_CLIENT_REGS(SaveRegs);
setCF(0); // function successful
}
Reference in a new issue View git blame Copy permalink