Modified: trunk/reactos/config
Modified: trunk/reactos/include/ddk/extypes.h
Modified: trunk/reactos/ntoskrnl/Makefile
Modified: trunk/reactos/ntoskrnl/ex/init.c
Modified: trunk/reactos/ntoskrnl/ex/work.c
Modified: trunk/reactos/ntoskrnl/include/internal/ex.h
Modified: trunk/reactos/ntoskrnl/include/internal/ke.h
Modified: trunk/reactos/ntoskrnl/include/internal/ps.h
Modified: trunk/reactos/ntoskrnl/ke/event.c
Modified: trunk/reactos/ntoskrnl/ke/i386/tskswitch.S
Modified: trunk/reactos/ntoskrnl/ke/kthread.c
Modified: trunk/reactos/ntoskrnl/ke/mutex.c
Modified: trunk/reactos/ntoskrnl/ke/queue.c
Modified: trunk/reactos/ntoskrnl/ke/sem.c
Modified: trunk/reactos/ntoskrnl/ke/timer.c
Modified: trunk/reactos/ntoskrnl/ke/wait.c
Modified: trunk/reactos/ntoskrnl/ntoskrnl.def
Modified: trunk/reactos/ntoskrnl/ps/kill.c
Modified: trunk/reactos/ntoskrnl/ps/thread.c
--- trunk/reactos/config 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/config 2005-03-14 05:54:32 UTC (rev 14047)
@@ -5,7 +5,6 @@
# Possible values in the future: alpha,i386,m68k,mips,powerpc
ARCH := i386
-
#
# Which cpu should reactos optimize for
# example : i486, i586, pentium, pentium2, pentium3, pentium4
@@ -33,11 +32,6 @@
CONFIG_SMP := 0
#
-# whether to use a 3GB User, 1GB Kernel memory map
-#
-3GB := 0
-
-#
# Which version of NDIS do we support up to?
#
#NDISVERSION=NDIS50
--- trunk/reactos/include/ddk/extypes.h 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/include/ddk/extypes.h 2005-03-14 05:54:32 UTC (rev 14047)
@@ -30,6 +30,22 @@
MaximumWorkQueue
} WORK_QUEUE_TYPE;
+typedef struct _EX_QUEUE_WORKER_INFO {
+ UCHAR QueueDisabled:1;
+ UCHAR MakeThreadsAsNecessary:1;
+ UCHAR WaitMode:1;
+ ULONG WorkerCount:29;
+} EX_QUEUE_WORKER_INFO, *PEX_QUEUE_WORKER_INFO;
+
+typedef struct _EX_WORK_QUEUE {
+ KQUEUE WorkerQueue;
+ ULONG DynamicThreadCount;
+ ULONG WorkItemsProcessed;
+ ULONG WorkItemsProcessedLastPass;
+ ULONG QueueDepthLastPass;
+ EX_QUEUE_WORKER_INFO Info;
+} EX_WORK_QUEUE, *PEX_WORK_QUEUE;
+
typedef ULONG_PTR ERESOURCE_THREAD, *PERESOURCE_THREAD;
typedef struct _OWNER_ENTRY
--- trunk/reactos/ntoskrnl/Makefile 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/Makefile 2005-03-14 05:54:32 UTC (rev 14047)
@@ -212,7 +212,8 @@
ob/object.o \
ob/sdcache.o \
ob/security.o \
- ob/symlink.o
+ ob/symlink.o \
+ ob/wait.o
# Process Manager (Ps)
OBJECTS_PS = \
--- trunk/reactos/ntoskrnl/ex/init.c 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ex/init.c 2005-03-14 05:54:32 UTC (rev 14047)
@@ -27,11 +27,9 @@
extern ULONG_PTR LastKernelAddress;
extern LOADER_MODULE KeLoaderModules[64];
extern PRTL_MESSAGE_RESOURCE_DATA KiBugCodeMessages;
-#if 0
extern LIST_ENTRY KiProfileListHead;
extern LIST_ENTRY KiProfileSourceListHead;
extern KSPIN_LOCK KiProfileLock;
-#endif
VOID PspPostInitSystemProcess(VOID);
@@ -427,12 +425,10 @@
/* Bring back the IRQL to Passive */
KeLowerIrql(PASSIVE_LEVEL);
-#if 0
/* Initialize Profiling */
InitializeListHead(&KiProfileListHead);
InitializeListHead(&KiProfileSourceListHead);
KeInitializeSpinLock(&KiProfileLock);
-#endif
/* Load basic Security for other Managers */
if (!SeInit1()) KEBUGCHECK(SECURITY_INITIALIZATION_FAILED);
@@ -488,7 +484,7 @@
PspPostInitSystemProcess();
/* initialize the worker threads */
- ExInitializeWorkerThreads();
+ ExpInitializeWorkerThreads();
/* initialize callbacks */
ExpInitializeCallbacks();
--- trunk/reactos/ntoskrnl/ex/work.c 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ex/work.c 2005-03-14 05:54:32 UTC (rev 14047)
@@ -1,11 +1,11 @@
-/* $Id$
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ex/work.c
* PURPOSE: Manage system work queues
*
- * PROGRAMMERS: David Welch (welch@mcmail.com)
+ * PROGRAMMERS: Alex Ionescu - Used correct work queue array and added some fixes and checks.
+ * Gunnar Dalsnes - Implemented
*/
/* INCLUDES ******************************************************************/
@@ -25,17 +25,10 @@
/*
* PURPOSE: Queue of items waiting to be processed at normal priority
*/
-KQUEUE EiNormalWorkQueue;
+EX_WORK_QUEUE ExWorkerQueue[MaximumWorkQueue];
-KQUEUE EiCriticalWorkQueue;
-
-KQUEUE EiHyperCriticalWorkQueue;
-
/* FUNCTIONS ****************************************************************/
-//static NTSTATUS STDCALL
-static VOID STDCALL
-ExWorkerThreadEntryPoint(IN PVOID context)
/*
* FUNCTION: Entry point for a worker thread
* ARGUMENTS:
@@ -44,161 +37,138 @@
* NOTE: To kill a worker thread you must queue an item whose callback
* calls PsTerminateSystemThread
*/
+static
+VOID
+STDCALL
+ExpWorkerThreadEntryPoint(IN PVOID Context)
{
-
- PWORK_QUEUE_ITEM item;
- PLIST_ENTRY current;
+ PWORK_QUEUE_ITEM WorkItem;
+ PLIST_ENTRY QueueEntry;
+ WORK_QUEUE_TYPE WorkQueueType;
+ PEX_WORK_QUEUE WorkQueue;
- while (TRUE)
- {
- current = KeRemoveQueue( (PKQUEUE)context, KernelMode, NULL );
+ /* Get Queue Type and Worker Queue */
+ WorkQueueType = (WORK_QUEUE_TYPE)Context;
+ WorkQueue = &ExWorkerQueue[WorkQueueType];
+
+ /* Loop forever */
+ while (TRUE) {
+
+ /* Wait for Something to Happen on the Queue */
+ QueueEntry = KeRemoveQueue(&WorkQueue->WorkerQueue, KernelMode, NULL);
- /* can't happend since we do a KernelMode wait (and we're a system thread) */
- ASSERT((NTSTATUS)current != STATUS_USER_APC);
+ /* Can't happen since we do a KernelMode wait (and we're a system thread) */
+ ASSERT((NTSTATUS)QueueEntry != STATUS_USER_APC);
- /* this should never happend either, since we wait with NULL timeout,
- * but there's a slight possibility that STATUS_TIMEOUT is returned
- * at queue rundown in NT (unlikely) -Gunnar
- */
- ASSERT((NTSTATUS)current != STATUS_TIMEOUT);
-
- /* based on INVALID_WORK_QUEUE_ITEM bugcheck desc. */
- if (current->Flink == NULL || current->Blink == NULL)
- {
- KeBugCheck(INVALID_WORK_QUEUE_ITEM);
- }
-
- /* "reinitialize" item (same as done in ExInitializeWorkItem) */
- current->Flink = NULL;
-
- item = CONTAINING_RECORD( current, WORK_QUEUE_ITEM, List);
- item->WorkerRoutine(item->Parameter);
-
- if (KeGetCurrentIrql() != PASSIVE_LEVEL)
- {
- KeBugCheck(IRQL_NOT_LESS_OR_EQUAL);
- }
- }
-
+ /* this should never happen either, since we wait with NULL timeout,
+ * but there's a slight possibility that STATUS_TIMEOUT is returned
+ * at queue rundown in NT (unlikely) -Gunnar
+ */
+ ASSERT((NTSTATUS)QueueEntry != STATUS_TIMEOUT);
+
+ /* Increment Processed Work Items */
+ InterlockedIncrement(&WorkQueue->WorkItemsProcessed);
+
+ /* Get the Work Item */
+ WorkItem = CONTAINING_RECORD(QueueEntry, WORK_QUEUE_ITEM, List);
+
+ /* Call the Worker Routine */
+ WorkItem->WorkerRoutine(WorkItem->Parameter);
+
+ /* Make sure it returned at right IRQL */
+ if (KeGetCurrentIrql() != PASSIVE_LEVEL) {
+
+ /* FIXME: Make this an Ex */
+ KEBUGCHECK(WORKER_THREAD_RETURNED_AT_BAD_IRQL);
+ }
+
+ /* Make sure it returned with Impersionation Disabled */
+ if (PsGetCurrentThread()->ActiveImpersonationInfo) {
+
+ /* FIXME: Make this an Ex */
+ KEBUGCHECK(IMPERSONATING_WORKER_THREAD);
+ }
+ }
}
-static VOID ExInitializeWorkQueue(PKQUEUE WorkQueue,
- KPRIORITY Priority)
+static
+VOID
+STDCALL
+ExpInitializeWorkQueue(WORK_QUEUE_TYPE WorkQueueType,
+ KPRIORITY Priority)
{
ULONG i;
PETHREAD Thread;
HANDLE hThread;
- NTSTATUS Status;
-
- PAGED_CODE();
-
+
/* Loop through how many threads we need to create */
for (i = 0; i < NUMBER_OF_WORKER_THREADS; i++) {
-
+
/* Create the System Thread */
- Status = PsCreateSystemThread(&hThread,
- THREAD_ALL_ACCESS,
- NULL,
- NULL,
- NULL,
- ExWorkerThreadEntryPoint,
- (PVOID)WorkQueue);
- if(NT_SUCCESS(Status))
- {
- /* Get the Thread */
- Status = ObReferenceObjectByHandle(hThread,
- THREAD_SET_INFORMATION,
- PsThreadType,
- KernelMode,
- (PVOID*)&Thread,
- NULL);
-
- if(NT_SUCCESS(Status))
- {
- /* Set the Priority */
- KeSetPriorityThread(&Thread->Tcb, Priority);
-
- /* Dereference and close handle */
- ObDereferenceObject(Thread);
- ZwClose(hThread);
- }
- else
- {
- DPRINT1("Unable to reference worker thread handle 0x%x, Status: 0x%x!\n", hThread, Status);
- KEBUGCHECK(0);
- }
- }
- else
- {
- DPRINT1("Unable to create worker thread, Status: 0x%x!\n", Status);
- KEBUGCHECK(0);
- }
+ PsCreateSystemThread(&hThread,
+ THREAD_ALL_ACCESS,
+ NULL,
+ NULL,
+ NULL,
+ ExpWorkerThreadEntryPoint,
+ (PVOID)WorkQueueType);
+
+ /* Get the Thread */
+ ObReferenceObjectByHandle(hThread,
+ THREAD_SET_INFORMATION,
+ PsThreadType,
+ KernelMode,
+ (PVOID*)&Thread,
+ NULL);
+
+ /* Set the Priority */
+ KeSetPriorityThread(&Thread->Tcb, Priority);
+
+ /* Dereference and close handle */
+ ObDereferenceObject(Thread);
+ ZwClose(hThread);
}
}
-VOID INIT_FUNCTION
-ExInitializeWorkerThreads(VOID)
+VOID
+INIT_FUNCTION
+ExpInitializeWorkerThreads(VOID)
{
- KeInitializeQueue( &EiNormalWorkQueue, NUMBER_OF_WORKER_THREADS );
- KeInitializeQueue( &EiCriticalWorkQueue , NUMBER_OF_WORKER_THREADS );
- KeInitializeQueue( &EiHyperCriticalWorkQueue , NUMBER_OF_WORKER_THREADS );
-
- ExInitializeWorkQueue(&EiNormalWorkQueue,
- LOW_PRIORITY);
- ExInitializeWorkQueue(&EiCriticalWorkQueue,
- LOW_REALTIME_PRIORITY);
- ExInitializeWorkQueue(&EiHyperCriticalWorkQueue,
- HIGH_PRIORITY);
+ ULONG WorkQueueType;
+
+ /* Initialize the Array */
+ for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++) {
+
+ RtlZeroMemory(&ExWorkerQueue[WorkQueueType], sizeof(EX_WORK_QUEUE));
+ KeInitializeQueue(&ExWorkerQueue[WorkQueueType].WorkerQueue, 0);
+ }
+
+ /* Create the built-in worker threads for each work queue */
+ ExpInitializeWorkQueue(CriticalWorkQueue, LOW_REALTIME_PRIORITY);
+ ExpInitializeWorkQueue(DelayedWorkQueue, LOW_PRIORITY);
+ ExpInitializeWorkQueue(HyperCriticalWorkQueue, HIGH_PRIORITY);
}
/*
* @implemented
- */
-VOID STDCALL
-ExQueueWorkItem (PWORK_QUEUE_ITEM WorkItem,
- WORK_QUEUE_TYPE QueueType)
-/*
+ *
* FUNCTION: Inserts a work item in a queue for one of the system worker
* threads to process
* ARGUMENTS:
* WorkItem = Item to insert
* QueueType = Queue to insert it in
*/
+VOID
+STDCALL
+ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem,
+ WORK_QUEUE_TYPE QueueType)
{
ASSERT(WorkItem!=NULL);
ASSERT_IRQL(DISPATCH_LEVEL);
ASSERT(WorkItem->List.Flink == NULL);
- /*
- * Insert the item in the appropiate queue and wake up any thread
- * waiting for something to do
- */
- switch(QueueType)
- {
- case DelayedWorkQueue:
- KeInsertQueue (
- &EiNormalWorkQueue,
- &WorkItem->List
- );
- break;
-
- case CriticalWorkQueue:
- KeInsertQueue (
- &EiCriticalWorkQueue,
- &WorkItem->List
- );
- break;
-
- case HyperCriticalWorkQueue:
- KeInsertQueue (
- &EiHyperCriticalWorkQueue,
- &WorkItem->List
- );
- break;
-
- default:
- break;
-
- }
+
+ /* Insert the Queue */
+ KeInsertQueue(&ExWorkerQueue[QueueType].WorkerQueue, &WorkItem->List);
}
/* EOF */
--- trunk/reactos/ntoskrnl/include/internal/ex.h 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/include/internal/ex.h 2005-03-14 05:54:32 UTC (rev 14047)
@@ -86,8 +86,10 @@
extern ULONG ExpTimeZoneId;
extern POBJECT_TYPE ExEventPairObjectType;
+extern POBJECT_TYPE EXPORTED ExMutantObjectType;
+extern POBJECT_TYPE EXPORTED ExSemaphoreObjectType;
+extern POBJECT_TYPE EXPORTED ExTimerType;
-
/* INITIALIZATION FUNCTIONS *************************************************/
VOID
@@ -100,7 +102,7 @@
VOID
ExpInitTimeZoneInfo(VOID);
VOID
-ExInitializeWorkerThreads(VOID);
+ExpInitializeWorkerThreads(VOID);
VOID
ExpInitLookasideLists(VOID);
VOID
--- trunk/reactos/ntoskrnl/include/internal/ke.h 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/include/internal/ke.h 2005-03-14 05:54:32 UTC (rev 14047)
@@ -139,34 +139,39 @@
IN KPROFILE_SOURCE Source
);
-VOID KiInsertProfileIntoProcess(PLIST_ENTRY ListHead, PKPROFILE Profile);
-VOID KiInsertProfile(PKPROFILE Profile);
-VOID KiRemoveProfile(PKPROFILE Profile);
-VOID STDCALL KiDeleteProfile(PVOID ObjectBody);
-
VOID STDCALL KeUpdateSystemTime(PKTRAP_FRAME TrapFrame, KIRQL Irql);
VOID STDCALL KeUpdateRunTime(PKTRAP_FRAME TrapFrame, KIRQL Irql);
VOID STDCALL KiExpireTimers(PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2);
-KIRQL KeAcquireDispatcherDatabaseLock(VOID);
-VOID KeAcquireDispatcherDatabaseLockAtDpcLevel(VOID);
-VOID KeReleaseDispatcherDatabaseLock(KIRQL Irql);
-VOID KeReleaseDispatcherDatabaseLockFromDpcLevel(VOID);
+KIRQL inline FASTCALL KeAcquireDispatcherDatabaseLock(VOID);
+VOID inline FASTCALL KeAcquireDispatcherDatabaseLockAtDpcLevel(VOID);
+VOID inline FASTCALL KeReleaseDispatcherDatabaseLock(KIRQL Irql);
+VOID inline FASTCALL KeReleaseDispatcherDatabaseLockFromDpcLevel(VOID);
BOOLEAN KiDispatcherObjectWake(DISPATCHER_HEADER* hdr, KPRIORITY increment);
VOID STDCALL KeExpireTimers(PKDPC Apc,
PVOID Arg1,
PVOID Arg2,
PVOID Arg3);
-VOID KeInitializeDispatcherHeader(DISPATCHER_HEADER* Header, ULONG Type,
- ULONG Size, ULONG SignalState);
+VOID inline FASTCALL KeInitializeDispatcherHeader(DISPATCHER_HEADER* Header, ULONG Type,
+ ULONG Size, ULONG SignalState);
VOID KeDumpStackFrames(PULONG Frame);
BOOLEAN KiTestAlert(VOID);
-BOOLEAN KiAbortWaitThread(struct _KTHREAD* Thread, NTSTATUS WaitStatus);
+VOID FASTCALL KiAbortWaitThread(struct _KTHREAD* Thread, NTSTATUS WaitStatus);
+
+BOOLEAN STDCALL KiInsertTimer(PKTIMER Timer, LARGE_INTEGER DueTime);
+VOID inline FASTCALL KiSatisfyObjectWait(PDISPATCHER_HEADER Object, PKTHREAD Thread);
+
+BOOLEAN inline FASTCALL KiIsObjectSignaled(PDISPATCHER_HEADER Object, PKTHREAD Thread);
+
+VOID inline FASTCALL KiSatisifyMultipleObjectWaits(PKWAIT_BLOCK WaitBlock);
+
+VOID FASTCALL KiWaitTest(PDISPATCHER_HEADER Object, KPRIORITY Increment);
+
PULONG KeGetStackTopThread(struct _ETHREAD* Thread);
VOID KeContextToTrapFrame(PCONTEXT Context, PKTRAP_FRAME TrapFrame);
VOID STDCALL KiDeliverApc(KPROCESSOR_MODE PreviousMode,
@@ -191,6 +196,7 @@
KeTestAlertThread(IN KPROCESSOR_MODE AlertMode);
BOOLEAN STDCALL KeRemoveQueueApc (PKAPC Apc);
+VOID FASTCALL KiWakeQueue(IN PKQUEUE Queue);
PLIST_ENTRY STDCALL KeRundownQueue(IN PKQUEUE Queue);
extern LARGE_INTEGER SystemBootTime;
@@ -202,7 +208,7 @@
VOID KeInitTimer(VOID);
VOID KeInitDpc(struct _KPRCB* Prcb);
VOID KeInitDispatcher(VOID);
-VOID KeInitializeDispatcher(VOID);
+VOID inline FASTCALL KeInitializeDispatcher(VOID);
VOID KiInitializeSystemClock(VOID);
VOID KiInitializeBugCheck(VOID);
VOID Phase1Initialization(PVOID Context);
--- trunk/reactos/ntoskrnl/include/internal/ps.h 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/include/internal/ps.h 2005-03-14 05:54:32 UTC (rev 14047)
@@ -525,8 +525,11 @@
ULONG PsEnumThreadsByProcess(PEPROCESS Process);
PEPROCESS PsGetNextProcess(PEPROCESS OldProcess);
VOID
-PsBlockThread(PNTSTATUS Status, UCHAR Alertable, ULONG WaitMode,
- BOOLEAN DispatcherLock, KIRQL WaitIrql, UCHAR WaitReason);
+STDCALL
+PsBlockThread(PNTSTATUS Status,
+ UCHAR Alertable,
+ ULONG WaitMode,
+ UCHAR WaitReason);
VOID
PsUnblockThread(PETHREAD Thread, PNTSTATUS WaitStatus, KPRIORITY Increment);
VOID
--- trunk/reactos/ntoskrnl/ke/event.c 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ke/event.c 2005-03-14 05:54:32 UTC (rev 14047)
@@ -91,7 +91,7 @@
Event->Header.SignalState = 1;
/* Wake the Event */
- KiDispatcherObjectWake(&Event->Header, Increment);
+ KiWaitTest(&Event->Header, Increment);
}
/* Unsignal it */
@@ -196,7 +196,7 @@
/* We must do a full wait satisfaction */
DPRINT("Notification Event or WaitAll, Wait on the Event and Signal\n");
Event->Header.SignalState = 1;
- KiDispatcherObjectWake(&Event->Header, Increment);
+ KiWaitTest(&Event->Header, Increment);
}
} else {
--- trunk/reactos/ntoskrnl/ke/i386/tskswitch.S 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ke/i386/tskswitch.S 2005-03-14 05:54:32 UTC (rev 14047)
@@ -204,7 +204,7 @@
*/
sti
- call _KeReleaseDispatcherDatabaseLockFromDpcLevel
+ call @KeReleaseDispatcherDatabaseLockFromDpcLevel@0
cmpl $0, _PiNrThreadsAwaitingReaping
je 5f
--- trunk/reactos/ntoskrnl/ke/kthread.c 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ke/kthread.c 2005-03-14 05:54:32 UTC (rev 14047)
@@ -56,7 +56,7 @@
/* Signal and satisfy */
Thread->SuspendSemaphore.Header.SignalState++;
- KiDispatcherObjectWake(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
+ KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
}
}
--- trunk/reactos/ntoskrnl/ke/mutex.c 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ke/mutex.c 2005-03-14 05:54:32 UTC (rev 14047)
@@ -177,7 +177,7 @@
/* Wake the Mutant */
DPRINT("Waking the Mutant\n");
- KiDispatcherObjectWake(&Mutant->Header, Increment);
+ KiWaitTest(&Mutant->Header, Increment);
}
}
--- trunk/reactos/ntoskrnl/ke/queue.c 2005-03-14 04:51:51 UTC (rev 14046)
+++ trunk/reactos/ntoskrnl/ke/queue.c 2005-03-14 05:54:32 UTC (rev 14047)
@@ -16,245 +16,483 @@
/* FUNCTIONS *****************************************************************/
-
+LONG STDCALL KiInsertQueue(IN PKQUEUE Queue, IN PLIST_ENTRY Entry, BOOLEAN Head);
+
/*
* @implemented
*/
-VOID STDCALL
+VOID
+STDCALL
KeInitializeQueue(IN PKQUEUE Queue,
- IN ULONG Count OPTIONAL)
+ IN ULONG Count OPTIONAL)
{
- KeInitializeDispatcherHeader(&Queue->Header,
- QueueObject,
- sizeof(KQUEUE)/sizeof(ULONG),
- 0);
- InitializeListHead(&Queue->EntryListHead);
- InitializeListHead(&Queue->ThreadListHead);
- Queue->CurrentCount = 0;
- Queue->MaximumCount = (Count == 0) ? (ULONG) KeNumberProcessors : Count;
+ DPRINT("KeInitializeQueue %x\n", Queue);
+
+ /* Initialize the Header */
+ KeInitializeDispatcherHeader(&Queue->Header,
+ QueueObject,
+ sizeof(KQUEUE)/sizeof(ULONG),
+ 0);
+
+ /* Initialize the Lists */
+ InitializeListHead(&Queue->EntryListHead);
+ InitializeListHead(&Queue->ThreadListHead);
+
+ /* Set the Current and Maximum Count */
+ Queue->CurrentCount = 0;
+ Queue->MaximumCount = (Count == 0) ? (ULONG) KeNumberProcessors : Count;
}
-
/*
* @implemented
- *
- * Returns number of entries in the queue
*/
-LONG STDCALL
-KeReadStateQueue(IN PKQUEUE Queue)
+LONG
+STDCALL
+KeInsertHeadQueue(IN PKQUEUE Queue,
+ IN PLIST_ENTRY Entry)
{
- return(Queue->Header.SignalState);
-}
-
-/*
- * Returns the previous number of entries in the queue
- */
-LONG STDCALL
-KiInsertQueue(
- IN PKQUEUE Queue,
- IN PLIST_ENTRY Entry,
- BOOLEAN Head
- )
-{
- ULONG InitialState;
-
- DPRINT("KiInsertQueue(Queue %x, Entry %x)\n", Queue, Entry);
+ LONG PreviousState;
+ KIRQL OldIrql;
+
+ DPRINT("KeInsertHeadQueue %x\n", Queue);
+
+ /* Lock the Dispatcher Database */
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+
+ /* Insert the Queue */
+ PreviousState = KiInsertQueue(Queue, Entry, TRUE);
+
+ /* Release the Dispatcher Lock */
+ KeReleaseDispatcherDatabaseLock(OldIrql);
- InitialState = Queue->Header.SignalState;
-
- if (Head)
- {
- InsertHeadList(&Queue->EntryListHead, Entry);
- }
- else
- {
- InsertTailList(&Queue->EntryListHead, Entry);
- }
-
- //inc. num entries in queue
- Queue->Header.SignalState++;
-
- /* Why the KeGetCurrentThread()->Queue != Queue?
- * KiInsertQueue might be called from an APC for the current thread.
- * -Gunnar
- */
- if (Queue->CurrentCount < Queue->MaximumCount &&
- !IsListEmpty(&Queue->Header.WaitListHead) &&
- KeGetCurrentThread()->Queue != Queue)
- {
- KiDispatcherObjectWake(&Queue->Header, IO_NO_INCREMENT);
- }
-
- return InitialState;
+ /* Return previous State */
+ return PreviousState;
}
-
-
/*
* @implemented
*/
LONG STDCALL
-KeInsertHeadQueue(IN PKQUEUE Queue,
- IN PLIST_ENTRY Entry)
+KeInsertQueue(IN PKQUEUE Queue,
+ IN PLIST_ENTRY Entry)
{
- LONG Result;
- KIRQL OldIrql;
+ LONG PreviousState;
+ KIRQL OldIrql;
+
+ DPRINT("KeInsertQueue %x\n", Queue);
+
+ /* Lock the Dispatcher Database */
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+
+ /* Insert the Queue */
+ PreviousState = KiInsertQueue(Queue, Entry, FALSE);
+
+ /* Release the Dispatcher Lock */
+ KeReleaseDispatcherDatabaseLock(OldIrql);
- OldIrql = KeAcquireDispatcherDatabaseLock();
- Result = KiInsertQueue(Queue,Entry,TRUE);
- KeReleaseDispatcherDatabaseLock(OldIrql);
-
- return Result;
+ /* Return previous State */
+ return PreviousState;
}
-
/*
* @implemented
+ *
+ * Returns number of entries in the queue
*/
-LONG STDCALL
-KeInsertQueue(IN PKQUEUE Queue,
- IN PLIST_ENTRY Entry)
+LONG
+STDCALL
+KeReadStateQueue(IN PKQUEUE Queue)
{
- LONG Result;
- KIRQL OldIrql;
-
- OldIrql = KeAcquireDispatcherDatabaseLock();
- Result = KiInsertQueue(Queue,Entry,FALSE);
- KeReleaseDispatcherDatabaseLock(OldIrql);
-
- return Result;
+ /* Returns the Signal State */
+ return(Queue->Header.SignalState);
}
-
/*
* @implemented
*/
-PLIST_ENTRY STDCALL
+PLIST_ENTRY
+STDCALL
KeRemoveQueue(IN PKQUEUE Queue,
- IN KPROCESSOR_MODE WaitMode,
- IN PLARGE_INTEGER Timeout OPTIONAL)
+ IN KPROCESSOR_MODE WaitMode,
+ IN PLARGE_INTEGER Timeout OPTIONAL)
{
- PLIST_ENTRY ListEntry;
- NTSTATUS Status;
- PKTHREAD Thread = KeGetCurrentThread();
- KIRQL OldIrql;
+ PLIST_ENTRY ListEntry;
+ NTSTATUS Status;
+ PKTHREAD Thread = KeGetCurrentThread();
+ KIRQL OldIrql;
+ PKQUEUE PreviousQueue;
+ PKWAIT_BLOCK WaitBlock;
+ PKWAIT_BLOCK TimerWaitBlock;
+ PKTIMER Timer;
- OldIrql = KeAcquireDispatcherDatabaseLock ();
+ DPRINT("KeRemoveQueue %x\n", Queue);
+
+ /* Check if the Lock is already held */
+ if (Thread->WaitNext) {
+
+ DPRINT("Lock is already held\n");
+
+ } else {
+
+ /* Lock the Dispatcher Database */
+ DPRINT("Lock not held, acquiring\n");
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+ Thread->WaitIrql = OldIrql;
+ }
- if (Thread->Queue != Queue)
- {
- /*
- * INVESTIGATE: What is the Thread->QueueListEntry used for? It's linked it into the
- * Queue->ThreadListHead when the thread registers with the queue and unlinked when
- * the thread registers with a new queue. The Thread->Queue already tells us what
- * queue the thread is registered with.
- * -Gunnar
- */
+ /* This is needed so that we can set the new queue right here, before additional processing */
+ PreviousQueue = Thread->Queue;
+ Thread->Queue = Queue;
- //unregister thread from previous queue (if any)
- if (Thread->Queue)
- {
- RemoveEntryList(&Thread->QueueListEntry);
- Thread->Queue->CurrentCount--;
-
- if (Thread->Queue->CurrentCount < Thread->Queue->MaximumCount &&
- !IsListEmpty(&Thread->Queue->EntryListHead))
- {
- KiDispatcherObjectWake(&Thread->Queue->Header, 0);
- }
+ /* Check if this is a different queue */
+ if (Queue != PreviousQueue) {
+
+ /*
+ * INVESTIGATE: What is the Thread->QueueListEntry used for? It's linked it into the
+ * Queue->ThreadListHead when the thread registers with the queue and unlinked when
+ * the thread registers with a new queue. The Thread->Queue already tells us what
+ * queue the thread is registered with.
+ * -Gunnar
+ */
+ DPRINT("Different Queue\n");
+ if (PreviousQueue) {
+
+ /* Remove from this list */
+ DPRINT("Removing Old Queue\n");
+ RemoveEntryList(&Thread->QueueListEntry);
+
+ /* Wake the queue */
+ DPRINT("Activating new thread\n");
+ KiWakeQueue(PreviousQueue);
}
- // register thread with this queue
- InsertTailList(&Queue->ThreadListHead, &Thread->QueueListEntry);
- Thread->Queue = Queue;
- }
- else /* if (Thread->Queue == Queue) */
- {
- //dec. num running threads
- Queue->CurrentCount--;
- }
+ /* Insert in this new Queue */
+ DPRINT("Inserting new Queue!\n");
+ InsertTailList(&Queue->ThreadListHead, &Thread->QueueListEntry);
-
-
-
- while (TRUE)
- {
- if (Queue->CurrentCount < Queue->MaximumCount && !IsListEmpty(&Queue->EntryListHead))
- {
- ListEntry = RemoveHeadList(&Queue->EntryListHead);
- //dec. num entries in queue
- Queue->Header.SignalState--;
- //inc. num running threads
- Queue->CurrentCount++;
-
- KeReleaseDispatcherDatabaseLock(OldIrql);
- return ListEntry;
- }
- else
- {
- //inform KeWaitXxx that we are holding disp. lock
- Thread->WaitNext = TRUE;
- Thread->WaitIrql = OldIrql;
+ } else {
+
+ /* Same queue, decrement waiting threads */
+ DPRINT("Same Queue!\n");
+ Queue->CurrentCount--;
+ }
+
+ /* Loop until the queue is processed */
+ while (TRUE) {
+
+ /* Get the Entry */
+ ListEntry = Queue->EntryListHead.Flink;
+
+ /* Check if the counts are valid and if there is still a queued entry */
+ if ((Queue->CurrentCount < Queue->MaximumCount) &&
+ (ListEntry != &Queue->EntryListHead)) {
+
+ /* Remove the Entry and Save it */
+ DPRINT("Removing Queue Entry. CurrentCount: %d, Maximum Count: %d\n",
+ Queue->CurrentCount, Queue->MaximumCount);
+ ListEntry = RemoveHeadList(&Queue->EntryListHead);
+
+ /* Decrease the number of entries */
+ Queue->Header.SignalState--;
+
+ /* Increase numbef of running threads */
+ Queue->CurrentCount++;
+
+ /* Check if the entry is valid. If not, bugcheck */
+ if (!ListEntry->Flink || !ListEntry->Blink) {
+
+ KEBUGCHECK(INVALID_WORK_QUEUE_ITEM);
+ }
+
+ /* Remove the Entry */
+ RemoveEntryList(ListEntry);
+ ListEntry->Flink = NULL;
+
+ /* Nothing to wait on */
+ break;
+
+ } else {
+
+ /* Do the wait */
+ DPRINT("Waiting on Queue Entry. CurrentCount: %d, Maximum Count: %d\n",
+ Queue->CurrentCount, Queue->MaximumCount);
+
+ /* Use the Thread's Wait Block, it's big enough */
+ Thread->WaitBlockList = &Thread->WaitBlock[0];
+
+ /* Fail if there's an APC Pending */
+ if (WaitMode == UserMode && Thread->ApcState.UserApcPending) {
+
+ /* Return the status and increase the pending threads */
+ ListEntry = (PLIST_ENTRY)STATUS_USER_APC;
+ Queue->CurrentCount++;
+
+ /* Nothing to wait on */
+ break;
+ }
+
+ /* Build the Wait Block */
+ WaitBlock = &Thread->WaitBlock[0];
+ WaitBlock->Object = (PVOID)Queue;
+ WaitBlock->WaitKey = STATUS_SUCCESS;
+ WaitBlock->WaitType = WaitAny;
+ WaitBlock->Thread = Thread;
+ WaitBlock->NextWaitBlock = NULL;
+
+ Thread->WaitStatus = STATUS_SUCCESS;
+
+ /* We need to wait for the object... check if we have a timeout */
+ if (Timeout) {
+
+ /* If it's zero, then don't do any waiting */
+ if (!Timeout->QuadPart) {
+
+ /* Instant Timeout, return the status and increase the pending threads */
+ DPRINT("Queue Wait has timed out\n");
+ ListEntry = (PLIST_ENTRY)STATUS_TIMEOUT;
+ Queue->CurrentCount++;
+
+ /* Nothing to wait on */
+ break;
+ }
+
+ /*
+ * Set up the Timer. We'll use the internal function so that we can
+ * hold on to the dispatcher lock.
+ */
+ Timer = &Thread->Timer;
+ TimerWaitBlock = &Thread->WaitBlock[1];
- Status = KeWaitForSingleObject(Queue,
- WrQueue,
- WaitMode,
- TRUE, //bAlertable
- Timeout);
-
- if (Status == STATUS_TIMEOUT || Status == STATUS_USER_APC)
- {
- return (PVOID)Status;
- }
-
- OldIrql = KeAcquireDispatcherDatabaseLock ();
- }
- }
+ /* Set up the Timer Wait Block */
+ TimerWaitBlock->Object = (PVOID)Timer;
+ TimerWaitBlock->Thread = Thread;
+ TimerWaitBlock->WaitKey = STATUS_TIMEOUT;
+ TimerWaitBlock->WaitType = WaitAny;
+ TimerWaitBlock->NextWaitBlock = NULL;
+
+ /* Link the timer to this Wait Block */
+ InitializeListHead(&Timer->Header.WaitListHead);
[truncated at 1000 lines; 2258 more skipped]