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