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