[ion] 20568: - Optimized the dispatcher lock. It is now gone on non-SMP systems and IRQL is raised or lowered instead.
- 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@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]
-
ion＠svn.reactos.org