- Implement KeReadyThread that wraps KiReadyThread so that \ps doesn't have to worry about dispatcher lock.

- Make sure all a process's threads are ready if they're on the ready queue, during attachment.
- Merge in KiReadyThread from scheduler code, with a small code change to keep working with ROS's scheduler lists instead.

svn path=/trunk/; revision=24108

reactos/ntoskrnl/include/internal/ke.h

@@ -186,6 +186,12 @@ KiSwapThread(
     IN PKPRCB Prcb
 );
 
+VOID
+NTAPI
+KeReadyThread(
+    IN PKTHREAD Thread
+);
+
 VOID
 NTAPI
 KiReadyThread(IN PKTHREAD Thread);

reactos/ntoskrnl/ke/process.c

@@ -58,6 +58,8 @@ KiAttachProcess(IN PKTHREAD Thread,
                 IN PKLOCK_QUEUE_HANDLE ApcLock,
                 IN PRKAPC_STATE SavedApcState)
 {
+    PLIST_ENTRY ListHead, NextEntry;
+    PKTHREAD CurrentThread;
     ASSERT(Process != Thread->ApcState.Process);
 
     /* Increase Stack Count */
@@ -87,7 +89,24 @@ KiAttachProcess(IN PKTHREAD Thread,
     /* Check if the process is paged in */
     if (Process->State == ProcessInMemory)
     {
-        /* FIXME: Scan the Ready Thread List once new scheduler is in */
+        /* Scan the ready list */
+        ListHead = &Process->ReadyListHead;
+        NextEntry = ListHead->Flink;
+        while (NextEntry != ListHead)
+        {
+            /* Get the thread */
+            CurrentThread = CONTAINING_RECORD(NextEntry, KTHREAD, WaitListEntry);
+
+            /* Remove it */
+            RemoveEntryList(NextEntry);
+            CurrentThread->ProcessReadyQueue = FALSE;
+
+            /* Mark it ready */
+            KiReadyThread(CurrentThread);
+
+            /* Go to the next one */
+            NextEntry = ListHead->Flink;
+        }
 
         /* Release dispatcher lock */
         KiReleaseDispatcherLockFromDpcLevel();

reactos/ntoskrnl/ke/thrdobj.c

@@ -80,6 +80,24 @@ KeQueryBasePriorityThread(IN PKTHREAD Thread)
     return BaseIncrement;
 }
 
+VOID
+NTAPI
+KeReadyThread(IN PKTHREAD Thread)
+{
+    KIRQL OldIrql;
+    ASSERT_THREAD(Thread);
+    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
+
+    /* Lock the Dispatcher Database */
+    OldIrql = KiAcquireDispatcherLock();
+
+    /* Make the thread ready */
+    KiReadyThread(Thread);
+
+    /* Unlock dispatcher database */
+    KiReleaseDispatcherLock(OldIrql);
+}
+
 ULONG
 NTAPI
 KeAlertResumeThread(IN PKTHREAD Thread)

reactos/ntoskrnl/ke/thrdschd.c

@@ -213,9 +213,38 @@ VOID
 NTAPI
 KiReadyThread(IN PKTHREAD Thread)
 {
-    /* Makes a thread ready */
-    Thread->State = Ready;
-    KiInsertIntoThreadList(Thread->Priority, Thread);
+    IN PKPROCESS Process = Thread->ApcState.Process;
+
+    /* Check if the process is paged out */
+    if (Process->State != ProcessInMemory)
+    {
+        /* We don't page out processes in ROS */
+        ASSERT(FALSE);
+    }
+    else if (!Thread->KernelStackResident)
+    {
+        /* Increase the stack count */
+        ASSERT(Process->StackCount != MAXULONG_PTR);
+        Process->StackCount++;
+
+        /* Set the thread to transition */
+        ASSERT(Thread->State != Transition);
+        Thread->State = Transition;
+
+        /* The stack is always resident in ROS */
+        ASSERT(FALSE);
+    }
+    else
+    {
+        /* Insert the thread on the deferred ready list */
+#if 0
+        KiInsertDeferredReadyList(Thread);
+#else
+        /* Insert the thread into the thread list */
+        Thread->State = Ready;
+        KiInsertIntoThreadList(Thread->Priority, Thread);
+#endif
+    }
 }
 
 VOID

reactos/ntoskrnl/ps/psmgr.c

@@ -81,7 +81,6 @@ NTAPI
 PsInitHackThread(VOID)
 {
     PETHREAD IdleThread;
-    KIRQL oldIrql;
 
     IdleThread = ExAllocatePool(NonPagedPool, sizeof(ETHREAD));
     RtlZeroMemory(IdleThread, sizeof(ETHREAD));
@@ -97,9 +96,7 @@ PsInitHackThread(VOID)
                               KERNEL_STACK_SIZE));
     InitializeListHead(&IdleThread->IrpList);
 
-    oldIrql = KiAcquireDispatcherLock ();
-    KiReadyThread(&IdleThread->Tcb);
-    KiReleaseDispatcherLock(oldIrql);
+    KeReadyThread(&IdleThread->Tcb);
 
     KeGetCurrentPrcb()->IdleThread = &IdleThread->Tcb;
     KeSetPriorityThread(&IdleThread->Tcb, LOW_PRIORITY);

reactos/ntoskrnl/ps/thread.c

@@ -156,7 +156,6 @@ PspCreateThread(OUT PHANDLE ThreadHandle,
     PEPROCESS Process;
     PETHREAD Thread;
     PTEB TebBase = NULL;
-    KIRQL OldIrql;
     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
     NTSTATUS Status, AccessStatus;
     HANDLE_TABLE_ENTRY CidEntry;
@@ -397,9 +396,7 @@ PspCreateThread(OUT PHANDLE ThreadHandle,
         if (CreateSuspended) KeResumeThread(&Thread->Tcb);
 
         /* Dispatch thread */
-        OldIrql = KiAcquireDispatcherLock ();
-        KiReadyThread(&Thread->Tcb);
-        KiReleaseDispatcherLock(OldIrql);
+        KeReadyThread(&Thread->Tcb);
 
         /* Dereference completely to kill it */
         ObDereferenceObjectEx(Thread, 2);
@@ -439,9 +436,7 @@ PspCreateThread(OUT PHANDLE ThreadHandle,
             if (CreateSuspended) KeResumeThread(&Thread->Tcb);
 
             /* Dispatch thread */
-            OldIrql = KiAcquireDispatcherLock ();
-            KiReadyThread(&Thread->Tcb);
-            KiReleaseDispatcherLock(OldIrql);
+            KeReadyThread(&Thread->Tcb);
 
             /* Dereference it, leaving only the keep-alive */
             ObDereferenceObject(Thread);
@@ -482,9 +477,7 @@ PspCreateThread(OUT PHANDLE ThreadHandle,
             if (CreateSuspended) KeResumeThread(&Thread->Tcb);
 
             /* Dispatch thread */
-            OldIrql = KiAcquireDispatcherLock ();
-            KiReadyThread(&Thread->Tcb);
-            KiReleaseDispatcherLock(OldIrql);
+            KeReadyThread(&Thread->Tcb);
 
             /* Dereference it, leaving only the keep-alive */
             ObDereferenceObject(Thread);
@@ -533,9 +526,7 @@ PspCreateThread(OUT PHANDLE ThreadHandle,
 
     /* Dispatch thread */
     PSREFTRACE(Thread);
-    OldIrql = KiAcquireDispatcherLock ();
-    KiReadyThread(&Thread->Tcb);
-    KiReleaseDispatcherLock(OldIrql);
+    KeReadyThread(&Thread->Tcb);
 
     /* Dereference it, leaving only the keep-alive */
     ObDereferenceObject(Thread);