/*
* @implemented
*/
LONG
NTAPI
KePulseEvent(IN PKEVENT Event,
IN KPRIORITY Increment,
IN BOOLEAN Wait)
{
KIRQL OldIrql;
LONG PreviousState;
PKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/* Lock the Dispatcher Database */
OldIrql = KiAcquireDispatcherLock();
/* Save the Old State */
PreviousState = Event->Header.SignalState;
/* Check if we are non-signaled and we have stuff in the Wait Queue */
if (!PreviousState && !IsListEmpty(&Event->Header.WaitListHead))
{
/* Set the Event to Signaled */
Event->Header.SignalState = 1;
/* Wake the Event */
KiWaitTest(&Event->Header, Increment);
}
/* Unsignal it */
Event->Header.SignalState = 0;
/* Check what wait state was requested */
if (Wait == FALSE)
{
/* Wait not requested, release Dispatcher Database and return */
KiReleaseDispatcherLock(OldIrql);
}
else
{
/* Return Locked and with a Wait */
Thread = KeGetCurrentThread();
Thread->WaitNext = TRUE;
Thread->WaitIrql = OldIrql;
}
/* Return the previous State */
return PreviousState;
}
LONG
KeSetEvent (
IN PRKEVENT Event,
IN KPRIORITY Increment,
IN BOOLEAN Wait
)
/*++
Routine Description:
This function sets the signal state of an event object to Signaled
and attempts to satisfy as many Waits as possible. The previous
signal state of the event object is returned as the function value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Increment - Supplies the priority increment that is to be applied
if setting the event causes a Wait to be satisfied.
Wait - Supplies a boolean value that signifies whether the call to
KePulseEvent will be immediately followed by a call to one of the
kernel Wait functions.
Return Value:
The previous signal state of the event object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Collect call data.
//
#if defined(_COLLECT_SET_EVENT_CALLDATA_)
RECORD_CALL_DATA(&KiSetEventCallData);
#endif
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// If the current state of the event object is not Signaled, the set the
// state of the event object to Signaled, and check for waiters.
//
OldState = Event->Header.SignalState;
Event->Header.SignalState = 1;
if ((OldState == 0) && (IsListEmpty(&Event->Header.WaitListHead) == FALSE)) {
KiWaitTest(Event, Increment);
}
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to its
// previous value.
//
if (Wait != FALSE) {
Thread = KeGetCurrentThread();
Thread->WaitNext = Wait;
Thread->WaitIrql = OldIrql;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of event object.
//
return OldState;
}
LONG
KeReleaseSemaphore (
IN PRKSEMAPHORE Semaphore,
IN KPRIORITY Increment,
IN LONG Adjustment,
IN BOOLEAN Wait
)
/*++
Routine Description:
This function releases a semaphore by adding the specified adjustment
value to the current semaphore count and attempts to satisfy as many
Waits as possible. The previous signal state of the semaphore object
is returned as the function value.
Arguments:
Semaphore - Supplies a pointer to a dispatcher object of type
semaphore.
Increment - Supplies the priority increment that is to be applied
if releasing the semaphore causes a Wait to be satisfied.
Adjustment - Supplies value that is to be added to the current
semaphore count.
Wait - Supplies a boolean value that signifies whether the call to
KeReleaseSemaphore will be immediately followed by a call to one
of the kernel Wait functions.
Return Value:
The previous signal state of the semaphore object.
--*/
{
LONG NewState;
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_SEMAPHORE( Semaphore );
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// Capture the current signal state of the semaphore object and
// compute the new count value.
//
OldState = Semaphore->Header.SignalState;
NewState = OldState + Adjustment;
//
// If the new state value is greater than the limit or a carry occurs,
// then unlock the dispatcher database, and raise an exception.
//
if ((NewState > Semaphore->Limit) || (NewState < OldState)) {
KiUnlockDispatcherDatabase(OldIrql);
ExRaiseStatus(STATUS_SEMAPHORE_LIMIT_EXCEEDED);
}
//
// Set the new signal state of the semaphore object and set the wait
// next value. If the previous signal state was Not-Signaled (i.e.
// the count was zero), and the wait queue is not empty, then attempt
// to satisfy as many Waits as possible.
//
Semaphore->Header.SignalState = NewState;
if ((OldState == 0) && (IsListEmpty(&Semaphore->Header.WaitListHead) == FALSE)) {
KiWaitTest(Semaphore, Increment);
}
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to its
// previous value.
//
if (Wait != FALSE) {
Thread = KeGetCurrentThread();
Thread->WaitNext = Wait;
Thread->WaitIrql = OldIrql;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of sempahore object.
//
return OldState;
}
VOID
FASTCALL
KiReadyThread (
IN PRKTHREAD Thread
)
/*++
Routine Description:
This function readies a thread for execution and attempts to immediately
dispatch the thread for execution by preempting another lower priority
thread. If a thread can be preempted, then the specified thread enters
the standby state and the target processor is requested to dispatch. If
another thread cannot be preempted, then the specified thread is inserted
either at the head or tail of the dispatcher ready selected by its priority
acccording to whether it was preempted or not.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
Return Value:
None.
--*/
{
PRKPRCB Prcb;
BOOLEAN Preempted;
KPRIORITY Priority;
PRKPROCESS Process;
ULONG Processor;
KPRIORITY ThreadPriority;
PRKTHREAD Thread1;
KAFFINITY IdleSet;
//
// Save value of thread's preempted flag, set thread preempted FALSE,
// capture the thread priority, and set clear the read wait time.
//
Preempted = Thread->Preempted;
Thread->Preempted = FALSE;
ThreadPriority = Thread->Priority;
Thread->WaitTime = KiQueryLowTickCount();
//
// If the thread's process is not in memory, then insert the thread in
// the process ready queue and inswap the process.
//
Process = Thread->ApcState.Process;
if (Process->State != ProcessInMemory) {
Thread->State = Ready;
Thread->ProcessReadyQueue = TRUE;
InsertTailList(&Process->ReadyListHead, &Thread->WaitListEntry);
if (Process->State == ProcessOutOfMemory) {
Process->State = ProcessInTransition;
InsertTailList(&KiProcessInSwapListHead, &Process->SwapListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
}
return;
} else if (Thread->KernelStackResident == FALSE) {
//
// The thread's kernel stack is not resident. Increment the process
// stack count, set the state of the thread to transition, insert
// the thread in the kernel stack inswap list, and set the kernel
// stack inswap event.
//
Process->StackCount += 1;
Thread->State = Transition;
InsertTailList(&KiStackInSwapListHead, &Thread->WaitListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
return;
} else {
//
// If there is an idle processor, then schedule the thread on an
// idle processor giving preference to the processor the thread
// last ran on. Otherwise, try to preempt either a thread in the
// standby or running state.
//
#if defined(NT_UP)
Prcb = KiProcessorBlock[0];
if (KiIdleSummary != 0) {
KiIdleSummary = 0;
KiIncrementSwitchCounter(IdleLast);
#else
IdleSet = KiIdleSummary & Thread->Affinity;
if (IdleSet != 0) {
Processor = Thread->IdealProcessor;
if ((IdleSet & (1 << Processor)) == 0) {
Processor = Thread->NextProcessor;
if ((IdleSet & (1 << Processor)) == 0) {
Prcb = KeGetCurrentPrcb();
if ((IdleSet & Prcb->SetMember) == 0) {
FindFirstSetLeftMember(IdleSet, &Processor);
KiIncrementSwitchCounter(IdleAny);
} else {
Processor = Prcb->Number;
KiIncrementSwitchCounter(IdleCurrent);
}
} else {
KiIncrementSwitchCounter(IdleLast);
}
} else {
KiIncrementSwitchCounter(IdleIdeal);
}
Thread->NextProcessor = (CCHAR)Processor;
ClearMember(Processor, KiIdleSummary);
Prcb = KiProcessorBlock[Processor];
#endif
Prcb->NextThread = Thread;
Thread->State = Standby;
return;
} else {
#if !defined(NT_UP)
Processor = Thread->IdealProcessor;
if ((Thread->Affinity & (1 << Processor)) == 0) {
Processor = Thread->NextProcessor;
if ((Thread->Affinity & (1 << Processor)) == 0) {
FindFirstSetLeftMember(Thread->Affinity, &Processor);
}
}
Thread->NextProcessor = (CCHAR)Processor;
Prcb = KiProcessorBlock[Processor];
#endif
if (Prcb->NextThread != NULL) {
Thread1 = Prcb->NextThread;
if (ThreadPriority > Thread1->Priority) {
Thread1->Preempted = TRUE;
Prcb->NextThread = Thread;
Thread->State = Standby;
KiReadyThread(Thread1);
KiIncrementSwitchCounter(PreemptLast);
return;
}
} else {
Thread1 = Prcb->CurrentThread;
if (ThreadPriority > Thread1->Priority) {
Thread1->Preempted = TRUE;
Prcb->NextThread = Thread;
Thread->State = Standby;
KiRequestDispatchInterrupt(Thread->NextProcessor);
KiIncrementSwitchCounter(PreemptLast);
return;
}
}
}
}
//
// No thread can be preempted. Insert the thread in the dispatcher
// queue selected by its priority. If the thread was preempted and
// runs at a realtime priority level, then insert the thread at the
// front of the queue. Else insert the thread at the tail of the queue.
//
Thread->State = Ready;
if (Preempted != FALSE) {
InsertHeadList(&KiDispatcherReadyListHead[ThreadPriority],
&Thread->WaitListEntry);
} else {
InsertTailList(&KiDispatcherReadyListHead[ThreadPriority],
&Thread->WaitListEntry);
}
SetMember(ThreadPriority, KiReadySummary);
return;
}
PRKTHREAD
FASTCALL
KiSelectNextThread (
IN PRKTHREAD Thread
)
/*++
Routine Description:
This function selects the next thread to run on the processor that the
specified thread is running on. If a thread cannot be found, then the
idle thread is selected.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
Return Value:
The address of the selected thread object.
--*/
{
PRKPRCB Prcb;
ULONG Processor;
PRKTHREAD Thread1;
//
// Get the processor number and the address of the processor control block.
//
#if !defined(NT_UP)
Processor = Thread->NextProcessor;
Prcb = KiProcessorBlock[Processor];
#else
Prcb = KiProcessorBlock[0];
#endif
//
// If a thread has already been selected to run on the specified processor,
// then return that thread as the selected thread.
//
if ((Thread1 = Prcb->NextThread) != NULL) {
Prcb->NextThread = (PKTHREAD)NULL;
} else {
//
// Attempt to find a ready thread to run.
//
#if !defined(NT_UP)
Thread1 = KiFindReadyThread(Processor, 0);
#else
Thread1 = KiFindReadyThread(0, 0);
#endif
//
// If a thread was not found, then select the idle thread and
// set the processor member in the idle summary.
//
if (Thread1 == NULL) {
KiIncrementSwitchCounter(SwitchToIdle);
Thread1 = Prcb->IdleThread;
#if !defined(NT_UP)
SetMember(Processor, KiIdleSummary);
#else
KiIdleSummary = 1;
#endif
}
}
//
// Return address of selected thread object.
//
return Thread1;
}
LONG
KePulseEvent (
__inout PRKEVENT Event,
__in KPRIORITY Increment,
__in BOOLEAN Wait
)
/*++
Routine Description:
This function atomically sets the signal state of an event object to
signaled, attempts to satisfy as many waits as possible, and then resets
the signal state of the event object to Not-Signaled. The previous signal
state of the event object is returned as the function value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Increment - Supplies the priority increment that is to be applied
if setting the event causes a Wait to be satisfied.
Wait - Supplies a boolean value that signifies whether the call to
KePulseEvent will be immediately followed by a call to one of the
kernel Wait functions.
Return Value:
The previous signal state of the event object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// If the current state of the event object is Not-Signaled and
// the wait queue is not empty, then set the state of the event
// to Signaled, satisfy as many Waits as possible, and then reset
// the state of the event to Not-Signaled.
//
OldState = ReadForWriteAccess(&Event->Header.SignalState);
if ((OldState == 0) &&
(IsListEmpty(&Event->Header.WaitListHead) == FALSE)) {
Event->Header.SignalState = 1;
KiWaitTest(Event, Increment);
}
Event->Header.SignalState = 0;
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to the
// previous value.
//
if (Wait != FALSE) {
Thread = KeGetCurrentThread();
Thread->WaitIrql = OldIrql;
Thread->WaitNext = Wait;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of event object.
//
return OldState;
}
VOID
FASTCALL
KiTimerListExpire (
IN PLIST_ENTRY ExpiredListHead,
IN KIRQL OldIrql
)
/*++
Routine Description:
This function is called to process a list of timers that have expired.
N.B. This function is called with the dispatcher database locked and
returns with the dispatcher database unlocked.
Arguments:
ExpiredListHead - Supplies a pointer to a list of timers that have
expired.
OldIrql - Supplies the previous IRQL.
Return Value:
None.
--*/
{
LONG Count;
PKDPC Dpc;
DPC_ENTRY DpcList[MAXIMUM_DPC_LIST_SIZE];
LONG Index;
LARGE_INTEGER Interval;
KIRQL OldIrql1;
LARGE_INTEGER SystemTime;
PKTIMER Timer;
//
// Capture the timer expiration time.
//
KiQuerySystemTime(&SystemTime);
//
// Remove the next timer from the expired timer list, set the state of
// the timer to signaled, reinsert the timer in the timer tree if it is
// periodic, and optionally call the DPC routine if one is specified.
//
RestartScan:
Count = 0;
while (ExpiredListHead->Flink != ExpiredListHead) {
Timer = CONTAINING_RECORD(ExpiredListHead->Flink, KTIMER, TimerListEntry);
KiRemoveTreeTimer(Timer);
Timer->Header.SignalState = 1;
if (IsListEmpty(&Timer->Header.WaitListHead) == FALSE) {
KiWaitTest(Timer, TIMER_EXPIRE_INCREMENT);
}
//
// If the timer is periodic, then compute the next interval time
// and reinsert the timer in the timer tree.
//
// N.B. Even though the timer insertion is relative, it can still
// fail if the period of the timer elapses in between computing
// the time and inserting the timer in the table. If this happens,
// try again.
//
if (Timer->Period != 0) {
Interval.QuadPart = Int32x32To64(Timer->Period, - 10 * 1000);
while (!KiInsertTreeTimer(Timer, Interval)) {
;
}
}
if (Timer->Dpc != NULL) {
Dpc = Timer->Dpc;
//
// If the DPC is explicitly targeted to another processor, then
// queue the DPC to the target processor. Otherwise, capture the
// DPC parameters for execution on the current processor.
//
#if defined(NT_UP)
DpcList[Count].Dpc = Dpc;
DpcList[Count].Routine = Dpc->DeferredRoutine;
DpcList[Count].Context = Dpc->DeferredContext;
Count += 1;
if (Count == MAXIMUM_DPC_LIST_SIZE) {
break;
}
#else
if ((Dpc->Number >= MAXIMUM_PROCESSORS) &&
(((ULONG)Dpc->Number - MAXIMUM_PROCESSORS) != (ULONG)KeGetCurrentProcessorNumber())) {
KeInsertQueueDpc(Dpc,
ULongToPtr(SystemTime.LowPart),
ULongToPtr(SystemTime.HighPart));
} else {
DpcList[Count].Dpc = Dpc;
DpcList[Count].Routine = Dpc->DeferredRoutine;
DpcList[Count].Context = Dpc->DeferredContext;
Count += 1;
if (Count == MAXIMUM_DPC_LIST_SIZE) {
break;
}
}
#endif
}
}
//
// Unlock the dispacher database and process DPC list entries.
//
if (Count != 0) {
KiUnlockDispatcherDatabase(DISPATCH_LEVEL);
Index = 0;
do {
#if DBG && (defined(i386) || defined(ALPHA))
//
// Reset the dpc tick count. If the tick count handler,
// which increments this value, detects that it has crossed
// a certain threshold, a breakpoint will be generated.
//
KeGetCurrentPrcb()->DebugDpcTime = 0;
#endif
(DpcList[Index].Routine)(DpcList[Index].Dpc,
DpcList[Index].Context,
ULongToPtr(SystemTime.LowPart),
ULongToPtr(SystemTime.HighPart));
Index += 1;
} while (Index < Count);
//
// If processing of the expired timer list was terminated because
// the DPC List was full, then process any remaining entries.
//
if (Count == MAXIMUM_DPC_LIST_SIZE) {
KiLockDispatcherDatabase(&OldIrql1);
goto RestartScan;
}
KeLowerIrql(OldIrql);
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
return;
}
LONG
KeReleaseMutant (
IN PRKMUTANT Mutant,
IN KPRIORITY Increment,
IN BOOLEAN Abandoned,
IN BOOLEAN Wait
)
/*++
Routine Description:
This function releases a mutant object by incrementing the mutant
count. If the resultant value is one, then an attempt is made to
satisfy as many Waits as possible. The previous signal state of
the mutant is returned as the function value. If the Abandoned
parameter is TRUE, then the mutant object is released by settings
the signal state to one.
Arguments:
Mutant - Supplies a pointer to a dispatcher object of type mutant.
Increment - Supplies the priority increment that is to be applied
if setting the event causes a Wait to be satisfied.
Abandoned - Supplies a boolean value that signifies whether the
mutant object is being abandoned.
Wait - Supplies a boolean value that signifies whether the call to
KeReleaseMutant will be immediately followed by a call to one
of the kernel Wait functions.
Return Value:
The previous signal state of the mutant object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_MUTANT(Mutant);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// Capture the current signal state of the mutant object.
//
OldState = Mutant->Header.SignalState;
//
// If the Abandoned parameter is TRUE, then force the release of the
// mutant object by setting its ownership count to one and setting its
// abandoned state to TRUE. Otherwise increment mutant ownership count.
// If the result count is one, then remove the mutant object from the
// thread's owned mutant list, set the owner thread to NULL, and attempt
// to satisfy a Wait for the mutant object if the mutant object wait
// list is not empty.
//
Thread = KeGetCurrentThread();
if (Abandoned != FALSE) {
Mutant->Header.SignalState = 1;
Mutant->Abandoned = TRUE;
} else {
//
// If the Mutant object is not owned by the current thread, then
// unlock the dispatcher data base and raise an exception. Otherwise
// increment the ownership count.
//
if (Mutant->OwnerThread != Thread) {
KiUnlockDispatcherDatabase(OldIrql);
ExRaiseStatus(Mutant->Abandoned ?
STATUS_ABANDONED : STATUS_MUTANT_NOT_OWNED);
}
Mutant->Header.SignalState += 1;
}
if (Mutant->Header.SignalState == 1) {
if (OldState <= 0) {
RemoveEntryList(&Mutant->MutantListEntry);
Thread->KernelApcDisable += Mutant->ApcDisable;
if ((Thread->KernelApcDisable == 0) &&
(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]) == FALSE)) {
Thread->ApcState.KernelApcPending = TRUE;
KiRequestSoftwareInterrupt(APC_LEVEL);
}
}
Mutant->OwnerThread = (PKTHREAD)NULL;
if (IsListEmpty(&Mutant->Header.WaitListHead) == FALSE) {
KiWaitTest(Mutant, Increment);
}
}
//
// If the value of the Wait argument is TRUE, then return to
// caller with IRQL raised and the dispatcher database locked.
// Else release the dispatcher database lock and lower IRQL to
// its previous value.
//
if (Wait != FALSE) {
Thread->WaitNext = Wait;
Thread->WaitIrql = OldIrql;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of mutant object.
//
return OldState;
}
VOID
KiAttachProcess (
IN PRKTHREAD Thread,
IN PKPROCESS Process,
IN KIRQL OldIrql,
OUT PRKAPC_STATE SavedApcState
)
/*++
Routine Description:
This function attaches a thread to a target process' address space.
N.B. The dispatcher database lock must be held when this routine is
called.
Arguments:
Thread - Supplies a pointer to a dispatcher object of type thread.
Process - Supplies a pointer to a dispatcher object of type process.
OldIrql - Supplies the previous IRQL.
SavedApcState - Supplies a pointer to the APC state structure that receives
the saved APC state.
Return Value:
None.
--*/
{
PRKTHREAD OutThread;
KAFFINITY Processor;
PLIST_ENTRY NextEntry;
KIRQL HighIrql;
ASSERT(Process != Thread->ApcState.Process);
//
// Bias the stack count of the target process to signify that a
// thread exists in that process with a stack that is resident.
//
Process->StackCount += 1;
//
// Save current APC state and initialize a new APC state.
//
KiMoveApcState(&Thread->ApcState, SavedApcState);
InitializeListHead(&Thread->ApcState.ApcListHead[KernelMode]);
InitializeListHead(&Thread->ApcState.ApcListHead[UserMode]);
Thread->ApcState.Process = Process;
Thread->ApcState.KernelApcInProgress = FALSE;
Thread->ApcState.KernelApcPending = FALSE;
Thread->ApcState.UserApcPending = FALSE;
if (SavedApcState == &Thread->SavedApcState) {
Thread->ApcStatePointer[0] = &Thread->SavedApcState;
Thread->ApcStatePointer[1] = &Thread->ApcState;
Thread->ApcStateIndex = 1;
}
//
// If the target process is in memory, then immediately enter the
// new address space by loading a new Directory Table Base. Otherwise,
// insert the current thread in the target process ready list, inswap
// the target process if necessary, select a new thread to run on the
// the current processor and context switch to the new thread.
//
if (Process->State == ProcessInMemory) {
//
// It is possible that the process is in memory, but there exist
// threads in the process ready list. This can happen when memory
// management forces a process attach.
//
NextEntry = Process->ReadyListHead.Flink;
while (NextEntry != &Process->ReadyListHead) {
OutThread = CONTAINING_RECORD(NextEntry, KTHREAD, WaitListEntry);
RemoveEntryList(NextEntry);
OutThread->ProcessReadyQueue = FALSE;
KiReadyThread(OutThread);
NextEntry = Process->ReadyListHead.Flink;
}
KiSwapProcess(Process, SavedApcState->Process);
KiUnlockDispatcherDatabase(OldIrql);
} else {
Thread->State = Ready;
Thread->ProcessReadyQueue = TRUE;
InsertTailList(&Process->ReadyListHead, &Thread->WaitListEntry);
if (Process->State == ProcessOutOfMemory) {
Process->State = ProcessInTransition;
InsertTailList(&KiProcessInSwapListHead, &Process->SwapListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
}
//
// Clear the active processor bit in the previous process and
// set active processor bit in the process being attached to.
//
#if !defined(NT_UP)
KiLockContextSwap(&HighIrql);
Processor = KeGetCurrentPrcb()->SetMember;
SavedApcState->Process->ActiveProcessors &= ~Processor;
Process->ActiveProcessors |= Processor;
#if defined(_ALPHA_)
Process->RunOnProcessors |= Processor;
#endif
KiUnlockContextSwap(HighIrql);
#endif
Thread->WaitIrql = OldIrql;
KiSwapThread();
}
return;
}
LONG
KeSetProcess (
IN PRKPROCESS Process,
IN KPRIORITY Increment,
IN BOOLEAN Wait
)
/*++
Routine Description:
This function sets the signal state of a proces object to Signaled
and attempts to satisfy as many Waits as possible. The previous
signal state of the process object is returned as the function value.
Arguments:
Process - Supplies a pointer to a dispatcher object of type process.
Increment - Supplies the priority increment that is to be applied
if setting the process causes a Wait to be satisfied.
Wait - Supplies a boolean value that signifies whether the call to
KeSetProcess will be immediately followed by a call to one of the
kernel Wait functions.
Return Value:
The previous signal state of the process object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_PROCESS(Process);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// If the previous state of the process object is Not-Signaled and
// the wait queue is not empty, then satisfy as many Waits as
// possible.
//
OldState = Process->Header.SignalState;
Process->Header.SignalState = 1;
if ((OldState == 0) && (!IsListEmpty(&Process->Header.WaitListHead))) {
KiWaitTest(Process, Increment);
}
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to its
// previous value.
//
if (Wait) {
Thread = KeGetCurrentThread();
Thread->WaitNext = Wait;
Thread->WaitIrql = OldIrql;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of process object.
//
return OldState;
}
VOID
KeUnstackDetachProcess (
IN PRKAPC_STATE ApcState
)
/*++
Routine Description:
This function detaches a thread from another process' address space
and restores previous attach state.
Arguments:
ApcState - Supplies a pointer to an APC state structure that was returned
from a previous call to stack attach process.
Return Value:
None.
--*/
{
KIRQL OldIrql;
PKPROCESS Process;
PKTHREAD Thread;
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
Thread = KeGetCurrentThread();
KiLockDispatcherDatabase(&OldIrql);
//
// If the APC state has a distinguished process pointer value, then no
// attach was performed on the paired call to stack attach process.
//
if (ApcState->Process != (PRKPROCESS)1) {
//
// If the current thread is not attached to another process, a kernel
// APC is in progress, or either the kernel or user mode APC queues
// are not empty, then call bug check.
//
if ((Thread->ApcStateIndex == 0) ||
(Thread->ApcState.KernelApcInProgress) ||
(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]) == FALSE) ||
(IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]) == FALSE)) {
KeBugCheck(INVALID_PROCESS_DETACH_ATTEMPT);
}
//
// Unbias current process stack count and check if the process should
// be swapped out of memory.
//
Process = Thread->ApcState.Process;
Process->StackCount -= 1;
if ((Process->StackCount == 0) &&
(IsListEmpty(&Process->ThreadListHead) == FALSE)) {
Process->State = ProcessInTransition;
InsertTailList(&KiProcessOutSwapListHead, &Process->SwapListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
}
//
// Restore APC state and check whether the kernel APC queue contains
// an entry. If the kernel APC queue contains an entry then set kernel
// APC pending and request a software interrupt at APC_LEVEL.
//
if (ApcState->Process != NULL) {
KiMoveApcState(ApcState, &Thread->ApcState);
} else {
KiMoveApcState(&Thread->SavedApcState, &Thread->ApcState);
Thread->SavedApcState.Process = (PKPROCESS)NULL;
Thread->ApcStatePointer[0] = &Thread->ApcState;
Thread->ApcStatePointer[1] = &Thread->SavedApcState;
Thread->ApcStateIndex = 0;
}
if (IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]) == FALSE) {
Thread->ApcState.KernelApcPending = TRUE;
KiRequestSoftwareInterrupt(APC_LEVEL);
}
//
// Swap the address space back to the parent process.
//
KiSwapProcess(Thread->ApcState.Process, Process);
}
//
// Lower IRQL to its previous value and return.
//
KiUnlockDispatcherDatabase(OldIrql);
return;
}
VOID
KeDetachProcess (
VOID
)
/*++
Routine Description:
This function detaches a thread from another process' address space.
Arguments:
None.
Return Value:
None.
--*/
{
KIRQL OldIrql;
PKPROCESS Process;
PKTHREAD Thread;
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
Thread = KeGetCurrentThread();
KiLockDispatcherDatabase(&OldIrql);
//
// If the current thread is attached to another process, then detach
// it.
//
if (Thread->ApcStateIndex != 0) {
//
// Check if a kernel APC is in progress, the kernel APC queue is
// not empty, or the user APC queue is not empty. If any of these
// conditions are true, then call bug check.
//
#if DBG
if ((Thread->ApcState.KernelApcInProgress) ||
(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]) == FALSE) ||
(IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]) == FALSE)) {
KeBugCheck(INVALID_PROCESS_DETACH_ATTEMPT);
}
#endif
//
// Unbias current process stack count and check if the process should
// be swapped out of memory.
//
Process = Thread->ApcState.Process;
Process->StackCount -= 1;
if ((Process->StackCount == 0) &&
(IsListEmpty(&Process->ThreadListHead) == FALSE)) {
Process->State = ProcessInTransition;
InsertTailList(&KiProcessOutSwapListHead, &Process->SwapListEntry);
KiSwapEvent.Header.SignalState = 1;
if (IsListEmpty(&KiSwapEvent.Header.WaitListHead) == FALSE) {
KiWaitTest(&KiSwapEvent, BALANCE_INCREMENT);
}
}
//
// Restore APC state and check whether the kernel APC queue contains
// an entry. If the kernel APC queue contains an entry then set kernel
// APC pending and request a software interrupt at APC_LEVEL.
//
KiMoveApcState(&Thread->SavedApcState, &Thread->ApcState);
Thread->SavedApcState.Process = (PKPROCESS)NULL;
Thread->ApcStatePointer[0] = &Thread->ApcState;
Thread->ApcStatePointer[1] = &Thread->SavedApcState;
Thread->ApcStateIndex = 0;
if (IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]) == FALSE) {
Thread->ApcState.KernelApcPending = TRUE;
KiRequestSoftwareInterrupt(APC_LEVEL);
}
//
// Swap the address space back to the parent process.
//
KiSwapProcess(Thread->ApcState.Process, Process);
}
//
// Lower IRQL to its previous value and return.
//
KiUnlockDispatcherDatabase(OldIrql);
return;
}
/*
* @implemented
*/
LONG
NTAPI
KeReleaseMutant(IN PKMUTANT Mutant,
IN KPRIORITY Increment,
IN BOOLEAN Abandon,
IN BOOLEAN Wait)
{
KIRQL OldIrql;
LONG PreviousState;
PKTHREAD CurrentThread = KeGetCurrentThread();
BOOLEAN EnableApc = FALSE;
ASSERT_MUTANT(Mutant);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/* Lock the Dispatcher Database */
OldIrql = KiAcquireDispatcherLock();
/* Save the Previous State */
PreviousState = Mutant->Header.SignalState;
/* Check if it is to be abandonned */
if (Abandon == FALSE)
{
/* Make sure that the Owner Thread is the current Thread */
if (Mutant->OwnerThread != CurrentThread)
{
/* Release the lock */
KiReleaseDispatcherLock(OldIrql);
/* Raise an exception */
ExRaiseStatus(Mutant->Abandoned ? STATUS_ABANDONED :
STATUS_MUTANT_NOT_OWNED);
}
/* If the thread owns it, then increase the signal state */
Mutant->Header.SignalState++;
}
else
{
/* It's going to be abandonned */
Mutant->Header.SignalState = 1;
Mutant->Abandoned = TRUE;
}
/* Check if the signal state is only single */
if (Mutant->Header.SignalState == 1)
{
/* Check if it's below 0 now */
if (PreviousState <= 0)
{
/* Remove the mutant from the list */
RemoveEntryList(&Mutant->MutantListEntry);
/* Save if we need to re-enable APCs */
EnableApc = Mutant->ApcDisable;
}
/* Remove the Owning Thread and wake it */
Mutant->OwnerThread = NULL;
/* Check if the Wait List isn't empty */
if (!IsListEmpty(&Mutant->Header.WaitListHead))
{
/* Wake the Mutant */
KiWaitTest(&Mutant->Header, Increment);
}
}
/* Check if the caller wants to wait after this release */
if (Wait == FALSE)
{
/* Release the Lock */
KiReleaseDispatcherLock(OldIrql);
}
else
{
/* Set a wait */
CurrentThread->WaitNext = TRUE;
CurrentThread->WaitIrql = OldIrql;
}
/* Check if we need to re-enable APCs */
if (EnableApc) KeLeaveCriticalRegion();
/* Return the previous state */
return PreviousState;
}
