vdm.c File Reference

#include "ki.h"
#include "vdmntos.h"

Go to the source code of this file.

Defines
#define	VDM_IO_TEST   0
#define	STRINGIO_BUFFER_SIZE   1024
Functions
BOOLEAN	Ki386GetSelectorParameters (IN USHORT Selector, OUT PULONG Flags, OUT PULONG Base, OUT PULONG Limit)
BOOLEAN	Ki386VdmDispatchIo (IN ULONG PortNumber, IN ULONG Size, IN BOOLEAN Read, IN UCHAR InstructionSize, IN PKTRAP_FRAME TrapFrame)
BOOLEAN	Ki386VdmDispatchStringIo (IN ULONG PortNumber, IN ULONG Size, IN BOOLEAN Rep, IN BOOLEAN Read, IN ULONG Count, IN ULONG Address, IN UCHAR InstructionSize, IN PKTRAP_FRAME TrapFrame)
BOOLEAN	VdmDispatchIoToHandler (IN PVDM_IO_HANDLER VdmIoHandler, IN ULONG Context, IN ULONG PortNumber, IN ULONG Size, IN BOOLEAN Read, IN OUT PULONG Data)
BOOLEAN	VdmDispatchUnalignedIoToHandler (IN PVDM_IO_HANDLER VdmIoHandler, IN ULONG Context, IN ULONG PortNumber, IN ULONG Size, IN BOOLEAN Read, IN OUT PULONG Data)
BOOLEAN	VdmDispatchStringIoToHandler (IN PVDM_IO_HANDLER VdmIoHandler, IN ULONG Context, IN ULONG PortNumber, IN ULONG Size, IN ULONG Count, IN BOOLEAN Read, IN ULONG Data)
BOOLEAN	VdmCallStringIoHandler (IN PVDM_IO_HANDLER VdmIoHandler, IN PVOID StringIoRoutine, IN ULONG Context, IN ULONG PortNumber, IN ULONG Size, IN ULONG Count, IN BOOLEAN Read, IN ULONG Data)
BOOLEAN	VdmConvertToLinearAddress (IN ULONG SegmentedAddress, IN PVOID *LinearAddress)
VOID	KeI386VdmInitialize (VOID)
ULONG	Ki386VdmEnablePentiumExtentions (ULONG)
BOOLEAN	VdmConvertToLinearAddress (IN ULONG SegmentedAddress, OUT PVOID *LinearAddress)
BOOLEAN	Ke386VdmInsertQueueApc (IN PKAPC Apc, IN PKTHREAD Thread, IN KPROCESSOR_MODE ApcMode, IN PKKERNEL_ROUTINE KernelRoutine, IN PKRUNDOWN_ROUTINE RundownRoutine OPTIONAL, IN PKNORMAL_ROUTINE NormalRoutine OPTIONAL, IN PVOID NormalContext OPTIONAL, IN KPRIORITY Increment)
VOID	Ke386VdmClearApcObject (IN PKAPC Apc)
Variables
KMUTEX	VdmStringIoMutex
ULONG	VdmFixedStateLinear
ULONG	KeI386EFlagsAndMaskV86 = EFLAGS_USER_SANITIZE
ULONG	KeI386EFlagsOrMaskV86 = EFLAGS_INTERRUPT_MASK
BOOLEAN	KeI386VdmIoplAllowed = FALSE
ULONG	KeI386VirtualIntExtensions = 0
UCHAR	VdmStringIoBuffer [STRINGIO_BUFFER_SIZE]

---

Define Documentation

#define STRINGIO_BUFFER_SIZE   1024

Definition at line 878 of file ke/i386/vdm.c. Referenced by VdmCallStringIoHandler().

#define VDM_IO_TEST   0

Definition at line 39 of file ke/i386/vdm.c.

---

Function Documentation

VOID Ke386VdmClearApcObject (  IN PKAPC  Apc  )

Definition at line 1437 of file ke/i386/vdm.c. References KiLockDispatcherDatabase, KiUnlockDispatcherDatabase(), and NULL. Referenced by VdmpDelayIntApcRoutine(), and VdmpQueueIntApcRoutine(). : Clears a VDM APC object, synchronously with Ke386VdmInsertQueueApc, and is expected to be called by one of the vdm kernel apc routine or the rundown routine. Arguments: Apc - Supplies a pointer to a control object of type APC. Return Value: void --*/ { KIRQL OldIrql; // // Take Dispatcher database lock, to sync with Ke386VDMInsertQueueApc // KiLockDispatcherDatabase(&OldIrql); Apc->Thread = NULL; KiUnlockDispatcherDatabase(OldIrql); }

BOOLEAN Ke386VdmInsertQueueApc (  IN PKAPC  Apc, IN PKTHREAD  Thread, IN KPROCESSOR_MODE  ApcMode, IN PKKERNEL_ROUTINE  KernelRoutine, IN PKRUNDOWN_ROUTINE RundownRoutine  OPTIONAL, IN PKNORMAL_ROUTINE NormalRoutine  OPTIONAL, IN PVOID NormalContext  OPTIONAL, IN KPRIORITY  Increment )

Definition at line 1257 of file ke/i386/vdm.c. References _KAPC_STATE::ApcListHead, ApcObject, _KTHREAD::ApcQueueLock, FALSE, Increment, _KAPC_STATE::KernelApcPending, KernelMode, KiBoostPriorityThread, KiInsertQueueApc(), KiLockDispatcherDatabase, KiUnlockDispatcherDatabase(), NULL, OriginalApcEnvironment, TRUE, _KAPC_STATE::UserApcPending, and UserMode. Referenced by VdmpDelayIntDpcRoutine(), VdmpQueueIntApcRoutine(), and VdmpQueueInterrupt(). : This function initializes, and queues a vdm type of APC to the specified thread. A Vdm type of APC: - OriginalApcEnvironment - will only be queued to one thread at a time - if UserMode Fires on the next system exit. A UserMode apc should not be queued if the current vdm context is not application mode. Arguments: Apc - Supplies a pointer to a control object of type APC. Thread - Supplies a pointer to a dispatcher object of type thread. ApcMode - Supplies the processor mode user\kernel of the Apc KernelRoutine - Supplies a pointer to a function that is to be executed at IRQL APC_LEVEL in kernel mode. RundownRoutine - Supplies an optional pointer to a function that is to be called if the APC is in a thread's APC queue when the thread terminates. NormalRoutine - Supplies an optional pointer to a function that is to be executed at IRQL 0 in the specified processor mode. If this parameter is not specified, then the ProcessorMode and NormalContext parameters are ignored. NormalContext - Supplies a pointer to an arbitrary data structure which is to be passed to the function specified by the NormalRoutine parameter. Increment - Supplies the priority increment that is to be applied if queuing the APC causes a thread wait to be satisfied. Return Value: If APC queuing is disabled, then a value of FALSE is returned. Otherwise a value of TRUE is returned. --*/ { PKAPC_STATE ApcState; PKTHREAD ApcThread; KIRQL OldIrql; BOOLEAN Inserted; // // Raise IRQL to dispatcher level and lock dispatcher database. // KiLockDispatcherDatabase(&OldIrql); // // If the apc object not initialized, then initialize it and acquire // the target thread APC queue lock. // if (Apc->Type != ApcObject) { Apc->Type = ApcObject; Apc->Size = sizeof(KAPC); Apc->ApcStateIndex = OriginalApcEnvironment; } else { // // Acquire the APC thread APC queue lock. // // If the APC is inserted in the corresponding APC queue, and the // APC thread is not the same thread as the target thread, then // the APC is removed from its current queue, the APC pending state // is updated, the APC thread APC queue lock is released, and the // target thread APC queue lock is acquired. Otherwise, the APC // thread and the target thread are same thread and the APC is already // queued to the correct thread. // // If the APC is not inserted in an APC queue, then release the // APC thread APC queue lock and acquire the target thread APC queue // lock. // ApcThread = Apc->Thread; if (ApcThread) { KiAcquireSpinLock(&ApcThread->ApcQueueLock); if (Apc->Inserted) { if (ApcThread == Apc->Thread && Apc->Thread != Thread) { Apc->Inserted = FALSE; RemoveEntryList(&Apc->ApcListEntry); ApcState = Apc->Thread->ApcStatePointer[Apc->ApcStateIndex]; if (IsListEmpty(&ApcState->ApcListHead[Apc->ApcMode]) != FALSE) { if (Apc->ApcMode == KernelMode) { ApcState->KernelApcPending = FALSE; } else { ApcState->UserApcPending = FALSE; } } } else { KiReleaseSpinLock(&ApcThread->ApcQueueLock); KiUnlockDispatcherDatabase(OldIrql); return TRUE; } } KiReleaseSpinLock(&ApcThread->ApcQueueLock); } } KiAcquireSpinLock(&Thread->ApcQueueLock); Apc->ApcMode = ApcMode; Apc->Thread = Thread; Apc->KernelRoutine = KernelRoutine; Apc->RundownRoutine = RundownRoutine; Apc->NormalRoutine = NormalRoutine; Apc->SystemArgument1 = NULL; Apc->SystemArgument2 = NULL; Apc->NormalContext = NormalContext; // // Unlock the target thread APC queue. // KiReleaseSpinLock(&Thread->ApcQueueLock); // // If APC queuing is enable, then attempt to queue the APC object. // if (Thread->ApcQueueable && KiInsertQueueApc(Apc, Increment)) { Inserted = TRUE; // // If UserMode: // For vdm a UserMode Apc is only queued by a kernel mode // apc which is on the current thread for the target thread. // Force UserApcPending for User mode apcstate, so that // the apc will fire when this thread exits the kernel. // if (ApcMode == UserMode) { KiBoostPriorityThread(Thread, Increment); Thread->ApcState.UserApcPending = TRUE; } } else { Inserted = FALSE; } // // Unlock the dispatcher database, lower IRQL to its previous value, and // return whether the APC object was inserted. // KiUnlockDispatcherDatabase(OldIrql); return Inserted; }

VOID KeI386VdmInitialize (  VOID   )

BOOLEAN Ki386GetSelectorParameters (  IN USHORT  Selector, OUT PULONG  Flags, OUT PULONG  Base, OUT PULONG  Limit )

BOOLEAN Ki386VdmDispatchIo (  IN ULONG  PortNumber, IN ULONG  Size, IN BOOLEAN  Read, IN UCHAR  InstructionSize, IN PKTRAP_FRAME  TrapFrame )

Definition at line 307 of file ke/i386/vdm.c. References _VdmEventInfo::Event, _Vdm_Tib::EventInfo, EXCEPTION_EXECUTE_HANDLER, ExRaiseException(), FALSE, _VdmEventInfo::InstructionSize, _VdmEventInfo::IoInfo, _VdmIoInfo::PortNumber, Ps386GetVdmIoHandler(), PsGetCurrentProcess, PUSHORT, _VdmIoInfo::Read, _VdmIoInfo::Size, Size, TRUE, USHORT, VdmDispatchIoToHandler(), VdmDispatchUnalignedIoToHandler(), VdmEndExecution(), and VdmIO. : This routine sets up the Event info for an IO event, and causes the event to be reflected to the Monitor. It is assumed that interrupts are enabled upon entry, and Irql is at APC level. Arguments: PortNumber -- Supplies the port number the IO was done to Size -- Supplies the size of the IO operation. Read -- Indicates whether the IO operation was a read or a write. InstructionSize -- Supplies the size of the IO instruction in bytes. Return Value: True if the io instruction will be reflected to User mode. --*/ { PVDM_TIB VdmTib; EXCEPTION_RECORD ExceptionRecord; VDM_IO_HANDLER VdmIoHandler; ULONG Result; BOOLEAN Success = FALSE; ULONG Context; Success = Ps386GetVdmIoHandler( PsGetCurrentProcess(), PortNumber & ~0x3, &VdmIoHandler, &Context ); if (Success) { Result = TrapFrame->Eax; // if port is not aligned, perform unaligned IO // else do the io the easy way if (PortNumber % Size) { Success = VdmDispatchUnalignedIoToHandler( &VdmIoHandler, Context, PortNumber, Size, Read, &Result ); } else { Success = VdmDispatchIoToHandler( &VdmIoHandler, Context, PortNumber, Size, Read, &Result ); } } if (Success) { if (Read) { switch (Size) { case 4: TrapFrame->Eax = Result; break; case 2: *(PUSHORT)(&TrapFrame->Eax) = (USHORT)Result; break; case 1: *(PUCHAR)(&TrapFrame->Eax) = (UCHAR)Result; break; } } TrapFrame->Eip += (ULONG) InstructionSize; return TRUE; } else { try { VdmTib = ((PVDM_PROCESS_OBJECTS)PsGetCurrentProcess()->VdmObjects)->VdmTib; VdmTib->EventInfo.InstructionSize = (ULONG) InstructionSize; VdmTib->EventInfo.Event = VdmIO; VdmTib->EventInfo.IoInfo.PortNumber = (USHORT)PortNumber; VdmTib->EventInfo.IoInfo.Size = (USHORT)Size; VdmTib->EventInfo.IoInfo.Read = Read; } except(EXCEPTION_EXECUTE_HANDLER) { ExceptionRecord.ExceptionCode = STATUS_ACCESS_VIOLATION; ExceptionRecord.ExceptionFlags = 0; ExceptionRecord.NumberParameters = 0; ExRaiseException(&ExceptionRecord); return FALSE; } } VdmEndExecution(TrapFrame, VdmTib); return TRUE; }

BOOLEAN Ki386VdmDispatchStringIo (  IN ULONG  PortNumber, IN ULONG  Size, IN BOOLEAN  Rep, IN BOOLEAN  Read, IN ULONG  Count, IN ULONG  Address, IN UCHAR  InstructionSize, IN PKTRAP_FRAME  TrapFrame )

Definition at line 418 of file ke/i386/vdm.c. References _VdmStringIoInfo::Address, _VdmStringIoInfo::Count, Count, _VdmEventInfo::Event, _Vdm_Tib::EventInfo, EXCEPTION_EXECUTE_HANDLER, ExRaiseException(), FALSE, Index, _VdmEventInfo::InstructionSize, _VdmStringIoInfo::PortNumber, Ps386GetVdmIoHandler(), PsGetCurrentProcess, PUSHORT, _VdmStringIoInfo::Read, _VdmStringIoInfo::Size, Size, _VdmEventInfo::StringIoInfo, TRUE, USHORT, VdmDispatchStringIoToHandler(), VdmEndExecution(), and VdmStringIO. : This routine sets up the Event info for a string IO event, and causes the event to be reflected to the Monitor. It is assumed that interrupts are enabled upon entry, and Irql is at APC level. Arguments: PortNumber -- Supplies the port number the IO was done to Size -- Supplies the size of the IO operation. Read -- Indicates whether the IO operation was a read or a write. Count -- indicates the number of IO operations of Size size Address -- Indicates address for string io InstructionSize -- Supplies the size of the IO instruction in bytes. Return Value: True if the io instruction will be reflected to User mode. --*/ { PVDM_TIB VdmTib; EXCEPTION_RECORD ExceptionRecord; BOOLEAN Success = FALSE; VDM_IO_HANDLER VdmIoHandler; ULONG Context; Success = Ps386GetVdmIoHandler( PsGetCurrentProcess(), PortNumber & ~0x3, &VdmIoHandler, &Context ); if (Success) { Success = VdmDispatchStringIoToHandler( &VdmIoHandler, Context, PortNumber, Size, Count, Read, Address ); } if (Success) { PUSHORT pIndexRegister; USHORT Index; // WARNING no 32 bit address support pIndexRegister = Read ? (PUSHORT)&TrapFrame->Edi : (PUSHORT)&TrapFrame->Esi; if (TrapFrame->EFlags & EFLAGS_DF_MASK) { Index = *pIndexRegister - (USHORT)(Count * Size); } else { Index = *pIndexRegister + (USHORT)(Count * Size); } *pIndexRegister = Index; if (Rep) { (USHORT)TrapFrame->Ecx = 0; } TrapFrame->Eip += (ULONG) InstructionSize; return TRUE; } try { VdmTib = ((PVDM_PROCESS_OBJECTS)PsGetCurrentProcess()->VdmObjects)->VdmTib; VdmTib->EventInfo.InstructionSize = (ULONG) InstructionSize; VdmTib->EventInfo.Event = VdmStringIO; VdmTib->EventInfo.StringIoInfo.PortNumber = (USHORT)PortNumber; VdmTib->EventInfo.StringIoInfo.Size = (USHORT)Size; VdmTib->EventInfo.StringIoInfo.Rep = Rep; VdmTib->EventInfo.StringIoInfo.Read = Read; VdmTib->EventInfo.StringIoInfo.Count = Count; VdmTib->EventInfo.StringIoInfo.Address = Address; } except(EXCEPTION_EXECUTE_HANDLER) { ExceptionRecord.ExceptionCode = STATUS_ACCESS_VIOLATION; ExceptionRecord.ExceptionFlags = 0; ExceptionRecord.NumberParameters = 0; ExRaiseException(&ExceptionRecord); return FALSE; } VdmEndExecution(TrapFrame, VdmTib); return TRUE; }

ULONG Ki386VdmEnablePentiumExtentions (  ULONG   )

Referenced by KeI386VdmInitialize().

BOOLEAN VdmCallStringIoHandler (  IN PVDM_IO_HANDLER  VdmIoHandler, IN PVOID  StringIoRoutine, IN ULONG  Context, IN ULONG  PortNumber, IN ULONG  Size, IN ULONG  Count, IN BOOLEAN  Read, IN ULONG  Data )

Definition at line 882 of file ke/i386/vdm.c. References ASSERT, Count, EMULATOR_READ_ACCESS, EMULATOR_WRITE_ACCESS, EXCEPTION_EXECUTE_HANDLER, ExRaiseException(), NT_SUCCESS, NTSTATUS(), NULL, PDRIVER_IO_PORT_UCHAR_STRING, Size, Status, STRINGIO_BUFFER_SIZE, TRUE, VdmConvertToLinearAddress(), VdmDispatchIoToHandler(), VdmDispatchUnalignedIoToHandler(), and VdmStringIoBuffer. Referenced by VdmDispatchStringIoToHandler(). : This routine actually performs the call to string io routine. It takes care of buffering the user data in kernel space so that the device driver does not have to. If there is not a string io function, or the io is misaligned, it will be simulated as a series of normal io operations Arguments: StringIoRoutine -- Supplies a pointer to the string Io routine Context -- Supplies 32 bits of data set when the port was trapped PortNumber -- Supplies the number of the port to perform Io to Size -- Supplies the size of the io operations Count -- Supplies the number of Io operations in the string. Read -- Indicates a read operation Data -- Supplies a pointer to the user buffer to perform the io on. Returns TRUE if a handler was called FALSE if not. --*/ { ULONG TotalBytes,BytesDone,BytesToDo,LoopCount,NumberIo; PUCHAR CurrentDataPtr; UCHAR AccessType; EXCEPTION_RECORD ExceptionRecord; NTSTATUS Status; BOOLEAN Success; Success = VdmConvertToLinearAddress( Data, &CurrentDataPtr ); if (!Success) { ExceptionRecord.ExceptionCode = STATUS_ACCESS_VIOLATION; ExceptionRecord.ExceptionFlags = 0; ExceptionRecord.NumberParameters = 0; ExRaiseException(&ExceptionRecord); // Cause kernel exit, rather than Io reflection return TRUE; } TotalBytes = Count * Size; BytesDone = 0; if (PortNumber % Size) { StringIoRoutine = NULL; } if (Read) { AccessType = EMULATOR_READ_ACCESS; } else { AccessType = EMULATOR_WRITE_ACCESS; } // Set up try out here to avoid overhead in loop try { while (BytesDone < TotalBytes) { if ((BytesDone + STRINGIO_BUFFER_SIZE) > TotalBytes) { BytesToDo = TotalBytes - BytesDone; } else { BytesToDo = STRINGIO_BUFFER_SIZE; } ASSERT((!(BytesToDo % Size))); if (!Read) { RtlMoveMemory(VdmStringIoBuffer, CurrentDataPtr, BytesToDo); } NumberIo = BytesToDo / Size; if (StringIoRoutine) { // in order to avoid having 3 separate calls, one for each size // we simply cast the parameters appropriately for the // byte routine. Status = (*((PDRIVER_IO_PORT_UCHAR_STRING)StringIoRoutine))( Context, PortNumber, AccessType, VdmStringIoBuffer, NumberIo ); if (NT_SUCCESS(Status)) { Success |= TRUE; } } else { if (PortNumber % Size) { for (LoopCount = 0; LoopCount < NumberIo; LoopCount++ ) { Success |= VdmDispatchUnalignedIoToHandler( VdmIoHandler, Context, PortNumber, Size, Read, (PULONG)(VdmStringIoBuffer + LoopCount * Size) ); } } else { for (LoopCount = 0; LoopCount < NumberIo; LoopCount++ ) { Success |= VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber, Size, Read, (PULONG)(VdmStringIoBuffer + LoopCount * Size) ); } } } if (Read) { RtlMoveMemory(CurrentDataPtr, VdmStringIoBuffer, BytesToDo); } BytesDone += BytesToDo; CurrentDataPtr += BytesToDo; } } except(EXCEPTION_EXECUTE_HANDLER) { ExceptionRecord.ExceptionCode = GetExceptionCode(); ExceptionRecord.ExceptionFlags = 0; ExceptionRecord.NumberParameters = 0; ExRaiseException(&ExceptionRecord); // Cause kernel exit, rather than Io reflection Success = TRUE; } return Success; }

BOOLEAN VdmConvertToLinearAddress (  IN ULONG  SegmentedAddress, OUT PVOID *  LinearAddress )

Definition at line 1034 of file ke/i386/vdm.c. References KeGetCurrentThread, Ki386GetSelectorParameters(), TRUE, and USHORT. Referenced by VdmCallStringIoHandler(). : This routine converts the specified segmented address into a linear address, based on processor mode in user mode. Arguments: SegmentedAddress -- Supplies the segmented address to convert. LinearAddress -- Supplies a pointer to the destination for the coresponding linear address Return Value: True if the address was converted. False otherwise Note: A linear address of 0 is a valid return --*/ { PKTHREAD Thread; PKTRAP_FRAME TrapFrame; BOOLEAN Success; ULONG Base, Limit, Flags; Thread = KeGetCurrentThread(); TrapFrame = VdmGetTrapFrame(Thread); if (TrapFrame->EFlags & EFLAGS_V86_MASK) { *LinearAddress = (PVOID)(((SegmentedAddress & 0xFFFF0000) >> 12) + (SegmentedAddress & 0xFFFF)); Success = TRUE; } else { Success = Ki386GetSelectorParameters( (USHORT)((SegmentedAddress & 0xFFFF0000) >> 16), &Flags, &Base, &Limit ); if (Success) { *LinearAddress = (PVOID)(Base + (SegmentedAddress & 0xFFFF)); } } return Success; }

BOOLEAN VdmConvertToLinearAddress (  IN ULONG  SegmentedAddress, IN PVOID *  LinearAddress )

BOOLEAN VdmDispatchIoToHandler (  IN PVDM_IO_HANDLER  VdmIoHandler, IN ULONG  Context, IN ULONG  PortNumber, IN ULONG  Size, IN BOOLEAN  Read, IN OUT PULONG  Data )

Definition at line 535 of file ke/i386/vdm.c. References ASSERT, EMULATOR_READ_ACCESS, EMULATOR_WRITE_ACCESS, FALSE, NT_SUCCESS, NTSTATUS(), PUSHORT, Size, Status, TRUE, and USHORT. Referenced by Ki386VdmDispatchIo(), VdmCallStringIoHandler(), and VdmDispatchUnalignedIoToHandler(). : This routine calls the handler for the IO. If there is not a handler of the proper size, it will call this function for 2 io's to the next smaller size. If the size was a byte, and there was no handler, FALSE is returned. Arguments: VdmIoHandler -- Supplies a pointer to the handler table Context -- Supplies 32 bits of data set when the port was trapped PortNumber -- Supplies the port number the IO was done to Size -- Supplies the size of the IO operation. Read -- Indicates whether the IO operation was a read or a write. Result -- Supplies a pointer to the location to put the result Return Value: True if one or more handlers were called to take care of the IO. False if no handler was called to take care of the IO. --*/ { NTSTATUS Status; BOOLEAN Success1, Success2; USHORT FnIndex; UCHAR AccessType; // Insure that Io is aligned ASSERT((!(PortNumber % Size))); if (Read) { FnIndex = 0; AccessType = EMULATOR_READ_ACCESS; } else { FnIndex = 1; AccessType = EMULATOR_WRITE_ACCESS; } switch (Size) { case 1: if (VdmIoHandler->IoFunctions[FnIndex].UcharIo[PortNumber % 4]) { Status = (*(VdmIoHandler->IoFunctions[FnIndex].UcharIo[PortNumber % 4]))( Context, PortNumber, AccessType, (PUCHAR)Data ); if (NT_SUCCESS(Status)) { return TRUE; } } // No handler for this port return FALSE; case 2: if (VdmIoHandler->IoFunctions[FnIndex].UshortIo[PortNumber % 2]) { Status = (*(VdmIoHandler->IoFunctions[FnIndex].UshortIo[PortNumber % 2]))( Context, PortNumber, AccessType, (PUSHORT)Data ); if (NT_SUCCESS(Status)) { return TRUE; } } else { // Dispatch to the two uchar handlers for this ushort port Success1 = VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber, Size /2, Read, Data ); Success2 = VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber + 1, Size / 2, Read, (PULONG)((PUCHAR)Data + 1) ); return (Success1 || Success2); } return FALSE; case 4: if (VdmIoHandler->IoFunctions[FnIndex].UlongIo) { Status = (*(VdmIoHandler->IoFunctions[FnIndex].UlongIo))( Context, PortNumber, AccessType, Data ); if (NT_SUCCESS(Status)) { return TRUE; } } else { // Dispatch to the two ushort handlers for this port Success1 = VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber, Size /2, Read, Data); Success2 = VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber + 2, Size / 2, Read, (PULONG)((PUSHORT)Data + 1) ); return (Success1 || Success2); } return FALSE; } }

BOOLEAN VdmDispatchStringIoToHandler (  IN PVDM_IO_HANDLER  VdmIoHandler, IN ULONG  Context, IN ULONG  PortNumber, IN ULONG  Size, IN ULONG  Count, IN BOOLEAN  Read, IN ULONG  Data )

Definition at line 777 of file ke/i386/vdm.c. References Count, Executive, FALSE, KeReleaseMutex(), KernelMode, KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, Size, Status, USHORT, VdmCallStringIoHandler(), and VdmStringIoMutex. Referenced by Ki386VdmDispatchStringIo(). : This routine calls the handler for the IO. If there is not a handler of the proper size, or the io is not aligned, it will simulate the io to the normal io handlers. Arguments: VdmIoHandler -- Supplies a pointer to the handler table Context -- Supplies 32 bits of data set when the port was trapped PortNumber -- Supplies the port number the IO was done to Size -- Supplies the size of the IO operation. Count -- Supplies the number of IO operations. Read -- Indicates whether the IO operation was a read or a write. Data -- Supplies a segmented address at which to put the result. Return Value: True if one or more handlers were called to take care of the IO. False if no handler was called to take care of the IO. --*/ { BOOLEAN Success = FALSE; USHORT FnIndex; NTSTATUS Status; if (Read) { FnIndex = 0; } else { FnIndex = 1; } Status = KeWaitForSingleObject( &VdmStringIoMutex, Executive, KernelMode, FALSE, NULL ); if (!NT_SUCCESS(Status)) { return FALSE; } switch (Size) { case 1: Success = VdmCallStringIoHandler( VdmIoHandler, (PVOID)VdmIoHandler->IoFunctions[FnIndex].UcharStringIo[PortNumber % 4], Context, PortNumber, Size, Count, Read, Data ); break; case 2: Success = VdmCallStringIoHandler( VdmIoHandler, (PVOID)VdmIoHandler->IoFunctions[FnIndex].UshortStringIo[PortNumber % 2], Context, PortNumber, Size, Count, Read, Data ); break; case 4: Success = VdmCallStringIoHandler( VdmIoHandler, (PVOID)VdmIoHandler->IoFunctions[FnIndex].UlongStringIo, Context, PortNumber, Size, Count, Read, Data ); break; } KeReleaseMutex(&VdmStringIoMutex, FALSE); return Success; }

BOOLEAN VdmDispatchUnalignedIoToHandler (  IN PVDM_IO_HANDLER  VdmIoHandler, IN ULONG  Context, IN ULONG  PortNumber, IN ULONG  Size, IN BOOLEAN  Read, IN OUT PULONG  Data )

Definition at line 672 of file ke/i386/vdm.c. References ASSERT, Offset, Size, and VdmDispatchIoToHandler(). Referenced by Ki386VdmDispatchIo(), and VdmCallStringIoHandler(). : This routine converts the unaligned IO to the necessary number of aligned IOs to smaller ports. Arguments: VdmIoHandler -- Supplies a pointer to the handler table Context -- Supplies 32 bits of data set when the port was trapped PortNumber -- Supplies the port number the IO was done to Size -- Supplies the size of the IO operation. Read -- Indicates whether the IO operation was a read or a write. Result -- Supplies a pointer to the location to put the result Return Value: True if one or more handlers were called to take care of the IO. False if no handler was called to take care of the IO. --*/ { ULONG Offset; BOOLEAN Success; ASSERT((Size > 1)); ASSERT((PortNumber % Size)); Offset = 0; // // The possible unaligned io situations are as follows. // // 1. Uchar aligned Ulong io // We have to dispatch a uchar io, a ushort io, and a uchar io // // 2. Ushort aligned Ulong Io // We have to dispatch a ushort io, and a ushort io // // 3. Uchar aligned Ushort Io // We have to dispatch a uchar io and a uchar io // // if the port is uchar aligned if ((PortNumber % Size) & 1) { Success = VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber, 1, Read, Data ); Offset += 1; // else it is ushort aligned (and therefore must be a ulong port) } else { Success = VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber, 2, Read, Data ); Offset += 2; } // if it is a ulong port, we know we have a ushort IO to dispatch if (Size == 4) { Success |= VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber + Offset, 2, Read, (PULONG)((PUCHAR)Data + Offset) ); Offset += 2; } // If we haven't dispatched the entire port, dispatch the final uchar if (Offset != 4) { Success |= VdmDispatchIoToHandler( VdmIoHandler, Context, PortNumber + Offset, 1, Read, (PULONG)((PUCHAR)Data + Offset) ); } return Success; }

---

Variable Documentation

ULONG KeI386EFlagsAndMaskV86 = EFLAGS_USER_SANITIZE

Definition at line 153 of file ke/i386/vdm.c. Referenced by KeI386VdmInitialize().

ULONG KeI386EFlagsOrMaskV86 = EFLAGS_INTERRUPT_MASK

Definition at line 154 of file ke/i386/vdm.c. Referenced by KeI386VdmInitialize().

BOOLEAN KeI386VdmIoplAllowed = FALSE

Definition at line 155 of file ke/i386/vdm.c. Referenced by KeI386VdmInitialize(), NtVdmControl(), VdmDispatchInterrupts(), VdmEndExecution(), VdmpDispatchableIntPending(), and VdmpStartExecution().

ULONG KeI386VirtualIntExtensions = 0

Definition at line 156 of file ke/i386/vdm.c. Referenced by KeI386VdmInitialize(), NtVdmControl(), VdmDispatchInterrupts(), VdmEndExecution(), VdmpDispatchableIntPending(), VdmpQueueIntApcRoutine(), and VdmpStartExecution().

ULONG VdmFixedStateLinear

Definition at line 151 of file ke/i386/vdm.c. Referenced by KeI386VdmInitialize(), and VdmpStartExecution().

UCHAR VdmStringIoBuffer[STRINGIO_BUFFER_SIZE]

Definition at line 879 of file ke/i386/vdm.c. Referenced by VdmCallStringIoHandler().

KMUTEX VdmStringIoMutex

Definition at line 150 of file ke/i386/vdm.c. Referenced by KeI386VdmInitialize(), and VdmDispatchStringIoToHandler().

---