Fix merge r65567.
[reactos.git] / ntoskrnl / ob / obwait.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ob/obwait.c
5 * PURPOSE: Handles Waiting on Objects
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 * Thomas Weidenmueller (w3seek@reactos.org)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* FUNCTIONS *****************************************************************/
17
18 /*++
19 * @name NtWaitForMultipleObjects
20 * @implemented NT4
21 *
22 * The NtWaitForMultipleObjects routine <FILLMEIN>
23 *
24 * @param ObjectCount
25 * <FILLMEIN>
26 *
27 * @param HandleArray
28 * <FILLMEIN>
29 *
30 * @param WaitType
31 * <FILLMEIN>
32 *
33 * @param Alertable
34 * <FILLMEIN>
35 *
36 * @param TimeOut
37 * <FILLMEIN>
38 *
39 * @return STATUS_SUCCESS or appropriate error value.
40 *
41 * @remarks None.
42 *
43 *--*/
44 NTSTATUS
45 NTAPI
46 NtWaitForMultipleObjects(IN ULONG ObjectCount,
47 IN PHANDLE HandleArray,
48 IN WAIT_TYPE WaitType,
49 IN BOOLEAN Alertable,
50 IN PLARGE_INTEGER TimeOut OPTIONAL)
51 {
52 PKWAIT_BLOCK WaitBlockArray = NULL;
53 HANDLE Handles[MAXIMUM_WAIT_OBJECTS], KernelHandle;
54 PVOID Objects[MAXIMUM_WAIT_OBJECTS];
55 PVOID WaitObjects[MAXIMUM_WAIT_OBJECTS];
56 ULONG i = 0, ReferencedObjects = 0, j;
57 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
58 LARGE_INTEGER SafeTimeOut;
59 BOOLEAN LockInUse;
60 PHANDLE_TABLE_ENTRY HandleEntry;
61 POBJECT_HEADER ObjectHeader;
62 PHANDLE_TABLE HandleTable;
63 ACCESS_MASK GrantedAccess;
64 PVOID DefaultObject;
65 NTSTATUS Status;
66 PAGED_CODE();
67
68 /* Enter a critical region since we'll play with handles */
69 LockInUse = TRUE;
70 KeEnterCriticalRegion();
71
72 /* Check for valid Object Count */
73 if ((ObjectCount > MAXIMUM_WAIT_OBJECTS) || !(ObjectCount))
74 {
75 /* Fail */
76 Status = STATUS_INVALID_PARAMETER_1;
77 goto Quickie;
78 }
79
80 /* Check for valid Wait Type */
81 if ((WaitType != WaitAll) && (WaitType != WaitAny))
82 {
83 /* Fail */
84 Status = STATUS_INVALID_PARAMETER_3;
85 goto Quickie;
86 }
87
88 /* Enter SEH */
89 _SEH2_TRY
90 {
91 /* Check if the call came from user mode */
92 if (PreviousMode != KernelMode)
93 {
94 /* Check if we have a timeout */
95 if (TimeOut)
96 {
97 /* Make a local copy of the timeout on the stack */
98 SafeTimeOut = ProbeForReadLargeInteger(TimeOut);
99 TimeOut = &SafeTimeOut;
100 }
101
102 /* Probe all the handles */
103 ProbeForRead(HandleArray,
104 ObjectCount * sizeof(HANDLE),
105 sizeof(HANDLE));
106 }
107
108 /*
109 * Make a copy so we don't have to guard with SEH later and keep
110 * track of what objects we referenced if dereferencing pointers
111 * suddenly fails
112 */
113 RtlCopyMemory(Handles,
114 HandleArray,
115 ObjectCount * sizeof(HANDLE));
116 }
117 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
118 {
119 /* Return the exception code */
120 Status = _SEH2_GetExceptionCode();
121 _SEH2_YIELD(goto Quickie);
122 }
123 _SEH2_END;
124
125 /* Check if we can use the internal Wait Array */
126 if (ObjectCount > THREAD_WAIT_OBJECTS)
127 {
128 /* Allocate from Pool */
129 WaitBlockArray = ExAllocatePoolWithTag(NonPagedPool,
130 ObjectCount *
131 sizeof(KWAIT_BLOCK),
132 TAG_WAIT);
133 if (!WaitBlockArray)
134 {
135 /* Fail */
136 Status = STATUS_INSUFFICIENT_RESOURCES;
137 goto Quickie;
138 }
139 }
140
141 /* Start the loop */
142 do
143 {
144 /* Use the right Executive Handle */
145 if (ObpIsKernelHandle(Handles[i], PreviousMode))
146 {
147 /* Use the System Handle Table and decode */
148 HandleTable = ObpKernelHandleTable;
149 KernelHandle = ObKernelHandleToHandle(Handles[i]);
150
151 /* Get a pointer to it */
152 HandleEntry = ExMapHandleToPointer(HandleTable, KernelHandle);
153 }
154 else
155 {
156 /* Use the Process' Handle table and get the Ex Handle */
157 HandleTable = PsGetCurrentProcess()->ObjectTable;
158
159 /* Get a pointer to it */
160 HandleEntry = ExMapHandleToPointer(HandleTable, Handles[i]);
161 }
162
163 /* Check if we have an entry */
164 if (!HandleEntry)
165 {
166 /* Fail, handle is invalid */
167 Status = STATUS_INVALID_HANDLE;
168 DPRINT1("Invalid handle passed to NtWaitForMultipleObjects\n");
169 goto Quickie;
170 }
171
172 /* Check for synchronize access */
173 GrantedAccess = HandleEntry->GrantedAccess;
174 if ((PreviousMode != KernelMode) && (!(GrantedAccess & SYNCHRONIZE)))
175 {
176 /* Unlock the entry and fail */
177 ExUnlockHandleTableEntry(HandleTable, HandleEntry);
178 DPRINT1("Handle does not have SYNCHRONIZE access\n");
179 Status = STATUS_ACCESS_DENIED;
180 goto Quickie;
181 }
182
183 /* Get the Object Header */
184 ObjectHeader = ObpGetHandleObject(HandleEntry);
185
186 /* Get default Object */
187 DefaultObject = ObjectHeader->Type->DefaultObject;
188
189 /* Check if it's the internal offset */
190 if (IsPointerOffset(DefaultObject))
191 {
192 /* Increase reference count */
193 InterlockedIncrement(&ObjectHeader->PointerCount);
194 ReferencedObjects++;
195
196 /* Save the Object and Wait Object, this is a relative offset */
197 Objects[i] = &ObjectHeader->Body;
198 WaitObjects[i] = (PVOID)((ULONG_PTR)&ObjectHeader->Body +
199 (ULONG_PTR)DefaultObject);
200 }
201 else
202 {
203 /* This is our internal Object */
204 ReferencedObjects++;
205 Objects[i] = NULL;
206 WaitObjects[i] = DefaultObject;
207 }
208
209 /* Unlock the Handle Table Entry */
210 ExUnlockHandleTableEntry(HandleTable, HandleEntry);
211
212 /* Keep looping */
213 i++;
214 } while (i < ObjectCount);
215
216 /* For a Waitall, we can't have the same object more then once */
217 if (WaitType == WaitAll)
218 {
219 /* Clear the main loop variable */
220 i = 0;
221
222 /* Start the loop */
223 do
224 {
225 /* Check the current and forward object */
226 for (j = i + 1; j < ObjectCount; j++)
227 {
228 /* Make sure they don't match */
229 if (WaitObjects[i] == WaitObjects[j])
230 {
231 /* Fail */
232 Status = STATUS_INVALID_PARAMETER_MIX;
233 DPRINT1("Passed a duplicate object to NtWaitForMultipleObjects\n");
234 goto Quickie;
235 }
236 }
237
238 /* Keep looping */
239 i++;
240 } while (i < ObjectCount);
241 }
242
243 /* Now we can finally wait. Use SEH since it can raise an exception */
244 _SEH2_TRY
245 {
246 /* We're done playing with handles */
247 LockInUse = FALSE;
248 KeLeaveCriticalRegion();
249
250 /* Do the kernel wait */
251 Status = KeWaitForMultipleObjects(ObjectCount,
252 WaitObjects,
253 WaitType,
254 UserRequest,
255 PreviousMode,
256 Alertable,
257 TimeOut,
258 WaitBlockArray);
259 }
260 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
261 {
262 /* Get the exception code */
263 Status = _SEH2_GetExceptionCode();
264 }
265 _SEH2_END;
266
267 Quickie:
268 /* First derefence */
269 while (ReferencedObjects)
270 {
271 /* Decrease the number of objects */
272 ReferencedObjects--;
273
274 /* Check if we had a valid object in this position */
275 if (Objects[ReferencedObjects])
276 {
277 /* Dereference it */
278 ObDereferenceObject(Objects[ReferencedObjects]);
279 }
280 }
281
282 /* Free wait block array */
283 if (WaitBlockArray) ExFreePoolWithTag(WaitBlockArray, TAG_WAIT);
284
285 /* Re-enable APCs if needed */
286 if (LockInUse) KeLeaveCriticalRegion();
287
288 /* Return status */
289 return Status;
290 }
291
292 /*++
293 * @name NtWaitForMultipleObjects32
294 * @implemented NT5.1
295 *
296 * The NtWaitForMultipleObjects32 routine <FILLMEIN>
297 *
298 * @param ObjectCount
299 * <FILLMEIN>
300 *
301 * @param HandleArray
302 * <FILLMEIN>
303 *
304 * @param WaitType
305 * <FILLMEIN>
306 *
307 * @param Alertable
308 * <FILLMEIN>
309 *
310 * @param TimeOut
311 * <FILLMEIN>
312 *
313 * @return STATUS_SUCCESS or appropriate error value.
314 *
315 * @remarks None.
316 *
317 *--*/
318 NTSTATUS
319 NTAPI
320 NtWaitForMultipleObjects32(IN ULONG ObjectCount,
321 IN PLONG Handles,
322 IN WAIT_TYPE WaitType,
323 IN BOOLEAN Alertable,
324 IN PLARGE_INTEGER TimeOut OPTIONAL)
325 {
326 /* FIXME WOW64 */
327 return NtWaitForMultipleObjects(ObjectCount,
328 (PHANDLE)Handles,
329 WaitType,
330 Alertable,
331 TimeOut);
332 }
333
334 /*++
335 * @name NtWaitForSingleObject
336 * @implemented NT4
337 *
338 * The NtWaitForSingleObject routine <FILLMEIN>
339 *
340 * @param ObjectHandle
341 * <FILLMEIN>
342 *
343 * @param Alertable
344 * <FILLMEIN>
345 *
346 * @param TimeOut
347 * <FILLMEIN>
348 *
349 * @return STATUS_SUCCESS or appropriate error value.
350 *
351 * @remarks None.
352 *
353 *--*/
354 NTSTATUS
355 NTAPI
356 NtWaitForSingleObject(IN HANDLE ObjectHandle,
357 IN BOOLEAN Alertable,
358 IN PLARGE_INTEGER TimeOut OPTIONAL)
359 {
360 PVOID Object, WaitableObject;
361 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
362 LARGE_INTEGER SafeTimeOut;
363 NTSTATUS Status;
364
365 /* Check if we came with a timeout from user mode */
366 if ((TimeOut) && (PreviousMode != KernelMode))
367 {
368 /* Enter SEH for proving */
369 _SEH2_TRY
370 {
371 /* Make a copy on the stack */
372 SafeTimeOut = ProbeForReadLargeInteger(TimeOut);
373 TimeOut = &SafeTimeOut;
374 }
375 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
376 {
377 /* Return the exception code */
378 _SEH2_YIELD(return _SEH2_GetExceptionCode());
379 }
380 _SEH2_END;
381 }
382
383 /* Get the Object */
384 Status = ObReferenceObjectByHandle(ObjectHandle,
385 SYNCHRONIZE,
386 NULL,
387 PreviousMode,
388 &Object,
389 NULL);
390 if (NT_SUCCESS(Status))
391 {
392 /* Get the Waitable Object */
393 WaitableObject = OBJECT_TO_OBJECT_HEADER(Object)->Type->DefaultObject;
394
395 /* Is it an offset for internal objects? */
396 if (IsPointerOffset(WaitableObject))
397 {
398 /* Turn it into a pointer */
399 WaitableObject = (PVOID)((ULONG_PTR)Object +
400 (ULONG_PTR)WaitableObject);
401 }
402
403 /* SEH this since it can also raise an exception */
404 _SEH2_TRY
405 {
406 /* Ask the kernel to do the wait */
407 Status = KeWaitForSingleObject(WaitableObject,
408 UserRequest,
409 PreviousMode,
410 Alertable,
411 TimeOut);
412 }
413 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
414 {
415 /* Get the exception code */
416 Status = _SEH2_GetExceptionCode();
417 }
418 _SEH2_END;
419
420 /* Dereference the Object */
421 ObDereferenceObject(Object);
422 }
423 else
424 {
425 DPRINT1("Failed to reference the handle with status 0x%x\n", Status);
426 }
427
428 /* Return the status */
429 return Status;
430 }
431
432 /*++
433 * @name NtSignalAndWaitForSingleObject
434 * @implemented NT4
435 *
436 * The NtSignalAndWaitForSingleObject routine <FILLMEIN>
437 *
438 * @param ObjectHandleToSignal
439 * <FILLMEIN>
440 *
441 * @param WaitableObjectHandle
442 * <FILLMEIN>
443 *
444 * @param Alertable
445 * <FILLMEIN>
446 *
447 * @param TimeOut
448 * <FILLMEIN>
449 *
450 * @return STATUS_SUCCESS or appropriate error value.
451 *
452 * @remarks None.
453 *
454 *--*/
455 NTSTATUS
456 NTAPI
457 NtSignalAndWaitForSingleObject(IN HANDLE ObjectHandleToSignal,
458 IN HANDLE WaitableObjectHandle,
459 IN BOOLEAN Alertable,
460 IN PLARGE_INTEGER TimeOut OPTIONAL)
461 {
462 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
463 POBJECT_TYPE Type;
464 PVOID SignalObj, WaitObj, WaitableObject;
465 LARGE_INTEGER SafeTimeOut;
466 OBJECT_HANDLE_INFORMATION HandleInfo;
467 NTSTATUS Status;
468
469 /* Check if we came with a timeout from user mode */
470 if ((TimeOut) && (PreviousMode != KernelMode))
471 {
472 /* Enter SEH for probing */
473 _SEH2_TRY
474 {
475 /* Make a copy on the stack */
476 SafeTimeOut = ProbeForReadLargeInteger(TimeOut);
477 TimeOut = &SafeTimeOut;
478 }
479 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
480 {
481 /* Return the exception code */
482 _SEH2_YIELD(return _SEH2_GetExceptionCode());
483 }
484 _SEH2_END;
485 }
486
487 /* Start by getting the signal object*/
488 Status = ObReferenceObjectByHandle(ObjectHandleToSignal,
489 0,
490 NULL,
491 PreviousMode,
492 &SignalObj,
493 &HandleInfo);
494 if (!NT_SUCCESS(Status)) return Status;
495
496 /* Now get the wait object */
497 Status = ObReferenceObjectByHandle(WaitableObjectHandle,
498 SYNCHRONIZE,
499 NULL,
500 PreviousMode,
501 &WaitObj,
502 NULL);
503 if (!NT_SUCCESS(Status))
504 {
505 /* Failed to reference the wait object */
506 ObDereferenceObject(SignalObj);
507 return Status;
508 }
509
510 /* Get the real waitable object */
511 WaitableObject = OBJECT_TO_OBJECT_HEADER(WaitObj)->Type->DefaultObject;
512
513 /* Handle internal offset */
514 if (IsPointerOffset(WaitableObject))
515 {
516 /* Get real pointer */
517 WaitableObject = (PVOID)((ULONG_PTR)WaitObj +
518 (ULONG_PTR)WaitableObject);
519 }
520
521 /* Check Signal Object Type */
522 Type = OBJECT_TO_OBJECT_HEADER(SignalObj)->Type;
523 if (Type == ExEventObjectType)
524 {
525 /* Check if we came from user-mode without the right access */
526 if ((PreviousMode != KernelMode) &&
527 !(HandleInfo.GrantedAccess & EVENT_MODIFY_STATE))
528 {
529 /* Fail: lack of rights */
530 Status = STATUS_ACCESS_DENIED;
531 goto Quickie;
532 }
533
534 /* Set the Event */
535 KeSetEvent(SignalObj, EVENT_INCREMENT, TRUE);
536 }
537 else if (Type == ExMutantObjectType)
538 {
539 /* This can raise an exception */
540 _SEH2_TRY
541 {
542 /* Release the mutant */
543 KeReleaseMutant(SignalObj, MUTANT_INCREMENT, FALSE, TRUE);
544 }
545 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
546 {
547 /* Get the exception code */
548 Status = _SEH2_GetExceptionCode();
549 }
550 _SEH2_END;
551 }
552 else if (Type == ExSemaphoreObjectType)
553 {
554 /* Check if we came from user-mode without the right access */
555 if ((PreviousMode != KernelMode) &&
556 !(HandleInfo.GrantedAccess & SEMAPHORE_MODIFY_STATE))
557 {
558 /* Fail: lack of rights */
559 Status = STATUS_ACCESS_DENIED;
560 goto Quickie;
561 }
562
563 /* This can raise an exception*/
564 _SEH2_TRY
565 {
566 /* Release the semaphore */
567 KeReleaseSemaphore(SignalObj, SEMAPHORE_INCREMENT, 1, TRUE);
568 }
569 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
570 {
571 /* Get the exception code */
572 Status = _SEH2_GetExceptionCode();
573 }
574 _SEH2_END;
575 }
576 else
577 {
578 /* This isn't a valid object to be waiting on */
579 Status = STATUS_OBJECT_TYPE_MISMATCH;
580 }
581
582 /* Make sure we didn't fail */
583 if (NT_SUCCESS(Status))
584 {
585 /* SEH this since it can also raise an exception */
586 _SEH2_TRY
587 {
588 /* Perform the wait now */
589 Status = KeWaitForSingleObject(WaitableObject,
590 UserRequest,
591 PreviousMode,
592 Alertable,
593 TimeOut);
594 }
595 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
596 {
597 /* Get the exception code */
598 Status = _SEH2_GetExceptionCode();
599 }
600 _SEH2_END;
601 }
602
603 /* We're done here, dereference both objects */
604 Quickie:
605 ObDereferenceObject(SignalObj);
606 ObDereferenceObject(WaitObj);
607 return Status;
608 }
609
610 /* EOF */