--- trunk/reactos/drivers/storage/floppy/floppy.c 2005-03-12 19:22:30 UTC (rev 13973)
+++ trunk/reactos/drivers/storage/floppy/floppy.c 2005-03-12 19:23:04 UTC (rev 13974)
@@ -58,7 +58,7 @@
/* Queue thread management */
static KEVENT QueueThreadTerminate;
-static PVOID ThreadObject;
+static PVOID QueueThreadObject;
static VOID NTAPI MotorStopDpcFunc(PKDPC UnusedDpc,
@@ -378,8 +378,8 @@
KdPrint(("floppy: unloading\n"));
KeSetEvent(&QueueThreadTerminate, 0, FALSE);
- KeWaitForSingleObject(ThreadObject, Executive, KernelMode, FALSE, 0);
- ObDereferenceObject(ThreadObject);
+ KeWaitForSingleObject(QueueThreadObject, Executive, KernelMode, FALSE, 0);
+ ObDereferenceObject(QueueThreadObject);
for(i = 0; i < gNumberOfControllers; i++)
{
@@ -1152,7 +1152,7 @@
return STATUS_INSUFFICIENT_RESOURCES;
}
- if(ObReferenceObjectByHandle(ThreadHandle, STANDARD_RIGHTS_ALL, NULL, KernelMode, &ThreadObject, NULL) != STATUS_SUCCESS)
+ if(ObReferenceObjectByHandle(ThreadHandle, STANDARD_RIGHTS_ALL, NULL, KernelMode, &QueueThreadObject, NULL) != STATUS_SUCCESS)
{
KdPrint(("floppy: Unable to reference returned thread handle; failing init\n"));
return STATUS_UNSUCCESSFUL;
--- trunk/reactos/ntoskrnl/ke/kthread.c 2005-03-12 19:22:30 UTC (rev 13973)
+++ trunk/reactos/ntoskrnl/ke/kthread.c 2005-03-12 19:23:04 UTC (rev 13974)
@@ -1,11 +1,11 @@
-/* $Id$
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/kthread.c
* PURPOSE: Microkernel thread support
*
- * PROGRAMMERS: David Welch (welch@cwcom.net)
+ * PROGRAMMERS: Alex Ionescu (alex@relsoft.net) - Commented, reorganized some stuff, fixed/implemented some functions.
+ * David Welch (welch@cwcom.net)
*/
/* INCLUDES *****************************************************************/
@@ -16,19 +16,93 @@
/* FUNCTIONS *****************************************************************/
-VOID
-KiServiceCheck (VOID)
+ULONG
+STDCALL
+KeAlertResumeThread(IN PKTHREAD Thread)
{
- PETHREAD Thread;
+ ULONG PreviousCount;
+ KIRQL OldIrql;
- Thread = PsGetCurrentThread();
+ ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
+
+ /* Lock the Dispatcher Database and the APC Queue */
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+ KiAcquireSpinLock(&Thread->ApcQueueLock);
- if (Thread->Tcb.ServiceTable != KeServiceDescriptorTableShadow)
- {
- PsInitWin32Thread (Thread);
+ /* Return if Thread is already alerted. */
+ if (Thread->Alerted[KernelMode] == FALSE) {
+
+ /* If it's Blocked, unblock if it we should */
+ if (Thread->State == THREAD_STATE_BLOCKED && Thread->Alertable) {
+
+ DPRINT("Aborting Wait\n");
+ KiAbortWaitThread(Thread, STATUS_ALERTED);
+
+ } else {
+
+ /* If not, simply Alert it */
+ Thread->Alerted[KernelMode] = TRUE;
+ }
+ }
+
+ /* Save the old Suspend Count */
+ PreviousCount = Thread->SuspendCount;
+
+ /* If the thread is suspended, decrease one of the suspend counts */
+ if (PreviousCount) {
+
+ /* Decrease count. If we are now zero, unwait it completely */
+ if (--Thread->SuspendCount) {
+
+ /* Signal and satisfy */
+ Thread->SuspendSemaphore.Header.SignalState++;
+ KiDispatcherObjectWake(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
+ }
+ }
- Thread->Tcb.ServiceTable = KeServiceDescriptorTableShadow;
+ /* Release Locks and return the Old State */
+ KiReleaseSpinLock(&Thread->ApcQueueLock);
+ KeReleaseDispatcherDatabaseLock(OldIrql);
+ return PreviousCount;
+}
+
+BOOLEAN
+STDCALL
+KeAlertThread(PKTHREAD Thread,
+ KPROCESSOR_MODE AlertMode)
+{
+ KIRQL OldIrql;
+ BOOLEAN PreviousState;
+
+ /* Acquire the Dispatcher Database Lock */
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+
+ /* Save the Previous State */
+ PreviousState = Thread->Alerted[AlertMode];
+
+ /* Return if Thread is already alerted. */
+ if (PreviousState == FALSE) {
+
+ /* If it's Blocked, unblock if it we should */
+ if (Thread->State == THREAD_STATE_BLOCKED &&
+ (AlertMode == KernelMode || Thread->WaitMode == AlertMode) &&
+ Thread->Alertable) {
+
+ DPRINT("Aborting Wait\n");
+ KiAbortWaitThread(Thread, STATUS_ALERTED);
+
+ } else {
+
+ /* If not, simply Alert it */
+ Thread->Alerted[AlertMode] = TRUE;
+ }
}
+
+ /* Release the Dispatcher Lock */
+ KeReleaseDispatcherDatabaseLock(OldIrql);
+
+ /* Return the old state */
+ return PreviousState;
}
/*
@@ -36,28 +110,231 @@
*/
VOID
STDCALL
-KeCapturePersistentThreadState(
- IN PVOID CurrentThread,
- IN ULONG Setting1,
- IN ULONG Setting2,
- IN ULONG Setting3,
- IN ULONG Setting4,
- IN ULONG Setting5,
- IN PVOID ThreadState
-)
+KeCapturePersistentThreadState(IN PVOID CurrentThread,
+ IN ULONG Setting1,
+ IN ULONG Setting2,
+ IN ULONG Setting3,
+ IN ULONG Setting4,
+ IN ULONG Setting5,
+ IN PVOID ThreadState)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
}
+/*
+ * FUNCTION: Initialize the microkernel state of the thread
+ */
VOID
-KeFreeStackPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
- PFN_TYPE Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
+STDCALL
+KeInitializeThread(PKPROCESS Process,
+ PKTHREAD Thread,
+ BOOLEAN First)
{
- ASSERT(SwapEntry == 0);
- if (Page != 0)
- {
- MmReleasePageMemoryConsumer(MC_NPPOOL, Page);
+ PVOID KernelStack;
+ NTSTATUS Status;
+ extern unsigned int init_stack_top;
+ extern unsigned int init_stack;
+ PMEMORY_AREA StackArea;
+ ULONG i;
+ PHYSICAL_ADDRESS BoundaryAddressMultiple;
+
+ /* Initialize the Boundary Address */
+ BoundaryAddressMultiple.QuadPart = 0;
+
+ /* Initalize the Dispatcher Header */
+ KeInitializeDispatcherHeader(&Thread->DispatcherHeader,
+ ThreadObject,
+ sizeof(KTHREAD),
+ FALSE);
+ InitializeListHead(&Thread->MutantListHead);
+
+ /* If this is isn't the first thread, allocate the Kernel Stack */
+ if (!First) {
+
+ PFN_TYPE Page[MM_STACK_SIZE / PAGE_SIZE];
+ KernelStack = NULL;
+
+ MmLockAddressSpace(MmGetKernelAddressSpace());
+ Status = MmCreateMemoryArea(NULL,
+ MmGetKernelAddressSpace(),
+ MEMORY_AREA_KERNEL_STACK,
+ &KernelStack,
+ MM_STACK_SIZE,
+ 0,
+ &StackArea,
+ FALSE,
+ FALSE,
+ BoundaryAddressMultiple);
+ MmUnlockAddressSpace(MmGetKernelAddressSpace());
+
+ /* Check for Success */
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1("Failed to create thread stack\n");
+ KEBUGCHECK(0);
+ }
+
+ /* Mark the Stack */
+ for (i = 0; i < (MM_STACK_SIZE / PAGE_SIZE); i++) {
+
+ Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &Page[i]);
+
+ /* Check for success */
+ if (!NT_SUCCESS(Status)) {
+
+ KEBUGCHECK(0);
+ }
+ }
+
+ /* Create a Virtual Mapping for it */
+ Status = MmCreateVirtualMapping(NULL,
+ KernelStack,
+ PAGE_READWRITE,
+ Page,
+ MM_STACK_SIZE / PAGE_SIZE);
+
+ /* Check for success */
+ if (!NT_SUCCESS(Status)) {
+
+ KEBUGCHECK(0);
+ }
+
+ /* Set the Kernel Stack */
+ Thread->InitialStack = (PCHAR)KernelStack + MM_STACK_SIZE;
+ Thread->StackBase = (PCHAR)KernelStack + MM_STACK_SIZE;
+ Thread->StackLimit = (ULONG_PTR)KernelStack;
+ Thread->KernelStack = (PCHAR)KernelStack + MM_STACK_SIZE;
+
+ } else {
+
+ /* Use the Initial Stack */
+ Thread->InitialStack = (PCHAR)init_stack_top;
+ Thread->StackBase = (PCHAR)init_stack_top;
+ Thread->StackLimit = (ULONG_PTR)init_stack;
+ Thread->KernelStack = (PCHAR)init_stack_top;
}
+
+ /*
+ * Establish the pde's for the new stack and the thread structure within the
+ * address space of the new process. They are accessed while taskswitching or
+ * while handling page faults. At this point it isn't possible to call the
+ * page fault handler for the missing pde's.
+ */
+ MmUpdatePageDir((PEPROCESS)Process, (PVOID)Thread->StackLimit, MM_STACK_SIZE);
+ MmUpdatePageDir((PEPROCESS)Process, (PVOID)Thread, sizeof(ETHREAD));
+
+ /* Set the Thread to initalized */
+ Thread->State = THREAD_STATE_INITIALIZED;
+
+ /* The Native API function will initialize the TEB field later */
+ Thread->Teb = NULL;
+
+ /* Initialize stuff to zero */
+ Thread->TlsArray = NULL;
+ Thread->DebugActive = 0;
+ Thread->Alerted[0] = 0;
+ Thread->Alerted[1] = 0;
+ Thread->Iopl = 0;
+
+ /* Set up FPU/NPX Stuff */
+ Thread->NpxState = NPX_STATE_INVALID;
+ Thread->NpxIrql = 0;
+
+ /* Setup APC Fields */
+ InitializeListHead(&Thread->ApcState.ApcListHead[0]);
+ InitializeListHead(&Thread->ApcState.ApcListHead[1]);
+ Thread->ApcState.Process = Process;
+ Thread->ApcState.KernelApcInProgress = 0;
+ Thread->ApcState.KernelApcPending = 0;
+ Thread->ApcState.UserApcPending = 0;
+ Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->ApcState;
+ Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->SavedApcState;
+ Thread->ApcStateIndex = OriginalApcEnvironment;
+ Thread->ApcQueueable = TRUE;
+ RtlZeroMemory(&Thread->SavedApcState, sizeof(KAPC_STATE));
+ KeInitializeSpinLock(&Thread->ApcQueueLock);
+
+ /* Setup Wait Fields */
+ Thread->WaitStatus = STATUS_SUCCESS;
+ Thread->WaitIrql = PASSIVE_LEVEL;
+ Thread->WaitMode = 0;
+ Thread->WaitNext = FALSE;
+ Thread->WaitListEntry.Flink = NULL;
+ Thread->WaitListEntry.Blink = NULL;
+ Thread->WaitTime = 0;
+ Thread->WaitBlockList = NULL;
+ RtlZeroMemory(Thread->WaitBlock, sizeof(KWAIT_BLOCK) * 4);
+ RtlZeroMemory(&Thread->Timer, sizeof(KTIMER));
+ KeInitializeTimer(&Thread->Timer);
+
+ /* Setup scheduler Fields */
+ Thread->BasePriority = Process->BasePriority;
+ Thread->DecrementCount = 0;
+ Thread->PriorityDecrement = 0;
+ Thread->Quantum = Process->ThreadQuantum;
+ Thread->Saturation = 0;
+ Thread->Priority = Process->BasePriority;
+ Thread->UserAffinity = Process->Affinity;
+ Thread->SystemAffinityActive = 0;
+ Thread->Affinity = Process->Affinity;
+ Thread->Preempted = 0;
+ Thread->ProcessReadyQueue = 0;
+ Thread->KernelStackResident = 1;
+ Thread->NextProcessor = 0;
+ Thread->ContextSwitches = 0;
+
+ /* Setup Queue Fields */
+ Thread->Queue = NULL;
+ Thread->QueueListEntry.Flink = NULL;
+ Thread->QueueListEntry.Blink = NULL;
+
+ /* Setup Misc Fields */
+ Thread->LegoData = 0;
+ Thread->PowerState = 0;
+ Thread->ServiceTable = KeServiceDescriptorTable;
+ Thread->CallbackStack = NULL;
+ Thread->Win32Thread = NULL;
+ Thread->TrapFrame = NULL;
+ Thread->EnableStackSwap = 0;
+ Thread->LargeStack = 0;
+ Thread->ResourceIndex = 0;
+ Thread->PreviousMode = KernelMode;
+ Thread->KernelTime = 0;
+ Thread->UserTime = 0;
+ Thread->AutoAlignment = Process->AutoAlignment;
+
+ /* FIXME OPTIMIZATION OF DOOM. DO NOT ENABLE FIXME */
+#if 0
+ Thread->WaitBlock[3].Object = (PVOID)&Thread->Timer;
+ Thread->WaitBlock[3].Thread = Thread;
+ Thread->WaitBlock[3].WaitKey = STATUS_TIMEOUT;
+ Thread->WaitBlock[3].WaitType = WaitAny;
+ Thread->WaitBlock[3].NextWaitBlock = NULL;
+ InsertTailList(&Thread->Timer.Header.WaitListHead,
+ &Thread->WaitBlock[3].WaitListEntry);
+#endif
+
+ /* Initialize the Suspend APC */
+ KeInitializeApc(&Thread->SuspendApc,
+ Thread,
+ OriginalApcEnvironment,
+ PiSuspendThreadKernelRoutine,
+ PiSuspendThreadRundownRoutine,
+ PiSuspendThreadNormalRoutine,
+ KernelMode,
+ NULL);
+
+ /* Initialize the Suspend Semaphore */
+ KeInitializeSemaphore(&Thread->SuspendSemaphore, 0, 128);
+
+ /* Insert the Thread into the Process's Thread List */
+ InsertTailList(&Process->ThreadListHead, &Thread->ThreadListEntry);
+
+ /* Set up the Suspend Counts */
+ Thread->FreezeCount = 0;
+ Thread->SuspendCount = 0;
+
+ /* Do x86 specific part */
}
/*
@@ -65,11 +342,9 @@
*/
KPRIORITY
STDCALL
-KeQueryPriorityThread (
- IN PKTHREAD Thread
- )
+KeQueryPriorityThread (IN PKTHREAD Thread)
{
- return Thread->Priority;
+ return Thread->Priority;
}
/*
@@ -77,19 +352,29 @@
*/
ULONG
STDCALL
-KeQueryRuntimeThread(
- IN PKTHREAD Thread,
- OUT PULONG UserTime
- )
+KeQueryRuntimeThread(IN PKTHREAD Thread,
+ OUT PULONG UserTime)
{
- /* Return the User Time */
- *UserTime = Thread->UserTime;
-
- /* Return the Kernel Time */
- return Thread->KernelTime;
+ /* Return the User Time */
+ *UserTime = Thread->UserTime;
+
+ /* Return the Kernel Time */
+ return Thread->KernelTime;
}
-NTSTATUS
+VOID
+KeFreeStackPage(PVOID Context,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address,
+ PFN_TYPE Page,
+ SWAPENTRY SwapEntry,
+ BOOLEAN Dirty)
+{
+ ASSERT(SwapEntry == 0);
+ if (Page) MmReleasePageMemoryConsumer(MC_NPPOOL, Page);
+}
+
+NTSTATUS
KeReleaseThread(PKTHREAD Thread)
/*
* FUNCTION: Releases the resource allocated for a thread by
@@ -123,195 +408,26 @@
*/
BOOLEAN
STDCALL
-KeSetKernelStackSwapEnable(
- IN BOOLEAN Enable
- )
+KeSetKernelStackSwapEnable(IN BOOLEAN Enable)
{
- PKTHREAD Thread;
- BOOLEAN PreviousState;
-
- Thread = KeGetCurrentThread();
-
- /* Save Old State */
- PreviousState = Thread->EnableStackSwap;
-
- /* Set New State */
- Thread->EnableStackSwap = Enable;
+ PKTHREAD Thread = KeGetCurrentThread();
+ BOOLEAN PreviousState;
+ KIRQL OldIrql;
+
+ /* Lock the Dispatcher Database */
+ OldIrql = KeAcquireDispatcherDatabaseLock();
- /* Return Old State */
- return PreviousState;
-}
+ /* Save Old State */
+ PreviousState = Thread->EnableStackSwap;
-VOID
-KeInitializeThread(PKPROCESS Process, PKTHREAD Thread, BOOLEAN First)
-/*
- * FUNCTION: Initialize the microkernel state of the thread
- */
-{
- PVOID KernelStack;
- NTSTATUS Status;
- extern unsigned int init_stack_top;
- extern unsigned int init_stack;
- PMEMORY_AREA StackArea;
- ULONG i;
- PHYSICAL_ADDRESS BoundaryAddressMultiple;
-
- BoundaryAddressMultiple.QuadPart = 0;
-
- KeInitializeDispatcherHeader(&Thread->DispatcherHeader,
- InternalThreadType,
- sizeof(ETHREAD),
- FALSE);
- InitializeListHead(&Thread->MutantListHead);
- if (!First)
- {
- PFN_TYPE Page[MM_STACK_SIZE / PAGE_SIZE];
- KernelStack = NULL;
-
- MmLockAddressSpace(MmGetKernelAddressSpace());
- Status = MmCreateMemoryArea(NULL,
- MmGetKernelAddressSpace(),
- MEMORY_AREA_KERNEL_STACK,
- &KernelStack,
- MM_STACK_SIZE,
- 0,
- &StackArea,
- FALSE,
- FALSE,
- BoundaryAddressMultiple);
- MmUnlockAddressSpace(MmGetKernelAddressSpace());
-
- if (!NT_SUCCESS(Status))
- {
- DPRINT1("Failed to create thread stack\n");
- KEBUGCHECK(0);
- }
- for (i = 0; i < (MM_STACK_SIZE / PAGE_SIZE); i++)
- {
- Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &Page[i]);
- if (!NT_SUCCESS(Status))
- {
- KEBUGCHECK(0);
- }
- }
- Status = MmCreateVirtualMapping(NULL,
- KernelStack,
- PAGE_READWRITE,
- Page,
- MM_STACK_SIZE / PAGE_SIZE);
- if (!NT_SUCCESS(Status))
- {
- KEBUGCHECK(0);
- }
- Thread->InitialStack = (PCHAR)KernelStack + MM_STACK_SIZE;
- Thread->StackBase = (PCHAR)KernelStack + MM_STACK_SIZE;
- Thread->StackLimit = (ULONG_PTR)KernelStack;
- Thread->KernelStack = (PCHAR)KernelStack + MM_STACK_SIZE;
- }
- else
- {
- Thread->InitialStack = (PCHAR)init_stack_top;
- Thread->StackBase = (PCHAR)init_stack_top;
- Thread->StackLimit = (ULONG_PTR)init_stack;
- Thread->KernelStack = (PCHAR)init_stack_top;
- }
+ /* Set New State */
+ Thread->EnableStackSwap = Enable;
- /*
- * Establish the pde's for the new stack and the thread structure within the
- * address space of the new process. They are accessed while taskswitching or
- * while handling page faults. At this point it isn't possible to call the
- * page fault handler for the missing pde's.
- */
-
- MmUpdatePageDir((PEPROCESS)Process, (PVOID)Thread->StackLimit, MM_STACK_SIZE);
- MmUpdatePageDir((PEPROCESS)Process, (PVOID)Thread, sizeof(ETHREAD));
-
- /*
- * The Native API function will initialize the TEB field later
- */
- Thread->Teb = NULL;
- Thread->TlsArray = NULL;
- Thread->DebugActive = 0;
- Thread->State = THREAD_STATE_INITIALIZED;
- Thread->Alerted[0] = 0;
- Thread->Alerted[1] = 0;
- Thread->Iopl = 0;
- Thread->NpxState = NPX_STATE_INVALID;
-
- Thread->Saturation = 0;
- Thread->Priority = Process->BasePriority;
- InitializeListHead(&Thread->ApcState.ApcListHead[0]);
- InitializeListHead(&Thread->ApcState.ApcListHead[1]);
- Thread->ApcState.Process = Process;
- Thread->ApcState.KernelApcInProgress = 0;
- Thread->ApcState.KernelApcPending = 0;
- Thread->ApcState.UserApcPending = 0;
- Thread->ContextSwitches = 0;
- Thread->WaitStatus = STATUS_SUCCESS;
- Thread->WaitIrql = PASSIVE_LEVEL;
- Thread->WaitMode = 0;
- Thread->WaitNext = FALSE;
- Thread->WaitBlockList = NULL;
- Thread->WaitListEntry.Flink = NULL;
- Thread->WaitListEntry.Blink = NULL;
- Thread->WaitTime = 0;
- Thread->BasePriority = Process->BasePriority;
- Thread->DecrementCount = 0;
- Thread->PriorityDecrement = 0;
- Thread->Quantum = Process->ThreadQuantum;
- RtlZeroMemory(Thread->WaitBlock, sizeof(KWAIT_BLOCK)*4);
- Thread->LegoData = 0;
- Thread->UserAffinity = Process->Affinity;
- Thread->SystemAffinityActive = 0;
- Thread->PowerState = 0;
- Thread->NpxIrql = 0;
- Thread->ServiceTable = KeServiceDescriptorTable;
- Thread->Queue = NULL;
- KeInitializeSpinLock(&Thread->ApcQueueLock);
- RtlZeroMemory(&Thread->Timer, sizeof(KTIMER));
- KeInitializeTimer(&Thread->Timer);
- Thread->QueueListEntry.Flink = NULL;
- Thread->QueueListEntry.Blink = NULL;
- Thread->Affinity = Process->Affinity;
- Thread->Preempted = 0;
- Thread->ProcessReadyQueue = 0;
- Thread->KernelStackResident = 1;
- Thread->NextProcessor = 0;
- Thread->CallbackStack = NULL;
- Thread->Win32Thread = NULL;
- Thread->TrapFrame = NULL;
- Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->ApcState;
- Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->SavedApcState;
- Thread->EnableStackSwap = 0;
- Thread->LargeStack = 0;
- Thread->ResourceIndex = 0;
- Thread->PreviousMode = KernelMode;
- Thread->KernelTime = 0;
- Thread->UserTime = 0;
- RtlZeroMemory(&Thread->SavedApcState, sizeof(KAPC_STATE));
-
- Thread->ApcStateIndex = OriginalApcEnvironment;
- Thread->ApcQueueable = TRUE;
- Thread->AutoAlignment = Process->AutoAlignment;
-
- KeInitializeApc(&Thread->SuspendApc,
- Thread,
- OriginalApcEnvironment,
- PiSuspendThreadKernelRoutine,
- PiSuspendThreadRundownRoutine,
- PiSuspendThreadNormalRoutine,
- KernelMode,
- NULL);
- KeInitializeSemaphore(&Thread->SuspendSemaphore, 0, 128);
-
- InsertTailList(&Process->ThreadListHead,
- &Thread->ThreadListEntry);
- Thread->FreezeCount = 0;
- Thread->SuspendCount = 0;
-
- /*
- * Do x86 specific part
- */
+ /* No, Release Lock */
+ KeReleaseDispatcherDatabaseLock(OldIrql);
+
+ /* Return Old State */
+ return PreviousState;
}
/*
@@ -321,33 +437,33 @@
STDCALL
KeRevertToUserAffinityThread(VOID)
{
-#ifdef CONFIG_SMP
- PKTHREAD CurrentThread;
- KIRQL oldIrql;
+ PKTHREAD CurrentThread = KeGetCurrentThread();
+ KIRQL OldIrql;
- oldIrql = KeAcquireDispatcherDatabaseLock();
+ ASSERT(CurrentThread->SystemAffinityActive != FALSE);
+
+ /* Lock the Dispatcher Database */
+ OldIrql = KeAcquireDispatcherDatabaseLock();
- CurrentThread = KeGetCurrentThread();
+ /* Return to User Affinity */
+ CurrentThread->Affinity = CurrentThread->UserAffinity;
- ASSERT(CurrentThread->SystemAffinityActive != FALSE);
-
- /* Return to User Affinity */
- CurrentThread->Affinity = CurrentThread->UserAffinity;
-
- /* Disable System Affinity */
- CurrentThread->SystemAffinityActive = FALSE;
-
- if (CurrentThread->Affinity & (1 << KeGetCurrentProcessorNumber()))
- {
- KeReleaseDispatcherDatabaseLock(oldIrql);
- }
- else
- {
- CurrentThread->WaitIrql = oldIrql;
- PsDispatchThreadNoLock(THREAD_STATE_READY);
- KeLowerIrql(oldIrql);
- }
-#endif
+ /* Disable System Affinity */
+ CurrentThread->SystemAffinityActive = FALSE;
+
+ /* Check if we need to Dispatch a New thread */
+ if (CurrentThread->Affinity & (1 << KeGetCurrentProcessorNumber())) {
+
+ /* No, just release */
+ KeReleaseDispatcherDatabaseLock(OldIrql);
+
+ } else {
+
+ /* We need to dispatch a new thread */
+ CurrentThread->WaitIrql = OldIrql;
+ PsDispatchThreadNoLock(THREAD_STATE_READY);
+ KeLowerIrql(OldIrql);
+ }
}
/*
@@ -355,20 +471,26 @@
*/
CCHAR
STDCALL
-KeSetIdealProcessorThread (
- IN PKTHREAD Thread,
- IN CCHAR Processor)
+KeSetIdealProcessorThread(IN PKTHREAD Thread,
+ IN CCHAR Processor)
{
[truncated at 1000 lines; 369 more skipped]