reactos/ntoskrnl/ke/kthread.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/ke/kthread.c
   5  * PURPOSE:         Microkernel thread support
   6  *
   7  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   8  *                  David Welch (welch@cwcom.net)
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <ntoskrnl.h>
  14 #define NDEBUG
  15 #include <internal/debug.h>
  16
  17 /* FIXME: NDK */
  18 #define MAXIMUM_SUSPEND_COUNT 0x7F
  19 #define THREAD_ALERT_INCREMENT 2
  20
  21 extern EX_WORK_QUEUE ExWorkerQueue[MaximumWorkQueue];
  22
  23 /*
  24  * PURPOSE: List of threads associated with each priority level
  25  */
  26 LIST_ENTRY PriorityListHead[MAXIMUM_PRIORITY];
  27 static ULONG PriorityListMask = 0;
  28 ULONG IdleProcessorMask = 0;
  29 extern PETHREAD PspReaperList;
  30
  31 /* FUNCTIONS *****************************************************************/
  32
  33 STATIC
  34 VOID
  35 KiRequestReschedule(CCHAR Processor)
  36 {
  37     PKPCR Pcr;
  38
  39     Pcr = (PKPCR)(KPCR_BASE + Processor * PAGE_SIZE);
  40     Pcr->Prcb->QuantumEnd = TRUE;
  41     KiIpiSendRequest(1 << Processor, IPI_DPC);
  42 }
  43
  44 STATIC
  45 VOID
  46 KiInsertIntoThreadList(KPRIORITY Priority,
  47                        PKTHREAD Thread)
  48 {
  49     ASSERT(Ready == Thread->State);
  50     ASSERT(Thread->Priority == Priority);
  51
  52     if (Priority >= MAXIMUM_PRIORITY || Priority < LOW_PRIORITY) {
  53
  54         DPRINT1("Invalid thread priority (%d)\n", Priority);
  55         KEBUGCHECK(0);
  56     }
  57
  58     InsertTailList(&PriorityListHead[Priority], &Thread->WaitListEntry);
  59     PriorityListMask |= (1 << Priority);
  60 }
  61
  62 STATIC
  63 VOID
  64 KiRemoveFromThreadList(PKTHREAD Thread)
  65 {
  66     ASSERT(Ready == Thread->State);
  67     RemoveEntryList(&Thread->WaitListEntry);
  68     if (IsListEmpty(&PriorityListHead[(ULONG)Thread->Priority])) {
  69
  70         PriorityListMask &= ~(1 << Thread->Priority);
  71     }
  72 }
  73
  74 STATIC
  75 PKTHREAD
  76 KiScanThreadList(KPRIORITY Priority,
  77                  KAFFINITY Affinity)
  78 {
  79     PKTHREAD current;
  80     ULONG Mask;
  81
  82     Mask = (1 << Priority);
  83
  84     if (PriorityListMask & Mask) {
  85
  86         LIST_FOR_EACH(current, &PriorityListHead[Priority], KTHREAD, WaitListEntry) {
  87
  88             if (current->State != Ready) {
  89
  90                 DPRINT1("%d/%d\n", &current, current->State);
  91             }
  92
  93             ASSERT(current->State == Ready);
  94
  95             if (current->Affinity & Affinity) {
  96
  97                 KiRemoveFromThreadList(current);
  98                 return(current);
  99             }
 100         }
 101     }
 102
 103     return(NULL);
 104 }
 105
 106 VOID
 107 STDCALL
 108 KiDispatchThreadNoLock(ULONG NewThreadStatus)
 109 {
 110     KPRIORITY CurrentPriority;
 111     PKTHREAD Candidate;
 112     ULONG Affinity;
 113     PKTHREAD CurrentThread = KeGetCurrentThread();
 114
 115     DPRINT("KiDispatchThreadNoLock() %d/%d/%d/%d\n", KeGetCurrentProcessorNumber(),
 116             CurrentThread, NewThreadStatus, CurrentThread->State);
 117
 118     CurrentThread->State = (UCHAR)NewThreadStatus;
 119
 120     if (NewThreadStatus == Ready) {
 121
 122         KiInsertIntoThreadList(CurrentThread->Priority,
 123                                CurrentThread);
 124     }
 125
 126     Affinity = 1 << KeGetCurrentProcessorNumber();
 127
 128     for (CurrentPriority = HIGH_PRIORITY; CurrentPriority >= LOW_PRIORITY; CurrentPriority--) {
 129
 130         Candidate = KiScanThreadList(CurrentPriority, Affinity);
 131
 132         if (Candidate == CurrentThread) {
 133
 134             Candidate->State = Running;
 135             KeReleaseDispatcherDatabaseLockFromDpcLevel();
 136             return;
 137         }
 138
 139         if (Candidate != NULL) {
 140
 141             PKTHREAD OldThread;
 142             PKTHREAD IdleThread;
 143
 144             DPRINT("Scheduling %x(%d)\n",Candidate, CurrentPriority);
 145
 146             Candidate->State = Running;
 147
 148             OldThread = CurrentThread;
 149             CurrentThread = Candidate;
 150             IdleThread = KeGetCurrentPrcb()->IdleThread;
 151
 152             if (OldThread == IdleThread) {
 153
 154                 IdleProcessorMask &= ~Affinity;
 155
 156             } else if (CurrentThread == IdleThread) {
 157
 158                 IdleProcessorMask |= Affinity;
 159             }
 160
 161             MmUpdatePageDir(PsGetCurrentProcess(),((PETHREAD)CurrentThread)->ThreadsProcess, sizeof(EPROCESS));
 162
 163             /* Special note for Filip: This will release the Dispatcher DB Lock ;-) -- Alex */
 164             DPRINT("You are : %x, swapping to: %x\n", OldThread, CurrentThread);
 165             KiArchContextSwitch(CurrentThread);
 166             DPRINT("You are : %x, swapped from: %x\n", OldThread, CurrentThread);
 167             return;
 168         }
 169     }
 170
 171     DPRINT1("CRITICAL: No threads are ready (CPU%d)\n", KeGetCurrentProcessorNumber());
 172     KEBUGCHECK(0);
 173 }
 174
 175 VOID
 176 STDCALL
 177 KiBlockThread(PNTSTATUS Status,
 178               UCHAR Alertable,
 179               ULONG WaitMode,
 180               UCHAR WaitReason)
 181 {
 182     PKTHREAD Thread = KeGetCurrentThread();
 183     PKWAIT_BLOCK WaitBlock;
 184
 185     if (Thread->ApcState.KernelApcPending) {
 186
 187         DPRINT("Dispatching Thread as ready (APC!)\n");
 188
 189         /* Remove Waits */
 190         WaitBlock = Thread->WaitBlockList;
 191         do {
 192             RemoveEntryList (&WaitBlock->WaitListEntry);
 193             WaitBlock = WaitBlock->NextWaitBlock;
 194         } while (WaitBlock != Thread->WaitBlockList);
 195         Thread->WaitBlockList = NULL;
 196
 197         /* Dispatch it and return status */
 198         KiDispatchThreadNoLock (Ready);
 199         if (Status != NULL) *Status = STATUS_KERNEL_APC;
 200
 201     } else {
 202
 203         /* Set the Thread Data as Requested */
 204         DPRINT("Dispatching Thread as blocked: %d\n", Thread->WaitStatus);
 205         Thread->Alertable = Alertable;
 206         Thread->WaitMode = (UCHAR)WaitMode;
 207         Thread->WaitReason = WaitReason;
 208
 209         /* Dispatch it and return status */
 210         KiDispatchThreadNoLock(Waiting);
 211         DPRINT("Dispatching Thread as blocked: %d\n", Thread->WaitStatus);
 212         if (Status != NULL) *Status = Thread->WaitStatus;
 213     }
 214
 215     DPRINT("Releasing Dispatcher Lock\n");
 216     KfLowerIrql(Thread->WaitIrql);
 217 }
 218
 219 VOID
 220 STDCALL
 221 KiDispatchThread(ULONG NewThreadStatus)
 222 {
 223     KIRQL OldIrql;
 224
 225     if (KeGetCurrentPrcb()->IdleThread == NULL) {
 226         return;
 227     }
 228
 229     OldIrql = KeAcquireDispatcherDatabaseLock();
 230     KiDispatchThreadNoLock(NewThreadStatus);
 231     KeLowerIrql(OldIrql);
 232 }
 233
 234 VOID
 235 STDCALL
 236 KiUnblockThread(PKTHREAD Thread,
 237                 PNTSTATUS WaitStatus,
 238                 KPRIORITY Increment)
 239 {
 240     if (Terminated == Thread->State) {
 241
 242         DPRINT("Can't unblock thread 0x%x because it's terminating\n",
 243                Thread);
 244
 245     } else if (Ready == Thread->State ||
 246                Running == Thread->State) {
 247
 248         DPRINT("Can't unblock thread 0x%x because it's %s\n",
 249                Thread, (Thread->State == Ready ? "ready" : "running"));
 250
 251     } else {
 252
 253         LONG Processor;
 254         KAFFINITY Affinity;
 255
 256         /* FIXME: This propably isn't the right way to do it... */
 257         /* No it's not... i'll fix it later-- Alex */
 258         if (Thread->Priority < LOW_REALTIME_PRIORITY &&
 259             Thread->BasePriority < LOW_REALTIME_PRIORITY - 2) {
 260
 261             if (!Thread->PriorityDecrement && !Thread->DisableBoost) {
 262
 263                 Thread->Priority = Thread->BasePriority + Increment;
 264                 Thread->PriorityDecrement = Increment;
 265             }
 266
 267             /* Also decrease quantum */
 268             Thread->Quantum--;
 269
 270         } else {
 271
 272             Thread->Quantum = Thread->QuantumReset;
 273         }
 274
 275         if (WaitStatus != NULL) {
 276
 277             Thread->WaitStatus = *WaitStatus;
 278         }
 279
 280         Thread->State = Ready;
 281         KiInsertIntoThreadList(Thread->Priority, Thread);
 282         Processor = KeGetCurrentProcessorNumber();
 283         Affinity = Thread->Affinity;
 284
 285         if (!(IdleProcessorMask & (1 << Processor) & Affinity) &&
 286              (IdleProcessorMask & ~(1 << Processor) & Affinity)) {
 287
 288             LONG i;
 289
 290             for (i = 0; i < KeNumberProcessors - 1; i++) {
 291
 292                 Processor++;
 293
 294                 if (Processor >= KeNumberProcessors) {
 295
 296                     Processor = 0;
 297                 }
 298
 299                 if (IdleProcessorMask & (1 << Processor) & Affinity) {
 300 #if 0
 301                     /* FIXME:
 302                      *   Reschedule the threads on an other processor
 303                      */
 304                     KeReleaseDispatcherDatabaseLockFromDpcLevel();
 305                     KiRequestReschedule(Processor);
 306                     KeAcquireDispatcherDatabaseLockAtDpcLevel();
 307 #endif
 308                     break;
 309                 }
 310             }
 311         }
 312     }
 313 }
 314
 315 VOID
 316 STDCALL
 317 KiAdjustQuantumThread(IN PKTHREAD Thread)
 318 {
 319     KPRIORITY Priority;
 320
 321     /* Don't adjust for RT threads */
 322     if ((Thread->Priority < LOW_REALTIME_PRIORITY) &&
 323         Thread->BasePriority < LOW_REALTIME_PRIORITY - 2)
 324     {
 325         /* Decrease Quantum by one and see if we've ran out */
 326         if (--Thread->Quantum <= 0)
 327         {
 328             /* Return quantum */
 329             Thread->Quantum = Thread->QuantumReset;
 330
 331             /* Calculate new Priority */
 332             Priority = Thread->Priority - (Thread->PriorityDecrement + 1);
 333
 334             /* Normalize it if we've gone too low */
 335             if (Priority < Thread->BasePriority) Priority = Thread->BasePriority;
 336
 337             /* Reset the priority decrement, we've done it */
 338             Thread->PriorityDecrement = 0;
 339
 340             /* Set the new priority, if needed */
 341             if (Priority != Thread->Priority)
 342             {
 343                 /*
 344                  * FIXME: This should be a call to KiSetPriorityThread but
 345                  * due to the current ""scheduler"" in ROS, it can't be done
 346                  * cleanly since it actualyl dispatches threads instead.
 347                  */
 348                 Thread->Priority = Priority;
 349             }
 350             else
 351             {
 352                 /* FIXME: Priority hasn't changed, find a new thread */
 353             }
 354         }
 355     }
 356
 357     /* Nothing to do... */
 358     return;
 359 }
 360
 361
 362 VOID
 363 STDCALL
 364 KiSuspendThreadKernelRoutine(PKAPC Apc,
 365                              PKNORMAL_ROUTINE* NormalRoutine,
 366                              PVOID* NormalContext,
 367                              PVOID* SystemArgument1,
 368                              PVOID* SystemArguemnt2)
 369 {
 370 }
 371
 372 VOID
 373 STDCALL
 374 KiSuspendThreadNormalRoutine(PVOID NormalContext,
 375                              PVOID SystemArgument1,
 376                              PVOID SystemArgument2)
 377 {
 378     PKTHREAD CurrentThread = KeGetCurrentThread();
 379
 380     /* Non-alertable kernel-mode suspended wait */
 381     DPRINT("Waiting...\n");
 382     KeWaitForSingleObject(&CurrentThread->SuspendSemaphore,
 383                           Suspended,
 384                           KernelMode,
 385                           FALSE,
 386                           NULL);
 387     DPRINT("Done Waiting\n");
 388 }
 389
 390 #ifdef KeGetCurrentThread
 391 #undef KeGetCurrentThread
 392 #endif
 393 /*
 394  * @implemented
 395  */
 396 PKTHREAD
 397 STDCALL
 398 KeGetCurrentThread(VOID)
 399 {
 400 #ifdef CONFIG_SMP
 401     ULONG Flags;
 402     PKTHREAD Thread;
 403     Ke386SaveFlags(Flags);
 404     Ke386DisableInterrupts();
 405     Thread = KeGetCurrentPrcb()->CurrentThread;
 406     Ke386RestoreFlags(Flags);
 407     return Thread;
 408 #else
 409     return(KeGetCurrentPrcb()->CurrentThread);
 410 #endif
 411 }
 412
 413 VOID
 414 STDCALL
 415 KeSetPreviousMode(ULONG Mode)
 416 {
 417     PsGetCurrentThread()->Tcb.PreviousMode = (UCHAR)Mode;
 418 }
 419
 420 /*
 421  * @implemented
 422  */
 423 KPROCESSOR_MODE
 424 STDCALL
 425 KeGetPreviousMode(VOID)
 426 {
 427     return (ULONG)PsGetCurrentThread()->Tcb.PreviousMode;
 428 }
 429
 430 BOOLEAN
 431 STDCALL
 432 KeDisableThreadApcQueueing(IN PKTHREAD Thread)
 433 {
 434     KIRQL OldIrql;
 435     BOOLEAN PreviousState;
 436
 437     /* Lock the Dispatcher Database */
 438     OldIrql = KeAcquireDispatcherDatabaseLock();
 439
 440     /* Save old state */
 441     PreviousState = Thread->ApcQueueable;
 442
 443     /* Disable it now */
 444     Thread->ApcQueueable = FALSE;
 445
 446     /* Release the Lock */
 447     KeReleaseDispatcherDatabaseLock(OldIrql);
 448
 449     /* Return old state */
 450     return PreviousState;
 451 }
 452
 453 VOID
 454 STDCALL
 455 KeRundownThread(VOID)
 456 {
 457     KIRQL OldIrql;
 458     PKTHREAD Thread = KeGetCurrentThread();
 459     PLIST_ENTRY NextEntry, ListHead;
 460     PKMUTANT Mutant;
 461     DPRINT("KeRundownThread: %x\n", Thread);
 462
 463     /* Optimized path if nothing is on the list at the moment */
 464     if (IsListEmpty(&Thread->MutantListHead)) return;
 465
 466     /* Lock the Dispatcher Database */
 467     OldIrql = KeAcquireDispatcherDatabaseLock();
 468
 469     /* Get the List Pointers */
 470     ListHead = &Thread->MutantListHead;
 471     NextEntry = ListHead->Flink;
 472     while (NextEntry != ListHead)
 473     {
 474         /* Get the Mutant */
 475         Mutant = CONTAINING_RECORD(NextEntry, KMUTANT, MutantListEntry);
 476         DPRINT1("Mutant: %p. Type, Size %x %x\n",
 477                  Mutant,
 478                  Mutant->Header.Type,
 479                  Mutant->Header.Size);
 480
 481         /* Make sure it's not terminating with APCs off */
 482         if (Mutant->ApcDisable)
 483         {
 484             /* Bugcheck the system */
 485             KEBUGCHECKEX(0,//THREAD_TERMINATE_HELD_MUTEX,
 486                          (ULONG_PTR)Thread,
 487                          (ULONG_PTR)Mutant,
 488                          0,
 489                          0);
 490         }
 491
 492         /* Now we can remove it */
 493         RemoveEntryList(&Mutant->MutantListEntry);
 494
 495         /* Unconditionally abandon it */
 496         DPRINT("Abandonning the Mutant\n");
 497         Mutant->Header.SignalState = 1;
 498         Mutant->Abandoned = TRUE;
 499         Mutant->OwnerThread = NULL;
 500
 501         /* Check if the Wait List isn't empty */
 502         DPRINT("Checking whether to wake the Mutant\n");
 503         if (!IsListEmpty(&Mutant->Header.WaitListHead))
 504         {
 505             /* Wake the Mutant */
 506             DPRINT("Waking the Mutant\n");
 507             KiWaitTest(&Mutant->Header, MUTANT_INCREMENT);
 508         }
 509
 510         /* Move on */
 511         NextEntry = NextEntry->Flink;
 512     }
 513
 514     /* Release the Lock */
 515     KeReleaseDispatcherDatabaseLock(OldIrql);
 516 }
 517
 518 ULONG
 519 STDCALL
 520 KeResumeThread(PKTHREAD Thread)
 521 {
 522     ULONG PreviousCount;
 523     KIRQL OldIrql;
 524
 525     DPRINT("KeResumeThread (Thread %p called). %x, %x\n", Thread,
 526             Thread->SuspendCount, Thread->FreezeCount);
 527
 528     /* Lock the Dispatcher */
 529     OldIrql = KeAcquireDispatcherDatabaseLock();
 530
 531     /* Save the Old Count */
 532     PreviousCount = Thread->SuspendCount;
 533
 534     /* Check if it existed */
 535     if (PreviousCount) {
 536
 537         Thread->SuspendCount--;
 538
 539         /* Decrease the current Suspend Count and Check Freeze Count */
 540         if ((!Thread->SuspendCount) && (!Thread->FreezeCount)) {
 541
 542             /* Signal the Suspend Semaphore */
 543             Thread->SuspendSemaphore.Header.SignalState++;
 544             KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
 545         }
 546     }
 547
 548     /* Release Lock and return the Old State */
 549     KeReleaseDispatcherDatabaseLock(OldIrql);
 550     return PreviousCount;
 551 }
 552
 553 VOID
 554 FASTCALL
 555 KiInsertQueueApc(PKAPC Apc,
 556                  KPRIORITY PriorityBoost);
 557
 558 /*
 559  * Used by the debugging code to freeze all the process's threads
 560  * while the debugger is examining their state.
 561  */
 562 VOID
 563 STDCALL
 564 KeFreezeAllThreads(PKPROCESS Process)
 565 {
 566     KIRQL OldIrql;
 567     PKTHREAD Current;
 568     PKTHREAD CurrentThread = KeGetCurrentThread();
 569
 570     /* Acquire Lock */
 571     OldIrql = KeAcquireDispatcherDatabaseLock();
 572
 573     /* If someone is already trying to free us, try again */
 574     while (CurrentThread->FreezeCount)
 575     {
 576         /* Release and re-acquire the lock so the APC will go through */
 577         KeReleaseDispatcherDatabaseLock(OldIrql);
 578         OldIrql = KeAcquireDispatcherDatabaseLock();
 579     }
 580
 581     /* Enter a critical region */
 582     KeEnterCriticalRegion();
 583
 584     /* Loop the Process's Threads */
 585     LIST_FOR_EACH(Current, &Process->ThreadListHead, KTHREAD, ThreadListEntry)
 586     {
 587         /* Make sure it's not ours */
 588         if (Current != CurrentThread)
 589         {
 590             /* Should be bother inserting the APC? */
 591             if (Current->ApcQueueable)
 592             {
 593                 /* Make sure it wasn't already frozen, and that it's not suspended */
 594                 if (!(++Current->FreezeCount) && !(Current->SuspendCount))
 595                 {
 596                     /* Did we already insert it? */
 597                     if (!Current->SuspendApc.Inserted)
 598                     {
 599                         /* Insert the APC */
 600                         Current->SuspendApc.Inserted = TRUE;
 601                         KiInsertQueueApc(&Current->SuspendApc, IO_NO_INCREMENT);
 602                     }
 603                     else
 604                     {
 605                         /* Unsignal the Semaphore, the APC already got inserted */
 606                         Current->SuspendSemaphore.Header.SignalState--;
 607                     }
 608                 }
 609             }
 610         }
 611     }
 612
 613     /* Release the lock */
 614     KeReleaseDispatcherDatabaseLock(OldIrql);
 615 }
 616
 617 NTSTATUS
 618 STDCALL
 619 KeSuspendThread(PKTHREAD Thread)
 620 {
 621     ULONG PreviousCount;
 622     KIRQL OldIrql;
 623
 624     DPRINT("KeSuspendThread (Thread %p called). %x, %x\n", Thread, Thread->SuspendCount, Thread->FreezeCount);
 625
 626     /* Lock the Dispatcher */
 627     OldIrql = KeAcquireDispatcherDatabaseLock();
 628
 629     /* Save the Old Count */
 630     PreviousCount = Thread->SuspendCount;
 631
 632     /* Handle the maximum */
 633     if (PreviousCount == MAXIMUM_SUSPEND_COUNT)
 634     {
 635         /* Raise an exception */
 636         KeReleaseDispatcherDatabaseLock(OldIrql);
 637         RtlRaiseStatus(STATUS_SUSPEND_COUNT_EXCEEDED);
 638     }
 639
 640     /* Should we bother to queue at all? */
 641     if (Thread->ApcQueueable)
 642     {
 643         /* Increment the suspend count */
 644         Thread->SuspendCount++;
 645
 646         /* Check if we should suspend it */
 647         if (!PreviousCount && !Thread->FreezeCount)
 648         {
 649             /* Is the APC already inserted? */
 650             if (!Thread->SuspendApc.Inserted)
 651             {
 652                 /* Not inserted, insert it */
 653                 Thread->SuspendApc.Inserted = TRUE;
 654                 KiInsertQueueApc(&Thread->SuspendApc, IO_NO_INCREMENT);
 655             }
 656             else
 657             {
 658                 /* Unsignal the Semaphore, the APC already got inserted */
 659                 Thread->SuspendSemaphore.Header.SignalState--;
 660             }
 661         }
 662     }
 663
 664     /* Release Lock and return the Old State */
 665     KeReleaseDispatcherDatabaseLock(OldIrql);
 666     return PreviousCount;
 667 }
 668
 669 ULONG
 670 STDCALL
 671 KeForceResumeThread(IN PKTHREAD Thread)
 672 {
 673     KIRQL OldIrql;
 674     ULONG PreviousCount;
 675
 676     /* Lock the Dispatcher Database and the APC Queue */
 677     OldIrql = KeAcquireDispatcherDatabaseLock();
 678
 679     /* Save the old Suspend Count */
 680     PreviousCount = Thread->SuspendCount + Thread->FreezeCount;
 681
 682     /* If the thread is suspended, wake it up!!! */
 683     if (PreviousCount) {
 684
 685         /* Unwait it completely */
 686         Thread->SuspendCount = 0;
 687         Thread->FreezeCount = 0;
 688
 689         /* Signal and satisfy */
 690         Thread->SuspendSemaphore.Header.SignalState++;
 691         KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
 692     }
 693
 694     /* Release Lock and return the Old State */
 695     KeReleaseDispatcherDatabaseLock(OldIrql);
 696     return PreviousCount;
 697 }
 698
 699 ULONG
 700 STDCALL
 701 KeAlertResumeThread(IN PKTHREAD Thread)
 702 {
 703     ULONG PreviousCount;
 704     KIRQL OldIrql;
 705
 706     ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 707
 708     /* Lock the Dispatcher Database and the APC Queue */
 709     OldIrql = KeAcquireDispatcherDatabaseLock();
 710     KiAcquireSpinLock(&Thread->ApcQueueLock);
 711
 712     /* Return if Thread is already alerted. */
 713     if (Thread->Alerted[KernelMode] == FALSE) {
 714
 715         /* If it's Blocked, unblock if it we should */
 716         if (Thread->State == Waiting &&  Thread->Alertable) {
 717
 718             DPRINT("Aborting Wait\n");
 719             KiAbortWaitThread(Thread, STATUS_ALERTED, THREAD_ALERT_INCREMENT);
 720
 721         } else {
 722
 723             /* If not, simply Alert it */
 724             Thread->Alerted[KernelMode] = TRUE;
 725         }
 726     }
 727
 728     /* Save the old Suspend Count */
 729     PreviousCount = Thread->SuspendCount;
 730
 731     /* If the thread is suspended, decrease one of the suspend counts */
 732     if (PreviousCount) {
 733
 734         /* Decrease count. If we are now zero, unwait it completely */
 735         if (--Thread->SuspendCount) {
 736
 737             /* Signal and satisfy */
 738             Thread->SuspendSemaphore.Header.SignalState++;
 739             KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
 740         }
 741     }
 742
 743     /* Release Locks and return the Old State */
 744     KiReleaseSpinLock(&Thread->ApcQueueLock);
 745     KeReleaseDispatcherDatabaseLock(OldIrql);
 746     return PreviousCount;
 747 }
 748
 749 BOOLEAN
 750 STDCALL
 751 KeAlertThread(PKTHREAD Thread,
 752               KPROCESSOR_MODE AlertMode)
 753 {
 754     KIRQL OldIrql;
 755     BOOLEAN PreviousState;
 756
 757     /* Acquire the Dispatcher Database Lock */
 758     OldIrql = KeAcquireDispatcherDatabaseLock();
 759
 760     /* Save the Previous State */
 761     PreviousState = Thread->Alerted[AlertMode];
 762
 763     /* Return if Thread is already alerted. */
 764     if (PreviousState == FALSE) {
 765
 766         /* If it's Blocked, unblock if it we should */
 767         if (Thread->State == Waiting &&
 768             (AlertMode == KernelMode || Thread->WaitMode == AlertMode) &&
 769             Thread->Alertable) {
 770
 771             DPRINT("Aborting Wait\n");
 772             KiAbortWaitThread(Thread, STATUS_ALERTED, THREAD_ALERT_INCREMENT);
 773
 774         } else {
 775
 776             /* If not, simply Alert it */
 777             Thread->Alerted[AlertMode] = TRUE;
 778         }
 779     }
 780
 781     /* Release the Dispatcher Lock */
 782     KeReleaseDispatcherDatabaseLock(OldIrql);
 783
 784     /* Return the old state */
 785     return PreviousState;
 786 }
 787
 788 /*
 789  * @unimplemented
 790  */
 791 VOID
 792 STDCALL
 793 KeCapturePersistentThreadState(IN PVOID CurrentThread,
 794                                IN ULONG Setting1,
 795                                IN ULONG Setting2,
 796                                IN ULONG Setting3,
 797                                IN ULONG Setting4,
 798                                IN ULONG Setting5,
 799                                IN PVOID ThreadState)
 800 {
 801     UNIMPLEMENTED;
 802 }
 803
 804 /*
 805  * FUNCTION: Initialize the microkernel state of the thread
 806  */
 807 VOID
 808 STDCALL
 809 KeInitializeThread(PKPROCESS Process,
 810                    PKTHREAD Thread,
 811                    PKSYSTEM_ROUTINE SystemRoutine,
 812                    PKSTART_ROUTINE StartRoutine,
 813                    PVOID StartContext,
 814                    PCONTEXT Context,
 815                    PVOID Teb,
 816                    PVOID KernelStack)
 817 {
 818     /* Initalize the Dispatcher Header */
 819     DPRINT("Initializing Dispatcher Header for New Thread: %x in Process: %x\n", Thread, Process);
 820     KeInitializeDispatcherHeader(&Thread->DispatcherHeader,
 821                                  ThreadObject,
 822                                  sizeof(KTHREAD) / sizeof(LONG),
 823                                  FALSE);
 824
 825     DPRINT("Thread Header Created. SystemRoutine: %x, StartRoutine: %x with Context: %x\n",
 826             SystemRoutine, StartRoutine, StartContext);
 827     DPRINT("UserMode Information. Context: %x, Teb: %x\n", Context, Teb);
 828
 829     /* Initialize the Mutant List */
 830     InitializeListHead(&Thread->MutantListHead);
 831
 832     /* Setup the Service Descriptor Table for Native Calls */
 833     Thread->ServiceTable = KeServiceDescriptorTable;
 834
 835     /* Setup APC Fields */
 836     InitializeListHead(&Thread->ApcState.ApcListHead[0]);
 837     InitializeListHead(&Thread->ApcState.ApcListHead[1]);
 838     Thread->ApcState.Process = Process;
 839     Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->ApcState;
 840     Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->SavedApcState;
 841     Thread->ApcStateIndex = OriginalApcEnvironment;
 842     KeInitializeSpinLock(&Thread->ApcQueueLock);
 843
 844     /* Initialize the Suspend APC */
 845     KeInitializeApc(&Thread->SuspendApc,
 846                     Thread,
 847                     OriginalApcEnvironment,
 848                     KiSuspendThreadKernelRoutine,
 849                     NULL,
 850                     KiSuspendThreadNormalRoutine,
 851                     KernelMode,
 852                     NULL);
 853
 854     /* Initialize the Suspend Semaphore */
 855     KeInitializeSemaphore(&Thread->SuspendSemaphore, 0, 128);
 856
 857     /* FIXME OPTIMIZATION OF DOOM. DO NOT ENABLE FIXME */
 858 #if 0
 859     Thread->WaitBlock[3].Object = (PVOID)&Thread->Timer;
 860     Thread->WaitBlock[3].Thread = Thread;
 861     Thread->WaitBlock[3].WaitKey = STATUS_TIMEOUT;
 862     Thread->WaitBlock[3].WaitType = WaitAny;
 863     Thread->WaitBlock[3].NextWaitBlock = NULL;
 864     InsertTailList(&Thread->Timer.Header.WaitListHead,
 865                    &Thread->WaitBlock[3].WaitListEntry);
 866 #endif
 867     KeInitializeTimer(&Thread->Timer);
 868
 869     /* Set the TEB */
 870     Thread->Teb = Teb;
 871
 872     /* Set the Thread Stacks */
 873     Thread->InitialStack = (PCHAR)KernelStack + MM_STACK_SIZE;
 874     Thread->StackBase = (PCHAR)KernelStack + MM_STACK_SIZE;
 875     Thread->StackLimit = (ULONG_PTR)KernelStack;
 876     Thread->KernelStackResident = TRUE;
 877
 878     /*
 879      * Establish the pde's for the new stack and the thread structure within the
 880      * address space of the new process. They are accessed while taskswitching or
 881      * while handling page faults. At this point it isn't possible to call the
 882      * page fault handler for the missing pde's.
 883      */
 884     MmUpdatePageDir((PEPROCESS)Process, (PVOID)Thread->StackLimit, MM_STACK_SIZE);
 885     MmUpdatePageDir((PEPROCESS)Process, (PVOID)Thread, sizeof(ETHREAD));
 886
 887     /* Initalize the Thread Context */
 888     DPRINT("Initializing the Context for the thread: %x\n", Thread);
 889     KiArchInitThreadWithContext(Thread,
 890                                 SystemRoutine,
 891                                 StartRoutine,
 892                                 StartContext,
 893                                 Context);
 894
 895     /* Setup scheduler Fields based on Parent */
 896     DPRINT("Thread context created, setting Scheduler Data\n");
 897     Thread->BasePriority = Process->BasePriority;
 898     Thread->Quantum = Process->QuantumReset;
 899     Thread->QuantumReset = Process->QuantumReset;
 900     Thread->Affinity = Process->Affinity;
 901     Thread->Priority = Process->BasePriority;
 902     Thread->UserAffinity = Process->Affinity;
 903     Thread->DisableBoost = Process->DisableBoost;
 904     Thread->AutoAlignment = Process->AutoAlignment;
 905     Thread->Iopl = Process->Iopl;
 906
 907     /* Set the Thread to initalized */
 908     Thread->State = Initialized;
 909
 910     /*
 911      * Insert the Thread into the Process's Thread List
 912      * Note, this is the KTHREAD Thread List. It is removed in
 913      * ke/kthread.c!KeTerminateThread.
 914      */
 915     InsertTailList(&Process->ThreadListHead, &Thread->ThreadListEntry);
 916     DPRINT("Thread initalized\n");
 917 }
 918
 919
 920 /*
 921  * @implemented
 922  */
 923 KPRIORITY
 924 STDCALL
 925 KeQueryPriorityThread (IN PKTHREAD Thread)
 926 {
 927     return Thread->Priority;
 928 }
 929
 930 /*
 931  * @implemented
 932  */
 933 ULONG
 934 STDCALL
 935 KeQueryRuntimeThread(IN PKTHREAD Thread,
 936                      OUT PULONG UserTime)
 937 {
 938     /* Return the User Time */
 939     *UserTime = Thread->UserTime;
 940
 941     /* Return the Kernel Time */
 942     return Thread->KernelTime;
 943 }
 944
 945 /*
 946  * @implemented
 947  */
 948 BOOLEAN
 949 STDCALL
 950 KeSetKernelStackSwapEnable(IN BOOLEAN Enable)
 951 {
 952     PKTHREAD Thread = KeGetCurrentThread();
 953     BOOLEAN PreviousState;
 954     KIRQL OldIrql;
 955
 956      /* Lock the Dispatcher Database */
 957     OldIrql = KeAcquireDispatcherDatabaseLock();
 958
 959     /* Save Old State */
 960     PreviousState = Thread->EnableStackSwap;
 961
 962     /* Set New State */
 963     Thread->EnableStackSwap = Enable;
 964
 965     /* No, Release Lock */
 966     KeReleaseDispatcherDatabaseLock(OldIrql);
 967
 968     /* Return Old State */
 969     return PreviousState;
 970 }
 971
 972 /*
 973  * @implemented
 974  */
 975 VOID
 976 STDCALL
 977 KeRevertToUserAffinityThread(VOID)
 978 {
 979     PKTHREAD CurrentThread = KeGetCurrentThread();
 980     KIRQL OldIrql;
 981
 982     ASSERT(CurrentThread->SystemAffinityActive != FALSE);
 983
 984     /* Lock the Dispatcher Database */
 985     OldIrql = KeAcquireDispatcherDatabaseLock();
 986
 987     /* Return to User Affinity */
 988     CurrentThread->Affinity = CurrentThread->UserAffinity;
 989
 990     /* Disable System Affinity */
 991     CurrentThread->SystemAffinityActive = FALSE;
 992
 993     /* Check if we need to Dispatch a New thread */
 994     if (CurrentThread->Affinity & (1 << KeGetCurrentProcessorNumber())) {
 995
 996         /* No, just release */
 997         KeReleaseDispatcherDatabaseLock(OldIrql);
 998
 999     } else {
1000
1001         /* We need to dispatch a new thread */
1002         CurrentThread->WaitIrql = OldIrql;
1003         KiDispatchThreadNoLock(Ready);
1004         KeLowerIrql(OldIrql);
1005     }
1006 }
1007
1008 /*
1009  * @implemented
1010  */
1011 CCHAR
1012 STDCALL
1013 KeSetIdealProcessorThread(IN PKTHREAD Thread,
1014                           IN CCHAR Processor)
1015 {
1016     CCHAR PreviousIdealProcessor;
1017     KIRQL OldIrql;
1018
1019     /* Lock the Dispatcher Database */
1020     OldIrql = KeAcquireDispatcherDatabaseLock();
1021
1022     /* Save Old Ideal Processor */
1023     PreviousIdealProcessor = Thread->IdealProcessor;
1024
1025     /* Set New Ideal Processor */
1026     Thread->IdealProcessor = Processor;
1027
1028     /* Release Lock */
1029     KeReleaseDispatcherDatabaseLock(OldIrql);
1030
1031     /* Return Old Ideal Processor */
1032     return PreviousIdealProcessor;
1033 }
1034
1035 /*
1036  * @implemented
1037  */
1038 VOID
1039 STDCALL
1040 KeSetSystemAffinityThread(IN KAFFINITY Affinity)
1041 {
1042     PKTHREAD CurrentThread = KeGetCurrentThread();
1043     KIRQL OldIrql;
1044
1045     ASSERT(Affinity & ((1 << KeNumberProcessors) - 1));
1046
1047     /* Lock the Dispatcher Database */
1048     OldIrql = KeAcquireDispatcherDatabaseLock();
1049
1050     /* Set the System Affinity Specified */
1051     CurrentThread->Affinity = Affinity;
1052
1053     /* Enable System Affinity */
1054     CurrentThread->SystemAffinityActive = TRUE;
1055
1056     /* Check if we need to Dispatch a New thread */
1057     if (Affinity & (1 << KeGetCurrentProcessorNumber())) {
1058
1059         /* No, just release */
1060         KeReleaseDispatcherDatabaseLock(OldIrql);
1061
1062     } else {
1063
1064         /* We need to dispatch a new thread */
1065         CurrentThread->WaitIrql = OldIrql;
1066         KiDispatchThreadNoLock(Ready);
1067         KeLowerIrql(OldIrql);
1068     }
1069 }
1070
1071 LONG
1072 STDCALL
1073 KeQueryBasePriorityThread(IN PKTHREAD Thread)
1074 {
1075     LONG BasePriorityIncrement;
1076     KIRQL OldIrql;
1077     PKPROCESS Process;
1078
1079     /* Lock the Dispatcher Database */
1080     OldIrql = KeAcquireDispatcherDatabaseLock();
1081
1082     /* Get the Process */
1083     Process = Thread->ApcStatePointer[0]->Process;
1084
1085     /* Calculate the BPI */
1086     BasePriorityIncrement = Thread->BasePriority - Process->BasePriority;
1087
1088     /* If saturation occured, return the SI instead */
1089     if (Thread->Saturation) BasePriorityIncrement = (HIGH_PRIORITY + 1) / 2 *
1090                                                     Thread->Saturation;
1091
1092     /* Release Lock */
1093     KeReleaseDispatcherDatabaseLock(OldIrql);
1094
1095     /* Return Increment */
1096     return BasePriorityIncrement;
1097 }
1098
1099 VOID
1100 STDCALL
1101 KiSetPriorityThread(PKTHREAD Thread,
1102                     KPRIORITY Priority,
1103                     PBOOLEAN Released)
1104 {
1105     KPRIORITY OldPriority = Thread->Priority;
1106     ULONG Mask;
1107     int i;
1108     PKPCR Pcr;
1109     DPRINT("Changing prio to : %lx\n", Priority);
1110
1111     /* Check if priority changed */
1112     if (OldPriority != Priority)
1113     {
1114         /* Set it */
1115         Thread->Priority = Priority;
1116
1117         /* Choose action based on thread's state */
1118         if (Thread->State == Ready)
1119         {
1120             /* Remove it from the current queue */
1121             KiRemoveFromThreadList(Thread);
1122
1123             /* Re-insert it at its current priority */
1124             KiInsertIntoThreadList(Priority, Thread);
1125
1126             /* Check if the old priority was lower */
1127             if (KeGetCurrentThread()->Priority < Priority)
1128             {
1129                 /* Dispatch it immediately */
1130                 KiDispatchThreadNoLock(Ready);
1131                 *Released = TRUE;
1132                 return;
1133             }
1134         }
1135         else if (Thread->State == Running)
1136         {
1137             /* Check if the new priority is lower */
1138             if (Priority < OldPriority)
1139             {
1140                 /* Check for threads with a higher priority */
1141                 Mask = ~((1 << (Priority + 1)) - 1);
1142                 if (PriorityListMask & Mask)
1143                 {
1144                     /* Found a thread, is it us? */
1145                     if (Thread == KeGetCurrentThread())
1146                     {
1147                         /* Dispatch us */
1148                         KiDispatchThreadNoLock(Ready);
1149                         *Released = TRUE;
1150                         return;
1151                     }
1152                     else
1153                     {
1154                         /* Loop every CPU */
1155                         for (i = 0; i < KeNumberProcessors; i++)
1156                         {
1157                             /* Get the PCR for this CPU */
1158                             Pcr = (PKPCR)(KPCR_BASE + i * PAGE_SIZE);
1159
1160                             /* Reschedule if the new one is already on a CPU */
1161                             if (Pcr->Prcb->CurrentThread == Thread)
1162                             {
1163                                 KeReleaseDispatcherDatabaseLockFromDpcLevel();
1164                                 KiRequestReschedule(i);
1165                                 *Released = TRUE;
1166                                 return;
1167                             }
1168                         }
1169                     }
1170                 }
1171             }
1172         }
1173     }
1174
1175     /* Return to caller */
1176     return;
1177 }
1178
1179 /*
1180  * @implemented
1181  */
1182 LONG
1183 STDCALL
1184 KeSetBasePriorityThread(PKTHREAD Thread,
1185                         LONG Increment)
1186 {
1187     KIRQL OldIrql;
1188     PKPROCESS Process;
1189     KPRIORITY Priority;
1190     KPRIORITY CurrentBasePriority;
1191     KPRIORITY BasePriority;
1192     BOOLEAN Released = FALSE;
1193     LONG CurrentIncrement;
1194
1195     /* Lock the Dispatcher Database */
1196     OldIrql = KeAcquireDispatcherDatabaseLock();
1197
1198     /* Get the process and calculate current BP and BPI */
1199     Process = Thread->ApcStatePointer[0]->Process;
1200     CurrentBasePriority = Thread->BasePriority;
1201     CurrentIncrement = CurrentBasePriority - Process->BasePriority;
1202
1203     /* Change to use the SI if Saturation was used */
1204     if (Thread->Saturation) CurrentIncrement = (HIGH_PRIORITY + 1) / 2 *
1205                                                Thread->Saturation;
1206
1207     /* Now check if saturation is being used for the new value */
1208     if (abs(Increment) >= ((HIGH_PRIORITY + 1) / 2))
1209     {
1210         /* Check if we need positive or negative saturation */
1211         Thread->Saturation = (Increment > 0) ? 1 : -1;
1212     }
1213
1214     /* Normalize the Base Priority */
1215     BasePriority = Process->BasePriority + Increment;
1216     if (Process->BasePriority >= LOW_REALTIME_PRIORITY)
1217     {
1218         /* Check if it's too low */
1219         if (BasePriority < LOW_REALTIME_PRIORITY)
1220             BasePriority = LOW_REALTIME_PRIORITY;
1221
1222         /* Check if it's too high */
1223         if (BasePriority > HIGH_PRIORITY) BasePriority = HIGH_PRIORITY;
1224
1225         /* We are at RTP, so use the raw BP */
1226         Priority = BasePriority;
1227     }
1228     else
1229     {
1230         /* Check if it's entering RTP */
1231         if (BasePriority >= LOW_REALTIME_PRIORITY)
1232             BasePriority = LOW_REALTIME_PRIORITY - 1;
1233
1234         /* Check if it's too low */
1235         if (BasePriority <= LOW_PRIORITY)
1236             BasePriority = 1;
1237
1238         /* If Saturation is used, then use the raw BP */
1239         if (Thread->Saturation)
1240         {
1241             Priority = BasePriority;
1242         }
1243         else
1244         {
1245             /* Calculate the new priority */
1246             Priority = Thread->Priority + (BasePriority - CurrentBasePriority)-
1247                        Thread->PriorityDecrement;
1248
1249             /* Make sure it won't enter RTP ranges */
1250             if (Priority >= LOW_REALTIME_PRIORITY)
1251                 Priority = LOW_REALTIME_PRIORITY - 1;
1252         }
1253     }
1254
1255     /* Finally set the new base priority */
1256     Thread->BasePriority = BasePriority;
1257
1258     /* Reset the decrements */
1259     Thread->PriorityDecrement = 0;
1260
1261     /* If the priority will change, reset quantum and change it for real */
1262     if (Priority != Thread->Priority)
1263     {
1264         Thread->Quantum = Thread->QuantumReset;
1265         KiSetPriorityThread(Thread, Priority, &Released);
1266     }
1267
1268     /* Release Lock if needed */
1269     if (!Released)
1270     {
1271         KeReleaseDispatcherDatabaseLock(OldIrql);
1272     }
1273     else
1274     {
1275         KeLowerIrql(OldIrql);
1276     }
1277
1278     /* Return the Old Increment */
1279     return CurrentIncrement;
1280 }
1281
1282 /*
1283  * @implemented
1284  */
1285 KPRIORITY
1286 STDCALL
1287 KeSetPriorityThread(PKTHREAD Thread,
1288                     KPRIORITY Priority)
1289 {
1290     KPRIORITY OldPriority;
1291     BOOLEAN Released = FALSE;
1292     KIRQL OldIrql;
1293
1294     /* Lock the Dispatcher Database */
1295     OldIrql = KeAcquireDispatcherDatabaseLock();
1296
1297     /* Save the old Priority */
1298     OldPriority = Thread->Priority;
1299
1300     /* Reset the Quantum and Decrements */
1301     Thread->Quantum = Thread->QuantumReset;
1302     Thread->PriorityDecrement = 0;
1303
1304     /* Set the new Priority */
1305     KiSetPriorityThread(Thread, Priority, &Released);
1306
1307     /* Release Lock if needed */
1308     if (!Released)
1309     {
1310         KeReleaseDispatcherDatabaseLock(OldIrql);
1311     }
1312     else
1313     {
1314         KeLowerIrql(OldIrql);
1315     }
1316
1317     /* Return Old Priority */
1318     return OldPriority;
1319 }
1320
1321 /*
1322  * @implemented
1323  *
1324  * Sets thread's affinity
1325  */
1326 NTSTATUS
1327 STDCALL
1328 KeSetAffinityThread(PKTHREAD Thread,
1329                     KAFFINITY Affinity)
1330 {
1331     KIRQL OldIrql;
1332     LONG i;
1333     PKPCR Pcr;
1334     KAFFINITY ProcessorMask;
1335
1336     DPRINT("KeSetAffinityThread(Thread %x, Affinity %x)\n", Thread, Affinity);
1337
1338     /* Verify correct affinity */
1339     if ((Affinity & Thread->ApcStatePointer[0]->Process->Affinity) !=
1340         Affinity || !Affinity)
1341     {
1342         KEBUGCHECK(INVALID_AFFINITY_SET);
1343     }
1344
1345     OldIrql = KeAcquireDispatcherDatabaseLock();
1346
1347     Thread->UserAffinity = Affinity;
1348
1349     if (Thread->SystemAffinityActive == FALSE) {
1350
1351         Thread->Affinity = Affinity;
1352
1353         if (Thread->State == Running) {
1354
1355             ProcessorMask = 1 << KeGetCurrentProcessorNumber();
1356             if (Thread == KeGetCurrentThread()) {
1357
1358                 if (!(Affinity & ProcessorMask)) {
1359
1360                     KiDispatchThreadNoLock(Ready);
1361                     KeLowerIrql(OldIrql);
1362                     return STATUS_SUCCESS;
1363                 }
1364
1365             } else {
1366
1367                 for (i = 0; i < KeNumberProcessors; i++) {
1368
1369                     Pcr = (PKPCR)(KPCR_BASE + i * PAGE_SIZE);
1370                     if (Pcr->Prcb->CurrentThread == Thread) {
1371
1372                         if (!(Affinity & ProcessorMask)) {
1373
1374                             KeReleaseDispatcherDatabaseLockFromDpcLevel();
1375                             KiRequestReschedule(i);
1376                             KeLowerIrql(OldIrql);
1377                             return STATUS_SUCCESS;
1378                         }
1379
1380                         break;
1381                     }
1382                 }
1383
1384                 ASSERT (i < KeNumberProcessors);
1385             }
1386         }
1387     }
1388
1389     KeReleaseDispatcherDatabaseLock(OldIrql);
1390     return STATUS_SUCCESS;
1391 }
1392
1393 /*
1394  * @implemented
1395  */
1396  /* The Increment Argument seems to be ignored by NT and always 0 when called */
1397 VOID
1398 STDCALL
1399 KeTerminateThread(IN KPRIORITY Increment)
1400 {
1401     KIRQL OldIrql;
1402     PKTHREAD Thread = KeGetCurrentThread();
1403
1404     /* Lock the Dispatcher Database and the APC Queue */
1405     DPRINT("Terminating\n");
1406     OldIrql = KeAcquireDispatcherDatabaseLock();
1407
1408     /* Remove the thread from the list */
1409     RemoveEntryList(&Thread->ThreadListEntry);
1410
1411     /* Insert into the Reaper List */
1412     DPRINT("List: %p\n", PspReaperList);
1413     ((PETHREAD)Thread)->ReaperLink = PspReaperList;
1414     PspReaperList = (PETHREAD)Thread;
1415     DPRINT("List: %p\n", PspReaperList);
1416
1417     /* Check if it's active */
1418     if (PspReaping == FALSE) {
1419
1420         /* Activate it. We use the internal function for speed, and use the Hyper Critical Queue */
1421         PspReaping = TRUE;
1422         DPRINT("Terminating\n");
1423         KiInsertQueue(&ExWorkerQueue[HyperCriticalWorkQueue].WorkerQueue,
1424                       &PspReaperWorkItem.List,
1425                       FALSE);
1426     }
1427
1428     /* Handle Kernel Queues */
1429     if (Thread->Queue) {
1430
1431         DPRINT("Waking Queue\n");
1432         RemoveEntryList(&Thread->QueueListEntry);
1433         KiWakeQueue(Thread->Queue);
1434     }
1435
1436     /* Signal the thread */
1437     Thread->DispatcherHeader.SignalState = TRUE;
1438     if (IsListEmpty(&Thread->DispatcherHeader.WaitListHead) != TRUE) {
1439
1440         /* Satisfy waits */
1441         KiWaitTest((PVOID)Thread, Increment);
1442     }
1443
1444     /* Find a new Thread */
1445     KiDispatchThreadNoLock(Terminated);
1446 }
1447
1448 /*
1449  * FUNCTION: Tests whether there are any pending APCs for the current thread
1450  * and if so the APCs will be delivered on exit from kernel mode
1451  */
1452 BOOLEAN
1453 STDCALL
1454 KeTestAlertThread(IN KPROCESSOR_MODE AlertMode)
1455 {
1456     KIRQL OldIrql;
1457     PKTHREAD Thread = KeGetCurrentThread();
1458     BOOLEAN OldState;
1459
1460     ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
1461
1462     /* Lock the Dispatcher Database and the APC Queue */
1463     OldIrql = KeAcquireDispatcherDatabaseLock();
1464     KiAcquireSpinLock(&Thread->ApcQueueLock);
1465
1466     /* Save the old State */
1467     OldState = Thread->Alerted[AlertMode];
1468
1469     /* If the Thread is Alerted, Clear it */
1470     if (OldState) {
1471
1472         Thread->Alerted[AlertMode] = FALSE;
1473
1474     } else if ((AlertMode != KernelMode) && (!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]))) {
1475
1476         /* If the mode is User and the Queue isn't empty, set Pending */
1477         Thread->ApcState.UserApcPending = TRUE;
1478     }
1479
1480     /* Release Locks and return the Old State */
1481     KiReleaseSpinLock(&Thread->ApcQueueLock);
1482     KeReleaseDispatcherDatabaseLock(OldIrql);
1483     return OldState;
1484 }
1485
1486 VOID
1487 KiServiceCheck (VOID)
1488 {
1489     PKTHREAD Thread = KeGetCurrentThread();
1490
1491     /* Check if we need to inialize Win32 for this Thread */
1492     if (Thread->ServiceTable != KeServiceDescriptorTableShadow) {
1493
1494         /* We do. Initialize it and save the new table */
1495         Thread->ServiceTable = KeServiceDescriptorTableShadow;
1496         PsInitWin32Thread((PETHREAD)Thread);
1497     }
1498 }
1499
1500 /*
1501  *
1502  * NOT EXPORTED
1503  */
1504 NTSTATUS
1505 STDCALL
1506 NtAlertResumeThread(IN  HANDLE ThreadHandle,
1507                     OUT PULONG SuspendCount)
1508 {
1509     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1510     PETHREAD Thread;
1511     NTSTATUS Status;
1512     ULONG PreviousState;
1513
1514     /* Check if parameters are valid */
1515     if(PreviousMode != KernelMode) {
1516
1517         _SEH_TRY {
1518
1519             ProbeForWriteUlong(SuspendCount);
1520
1521         } _SEH_HANDLE {
1522
1523             Status = _SEH_GetExceptionCode();
1524
1525         } _SEH_END;
1526     }
1527
1528     /* Reference the Object */
1529     Status = ObReferenceObjectByHandle(ThreadHandle,
1530                                        THREAD_SUSPEND_RESUME,
1531                                        PsThreadType,
1532                                        PreviousMode,
1533                                        (PVOID*)&Thread,
1534                                        NULL);
1535
1536     /* Check for Success */
1537     if (NT_SUCCESS(Status)) {
1538
1539         /* Call the Kernel Function */
1540         PreviousState = KeAlertResumeThread(&Thread->Tcb);
1541
1542         /* Dereference Object */
1543         ObDereferenceObject(Thread);
1544
1545         if (SuspendCount) {
1546
1547             _SEH_TRY {
1548
1549                 *SuspendCount = PreviousState;
1550
1551             } _SEH_HANDLE {
1552
1553                 Status = _SEH_GetExceptionCode();
1554
1555             } _SEH_END;
1556         }
1557     }
1558
1559     /* Return status */
1560     return Status;
1561 }
1562
1563 /*
1564  * @implemented
1565  *
1566  * EXPORTED
1567  */
1568 NTSTATUS
1569 STDCALL
1570 NtAlertThread (IN HANDLE ThreadHandle)
1571 {
1572     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1573     PETHREAD Thread;
1574     NTSTATUS Status;
1575
1576     /* Reference the Object */
1577     Status = ObReferenceObjectByHandle(ThreadHandle,
1578                                        THREAD_SUSPEND_RESUME,
1579                                        PsThreadType,
1580                                        PreviousMode,
1581                                        (PVOID*)&Thread,
1582                                        NULL);
1583
1584     /* Check for Success */
1585     if (NT_SUCCESS(Status)) {
1586
1587         /*
1588          * Do an alert depending on the processor mode. If some kmode code wants to
1589          * enforce a umode alert it should call KeAlertThread() directly. If kmode
1590          * code wants to do a kmode alert it's sufficient to call it with Zw or just
1591          * use KeAlertThread() directly
1592          */
1593         KeAlertThread(&Thread->Tcb, PreviousMode);
1594
1595         /* Dereference Object */
1596         ObDereferenceObject(Thread);
1597     }
1598
1599     /* Return status */
1600     return Status;
1601 }
1602
1603 NTSTATUS
1604 STDCALL
1605 NtDelayExecution(IN BOOLEAN Alertable,
1606                  IN PLARGE_INTEGER DelayInterval)
1607 {
1608     KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1609     LARGE_INTEGER SafeInterval;
1610     NTSTATUS Status;
1611
1612     /* Check if parameters are valid */
1613     if(PreviousMode != KernelMode) {
1614
1615         Status = STATUS_SUCCESS;
1616
1617         _SEH_TRY {
1618
1619             /* make a copy on the kernel stack and let DelayInterval point to it so
1620                we don't need to wrap KeDelayExecutionThread in SEH! */
1621             SafeInterval = ProbeForReadLargeInteger(DelayInterval);
1622             DelayInterval = &SafeInterval;
1623
1624         } _SEH_HANDLE {
1625
1626             Status = _SEH_GetExceptionCode();
1627         } _SEH_END;
1628
1629         if (!NT_SUCCESS(Status))
1630         {
1631             return Status;
1632         }
1633    }
1634
1635    /* Call the Kernel Function */
1636    Status = KeDelayExecutionThread(PreviousMode,
1637                                    Alertable,
1638                                    DelayInterval);
1639
1640    /* Return Status */
1641    return Status;
1642 }