[NTOS:MM] Quick fix: use SIZE_T instead of ULONG, because ULONG is 32-bit and on...
[reactos.git] / ntoskrnl / ke / gate.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ke/gate.c
5 * PURPOSE: Implements the Gate Dispatcher Object
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES *****************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* FUNCTIONS ****************************************************************/
16
17 VOID
18 FASTCALL
19 KeInitializeGate(IN PKGATE Gate)
20 {
21 /* Initialize the Dispatcher Header */
22 Gate->Header.Type = GateObject;
23 Gate->Header.Signalling = FALSE;
24 Gate->Header.Size = sizeof(KGATE) / sizeof(ULONG);
25 Gate->Header.SignalState = 0;
26 InitializeListHead(&(Gate->Header.WaitListHead));
27 }
28
29 VOID
30 FASTCALL
31 KeWaitForGate(IN PKGATE Gate,
32 IN KWAIT_REASON WaitReason,
33 IN KPROCESSOR_MODE WaitMode)
34 {
35 KLOCK_QUEUE_HANDLE ApcLock;
36 PKTHREAD Thread = KeGetCurrentThread();
37 PKWAIT_BLOCK GateWaitBlock;
38 LONG_PTR Status;
39 PKQUEUE Queue;
40 ASSERT_GATE(Gate);
41 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
42
43 /* Start wait loop */
44 do
45 {
46 /* Acquire the APC lock */
47 KiAcquireApcLock(Thread, &ApcLock);
48
49 /* Check if a kernel APC is pending and we're below APC_LEVEL */
50 if ((Thread->ApcState.KernelApcPending) &&
51 !(Thread->SpecialApcDisable) &&
52 (ApcLock.OldIrql < APC_LEVEL))
53 {
54 /* Release the lock, this will fire the APC */
55 KiReleaseApcLock(&ApcLock);
56 }
57 else
58 {
59 /* Check if we have a queue and lock the dispatcher if so */
60 Queue = Thread->Queue;
61 if (Queue) KiAcquireDispatcherLockAtDpcLevel();
62
63 /* Lock the thread */
64 KiAcquireThreadLock(Thread);
65
66 /* Lock the gate */
67 KiAcquireDispatcherObject(&Gate->Header);
68
69 /* Check if it's already signaled */
70 if (Gate->Header.SignalState)
71 {
72 /* Unsignal it */
73 Gate->Header.SignalState = 0;
74
75 /* Release the gate and thread locks */
76 KiReleaseDispatcherObject(&Gate->Header);
77 KiReleaseThreadLock(Thread);
78
79 /* Release the gate lock */
80 if (Queue) KiReleaseDispatcherLockFromDpcLevel();
81
82 /* Release the APC lock and return */
83 KiReleaseApcLock(&ApcLock);
84 break;
85 }
86
87 /* Setup a Wait Block */
88 GateWaitBlock = &Thread->WaitBlock[0];
89 GateWaitBlock->Object = (PVOID)Gate;
90 GateWaitBlock->Thread = Thread;
91
92 /* Set the Thread Wait Data */
93 Thread->WaitMode = WaitMode;
94 Thread->WaitReason = WaitReason;
95 Thread->WaitIrql = ApcLock.OldIrql;
96 Thread->State = GateWait;
97 Thread->GateObject = Gate;
98
99 /* Insert into the Wait List */
100 InsertTailList(&Gate->Header.WaitListHead,
101 &GateWaitBlock->WaitListEntry);
102
103 /* Release the gate lock */
104 KiReleaseDispatcherObject(&Gate->Header);
105
106 /* Set swap busy */
107 KiSetThreadSwapBusy(Thread);
108
109 /* Release the thread lock */
110 KiReleaseThreadLock(Thread);
111
112 /* Check if we had a queue */
113 if (Queue)
114 {
115 /* Wake it up */
116 KiActivateWaiterQueue(Queue);
117
118 /* Release the dispatcher lock */
119 KiReleaseDispatcherLockFromDpcLevel();
120 }
121
122 /* Release the APC lock but stay at DPC level */
123 KiReleaseApcLockFromDpcLevel(&ApcLock);
124
125 /* Find a new thread to run */
126 Status = KiSwapThread(Thread, KeGetCurrentPrcb());
127
128 /* Make sure we weren't executing an APC */
129 if (Status == STATUS_SUCCESS) return;
130 }
131 } while (TRUE);
132 }
133
134 VOID
135 FASTCALL
136 KeSignalGateBoostPriority(IN PKGATE Gate)
137 {
138 PKTHREAD WaitThread;
139 PKWAIT_BLOCK WaitBlock;
140 KIRQL OldIrql;
141 ASSERT_GATE(Gate);
142 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
143
144 /* Start entry loop */
145 for (;;)
146 {
147 /* Raise to synch level */
148 OldIrql = KeRaiseIrqlToSynchLevel();
149
150 /* Lock the gate */
151 KiAcquireDispatcherObject(&Gate->Header);
152
153 /* Make sure we're not already signaled or that the list is empty */
154 if (Gate->Header.SignalState) break;
155
156 /* Check if our wait list is empty */
157 if (IsListEmpty(&Gate->Header.WaitListHead))
158 {
159 /* It is, so signal the event */
160 Gate->Header.SignalState = 1;
161 break;
162 }
163 else
164 {
165 /* Get WaitBlock */
166 WaitBlock = CONTAINING_RECORD(Gate->Header.WaitListHead.Flink,
167 KWAIT_BLOCK,
168 WaitListEntry);
169
170 /* Get the Associated thread */
171 WaitThread = WaitBlock->Thread;
172
173 /* Check to see if the waiting thread is locked */
174 if (KiTryThreadLock(WaitThread))
175 {
176 /* Unlock the gate */
177 KiReleaseDispatcherObject(&Gate->Header);
178
179 /* Lower IRQL and loop again */
180 KeLowerIrql(OldIrql);
181 continue;
182 }
183
184 /* Remove it */
185 RemoveEntryList(&WaitBlock->WaitListEntry);
186
187 /* Clear wait status */
188 WaitThread->WaitStatus = STATUS_SUCCESS;
189
190 /* Set state and CPU */
191 WaitThread->State = DeferredReady;
192 WaitThread->DeferredProcessor = KeGetCurrentPrcb()->Number;
193
194 /* Release the gate lock */
195 KiReleaseDispatcherObject(&Gate->Header);
196
197 /* Release the thread lock */
198 KiReleaseThreadLock(WaitThread);
199
200 /* FIXME: Boosting */
201
202 /* Check if we have a queue */
203 if (WaitThread->Queue)
204 {
205 /* Acquire the dispatcher lock */
206 KiAcquireDispatcherLockAtDpcLevel();
207
208 /* Check if we still have one */
209 if (WaitThread->Queue)
210 {
211 /* Increment active threads */
212 WaitThread->Queue->CurrentCount++;
213 }
214
215 /* Release lock */
216 KiReleaseDispatcherLockFromDpcLevel();
217 }
218
219 /* Make the thread ready */
220 KiReadyThread(WaitThread);
221
222 /* Exit the dispatcher */
223 KiExitDispatcher(OldIrql);
224 return;
225 }
226 }
227
228 /* If we got here, then there's no rescheduling. */
229 KiReleaseDispatcherObject(&Gate->Header);
230 KeLowerIrql(OldIrql);
231 }
232
233 /* EOF */