- Optimized the dispatcher lock. It is now gone on non-SMP systems and
IRQL is raised or lowered instead.
- Made inlined functions in ke/wait.c macros, because they weren't being
inlined.
- Created separate cases for satisfying mutant, non-mutant and generic
objects, to optimize wait satisfaction.
- Fixed some places which werne't setting the dispatcher header's size
member correctly.
- Fixed formatting in ke/wait.c
- Fixed a case in KiCheckAlertability: we also need to check if the
thread is alerted in Kernel-Mode, even if the wait mode given was user
and user-mode is not alerted.
- Fixed signaling checks across the wait code and removed
KiCheckIfObjectSignaled. We must not consider the mutant as signaled if
SignalState is = 1.
- Fix code to check if the wait blocks' status is STATUS_TIMEOUT,
because we do not need to check for signal state in that case.
- Removed the exports for internal dispatcher lock routines.
** Thanks to Waxdragon for stress-testing this for an hour :)
Modified: trunk/reactos/ntoskrnl/include/internal/ke.h
Modified: trunk/reactos/ntoskrnl/ke/i386/ctxswitch.S
Modified: trunk/reactos/ntoskrnl/ke/kthread.c
Modified: trunk/reactos/ntoskrnl/ke/wait.c
Modified: trunk/reactos/ntoskrnl/ntoskrnl.def
Modified: trunk/reactos/ntoskrnl/ps/psmgr.c
_____
Modified: trunk/reactos/ntoskrnl/include/internal/ke.h
--- trunk/reactos/ntoskrnl/include/internal/ke.h 2006-01-05
01:49:00 UTC (rev 20567)
+++ trunk/reactos/ntoskrnl/include/internal/ke.h 2006-01-05
04:26:55 UTC (rev 20568)
@@ -44,31 +44,174 @@
/* MACROS
************************************************************************
*/
-#define KeEnterCriticalRegion() \
-{ \
- PKTHREAD _Thread = KeGetCurrentThread(); \
- if (_Thread) _Thread->KernelApcDisable--; \
+/*
+ * On UP machines, we don't actually have a spinlock, we merely raise
+ * IRQL to DPC level.
+ */
+#ifndef CONFIG_SMP
+#define KeInitializeDispatcher()
+#define KeAcquireDispatcherDatabaseLock() KeRaiseIrqlToDpcLevel();
+#define KeAcquireDispatcherDatabaseLockAtDpcLevel()
+#define KeReleaseDispatcherDatabaseLockFromDpcLevel()
+#else
+#define KeInitializeDispatcher()
KeInitializeSpinLock(&DispatcherDatabaseLock);
+#define KeAcquireDispatcherDatabaseLock()
KfAcquireSpinLock(&DispatcherDatabaseLock);
+#define KeAcquireDispatcherDatabaseLockAtDpcLevel() \
+ KeAcquireSpinLockAtDpcLevel (&DispatcherDatabaseLock);
+#define KeReleaseDispatcherDatabaseLockFromDpcLevel() \
+ KeReleaseSpinLockFromDpcLevel(&DispatcherDatabaseLock);
+#endif
+
+/* The following macro initializes a dispatcher object's header */
+#define KeInitializeDispatcherHeader(Header, t, s, State)
\
+{
\
+ (Header)->Type = t;
\
+ (Header)->Absolute = 0;
\
+ (Header)->Inserted = 0;
\
+ (Header)->Size = s;
\
+ (Header)->SignalState = State;
\
+ InitializeListHead(&((Header)->WaitListHead));
\
}
-#define KeLeaveCriticalRegion() \
-{ \
- PKTHREAD _Thread = KeGetCurrentThread(); \
- if((_Thread) && (++_Thread->KernelApcDisable == 0)) \
- { \
- if (!IsListEmpty(&_Thread->ApcState.ApcListHead[KernelMode]) &&
\
- (_Thread->SpecialApcDisable == 0)) \
- { \
- KiCheckForKernelApcDelivery(); \
- } \
- } \
+/* The following macro satisfies the wait of any dispatcher object */
+#define KiSatisfyObjectWait(Object, Thread)
\
+{
\
+ /* Special case for Mutants */
\
+ if ((Object)->Header.Type == MutantObject)
\
+ {
\
+ /* Decrease the Signal State */
\
+ (Object)->Header.SignalState--;
\
+
\
+ /* Check if it's now non-signaled */
\
+ if (!(Object)->Header.SignalState)
\
+ {
\
+ /* Set the Owner Thread */
\
+ (Object)->OwnerThread = Thread;
\
+
\
+ /* Disable APCs if needed */
\
+ Thread->KernelApcDisable -= (Object)->ApcDisable;
\
+
\
+ /* Check if it's abandoned */
\
+ if ((Object)->Abandoned)
\
+ {
\
+ /* Unabandon it */
\
+ (Object)->Abandoned = FALSE;
\
+
\
+ /* Return Status */
\
+ Thread->WaitStatus = STATUS_ABANDONED;
\
+ }
\
+
\
+ /* Insert it into the Mutant List */
\
+ InsertHeadList(&Thread->MutantListHead,
\
+ &(Object)->MutantListEntry);
\
+ }
\
+ }
\
+ else if (((Object)->Header.Type & TIMER_OR_EVENT_TYPE) ==
\
+ EventSynchronizationObject)
\
+ {
\
+ /* Synchronization Timers and Events just get un-signaled */
\
+ (Object)->Header.SignalState = 0;
\
+ }
\
+ else if ((Object)->Header.Type == SemaphoreObject)
\
+ {
\
+ /* These ones can have multiple states, so we only decrease it
*/ \
+ (Object)->Header.SignalState--;
\
+ }
\
}
-#define KEBUGCHECKWITHTF(a,b,c,d,e,f) \
- DbgPrint("KeBugCheckWithTf at %s:%i\n",__FILE__,__LINE__),
KeBugCheckWithTf(a,b,c,d,e,f)
+/* The following macro satisfies the wait of a mutant dispatcher object
*/
+#define KiSatisfyMutantWait(Object, Thread)
\
+{
\
+ /* Decrease the Signal State */
\
+ (Object)->Header.SignalState--;
\
+
\
+ /* Check if it's now non-signaled */
\
+ if (!(Object)->Header.SignalState)
\
+ {
\
+ /* Set the Owner Thread */
\
+ (Object)->OwnerThread = Thread;
\
+
\
+ /* Disable APCs if needed */
\
+ Thread->KernelApcDisable -= (Object)->ApcDisable;
\
+
\
+ /* Check if it's abandoned */
\
+ if ((Object)->Abandoned)
\
+ {
\
+ /* Unabandon it */
\
+ (Object)->Abandoned = FALSE;
\
+
\
+ /* Return Status */
\
+ Thread->WaitStatus = STATUS_ABANDONED;
\
+ }
\
+
\
+ /* Insert it into the Mutant List */
\
+ InsertHeadList(&Thread->MutantListHead,
\
+ &(Object)->MutantListEntry);
\
+ }
\
+}
-#define MAXIMUM_PROCESSORS 32
+/* The following macro satisfies the wait of any nonmutant dispatcher
object */
+#define KiSatisfyNonMutantWait(Object, Thread)
\
+{
\
+ if (((Object)->Header.Type & TIMER_OR_EVENT_TYPE) ==
\
+ EventSynchronizationObject)
\
+ {
\
+ /* Synchronization Timers and Events just get un-signaled */
\
+ (Object)->Header.SignalState = 0;
\
+ }
\
+ else if ((Object)->Header.Type == SemaphoreObject)
\
+ {
\
+ /* These ones can have multiple states, so we only decrease it
*/ \
+ (Object)->Header.SignalState--;
\
+ }
\
+}
+/* The following macro satisfies multiple objects in a wait state */
+#define KiSatisifyMultipleObjectWaits(FirstBlock)
\
+{
\
+ PKWAIT_BLOCK WaitBlock = FirstBlock;
\
+ PKTHREAD WaitThread = WaitBlock->Thread;
\
+
\
+ /* Loop through all the Wait Blocks, and wake each Object */
\
+ do
\
+ {
\
+ /* Make sure it hasn't timed out */
\
+ if (WaitBlock->WaitKey != STATUS_TIMEOUT)
\
+ {
\
+ /* Wake the Object */
\
+ KiSatisfyObjectWait((PKMUTANT)WaitBlock->Object,
WaitThread); \
+ }
\
+
\
+ /* Move to the next block */
\
+ WaitBlock = WaitBlock->NextWaitBlock;
\
+ } while (WaitBlock != FirstBlock);
\
+}
+extern KSPIN_LOCK DispatcherDatabaseLock;
+
+#define KeEnterCriticalRegion()
\
+{
\
+ PKTHREAD _Thread = KeGetCurrentThread();
\
+ if (_Thread) _Thread->KernelApcDisable--;
\
+}
+
+#define KeLeaveCriticalRegion()
\
+{
\
+ PKTHREAD _Thread = KeGetCurrentThread();
\
+ if((_Thread) && (++_Thread->KernelApcDisable == 0))
\
+ {
\
+ if (!IsListEmpty(&_Thread->ApcState.ApcListHead[KernelMode]) &&
\
+ (_Thread->SpecialApcDisable == 0))
\
+ {
\
+ KiCheckForKernelApcDelivery();
\
+ }
\
+ }
\
+}
+
+#define KEBUGCHECKWITHTF(a,b,c,d,e,f) \
+ DbgPrint("KeBugCheckWithTf at %s:%i\n",__FILE__,__LINE__), \
+ KeBugCheckWithTf(a,b,c,d,e,f)
+
/* INTERNAL KERNEL FUNCTIONS
************************************************/
/* threadsch.c
********************************************************************/
@@ -243,27 +386,11 @@
PVOID SystemArgument2
);
-KIRQL
-__inline
-FASTCALL
-KeAcquireDispatcherDatabaseLock(VOID);
-
VOID
-__inline
FASTCALL
-KeAcquireDispatcherDatabaseLockAtDpcLevel(VOID);
-
-VOID
-__inline
-FASTCALL
KeReleaseDispatcherDatabaseLock(KIRQL Irql);
VOID
-__inline
-FASTCALL
-KeReleaseDispatcherDatabaseLockFromDpcLevel(VOID);
-
-VOID
STDCALL
KeInitializeThread(
struct _KPROCESS* Process,
@@ -313,16 +440,6 @@
);
VOID
-__inline
-FASTCALL
-KeInitializeDispatcherHeader(
- DISPATCHER_HEADER* Header,
- ULONG Type,
- ULONG Size,
- ULONG SignalState
-);
-
-VOID
NTAPI
KeDumpStackFrames(PULONG Frame);
@@ -362,14 +479,6 @@
LARGE_INTEGER DueTime
);
-VOID
-__inline
-FASTCALL
-KiSatisfyObjectWait(
- PDISPATCHER_HEADER Object,
- PKTHREAD Thread
-);
-
BOOLEAN
__inline
FASTCALL
@@ -379,14 +488,9 @@
);
VOID
-__inline
FASTCALL
-KiSatisifyMultipleObjectWaits(PKWAIT_BLOCK WaitBlock);
-
-VOID
-FASTCALL
KiWaitTest(
- PDISPATCHER_HEADER Object,
+ PVOID Object,
KPRIORITY Increment
);
@@ -507,11 +611,6 @@
KeInitDispatcher(VOID);
VOID
-__inline
-FASTCALL
-KeInitializeDispatcher(VOID);
-
-VOID
NTAPI
KiInitializeSystemClock(VOID);
_____
Modified: trunk/reactos/ntoskrnl/ke/i386/ctxswitch.S
--- trunk/reactos/ntoskrnl/ke/i386/ctxswitch.S 2006-01-05 01:49:00 UTC
(rev 20567)
+++ trunk/reactos/ntoskrnl/ke/i386/ctxswitch.S 2006-01-05 04:26:55 UTC
(rev 20568)
@@ -21,6 +21,8 @@
/* GLOBALS
****************************************************************/
+.extern _DispatcherDatabaseLock
+
/* FUNCTIONS
****************************************************************/
/*++
@@ -244,7 +246,10 @@
pop [ebx+KPCR_EXCEPTION_LIST]
/* Return */
- call @KeReleaseDispatcherDatabaseLockFromDpcLevel@0
+//#ifdef CONFIG_SMP
+ mov ecx, _DispatcherDatabaseLock
+ call @KefReleaseSpinLockFromDpcLevel@4
+//#endif
ret
/*++
_____
Modified: trunk/reactos/ntoskrnl/ke/kthread.c
--- trunk/reactos/ntoskrnl/ke/kthread.c 2006-01-05 01:49:00 UTC (rev
20567)
+++ trunk/reactos/ntoskrnl/ke/kthread.c 2006-01-05 04:26:55 UTC (rev
20568)
@@ -819,7 +819,7 @@
DPRINT("Initializing Dispatcher Header for New Thread: %x in
Process: %x\n", Thread, Process);
KeInitializeDispatcherHeader(&Thread->DispatcherHeader,
ThreadObject,
- sizeof(KTHREAD),
+ sizeof(KTHREAD) / sizeof(LONG),
FALSE);
DPRINT("Thread Header Created. SystemRoutine: %x, StartRoutine: %x
with Context: %x\n",
_____
Modified: trunk/reactos/ntoskrnl/ke/wait.c
--- trunk/reactos/ntoskrnl/ke/wait.c 2006-01-05 01:49:00 UTC (rev
20567)
+++ trunk/reactos/ntoskrnl/ke/wait.c 2006-01-05 04:26:55 UTC (rev
20568)
@@ -2,7 +2,7 @@
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel
* FILE: ntoskrnl/ke/wait.c
- * PURPOSE: Manages dispatch level wait-related code
+ * PURPOSE: Manages waiting for Dispatcher Objects
* PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net)
* Gunnar Dalsnes
*/
@@ -16,7 +16,7 @@
/* GLOBALS
******************************************************************/
-static KSPIN_LOCK DispatcherDatabaseLock;
+KSPIN_LOCK DispatcherDatabaseLock;
/* Tells us if the Timer or Event is a Syncronization or Notification
Object */
#define TIMER_OR_EVENT_TYPE 0x7L
@@ -30,38 +30,58 @@
__inline
FASTCALL
KiCheckAlertability(BOOLEAN Alertable,
- PKTHREAD CurrentThread,
+ PKTHREAD Thread,
KPROCESSOR_MODE WaitMode,
PNTSTATUS Status)
{
- /* At this point, we have to do a wait, so make sure we can make
the thread Alertable if requested */
- if (Alertable) {
-
+ /*
+ * At this point, we have to do a wait, so make sure we can make
+ * the thread Alertable if requested.
+ */
+ if (Alertable)
+ {
/* If the Thread is Alerted, set the Wait Status accordingly */
- if (CurrentThread->Alerted[(int)WaitMode]) {
-
- CurrentThread->Alerted[(int)WaitMode] = FALSE;
- DPRINT("Thread was Alerted\n");
+ if (Thread->Alerted[(int)WaitMode])
+ {
+ Thread->Alerted[(int)WaitMode] = FALSE;
+ DPRINT("Thread was Alerted in the specified Mode\n");
*Status = STATUS_ALERTED;
return TRUE;
-
- /* If there are User APCs Pending, then we can't really be
alertable */
- } else if
((!IsListEmpty(&CurrentThread->ApcState.ApcListHead[UserMode])) &&
- (WaitMode != KernelMode)) {
-
+ }
+ else if ((WaitMode != KernelMode) &&
+
(!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])))
+ {
+ /* If there are User APCs Pending, then we can't really be
alertable */
DPRINT("APCs are Pending\n");
- CurrentThread->ApcState.UserApcPending = TRUE;
+ Thread->ApcState.UserApcPending = TRUE;
*Status = STATUS_USER_APC;
return TRUE;
}
-
- /* If there are User APCs Pending and we are waiting in usermode,
then we must notify the caller */
- } else if ((CurrentThread->ApcState.UserApcPending) && (WaitMode !=
KernelMode)) {
- DPRINT("APCs are Pending\n");
- *Status = STATUS_USER_APC;
+ else if (Thread->Alerted[KernelMode])
+ {
+ /*
+ * The thread is not alerted in the mode given, but it is
alerted
+ * in kernel-mode.
+ */
+ Thread->Alerted[KernelMode] = FALSE;
+ DPRINT("Thread was Alerted in Kernel-Mode\n");
+ *Status = STATUS_ALERTED;
return TRUE;
+ }
}
+ else if ((WaitMode != KernelMode) &&
+ (Thread->ApcState.UserApcPending))
+ {
+ /*
+ * If there are User APCs Pending and we are waiting in
usermode,
+ * then we must notify the caller
+ */
+ DPRINT("APCs are Pending\n");
+ *Status = STATUS_USER_APC;
+ return TRUE;
+ }
+ /* Stay in the loop */
return FALSE;
}
@@ -90,14 +110,14 @@
DPRINT("Entering KeDelayExecutionThread\n");
/* Check if the lock is already held */
- if (CurrentThread->WaitNext) {
-
+ if (CurrentThread->WaitNext)
+ {
/* Lock is held, disable Wait Next */
DPRINT("Lock is held\n");
CurrentThread->WaitNext = FALSE;
-
- } else {
-
+ }
+ else
+ {
/* Lock not held, acquire it */
DPRINT("Lock is not held, acquiring\n");
CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
@@ -107,12 +127,11 @@
TimerWaitBlock = &CurrentThread->WaitBlock[TIMER_WAIT_BLOCK];
/* Start Wait Loop */
- do {
+ do
+ {
+ /* Chceck if we can do an alertable wait, if requested */
+ if (KiCheckAlertability(Alertable, CurrentThread, WaitMode,
&Status)) break;
- /* We are going to wait no matter what (that's the point), so
test Alertability */
- if (KiCheckAlertability(Alertable, CurrentThread, WaitMode,
&Status))
- break;
-
/* Set Timer */
ThreadTimer = &CurrentThread->Timer;
@@ -129,30 +148,31 @@
InsertTailList(&ThreadTimer->Header.WaitListHead,
&TimerWaitBlock->WaitListEntry);
/* Insert the Timer into the Timer Lists and enable it */
- if (!KiInsertTimer(ThreadTimer, *Interval)) {
-
+ if (!KiInsertTimer(ThreadTimer, *Interval))
+ {
/* FIXME: The timer already expired, we should find a new
ready thread */
Status = STATUS_SUCCESS;
break;
}
/* Handle Kernel Queues */
- if (CurrentThread->Queue) {
-
+ if (CurrentThread->Queue)
+ {
DPRINT("Waking Queue\n");
KiWakeQueue(CurrentThread->Queue);
}
/* Block the Thread */
- DPRINT("Blocking the Thread: %d, %d, %x\n", Alertable,
WaitMode, KeGetCurrentThread());
+ DPRINT("Blocking the Thread: %d, %d, %x\n",
+ Alertable, WaitMode, KeGetCurrentThread());
KiBlockThread(&Status,
Alertable,
WaitMode,
DelayExecution);
/* Check if we were executing an APC or if we timed out */
- if (Status != STATUS_KERNEL_APC) {
-
+ if (Status != STATUS_KERNEL_APC)
+ {
/* This is a good thing */
if (Status == STATUS_TIMEOUT) Status = STATUS_SUCCESS;
@@ -160,13 +180,14 @@
return Status;
}
- DPRINT("Looping Again\n");
+ DPRINT("Looping Again\n"); // FIXME: Need to modify interval
CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
+ }
+ while (TRUE);
- } while (TRUE);
-
/* Release the Lock, we are done */
- DPRINT("Returning from KeDelayExecutionThread(), %x. Status: %d\n",
KeGetCurrentThread(), Status);
+ DPRINT("Returning from KeDelayExecutionThread(), %x. Status: %d\n",
+ KeGetCurrentThread(), Status);
KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
return Status;
}
@@ -194,33 +215,32 @@
BOOLEAN Alertable,
PLARGE_INTEGER Timeout)
{
- PDISPATCHER_HEADER CurrentObject;
+ PKMUTANT CurrentObject;
PKWAIT_BLOCK WaitBlock;
PKWAIT_BLOCK TimerWaitBlock;
PKTIMER ThreadTimer;
PKTHREAD CurrentThread = KeGetCurrentThread();
NTSTATUS Status;
NTSTATUS WaitStatus;
-
DPRINT("Entering KeWaitForSingleObject\n");
/* Check if the lock is already held */
- if (CurrentThread->WaitNext) {
-
+ if (CurrentThread->WaitNext)
+ {
/* Lock is held, disable Wait Next */
DPRINT("Lock is held\n");
CurrentThread->WaitNext = FALSE;
-
- } else {
-
+ }
+ else
+ {
/* Lock not held, acquire it */
DPRINT("Lock is not held, acquiring\n");
CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
}
/* Start the actual Loop */
- do {
-
+ do
+ {
/* Get the current Wait Status */
WaitStatus = CurrentThread->WaitStatus;
@@ -228,30 +248,38 @@
CurrentThread->WaitBlockList = WaitBlock =
&CurrentThread->WaitBlock[0];
/* Get the Current Object */
- CurrentObject = (PDISPATCHER_HEADER)Object;
+ CurrentObject = (PKMUTANT)Object;
- /* Check if the Object is Signaled */
- if (KiIsObjectSignaled(CurrentObject, CurrentThread)) {
-
- /* Just unwait this guy and exit */
- if (CurrentObject->SignalState != (LONG)MINLONG) {
-
- /* It has a normal signal state, so unwait it and
return */
- KiSatisfyObjectWait(CurrentObject, CurrentThread);
- Status = STATUS_WAIT_0;
- goto DontWait;
-
- } else {
-
- /* Is this a Mutant? */
- if (CurrentObject->Type == MutantObject) {
-
+ /* Check if it's a mutant */
+ if (CurrentObject->Header.Type == MutantObject)
+ {
+ /* Check its signal state or if we own it */
+ if ((CurrentObject->Header.SignalState > 0) ||
+ (CurrentThread == CurrentObject->OwnerThread))
+ {
+ /* Just unwait this guy and exit */
+ if (CurrentObject->Header.SignalState != (LONG)MINLONG)
+ {
+ /* It has a normal signal state, so unwait it and
return */
+ KiSatisfyMutantWait(CurrentObject, CurrentThread);
+ Status = STATUS_WAIT_0;
+ goto DontWait;
+ }
+ else
+ {
/* According to wasm.ru, we must raise this
exception (tested and true) */
KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
}
}
}
+ else if (CurrentObject->Header.SignalState > 0)
+ {
+ /* Another satisfied object */
+ KiSatisfyNonMutantWait(CurrentObject, CurrentThread);
+ Status = STATUS_WAIT_0;
+ goto DontWait;
+ }
/* Set up the Wait Block */
WaitBlock->Object = CurrentObject;
@@ -261,18 +289,17 @@
WaitBlock->NextWaitBlock = WaitBlock;
/* Make sure we can satisfy the Alertable request */
- if (KiCheckAlertability(Alertable, CurrentThread, WaitMode,
&Status))
- break;
+ if (KiCheckAlertability(Alertable, CurrentThread, WaitMode,
&Status)) break;
/* Set the Wait Status */
CurrentThread->WaitStatus = Status;
/* Enable the Timeout Timer if there was any specified */
- if (Timeout != NULL) {
-
- /* However if 0 timeout was specified, then we must fail
since we need to peform a wait */
- if (!Timeout->QuadPart) {
-
+ if (Timeout)
+ {
+ /* Fail if the timeout interval is actually 0 */
+ if (!Timeout->QuadPart)
+ {
/* Return a timeout */
Status = STATUS_TIMEOUT;
goto DontWait;
@@ -294,48 +321,53 @@
/* Link the timer to this Wait Block */
InitializeListHead(&ThreadTimer->Header.WaitListHead);
- InsertTailList(&ThreadTimer->Header.WaitListHead,
&TimerWaitBlock->WaitListEntry);
+ InsertTailList(&ThreadTimer->Header.WaitListHead,
+ &TimerWaitBlock->WaitListEntry);
/* Insert the Timer into the Timer Lists and enable it */
- if (!KiInsertTimer(ThreadTimer, *Timeout)) {
-
- /* Return a timeout if we couldn't insert the timer for
some reason */
+ if (!KiInsertTimer(ThreadTimer, *Timeout))
+ {
+ /* Return a timeout if we couldn't insert the timer */
Status = STATUS_TIMEOUT;
goto DontWait;
}
}
/* Link the Object to this Wait Block */
- InsertTailList(&CurrentObject->WaitListHead,
&WaitBlock->WaitListEntry);
+ InsertTailList(&CurrentObject->Header.WaitListHead,
+ &WaitBlock->WaitListEntry);
/* Handle Kernel Queues */
- if (CurrentThread->Queue) {
-
+ if (CurrentThread->Queue)
+ {
DPRINT("Waking Queue\n");
KiWakeQueue(CurrentThread->Queue);
}
/* Block the Thread */
- DPRINT("Blocking the Thread: %d, %d, %d, %x\n", Alertable,
WaitMode, WaitReason, KeGetCurrentThread());
+ DPRINT("Blocking the Thread: %d, %d, %d, %x\n",
+ Alertable, WaitMode, WaitReason, KeGetCurrentThread());
KiBlockThread(&Status,
Alertable,
WaitMode,
(UCHAR)WaitReason);
/* Check if we were executing an APC */
- if (Status != STATUS_KERNEL_APC) {
-
+ if (Status != STATUS_KERNEL_APC)
+ {
/* Return Status */
return Status;
}
- DPRINT("Looping Again\n");
+ /* Loop again and acquire the dispatcher lock */
+ DPRINT("Looping Again\n"); // FIXME: Change interval
CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
+ }
+ while (TRUE);
- } while (TRUE);
-
/* Release the Lock, we are done */
- DPRINT("Returning from KeWaitForMultipleObjects(), %x. Status:
%d\n", KeGetCurrentThread(), Status);
+ DPRINT("Returning from KeWaitForMultipleObjects(), %x. Status:
%d\n",
+ KeGetCurrentThread(), Status);
KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
return Status;
@@ -344,7 +376,8 @@
KiAdjustQuantumThread(CurrentThread);
/* Release & Return */
- DPRINT("Returning from KeWaitForMultipleObjects(), %x. Status:
%d\n. We did not wait.", KeGetCurrentThread(), Status);
+ DPRINT("Quick-return from KeWaitForMultipleObjects(), %x. Status:
%d\n.",
+ KeGetCurrentThread(), Status);
KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
return Status;
}
@@ -362,7 +395,7 @@
PLARGE_INTEGER Timeout,
PKWAIT_BLOCK WaitBlockArray)
{
- PDISPATCHER_HEADER CurrentObject;
+ PKMUTANT CurrentObject;
PKWAIT_BLOCK WaitBlock;
PKWAIT_BLOCK TimerWaitBlock;
PKTIMER ThreadTimer;
@@ -371,51 +404,45 @@
ULONG WaitIndex;
NTSTATUS Status;
NTSTATUS WaitStatus;
-
DPRINT("Entering KeWaitForMultipleObjects(Count %lu Object[] %p) "
- "PsGetCurrentThread() %x, Timeout %x\n", Count, Object,
PsGetCurrentThread(), Timeout);
+ "PsGetCurrentThread() %x, Timeout %x\n",
+ Count, Object, PsGetCurrentThread(), Timeout);
/* Set the Current Thread */
CurrentThread = KeGetCurrentThread();
/* Check if the lock is already held */
- if (CurrentThread->WaitNext) {
-
+ if (CurrentThread->WaitNext)
+ {
/* Lock is held, disable Wait Next */
DPRINT("Lock is held\n");
CurrentThread->WaitNext = FALSE;
-
- } else {
-
+ }
+ else
+ {
/* Lock not held, acquire it */
DPRINT("Lock is not held, acquiring\n");
CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
}
/* Make sure the Wait Count is valid for the Thread and Maximum
Wait Objects */
- if (!WaitBlockArray) {
-
+ if (!WaitBlockArray)
+ {
/* Check in regards to the Thread Object Limit */
- if (Count > THREAD_WAIT_OBJECTS) {
+ if (Count > THREAD_WAIT_OBJECTS)
KEBUGCHECK(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
- KEBUGCHECK(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
- }
-
/* Use the Thread's Wait Block */
WaitBlockArray = &CurrentThread->WaitBlock[0];
-
- } else {
-
+ }
+ else
+ {
/* Using our own Block Array. Check in regards to System Object
Limit */
- if (Count > MAXIMUM_WAIT_OBJECTS) {
-
- KEBUGCHECK(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
- }
+ if (Count > MAXIMUM_WAIT_OBJECTS)
KEBUGCHECK(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
}
/* Start the actual Loop */
- do {
-
+ do
+ {
/* Get the current Wait Status */
WaitStatus = CurrentThread->WaitStatus;
@@ -426,47 +453,76 @@
AllObjectsSignaled = TRUE;
/* First, we'll try to satisfy the wait directly */
- for (WaitIndex = 0; WaitIndex < Count; WaitIndex++) {
-
+ for (WaitIndex = 0; WaitIndex < Count; WaitIndex++)
+ {
/* Get the Current Object */
- CurrentObject = (PDISPATCHER_HEADER)Object[WaitIndex];
+ CurrentObject = (PKMUTANT)Object[WaitIndex];
- /* Check if the Object is Signaled */
- if (KiIsObjectSignaled(CurrentObject, CurrentThread)) {
-
- /* Check what kind of wait this is */
- if (WaitType == WaitAny) {
-
- /* This is a Wait Any, so just unwait this guy and
exit */
- if (CurrentObject->SignalState != (LONG)MINLONG) {
-
- /* It has a normal signal state, so unwait it
and return */
- KiSatisfyObjectWait(CurrentObject,
CurrentThread);
- Status = STATUS_WAIT_0 | WaitIndex;
- goto DontWait;
-
- } else {
-
- /* Is this a Mutant? */
- if (CurrentObject->Type == MutantObject) {
-
+ /* Check the type of wait */
+ if (WaitType == WaitAny)
+ {
+ /* Check if the Object is a mutant */
+ if (CurrentObject->Header.Type == MutantObject)
+ {
+ /* Check if it's signaled */
+ if ((CurrentObject->Header.SignalState > 0) ||
+ (CurrentThread == CurrentObject->OwnerThread))
+ {
+ /* This is a Wait Any, so just unwait this and
exit */
+ if (CurrentObject->Header.SignalState !=
(LONG)MINLONG)
+ {
+ /* Normal signal state, so unwait it and
return */
+ KiSatisfyMutantWait(CurrentObject,
CurrentThread);
+ Status = STATUS_WAIT_0 | WaitIndex;
+ goto DontWait;
+ }
+ else
+ {
/* According to wasm.ru, we must raise this
exception (tested and true) */
KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
}
}
}
-
- } else {
-
- /* One of the objects isn't signaled... if this is a
WaitAll, we will fail later */
- AllObjectsSignaled = FALSE;
+ else if (CurrentObject->Header.SignalState > 0)
+ {
+ /* Another signaled object, unwait and return */
+ KiSatisfyNonMutantWait(CurrentObject,
CurrentThread);
+ Status = WaitIndex;
+ goto DontWait;
+ }
}
+ else
+ {
+ /* Check if we're dealing with a mutant again */
+ if (CurrentObject->Header.Type == MutantObject)
+ {
+ /* Check if it has an invalid count */
+ if ((CurrentThread == CurrentObject->OwnerThread)
&&
+ (CurrentObject->Header.SignalState == MINLONG))
+ {
+ /* Raise an exception */
+
KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
+ ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
+ }
+ else if ((CurrentObject->Header.SignalState <= 0)
&&
+ (CurrentThread !=
CurrentObject->OwnerThread))
+ {
+ /* We don't own it, can't satisfy the wait */
+ AllObjectsSignaled = FALSE;
+ }
+ }
+ else if (CurrentObject->Header.SignalState <= 0)
+ {
+ /* Not signaled, can't satisfy */
+ AllObjectsSignaled = FALSE;
+ }
+ }
/* Set up a Wait Block for this Object */
WaitBlock->Object = CurrentObject;
WaitBlock->Thread = CurrentThread;
- WaitBlock->WaitKey = (USHORT)(STATUS_WAIT_0 + WaitIndex);
+ WaitBlock->WaitKey = (USHORT)WaitIndex;
WaitBlock->WaitType = (USHORT)WaitType;
WaitBlock->NextWaitBlock = WaitBlock + 1;
@@ -479,8 +535,8 @@
WaitBlock->NextWaitBlock = WaitBlockArray;
/* Check if this is a Wait All and all the objects are signaled
*/
- if ((WaitType == WaitAll) && (AllObjectsSignaled)) {
-
+ if ((WaitType == WaitAll) && (AllObjectsSignaled))
+ {
/* Return to the Root Wait Block */
WaitBlock = CurrentThread->WaitBlockList;
@@ -491,18 +547,17 @@
}
/* Make sure we can satisfy the Alertable request */
- if (KiCheckAlertability(Alertable, CurrentThread, WaitMode,
&Status))
- break;
+ if (KiCheckAlertability(Alertable, CurrentThread, WaitMode,
&Status)) break;
/* Set the Wait Status */
CurrentThread->WaitStatus = Status;
/* Enable the Timeout Timer if there was any specified */
- if (Timeout != NULL) {
-
- /* However if 0 timeout was specified, then we must fail
since we need to peform a wait */
- if (!Timeout->QuadPart) {
-
+ if (Timeout)
+ {
+ /* Make sure the timeout interval isn't actually 0 */
+ if (!Timeout->QuadPart)
+ {
/* Return a timeout */
Status = STATUS_TIMEOUT;
goto DontWait;
@@ -526,9 +581,9 @@
InitializeListHead(&ThreadTimer->Header.WaitListHead);
/* Insert the Timer into the Timer Lists and enable it */
- if (!KiInsertTimer(ThreadTimer, *Timeout)) {
-
- /* Return a timeout if we couldn't insert the timer for
some reason */
+ if (!KiInsertTimer(ThreadTimer, *Timeout))
+ {
+ /* Return a timeout if we couldn't insert the timer */
Status = STATUS_TIMEOUT;
goto DontWait;
}
@@ -536,28 +591,30 @@
/* Insert into Object's Wait List*/
WaitBlock = CurrentThread->WaitBlockList;
- do {
-
+ do
+ {
/* Get the Current Object */
CurrentObject = WaitBlock->Object;
/* Link the Object to this Wait Block */
- InsertTailList(&CurrentObject->WaitListHead,
&WaitBlock->WaitListEntry);
+ InsertTailList(&CurrentObject->Header.WaitListHead,
+ &WaitBlock->WaitListEntry);
/* Move to the next Wait Block */
WaitBlock = WaitBlock->NextWaitBlock;
- } while (WaitBlock != WaitBlockArray);
+ }
+ while (WaitBlock != WaitBlockArray);
/* Handle Kernel Queues */
- if (CurrentThread->Queue) {
-
+ if (CurrentThread->Queue)
+ {
DPRINT("Waking Queue\n");
KiWakeQueue(CurrentThread->Queue);
}
/* Block the Thread */
- DPRINT("Blocking the Thread: %d, %d, %d, %x\n", Alertable,
WaitMode,
- WaitReason, KeGetCurrentThread());
+ DPRINT("Blocking the Thread: %d, %d, %d, %x\n",
+ Alertable, WaitMode, WaitReason, KeGetCurrentThread());
KiBlockThread(&Status,
Alertable,
WaitMode,
@@ -565,17 +622,18 @@
/* Check if we were executing an APC */
DPRINT("Thread is back\n");
- if (Status != STATUS_KERNEL_APC) {
-
+ if (Status != STATUS_KERNEL_APC)
+ {
/* Return Status */
return Status;
}
[truncated at 1000 lines; 408 more skipped]
