- Update KTHREAD and KUSER_SHARED_DATA to latest versions. This should make 2K3 drive...
[reactos.git] / 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),
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 * Sets thread's base priority relative to the process' base priority
1181 * Should only be passed in THREAD_PRIORITY_ constants in pstypes.h
1182 *
1183 * @implemented
1184 */
1185 LONG
1186 STDCALL
1187 KeSetBasePriorityThread (PKTHREAD Thread,
1188 LONG Increment)
1189 {
1190 KIRQL OldIrql;
1191 PKPROCESS Process;
1192 KPRIORITY Priority;
1193 KPRIORITY CurrentBasePriority;
1194 KPRIORITY BasePriority;
1195 BOOLEAN Released = FALSE;
1196 LONG CurrentIncrement;
1197
1198 /* Lock the Dispatcher Database */
1199 OldIrql = KeAcquireDispatcherDatabaseLock();
1200
1201 /* Get the process and calculate current BP and BPI */
1202 Process = Thread->ApcStatePointer[0]->Process;
1203 CurrentBasePriority = Thread->BasePriority;
1204 CurrentIncrement = CurrentBasePriority - Process->BasePriority;
1205
1206 /* Change to use the SI if Saturation was used */
1207 if (Thread->Saturation) CurrentIncrement = (HIGH_PRIORITY + 1) / 2 *
1208 Thread->Saturation;
1209
1210 /* Now check if saturation is being used for the new value */
1211 if (abs(Increment) >= ((HIGH_PRIORITY + 1) / 2))
1212 {
1213 /* Check if we need positive or negative saturation */
1214 Thread->Saturation = (Increment > 0) ? 1 : -1;
1215 }
1216
1217 /* Normalize the Base Priority */
1218 BasePriority = Process->BasePriority + Increment;
1219 if (Process->BasePriority >= LOW_REALTIME_PRIORITY)
1220 {
1221 /* Check if it's too low */
1222 if (BasePriority < LOW_REALTIME_PRIORITY)
1223 BasePriority = LOW_REALTIME_PRIORITY;
1224
1225 /* Check if it's too high */
1226 if (BasePriority > HIGH_PRIORITY) BasePriority = HIGH_PRIORITY;
1227
1228 /* We are at RTP, so use the raw BP */
1229 Priority = BasePriority;
1230 }
1231 else
1232 {
1233 /* Check if it's entering RTP */
1234 if (BasePriority >= LOW_REALTIME_PRIORITY)
1235 BasePriority = LOW_REALTIME_PRIORITY - 1;
1236
1237 /* Check if it's too low */
1238 if (BasePriority <= LOW_PRIORITY)
1239 BasePriority = 1;
1240
1241 /* If Saturation is used, then use the raw BP */
1242 if (Thread->Saturation)
1243 {
1244 Priority = BasePriority;
1245 }
1246 else
1247 {
1248 /* Calculate the new priority */
1249 Priority = Thread->Priority + (BasePriority - CurrentBasePriority)-
1250 Thread->PriorityDecrement;
1251
1252 /* Make sure it won't enter RTP ranges */
1253 if (Priority >= LOW_REALTIME_PRIORITY)
1254 Priority = LOW_REALTIME_PRIORITY - 1;
1255 }
1256 }
1257
1258 /* Finally set the new base priority */
1259 Thread->BasePriority = BasePriority;
1260
1261 /* Reset the decrements */
1262 Thread->PriorityDecrement = 0;
1263
1264 /* If the priority will change, reset quantum and change it for real */
1265 if (Priority != Thread->Priority)
1266 {
1267 Thread->Quantum = Thread->QuantumReset;
1268 KiSetPriorityThread(Thread, Priority, &Released);
1269 }
1270
1271 /* Release Lock if needed */
1272 if (!Released)
1273 {
1274 KeReleaseDispatcherDatabaseLock(OldIrql);
1275 }
1276 else
1277 {
1278 KeLowerIrql(OldIrql);
1279 }
1280
1281 /* Return the Old Increment */
1282 return CurrentIncrement;
1283 }
1284
1285 /*
1286 * @implemented
1287 */
1288 KPRIORITY
1289 STDCALL
1290 KeSetPriorityThread(PKTHREAD Thread,
1291 KPRIORITY Priority)
1292 {
1293 KPRIORITY OldPriority;
1294 BOOLEAN Released = FALSE;
1295 KIRQL OldIrql;
1296
1297 /* Lock the Dispatcher Database */
1298 OldIrql = KeAcquireDispatcherDatabaseLock();
1299
1300 /* Save the old Priority */
1301 OldPriority = Thread->Priority;
1302
1303 /* Reset the Quantum and Decrements */
1304 Thread->Quantum = Thread->QuantumReset;
1305 Thread->PriorityDecrement = 0;
1306
1307 /* Set the new Priority */
1308 KiSetPriorityThread(Thread, Priority, &Released);
1309
1310 /* Release Lock if needed */
1311 if (!Released)
1312 {
1313 KeReleaseDispatcherDatabaseLock(OldIrql);
1314 }
1315 else
1316 {
1317 KeLowerIrql(OldIrql);
1318 }
1319
1320 /* Return Old Priority */
1321 return OldPriority;
1322 }
1323
1324 /*
1325 * @implemented
1326 *
1327 * Sets thread's affinity
1328 */
1329 NTSTATUS
1330 STDCALL
1331 KeSetAffinityThread(PKTHREAD Thread,
1332 KAFFINITY Affinity)
1333 {
1334 KIRQL OldIrql;
1335 LONG i;
1336 PKPCR Pcr;
1337 KAFFINITY ProcessorMask;
1338
1339 DPRINT("KeSetAffinityThread(Thread %x, Affinity %x)\n", Thread, Affinity);
1340
1341 /* Verify correct affinity */
1342 if ((Affinity & Thread->ApcStatePointer[0]->Process->Affinity) !=
1343 Affinity || !Affinity)
1344 {
1345 KEBUGCHECK(INVALID_AFFINITY_SET);
1346 }
1347
1348 OldIrql = KeAcquireDispatcherDatabaseLock();
1349
1350 Thread->UserAffinity = Affinity;
1351
1352 if (Thread->SystemAffinityActive == FALSE) {
1353
1354 Thread->Affinity = Affinity;
1355
1356 if (Thread->State == Running) {
1357
1358 ProcessorMask = 1 << KeGetCurrentKPCR()->Number;
1359 if (Thread == KeGetCurrentThread()) {
1360
1361 if (!(Affinity & ProcessorMask)) {
1362
1363 KiDispatchThreadNoLock(Ready);
1364 KeLowerIrql(OldIrql);
1365 return STATUS_SUCCESS;
1366 }
1367
1368 } else {
1369
1370 for (i = 0; i < KeNumberProcessors; i++) {
1371
1372 Pcr = (PKPCR)(KPCR_BASE + i * PAGE_SIZE);
1373 if (Pcr->Prcb->CurrentThread == Thread) {
1374
1375 if (!(Affinity & ProcessorMask)) {
1376
1377 KeReleaseDispatcherDatabaseLockFromDpcLevel();
1378 KiRequestReschedule(i);
1379 KeLowerIrql(OldIrql);
1380 return STATUS_SUCCESS;
1381 }
1382
1383 break;
1384 }
1385 }
1386
1387 ASSERT (i < KeNumberProcessors);
1388 }
1389 }
1390 }
1391
1392 KeReleaseDispatcherDatabaseLock(OldIrql);
1393 return STATUS_SUCCESS;
1394 }
1395
1396 /*
1397 * @implemented
1398 */
1399 /* The Increment Argument seems to be ignored by NT and always 0 when called */
1400 VOID
1401 STDCALL
1402 KeTerminateThread(IN KPRIORITY Increment)
1403 {
1404 KIRQL OldIrql;
1405 PKTHREAD Thread = KeGetCurrentThread();
1406
1407 /* Lock the Dispatcher Database and the APC Queue */
1408 DPRINT("Terminating\n");
1409 OldIrql = KeAcquireDispatcherDatabaseLock();
1410
1411 /* Remove the thread from the list */
1412 RemoveEntryList(&Thread->ThreadListEntry);
1413
1414 /* Insert into the Reaper List */
1415 DPRINT("List: %p\n", PspReaperList);
1416 ((PETHREAD)Thread)->ReaperLink = PspReaperList;
1417 PspReaperList = (PETHREAD)Thread;
1418 DPRINT("List: %p\n", PspReaperList);
1419
1420 /* Check if it's active */
1421 if (PspReaping == FALSE) {
1422
1423 /* Activate it. We use the internal function for speed, and use the Hyper Critical Queue */
1424 PspReaping = TRUE;
1425 DPRINT("Terminating\n");
1426 KiInsertQueue(&ExWorkerQueue[HyperCriticalWorkQueue].WorkerQueue,
1427 &PspReaperWorkItem.List,
1428 FALSE);
1429 }
1430
1431 /* Handle Kernel Queues */
1432 if (Thread->Queue) {
1433
1434 DPRINT("Waking Queue\n");
1435 RemoveEntryList(&Thread->QueueListEntry);
1436 KiWakeQueue(Thread->Queue);
1437 }
1438
1439 /* Signal the thread */
1440 Thread->DispatcherHeader.SignalState = TRUE;
1441 if (IsListEmpty(&Thread->DispatcherHeader.WaitListHead) != TRUE) {
1442
1443 /* Satisfy waits */
1444 KiWaitTest((PVOID)Thread, Increment);
1445 }
1446
1447 /* Find a new Thread */
1448 KiDispatchThreadNoLock(Terminated);
1449 }
1450
1451 /*
1452 * FUNCTION: Tests whether there are any pending APCs for the current thread
1453 * and if so the APCs will be delivered on exit from kernel mode
1454 */
1455 BOOLEAN
1456 STDCALL
1457 KeTestAlertThread(IN KPROCESSOR_MODE AlertMode)
1458 {
1459 KIRQL OldIrql;
1460 PKTHREAD Thread = KeGetCurrentThread();
1461 BOOLEAN OldState;
1462
1463 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
1464
1465 /* Lock the Dispatcher Database and the APC Queue */
1466 OldIrql = KeAcquireDispatcherDatabaseLock();
1467 KiAcquireSpinLock(&Thread->ApcQueueLock);
1468
1469 /* Save the old State */
1470 OldState = Thread->Alerted[AlertMode];
1471
1472 /* If the Thread is Alerted, Clear it */
1473 if (OldState) {
1474
1475 Thread->Alerted[AlertMode] = FALSE;
1476
1477 } else if ((AlertMode != KernelMode) && (!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]))) {
1478
1479 /* If the mode is User and the Queue isn't empty, set Pending */
1480 Thread->ApcState.UserApcPending = TRUE;
1481 }
1482
1483 /* Release Locks and return the Old State */
1484 KiReleaseSpinLock(&Thread->ApcQueueLock);
1485 KeReleaseDispatcherDatabaseLock(OldIrql);
1486 return OldState;
1487 }
1488
1489 VOID
1490 KiServiceCheck (VOID)
1491 {
1492 PKTHREAD Thread = KeGetCurrentThread();
1493
1494 /* Check if we need to inialize Win32 for this Thread */
1495 if (Thread->ServiceTable != KeServiceDescriptorTableShadow) {
1496
1497 /* We do. Initialize it and save the new table */
1498 Thread->ServiceTable = KeServiceDescriptorTableShadow;
1499 PsInitWin32Thread((PETHREAD)Thread);
1500 }
1501 }
1502
1503 /*
1504 *
1505 * NOT EXPORTED
1506 */
1507 NTSTATUS
1508 STDCALL
1509 NtAlertResumeThread(IN HANDLE ThreadHandle,
1510 OUT PULONG SuspendCount)
1511 {
1512 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1513 PETHREAD Thread;
1514 NTSTATUS Status;
1515 ULONG PreviousState;
1516
1517 /* Check if parameters are valid */
1518 if(PreviousMode != KernelMode) {
1519
1520 _SEH_TRY {
1521
1522 ProbeForWriteUlong(SuspendCount);
1523
1524 } _SEH_HANDLE {
1525
1526 Status = _SEH_GetExceptionCode();
1527
1528 } _SEH_END;
1529 }
1530
1531 /* Reference the Object */
1532 Status = ObReferenceObjectByHandle(ThreadHandle,
1533 THREAD_SUSPEND_RESUME,
1534 PsThreadType,
1535 PreviousMode,
1536 (PVOID*)&Thread,
1537 NULL);
1538
1539 /* Check for Success */
1540 if (NT_SUCCESS(Status)) {
1541
1542 /* Call the Kernel Function */
1543 PreviousState = KeAlertResumeThread(&Thread->Tcb);
1544
1545 /* Dereference Object */
1546 ObDereferenceObject(Thread);
1547
1548 if (SuspendCount) {
1549
1550 _SEH_TRY {
1551
1552 *SuspendCount = PreviousState;
1553
1554 } _SEH_HANDLE {
1555
1556 Status = _SEH_GetExceptionCode();
1557
1558 } _SEH_END;
1559 }
1560 }
1561
1562 /* Return status */
1563 return Status;
1564 }
1565
1566 /*
1567 * @implemented
1568 *
1569 * EXPORTED
1570 */
1571 NTSTATUS
1572 STDCALL
1573 NtAlertThread (IN HANDLE ThreadHandle)
1574 {
1575 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1576 PETHREAD Thread;
1577 NTSTATUS Status;
1578
1579 /* Reference the Object */
1580 Status = ObReferenceObjectByHandle(ThreadHandle,
1581 THREAD_SUSPEND_RESUME,
1582 PsThreadType,
1583 PreviousMode,
1584 (PVOID*)&Thread,
1585 NULL);
1586
1587 /* Check for Success */
1588 if (NT_SUCCESS(Status)) {
1589
1590 /*
1591 * Do an alert depending on the processor mode. If some kmode code wants to
1592 * enforce a umode alert it should call KeAlertThread() directly. If kmode
1593 * code wants to do a kmode alert it's sufficient to call it with Zw or just
1594 * use KeAlertThread() directly
1595 */
1596 KeAlertThread(&Thread->Tcb, PreviousMode);
1597
1598 /* Dereference Object */
1599 ObDereferenceObject(Thread);
1600 }
1601
1602 /* Return status */
1603 return Status;
1604 }
1605
1606 NTSTATUS
1607 STDCALL
1608 NtDelayExecution(IN BOOLEAN Alertable,
1609 IN PLARGE_INTEGER DelayInterval)
1610 {
1611 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1612 LARGE_INTEGER SafeInterval;
1613 NTSTATUS Status;
1614
1615 /* Check if parameters are valid */
1616 if(PreviousMode != KernelMode) {
1617
1618 Status = STATUS_SUCCESS;
1619
1620 _SEH_TRY {
1621
1622 /* make a copy on the kernel stack and let DelayInterval point to it so
1623 we don't need to wrap KeDelayExecutionThread in SEH! */
1624 SafeInterval = ProbeForReadLargeInteger(DelayInterval);
1625 DelayInterval = &SafeInterval;
1626
1627 } _SEH_HANDLE {
1628
1629 Status = _SEH_GetExceptionCode();
1630 } _SEH_END;
1631
1632 if (!NT_SUCCESS(Status))
1633 {
1634 return Status;
1635 }
1636 }
1637
1638 /* Call the Kernel Function */
1639 Status = KeDelayExecutionThread(PreviousMode,
1640 Alertable,
1641 DelayInterval);
1642
1643 /* Return Status */
1644 return Status;
1645 }