able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntos/vdm/i386/vdmentry.c

480 lines
13 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
vdmentry.c
Abstract:
This function dispatches to the vdm services
Author:
Dave Hastings (daveh) 6-Apr-1992
Notes:
This module will be fleshed out when the great vdm code consolidation
occurs, sometime soon after the functionality is done.
Revision History:
24-Sep-1993 Jonle: reoptimize dispatcher to suit the number of services
add QueueInterrupt service
--*/
#include "vdmp.h"
#include <ntvdmp.h>
ULONG VdmpMaxPMCliTime;
#if DISABLE_CLI
ULONG VdmpPMCliCount;
#endif
BOOLEAN
VdmpIsVdmProcess(
VOID
);
VOID
VdmpEnableOPL2 (
ULONG BasePort
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, VdmpIsVdmProcess)
#pragma alloc_text(PAGE, NtVdmControl)
#pragma alloc_text(PAGE, VdmpEnableOPL2)
#endif
#if DBG
ULONG VdmInjectFailures;
#endif
BOOLEAN
VdmpIsVdmProcess(
VOID
)
/*++
Routine Description:
This function verifies the caller is a VDM process.
Arguments:
None.
Return Value:
True if the caller is a VDM process.
False if not
--*/
{
PEPROCESS Process;
PVDM_TIB VdmTib;
NTSTATUS Status;
PAGED_CODE();
Process = PsGetCurrentProcess();
if (Process->VdmObjects == NULL) {
return FALSE;
}
//
// Make sure the current thread has valid vdmtib.
//
Status = VdmpGetVdmTib(&VdmTib);
if (!NT_SUCCESS(Status)) {
return(FALSE);
}
//
// More checking here ...
//
return TRUE;
}
NTSTATUS
NtVdmControl(
IN VDMSERVICECLASS Service,
IN OUT PVOID ServiceData
)
/*++
Routine Description:
386 specific routine which dispatches to the appropriate function
based on service number.
Arguments:
Service -- Specifies what service is to be performed
ServiceData -- Supplies a pointer to service specific data
Return Value:
if invalid service number: STATUS_INVALID_PARAMETER_1
else see individual services.
--*/
{
NTSTATUS Status;
PVDM_PROCESS_OBJECTS pVdmObjects;
VDM_INITIALIZE_DATA CapturedVdmInitializeData;
PAGED_CODE();
//
// Make sure the caller is ntvdm. Except ...
// VdmStartExecution - video driver uses it to support int 10
// VdmInitialize - the vdm state is not fully initialized to
// perform the check
//
if ((Service != VdmInitialize) &&
(Service != VdmStartExecution) &&
(PsGetCurrentProcess()->VdmObjects == NULL)) {
return STATUS_ACCESS_DENIED;
}
try {
//
// Dispatch in descending order of frequency
//
if (Service == VdmStartExecution) {
Status = VdmpStartExecution();
} else if (Service == VdmQueueInterrupt) {
Status = VdmpQueueInterrupt(ServiceData);
} else if (Service == VdmDelayInterrupt) {
Status = VdmpDelayInterrupt(ServiceData);
} else if (Service == VdmQueryDir) {
Status = VdmQueryDirectoryFile(ServiceData);
} else if (Service == VdmInitialize) {
VdmpMaxPMCliTime = 1;
ProbeForRead(ServiceData, sizeof(VDM_INITIALIZE_DATA), 1);
RtlCopyMemory (&CapturedVdmInitializeData, ServiceData, sizeof (VDM_INITIALIZE_DATA));
Status = VdmpInitialize(&CapturedVdmInitializeData);
} else if (Service == VdmFeatures) {
//
// Verify that we were passed a valid user address
//
ProbeForWriteBoolean((PBOOLEAN)ServiceData);
//
// Return the appropriate feature bits to notify
// ntvdm which modes (if any) fast IF emulation is
// available for
//
if (KeI386VdmIoplAllowed) {
*((PULONG)ServiceData) = V86_VIRTUAL_INT_EXTENSIONS;
} else {
// remove this if pm extensions to be used
*((PULONG)ServiceData) = KeI386VirtualIntExtensions &
~PM_VIRTUAL_INT_EXTENSIONS;
}
Status = STATUS_SUCCESS;
} else if (Service == VdmSetInt21Handler) {
ProbeForRead(ServiceData, sizeof(VDMSET_INT21_HANDLER_DATA), 1);
Status = Ke386SetVdmInterruptHandler(
KeGetCurrentThread()->ApcState.Process,
0x21L,
(USHORT)(((PVDMSET_INT21_HANDLER_DATA)ServiceData)->Selector),
((PVDMSET_INT21_HANDLER_DATA)ServiceData)->Offset,
((PVDMSET_INT21_HANDLER_DATA)ServiceData)->Gate32
);
} else if (Service == VdmPrinterDirectIoOpen) {
Status = VdmpPrinterDirectIoOpen(ServiceData);
} else if (Service == VdmPrinterDirectIoClose) {
Status = VdmpPrinterDirectIoClose(ServiceData);
} else if (Service == VdmPrinterInitialize) {
Status = VdmpPrinterInitialize(ServiceData);
} else if (Service == VdmSetLdtEntries && VdmpIsVdmProcess()) {
ProbeForRead(ServiceData, sizeof(VDMSET_LDT_ENTRIES_DATA), 1);
Status = VdmpSetLdtEntries(
((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Selector0,
((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry0Low,
((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry0Hi,
((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Selector1,
((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry1Low,
((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry1Hi
);
} else if (Service == VdmSetProcessLdtInfo && VdmpIsVdmProcess()) {
PPROCESS_LDT_INFORMATION ldtInfo;
ULONG length;
ProbeForRead(ServiceData, sizeof(VDMSET_PROCESS_LDT_INFO_DATA), 1);
ldtInfo = ((PVDMSET_PROCESS_LDT_INFO_DATA)ServiceData)->LdtInformation;
length = ((PVDMSET_PROCESS_LDT_INFO_DATA)ServiceData)->LdtInformationLength;
ProbeForRead(ldtInfo, length, 1);
Status = VdmpSetProcessLdtInfo(ldtInfo, length);
} else if (Service == VdmAdlibEmulation && VdmpIsVdmProcess()) {
//
// Ntvdm calls here to do adlib emulation under the following conditions:
// ADLIB_DIRECT_IO - only If a FM synth device is opened for exclusive access.
// ADLIB_KERNEL_EMULATION - otherwise.
// Note ADLIB_USER_EMULATION is defaulted. It is basically used by external
// ADLIB/SB vdds.
//
ProbeForRead(ServiceData, sizeof(VDM_ADLIB_DATA), 1);
pVdmObjects = PsGetCurrentProcess()->VdmObjects;
pVdmObjects->AdlibAction = ((PVDM_ADLIB_DATA)ServiceData)->Action;
pVdmObjects->AdlibPhysPortStart = ((PVDM_ADLIB_DATA)ServiceData)->PhysicalPortStart;
pVdmObjects->AdlibPhysPortEnd = ((PVDM_ADLIB_DATA)ServiceData)->PhysicalPortEnd;
pVdmObjects->AdlibVirtPortStart = ((PVDM_ADLIB_DATA)ServiceData)->VirtualPortStart;
pVdmObjects->AdlibVirtPortEnd = ((PVDM_ADLIB_DATA)ServiceData)->VirtualPortEnd;
pVdmObjects->AdlibIndexRegister = 0;
pVdmObjects->AdlibStatus = 0x6; // OPL2 emulation
if (pVdmObjects->AdlibAction == ADLIB_DIRECT_IO) {
VdmpEnableOPL2(pVdmObjects->AdlibPhysPortStart);
}
Status = STATUS_SUCCESS;
} else if (Service == VdmPMCliControl) {
pVdmObjects = PsGetCurrentProcess()->VdmObjects;
ProbeForRead(ServiceData, sizeof(VDM_PM_CLI_DATA), 1);
Status = STATUS_SUCCESS;
switch (((PVDM_PM_CLI_DATA)ServiceData)->Control) {
case PM_CLI_CONTROL_DISABLE:
pVdmObjects->VdmControl &= ~PM_CLI_CONTROL;
break;
case PM_CLI_CONTROL_ENABLE:
pVdmObjects->VdmControl |= PM_CLI_CONTROL;
#if DISABLE_CLI
VdmpPMCliCount = 0;
#endif
if ((*FIXED_NTVDMSTATE_LINEAR_PC_AT & VDM_VIRTUAL_INTERRUPTS) == 0) {
VdmSetPMCliTimeStamp(TRUE);
}
break;
case PM_CLI_CONTROL_CHECK:
VdmCheckPMCliTimeStamp();
break;
case PM_CLI_CONTROL_SET:
VdmSetPMCliTimeStamp(FALSE);
break;
case PM_CLI_CONTROL_CLEAR:
VdmClearPMCliTimeStamp();
break;
default:
Status = STATUS_INVALID_PARAMETER_1;
}
} else {
Status = STATUS_INVALID_PARAMETER_1;
}
} except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
}
#if DBG
if (PsGetCurrentProcess()->VdmObjects != NULL) {
if (VdmInjectFailures != 0) {
PS_SET_BITS (&PsGetCurrentProcess()->Flags,
PS_PROCESS_INJECT_INPAGE_ERRORS);
}
}
#endif
ASSERT(KeGetCurrentIrql () == PASSIVE_LEVEL);
return Status;
}
VOID
VdmpEnableOPL2 (
ULONG BasePort
)
/*++
Routine Description:
This routine checks if OPL3 is present. If yes, it will set it OPL2
mode.
Note, According to OPL3 programming guide, we don't need to worry about
the delay between ins and outs (back to back IOs). In fact, I found out
it needs a little bit delay. When I code this routine in assembly,
it does not work. So, we may need to add a little more delay here if
OPL2 stops working on some audio cards.
Arguments:
BasePort - adlib base port
Return Value:
None.
--*/
{
UCHAR ch;
PUCHAR SecondaryPort;
ch = READ_PORT_UCHAR((PUCHAR)BasePort);
if (ch == 0) { // if OPL3
SecondaryPort = (PUCHAR)(BasePort + 2); // move to secondary ports
WRITE_PORT_UCHAR(SecondaryPort, 5); // Select index register 5
ch = READ_PORT_UCHAR((PUCHAR)BasePort); // a little bit delay
WRITE_PORT_UCHAR(SecondaryPort + 1, 0); // Select index register 5
}
}
VOID
VdmCheckPMCliTimeStamp (
VOID
)
/*++
Routine Description:
This routine checks if interrupts are disabled for too long by protected
mode apps. If ints are disabled for over predefined limit, they will be
reenabled such that ntvdm will be able to dispatch pending interrupts.
Note, V86 mode should NOT call this function.
Arguments:
None.
Return Value:
None.
--*/
{
PVDM_PROCESS_OBJECTS pVdmObjects;
PKPROCESS process = (PKPROCESS)PsGetCurrentProcess();
NTSTATUS status;
PVDM_TIB vdmTib;
pVdmObjects = ((PEPROCESS)process)->VdmObjects;
if (pVdmObjects->VdmControl & PM_CLI_CONTROL &&
pVdmObjects->PMCliTimeStamp != 0) {
if (((process->UserTime + 1)- pVdmObjects->PMCliTimeStamp) >= VdmpMaxPMCliTime) {
pVdmObjects->PMCliTimeStamp = 0;
#if DISABLE_CLI
VdmpPMCliCount++;
#endif
try {
*FIXED_NTVDMSTATE_LINEAR_PC_AT |= VDM_VIRTUAL_INTERRUPTS;
status = VdmpGetVdmTib(&vdmTib);
if (NT_SUCCESS(status)) {
vdmTib->VdmContext.EFlags |= EFLAGS_INTERRUPT_MASK;
}
} except(ExSystemExceptionFilter()) {
status = GetExceptionCode();
}
}
}
}
VOID
VdmSetPMCliTimeStamp (
BOOLEAN Reset
)
/*++
Routine Description:
This routine checks if interrupts are disabled for too long by protected
mode apps. If ints are disabled for over predefined limit, they will be
reenabled such that ntvdm will be able to dispatch pending interrupts.
Note, V86 mode should NOT call this function.
Arguments:
Reset - a Bool value to indicate should we re-set the count if it is not zero
Return Value:
None.
--*/
{
PVDM_PROCESS_OBJECTS pVdmObjects;
PKPROCESS process = (PKPROCESS)PsGetCurrentProcess();
#if DISABLE_CLI
if (VdmpPMCliCount > 0x20) {
try {
*FIXED_NTVDMSTATE_LINEAR_PC_AT |= VDM_VIRTUAL_INTERRUPTS;
}
except (EXCEPTION_EXECUTE_HANDLER) {
NOTHING;
}
return;
}
#endif
pVdmObjects = ((PEPROCESS)process)->VdmObjects;
if (pVdmObjects->VdmControl & PM_CLI_CONTROL) {
if (Reset || pVdmObjects->PMCliTimeStamp == 0) {
pVdmObjects->PMCliTimeStamp = process->UserTime + 1;
}
}
}
VOID
VdmClearPMCliTimeStamp (
VOID
)
/*++
Routine Description:
This routine checks if interrupts are disabled for too long by protected
mode apps. If ints are disabled for over predefined limit, they will be
reenabled such that ntvdm will be able to dispatch pending interrupts.
Note, V86 mode should NOT call this function.
Arguments:
None.
Return Value:
None.
--*/
{
PVDM_PROCESS_OBJECTS pVdmObjects;
pVdmObjects = PsGetCurrentProcess()->VdmObjects;
if (pVdmObjects->VdmControl & PM_CLI_CONTROL) {
pVdmObjects->PMCliTimeStamp = 0;
}
}
Reference in a new issue Copy permalink