2 * Process synchronisation
4 * Copyright 1996, 1997, 1998 Marcus Meissner
5 * Copyright 1997, 1999 Alexandre Julliard
6 * Copyright 1999, 2000 Juergen Schmied
7 * Copyright 2003 Eric Pouech
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #ifdef HAVE_SYS_TIME_H
30 # include <sys/time.h>
35 #ifdef HAVE_SYS_POLL_H
36 # include <sys/poll.h>
50 #define NONAMELESSUNION
51 #define NONAMELESSSTRUCT
54 #define WIN32_NO_STATUS
57 #include "wine/server.h"
58 #include "wine/debug.h"
59 #include "ntdll_misc.h"
61 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
63 /* creates a struct security_descriptor and contained information in one contiguous piece of memory */
64 NTSTATUS NTDLL_create_struct_sd(PSECURITY_DESCRIPTOR nt_sd, struct security_descriptor **server_sd,
65 data_size_t *server_sd_len)
70 BOOLEAN owner_present, group_present, dacl_present, sacl_present;
79 return STATUS_SUCCESS;
82 len = sizeof(struct security_descriptor);
84 status = RtlGetOwnerSecurityDescriptor(nt_sd, &owner, &owner_present);
85 if (status != STATUS_SUCCESS) return status;
86 status = RtlGetGroupSecurityDescriptor(nt_sd, &group, &group_present);
87 if (status != STATUS_SUCCESS) return status;
88 status = RtlGetSaclSecurityDescriptor(nt_sd, &sacl_present, &sacl, &defaulted);
89 if (status != STATUS_SUCCESS) return status;
90 status = RtlGetDaclSecurityDescriptor(nt_sd, &dacl_present, &dacl, &defaulted);
91 if (status != STATUS_SUCCESS) return status;
94 len += RtlLengthSid(owner);
96 len += RtlLengthSid(group);
97 if (sacl_present && sacl)
99 if (dacl_present && dacl)
100 len += dacl->AclSize;
102 /* fix alignment for the Unicode name that follows the structure */
103 len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
104 *server_sd = RtlAllocateHeap(GetProcessHeap(), 0, len);
105 if (!*server_sd) return STATUS_NO_MEMORY;
107 (*server_sd)->control = ((SECURITY_DESCRIPTOR *)nt_sd)->Control & ~SE_SELF_RELATIVE;
108 (*server_sd)->owner_len = owner_present ? RtlLengthSid(owner) : 0;
109 (*server_sd)->group_len = group_present ? RtlLengthSid(group) : 0;
110 (*server_sd)->sacl_len = (sacl_present && sacl) ? sacl->AclSize : 0;
111 (*server_sd)->dacl_len = (dacl_present && dacl) ? dacl->AclSize : 0;
113 ptr = (unsigned char *)(*server_sd + 1);
114 memcpy(ptr, owner, (*server_sd)->owner_len);
115 ptr += (*server_sd)->owner_len;
116 memcpy(ptr, group, (*server_sd)->group_len);
117 ptr += (*server_sd)->group_len;
118 memcpy(ptr, sacl, (*server_sd)->sacl_len);
119 ptr += (*server_sd)->sacl_len;
120 memcpy(ptr, dacl, (*server_sd)->dacl_len);
122 *server_sd_len = len;
124 return STATUS_SUCCESS;
127 /* frees a struct security_descriptor allocated by NTDLL_create_struct_sd */
128 void NTDLL_free_struct_sd(struct security_descriptor *server_sd)
130 RtlFreeHeap(GetProcessHeap(), 0, server_sd);
137 /******************************************************************************
138 * NtCreateSemaphore (NTDLL.@)
140 NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
141 IN ACCESS_MASK access,
142 IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
143 IN LONG InitialCount,
144 IN LONG MaximumCount )
146 DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
148 struct object_attributes objattr;
149 struct security_descriptor *sd = NULL;
151 if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount)
152 return STATUS_INVALID_PARAMETER;
153 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
155 objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
157 objattr.name_len = len;
160 ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
161 if (ret != STATUS_SUCCESS) return ret;
164 SERVER_START_REQ( create_semaphore )
166 req->access = access;
167 req->attributes = (attr) ? attr->Attributes : 0;
168 req->initial = InitialCount;
169 req->max = MaximumCount;
170 wine_server_add_data( req, &objattr, sizeof(objattr) );
171 if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
172 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
173 ret = wine_server_call( req );
174 *SemaphoreHandle = wine_server_ptr_handle( reply->handle );
178 NTDLL_free_struct_sd( sd );
183 /******************************************************************************
184 * NtOpenSemaphore (NTDLL.@)
186 NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
187 IN ACCESS_MASK access,
188 IN const OBJECT_ATTRIBUTES *attr )
190 DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
193 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
195 SERVER_START_REQ( open_semaphore )
197 req->access = access;
198 req->attributes = (attr) ? attr->Attributes : 0;
199 req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
200 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
201 ret = wine_server_call( req );
202 *SemaphoreHandle = wine_server_ptr_handle( reply->handle );
208 /******************************************************************************
209 * NtQuerySemaphore (NTDLL.@)
211 NTSTATUS WINAPI NtQuerySemaphore(
212 HANDLE SemaphoreHandle,
213 SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
214 PVOID SemaphoreInformation,
218 FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
219 SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
220 return STATUS_SUCCESS;
223 /******************************************************************************
224 * NtReleaseSemaphore (NTDLL.@)
226 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
229 SERVER_START_REQ( release_semaphore )
231 req->handle = wine_server_obj_handle( handle );
233 if (!(ret = wine_server_call( req )))
235 if (previous) *previous = reply->prev_count;
246 /**************************************************************************
247 * NtCreateEvent (NTDLL.@)
248 * ZwCreateEvent (NTDLL.@)
250 NTSTATUS WINAPI NtCreateEvent(
251 OUT PHANDLE EventHandle,
252 IN ACCESS_MASK DesiredAccess,
253 IN const OBJECT_ATTRIBUTES *attr,
254 IN BOOLEAN ManualReset,
255 IN BOOLEAN InitialState)
257 DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
259 struct security_descriptor *sd = NULL;
260 struct object_attributes objattr;
262 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
264 objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
266 objattr.name_len = len;
269 ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
270 if (ret != STATUS_SUCCESS) return ret;
273 SERVER_START_REQ( create_event )
275 req->access = DesiredAccess;
276 req->attributes = (attr) ? attr->Attributes : 0;
277 req->manual_reset = ManualReset;
278 req->initial_state = InitialState;
279 wine_server_add_data( req, &objattr, sizeof(objattr) );
280 if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
281 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
282 ret = wine_server_call( req );
283 *EventHandle = wine_server_ptr_handle( reply->handle );
287 NTDLL_free_struct_sd( sd );
292 /******************************************************************************
293 * NtOpenEvent (NTDLL.@)
294 * ZwOpenEvent (NTDLL.@)
296 NTSTATUS WINAPI NtOpenEvent(
297 OUT PHANDLE EventHandle,
298 IN ACCESS_MASK DesiredAccess,
299 IN const OBJECT_ATTRIBUTES *attr )
301 DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
304 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
306 SERVER_START_REQ( open_event )
308 req->access = DesiredAccess;
309 req->attributes = (attr) ? attr->Attributes : 0;
310 req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
311 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
312 ret = wine_server_call( req );
313 *EventHandle = wine_server_ptr_handle( reply->handle );
320 /******************************************************************************
321 * NtSetEvent (NTDLL.@)
322 * ZwSetEvent (NTDLL.@)
324 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
328 /* FIXME: set NumberOfThreadsReleased */
330 SERVER_START_REQ( event_op )
332 req->handle = wine_server_obj_handle( handle );
334 ret = wine_server_call( req );
340 /******************************************************************************
341 * NtResetEvent (NTDLL.@)
343 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
347 /* resetting an event can't release any thread... */
348 if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
350 SERVER_START_REQ( event_op )
352 req->handle = wine_server_obj_handle( handle );
353 req->op = RESET_EVENT;
354 ret = wine_server_call( req );
360 /******************************************************************************
361 * NtClearEvent (NTDLL.@)
364 * same as NtResetEvent ???
366 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
368 return NtResetEvent( handle, NULL );
371 /******************************************************************************
372 * NtPulseEvent (NTDLL.@)
377 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
382 FIXME("(%p,%d)\n", handle, *PulseCount);
384 SERVER_START_REQ( event_op )
386 req->handle = wine_server_obj_handle( handle );
387 req->op = PULSE_EVENT;
388 ret = wine_server_call( req );
394 /******************************************************************************
395 * NtQueryEvent (NTDLL.@)
397 NTSTATUS WINAPI NtQueryEvent (
398 IN HANDLE EventHandle,
399 IN EVENT_INFORMATION_CLASS EventInformationClass,
400 OUT PVOID EventInformation,
401 IN ULONG EventInformationLength,
402 OUT PULONG ReturnLength)
404 FIXME("(%p)\n", EventHandle);
405 return STATUS_SUCCESS;
409 * Mutants (known as Mutexes in Kernel32)
412 /******************************************************************************
413 * NtCreateMutant [NTDLL.@]
414 * ZwCreateMutant [NTDLL.@]
416 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
417 IN ACCESS_MASK access,
418 IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
419 IN BOOLEAN InitialOwner)
422 DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
423 struct security_descriptor *sd = NULL;
424 struct object_attributes objattr;
426 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
428 objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
430 objattr.name_len = len;
433 status = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
434 if (status != STATUS_SUCCESS) return status;
437 SERVER_START_REQ( create_mutex )
439 req->access = access;
440 req->attributes = (attr) ? attr->Attributes : 0;
441 req->owned = InitialOwner;
442 wine_server_add_data( req, &objattr, sizeof(objattr) );
443 if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
444 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
445 status = wine_server_call( req );
446 *MutantHandle = wine_server_ptr_handle( reply->handle );
450 NTDLL_free_struct_sd( sd );
455 /**************************************************************************
456 * NtOpenMutant [NTDLL.@]
457 * ZwOpenMutant [NTDLL.@]
459 NTSTATUS WINAPI NtOpenMutant(OUT HANDLE* MutantHandle,
460 IN ACCESS_MASK access,
461 IN const OBJECT_ATTRIBUTES* attr )
464 DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
466 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
468 SERVER_START_REQ( open_mutex )
470 req->access = access;
471 req->attributes = (attr) ? attr->Attributes : 0;
472 req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
473 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
474 status = wine_server_call( req );
475 *MutantHandle = wine_server_ptr_handle( reply->handle );
481 /**************************************************************************
482 * NtReleaseMutant [NTDLL.@]
483 * ZwReleaseMutant [NTDLL.@]
485 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
489 SERVER_START_REQ( release_mutex )
491 req->handle = wine_server_obj_handle( handle );
492 status = wine_server_call( req );
493 if (prev_count) *prev_count = reply->prev_count;
499 /******************************************************************
500 * NtQueryMutant [NTDLL.@]
501 * ZwQueryMutant [NTDLL.@]
503 NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle,
504 IN MUTANT_INFORMATION_CLASS MutantInformationClass,
505 OUT PVOID MutantInformation,
506 IN ULONG MutantInformationLength,
507 OUT PULONG ResultLength OPTIONAL )
509 FIXME("(%p %u %p %u %p): stub!\n",
510 handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
511 return STATUS_NOT_IMPLEMENTED;
518 /******************************************************************************
519 * NtCreateJobObject [NTDLL.@]
520 * ZwCreateJobObject [NTDLL.@]
522 NTSTATUS WINAPI NtCreateJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
524 FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
525 *handle = (HANDLE)0xdead;
526 return STATUS_SUCCESS;
529 /******************************************************************************
530 * NtOpenJobObject [NTDLL.@]
531 * ZwOpenJobObject [NTDLL.@]
533 NTSTATUS WINAPI NtOpenJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
535 FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
536 return STATUS_NOT_IMPLEMENTED;
539 /******************************************************************************
540 * NtTerminateJobObject [NTDLL.@]
541 * ZwTerminateJobObject [NTDLL.@]
543 NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status )
545 FIXME( "stub: %p %x\n", handle, status );
546 return STATUS_SUCCESS;
549 /******************************************************************************
550 * NtQueryInformationJobObject [NTDLL.@]
551 * ZwQueryInformationJobObject [NTDLL.@]
553 NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info,
554 ULONG len, PULONG ret_len )
556 FIXME( "stub: %p %u %p %u %p\n", handle, class, info, len, ret_len );
557 return STATUS_NOT_IMPLEMENTED;
560 /******************************************************************************
561 * NtSetInformationJobObject [NTDLL.@]
562 * ZwSetInformationJobObject [NTDLL.@]
564 NTSTATUS WINAPI NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info, ULONG len )
566 FIXME( "stub: %p %u %p %u\n", handle, class, info, len );
567 return STATUS_SUCCESS;
570 /******************************************************************************
571 * NtIsProcessInJob [NTDLL.@]
572 * ZwIsProcessInJob [NTDLL.@]
574 NTSTATUS WINAPI NtIsProcessInJob( HANDLE process, HANDLE job )
576 FIXME( "stub: %p %p\n", process, job );
577 return STATUS_PROCESS_NOT_IN_JOB;
580 /******************************************************************************
581 * NtAssignProcessToJobObject [NTDLL.@]
582 * ZwAssignProcessToJobObject [NTDLL.@]
584 NTSTATUS WINAPI NtAssignProcessToJobObject( HANDLE job, HANDLE process )
586 FIXME( "stub: %p %p\n", job, process );
587 return STATUS_SUCCESS;
594 /**************************************************************************
595 * NtCreateTimer [NTDLL.@]
596 * ZwCreateTimer [NTDLL.@]
598 NTSTATUS WINAPI NtCreateTimer(OUT HANDLE *handle,
599 IN ACCESS_MASK access,
600 IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
601 IN TIMER_TYPE timer_type)
603 DWORD len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
606 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
608 if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
609 return STATUS_INVALID_PARAMETER;
611 SERVER_START_REQ( create_timer )
613 req->access = access;
614 req->attributes = (attr) ? attr->Attributes : 0;
615 req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
616 req->manual = (timer_type == NotificationTimer) ? TRUE : FALSE;
617 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
618 status = wine_server_call( req );
619 *handle = wine_server_ptr_handle( reply->handle );
626 /**************************************************************************
627 * NtOpenTimer [NTDLL.@]
628 * ZwOpenTimer [NTDLL.@]
630 NTSTATUS WINAPI NtOpenTimer(OUT PHANDLE handle,
631 IN ACCESS_MASK access,
632 IN const OBJECT_ATTRIBUTES* attr )
634 DWORD len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
637 if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
639 SERVER_START_REQ( open_timer )
641 req->access = access;
642 req->attributes = (attr) ? attr->Attributes : 0;
643 req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
644 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
645 status = wine_server_call( req );
646 *handle = wine_server_ptr_handle( reply->handle );
652 /**************************************************************************
653 * NtSetTimer [NTDLL.@]
654 * ZwSetTimer [NTDLL.@]
656 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
657 IN const LARGE_INTEGER* when,
658 IN PTIMER_APC_ROUTINE callback,
659 IN PVOID callback_arg,
661 IN ULONG period OPTIONAL,
662 OUT PBOOLEAN state OPTIONAL)
664 NTSTATUS status = STATUS_SUCCESS;
666 TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
667 handle, when, callback, callback_arg, resume, period, state);
669 SERVER_START_REQ( set_timer )
671 req->handle = wine_server_obj_handle( handle );
672 req->period = period;
673 req->expire = when->QuadPart;
674 req->callback = wine_server_client_ptr( callback );
675 req->arg = wine_server_client_ptr( callback_arg );
676 status = wine_server_call( req );
677 if (state) *state = reply->signaled;
681 /* set error but can still succeed */
682 if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
686 /**************************************************************************
687 * NtCancelTimer [NTDLL.@]
688 * ZwCancelTimer [NTDLL.@]
690 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
694 SERVER_START_REQ( cancel_timer )
696 req->handle = wine_server_obj_handle( handle );
697 status = wine_server_call( req );
698 if (state) *state = reply->signaled;
704 /******************************************************************************
705 * NtQueryTimer (NTDLL.@)
707 * Retrieves information about a timer.
710 * TimerHandle [I] The timer to retrieve information about.
711 * TimerInformationClass [I] The type of information to retrieve.
712 * TimerInformation [O] Pointer to buffer to store information in.
713 * Length [I] The length of the buffer pointed to by TimerInformation.
714 * ReturnLength [O] Optional. The size of buffer actually used.
717 * Success: STATUS_SUCCESS
718 * Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
719 * size for the class specified.
720 * STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
721 * STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
724 NTSTATUS WINAPI NtQueryTimer(
726 TIMER_INFORMATION_CLASS TimerInformationClass,
727 PVOID TimerInformation,
731 TIMER_BASIC_INFORMATION * basic_info = (TIMER_BASIC_INFORMATION *)TimerInformation;
735 TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
736 TimerInformation, Length, ReturnLength);
738 switch (TimerInformationClass)
740 case TimerBasicInformation:
741 if (Length < sizeof(TIMER_BASIC_INFORMATION))
742 return STATUS_INFO_LENGTH_MISMATCH;
744 SERVER_START_REQ(get_timer_info)
746 req->handle = wine_server_obj_handle( TimerHandle );
747 status = wine_server_call(req);
749 /* convert server time to absolute NTDLL time */
750 basic_info->RemainingTime.QuadPart = reply->when;
751 basic_info->TimerState = reply->signaled;
755 /* convert from absolute into relative time */
756 NtQuerySystemTime(&now);
757 if (now.QuadPart > basic_info->RemainingTime.QuadPart)
758 basic_info->RemainingTime.QuadPart = 0;
760 basic_info->RemainingTime.QuadPart -= now.QuadPart;
762 if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
767 FIXME("Unhandled class %d\n", TimerInformationClass);
768 return STATUS_INVALID_INFO_CLASS;
772 /******************************************************************************
773 * NtQueryTimerResolution [NTDLL.@]
775 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
776 OUT ULONG* max_resolution,
777 OUT ULONG* current_resolution)
779 FIXME("(%p,%p,%p), stub!\n",
780 min_resolution, max_resolution, current_resolution);
782 return STATUS_NOT_IMPLEMENTED;
785 /******************************************************************************
786 * NtSetTimerResolution [NTDLL.@]
788 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
789 IN BOOLEAN set_resolution,
790 OUT ULONG* current_resolution )
792 FIXME("(%u,%u,%p), stub!\n",
793 resolution, set_resolution, current_resolution);
795 return STATUS_NOT_IMPLEMENTED;
799 /***********************************************************************
802 * Wait for a reply on the waiting pipe of the current thread.
804 static int wait_reply( void *cookie )
807 struct wake_up_reply reply;
811 ret = read( ntdll_get_thread_data()->wait_fd[0], &reply, sizeof(reply) );
812 if (ret == sizeof(reply))
814 if (!reply.cookie) break; /* thread got killed */
815 if (wine_server_get_ptr(reply.cookie) == cookie) return reply.signaled;
816 /* we stole another reply, wait for the real one */
817 signaled = wait_reply( cookie );
818 /* and now put the wrong one back in the pipe */
821 ret = write( ntdll_get_thread_data()->wait_fd[1], &reply, sizeof(reply) );
822 if (ret == sizeof(reply)) break;
823 if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
824 if (errno == EINTR) continue;
825 server_protocol_perror("wakeup write");
829 if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
830 if (errno == EINTR) continue;
831 server_protocol_perror("wakeup read");
833 /* the server closed the connection; time to die... */
834 server_abort_thread(0);
838 /***********************************************************************
841 * Invoke a single APC. Return TRUE if a user APC has been run.
843 static BOOL invoke_apc( const apc_call_t *call, apc_result_t *result )
845 BOOL user_apc = FALSE;
849 memset( result, 0, sizeof(*result) );
856 call->user.func( call->user.args[0], call->user.args[1], call->user.args[2] );
861 void (WINAPI *func)(void*, unsigned int, unsigned int) = wine_server_get_ptr( call->timer.func );
862 func( wine_server_get_ptr( call->timer.arg ),
863 (DWORD)call->timer.time, (DWORD)(call->timer.time >> 32) );
870 IO_STATUS_BLOCK *iosb = call->async_io.sb;
871 result->type = call->type;
872 result->async_io.status = call->async_io.func( call->async_io.user, iosb,
873 call->async_io.status, &apc );
874 if (result->async_io.status != STATUS_PENDING)
876 result->async_io.total = iosb->Information;
877 result->async_io.apc = apc;
881 case APC_VIRTUAL_ALLOC:
882 result->type = call->type;
883 addr = wine_server_get_ptr( call->virtual_alloc.addr );
884 size = call->virtual_alloc.size;
885 if ((ULONG_PTR)addr == call->virtual_alloc.addr && size == call->virtual_alloc.size)
887 result->virtual_alloc.status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr,
888 call->virtual_alloc.zero_bits, &size,
889 call->virtual_alloc.op_type,
890 call->virtual_alloc.prot );
891 result->virtual_alloc.addr = wine_server_client_ptr( addr );
892 result->virtual_alloc.size = size;
894 else result->virtual_alloc.status = STATUS_WORKING_SET_LIMIT_RANGE;
896 case APC_VIRTUAL_FREE:
897 result->type = call->type;
898 addr = wine_server_get_ptr( call->virtual_free.addr );
899 size = call->virtual_free.size;
900 if ((ULONG_PTR)addr == call->virtual_free.addr && size == call->virtual_free.size)
902 result->virtual_free.status = NtFreeVirtualMemory( NtCurrentProcess(), &addr, &size,
903 call->virtual_free.op_type );
904 result->virtual_free.addr = wine_server_client_ptr( addr );
905 result->virtual_free.size = size;
907 else result->virtual_free.status = STATUS_INVALID_PARAMETER;
909 case APC_VIRTUAL_QUERY:
911 MEMORY_BASIC_INFORMATION info;
912 result->type = call->type;
913 addr = wine_server_get_ptr( call->virtual_query.addr );
914 if ((ULONG_PTR)addr == call->virtual_query.addr)
915 result->virtual_query.status = NtQueryVirtualMemory( NtCurrentProcess(),
916 addr, MemoryBasicInformation, &info,
917 sizeof(info), NULL );
919 result->virtual_query.status = STATUS_WORKING_SET_LIMIT_RANGE;
921 if (result->virtual_query.status == STATUS_SUCCESS)
923 result->virtual_query.base = wine_server_client_ptr( info.BaseAddress );
924 result->virtual_query.alloc_base = wine_server_client_ptr( info.AllocationBase );
925 result->virtual_query.size = info.RegionSize;
926 result->virtual_query.prot = info.Protect;
927 result->virtual_query.alloc_prot = info.AllocationProtect;
928 result->virtual_query.state = info.State >> 12;
929 result->virtual_query.alloc_type = info.Type >> 16;
933 case APC_VIRTUAL_PROTECT:
934 result->type = call->type;
935 addr = wine_server_get_ptr( call->virtual_protect.addr );
936 size = call->virtual_protect.size;
937 if ((ULONG_PTR)addr == call->virtual_protect.addr && size == call->virtual_protect.size)
939 result->virtual_protect.status = NtProtectVirtualMemory( NtCurrentProcess(), &addr, &size,
940 call->virtual_protect.prot,
941 &result->virtual_protect.prot );
942 result->virtual_protect.addr = wine_server_client_ptr( addr );
943 result->virtual_protect.size = size;
945 else result->virtual_protect.status = STATUS_INVALID_PARAMETER;
947 case APC_VIRTUAL_FLUSH:
948 result->type = call->type;
949 addr = wine_server_get_ptr( call->virtual_flush.addr );
950 size = call->virtual_flush.size;
951 if ((ULONG_PTR)addr == call->virtual_flush.addr && size == call->virtual_flush.size)
953 result->virtual_flush.status = NtFlushVirtualMemory( NtCurrentProcess(),
954 (const void **)&addr, &size, 0 );
955 result->virtual_flush.addr = wine_server_client_ptr( addr );
956 result->virtual_flush.size = size;
958 else result->virtual_flush.status = STATUS_INVALID_PARAMETER;
960 case APC_VIRTUAL_LOCK:
961 result->type = call->type;
962 addr = wine_server_get_ptr( call->virtual_lock.addr );
963 size = call->virtual_lock.size;
964 if ((ULONG_PTR)addr == call->virtual_lock.addr && size == call->virtual_lock.size)
966 result->virtual_lock.status = NtLockVirtualMemory( NtCurrentProcess(), &addr, &size, 0 );
967 result->virtual_lock.addr = wine_server_client_ptr( addr );
968 result->virtual_lock.size = size;
970 else result->virtual_lock.status = STATUS_INVALID_PARAMETER;
972 case APC_VIRTUAL_UNLOCK:
973 result->type = call->type;
974 addr = wine_server_get_ptr( call->virtual_unlock.addr );
975 size = call->virtual_unlock.size;
976 if ((ULONG_PTR)addr == call->virtual_unlock.addr && size == call->virtual_unlock.size)
978 result->virtual_unlock.status = NtUnlockVirtualMemory( NtCurrentProcess(), &addr, &size, 0 );
979 result->virtual_unlock.addr = wine_server_client_ptr( addr );
980 result->virtual_unlock.size = size;
982 else result->virtual_unlock.status = STATUS_INVALID_PARAMETER;
985 result->type = call->type;
986 addr = wine_server_get_ptr( call->map_view.addr );
987 size = call->map_view.size;
988 if ((ULONG_PTR)addr == call->map_view.addr && size == call->map_view.size)
990 LARGE_INTEGER offset;
991 offset.QuadPart = call->map_view.offset;
992 result->map_view.status = NtMapViewOfSection( wine_server_ptr_handle(call->map_view.handle),
993 NtCurrentProcess(), &addr,
994 call->map_view.zero_bits, 0,
995 &offset, &size, ViewShare,
996 call->map_view.alloc_type, call->map_view.prot );
997 result->map_view.addr = wine_server_client_ptr( addr );
998 result->map_view.size = size;
1000 else result->map_view.status = STATUS_INVALID_PARAMETER;
1001 NtClose( wine_server_ptr_handle(call->map_view.handle) );
1003 case APC_UNMAP_VIEW:
1004 result->type = call->type;
1005 addr = wine_server_get_ptr( call->unmap_view.addr );
1006 if ((ULONG_PTR)addr == call->unmap_view.addr)
1007 result->unmap_view.status = NtUnmapViewOfSection( NtCurrentProcess(), addr );
1009 result->unmap_view.status = STATUS_INVALID_PARAMETER;
1011 case APC_CREATE_THREAD:
1015 SIZE_T reserve = call->create_thread.reserve;
1016 SIZE_T commit = call->create_thread.commit;
1017 void *func = wine_server_get_ptr( call->create_thread.func );
1018 void *arg = wine_server_get_ptr( call->create_thread.arg );
1020 result->type = call->type;
1021 if (reserve == call->create_thread.reserve && commit == call->create_thread.commit &&
1022 (ULONG_PTR)func == call->create_thread.func && (ULONG_PTR)arg == call->create_thread.arg)
1024 result->create_thread.status = RtlCreateUserThread( NtCurrentProcess(), NULL,
1025 call->create_thread.suspend, NULL,
1026 reserve, commit, func, arg, &handle, &id );
1027 result->create_thread.handle = wine_server_obj_handle( handle );
1028 result->create_thread.tid = HandleToULong(id.UniqueThread);
1030 else result->create_thread.status = STATUS_INVALID_PARAMETER;
1034 server_protocol_error( "get_apc_request: bad type %d\n", call->type );
1040 /***********************************************************************
1041 * NTDLL_queue_process_apc
1043 NTSTATUS NTDLL_queue_process_apc( HANDLE process, const apc_call_t *call, apc_result_t *result )
1051 SERVER_START_REQ( queue_apc )
1053 req->handle = wine_server_obj_handle( process );
1055 if (!(ret = wine_server_call( req )))
1057 handle = wine_server_ptr_handle( reply->handle );
1062 if (ret != STATUS_SUCCESS) return ret;
1066 invoke_apc( call, result );
1070 NtWaitForSingleObject( handle, FALSE, NULL );
1072 SERVER_START_REQ( get_apc_result )
1074 req->handle = wine_server_obj_handle( handle );
1075 if (!(ret = wine_server_call( req ))) *result = reply->result;
1079 if (!ret && result->type == APC_NONE) continue; /* APC didn't run, try again */
1080 if (ret) NtClose( handle );
1087 /***********************************************************************
1088 * NTDLL_wait_for_multiple_objects
1090 * Implementation of NtWaitForMultipleObjects
1092 NTSTATUS NTDLL_wait_for_multiple_objects( UINT count, const HANDLE *handles, UINT flags,
1093 const LARGE_INTEGER *timeout, HANDLE signal_object )
1097 BOOL user_apc = FALSE;
1098 obj_handle_t obj_handles[MAXIMUM_WAIT_OBJECTS];
1099 obj_handle_t apc_handle = 0;
1101 apc_result_t result;
1102 timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE;
1104 memset( &result, 0, sizeof(result) );
1105 for (i = 0; i < count; i++) obj_handles[i] = wine_server_obj_handle( handles[i] );
1109 SERVER_START_REQ( select )
1112 req->cookie = wine_server_client_ptr( &cookie );
1113 req->signal = wine_server_obj_handle( signal_object );
1114 req->prev_apc = apc_handle;
1115 req->timeout = abs_timeout;
1116 wine_server_add_data( req, &result, sizeof(result) );
1117 wine_server_add_data( req, obj_handles, count * sizeof(*obj_handles) );
1118 ret = wine_server_call( req );
1119 abs_timeout = reply->timeout;
1120 apc_handle = reply->apc_handle;
1124 if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
1125 if (ret != STATUS_USER_APC) break;
1126 if (invoke_apc( &call, &result ))
1128 /* if we ran a user apc we have to check once more if an object got signaled,
1129 * but we don't want to wait */
1133 signal_object = 0; /* don't signal it multiple times */
1136 if (ret == STATUS_TIMEOUT && user_apc) ret = STATUS_USER_APC;
1138 /* A test on Windows 2000 shows that Windows always yields during
1139 a wait, but a wait that is hit by an event gets a priority
1140 boost as well. This seems to model that behavior the closest. */
1141 if (ret == STATUS_TIMEOUT) NtYieldExecution();
1147 /* wait operations */
1149 /******************************************************************
1150 * NtWaitForMultipleObjects (NTDLL.@)
1152 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
1153 BOOLEAN wait_all, BOOLEAN alertable,
1154 const LARGE_INTEGER *timeout )
1156 UINT flags = SELECT_INTERRUPTIBLE;
1158 if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
1160 if (wait_all) flags |= SELECT_ALL;
1161 if (alertable) flags |= SELECT_ALERTABLE;
1162 return NTDLL_wait_for_multiple_objects( count, handles, flags, timeout, 0 );
1166 /******************************************************************
1167 * NtWaitForSingleObject (NTDLL.@)
1169 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1171 return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
1175 /******************************************************************
1176 * NtSignalAndWaitForSingleObject (NTDLL.@)
1178 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE hSignalObject, HANDLE hWaitObject,
1179 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1181 UINT flags = SELECT_INTERRUPTIBLE;
1183 if (!hSignalObject) return STATUS_INVALID_HANDLE;
1184 if (alertable) flags |= SELECT_ALERTABLE;
1185 return NTDLL_wait_for_multiple_objects( 1, &hWaitObject, flags, timeout, hSignalObject );
1189 /******************************************************************
1190 * NtYieldExecution (NTDLL.@)
1192 NTSTATUS WINAPI NtYieldExecution(void)
1194 #ifdef HAVE_SCHED_YIELD
1196 return STATUS_SUCCESS;
1198 return STATUS_NO_YIELD_PERFORMED;
1203 /******************************************************************
1204 * NtDelayExecution (NTDLL.@)
1206 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
1208 /* if alertable, we need to query the server */
1210 return NTDLL_wait_for_multiple_objects( 0, NULL, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE,
1213 if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE) /* sleep forever */
1215 for (;;) select( 0, NULL, NULL, NULL, NULL );
1220 timeout_t when, diff;
1222 if ((when = timeout->QuadPart) < 0)
1224 NtQuerySystemTime( &now );
1225 when = now.QuadPart - when;
1228 /* Note that we yield after establishing the desired timeout */
1230 if (!when) return STATUS_SUCCESS;
1235 NtQuerySystemTime( &now );
1236 diff = (when - now.QuadPart + 9) / 10;
1237 if (diff <= 0) break;
1238 tv.tv_sec = diff / 1000000;
1239 tv.tv_usec = diff % 1000000;
1240 if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
1243 return STATUS_SUCCESS;
1246 /******************************************************************
1247 * NtCreateIoCompletion (NTDLL.@)
1248 * ZwCreateIoCompletion (NTDLL.@)
1250 * Creates I/O completion object.
1253 * CompletionPort [O] created completion object handle will be placed there
1254 * DesiredAccess [I] desired access to a handle (combination of IO_COMPLETION_*)
1255 * ObjectAttributes [I] completion object attributes
1256 * NumberOfConcurrentThreads [I] desired number of concurrent active worker threads
1259 NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1260 POBJECT_ATTRIBUTES ObjectAttributes, ULONG NumberOfConcurrentThreads )
1264 TRACE("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess,
1265 ObjectAttributes, NumberOfConcurrentThreads);
1267 if (!CompletionPort)
1268 return STATUS_INVALID_PARAMETER;
1270 SERVER_START_REQ( create_completion )
1272 req->access = DesiredAccess;
1273 req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
1274 req->rootdir = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
1275 req->concurrent = NumberOfConcurrentThreads;
1276 if (ObjectAttributes && ObjectAttributes->ObjectName)
1277 wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1278 ObjectAttributes->ObjectName->Length );
1279 if (!(status = wine_server_call( req )))
1280 *CompletionPort = wine_server_ptr_handle( reply->handle );
1286 /******************************************************************
1287 * NtSetIoCompletion (NTDLL.@)
1288 * ZwSetIoCompletion (NTDLL.@)
1290 * Inserts completion message into queue
1293 * CompletionPort [I] HANDLE to completion object
1294 * CompletionKey [I] completion key
1295 * CompletionValue [I] completion value (usually pointer to OVERLAPPED)
1296 * Status [I] operation status
1297 * NumberOfBytesTransferred [I] number of bytes transferred
1299 NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKey,
1300 ULONG_PTR CompletionValue, NTSTATUS Status,
1301 ULONG NumberOfBytesTransferred )
1305 TRACE("(%p, %lx, %lx, %x, %d)\n", CompletionPort, CompletionKey,
1306 CompletionValue, Status, NumberOfBytesTransferred);
1308 SERVER_START_REQ( add_completion )
1310 req->handle = wine_server_obj_handle( CompletionPort );
1311 req->ckey = CompletionKey;
1312 req->cvalue = CompletionValue;
1313 req->status = Status;
1314 req->information = NumberOfBytesTransferred;
1315 status = wine_server_call( req );
1321 /******************************************************************
1322 * NtRemoveIoCompletion (NTDLL.@)
1323 * ZwRemoveIoCompletion (NTDLL.@)
1325 * (Wait for and) retrieve first completion message from completion object's queue
1328 * CompletionPort [I] HANDLE to I/O completion object
1329 * CompletionKey [O] completion key
1330 * CompletionValue [O] Completion value given in NtSetIoCompletion or in async operation
1331 * iosb [O] IO_STATUS_BLOCK of completed asynchronous operation
1332 * WaitTime [I] optional wait time in NTDLL format
1335 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE CompletionPort, PULONG_PTR CompletionKey,
1336 PULONG_PTR CompletionValue, PIO_STATUS_BLOCK iosb,
1337 PLARGE_INTEGER WaitTime )
1341 TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort, CompletionKey,
1342 CompletionValue, iosb, WaitTime);
1346 SERVER_START_REQ( remove_completion )
1348 req->handle = wine_server_obj_handle( CompletionPort );
1349 if (!(status = wine_server_call( req )))
1351 *CompletionKey = reply->ckey;
1352 *CompletionValue = reply->cvalue;
1353 iosb->Information = reply->information;
1354 iosb->u.Status = reply->status;
1358 if (status != STATUS_PENDING) break;
1360 status = NtWaitForSingleObject( CompletionPort, FALSE, WaitTime );
1361 if (status != WAIT_OBJECT_0) break;
1366 /******************************************************************
1367 * NtOpenIoCompletion (NTDLL.@)
1368 * ZwOpenIoCompletion (NTDLL.@)
1370 * Opens I/O completion object
1373 * CompletionPort [O] completion object handle will be placed there
1374 * DesiredAccess [I] desired access to a handle (combination of IO_COMPLETION_*)
1375 * ObjectAttributes [I] completion object name
1378 NTSTATUS WINAPI NtOpenIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1379 POBJECT_ATTRIBUTES ObjectAttributes )
1383 TRACE("(%p, 0x%x, %p)\n", CompletionPort, DesiredAccess, ObjectAttributes);
1385 if (!CompletionPort || !ObjectAttributes || !ObjectAttributes->ObjectName)
1386 return STATUS_INVALID_PARAMETER;
1388 SERVER_START_REQ( open_completion )
1390 req->access = DesiredAccess;
1391 req->rootdir = wine_server_obj_handle( ObjectAttributes->RootDirectory );
1392 wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1393 ObjectAttributes->ObjectName->Length );
1394 if (!(status = wine_server_call( req )))
1395 *CompletionPort = wine_server_ptr_handle( reply->handle );
1401 /******************************************************************
1402 * NtQueryIoCompletion (NTDLL.@)
1403 * ZwQueryIoCompletion (NTDLL.@)
1405 * Requests information about given I/O completion object
1408 * CompletionPort [I] HANDLE to completion port to request
1409 * InformationClass [I] information class
1410 * CompletionInformation [O] user-provided buffer for data
1411 * BufferLength [I] buffer length
1412 * RequiredLength [O] required buffer length
1415 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE CompletionPort, IO_COMPLETION_INFORMATION_CLASS InformationClass,
1416 PVOID CompletionInformation, ULONG BufferLength, PULONG RequiredLength )
1420 TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort, InformationClass, CompletionInformation,
1421 BufferLength, RequiredLength);
1423 if (!CompletionInformation) return STATUS_INVALID_PARAMETER;
1424 switch( InformationClass )
1426 case IoCompletionBasicInformation:
1428 ULONG *info = (ULONG *)CompletionInformation;
1430 if (RequiredLength) *RequiredLength = sizeof(*info);
1431 if (BufferLength != sizeof(*info))
1432 status = STATUS_INFO_LENGTH_MISMATCH;
1435 SERVER_START_REQ( query_completion )
1437 req->handle = wine_server_obj_handle( CompletionPort );
1438 if (!(status = wine_server_call( req )))
1439 *info = reply->depth;
1446 status = STATUS_INVALID_PARAMETER;
1452 NTSTATUS NTDLL_AddCompletion( HANDLE hFile, ULONG_PTR CompletionValue,
1453 NTSTATUS CompletionStatus, ULONG Information )
1457 SERVER_START_REQ( add_fd_completion )
1459 req->handle = wine_server_obj_handle( hFile );
1460 req->cvalue = CompletionValue;
1461 req->status = CompletionStatus;
1462 req->information = Information;
1463 status = wine_server_call( req );