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