VOID
NTAPI
HalpSetupRealModeIoPermissionsAndTask(VOID)
{
//
// Switch to valid TSS
//
HalpBorrowTss();
//
// Save a copy of the I/O Map and delete it
//
HalpSavedIoMap = (PUSHORT)&(KeGetPcr()->TSS->IoMaps[0]);
HalpStoreAndClearIopm();
//
// Save the IOPM and switch to the real-mode one
//
HalpSavedIopmBase = KeGetPcr()->TSS->IoMapBase;
KeGetPcr()->TSS->IoMapBase = KiComputeIopmOffset(1);
//
// Save our stack pointer
//
HalpSavedEsp0 = KeGetPcr()->TSS->Esp0;
}
/*
* @implemented
*/
BOOLEAN
NTAPI
Ke386IoSetAccessProcess(IN PKPROCESS Process,
IN ULONG MapNumber)
{
USHORT MapOffset;
PKPRCB Prcb;
KAFFINITY TargetProcessors;
if(MapNumber > IOPM_COUNT)
return FALSE;
MapOffset = KiComputeIopmOffset(MapNumber);
Process->IopmOffset = MapOffset;
TargetProcessors = Process->ActiveProcessors;
Prcb = KeGetCurrentPrcb();
if (TargetProcessors & Prcb->SetMember)
KeGetPcr()->TSS->IoMapBase = MapOffset;
return TRUE;
}
BOOLEAN
Ke386IoSetAccessProcess (
PKPROCESS Process,
ULONG MapNumber
)
/*++
Routine Description:
Set the i/o access map which controls user mode i/o access
for a particular process.
Arguments:
Process - Pointer to kernel process object describing the
process which for which a map is to be set.
MapNumber - Number of the map to set. Value of map is
defined by Ke386IoSetAccessProcess. Setting MapNumber
to IO_ACCESS_MAP_NONE will disallow any user mode i/o
access from the process.
Return Value:
TRUE if success, FALSE if failure (illegal MapNumber)
--*/
{
USHORT MapOffset;
KIRQL OldIrql;
PKPRCB Prcb;
KAFFINITY TargetProcessors;
//
// Reject illegal requests
//
if (MapNumber > IOPM_COUNT) {
return FALSE;
}
MapOffset = KiComputeIopmOffset(MapNumber);
//
// Acquire the context swap lock so a context switch will not occur.
//
KiLockContextSwap(&OldIrql);
//
// Store new offset in process object, compute current set of
// active processors for process, if this cpu is one, set IOPM.
//
Process->IopmOffset = MapOffset;
TargetProcessors = Process->ActiveProcessors;
Prcb = KeGetCurrentPrcb();
if (TargetProcessors & Prcb->SetMember) {
KiPcr()->TSS->IoMapBase = MapOffset;
}
//
// Compute set of active processors other than this one, if non-empty
// IPI them to load their IOPMs, wait for them.
//
#if !defined(NT_UP)
TargetProcessors = TargetProcessors & ~Prcb->SetMember;
if (TargetProcessors != 0) {
KiIpiSendPacket(TargetProcessors,
KiLoadIopmOffset,
NULL,
NULL,
NULL);
KiIpiStallOnPacketTargets(TargetProcessors);
}
#endif
//
// Restore IRQL and unlock the context swap lock.
//
KiUnlockContextSwap(OldIrql);
return TRUE;
}
VOID
KeInitializeProcess (
IN PRKPROCESS Process,
IN KPRIORITY BasePriority,
IN KAFFINITY Affinity,
IN ULONG_PTR DirectoryTableBase[2],
IN BOOLEAN Enable
)
/*++
Routine Description:
This function initializes a kernel process object. The base priority,
affinity, and page frame numbers for the process page table directory
and hyper space are stored in the process object.
N.B. It is assumed that the process object is zeroed.
Arguments:
Process - Supplies a pointer to a dispatcher object of type process.
BasePriority - Supplies the base priority of the process.
Affinity - Supplies the set of processors on which children threads
of the process can execute.
DirectoryTableBase - Supplies a pointer to an array whose fist element
is the value that is to be loaded into the Directory Table Base
register when a child thread is dispatched for execution and whose
second element contains the page table entry that maps hyper space.
Enable - Supplies a boolean value that determines the default
handling of data alignment exceptions for child threads. A value
of TRUE causes all data alignment exceptions to be automatically
handled by the kernel. A value of FALSE causes all data alignment
exceptions to be actually raised as exceptions.
Return Value:
None.
--*/
{
//
// Initialize the standard dispatcher object header and set the initial
// signal state of the process object.
//
Process->Header.Type = ProcessObject;
Process->Header.Size = sizeof(KPROCESS) / sizeof(LONG);
InitializeListHead(&Process->Header.WaitListHead);
//
// Initialize the base priority, affinity, directory table base values,
// autoalignment, and stack count.
//
// N.B. The distinguished value MAXSHORT is used to signify that no
// threads have been created for the process.
//
Process->BasePriority = (SCHAR)BasePriority;
Process->Affinity = Affinity;
Process->AutoAlignment = Enable;
Process->DirectoryTableBase[0] = DirectoryTableBase[0];
Process->DirectoryTableBase[1] = DirectoryTableBase[1];
Process->StackCount = MAXSHORT;
//
// Initialize the stack count, profile listhead, ready queue list head,
// accumulated runtime, process quantum, thread quantum, and thread list
// head.
//
InitializeListHead(&Process->ProfileListHead);
InitializeListHead(&Process->ReadyListHead);
InitializeListHead(&Process->ThreadListHead);
Process->ThreadQuantum = THREAD_QUANTUM;
//
// Initialize the process state and set the thread processor selection
// seed.
//
Process->State = ProcessInMemory;
Process->ThreadSeed = (UCHAR)KiQueryLowTickCount();
//
// Initialize IopmBase and Iopl flag for this process (i386 only)
//
#ifdef i386
Process->IopmOffset = KiComputeIopmOffset(IO_ACCESS_MAP_NONE);
#endif
return;
}
