- Invert CONFIG_SMP defines as requested by Hartmut
[reactos.git] / reactos / ntoskrnl / ke / wait.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel
4 * FILE: ntoskrnl/ke/wait.c
5 * PURPOSE: Manages waiting for Dispatcher Objects
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 * Gunnar Dalsnes
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13
14 #define NDEBUG
15 #include <internal/debug.h>
16
17 /* GLOBALS ******************************************************************/
18
19 KSPIN_LOCK DispatcherDatabaseLock;
20
21 /* Tells us if the Timer or Event is a Syncronization or Notification Object */
22 #define TIMER_OR_EVENT_TYPE 0x7L
23
24 /* One of the Reserved Wait Blocks, this one is for the Thread's Timer */
25 #define TIMER_WAIT_BLOCK 0x3L
26
27 /* FUNCTIONS *****************************************************************/
28
29 BOOLEAN
30 __inline
31 FASTCALL
32 KiCheckAlertability(BOOLEAN Alertable,
33 PKTHREAD Thread,
34 KPROCESSOR_MODE WaitMode,
35 PNTSTATUS Status)
36 {
37 /*
38 * At this point, we have to do a wait, so make sure we can make
39 * the thread Alertable if requested.
40 */
41 if (Alertable)
42 {
43 /* If the Thread is Alerted, set the Wait Status accordingly */
44 if (Thread->Alerted[(int)WaitMode])
45 {
46 Thread->Alerted[(int)WaitMode] = FALSE;
47 DPRINT("Thread was Alerted in the specified Mode\n");
48 *Status = STATUS_ALERTED;
49 return TRUE;
50 }
51 else if ((WaitMode != KernelMode) &&
52 (!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])))
53 {
54 /* If there are User APCs Pending, then we can't really be alertable */
55 DPRINT("APCs are Pending\n");
56 Thread->ApcState.UserApcPending = TRUE;
57 *Status = STATUS_USER_APC;
58 return TRUE;
59 }
60 else if (Thread->Alerted[KernelMode])
61 {
62 /*
63 * The thread is not alerted in the mode given, but it is alerted
64 * in kernel-mode.
65 */
66 Thread->Alerted[KernelMode] = FALSE;
67 DPRINT("Thread was Alerted in Kernel-Mode\n");
68 *Status = STATUS_ALERTED;
69 return TRUE;
70 }
71 }
72 else if ((WaitMode != KernelMode) &&
73 (Thread->ApcState.UserApcPending))
74 {
75 /*
76 * If there are User APCs Pending and we are waiting in usermode,
77 * then we must notify the caller
78 */
79 DPRINT("APCs are Pending\n");
80 *Status = STATUS_USER_APC;
81 return TRUE;
82 }
83
84 /* Stay in the loop */
85 return FALSE;
86 }
87
88 /*
89 * @implemented
90 *
91 * FUNCTION: Puts the current thread into an alertable or nonalertable
92 * wait state for a given internal
93 * ARGUMENTS:
94 * WaitMode = Processor mode in which the caller is waiting
95 * Altertable = Specifies if the wait is alertable
96 * Interval = Specifies the interval to wait
97 * RETURNS: Status
98 */
99 NTSTATUS
100 STDCALL
101 KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
102 BOOLEAN Alertable,
103 PLARGE_INTEGER Interval)
104 {
105 PKWAIT_BLOCK TimerWaitBlock;
106 PKTIMER ThreadTimer;
107 PKTHREAD CurrentThread = KeGetCurrentThread();
108 NTSTATUS Status;
109 DPRINT("Entering KeDelayExecutionThread\n");
110
111 /* Check if the lock is already held */
112 if (CurrentThread->WaitNext)
113 {
114 /* Lock is held, disable Wait Next */
115 DPRINT("Lock is held\n");
116 CurrentThread->WaitNext = FALSE;
117 }
118 else
119 {
120 /* Lock not held, acquire it */
121 DPRINT("Lock is not held, acquiring\n");
122 CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
123 }
124
125 /* Use built-in Wait block */
126 TimerWaitBlock = &CurrentThread->WaitBlock[TIMER_WAIT_BLOCK];
127
128 /* Start Wait Loop */
129 do
130 {
131 /* Check if a kernel APC is pending and we were below APC_LEVEL */
132 if ((CurrentThread->ApcState.KernelApcPending) &&
133 (CurrentThread->WaitIrql < APC_LEVEL))
134 {
135 /* Unlock the dispatcher */
136 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
137 goto SkipWait;
138 }
139
140 /* Chceck if we can do an alertable wait, if requested */
141 if (KiCheckAlertability(Alertable, CurrentThread, WaitMode, &Status)) break;
142
143 /* Set Timer */
144 ThreadTimer = &CurrentThread->Timer;
145
146 /* Setup the Wait Block */
147 CurrentThread->WaitBlockList = TimerWaitBlock;
148 TimerWaitBlock->Object = (PVOID)ThreadTimer;
149 TimerWaitBlock->Thread = CurrentThread;
150 TimerWaitBlock->WaitKey = (USHORT)STATUS_TIMEOUT;
151 TimerWaitBlock->WaitType = WaitAny;
152 TimerWaitBlock->NextWaitBlock = TimerWaitBlock;
153
154 /* Link the timer to this Wait Block */
155 InitializeListHead(&ThreadTimer->Header.WaitListHead);
156 InsertTailList(&ThreadTimer->Header.WaitListHead, &TimerWaitBlock->WaitListEntry);
157
158 /* Insert the Timer into the Timer Lists and enable it */
159 if (!KiInsertTimer(ThreadTimer, *Interval))
160 {
161 /* FIXME: The timer already expired, we should find a new ready thread */
162 Status = STATUS_SUCCESS;
163 break;
164 }
165
166 /* Handle Kernel Queues */
167 if (CurrentThread->Queue)
168 {
169 DPRINT("Waking Queue\n");
170 KiWakeQueue(CurrentThread->Queue);
171 }
172
173 /* Setup the wait information */
174 CurrentThread->Alertable = Alertable;
175 CurrentThread->WaitMode = WaitMode;
176 CurrentThread->WaitReason = DelayExecution;
177 CurrentThread->WaitTime = 0;
178 CurrentThread->State = Waiting;
179
180 /* Find a new thread to run */
181 DPRINT("Swapping threads\n");
182 Status = KiSwapThread();
183
184 /* Check if we were executing an APC or if we timed out */
185 if (Status != STATUS_KERNEL_APC)
186 {
187 /* This is a good thing */
188 if (Status == STATUS_TIMEOUT) Status = STATUS_SUCCESS;
189
190 /* Return Status */
191 return Status;
192 }
193
194 /* FIXME: Fixup interval */
195
196 /* Acquire again the lock */
197 SkipWait:
198 DPRINT("Looping again\n");
199 CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
200 }
201 while (TRUE);
202
203 /* Release the Lock, we are done */
204 DPRINT("Returning from KeDelayExecutionThread(), %x. Status: %d\n",
205 KeGetCurrentThread(), Status);
206 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
207 return Status;
208 }
209
210 /*
211 * @implemented
212 *
213 * FUNCTION: Puts the current thread into a wait state until the
214 * given dispatcher object is set to signalled
215 * ARGUMENTS:
216 * Object = Object to wait on
217 * WaitReason = Reason for the wait (debugging aid)
218 * WaitMode = Can be KernelMode or UserMode, if UserMode then
219 * user-mode APCs can be delivered and the thread's
220 * stack can be paged out
221 * Altertable = Specifies if the wait is a alertable
222 * Timeout = Optional timeout value
223 * RETURNS: Status
224 */
225 NTSTATUS
226 STDCALL
227 KeWaitForSingleObject(PVOID Object,
228 KWAIT_REASON WaitReason,
229 KPROCESSOR_MODE WaitMode,
230 BOOLEAN Alertable,
231 PLARGE_INTEGER Timeout)
232 {
233 PKMUTANT CurrentObject;
234 PKWAIT_BLOCK WaitBlock;
235 PKWAIT_BLOCK TimerWaitBlock;
236 PKTIMER ThreadTimer;
237 PKTHREAD CurrentThread = KeGetCurrentThread();
238 NTSTATUS Status;
239 NTSTATUS WaitStatus;
240 DPRINT("Entering KeWaitForSingleObject\n");
241
242 /* Check if the lock is already held */
243 if (CurrentThread->WaitNext)
244 {
245 /* Lock is held, disable Wait Next */
246 DPRINT("Lock is held\n");
247 CurrentThread->WaitNext = FALSE;
248 }
249 else
250 {
251 /* Lock not held, acquire it */
252 DPRINT("Lock is not held, acquiring\n");
253 CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
254 }
255
256 /* Start the actual Loop */
257 do
258 {
259 /* Check if a kernel APC is pending and we were below APC_LEVEL */
260 if ((CurrentThread->ApcState.KernelApcPending) &&
261 (CurrentThread->WaitIrql < APC_LEVEL))
262 {
263 /* Unlock the dispatcher */
264 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
265 goto SkipWait;
266 }
267
268 /* Get the current Wait Status */
269 WaitStatus = CurrentThread->WaitStatus;
270
271 /* Append wait block to the KTHREAD wait block list */
272 CurrentThread->WaitBlockList = WaitBlock = &CurrentThread->WaitBlock[0];
273
274 /* Get the Current Object */
275 CurrentObject = (PKMUTANT)Object;
276
277 /* Check if it's a mutant */
278 if (CurrentObject->Header.Type == MutantObject)
279 {
280 /* Check its signal state or if we own it */
281 if ((CurrentObject->Header.SignalState > 0) ||
282 (CurrentThread == CurrentObject->OwnerThread))
283 {
284 /* Just unwait this guy and exit */
285 if (CurrentObject->Header.SignalState != (LONG)MINLONG)
286 {
287 /* It has a normal signal state, so unwait it and return */
288 KiSatisfyMutantWait(CurrentObject, CurrentThread);
289 Status = STATUS_WAIT_0;
290 goto DontWait;
291 }
292 else
293 {
294 /* According to wasm.ru, we must raise this exception (tested and true) */
295 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
296 ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
297 }
298 }
299 }
300 else if (CurrentObject->Header.SignalState > 0)
301 {
302 /* Another satisfied object */
303 KiSatisfyNonMutantWait(CurrentObject, CurrentThread);
304 Status = STATUS_WAIT_0;
305 goto DontWait;
306 }
307
308 /* Set up the Wait Block */
309 WaitBlock->Object = CurrentObject;
310 WaitBlock->Thread = CurrentThread;
311 WaitBlock->WaitKey = (USHORT)(STATUS_WAIT_0);
312 WaitBlock->WaitType = WaitAny;
313 WaitBlock->NextWaitBlock = WaitBlock;
314
315 /* Make sure we can satisfy the Alertable request */
316 if (KiCheckAlertability(Alertable, CurrentThread, WaitMode, &Status)) break;
317
318 /* Set the Wait Status */
319 CurrentThread->WaitStatus = Status;
320
321 /* Enable the Timeout Timer if there was any specified */
322 if (Timeout)
323 {
324 /* Fail if the timeout interval is actually 0 */
325 if (!Timeout->QuadPart)
326 {
327 /* Return a timeout */
328 Status = STATUS_TIMEOUT;
329 goto DontWait;
330 }
331
332 /* Point to Timer Wait Block and Thread Timer */
333 TimerWaitBlock = &CurrentThread->WaitBlock[TIMER_WAIT_BLOCK];
334 ThreadTimer = &CurrentThread->Timer;
335
336 /* Connect the Timer Wait Block */
337 WaitBlock->NextWaitBlock = TimerWaitBlock;
338
339 /* Set up the Timer Wait Block */
340 TimerWaitBlock->Object = (PVOID)ThreadTimer;
341 TimerWaitBlock->Thread = CurrentThread;
342 TimerWaitBlock->WaitKey = STATUS_TIMEOUT;
343 TimerWaitBlock->WaitType = WaitAny;
344 TimerWaitBlock->NextWaitBlock = WaitBlock;
345
346 /* Link the timer to this Wait Block */
347 InitializeListHead(&ThreadTimer->Header.WaitListHead);
348 InsertTailList(&ThreadTimer->Header.WaitListHead,
349 &TimerWaitBlock->WaitListEntry);
350
351 /* Insert the Timer into the Timer Lists and enable it */
352 if (!KiInsertTimer(ThreadTimer, *Timeout))
353 {
354 /* Return a timeout if we couldn't insert the timer */
355 Status = STATUS_TIMEOUT;
356 goto DontWait;
357 }
358 }
359
360 /* Link the Object to this Wait Block */
361 InsertTailList(&CurrentObject->Header.WaitListHead,
362 &WaitBlock->WaitListEntry);
363
364 /* Handle Kernel Queues */
365 if (CurrentThread->Queue)
366 {
367 DPRINT("Waking Queue\n");
368 KiWakeQueue(CurrentThread->Queue);
369 }
370
371 /* Setup the wait information */
372 CurrentThread->Alertable = Alertable;
373 CurrentThread->WaitMode = WaitMode;
374 CurrentThread->WaitReason = WaitReason;
375 CurrentThread->WaitTime = 0;
376 CurrentThread->State = Waiting;
377
378 /* Find a new thread to run */
379 DPRINT("Swapping threads\n");
380 Status = KiSwapThread();
381
382 /* Check if we were executing an APC */
383 if (Status != STATUS_KERNEL_APC)
384 {
385 /* Return Status */
386 return Status;
387 }
388
389 /* Check if we had a timeout */
390 if (Timeout)
391 {
392 /* FIXME: Fixup interval */
393 }
394
395 /* Acquire again the lock */
396 SkipWait:
397 DPRINT("Looping again\n");
398 CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
399 }
400 while (TRUE);
401
402 /* Release the Lock, we are done */
403 DPRINT("Returning from KeWaitForMultipleObjects(), %x. Status: %d\n",
404 KeGetCurrentThread(), Status);
405 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
406 return Status;
407
408 DontWait:
409 /* Adjust the Quantum */
410 KiAdjustQuantumThread(CurrentThread);
411
412 /* Release & Return */
413 DPRINT("Quick-return from KeWaitForMultipleObjects(), %x. Status: %d\n.",
414 KeGetCurrentThread(), Status);
415 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
416 return Status;
417 }
418
419 /*
420 * @implemented
421 */
422 NTSTATUS STDCALL
423 KeWaitForMultipleObjects(ULONG Count,
424 PVOID Object[],
425 WAIT_TYPE WaitType,
426 KWAIT_REASON WaitReason,
427 KPROCESSOR_MODE WaitMode,
428 BOOLEAN Alertable,
429 PLARGE_INTEGER Timeout,
430 PKWAIT_BLOCK WaitBlockArray)
431 {
432 PKMUTANT CurrentObject;
433 PKWAIT_BLOCK WaitBlock;
434 PKWAIT_BLOCK TimerWaitBlock;
435 PKTIMER ThreadTimer;
436 PKTHREAD CurrentThread = KeGetCurrentThread();
437 ULONG AllObjectsSignaled;
438 ULONG WaitIndex;
439 NTSTATUS Status;
440 NTSTATUS WaitStatus;
441 DPRINT("Entering KeWaitForMultipleObjects(Count %lu Object[] %p) "
442 "PsGetCurrentThread() %x, Timeout %x\n",
443 Count, Object, PsGetCurrentThread(), Timeout);
444
445 /* Set the Current Thread */
446 CurrentThread = KeGetCurrentThread();
447
448 /* Check if the lock is already held */
449 if (CurrentThread->WaitNext)
450 {
451 /* Lock is held, disable Wait Next */
452 DPRINT("Lock is held\n");
453 CurrentThread->WaitNext = FALSE;
454 }
455 else
456 {
457 /* Lock not held, acquire it */
458 DPRINT("Lock is not held, acquiring\n");
459 CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
460 }
461
462 /* Make sure the Wait Count is valid for the Thread and Maximum Wait Objects */
463 if (!WaitBlockArray)
464 {
465 /* Check in regards to the Thread Object Limit */
466 if (Count > THREAD_WAIT_OBJECTS) KEBUGCHECK(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
467
468 /* Use the Thread's Wait Block */
469 WaitBlockArray = &CurrentThread->WaitBlock[0];
470 }
471 else
472 {
473 /* Using our own Block Array. Check in regards to System Object Limit */
474 if (Count > MAXIMUM_WAIT_OBJECTS) KEBUGCHECK(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
475 }
476
477 /* Start the actual Loop */
478 do
479 {
480 /* Check if a kernel APC is pending and we were below APC_LEVEL */
481 if ((CurrentThread->ApcState.KernelApcPending) &&
482 (CurrentThread->WaitIrql < APC_LEVEL))
483 {
484 /* Unlock the dispatcher */
485 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
486 goto SkipWait;
487 }
488
489 /* Get the current Wait Status */
490 WaitStatus = CurrentThread->WaitStatus;
491
492 /* Append wait block to the KTHREAD wait block list */
493 CurrentThread->WaitBlockList = WaitBlock = WaitBlockArray;
494
495 /* Check if the wait is (already) satisfied */
496 AllObjectsSignaled = TRUE;
497
498 /* First, we'll try to satisfy the wait directly */
499 for (WaitIndex = 0; WaitIndex < Count; WaitIndex++)
500 {
501 /* Get the Current Object */
502 CurrentObject = (PKMUTANT)Object[WaitIndex];
503
504 /* Check the type of wait */
505 if (WaitType == WaitAny)
506 {
507 /* Check if the Object is a mutant */
508 if (CurrentObject->Header.Type == MutantObject)
509 {
510 /* Check if it's signaled */
511 if ((CurrentObject->Header.SignalState > 0) ||
512 (CurrentThread == CurrentObject->OwnerThread))
513 {
514 /* This is a Wait Any, so just unwait this and exit */
515 if (CurrentObject->Header.SignalState != (LONG)MINLONG)
516 {
517 /* Normal signal state, so unwait it and return */
518 KiSatisfyMutantWait(CurrentObject, CurrentThread);
519 Status = STATUS_WAIT_0 | WaitIndex;
520 goto DontWait;
521 }
522 else
523 {
524 /* According to wasm.ru, we must raise this exception (tested and true) */
525 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
526 ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
527 }
528 }
529 }
530 else if (CurrentObject->Header.SignalState > 0)
531 {
532 /* Another signaled object, unwait and return */
533 KiSatisfyNonMutantWait(CurrentObject, CurrentThread);
534 Status = WaitIndex;
535 goto DontWait;
536 }
537 }
538 else
539 {
540 /* Check if we're dealing with a mutant again */
541 if (CurrentObject->Header.Type == MutantObject)
542 {
543 /* Check if it has an invalid count */
544 if ((CurrentThread == CurrentObject->OwnerThread) &&
545 (CurrentObject->Header.SignalState == MINLONG))
546 {
547 /* Raise an exception */
548 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
549 ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
550 }
551 else if ((CurrentObject->Header.SignalState <= 0) &&
552 (CurrentThread != CurrentObject->OwnerThread))
553 {
554 /* We don't own it, can't satisfy the wait */
555 AllObjectsSignaled = FALSE;
556 }
557 }
558 else if (CurrentObject->Header.SignalState <= 0)
559 {
560 /* Not signaled, can't satisfy */
561 AllObjectsSignaled = FALSE;
562 }
563 }
564
565 /* Set up a Wait Block for this Object */
566 WaitBlock->Object = CurrentObject;
567 WaitBlock->Thread = CurrentThread;
568 WaitBlock->WaitKey = (USHORT)WaitIndex;
569 WaitBlock->WaitType = (USHORT)WaitType;
570 WaitBlock->NextWaitBlock = WaitBlock + 1;
571
572 /* Move to the next Wait Block */
573 WaitBlock = WaitBlock->NextWaitBlock;
574 }
575
576 /* Return to the Root Wait Block */
577 WaitBlock--;
578 WaitBlock->NextWaitBlock = WaitBlockArray;
579
580 /* Check if this is a Wait All and all the objects are signaled */
581 if ((WaitType == WaitAll) && (AllObjectsSignaled))
582 {
583 /* Return to the Root Wait Block */
584 WaitBlock = CurrentThread->WaitBlockList;
585
586 /* Satisfy their Waits and return to the caller */
587 KiSatisifyMultipleObjectWaits(WaitBlock);
588 Status = STATUS_WAIT_0;
589 goto DontWait;
590 }
591
592 /* Make sure we can satisfy the Alertable request */
593 if (KiCheckAlertability(Alertable, CurrentThread, WaitMode, &Status)) break;
594
595 /* Set the Wait Status */
596 CurrentThread->WaitStatus = Status;
597
598 /* Enable the Timeout Timer if there was any specified */
599 if (Timeout)
600 {
601 /* Make sure the timeout interval isn't actually 0 */
602 if (!Timeout->QuadPart)
603 {
604 /* Return a timeout */
605 Status = STATUS_TIMEOUT;
606 goto DontWait;
607 }
608
609 /* Point to Timer Wait Block and Thread Timer */
610 TimerWaitBlock = &CurrentThread->WaitBlock[TIMER_WAIT_BLOCK];
611 ThreadTimer = &CurrentThread->Timer;
612
613 /* Connect the Timer Wait Block */
614 WaitBlock->NextWaitBlock = TimerWaitBlock;
615
616 /* Set up the Timer Wait Block */
617 TimerWaitBlock->Object = (PVOID)ThreadTimer;
618 TimerWaitBlock->Thread = CurrentThread;
619 TimerWaitBlock->WaitKey = STATUS_TIMEOUT;
620 TimerWaitBlock->WaitType = WaitAny;
621 TimerWaitBlock->NextWaitBlock = WaitBlockArray;
622
623 /* Link the timer to this Wait Block */
624 InitializeListHead(&ThreadTimer->Header.WaitListHead);
625
626 /* Insert the Timer into the Timer Lists and enable it */
627 if (!KiInsertTimer(ThreadTimer, *Timeout))
628 {
629 /* Return a timeout if we couldn't insert the timer */
630 Status = STATUS_TIMEOUT;
631 goto DontWait;
632 }
633 }
634
635 /* Insert into Object's Wait List*/
636 WaitBlock = CurrentThread->WaitBlockList;
637 do
638 {
639 /* Get the Current Object */
640 CurrentObject = WaitBlock->Object;
641
642 /* Link the Object to this Wait Block */
643 InsertTailList(&CurrentObject->Header.WaitListHead,
644 &WaitBlock->WaitListEntry);
645
646 /* Move to the next Wait Block */
647 WaitBlock = WaitBlock->NextWaitBlock;
648 }
649 while (WaitBlock != WaitBlockArray);
650
651 /* Handle Kernel Queues */
652 if (CurrentThread->Queue)
653 {
654 DPRINT("Waking Queue\n");
655 KiWakeQueue(CurrentThread->Queue);
656 }
657
658 /* Setup the wait information */
659 CurrentThread->Alertable = Alertable;
660 CurrentThread->WaitMode = WaitMode;
661 CurrentThread->WaitReason = WaitReason;
662 CurrentThread->WaitTime = 0;
663 CurrentThread->State = Waiting;
664
665 /* Find a new thread to run */
666 DPRINT("Swapping threads\n");
667 Status = KiSwapThread();
668
669 /* Check if we were executing an APC */
670 DPRINT("Thread is back\n");
671 if (Status != STATUS_KERNEL_APC)
672 {
673 /* Return Status */
674 return Status;
675 }
676
677 /* Check if we had a timeout */
678 if (Timeout)
679 {
680 /* FIXME: Fixup interval */
681 }
682
683 /* Acquire again the lock */
684 SkipWait:
685 DPRINT("Looping again\n");
686 CurrentThread->WaitIrql = KeAcquireDispatcherDatabaseLock();
687 }
688 while (TRUE);
689
690 /* Release the Lock, we are done */
691 DPRINT("Returning, %x. Status: %d\n", KeGetCurrentThread(), Status);
692 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
693 return Status;
694
695 DontWait:
696 /* Adjust the Quantum */
697 KiAdjustQuantumThread(CurrentThread);
698
699 /* Release & Return */
700 DPRINT("Returning, %x. Status: %d\n. We did not wait.",
701 KeGetCurrentThread(), Status);
702 KeReleaseDispatcherDatabaseLock(CurrentThread->WaitIrql);
703 return Status;
704 }
705
706 VOID
707 FASTCALL
708 KiWaitTest(PVOID ObjectPointer,
709 KPRIORITY Increment)
710 {
711 PLIST_ENTRY WaitEntry;
712 PLIST_ENTRY WaitList;
713 PKWAIT_BLOCK CurrentWaitBlock;
714 PKWAIT_BLOCK NextWaitBlock;
715 PKTHREAD WaitThread;
716 PKMUTANT FirstObject = ObjectPointer, Object;
717
718 /* Loop the Wait Entries */
719 DPRINT("KiWaitTest for Object: %x\n", FirstObject);
720 WaitList = &FirstObject->Header.WaitListHead;
721 WaitEntry = WaitList->Flink;
722 while ((FirstObject->Header.SignalState > 0) && (WaitEntry != WaitList))
723 {
724 /* Get the current wait block */
725 CurrentWaitBlock = CONTAINING_RECORD(WaitEntry,
726 KWAIT_BLOCK,
727 WaitListEntry);
728 WaitThread = CurrentWaitBlock->Thread;
729
730 /* Check the current Wait Mode */
731 if (CurrentWaitBlock->WaitType == WaitAny)
732 {
733 /* Easy case, satisfy only this wait */
734 DPRINT("Satisfiying a Wait any\n");
735 WaitEntry = WaitEntry->Blink;
736 KiSatisfyObjectWait(FirstObject, WaitThread);
737 }
738 else
739 {
740 /* Everything must be satisfied */
741 DPRINT("Checking for a Wait All\n");
742 NextWaitBlock = CurrentWaitBlock->NextWaitBlock;
743
744 /* Loop first to make sure they are valid */
745 while (NextWaitBlock != CurrentWaitBlock)
746 {
747 /* Check if the object is signaled */
748 Object = NextWaitBlock->Object;
749 DPRINT("Checking: %p %d\n",
750 Object, Object->Header.SignalState);
751 if (NextWaitBlock->WaitKey != STATUS_TIMEOUT)
752 {
753 /* Check if this is a mutant */
754 if ((Object->Header.Type == MutantObject) &&
755 (Object->Header.SignalState <= 0) &&
756 (WaitThread == Object->OwnerThread))
757 {
758 /* It's a signaled mutant */
759 }
760 else if (Object->Header.SignalState <= 0)
761 {
762 /* Skip the unwaiting */
763 goto SkipUnwait;
764 }
765 }
766
767 /* Go to the next Wait block */
768 NextWaitBlock = NextWaitBlock->NextWaitBlock;
769 }
770
771 /* All the objects are signaled, we can satisfy */
772 DPRINT("Satisfiying a Wait All\n");
773 WaitEntry = WaitEntry->Blink;
774 KiSatisifyMultipleObjectWaits(CurrentWaitBlock);
775 }
776
777 /* All waits satisfied, unwait the thread */
778 DPRINT("Unwaiting the Thread\n");
779 KiAbortWaitThread(WaitThread, CurrentWaitBlock->WaitKey, Increment);
780
781 SkipUnwait:
782 /* Next entry */
783 WaitEntry = WaitEntry->Flink;
784 }
785
786 DPRINT("Done\n");
787 }
788
789 /* Must be called with the dispatcher lock held */
790 VOID
791 FASTCALL
792 KiAbortWaitThread(PKTHREAD Thread,
793 NTSTATUS WaitStatus,
794 KPRIORITY Increment)
795 {
796 PKWAIT_BLOCK WaitBlock;
797
798 /* If we are blocked, we must be waiting on something also */
799 DPRINT("KiAbortWaitThread: %x, Status: %x, %x \n",
800 Thread, WaitStatus, Thread->WaitBlockList);
801
802 /* Remove the Wait Blocks from the list */
803 DPRINT("Removing waits\n");
804 WaitBlock = Thread->WaitBlockList;
805 do
806 {
807 /* Remove it */
808 DPRINT("Removing Waitblock: %x, %x\n",
809 WaitBlock, WaitBlock->NextWaitBlock);
810 RemoveEntryList(&WaitBlock->WaitListEntry);
811
812 /* Go to the next one */
813 WaitBlock = WaitBlock->NextWaitBlock;
814 } while (WaitBlock != Thread->WaitBlockList);
815
816 /* Check if there's a Thread Timer */
817 if (Thread->Timer.Header.Inserted)
818 {
819 /* Cancel the Thread Timer with the no-lock fastpath */
820 DPRINT("Removing the Thread's Timer\n");
821 Thread->Timer.Header.Inserted = FALSE;
822 RemoveEntryList(&Thread->Timer.TimerListEntry);
823 }
824
825 /* Increment the Queue's active threads */
826 if (Thread->Queue)
827 {
828 DPRINT("Incrementing Queue's active threads\n");
829 Thread->Queue->CurrentCount++;
830 }
831
832 /* Reschedule the Thread */
833 DPRINT("Unblocking the Thread\n");
834 KiUnblockThread(Thread, &WaitStatus, 0);
835 }
836
837 VOID
838 FASTCALL
839 KiAcquireFastMutex(IN PFAST_MUTEX FastMutex)
840 {
841 /* Increase contention count */
842 FastMutex->Contention++;
843
844 /* Wait for the event */
845 KeWaitForSingleObject(&FastMutex->Gate,
846 WrMutex,
847 KernelMode,
848 FALSE,
849 NULL);
850 }
851
852 VOID
853 FASTCALL
854 KiExitDispatcher(KIRQL OldIrql)
855 {
856 /* If it's the idle thread, dispatch */
857 if (!(KeIsExecutingDpc()) &&
858 (OldIrql < DISPATCH_LEVEL) &&
859 (KeGetCurrentThread()) &&
860 (KeGetCurrentThread() == KeGetCurrentPrcb()->IdleThread))
861 {
862 KiDispatchThreadNoLock(Ready);
863 }
864
865 /* Lower irql back */
866 KeLowerIrql(OldIrql);
867 }
868
869 /* EOF */