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
25 #include "wine/port.h"
30 #ifdef HAVE_SYS_TIME_H
31 # include <sys/time.h>
36 #ifdef HAVE_SYS_POLL_H
37 # include <sys/poll.h>
52 #define WIN32_NO_STATUS
53 #define NONAMELESSUNION
56 #include "wine/server.h"
57 #include "wine/debug.h"
58 #include "ntdll_misc.h"
60 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
62 HANDLE keyed_event
= NULL
;
64 static inline int interlocked_dec_if_nonzero( int *dest
)
67 for (val
= *dest
;; val
= tmp
)
69 if (!val
|| (tmp
= interlocked_cmpxchg( dest
, val
- 1, val
)) == val
)
75 /* creates a struct security_descriptor and contained information in one contiguous piece of memory */
76 NTSTATUS
alloc_object_attributes( const OBJECT_ATTRIBUTES
*attr
, struct object_attributes
**ret
,
77 data_size_t
*ret_len
)
79 unsigned int len
= sizeof(**ret
);
82 BOOLEAN owner_present
, group_present
, dacl_present
, sacl_present
, defaulted
;
83 PSECURITY_DESCRIPTOR sd
;
89 if (!attr
) return STATUS_SUCCESS
;
91 if (attr
->Length
!= sizeof(*attr
)) return STATUS_INVALID_PARAMETER
;
93 if ((sd
= attr
->SecurityDescriptor
))
95 len
+= sizeof(struct security_descriptor
);
97 if ((status
= RtlGetOwnerSecurityDescriptor( sd
, &owner
, &owner_present
))) return status
;
98 if ((status
= RtlGetGroupSecurityDescriptor( sd
, &group
, &group_present
))) return status
;
99 if ((status
= RtlGetSaclSecurityDescriptor( sd
, &sacl_present
, &sacl
, &defaulted
))) return status
;
100 if ((status
= RtlGetDaclSecurityDescriptor( sd
, &dacl_present
, &dacl
, &defaulted
))) return status
;
101 if (owner_present
) len
+= RtlLengthSid( owner
);
102 if (group_present
) len
+= RtlLengthSid( group
);
103 if (sacl_present
&& sacl
) len
+= sacl
->AclSize
;
104 if (dacl_present
&& dacl
) len
+= dacl
->AclSize
;
106 /* fix alignment for the Unicode name that follows the structure */
107 len
= (len
+ sizeof(WCHAR
) - 1) & ~(sizeof(WCHAR
) - 1);
110 if (attr
->ObjectName
)
112 if (attr
->ObjectName
->Length
& (sizeof(WCHAR
) - 1)) return STATUS_OBJECT_NAME_INVALID
;
113 len
+= attr
->ObjectName
->Length
;
115 else if (attr
->RootDirectory
) return STATUS_OBJECT_NAME_INVALID
;
117 *ret
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, len
);
118 if (!*ret
) return STATUS_NO_MEMORY
;
120 (*ret
)->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
121 (*ret
)->attributes
= attr
->Attributes
;
123 if (attr
->SecurityDescriptor
)
125 struct security_descriptor
*descr
= (struct security_descriptor
*)(*ret
+ 1);
126 unsigned char *ptr
= (unsigned char *)(descr
+ 1);
128 descr
->control
= ((SECURITY_DESCRIPTOR
*)sd
)->Control
& ~SE_SELF_RELATIVE
;
129 if (owner_present
) descr
->owner_len
= RtlLengthSid( owner
);
130 if (group_present
) descr
->group_len
= RtlLengthSid( group
);
131 if (sacl_present
&& sacl
) descr
->sacl_len
= sacl
->AclSize
;
132 if (dacl_present
&& dacl
) descr
->dacl_len
= dacl
->AclSize
;
134 memcpy( ptr
, owner
, descr
->owner_len
);
135 ptr
+= descr
->owner_len
;
136 memcpy( ptr
, group
, descr
->group_len
);
137 ptr
+= descr
->group_len
;
138 memcpy( ptr
, sacl
, descr
->sacl_len
);
139 ptr
+= descr
->sacl_len
;
140 memcpy( ptr
, dacl
, descr
->dacl_len
);
141 (*ret
)->sd_len
= (sizeof(*descr
) + descr
->owner_len
+ descr
->group_len
+ descr
->sacl_len
+
142 descr
->dacl_len
+ sizeof(WCHAR
) - 1) & ~(sizeof(WCHAR
) - 1);
145 if (attr
->ObjectName
)
147 unsigned char *ptr
= (unsigned char *)(*ret
+ 1) + (*ret
)->sd_len
;
148 (*ret
)->name_len
= attr
->ObjectName
->Length
;
149 memcpy( ptr
, attr
->ObjectName
->Buffer
, (*ret
)->name_len
);
153 return STATUS_SUCCESS
;
156 NTSTATUS
validate_open_object_attributes( const OBJECT_ATTRIBUTES
*attr
)
158 if (!attr
|| attr
->Length
!= sizeof(*attr
)) return STATUS_INVALID_PARAMETER
;
160 if (attr
->ObjectName
)
162 if (attr
->ObjectName
->Length
& (sizeof(WCHAR
) - 1)) return STATUS_OBJECT_NAME_INVALID
;
164 else if (attr
->RootDirectory
) return STATUS_OBJECT_NAME_INVALID
;
166 return STATUS_SUCCESS
;
173 /******************************************************************************
174 * NtCreateSemaphore (NTDLL.@)
176 NTSTATUS WINAPI
NtCreateSemaphore( OUT PHANDLE SemaphoreHandle
,
177 IN ACCESS_MASK access
,
178 IN
const OBJECT_ATTRIBUTES
*attr OPTIONAL
,
179 IN LONG InitialCount
,
180 IN LONG MaximumCount
)
184 struct object_attributes
*objattr
;
186 if (MaximumCount
<= 0 || InitialCount
< 0 || InitialCount
> MaximumCount
)
187 return STATUS_INVALID_PARAMETER
;
189 if ((ret
= alloc_object_attributes( attr
, &objattr
, &len
))) return ret
;
191 SERVER_START_REQ( create_semaphore
)
193 req
->access
= access
;
194 req
->initial
= InitialCount
;
195 req
->max
= MaximumCount
;
196 wine_server_add_data( req
, objattr
, len
);
197 ret
= wine_server_call( req
);
198 *SemaphoreHandle
= wine_server_ptr_handle( reply
->handle
);
202 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
206 /******************************************************************************
207 * NtOpenSemaphore (NTDLL.@)
209 NTSTATUS WINAPI
NtOpenSemaphore( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
213 if ((ret
= validate_open_object_attributes( attr
))) return ret
;
215 SERVER_START_REQ( open_semaphore
)
217 req
->access
= access
;
218 req
->attributes
= attr
->Attributes
;
219 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
220 if (attr
->ObjectName
)
221 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
222 ret
= wine_server_call( req
);
223 *handle
= wine_server_ptr_handle( reply
->handle
);
229 /******************************************************************************
230 * NtQuerySemaphore (NTDLL.@)
232 NTSTATUS WINAPI
NtQuerySemaphore( HANDLE handle
, SEMAPHORE_INFORMATION_CLASS
class,
233 void *info
, ULONG len
, ULONG
*ret_len
)
236 SEMAPHORE_BASIC_INFORMATION
*out
= info
;
238 if (class != SemaphoreBasicInformation
)
240 FIXME("(%p,%d,%u) Unknown class\n", handle
, class, len
);
241 return STATUS_INVALID_INFO_CLASS
;
244 if (len
!= sizeof(SEMAPHORE_BASIC_INFORMATION
)) return STATUS_INFO_LENGTH_MISMATCH
;
246 SERVER_START_REQ( query_semaphore
)
248 req
->handle
= wine_server_obj_handle( handle
);
249 if (!(ret
= wine_server_call( req
)))
251 out
->CurrentCount
= reply
->current
;
252 out
->MaximumCount
= reply
->max
;
253 if (ret_len
) *ret_len
= sizeof(SEMAPHORE_BASIC_INFORMATION
);
261 /******************************************************************************
262 * NtReleaseSemaphore (NTDLL.@)
264 NTSTATUS WINAPI
NtReleaseSemaphore( HANDLE handle
, ULONG count
, PULONG previous
)
267 SERVER_START_REQ( release_semaphore
)
269 req
->handle
= wine_server_obj_handle( handle
);
271 if (!(ret
= wine_server_call( req
)))
273 if (previous
) *previous
= reply
->prev_count
;
284 /**************************************************************************
285 * NtCreateEvent (NTDLL.@)
286 * ZwCreateEvent (NTDLL.@)
288 NTSTATUS WINAPI
NtCreateEvent( PHANDLE EventHandle
, ACCESS_MASK DesiredAccess
,
289 const OBJECT_ATTRIBUTES
*attr
, EVENT_TYPE type
, BOOLEAN InitialState
)
293 struct object_attributes
*objattr
;
295 if ((ret
= alloc_object_attributes( attr
, &objattr
, &len
))) return ret
;
297 SERVER_START_REQ( create_event
)
299 req
->access
= DesiredAccess
;
300 req
->manual_reset
= (type
== NotificationEvent
);
301 req
->initial_state
= InitialState
;
302 wine_server_add_data( req
, objattr
, len
);
303 ret
= wine_server_call( req
);
304 *EventHandle
= wine_server_ptr_handle( reply
->handle
);
308 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
312 /******************************************************************************
313 * NtOpenEvent (NTDLL.@)
314 * ZwOpenEvent (NTDLL.@)
316 NTSTATUS WINAPI
NtOpenEvent( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
320 if ((ret
= validate_open_object_attributes( attr
))) return ret
;
322 SERVER_START_REQ( open_event
)
324 req
->access
= access
;
325 req
->attributes
= attr
->Attributes
;
326 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
327 if (attr
->ObjectName
)
328 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
329 ret
= wine_server_call( req
);
330 *handle
= wine_server_ptr_handle( reply
->handle
);
337 /******************************************************************************
338 * NtSetEvent (NTDLL.@)
339 * ZwSetEvent (NTDLL.@)
341 NTSTATUS WINAPI
NtSetEvent( HANDLE handle
, PULONG NumberOfThreadsReleased
)
345 /* FIXME: set NumberOfThreadsReleased */
347 SERVER_START_REQ( event_op
)
349 req
->handle
= wine_server_obj_handle( handle
);
351 ret
= wine_server_call( req
);
357 /******************************************************************************
358 * NtResetEvent (NTDLL.@)
360 NTSTATUS WINAPI
NtResetEvent( HANDLE handle
, PULONG NumberOfThreadsReleased
)
364 /* resetting an event can't release any thread... */
365 if (NumberOfThreadsReleased
) *NumberOfThreadsReleased
= 0;
367 SERVER_START_REQ( event_op
)
369 req
->handle
= wine_server_obj_handle( handle
);
370 req
->op
= RESET_EVENT
;
371 ret
= wine_server_call( req
);
377 /******************************************************************************
378 * NtClearEvent (NTDLL.@)
381 * same as NtResetEvent ???
383 NTSTATUS WINAPI
NtClearEvent ( HANDLE handle
)
385 return NtResetEvent( handle
, NULL
);
388 /******************************************************************************
389 * NtPulseEvent (NTDLL.@)
394 NTSTATUS WINAPI
NtPulseEvent( HANDLE handle
, PULONG PulseCount
)
399 FIXME("(%p,%d)\n", handle
, *PulseCount
);
401 SERVER_START_REQ( event_op
)
403 req
->handle
= wine_server_obj_handle( handle
);
404 req
->op
= PULSE_EVENT
;
405 ret
= wine_server_call( req
);
411 /******************************************************************************
412 * NtQueryEvent (NTDLL.@)
414 NTSTATUS WINAPI
NtQueryEvent( HANDLE handle
, EVENT_INFORMATION_CLASS
class,
415 void *info
, ULONG len
, ULONG
*ret_len
)
418 EVENT_BASIC_INFORMATION
*out
= info
;
420 if (class != EventBasicInformation
)
422 FIXME("(%p, %d, %d) Unknown class\n",
424 return STATUS_INVALID_INFO_CLASS
;
427 if (len
!= sizeof(EVENT_BASIC_INFORMATION
)) return STATUS_INFO_LENGTH_MISMATCH
;
429 SERVER_START_REQ( query_event
)
431 req
->handle
= wine_server_obj_handle( handle
);
432 if (!(ret
= wine_server_call( req
)))
434 out
->EventType
= reply
->manual_reset
? NotificationEvent
: SynchronizationEvent
;
435 out
->EventState
= reply
->state
;
436 if (ret_len
) *ret_len
= sizeof(EVENT_BASIC_INFORMATION
);
445 * Mutants (known as Mutexes in Kernel32)
448 /******************************************************************************
449 * NtCreateMutant [NTDLL.@]
450 * ZwCreateMutant [NTDLL.@]
452 NTSTATUS WINAPI
NtCreateMutant(OUT HANDLE
* MutantHandle
,
453 IN ACCESS_MASK access
,
454 IN
const OBJECT_ATTRIBUTES
* attr OPTIONAL
,
455 IN BOOLEAN InitialOwner
)
459 struct object_attributes
*objattr
;
461 if ((status
= alloc_object_attributes( attr
, &objattr
, &len
))) return status
;
463 SERVER_START_REQ( create_mutex
)
465 req
->access
= access
;
466 req
->owned
= InitialOwner
;
467 wine_server_add_data( req
, objattr
, len
);
468 status
= wine_server_call( req
);
469 *MutantHandle
= wine_server_ptr_handle( reply
->handle
);
473 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
477 /**************************************************************************
478 * NtOpenMutant [NTDLL.@]
479 * ZwOpenMutant [NTDLL.@]
481 NTSTATUS WINAPI
NtOpenMutant( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
485 if ((status
= validate_open_object_attributes( attr
))) return status
;
487 SERVER_START_REQ( open_mutex
)
489 req
->access
= access
;
490 req
->attributes
= attr
->Attributes
;
491 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
492 if (attr
->ObjectName
)
493 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
494 status
= wine_server_call( req
);
495 *handle
= wine_server_ptr_handle( reply
->handle
);
501 /**************************************************************************
502 * NtReleaseMutant [NTDLL.@]
503 * ZwReleaseMutant [NTDLL.@]
505 NTSTATUS WINAPI
NtReleaseMutant( IN HANDLE handle
, OUT PLONG prev_count OPTIONAL
)
509 SERVER_START_REQ( release_mutex
)
511 req
->handle
= wine_server_obj_handle( handle
);
512 status
= wine_server_call( req
);
513 if (prev_count
) *prev_count
= reply
->prev_count
;
519 /******************************************************************
520 * NtQueryMutant [NTDLL.@]
521 * ZwQueryMutant [NTDLL.@]
523 NTSTATUS WINAPI
NtQueryMutant(IN HANDLE handle
,
524 IN MUTANT_INFORMATION_CLASS MutantInformationClass
,
525 OUT PVOID MutantInformation
,
526 IN ULONG MutantInformationLength
,
527 OUT PULONG ResultLength OPTIONAL
)
529 FIXME("(%p %u %p %u %p): stub!\n",
530 handle
, MutantInformationClass
, MutantInformation
, MutantInformationLength
, ResultLength
);
531 return STATUS_NOT_IMPLEMENTED
;
538 /******************************************************************************
539 * NtCreateJobObject [NTDLL.@]
540 * ZwCreateJobObject [NTDLL.@]
542 NTSTATUS WINAPI
NtCreateJobObject( PHANDLE handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
546 struct object_attributes
*objattr
;
548 if ((ret
= alloc_object_attributes( attr
, &objattr
, &len
))) return ret
;
550 SERVER_START_REQ( create_job
)
552 req
->access
= access
;
553 wine_server_add_data( req
, objattr
, len
);
554 ret
= wine_server_call( req
);
555 *handle
= wine_server_ptr_handle( reply
->handle
);
559 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
563 /******************************************************************************
564 * NtOpenJobObject [NTDLL.@]
565 * ZwOpenJobObject [NTDLL.@]
567 NTSTATUS WINAPI
NtOpenJobObject( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
571 if ((ret
= validate_open_object_attributes( attr
))) return ret
;
573 SERVER_START_REQ( open_job
)
575 req
->access
= access
;
576 req
->attributes
= attr
->Attributes
;
577 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
578 if (attr
->ObjectName
)
579 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
580 ret
= wine_server_call( req
);
581 *handle
= wine_server_ptr_handle( reply
->handle
);
587 /******************************************************************************
588 * NtTerminateJobObject [NTDLL.@]
589 * ZwTerminateJobObject [NTDLL.@]
591 NTSTATUS WINAPI
NtTerminateJobObject( HANDLE handle
, NTSTATUS status
)
595 TRACE( "(%p, %d)\n", handle
, status
);
597 SERVER_START_REQ( terminate_job
)
599 req
->handle
= wine_server_obj_handle( handle
);
600 req
->status
= status
;
601 ret
= wine_server_call( req
);
608 /******************************************************************************
609 * NtQueryInformationJobObject [NTDLL.@]
610 * ZwQueryInformationJobObject [NTDLL.@]
612 NTSTATUS WINAPI
NtQueryInformationJobObject( HANDLE handle
, JOBOBJECTINFOCLASS
class, PVOID info
,
613 ULONG len
, PULONG ret_len
)
615 FIXME( "stub: %p %u %p %u %p\n", handle
, class, info
, len
, ret_len
);
617 if (class >= MaxJobObjectInfoClass
)
618 return STATUS_INVALID_PARAMETER
;
622 case JobObjectExtendedLimitInformation
:
624 JOBOBJECT_EXTENDED_LIMIT_INFORMATION
*extended_limit
;
625 if (len
< sizeof(*extended_limit
))
626 return STATUS_INFO_LENGTH_MISMATCH
;
628 extended_limit
= (JOBOBJECT_EXTENDED_LIMIT_INFORMATION
*)info
;
629 memset(extended_limit
, 0, sizeof(*extended_limit
));
630 if (ret_len
) *ret_len
= sizeof(*extended_limit
);
631 return STATUS_SUCCESS
;
634 case JobObjectBasicLimitInformation
:
636 JOBOBJECT_BASIC_LIMIT_INFORMATION
*basic_limit
;
637 if (len
< sizeof(*basic_limit
))
638 return STATUS_INFO_LENGTH_MISMATCH
;
640 basic_limit
= (JOBOBJECT_BASIC_LIMIT_INFORMATION
*)info
;
641 memset(basic_limit
, 0, sizeof(*basic_limit
));
642 if (ret_len
) *ret_len
= sizeof(*basic_limit
);
643 return STATUS_SUCCESS
;
647 return STATUS_NOT_IMPLEMENTED
;
651 /******************************************************************************
652 * NtSetInformationJobObject [NTDLL.@]
653 * ZwSetInformationJobObject [NTDLL.@]
655 NTSTATUS WINAPI
NtSetInformationJobObject( HANDLE handle
, JOBOBJECTINFOCLASS
class, PVOID info
, ULONG len
)
657 NTSTATUS status
= STATUS_NOT_IMPLEMENTED
;
658 JOBOBJECT_BASIC_LIMIT_INFORMATION
*basic_limit
;
659 ULONG info_size
= sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION
);
660 DWORD limit_flags
= JOB_OBJECT_BASIC_LIMIT_VALID_FLAGS
;
662 TRACE( "(%p, %u, %p, %u)\n", handle
, class, info
, len
);
664 if (class >= MaxJobObjectInfoClass
)
665 return STATUS_INVALID_PARAMETER
;
670 case JobObjectExtendedLimitInformation
:
671 info_size
= sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION
);
672 limit_flags
= JOB_OBJECT_EXTENDED_LIMIT_VALID_FLAGS
;
674 case JobObjectBasicLimitInformation
:
675 if (len
!= info_size
)
676 return STATUS_INVALID_PARAMETER
;
679 if (basic_limit
->LimitFlags
& ~limit_flags
)
680 return STATUS_INVALID_PARAMETER
;
682 SERVER_START_REQ( set_job_limits
)
684 req
->handle
= wine_server_obj_handle( handle
);
685 req
->limit_flags
= basic_limit
->LimitFlags
;
686 status
= wine_server_call( req
);
691 case JobObjectAssociateCompletionPortInformation
:
692 if (len
!= sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT
))
693 return STATUS_INVALID_PARAMETER
;
695 SERVER_START_REQ( set_job_completion_port
)
697 JOBOBJECT_ASSOCIATE_COMPLETION_PORT
*port_info
= info
;
698 req
->job
= wine_server_obj_handle( handle
);
699 req
->port
= wine_server_obj_handle( port_info
->CompletionPort
);
700 req
->key
= wine_server_client_ptr( port_info
->CompletionKey
);
701 status
= wine_server_call(req
);
706 case JobObjectBasicUIRestrictions
:
707 status
= STATUS_SUCCESS
;
710 FIXME( "stub: %p %u %p %u\n", handle
, class, info
, len
);
716 /******************************************************************************
717 * NtIsProcessInJob [NTDLL.@]
718 * ZwIsProcessInJob [NTDLL.@]
720 NTSTATUS WINAPI
NtIsProcessInJob( HANDLE process
, HANDLE job
)
724 TRACE( "(%p %p)\n", job
, process
);
726 SERVER_START_REQ( process_in_job
)
728 req
->job
= wine_server_obj_handle( job
);
729 req
->process
= wine_server_obj_handle( process
);
730 status
= wine_server_call( req
);
737 /******************************************************************************
738 * NtAssignProcessToJobObject [NTDLL.@]
739 * ZwAssignProcessToJobObject [NTDLL.@]
741 NTSTATUS WINAPI
NtAssignProcessToJobObject( HANDLE job
, HANDLE process
)
745 TRACE( "(%p %p)\n", job
, process
);
747 SERVER_START_REQ( assign_job
)
749 req
->job
= wine_server_obj_handle( job
);
750 req
->process
= wine_server_obj_handle( process
);
751 status
= wine_server_call( req
);
762 /**************************************************************************
763 * NtCreateTimer [NTDLL.@]
764 * ZwCreateTimer [NTDLL.@]
766 NTSTATUS WINAPI
NtCreateTimer(OUT HANDLE
*handle
,
767 IN ACCESS_MASK access
,
768 IN
const OBJECT_ATTRIBUTES
*attr OPTIONAL
,
769 IN TIMER_TYPE timer_type
)
773 struct object_attributes
*objattr
;
775 if (timer_type
!= NotificationTimer
&& timer_type
!= SynchronizationTimer
)
776 return STATUS_INVALID_PARAMETER
;
778 if ((status
= alloc_object_attributes( attr
, &objattr
, &len
))) return status
;
780 SERVER_START_REQ( create_timer
)
782 req
->access
= access
;
783 req
->manual
= (timer_type
== NotificationTimer
);
784 wine_server_add_data( req
, objattr
, len
);
785 status
= wine_server_call( req
);
786 *handle
= wine_server_ptr_handle( reply
->handle
);
790 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
795 /**************************************************************************
796 * NtOpenTimer [NTDLL.@]
797 * ZwOpenTimer [NTDLL.@]
799 NTSTATUS WINAPI
NtOpenTimer( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
803 if ((status
= validate_open_object_attributes( attr
))) return status
;
805 SERVER_START_REQ( open_timer
)
807 req
->access
= access
;
808 req
->attributes
= attr
->Attributes
;
809 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
810 if (attr
->ObjectName
)
811 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
812 status
= wine_server_call( req
);
813 *handle
= wine_server_ptr_handle( reply
->handle
);
819 /**************************************************************************
820 * NtSetTimer [NTDLL.@]
821 * ZwSetTimer [NTDLL.@]
823 NTSTATUS WINAPI
NtSetTimer(IN HANDLE handle
,
824 IN
const LARGE_INTEGER
* when
,
825 IN PTIMER_APC_ROUTINE callback
,
826 IN PVOID callback_arg
,
828 IN ULONG period OPTIONAL
,
829 OUT PBOOLEAN state OPTIONAL
)
831 NTSTATUS status
= STATUS_SUCCESS
;
833 TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
834 handle
, when
, callback
, callback_arg
, resume
, period
, state
);
836 SERVER_START_REQ( set_timer
)
838 req
->handle
= wine_server_obj_handle( handle
);
839 req
->period
= period
;
840 req
->expire
= when
->QuadPart
;
841 req
->callback
= wine_server_client_ptr( callback
);
842 req
->arg
= wine_server_client_ptr( callback_arg
);
843 status
= wine_server_call( req
);
844 if (state
) *state
= reply
->signaled
;
848 /* set error but can still succeed */
849 if (resume
&& status
== STATUS_SUCCESS
) return STATUS_TIMER_RESUME_IGNORED
;
853 /**************************************************************************
854 * NtCancelTimer [NTDLL.@]
855 * ZwCancelTimer [NTDLL.@]
857 NTSTATUS WINAPI
NtCancelTimer(IN HANDLE handle
, OUT BOOLEAN
* state
)
861 SERVER_START_REQ( cancel_timer
)
863 req
->handle
= wine_server_obj_handle( handle
);
864 status
= wine_server_call( req
);
865 if (state
) *state
= reply
->signaled
;
871 /******************************************************************************
872 * NtQueryTimer (NTDLL.@)
874 * Retrieves information about a timer.
877 * TimerHandle [I] The timer to retrieve information about.
878 * TimerInformationClass [I] The type of information to retrieve.
879 * TimerInformation [O] Pointer to buffer to store information in.
880 * Length [I] The length of the buffer pointed to by TimerInformation.
881 * ReturnLength [O] Optional. The size of buffer actually used.
884 * Success: STATUS_SUCCESS
885 * Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
886 * size for the class specified.
887 * STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
888 * STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
891 NTSTATUS WINAPI
NtQueryTimer(
893 TIMER_INFORMATION_CLASS TimerInformationClass
,
894 PVOID TimerInformation
,
898 TIMER_BASIC_INFORMATION
* basic_info
= TimerInformation
;
902 TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle
, TimerInformationClass
,
903 TimerInformation
, Length
, ReturnLength
);
905 switch (TimerInformationClass
)
907 case TimerBasicInformation
:
908 if (Length
< sizeof(TIMER_BASIC_INFORMATION
))
909 return STATUS_INFO_LENGTH_MISMATCH
;
911 SERVER_START_REQ(get_timer_info
)
913 req
->handle
= wine_server_obj_handle( TimerHandle
);
914 status
= wine_server_call(req
);
916 /* convert server time to absolute NTDLL time */
917 basic_info
->RemainingTime
.QuadPart
= reply
->when
;
918 basic_info
->TimerState
= reply
->signaled
;
922 /* convert from absolute into relative time */
923 NtQuerySystemTime(&now
);
924 if (now
.QuadPart
> basic_info
->RemainingTime
.QuadPart
)
925 basic_info
->RemainingTime
.QuadPart
= 0;
927 basic_info
->RemainingTime
.QuadPart
-= now
.QuadPart
;
929 if (ReturnLength
) *ReturnLength
= sizeof(TIMER_BASIC_INFORMATION
);
934 FIXME("Unhandled class %d\n", TimerInformationClass
);
935 return STATUS_INVALID_INFO_CLASS
;
939 /******************************************************************************
940 * NtQueryTimerResolution [NTDLL.@]
942 NTSTATUS WINAPI
NtQueryTimerResolution(OUT ULONG
* min_resolution
,
943 OUT ULONG
* max_resolution
,
944 OUT ULONG
* current_resolution
)
946 FIXME("(%p,%p,%p), stub!\n",
947 min_resolution
, max_resolution
, current_resolution
);
949 return STATUS_NOT_IMPLEMENTED
;
952 /******************************************************************************
953 * NtSetTimerResolution [NTDLL.@]
955 NTSTATUS WINAPI
NtSetTimerResolution(IN ULONG resolution
,
956 IN BOOLEAN set_resolution
,
957 OUT ULONG
* current_resolution
)
959 FIXME("(%u,%u,%p), stub!\n",
960 resolution
, set_resolution
, current_resolution
);
962 return STATUS_NOT_IMPLEMENTED
;
967 /* wait operations */
969 static NTSTATUS
wait_objects( DWORD count
, const HANDLE
*handles
,
970 BOOLEAN wait_any
, BOOLEAN alertable
,
971 const LARGE_INTEGER
*timeout
)
973 select_op_t select_op
;
974 UINT i
, flags
= SELECT_INTERRUPTIBLE
;
976 if (!count
|| count
> MAXIMUM_WAIT_OBJECTS
) return STATUS_INVALID_PARAMETER_1
;
978 if (alertable
) flags
|= SELECT_ALERTABLE
;
979 select_op
.wait
.op
= wait_any
? SELECT_WAIT
: SELECT_WAIT_ALL
;
980 for (i
= 0; i
< count
; i
++) select_op
.wait
.handles
[i
] = wine_server_obj_handle( handles
[i
] );
981 return server_select( &select_op
, offsetof( select_op_t
, wait
.handles
[count
] ), flags
, timeout
);
985 /******************************************************************
986 * NtWaitForMultipleObjects (NTDLL.@)
988 NTSTATUS WINAPI
NtWaitForMultipleObjects( DWORD count
, const HANDLE
*handles
,
989 BOOLEAN wait_any
, BOOLEAN alertable
,
990 const LARGE_INTEGER
*timeout
)
992 return wait_objects( count
, handles
, wait_any
, alertable
, timeout
);
996 /******************************************************************
997 * NtWaitForSingleObject (NTDLL.@)
999 NTSTATUS WINAPI
NtWaitForSingleObject(HANDLE handle
, BOOLEAN alertable
, const LARGE_INTEGER
*timeout
)
1001 return wait_objects( 1, &handle
, FALSE
, alertable
, timeout
);
1005 /******************************************************************
1006 * NtSignalAndWaitForSingleObject (NTDLL.@)
1008 NTSTATUS WINAPI
NtSignalAndWaitForSingleObject( HANDLE hSignalObject
, HANDLE hWaitObject
,
1009 BOOLEAN alertable
, const LARGE_INTEGER
*timeout
)
1011 select_op_t select_op
;
1012 UINT flags
= SELECT_INTERRUPTIBLE
;
1014 if (!hSignalObject
) return STATUS_INVALID_HANDLE
;
1016 if (alertable
) flags
|= SELECT_ALERTABLE
;
1017 select_op
.signal_and_wait
.op
= SELECT_SIGNAL_AND_WAIT
;
1018 select_op
.signal_and_wait
.wait
= wine_server_obj_handle( hWaitObject
);
1019 select_op
.signal_and_wait
.signal
= wine_server_obj_handle( hSignalObject
);
1020 return server_select( &select_op
, sizeof(select_op
.signal_and_wait
), flags
, timeout
);
1024 /******************************************************************
1025 * NtYieldExecution (NTDLL.@)
1027 NTSTATUS WINAPI
NtYieldExecution(void)
1029 #ifdef HAVE_SCHED_YIELD
1031 return STATUS_SUCCESS
;
1033 return STATUS_NO_YIELD_PERFORMED
;
1038 /******************************************************************
1039 * NtDelayExecution (NTDLL.@)
1041 NTSTATUS WINAPI
NtDelayExecution( BOOLEAN alertable
, const LARGE_INTEGER
*timeout
)
1043 /* if alertable, we need to query the server */
1045 return server_select( NULL
, 0, SELECT_INTERRUPTIBLE
| SELECT_ALERTABLE
, timeout
);
1047 if (!timeout
|| timeout
->QuadPart
== TIMEOUT_INFINITE
) /* sleep forever */
1049 for (;;) select( 0, NULL
, NULL
, NULL
, NULL
);
1054 timeout_t when
, diff
;
1056 if ((when
= timeout
->QuadPart
) < 0)
1058 NtQuerySystemTime( &now
);
1059 when
= now
.QuadPart
- when
;
1062 /* Note that we yield after establishing the desired timeout */
1064 if (!when
) return STATUS_SUCCESS
;
1069 NtQuerySystemTime( &now
);
1070 diff
= (when
- now
.QuadPart
+ 9) / 10;
1071 if (diff
<= 0) break;
1072 tv
.tv_sec
= diff
/ 1000000;
1073 tv
.tv_usec
= diff
% 1000000;
1074 if (select( 0, NULL
, NULL
, NULL
, &tv
) != -1) break;
1077 return STATUS_SUCCESS
;
1081 /******************************************************************************
1082 * NtCreateKeyedEvent (NTDLL.@)
1084 NTSTATUS WINAPI
NtCreateKeyedEvent( HANDLE
*handle
, ACCESS_MASK access
,
1085 const OBJECT_ATTRIBUTES
*attr
, ULONG flags
)
1089 struct object_attributes
*objattr
;
1091 if ((ret
= alloc_object_attributes( attr
, &objattr
, &len
))) return ret
;
1093 SERVER_START_REQ( create_keyed_event
)
1095 req
->access
= access
;
1096 wine_server_add_data( req
, objattr
, len
);
1097 ret
= wine_server_call( req
);
1098 *handle
= wine_server_ptr_handle( reply
->handle
);
1102 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
1106 /******************************************************************************
1107 * NtOpenKeyedEvent (NTDLL.@)
1109 NTSTATUS WINAPI
NtOpenKeyedEvent( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
1113 if ((ret
= validate_open_object_attributes( attr
))) return ret
;
1115 SERVER_START_REQ( open_keyed_event
)
1117 req
->access
= access
;
1118 req
->attributes
= attr
->Attributes
;
1119 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
1120 if (attr
->ObjectName
)
1121 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
1122 ret
= wine_server_call( req
);
1123 *handle
= wine_server_ptr_handle( reply
->handle
);
1129 /******************************************************************************
1130 * NtWaitForKeyedEvent (NTDLL.@)
1132 NTSTATUS WINAPI
NtWaitForKeyedEvent( HANDLE handle
, const void *key
,
1133 BOOLEAN alertable
, const LARGE_INTEGER
*timeout
)
1135 select_op_t select_op
;
1136 UINT flags
= SELECT_INTERRUPTIBLE
;
1138 if ((ULONG_PTR
)key
& 1) return STATUS_INVALID_PARAMETER_1
;
1139 if (alertable
) flags
|= SELECT_ALERTABLE
;
1140 select_op
.keyed_event
.op
= SELECT_KEYED_EVENT_WAIT
;
1141 select_op
.keyed_event
.handle
= wine_server_obj_handle( handle
);
1142 select_op
.keyed_event
.key
= wine_server_client_ptr( key
);
1143 return server_select( &select_op
, sizeof(select_op
.keyed_event
), flags
, timeout
);
1146 /******************************************************************************
1147 * NtReleaseKeyedEvent (NTDLL.@)
1149 NTSTATUS WINAPI
NtReleaseKeyedEvent( HANDLE handle
, const void *key
,
1150 BOOLEAN alertable
, const LARGE_INTEGER
*timeout
)
1152 select_op_t select_op
;
1153 UINT flags
= SELECT_INTERRUPTIBLE
;
1155 if ((ULONG_PTR
)key
& 1) return STATUS_INVALID_PARAMETER_1
;
1156 if (alertable
) flags
|= SELECT_ALERTABLE
;
1157 select_op
.keyed_event
.op
= SELECT_KEYED_EVENT_RELEASE
;
1158 select_op
.keyed_event
.handle
= wine_server_obj_handle( handle
);
1159 select_op
.keyed_event
.key
= wine_server_client_ptr( key
);
1160 return server_select( &select_op
, sizeof(select_op
.keyed_event
), flags
, timeout
);
1163 /******************************************************************
1164 * NtCreateIoCompletion (NTDLL.@)
1165 * ZwCreateIoCompletion (NTDLL.@)
1167 * Creates I/O completion object.
1170 * CompletionPort [O] created completion object handle will be placed there
1171 * DesiredAccess [I] desired access to a handle (combination of IO_COMPLETION_*)
1172 * ObjectAttributes [I] completion object attributes
1173 * NumberOfConcurrentThreads [I] desired number of concurrent active worker threads
1176 NTSTATUS WINAPI
NtCreateIoCompletion( PHANDLE CompletionPort
, ACCESS_MASK DesiredAccess
,
1177 POBJECT_ATTRIBUTES attr
, ULONG NumberOfConcurrentThreads
)
1181 struct object_attributes
*objattr
;
1183 TRACE("(%p, %x, %p, %d)\n", CompletionPort
, DesiredAccess
, attr
, NumberOfConcurrentThreads
);
1185 if (!CompletionPort
)
1186 return STATUS_INVALID_PARAMETER
;
1188 if ((status
= alloc_object_attributes( attr
, &objattr
, &len
))) return status
;
1190 SERVER_START_REQ( create_completion
)
1192 req
->access
= DesiredAccess
;
1193 req
->concurrent
= NumberOfConcurrentThreads
;
1194 wine_server_add_data( req
, objattr
, len
);
1195 if (!(status
= wine_server_call( req
)))
1196 *CompletionPort
= wine_server_ptr_handle( reply
->handle
);
1200 RtlFreeHeap( GetProcessHeap(), 0, objattr
);
1204 /******************************************************************
1205 * NtSetIoCompletion (NTDLL.@)
1206 * ZwSetIoCompletion (NTDLL.@)
1208 * Inserts completion message into queue
1211 * CompletionPort [I] HANDLE to completion object
1212 * CompletionKey [I] completion key
1213 * CompletionValue [I] completion value (usually pointer to OVERLAPPED)
1214 * Status [I] operation status
1215 * NumberOfBytesTransferred [I] number of bytes transferred
1217 NTSTATUS WINAPI
NtSetIoCompletion( HANDLE CompletionPort
, ULONG_PTR CompletionKey
,
1218 ULONG_PTR CompletionValue
, NTSTATUS Status
,
1219 SIZE_T NumberOfBytesTransferred
)
1223 TRACE("(%p, %lx, %lx, %x, %lx)\n", CompletionPort
, CompletionKey
,
1224 CompletionValue
, Status
, NumberOfBytesTransferred
);
1226 SERVER_START_REQ( add_completion
)
1228 req
->handle
= wine_server_obj_handle( CompletionPort
);
1229 req
->ckey
= CompletionKey
;
1230 req
->cvalue
= CompletionValue
;
1231 req
->status
= Status
;
1232 req
->information
= NumberOfBytesTransferred
;
1233 status
= wine_server_call( req
);
1239 /******************************************************************
1240 * NtRemoveIoCompletion (NTDLL.@)
1241 * ZwRemoveIoCompletion (NTDLL.@)
1243 * (Wait for and) retrieve first completion message from completion object's queue
1246 * CompletionPort [I] HANDLE to I/O completion object
1247 * CompletionKey [O] completion key
1248 * CompletionValue [O] Completion value given in NtSetIoCompletion or in async operation
1249 * iosb [O] IO_STATUS_BLOCK of completed asynchronous operation
1250 * WaitTime [I] optional wait time in NTDLL format
1253 NTSTATUS WINAPI
NtRemoveIoCompletion( HANDLE CompletionPort
, PULONG_PTR CompletionKey
,
1254 PULONG_PTR CompletionValue
, PIO_STATUS_BLOCK iosb
,
1255 PLARGE_INTEGER WaitTime
)
1259 TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort
, CompletionKey
,
1260 CompletionValue
, iosb
, WaitTime
);
1264 SERVER_START_REQ( remove_completion
)
1266 req
->handle
= wine_server_obj_handle( CompletionPort
);
1267 if (!(status
= wine_server_call( req
)))
1269 *CompletionKey
= reply
->ckey
;
1270 *CompletionValue
= reply
->cvalue
;
1271 iosb
->Information
= reply
->information
;
1272 iosb
->u
.Status
= reply
->status
;
1276 if (status
!= STATUS_PENDING
) break;
1278 status
= NtWaitForSingleObject( CompletionPort
, FALSE
, WaitTime
);
1279 if (status
!= WAIT_OBJECT_0
) break;
1284 /******************************************************************
1285 * NtOpenIoCompletion (NTDLL.@)
1286 * ZwOpenIoCompletion (NTDLL.@)
1288 * Opens I/O completion object
1291 * CompletionPort [O] completion object handle will be placed there
1292 * DesiredAccess [I] desired access to a handle (combination of IO_COMPLETION_*)
1293 * ObjectAttributes [I] completion object name
1296 NTSTATUS WINAPI
NtOpenIoCompletion( HANDLE
*handle
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
1300 if (!handle
) return STATUS_INVALID_PARAMETER
;
1301 if ((status
= validate_open_object_attributes( attr
))) return status
;
1303 SERVER_START_REQ( open_completion
)
1305 req
->access
= access
;
1306 req
->attributes
= attr
->Attributes
;
1307 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
1308 if (attr
->ObjectName
)
1309 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
1310 status
= wine_server_call( req
);
1311 *handle
= wine_server_ptr_handle( reply
->handle
);
1317 /******************************************************************
1318 * NtQueryIoCompletion (NTDLL.@)
1319 * ZwQueryIoCompletion (NTDLL.@)
1321 * Requests information about given I/O completion object
1324 * CompletionPort [I] HANDLE to completion port to request
1325 * InformationClass [I] information class
1326 * CompletionInformation [O] user-provided buffer for data
1327 * BufferLength [I] buffer length
1328 * RequiredLength [O] required buffer length
1331 NTSTATUS WINAPI
NtQueryIoCompletion( HANDLE CompletionPort
, IO_COMPLETION_INFORMATION_CLASS InformationClass
,
1332 PVOID CompletionInformation
, ULONG BufferLength
, PULONG RequiredLength
)
1336 TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort
, InformationClass
, CompletionInformation
,
1337 BufferLength
, RequiredLength
);
1339 if (!CompletionInformation
) return STATUS_INVALID_PARAMETER
;
1340 switch( InformationClass
)
1342 case IoCompletionBasicInformation
:
1344 ULONG
*info
= CompletionInformation
;
1346 if (RequiredLength
) *RequiredLength
= sizeof(*info
);
1347 if (BufferLength
!= sizeof(*info
))
1348 status
= STATUS_INFO_LENGTH_MISMATCH
;
1351 SERVER_START_REQ( query_completion
)
1353 req
->handle
= wine_server_obj_handle( CompletionPort
);
1354 if (!(status
= wine_server_call( req
)))
1355 *info
= reply
->depth
;
1362 status
= STATUS_INVALID_PARAMETER
;
1368 NTSTATUS
NTDLL_AddCompletion( HANDLE hFile
, ULONG_PTR CompletionValue
,
1369 NTSTATUS CompletionStatus
, ULONG Information
)
1373 SERVER_START_REQ( add_fd_completion
)
1375 req
->handle
= wine_server_obj_handle( hFile
);
1376 req
->cvalue
= CompletionValue
;
1377 req
->status
= CompletionStatus
;
1378 req
->information
= Information
;
1379 status
= wine_server_call( req
);
1385 /******************************************************************
1386 * RtlRunOnceInitialize (NTDLL.@)
1388 void WINAPI
RtlRunOnceInitialize( RTL_RUN_ONCE
*once
)
1393 /******************************************************************
1394 * RtlRunOnceBeginInitialize (NTDLL.@)
1396 DWORD WINAPI
RtlRunOnceBeginInitialize( RTL_RUN_ONCE
*once
, ULONG flags
, void **context
)
1398 if (flags
& RTL_RUN_ONCE_CHECK_ONLY
)
1400 ULONG_PTR val
= (ULONG_PTR
)once
->Ptr
;
1402 if (flags
& RTL_RUN_ONCE_ASYNC
) return STATUS_INVALID_PARAMETER
;
1403 if ((val
& 3) != 2) return STATUS_UNSUCCESSFUL
;
1404 if (context
) *context
= (void *)(val
& ~3);
1405 return STATUS_SUCCESS
;
1410 ULONG_PTR next
, val
= (ULONG_PTR
)once
->Ptr
;
1414 case 0: /* first time */
1415 if (!interlocked_cmpxchg_ptr( &once
->Ptr
,
1416 (flags
& RTL_RUN_ONCE_ASYNC
) ? (void *)3 : (void *)1, 0 ))
1417 return STATUS_PENDING
;
1420 case 1: /* in progress, wait */
1421 if (flags
& RTL_RUN_ONCE_ASYNC
) return STATUS_INVALID_PARAMETER
;
1423 if (interlocked_cmpxchg_ptr( &once
->Ptr
, (void *)((ULONG_PTR
)&next
| 1),
1424 (void *)val
) == (void *)val
)
1425 NtWaitForKeyedEvent( keyed_event
, &next
, FALSE
, NULL
);
1429 if (context
) *context
= (void *)(val
& ~3);
1430 return STATUS_SUCCESS
;
1432 case 3: /* in progress, async */
1433 if (!(flags
& RTL_RUN_ONCE_ASYNC
)) return STATUS_INVALID_PARAMETER
;
1434 return STATUS_PENDING
;
1439 /******************************************************************
1440 * RtlRunOnceComplete (NTDLL.@)
1442 DWORD WINAPI
RtlRunOnceComplete( RTL_RUN_ONCE
*once
, ULONG flags
, void *context
)
1444 if ((ULONG_PTR
)context
& 3) return STATUS_INVALID_PARAMETER
;
1446 if (flags
& RTL_RUN_ONCE_INIT_FAILED
)
1448 if (context
) return STATUS_INVALID_PARAMETER
;
1449 if (flags
& RTL_RUN_ONCE_ASYNC
) return STATUS_INVALID_PARAMETER
;
1451 else context
= (void *)((ULONG_PTR
)context
| 2);
1455 ULONG_PTR val
= (ULONG_PTR
)once
->Ptr
;
1459 case 1: /* in progress */
1460 if (interlocked_cmpxchg_ptr( &once
->Ptr
, context
, (void *)val
) != (void *)val
) break;
1464 ULONG_PTR next
= *(ULONG_PTR
*)val
;
1465 NtReleaseKeyedEvent( keyed_event
, (void *)val
, FALSE
, NULL
);
1468 return STATUS_SUCCESS
;
1470 case 3: /* in progress, async */
1471 if (!(flags
& RTL_RUN_ONCE_ASYNC
)) return STATUS_INVALID_PARAMETER
;
1472 if (interlocked_cmpxchg_ptr( &once
->Ptr
, context
, (void *)val
) != (void *)val
) break;
1473 return STATUS_SUCCESS
;
1476 return STATUS_UNSUCCESSFUL
;
1481 /******************************************************************
1482 * RtlRunOnceExecuteOnce (NTDLL.@)
1484 DWORD WINAPI
RtlRunOnceExecuteOnce( RTL_RUN_ONCE
*once
, PRTL_RUN_ONCE_INIT_FN func
,
1485 void *param
, void **context
)
1487 DWORD ret
= RtlRunOnceBeginInitialize( once
, 0, context
);
1489 if (ret
!= STATUS_PENDING
) return ret
;
1491 if (!func( once
, param
, context
))
1493 RtlRunOnceComplete( once
, RTL_RUN_ONCE_INIT_FAILED
, NULL
);
1494 return STATUS_UNSUCCESSFUL
;
1497 return RtlRunOnceComplete( once
, 0, context
? *context
: NULL
);
1501 /* SRW locks implementation
1503 * The memory layout used by the lock is:
1506 * ________________ ________________
1507 * | X| #exclusive | #shared |
1508 * ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1509 * Since there is no space left for a separate counter of shared access
1510 * threads inside the locked section the #shared field is used for multiple
1511 * purposes. The following table lists all possible states the lock can be
1512 * in, notation: [X, #exclusive, #shared]:
1514 * [0, 0, N] -> locked by N shared access threads, if N=0 its unlocked
1515 * [0, >=1, >=1] -> threads are requesting exclusive locks, but there are
1516 * still shared access threads inside. #shared should not be incremented
1518 * [1, >=1, >=0] -> lock is owned by an exclusive thread and the #shared
1519 * counter can be used again to count the number of threads waiting in the
1520 * queue for shared access.
1522 * the following states are invalid and will never occur:
1523 * [0, >=1, 0], [1, 0, >=0]
1525 * The main problem arising from the fact that we have no separate counter
1526 * of shared access threads inside the locked section is that in the state
1527 * [0, >=1, >=1] above we cannot add additional waiting threads to the
1528 * shared access queue - it wouldn't be possible to distinguish waiting
1529 * threads and those that are still inside. To solve this problem the lock
1530 * uses the following approach: a thread that isn't able to allocate a
1531 * shared lock just uses the exclusive queue instead. As soon as the thread
1532 * is woken up it is in the state [1, >=1, >=0]. In this state it's again
1533 * possible to use the shared access queue. The thread atomically moves
1534 * itself to the shared access queue and releases the exclusive lock, so
1535 * that the "real" exclusive access threads have a chance. As soon as they
1536 * are all ready the shared access threads are processed.
1539 #define SRWLOCK_MASK_IN_EXCLUSIVE 0x80000000
1540 #define SRWLOCK_MASK_EXCLUSIVE_QUEUE 0x7fff0000
1541 #define SRWLOCK_MASK_SHARED_QUEUE 0x0000ffff
1542 #define SRWLOCK_RES_EXCLUSIVE 0x00010000
1543 #define SRWLOCK_RES_SHARED 0x00000001
1545 #ifdef WORDS_BIGENDIAN
1546 #define srwlock_key_exclusive(lock) (&lock->Ptr)
1547 #define srwlock_key_shared(lock) ((void *)((char *)&lock->Ptr + 2))
1549 #define srwlock_key_exclusive(lock) ((void *)((char *)&lock->Ptr + 2))
1550 #define srwlock_key_shared(lock) (&lock->Ptr)
1553 static inline void srwlock_check_invalid( unsigned int val
)
1555 /* Throw exception if it's impossible to acquire/release this lock. */
1556 if ((val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
) == SRWLOCK_MASK_EXCLUSIVE_QUEUE
||
1557 (val
& SRWLOCK_MASK_SHARED_QUEUE
) == SRWLOCK_MASK_SHARED_QUEUE
)
1558 RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED
);
1561 static inline unsigned int srwlock_lock_exclusive( unsigned int *dest
, int incr
)
1563 unsigned int val
, tmp
;
1564 /* Atomically modifies the value of *dest by adding incr. If the shared
1565 * queue is empty and there are threads waiting for exclusive access, then
1566 * sets the mark SRWLOCK_MASK_IN_EXCLUSIVE to signal other threads that
1567 * they are allowed again to use the shared queue counter. */
1568 for (val
= *dest
;; val
= tmp
)
1571 srwlock_check_invalid( tmp
);
1572 if ((tmp
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
) && !(tmp
& SRWLOCK_MASK_SHARED_QUEUE
))
1573 tmp
|= SRWLOCK_MASK_IN_EXCLUSIVE
;
1574 if ((tmp
= interlocked_cmpxchg( (int *)dest
, tmp
, val
)) == val
)
1580 static inline unsigned int srwlock_unlock_exclusive( unsigned int *dest
, int incr
)
1582 unsigned int val
, tmp
;
1583 /* Atomically modifies the value of *dest by adding incr. If the queue of
1584 * threads waiting for exclusive access is empty, then remove the
1585 * SRWLOCK_MASK_IN_EXCLUSIVE flag (only the shared queue counter will
1587 for (val
= *dest
;; val
= tmp
)
1590 srwlock_check_invalid( tmp
);
1591 if (!(tmp
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
))
1592 tmp
&= SRWLOCK_MASK_SHARED_QUEUE
;
1593 if ((tmp
= interlocked_cmpxchg( (int *)dest
, tmp
, val
)) == val
)
1599 static inline void srwlock_leave_exclusive( RTL_SRWLOCK
*lock
, unsigned int val
)
1601 /* Used when a thread leaves an exclusive section. If there are other
1602 * exclusive access threads they are processed first, followed by
1603 * the shared waiters. */
1604 if (val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
)
1605 NtReleaseKeyedEvent( keyed_event
, srwlock_key_exclusive(lock
), FALSE
, NULL
);
1608 val
&= SRWLOCK_MASK_SHARED_QUEUE
; /* remove SRWLOCK_MASK_IN_EXCLUSIVE */
1610 NtReleaseKeyedEvent( keyed_event
, srwlock_key_shared(lock
), FALSE
, NULL
);
1614 static inline void srwlock_leave_shared( RTL_SRWLOCK
*lock
, unsigned int val
)
1616 /* Wake up one exclusive thread as soon as the last shared access thread
1618 if ((val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
) && !(val
& SRWLOCK_MASK_SHARED_QUEUE
))
1619 NtReleaseKeyedEvent( keyed_event
, srwlock_key_exclusive(lock
), FALSE
, NULL
);
1622 /***********************************************************************
1623 * RtlInitializeSRWLock (NTDLL.@)
1626 * Please note that SRWLocks do not keep track of the owner of a lock.
1627 * It doesn't make any difference which thread for example unlocks an
1628 * SRWLock (see corresponding tests). This implementation uses two
1629 * keyed events (one for the exclusive waiters and one for the shared
1630 * waiters) and is limited to 2^15-1 waiting threads.
1632 void WINAPI
RtlInitializeSRWLock( RTL_SRWLOCK
*lock
)
1637 /***********************************************************************
1638 * RtlAcquireSRWLockExclusive (NTDLL.@)
1641 * Unlike RtlAcquireResourceExclusive this function doesn't allow
1642 * nested calls from the same thread. "Upgrading" a shared access lock
1643 * to an exclusive access lock also doesn't seem to be supported.
1645 void WINAPI
RtlAcquireSRWLockExclusive( RTL_SRWLOCK
*lock
)
1647 if (srwlock_lock_exclusive( (unsigned int *)&lock
->Ptr
, SRWLOCK_RES_EXCLUSIVE
))
1648 NtWaitForKeyedEvent( keyed_event
, srwlock_key_exclusive(lock
), FALSE
, NULL
);
1651 /***********************************************************************
1652 * RtlAcquireSRWLockShared (NTDLL.@)
1655 * Do not call this function recursively - it will only succeed when
1656 * there are no threads waiting for an exclusive lock!
1658 void WINAPI
RtlAcquireSRWLockShared( RTL_SRWLOCK
*lock
)
1660 unsigned int val
, tmp
;
1661 /* Acquires a shared lock. If it's currently not possible to add elements to
1662 * the shared queue, then request exclusive access instead. */
1663 for (val
= *(unsigned int *)&lock
->Ptr
;; val
= tmp
)
1665 if ((val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
) && !(val
& SRWLOCK_MASK_IN_EXCLUSIVE
))
1666 tmp
= val
+ SRWLOCK_RES_EXCLUSIVE
;
1668 tmp
= val
+ SRWLOCK_RES_SHARED
;
1669 if ((tmp
= interlocked_cmpxchg( (int *)&lock
->Ptr
, tmp
, val
)) == val
)
1673 /* Drop exclusive access again and instead requeue for shared access. */
1674 if ((val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
) && !(val
& SRWLOCK_MASK_IN_EXCLUSIVE
))
1676 NtWaitForKeyedEvent( keyed_event
, srwlock_key_exclusive(lock
), FALSE
, NULL
);
1677 val
= srwlock_unlock_exclusive( (unsigned int *)&lock
->Ptr
, (SRWLOCK_RES_SHARED
1678 - SRWLOCK_RES_EXCLUSIVE
) ) - SRWLOCK_RES_EXCLUSIVE
;
1679 srwlock_leave_exclusive( lock
, val
);
1682 if (val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
)
1683 NtWaitForKeyedEvent( keyed_event
, srwlock_key_shared(lock
), FALSE
, NULL
);
1686 /***********************************************************************
1687 * RtlReleaseSRWLockExclusive (NTDLL.@)
1689 void WINAPI
RtlReleaseSRWLockExclusive( RTL_SRWLOCK
*lock
)
1691 srwlock_leave_exclusive( lock
, srwlock_unlock_exclusive( (unsigned int *)&lock
->Ptr
,
1692 - SRWLOCK_RES_EXCLUSIVE
) - SRWLOCK_RES_EXCLUSIVE
);
1695 /***********************************************************************
1696 * RtlReleaseSRWLockShared (NTDLL.@)
1698 void WINAPI
RtlReleaseSRWLockShared( RTL_SRWLOCK
*lock
)
1700 srwlock_leave_shared( lock
, srwlock_lock_exclusive( (unsigned int *)&lock
->Ptr
,
1701 - SRWLOCK_RES_SHARED
) - SRWLOCK_RES_SHARED
);
1704 /***********************************************************************
1705 * RtlTryAcquireSRWLockExclusive (NTDLL.@)
1708 * Similar to AcquireSRWLockExclusive recusive calls are not allowed
1709 * and will fail with return value FALSE.
1711 BOOLEAN WINAPI
RtlTryAcquireSRWLockExclusive( RTL_SRWLOCK
*lock
)
1713 return interlocked_cmpxchg( (int *)&lock
->Ptr
, SRWLOCK_MASK_IN_EXCLUSIVE
|
1714 SRWLOCK_RES_EXCLUSIVE
, 0 ) == 0;
1717 /***********************************************************************
1718 * RtlTryAcquireSRWLockShared (NTDLL.@)
1720 BOOLEAN WINAPI
RtlTryAcquireSRWLockShared( RTL_SRWLOCK
*lock
)
1722 unsigned int val
, tmp
;
1723 for (val
= *(unsigned int *)&lock
->Ptr
;; val
= tmp
)
1725 if (val
& SRWLOCK_MASK_EXCLUSIVE_QUEUE
)
1727 if ((tmp
= interlocked_cmpxchg( (int *)&lock
->Ptr
, val
+ SRWLOCK_RES_SHARED
, val
)) == val
)
1733 /***********************************************************************
1734 * RtlInitializeConditionVariable (NTDLL.@)
1736 * Initializes the condition variable with NULL.
1739 * variable [O] condition variable
1744 void WINAPI
RtlInitializeConditionVariable( RTL_CONDITION_VARIABLE
*variable
)
1746 variable
->Ptr
= NULL
;
1749 /***********************************************************************
1750 * RtlWakeConditionVariable (NTDLL.@)
1752 * Wakes up one thread waiting on the condition variable.
1755 * variable [I/O] condition variable to wake up.
1761 * The calling thread does not have to own any lock in order to call
1764 void WINAPI
RtlWakeConditionVariable( RTL_CONDITION_VARIABLE
*variable
)
1766 if (interlocked_dec_if_nonzero( (int *)&variable
->Ptr
))
1767 NtReleaseKeyedEvent( keyed_event
, &variable
->Ptr
, FALSE
, NULL
);
1770 /***********************************************************************
1771 * RtlWakeAllConditionVariable (NTDLL.@)
1773 * See WakeConditionVariable, wakes up all waiting threads.
1775 void WINAPI
RtlWakeAllConditionVariable( RTL_CONDITION_VARIABLE
*variable
)
1777 int val
= interlocked_xchg( (int *)&variable
->Ptr
, 0 );
1779 NtReleaseKeyedEvent( keyed_event
, &variable
->Ptr
, FALSE
, NULL
);
1782 /***********************************************************************
1783 * RtlSleepConditionVariableCS (NTDLL.@)
1785 * Atomically releases the critical section and suspends the thread,
1786 * waiting for a Wake(All)ConditionVariable event. Afterwards it enters
1787 * the critical section again and returns.
1790 * variable [I/O] condition variable
1791 * crit [I/O] critical section to leave temporarily
1792 * timeout [I] timeout
1795 * see NtWaitForKeyedEvent for all possible return values.
1797 NTSTATUS WINAPI
RtlSleepConditionVariableCS( RTL_CONDITION_VARIABLE
*variable
, RTL_CRITICAL_SECTION
*crit
,
1798 const LARGE_INTEGER
*timeout
)
1801 interlocked_xchg_add( (int *)&variable
->Ptr
, 1 );
1802 RtlLeaveCriticalSection( crit
);
1804 status
= NtWaitForKeyedEvent( keyed_event
, &variable
->Ptr
, FALSE
, timeout
);
1805 if (status
!= STATUS_SUCCESS
)
1807 if (!interlocked_dec_if_nonzero( (int *)&variable
->Ptr
))
1808 status
= NtWaitForKeyedEvent( keyed_event
, &variable
->Ptr
, FALSE
, NULL
);
1811 RtlEnterCriticalSection( crit
);
1815 /***********************************************************************
1816 * RtlSleepConditionVariableSRW (NTDLL.@)
1818 * Atomically releases the SRWLock and suspends the thread,
1819 * waiting for a Wake(All)ConditionVariable event. Afterwards it enters
1820 * the SRWLock again with the same access rights and returns.
1823 * variable [I/O] condition variable
1824 * lock [I/O] SRWLock to leave temporarily
1825 * timeout [I] timeout
1826 * flags [I] type of the current lock (exclusive / shared)
1829 * see NtWaitForKeyedEvent for all possible return values.
1832 * the behaviour is undefined if the thread doesn't own the lock.
1834 NTSTATUS WINAPI
RtlSleepConditionVariableSRW( RTL_CONDITION_VARIABLE
*variable
, RTL_SRWLOCK
*lock
,
1835 const LARGE_INTEGER
*timeout
, ULONG flags
)
1838 interlocked_xchg_add( (int *)&variable
->Ptr
, 1 );
1840 if (flags
& RTL_CONDITION_VARIABLE_LOCKMODE_SHARED
)
1841 RtlReleaseSRWLockShared( lock
);
1843 RtlReleaseSRWLockExclusive( lock
);
1845 status
= NtWaitForKeyedEvent( keyed_event
, &variable
->Ptr
, FALSE
, timeout
);
1846 if (status
!= STATUS_SUCCESS
)
1848 if (!interlocked_dec_if_nonzero( (int *)&variable
->Ptr
))
1849 status
= NtWaitForKeyedEvent( keyed_event
, &variable
->Ptr
, FALSE
, NULL
);
1852 if (flags
& RTL_CONDITION_VARIABLE_LOCKMODE_SHARED
)
1853 RtlAcquireSRWLockShared( lock
);
1855 RtlAcquireSRWLockExclusive( lock
);