- Invert CONFIG_SMP defines as requested by Hartmut
authorAlex Ionescu <aionescu@gmail.com>
Fri, 6 Jan 2006 08:00:09 +0000 (08:00 +0000)
committerAlex Ionescu <aionescu@gmail.com>
Fri, 6 Jan 2006 08:00:09 +0000 (08:00 +0000)
- Remove KiBlockThread and replace by more elegant KiSwapThread which will also make moving to the new scheduler easier.
- Handle special case where we have kernel apcs pending and your previous irql was below apc_level during the wait code.
- Remove hack to manually unwait a thread during a status of kernel apc.

svn path=/trunk/; revision=20605

reactos/ntoskrnl/include/internal/ke.h
reactos/ntoskrnl/ke/gate.c
reactos/ntoskrnl/ke/kthread.c
reactos/ntoskrnl/ke/queue.c
reactos/ntoskrnl/ke/wait.c

index 9c8a49a..1b8e32a 100644 (file)
@@ -48,13 +48,7 @@ extern ULONG_PTR KERNEL_BASE;
  * On UP machines, we don't actually have a spinlock, we merely raise
  * IRQL to DPC level.
  */
  * 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 KeReleaseDispatcherDatabaseLock(OldIrql) KiExitDispatcher(OldIrql);
-#define KeAcquireDispatcherDatabaseLockAtDpcLevel()
-#define KeReleaseDispatcherDatabaseLockFromDpcLevel()
-#else
+#ifdef CONFIG_SMP
 #define KeInitializeDispatcher() KeInitializeSpinLock(&DispatcherDatabaseLock);
 #define KeAcquireDispatcherDatabaseLock() KfAcquireSpinLock(&DispatcherDatabaseLock);
 #define KeAcquireDispatcherDatabaseLockAtDpcLevel() \
 #define KeInitializeDispatcher() KeInitializeSpinLock(&DispatcherDatabaseLock);
 #define KeAcquireDispatcherDatabaseLock() KfAcquireSpinLock(&DispatcherDatabaseLock);
 #define KeAcquireDispatcherDatabaseLockAtDpcLevel() \
@@ -64,6 +58,12 @@ extern ULONG_PTR KERNEL_BASE;
 #define KeReleaseDispatcherDatabaseLock(OldIrql) \
     KeReleaseSpinLockFromDpcLevel(&DispatcherDatabaseLock); \
     KiExitDispatcher(OldIrql);
 #define KeReleaseDispatcherDatabaseLock(OldIrql) \
     KeReleaseSpinLockFromDpcLevel(&DispatcherDatabaseLock); \
     KiExitDispatcher(OldIrql);
+#else
+#define KeInitializeDispatcher()
+#define KeAcquireDispatcherDatabaseLock() KeRaiseIrqlToDpcLevel();
+#define KeReleaseDispatcherDatabaseLock(OldIrql) KiExitDispatcher(OldIrql);
+#define KeAcquireDispatcherDatabaseLockAtDpcLevel()
+#define KeReleaseDispatcherDatabaseLockFromDpcLevel()
 #endif
 
 /* The following macro initializes a dispatcher object's header */
 #endif
 
 /* The following macro initializes a dispatcher object's header */
@@ -232,14 +232,11 @@ VOID
 STDCALL
 KiDispatchThread(ULONG NewThreadStatus);
 
 STDCALL
 KiDispatchThread(ULONG NewThreadStatus);
 
-/* Puts a Thread into a block state. */
-VOID
-STDCALL
-KiBlockThread(
-    PNTSTATUS Status,
-    UCHAR Alertable,
-    ULONG WaitMode,
-    UCHAR WaitReason
+/* Finds a new thread to run */
+NTSTATUS
+NTAPI
+KiSwapThread(
+    VOID
 );
 
 /* Removes a thread out of a block state. */
 );
 
 /* Removes a thread out of a block state. */
index 6530667..228ed3c 100644 (file)
@@ -78,12 +78,15 @@ KeWaitForGate(PKGATE Gate,
             KiWakeQueue(CurrentThread->Queue);
         }
 
             KiWakeQueue(CurrentThread->Queue);
         }
 
-        /* Block the Thread */
-        DPRINT("Blocking the Thread: %x\n", CurrentThread);
-        KiBlockThread(&Status,
-                      CurrentThread->Alertable,
-                      WaitMode,
-                      WaitReason);
+        /* Setup the wait information */
+        CurrentThread->WaitMode = WaitMode;
+        CurrentThread->WaitReason = WaitReason;
+        CurrentThread->WaitTime = 0;
+        CurrentThread->State = Waiting;
+
+        /* Find a new thread to run */
+        DPRINT("Swapping threads\n");
+        Status = KiSwapThread();
 
         /* Check if we were executing an APC */
         if (Status != STATUS_KERNEL_APC) return;
 
         /* Check if we were executing an APC */
         if (Status != STATUS_KERNEL_APC) return;
index b473e47..57c775c 100644 (file)
@@ -172,48 +172,22 @@ KiDispatchThreadNoLock(ULONG NewThreadStatus)
     KEBUGCHECK(0);
 }
 
     KEBUGCHECK(0);
 }
 
-VOID
-STDCALL
-KiBlockThread(PNTSTATUS Status,
-              UCHAR Alertable,
-              ULONG WaitMode,
-              UCHAR WaitReason)
+NTSTATUS
+NTAPI
+KiSwapThread(VOID)
 {
 {
-    PKTHREAD Thread = KeGetCurrentThread();
-    PKWAIT_BLOCK WaitBlock;
-
-    if (Thread->ApcState.KernelApcPending) {
-
-        DPRINT("Dispatching Thread as ready (APC!)\n");
-
-        /* Remove Waits */
-        WaitBlock = Thread->WaitBlockList;
-        do {
-            RemoveEntryList (&WaitBlock->WaitListEntry);
-            WaitBlock = WaitBlock->NextWaitBlock;
-        } while (WaitBlock != Thread->WaitBlockList);
-        Thread->WaitBlockList = NULL;
-
-        /* Dispatch it and return status */
-        KiDispatchThreadNoLock (Ready);
-        if (Status != NULL) *Status = STATUS_KERNEL_APC;
-
-    } else {
+    PKTHREAD CurrentThread = KeGetCurrentThread();
 
 
-        /* Set the Thread Data as Requested */
-        DPRINT("Dispatching Thread as blocked: %d\n", Thread->WaitStatus);
-        Thread->Alertable = Alertable;
-        Thread->WaitMode = (UCHAR)WaitMode;
-        Thread->WaitReason = WaitReason;
+    /* Find a new thread to run */
+    DPRINT("Dispatching Thread as blocked\n");
+    KiDispatchThreadNoLock(Waiting);
 
 
-        /* Dispatch it and return status */
-        KiDispatchThreadNoLock(Waiting);
-        DPRINT("Dispatching Thread as blocked: %d\n", Thread->WaitStatus);
-        if (Status != NULL) *Status = Thread->WaitStatus;
-    }
+    /* Lower IRQL back */
+    DPRINT("Lowering IRQL \n");
+    KfLowerIrql(CurrentThread->WaitIrql);
 
 
-    DPRINT("Releasing Dispatcher Lock\n");
-    KfLowerIrql(Thread->WaitIrql);
+    /* Return the wait status */
+    return CurrentThread->WaitStatus;
 }
 
 VOID
 }
 
 VOID
index 53d451a..8883a35 100644 (file)
@@ -286,12 +286,16 @@ KeRemoveQueue(IN PKQUEUE Queue,
             InsertTailList(&Queue->Header.WaitListHead,
                            &WaitBlock->WaitListEntry);
 
             InsertTailList(&Queue->Header.WaitListHead,
                            &WaitBlock->WaitListEntry);
 
-            /* Block the Thread */
-            DPRINT("Blocking the Thread: %x %x!\n", KeGetCurrentThread(), Thread);
-            KiBlockThread(&Status,
-                          FALSE,
-                          WaitMode,
-                          WrQueue);
+            /* Setup the wait information */
+            Thread->WaitMode = WaitMode;
+            Thread->WaitReason = WrQueue;
+            Thread->Alertable = FALSE;
+            Thread->WaitTime = 0;
+            Thread->State = Waiting;
+
+            /* Find a new thread to run */
+            DPRINT("Swapping threads\n");
+            Status = KiSwapThread();
 
             /* Reset the wait reason */
             Thread->WaitReason = 0;
 
             /* Reset the wait reason */
             Thread->WaitReason = 0;
index fad80d9..2430d30 100644 (file)
@@ -106,7 +106,6 @@ KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
     PKTIMER ThreadTimer;
     PKTHREAD CurrentThread = KeGetCurrentThread();
     NTSTATUS Status;
     PKTIMER ThreadTimer;
     PKTHREAD CurrentThread = KeGetCurrentThread();
     NTSTATUS Status;
-
     DPRINT("Entering KeDelayExecutionThread\n");
 
     /* Check if the lock is already held */
     DPRINT("Entering KeDelayExecutionThread\n");
 
     /* Check if the lock is already held */
@@ -129,6 +128,15 @@ KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
     /* Start Wait Loop */
     do
     {
     /* Start Wait Loop */
     do
     {
+        /* Check if a kernel APC is pending and we were below APC_LEVEL */
+        if ((CurrentThread->ApcState.KernelApcPending) &&
+            (CurrentThread->WaitIrql < APC_LEVEL))
+        {
+            /* Unlock the dispatcher */
+            KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
+            goto SkipWait;
+        }
+
         /* Chceck if we can do an alertable wait, if requested */
         if (KiCheckAlertability(Alertable, CurrentThread, WaitMode, &Status)) break;
 
         /* Chceck if we can do an alertable wait, if requested */
         if (KiCheckAlertability(Alertable, CurrentThread, WaitMode, &Status)) break;
 
@@ -162,13 +170,16 @@ KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
             KiWakeQueue(CurrentThread->Queue);
         }
 
             KiWakeQueue(CurrentThread->Queue);
         }
 
-        /* Block the Thread */
-        DPRINT("Blocking the Thread: %d, %d, %x\n",
-                Alertable, WaitMode, KeGetCurrentThread());
-        KiBlockThread(&Status,
-                      Alertable,
-                      WaitMode,
-                      DelayExecution);
+        /* Setup the wait information */
+        CurrentThread->Alertable = Alertable;
+        CurrentThread->WaitMode = WaitMode;
+        CurrentThread->WaitReason = DelayExecution;
+        CurrentThread->WaitTime = 0;
+        CurrentThread->State = Waiting;
+
+        /* Find a new thread to run */
+        DPRINT("Swapping threads\n");
+        Status = KiSwapThread();
 
         /* Check if we were executing an APC or if we timed out */
         if (Status != STATUS_KERNEL_APC)
 
         /* Check if we were executing an APC or if we timed out */
         if (Status != STATUS_KERNEL_APC)
@@ -180,7 +191,11 @@ KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
             return Status;
         }
 
             return Status;
         }
 
-        DPRINT("Looping Again\n"); // FIXME: Need to modify interval
+        /* FIXME: Fixup interval */
+
+        /* Acquire again the lock */
+SkipWait:
+        DPRINT("Looping again\n");
         CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
     }
     while (TRUE);
         CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
     }
     while (TRUE);
@@ -241,6 +256,15 @@ KeWaitForSingleObject(PVOID Object,
     /* Start the actual Loop */
     do
     {
     /* Start the actual Loop */
     do
     {
+        /* Check if a kernel APC is pending and we were below APC_LEVEL */
+        if ((CurrentThread->ApcState.KernelApcPending) &&
+            (CurrentThread->WaitIrql < APC_LEVEL))
+        {
+            /* Unlock the dispatcher */
+            KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
+            goto SkipWait;
+        }
+
         /* Get the current Wait Status */
         WaitStatus = CurrentThread->WaitStatus;
 
         /* Get the current Wait Status */
         WaitStatus = CurrentThread->WaitStatus;
 
@@ -344,13 +368,16 @@ KeWaitForSingleObject(PVOID Object,
             KiWakeQueue(CurrentThread->Queue);
         }
 
             KiWakeQueue(CurrentThread->Queue);
         }
 
-        /* Block the Thread */
-        DPRINT("Blocking the Thread: %d, %d, %d, %x\n",
-                Alertable, WaitMode, WaitReason, KeGetCurrentThread());
-        KiBlockThread(&Status,
-                      Alertable,
-                      WaitMode,
-                      (UCHAR)WaitReason);
+        /* Setup the wait information */
+        CurrentThread->Alertable = Alertable;
+        CurrentThread->WaitMode = WaitMode;
+        CurrentThread->WaitReason = WaitReason;
+        CurrentThread->WaitTime = 0;
+        CurrentThread->State = Waiting;
+
+        /* Find a new thread to run */
+        DPRINT("Swapping threads\n");
+        Status = KiSwapThread();
 
         /* Check if we were executing an APC */
         if (Status != STATUS_KERNEL_APC)
 
         /* Check if we were executing an APC */
         if (Status != STATUS_KERNEL_APC)
@@ -359,8 +386,15 @@ KeWaitForSingleObject(PVOID Object,
             return Status;
         }
 
             return Status;
         }
 
-        /* Loop again and acquire the dispatcher lock */
-        DPRINT("Looping Again\n"); // FIXME: Change interval
+        /* Check if we had a timeout */
+        if (Timeout)
+        {
+             /* FIXME: Fixup interval */
+        }
+
+        /* Acquire again the lock */
+SkipWait:
+        DPRINT("Looping again\n");
         CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
     }
     while (TRUE);
         CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
     }
     while (TRUE);
@@ -443,6 +477,15 @@ KeWaitForMultipleObjects(ULONG Count,
     /* Start the actual Loop */
     do
     {
     /* Start the actual Loop */
     do
     {
+        /* Check if a kernel APC is pending and we were below APC_LEVEL */
+        if ((CurrentThread->ApcState.KernelApcPending) &&
+            (CurrentThread->WaitIrql < APC_LEVEL))
+        {
+            /* Unlock the dispatcher */
+            KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
+            goto SkipWait;
+        }
+
         /* Get the current Wait Status */
         WaitStatus = CurrentThread->WaitStatus;
 
         /* Get the current Wait Status */
         WaitStatus = CurrentThread->WaitStatus;
 
@@ -612,13 +655,16 @@ KeWaitForMultipleObjects(ULONG Count,
             KiWakeQueue(CurrentThread->Queue);
         }
 
             KiWakeQueue(CurrentThread->Queue);
         }
 
-        /* Block the Thread */
-        DPRINT("Blocking the Thread: %d, %d, %d, %x\n",
-                Alertable, WaitMode, WaitReason, KeGetCurrentThread());
-        KiBlockThread(&Status,
-                      Alertable,
-                      WaitMode,
-                      (UCHAR)WaitReason);
+        /* Setup the wait information */
+        CurrentThread->Alertable = Alertable;
+        CurrentThread->WaitMode = WaitMode;
+        CurrentThread->WaitReason = WaitReason;
+        CurrentThread->WaitTime = 0;
+        CurrentThread->State = Waiting;
+
+        /* Find a new thread to run */
+        DPRINT("Swapping threads\n");
+        Status = KiSwapThread();
 
         /* Check if we were executing an APC */
         DPRINT("Thread is back\n");
 
         /* Check if we were executing an APC */
         DPRINT("Thread is back\n");
@@ -628,8 +674,15 @@ KeWaitForMultipleObjects(ULONG Count,
             return Status;
         }
 
             return Status;
         }
 
-        /* Loop again and re-acquire the dispatcher lock */
-        DPRINT("Looping Again\n"); // FIXME: Fix-up the interval */
+        /* Check if we had a timeout */
+        if (Timeout)
+        {
+             /* FIXME: Fixup interval */
+        }
+
+        /* Acquire again the lock */
+SkipWait:
+        DPRINT("Looping again\n");
         CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
     }
     while (TRUE);
         CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
     }
     while (TRUE);