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