dlls/ntdll/sync.c

   1 /*
   2  *      Process synchronisation
   3  *
   4  * Copyright 1996, 1997, 1998 Marcus Meissner
   5  * Copyright 1997, 1999 Alexandre Julliard
   6  * Copyright 1999, 2000 Juergen Schmied
   7  * Copyright 2003 Eric Pouech
   8  *
   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.
  13  *
  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.
  18  *
  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
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <assert.h>
  28 #include <errno.h>
  29 #include <signal.h>
  30 #ifdef HAVE_SYS_TIME_H
  31 # include <sys/time.h>
  32 #endif
  33 #ifdef HAVE_POLL_H
  34 #include <poll.h>
  35 #endif
  36 #ifdef HAVE_SYS_POLL_H
  37 # include <sys/poll.h>
  38 #endif
  39 #ifdef HAVE_UNISTD_H
  40 # include <unistd.h>
  41 #endif
  42 #ifdef HAVE_SCHED_H
  43 # include <sched.h>
  44 #endif
  45 #include <string.h>
  46 #include <stdarg.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <time.h>
  50
  51 #define NONAMELESSUNION
  52 #define NONAMELESSSTRUCT
  53
  54 #include "ntstatus.h"
  55 #define WIN32_NO_STATUS
  56 #include "windef.h"
  57 #include "winternl.h"
  58 #include "wine/server.h"
  59 #include "wine/debug.h"
  60 #include "ntdll_misc.h"
  61
  62 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  63
  64 HANDLE keyed_event = NULL;
  65
  66 static inline int interlocked_dec_if_nonzero( int *dest )
  67 {
  68     int val, tmp;
  69     for (val = *dest;; val = tmp)
  70     {
  71         if (!val || (tmp = interlocked_cmpxchg( dest, val - 1, val )) == val)
  72             break;
  73     }
  74     return val;
  75 }
  76
  77 /* creates a struct security_descriptor and contained information in one contiguous piece of memory */
  78 NTSTATUS NTDLL_create_struct_sd(PSECURITY_DESCRIPTOR nt_sd, struct security_descriptor **server_sd,
  79                                 data_size_t *server_sd_len)
  80 {
  81     unsigned int len;
  82     PSID owner, group;
  83     ACL *dacl, *sacl;
  84     BOOLEAN owner_present, group_present, dacl_present, sacl_present;
  85     BOOLEAN defaulted;
  86     NTSTATUS status;
  87     unsigned char *ptr;
  88
  89     if (!nt_sd)
  90     {
  91         *server_sd = NULL;
  92         *server_sd_len = 0;
  93         return STATUS_SUCCESS;
  94     }
  95
  96     len = sizeof(struct security_descriptor);
  97
  98     status = RtlGetOwnerSecurityDescriptor(nt_sd, &owner, &owner_present);
  99     if (status != STATUS_SUCCESS) return status;
 100     status = RtlGetGroupSecurityDescriptor(nt_sd, &group, &group_present);
 101     if (status != STATUS_SUCCESS) return status;
 102     status = RtlGetSaclSecurityDescriptor(nt_sd, &sacl_present, &sacl, &defaulted);
 103     if (status != STATUS_SUCCESS) return status;
 104     status = RtlGetDaclSecurityDescriptor(nt_sd, &dacl_present, &dacl, &defaulted);
 105     if (status != STATUS_SUCCESS) return status;
 106
 107     if (owner_present)
 108         len += RtlLengthSid(owner);
 109     if (group_present)
 110         len += RtlLengthSid(group);
 111     if (sacl_present && sacl)
 112         len += sacl->AclSize;
 113     if (dacl_present && dacl)
 114         len += dacl->AclSize;
 115
 116     /* fix alignment for the Unicode name that follows the structure */
 117     len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
 118     *server_sd = RtlAllocateHeap(GetProcessHeap(), 0, len);
 119     if (!*server_sd) return STATUS_NO_MEMORY;
 120
 121     (*server_sd)->control = ((SECURITY_DESCRIPTOR *)nt_sd)->Control & ~SE_SELF_RELATIVE;
 122     (*server_sd)->owner_len = owner_present ? RtlLengthSid(owner) : 0;
 123     (*server_sd)->group_len = group_present ? RtlLengthSid(group) : 0;
 124     (*server_sd)->sacl_len = (sacl_present && sacl) ? sacl->AclSize : 0;
 125     (*server_sd)->dacl_len = (dacl_present && dacl) ? dacl->AclSize : 0;
 126
 127     ptr = (unsigned char *)(*server_sd + 1);
 128     memcpy(ptr, owner, (*server_sd)->owner_len);
 129     ptr += (*server_sd)->owner_len;
 130     memcpy(ptr, group, (*server_sd)->group_len);
 131     ptr += (*server_sd)->group_len;
 132     memcpy(ptr, sacl, (*server_sd)->sacl_len);
 133     ptr += (*server_sd)->sacl_len;
 134     memcpy(ptr, dacl, (*server_sd)->dacl_len);
 135
 136     *server_sd_len = len;
 137
 138     return STATUS_SUCCESS;
 139 }
 140
 141 /* frees a struct security_descriptor allocated by NTDLL_create_struct_sd */
 142 void NTDLL_free_struct_sd(struct security_descriptor *server_sd)
 143 {
 144     RtlFreeHeap(GetProcessHeap(), 0, server_sd);
 145 }
 146
 147 /*
 148  *      Semaphores
 149  */
 150
 151 /******************************************************************************
 152  *  NtCreateSemaphore (NTDLL.@)
 153  */
 154 NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
 155                                    IN ACCESS_MASK access,
 156                                    IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
 157                                    IN LONG InitialCount,
 158                                    IN LONG MaximumCount )
 159 {
 160     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 161     NTSTATUS ret;
 162     struct object_attributes objattr;
 163     struct security_descriptor *sd = NULL;
 164
 165     if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount)
 166         return STATUS_INVALID_PARAMETER;
 167     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 168
 169     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 170     objattr.sd_len = 0;
 171     objattr.name_len = len;
 172     if (attr)
 173     {
 174         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 175         if (ret != STATUS_SUCCESS) return ret;
 176     }
 177
 178     SERVER_START_REQ( create_semaphore )
 179     {
 180         req->access  = access;
 181         req->attributes = (attr) ? attr->Attributes : 0;
 182         req->initial = InitialCount;
 183         req->max     = MaximumCount;
 184         wine_server_add_data( req, &objattr, sizeof(objattr) );
 185         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 186         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 187         ret = wine_server_call( req );
 188         *SemaphoreHandle = wine_server_ptr_handle( reply->handle );
 189     }
 190     SERVER_END_REQ;
 191
 192     NTDLL_free_struct_sd( sd );
 193
 194     return ret;
 195 }
 196
 197 /******************************************************************************
 198  *  NtOpenSemaphore (NTDLL.@)
 199  */
 200 NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
 201                                  IN ACCESS_MASK access,
 202                                  IN const OBJECT_ATTRIBUTES *attr )
 203 {
 204     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 205     NTSTATUS ret;
 206
 207     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 208
 209     SERVER_START_REQ( open_semaphore )
 210     {
 211         req->access  = access;
 212         req->attributes = (attr) ? attr->Attributes : 0;
 213         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 214         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 215         ret = wine_server_call( req );
 216         *SemaphoreHandle = wine_server_ptr_handle( reply->handle );
 217     }
 218     SERVER_END_REQ;
 219     return ret;
 220 }
 221
 222 /******************************************************************************
 223  *  NtQuerySemaphore (NTDLL.@)
 224  */
 225 NTSTATUS WINAPI NtQuerySemaphore( HANDLE handle, SEMAPHORE_INFORMATION_CLASS class,
 226                                   void *info, ULONG len, ULONG *ret_len )
 227 {
 228     NTSTATUS ret;
 229     SEMAPHORE_BASIC_INFORMATION *out = info;
 230
 231     if (class != SemaphoreBasicInformation)
 232     {
 233         FIXME("(%p,%d,%u) Unknown class\n", handle, class, len);
 234         return STATUS_INVALID_INFO_CLASS;
 235     }
 236
 237     if (len != sizeof(SEMAPHORE_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 238
 239     SERVER_START_REQ( query_semaphore )
 240     {
 241         req->handle = wine_server_obj_handle( handle );
 242         if (!(ret = wine_server_call( req )))
 243         {
 244             out->CurrentCount = reply->current;
 245             out->MaximumCount = reply->max;
 246             if (ret_len) *ret_len = sizeof(SEMAPHORE_BASIC_INFORMATION);
 247         }
 248     }
 249     SERVER_END_REQ;
 250
 251     return ret;
 252 }
 253
 254 /******************************************************************************
 255  *  NtReleaseSemaphore (NTDLL.@)
 256  */
 257 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
 258 {
 259     NTSTATUS ret;
 260     SERVER_START_REQ( release_semaphore )
 261     {
 262         req->handle = wine_server_obj_handle( handle );
 263         req->count  = count;
 264         if (!(ret = wine_server_call( req )))
 265         {
 266             if (previous) *previous = reply->prev_count;
 267         }
 268     }
 269     SERVER_END_REQ;
 270     return ret;
 271 }
 272
 273 /*
 274  *      Events
 275  */
 276
 277 /**************************************************************************
 278  * NtCreateEvent (NTDLL.@)
 279  * ZwCreateEvent (NTDLL.@)
 280  */
 281 NTSTATUS WINAPI NtCreateEvent( PHANDLE EventHandle, ACCESS_MASK DesiredAccess,
 282                                const OBJECT_ATTRIBUTES *attr, EVENT_TYPE type, BOOLEAN InitialState)
 283 {
 284     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 285     NTSTATUS ret;
 286     struct security_descriptor *sd = NULL;
 287     struct object_attributes objattr;
 288
 289     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 290
 291     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 292     objattr.sd_len = 0;
 293     objattr.name_len = len;
 294     if (attr)
 295     {
 296         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 297         if (ret != STATUS_SUCCESS) return ret;
 298     }
 299
 300     SERVER_START_REQ( create_event )
 301     {
 302         req->access = DesiredAccess;
 303         req->attributes = (attr) ? attr->Attributes : 0;
 304         req->manual_reset = (type == NotificationEvent);
 305         req->initial_state = InitialState;
 306         wine_server_add_data( req, &objattr, sizeof(objattr) );
 307         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 308         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 309         ret = wine_server_call( req );
 310         *EventHandle = wine_server_ptr_handle( reply->handle );
 311     }
 312     SERVER_END_REQ;
 313
 314     NTDLL_free_struct_sd( sd );
 315
 316     return ret;
 317 }
 318
 319 /******************************************************************************
 320  *  NtOpenEvent (NTDLL.@)
 321  *  ZwOpenEvent (NTDLL.@)
 322  */
 323 NTSTATUS WINAPI NtOpenEvent(
 324         OUT PHANDLE EventHandle,
 325         IN ACCESS_MASK DesiredAccess,
 326         IN const OBJECT_ATTRIBUTES *attr )
 327 {
 328     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 329     NTSTATUS ret;
 330
 331     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 332
 333     SERVER_START_REQ( open_event )
 334     {
 335         req->access  = DesiredAccess;
 336         req->attributes = (attr) ? attr->Attributes : 0;
 337         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 338         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 339         ret = wine_server_call( req );
 340         *EventHandle = wine_server_ptr_handle( reply->handle );
 341     }
 342     SERVER_END_REQ;
 343     return ret;
 344 }
 345
 346
 347 /******************************************************************************
 348  *  NtSetEvent (NTDLL.@)
 349  *  ZwSetEvent (NTDLL.@)
 350  */
 351 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 352 {
 353     NTSTATUS ret;
 354
 355     /* FIXME: set NumberOfThreadsReleased */
 356
 357     SERVER_START_REQ( event_op )
 358     {
 359         req->handle = wine_server_obj_handle( handle );
 360         req->op     = SET_EVENT;
 361         ret = wine_server_call( req );
 362     }
 363     SERVER_END_REQ;
 364     return ret;
 365 }
 366
 367 /******************************************************************************
 368  *  NtResetEvent (NTDLL.@)
 369  */
 370 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 371 {
 372     NTSTATUS ret;
 373
 374     /* resetting an event can't release any thread... */
 375     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
 376
 377     SERVER_START_REQ( event_op )
 378     {
 379         req->handle = wine_server_obj_handle( handle );
 380         req->op     = RESET_EVENT;
 381         ret = wine_server_call( req );
 382     }
 383     SERVER_END_REQ;
 384     return ret;
 385 }
 386
 387 /******************************************************************************
 388  *  NtClearEvent (NTDLL.@)
 389  *
 390  * FIXME
 391  *   same as NtResetEvent ???
 392  */
 393 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 394 {
 395     return NtResetEvent( handle, NULL );
 396 }
 397
 398 /******************************************************************************
 399  *  NtPulseEvent (NTDLL.@)
 400  *
 401  * FIXME
 402  *   PulseCount
 403  */
 404 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 405 {
 406     NTSTATUS ret;
 407
 408     if (PulseCount)
 409       FIXME("(%p,%d)\n", handle, *PulseCount);
 410
 411     SERVER_START_REQ( event_op )
 412     {
 413         req->handle = wine_server_obj_handle( handle );
 414         req->op     = PULSE_EVENT;
 415         ret = wine_server_call( req );
 416     }
 417     SERVER_END_REQ;
 418     return ret;
 419 }
 420
 421 /******************************************************************************
 422  *  NtQueryEvent (NTDLL.@)
 423  */
 424 NTSTATUS WINAPI NtQueryEvent( HANDLE handle, EVENT_INFORMATION_CLASS class,
 425                               void *info, ULONG len, ULONG *ret_len )
 426 {
 427     NTSTATUS ret;
 428     EVENT_BASIC_INFORMATION *out = info;
 429
 430     if (class != EventBasicInformation)
 431     {
 432         FIXME("(%p, %d, %d) Unknown class\n",
 433               handle, class, len);
 434         return STATUS_INVALID_INFO_CLASS;
 435     }
 436
 437     if (len != sizeof(EVENT_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 438
 439     SERVER_START_REQ( query_event )
 440     {
 441         req->handle = wine_server_obj_handle( handle );
 442         if (!(ret = wine_server_call( req )))
 443         {
 444             out->EventType  = reply->manual_reset ? NotificationEvent : SynchronizationEvent;
 445             out->EventState = reply->state;
 446             if (ret_len) *ret_len = sizeof(EVENT_BASIC_INFORMATION);
 447         }
 448     }
 449     SERVER_END_REQ;
 450
 451     return ret;
 452 }
 453
 454 /*
 455  *      Mutants (known as Mutexes in Kernel32)
 456  */
 457
 458 /******************************************************************************
 459  *              NtCreateMutant                          [NTDLL.@]
 460  *              ZwCreateMutant                          [NTDLL.@]
 461  */
 462 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
 463                                IN ACCESS_MASK access,
 464                                IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
 465                                IN BOOLEAN InitialOwner)
 466 {
 467     NTSTATUS status;
 468     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 469     struct security_descriptor *sd = NULL;
 470     struct object_attributes objattr;
 471
 472     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 473
 474     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 475     objattr.sd_len = 0;
 476     objattr.name_len = len;
 477     if (attr)
 478     {
 479         status = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 480         if (status != STATUS_SUCCESS) return status;
 481     }
 482
 483     SERVER_START_REQ( create_mutex )
 484     {
 485         req->access  = access;
 486         req->attributes = (attr) ? attr->Attributes : 0;
 487         req->owned   = InitialOwner;
 488         wine_server_add_data( req, &objattr, sizeof(objattr) );
 489         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 490         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 491         status = wine_server_call( req );
 492         *MutantHandle = wine_server_ptr_handle( reply->handle );
 493     }
 494     SERVER_END_REQ;
 495
 496     NTDLL_free_struct_sd( sd );
 497
 498     return status;
 499 }
 500
 501 /**************************************************************************
 502  *              NtOpenMutant                            [NTDLL.@]
 503  *              ZwOpenMutant                            [NTDLL.@]
 504  */
 505 NTSTATUS WINAPI NtOpenMutant(OUT HANDLE* MutantHandle,
 506                              IN ACCESS_MASK access,
 507                              IN const OBJECT_ATTRIBUTES* attr )
 508 {
 509     NTSTATUS    status;
 510     DWORD       len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 511
 512     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 513
 514     SERVER_START_REQ( open_mutex )
 515     {
 516         req->access  = access;
 517         req->attributes = (attr) ? attr->Attributes : 0;
 518         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 519         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 520         status = wine_server_call( req );
 521         *MutantHandle = wine_server_ptr_handle( reply->handle );
 522     }
 523     SERVER_END_REQ;
 524     return status;
 525 }
 526
 527 /**************************************************************************
 528  *              NtReleaseMutant                         [NTDLL.@]
 529  *              ZwReleaseMutant                         [NTDLL.@]
 530  */
 531 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
 532 {
 533     NTSTATUS    status;
 534
 535     SERVER_START_REQ( release_mutex )
 536     {
 537         req->handle = wine_server_obj_handle( handle );
 538         status = wine_server_call( req );
 539         if (prev_count) *prev_count = reply->prev_count;
 540     }
 541     SERVER_END_REQ;
 542     return status;
 543 }
 544
 545 /******************************************************************
 546  *              NtQueryMutant                   [NTDLL.@]
 547  *              ZwQueryMutant                   [NTDLL.@]
 548  */
 549 NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle,
 550                               IN MUTANT_INFORMATION_CLASS MutantInformationClass,
 551                               OUT PVOID MutantInformation,
 552                               IN ULONG MutantInformationLength,
 553                               OUT PULONG ResultLength OPTIONAL )
 554 {
 555     FIXME("(%p %u %p %u %p): stub!\n",
 556           handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
 557     return STATUS_NOT_IMPLEMENTED;
 558 }
 559
 560 /*
 561  *      Jobs
 562  */
 563
 564 /******************************************************************************
 565  *              NtCreateJobObject   [NTDLL.@]
 566  *              ZwCreateJobObject   [NTDLL.@]
 567  */
 568 NTSTATUS WINAPI NtCreateJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 569 {
 570     FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
 571     *handle = (HANDLE)0xdead;
 572     return STATUS_SUCCESS;
 573 }
 574
 575 /******************************************************************************
 576  *              NtOpenJobObject   [NTDLL.@]
 577  *              ZwOpenJobObject   [NTDLL.@]
 578  */
 579 NTSTATUS WINAPI NtOpenJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 580 {
 581     FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
 582     return STATUS_NOT_IMPLEMENTED;
 583 }
 584
 585 /******************************************************************************
 586  *              NtTerminateJobObject   [NTDLL.@]
 587  *              ZwTerminateJobObject   [NTDLL.@]
 588  */
 589 NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status )
 590 {
 591     FIXME( "stub: %p %x\n", handle, status );
 592     return STATUS_SUCCESS;
 593 }
 594
 595 /******************************************************************************
 596  *              NtQueryInformationJobObject   [NTDLL.@]
 597  *              ZwQueryInformationJobObject   [NTDLL.@]
 598  */
 599 NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info,
 600                                              ULONG len, PULONG ret_len )
 601 {
 602     FIXME( "stub: %p %u %p %u %p\n", handle, class, info, len, ret_len );
 603     return STATUS_NOT_IMPLEMENTED;
 604 }
 605
 606 /******************************************************************************
 607  *              NtSetInformationJobObject   [NTDLL.@]
 608  *              ZwSetInformationJobObject   [NTDLL.@]
 609  */
 610 NTSTATUS WINAPI NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info, ULONG len )
 611 {
 612     FIXME( "stub: %p %u %p %u\n", handle, class, info, len );
 613     return STATUS_SUCCESS;
 614 }
 615
 616 /******************************************************************************
 617  *              NtIsProcessInJob   [NTDLL.@]
 618  *              ZwIsProcessInJob   [NTDLL.@]
 619  */
 620 NTSTATUS WINAPI NtIsProcessInJob( HANDLE process, HANDLE job )
 621 {
 622     FIXME( "stub: %p %p\n", process, job );
 623     return STATUS_PROCESS_NOT_IN_JOB;
 624 }
 625
 626 /******************************************************************************
 627  *              NtAssignProcessToJobObject   [NTDLL.@]
 628  *              ZwAssignProcessToJobObject   [NTDLL.@]
 629  */
 630 NTSTATUS WINAPI NtAssignProcessToJobObject( HANDLE job, HANDLE process )
 631 {
 632     FIXME( "stub: %p %p\n", job, process );
 633     return STATUS_SUCCESS;
 634 }
 635
 636 /*
 637  *      Timers
 638  */
 639
 640 /**************************************************************************
 641  *              NtCreateTimer                           [NTDLL.@]
 642  *              ZwCreateTimer                           [NTDLL.@]
 643  */
 644 NTSTATUS WINAPI NtCreateTimer(OUT HANDLE *handle,
 645                               IN ACCESS_MASK access,
 646                               IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
 647                               IN TIMER_TYPE timer_type)
 648 {
 649     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 650     NTSTATUS    status;
 651
 652     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 653
 654     if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
 655         return STATUS_INVALID_PARAMETER;
 656
 657     SERVER_START_REQ( create_timer )
 658     {
 659         req->access  = access;
 660         req->attributes = (attr) ? attr->Attributes : 0;
 661         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 662         req->manual  = (timer_type == NotificationTimer);
 663         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 664         status = wine_server_call( req );
 665         *handle = wine_server_ptr_handle( reply->handle );
 666     }
 667     SERVER_END_REQ;
 668     return status;
 669
 670 }
 671
 672 /**************************************************************************
 673  *              NtOpenTimer                             [NTDLL.@]
 674  *              ZwOpenTimer                             [NTDLL.@]
 675  */
 676 NTSTATUS WINAPI NtOpenTimer(OUT PHANDLE handle,
 677                             IN ACCESS_MASK access,
 678                             IN const OBJECT_ATTRIBUTES* attr )
 679 {
 680     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 681     NTSTATUS    status;
 682
 683     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 684
 685     SERVER_START_REQ( open_timer )
 686     {
 687         req->access  = access;
 688         req->attributes = (attr) ? attr->Attributes : 0;
 689         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 690         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 691         status = wine_server_call( req );
 692         *handle = wine_server_ptr_handle( reply->handle );
 693     }
 694     SERVER_END_REQ;
 695     return status;
 696 }
 697
 698 /**************************************************************************
 699  *              NtSetTimer                              [NTDLL.@]
 700  *              ZwSetTimer                              [NTDLL.@]
 701  */
 702 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
 703                            IN const LARGE_INTEGER* when,
 704                            IN PTIMER_APC_ROUTINE callback,
 705                            IN PVOID callback_arg,
 706                            IN BOOLEAN resume,
 707                            IN ULONG period OPTIONAL,
 708                            OUT PBOOLEAN state OPTIONAL)
 709 {
 710     NTSTATUS    status = STATUS_SUCCESS;
 711
 712     TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
 713           handle, when, callback, callback_arg, resume, period, state);
 714
 715     SERVER_START_REQ( set_timer )
 716     {
 717         req->handle   = wine_server_obj_handle( handle );
 718         req->period   = period;
 719         req->expire   = when->QuadPart;
 720         req->callback = wine_server_client_ptr( callback );
 721         req->arg      = wine_server_client_ptr( callback_arg );
 722         status = wine_server_call( req );
 723         if (state) *state = reply->signaled;
 724     }
 725     SERVER_END_REQ;
 726
 727     /* set error but can still succeed */
 728     if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
 729     return status;
 730 }
 731
 732 /**************************************************************************
 733  *              NtCancelTimer                           [NTDLL.@]
 734  *              ZwCancelTimer                           [NTDLL.@]
 735  */
 736 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
 737 {
 738     NTSTATUS    status;
 739
 740     SERVER_START_REQ( cancel_timer )
 741     {
 742         req->handle = wine_server_obj_handle( handle );
 743         status = wine_server_call( req );
 744         if (state) *state = reply->signaled;
 745     }
 746     SERVER_END_REQ;
 747     return status;
 748 }
 749
 750 /******************************************************************************
 751  *  NtQueryTimer (NTDLL.@)
 752  *
 753  * Retrieves information about a timer.
 754  *
 755  * PARAMS
 756  *  TimerHandle           [I] The timer to retrieve information about.
 757  *  TimerInformationClass [I] The type of information to retrieve.
 758  *  TimerInformation      [O] Pointer to buffer to store information in.
 759  *  Length                [I] The length of the buffer pointed to by TimerInformation.
 760  *  ReturnLength          [O] Optional. The size of buffer actually used.
 761  *
 762  * RETURNS
 763  *  Success: STATUS_SUCCESS
 764  *  Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
 765  *           size for the class specified.
 766  *           STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
 767  *           STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
 768  *           to the timer.
 769  */
 770 NTSTATUS WINAPI NtQueryTimer(
 771     HANDLE TimerHandle,
 772     TIMER_INFORMATION_CLASS TimerInformationClass,
 773     PVOID TimerInformation,
 774     ULONG Length,
 775     PULONG ReturnLength)
 776 {
 777     TIMER_BASIC_INFORMATION * basic_info = TimerInformation;
 778     NTSTATUS status;
 779     LARGE_INTEGER now;
 780
 781     TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
 782        TimerInformation, Length, ReturnLength);
 783
 784     switch (TimerInformationClass)
 785     {
 786     case TimerBasicInformation:
 787         if (Length < sizeof(TIMER_BASIC_INFORMATION))
 788             return STATUS_INFO_LENGTH_MISMATCH;
 789
 790         SERVER_START_REQ(get_timer_info)
 791         {
 792             req->handle = wine_server_obj_handle( TimerHandle );
 793             status = wine_server_call(req);
 794
 795             /* convert server time to absolute NTDLL time */
 796             basic_info->RemainingTime.QuadPart = reply->when;
 797             basic_info->TimerState = reply->signaled;
 798         }
 799         SERVER_END_REQ;
 800
 801         /* convert from absolute into relative time */
 802         NtQuerySystemTime(&now);
 803         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
 804             basic_info->RemainingTime.QuadPart = 0;
 805         else
 806             basic_info->RemainingTime.QuadPart -= now.QuadPart;
 807
 808         if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
 809
 810         return status;
 811     }
 812
 813     FIXME("Unhandled class %d\n", TimerInformationClass);
 814     return STATUS_INVALID_INFO_CLASS;
 815 }
 816
 817
 818 /******************************************************************************
 819  * NtQueryTimerResolution [NTDLL.@]
 820  */
 821 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
 822                                        OUT ULONG* max_resolution,
 823                                        OUT ULONG* current_resolution)
 824 {
 825     FIXME("(%p,%p,%p), stub!\n",
 826           min_resolution, max_resolution, current_resolution);
 827
 828     return STATUS_NOT_IMPLEMENTED;
 829 }
 830
 831 /******************************************************************************
 832  * NtSetTimerResolution [NTDLL.@]
 833  */
 834 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
 835                                      IN BOOLEAN set_resolution,
 836                                      OUT ULONG* current_resolution )
 837 {
 838     FIXME("(%u,%u,%p), stub!\n",
 839           resolution, set_resolution, current_resolution);
 840
 841     return STATUS_NOT_IMPLEMENTED;
 842 }
 843
 844
 845
 846 /* wait operations */
 847
 848 /******************************************************************
 849  *              NtWaitForMultipleObjects (NTDLL.@)
 850  */
 851 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
 852                                           BOOLEAN wait_all, BOOLEAN alertable,
 853                                           const LARGE_INTEGER *timeout )
 854 {
 855     select_op_t select_op;
 856     UINT i, flags = SELECT_INTERRUPTIBLE;
 857
 858     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
 859
 860     if (alertable) flags |= SELECT_ALERTABLE;
 861     select_op.wait.op = wait_all ? SELECT_WAIT_ALL : SELECT_WAIT;
 862     for (i = 0; i < count; i++) select_op.wait.handles[i] = wine_server_obj_handle( handles[i] );
 863     return server_select( &select_op, offsetof( select_op_t, wait.handles[count] ), flags, timeout );
 864 }
 865
 866
 867 /******************************************************************
 868  *              NtWaitForSingleObject (NTDLL.@)
 869  */
 870 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
 871 {
 872     return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
 873 }
 874
 875
 876 /******************************************************************
 877  *              NtSignalAndWaitForSingleObject (NTDLL.@)
 878  */
 879 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE hSignalObject, HANDLE hWaitObject,
 880                                                 BOOLEAN alertable, const LARGE_INTEGER *timeout )
 881 {
 882     select_op_t select_op;
 883     UINT flags = SELECT_INTERRUPTIBLE;
 884
 885     if (!hSignalObject) return STATUS_INVALID_HANDLE;
 886
 887     if (alertable) flags |= SELECT_ALERTABLE;
 888     select_op.signal_and_wait.op = SELECT_SIGNAL_AND_WAIT;
 889     select_op.signal_and_wait.wait = wine_server_obj_handle( hWaitObject );
 890     select_op.signal_and_wait.signal = wine_server_obj_handle( hSignalObject );
 891     return server_select( &select_op, sizeof(select_op.signal_and_wait), flags, timeout );
 892 }
 893
 894
 895 /******************************************************************
 896  *              NtYieldExecution (NTDLL.@)
 897  */
 898 NTSTATUS WINAPI NtYieldExecution(void)
 899 {
 900 #ifdef HAVE_SCHED_YIELD
 901     sched_yield();
 902     return STATUS_SUCCESS;
 903 #else
 904     return STATUS_NO_YIELD_PERFORMED;
 905 #endif
 906 }
 907
 908
 909 /******************************************************************
 910  *              NtDelayExecution (NTDLL.@)
 911  */
 912 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
 913 {
 914     /* if alertable, we need to query the server */
 915     if (alertable)
 916         return server_select( NULL, 0, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE, timeout );
 917
 918     if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE)  /* sleep forever */
 919     {
 920         for (;;) select( 0, NULL, NULL, NULL, NULL );
 921     }
 922     else
 923     {
 924         LARGE_INTEGER now;
 925         timeout_t when, diff;
 926
 927         if ((when = timeout->QuadPart) < 0)
 928         {
 929             NtQuerySystemTime( &now );
 930             when = now.QuadPart - when;
 931         }
 932
 933         /* Note that we yield after establishing the desired timeout */
 934         NtYieldExecution();
 935         if (!when) return STATUS_SUCCESS;
 936
 937         for (;;)
 938         {
 939             struct timeval tv;
 940             NtQuerySystemTime( &now );
 941             diff = (when - now.QuadPart + 9) / 10;
 942             if (diff <= 0) break;
 943             tv.tv_sec  = diff / 1000000;
 944             tv.tv_usec = diff % 1000000;
 945             if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
 946         }
 947     }
 948     return STATUS_SUCCESS;
 949 }
 950
 951
 952 /******************************************************************************
 953  *              NtCreateKeyedEvent (NTDLL.@)
 954  */
 955 NTSTATUS WINAPI NtCreateKeyedEvent( HANDLE *handle, ACCESS_MASK access,
 956                                     const OBJECT_ATTRIBUTES *attr, ULONG flags )
 957 {
 958     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 959     NTSTATUS ret;
 960     struct security_descriptor *sd = NULL;
 961     struct object_attributes objattr;
 962
 963     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 964
 965     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 966     objattr.sd_len = 0;
 967     objattr.name_len = len;
 968     if (attr)
 969     {
 970         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 971         if (ret != STATUS_SUCCESS) return ret;
 972     }
 973
 974     SERVER_START_REQ( create_keyed_event )
 975     {
 976         req->access = access;
 977         req->attributes = attr ? attr->Attributes : 0;
 978         wine_server_add_data( req, &objattr, sizeof(objattr) );
 979         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 980         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 981         ret = wine_server_call( req );
 982         *handle = wine_server_ptr_handle( reply->handle );
 983     }
 984     SERVER_END_REQ;
 985
 986     NTDLL_free_struct_sd( sd );
 987     return ret;
 988 }
 989
 990 /******************************************************************************
 991  *              NtOpenKeyedEvent (NTDLL.@)
 992  */
 993 NTSTATUS WINAPI NtOpenKeyedEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 994 {
 995     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 996     NTSTATUS ret;
 997
 998     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 999
1000     SERVER_START_REQ( open_keyed_event )
1001     {
1002         req->access  = access;
1003         req->attributes = attr ? attr->Attributes : 0;
1004         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
1005         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
1006         ret = wine_server_call( req );
1007         *handle = wine_server_ptr_handle( reply->handle );
1008     }
1009     SERVER_END_REQ;
1010     return ret;
1011 }
1012
1013 /******************************************************************************
1014  *              NtWaitForKeyedEvent (NTDLL.@)
1015  */
1016 NTSTATUS WINAPI NtWaitForKeyedEvent( HANDLE handle, const void *key,
1017                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
1018 {
1019     select_op_t select_op;
1020     UINT flags = SELECT_INTERRUPTIBLE;
1021
1022     if ((ULONG_PTR)key & 1) return STATUS_INVALID_PARAMETER_1;
1023     if (alertable) flags |= SELECT_ALERTABLE;
1024     select_op.keyed_event.op     = SELECT_KEYED_EVENT_WAIT;
1025     select_op.keyed_event.handle = wine_server_obj_handle( handle );
1026     select_op.keyed_event.key    = wine_server_client_ptr( key );
1027     return server_select( &select_op, sizeof(select_op.keyed_event), flags, timeout );
1028 }
1029
1030 /******************************************************************************
1031  *              NtReleaseKeyedEvent (NTDLL.@)
1032  */
1033 NTSTATUS WINAPI NtReleaseKeyedEvent( HANDLE handle, const void *key,
1034                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
1035 {
1036     select_op_t select_op;
1037     UINT flags = SELECT_INTERRUPTIBLE;
1038
1039     if ((ULONG_PTR)key & 1) return STATUS_INVALID_PARAMETER_1;
1040     if (alertable) flags |= SELECT_ALERTABLE;
1041     select_op.keyed_event.op     = SELECT_KEYED_EVENT_RELEASE;
1042     select_op.keyed_event.handle = wine_server_obj_handle( handle );
1043     select_op.keyed_event.key    = wine_server_client_ptr( key );
1044     return server_select( &select_op, sizeof(select_op.keyed_event), flags, timeout );
1045 }
1046
1047 /******************************************************************
1048  *              NtCreateIoCompletion (NTDLL.@)
1049  *              ZwCreateIoCompletion (NTDLL.@)
1050  *
1051  * Creates I/O completion object.
1052  *
1053  * PARAMS
1054  *      CompletionPort            [O] created completion object handle will be placed there
1055  *      DesiredAccess             [I] desired access to a handle (combination of IO_COMPLETION_*)
1056  *      ObjectAttributes          [I] completion object attributes
1057  *      NumberOfConcurrentThreads [I] desired number of concurrent active worker threads
1058  *
1059  */
1060 NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1061                                       POBJECT_ATTRIBUTES ObjectAttributes, ULONG NumberOfConcurrentThreads )
1062 {
1063     NTSTATUS status;
1064
1065     TRACE("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess,
1066           ObjectAttributes, NumberOfConcurrentThreads);
1067
1068     if (!CompletionPort)
1069         return STATUS_INVALID_PARAMETER;
1070
1071     SERVER_START_REQ( create_completion )
1072     {
1073         req->access     = DesiredAccess;
1074         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
1075         req->rootdir    = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
1076         req->concurrent = NumberOfConcurrentThreads;
1077         if (ObjectAttributes && ObjectAttributes->ObjectName)
1078             wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1079                                        ObjectAttributes->ObjectName->Length );
1080         if (!(status = wine_server_call( req )))
1081             *CompletionPort = wine_server_ptr_handle( reply->handle );
1082     }
1083     SERVER_END_REQ;
1084     return status;
1085 }
1086
1087 /******************************************************************
1088  *              NtSetIoCompletion (NTDLL.@)
1089  *              ZwSetIoCompletion (NTDLL.@)
1090  *
1091  * Inserts completion message into queue
1092  *
1093  * PARAMS
1094  *      CompletionPort           [I] HANDLE to completion object
1095  *      CompletionKey            [I] completion key
1096  *      CompletionValue          [I] completion value (usually pointer to OVERLAPPED)
1097  *      Status                   [I] operation status
1098  *      NumberOfBytesTransferred [I] number of bytes transferred
1099  */
1100 NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKey,
1101                                    ULONG_PTR CompletionValue, NTSTATUS Status,
1102                                    SIZE_T NumberOfBytesTransferred )
1103 {
1104     NTSTATUS status;
1105
1106     TRACE("(%p, %lx, %lx, %x, %lx)\n", CompletionPort, CompletionKey,
1107           CompletionValue, Status, NumberOfBytesTransferred);
1108
1109     SERVER_START_REQ( add_completion )
1110     {
1111         req->handle      = wine_server_obj_handle( CompletionPort );
1112         req->ckey        = CompletionKey;
1113         req->cvalue      = CompletionValue;
1114         req->status      = Status;
1115         req->information = NumberOfBytesTransferred;
1116         status = wine_server_call( req );
1117     }
1118     SERVER_END_REQ;
1119     return status;
1120 }
1121
1122 /******************************************************************
1123  *              NtRemoveIoCompletion (NTDLL.@)
1124  *              ZwRemoveIoCompletion (NTDLL.@)
1125  *
1126  * (Wait for and) retrieve first completion message from completion object's queue
1127  *
1128  * PARAMS
1129  *      CompletionPort  [I] HANDLE to I/O completion object
1130  *      CompletionKey   [O] completion key
1131  *      CompletionValue [O] Completion value given in NtSetIoCompletion or in async operation
1132  *      iosb            [O] IO_STATUS_BLOCK of completed asynchronous operation
1133  *      WaitTime        [I] optional wait time in NTDLL format
1134  *
1135  */
1136 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE CompletionPort, PULONG_PTR CompletionKey,
1137                                       PULONG_PTR CompletionValue, PIO_STATUS_BLOCK iosb,
1138                                       PLARGE_INTEGER WaitTime )
1139 {
1140     NTSTATUS status;
1141
1142     TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort, CompletionKey,
1143           CompletionValue, iosb, WaitTime);
1144
1145     for(;;)
1146     {
1147         SERVER_START_REQ( remove_completion )
1148         {
1149             req->handle = wine_server_obj_handle( CompletionPort );
1150             if (!(status = wine_server_call( req )))
1151             {
1152                 *CompletionKey    = reply->ckey;
1153                 *CompletionValue  = reply->cvalue;
1154                 iosb->Information = reply->information;
1155                 iosb->u.Status    = reply->status;
1156             }
1157         }
1158         SERVER_END_REQ;
1159         if (status != STATUS_PENDING) break;
1160
1161         status = NtWaitForSingleObject( CompletionPort, FALSE, WaitTime );
1162         if (status != WAIT_OBJECT_0) break;
1163     }
1164     return status;
1165 }
1166
1167 /******************************************************************
1168  *              NtOpenIoCompletion (NTDLL.@)
1169  *              ZwOpenIoCompletion (NTDLL.@)
1170  *
1171  * Opens I/O completion object
1172  *
1173  * PARAMS
1174  *      CompletionPort     [O] completion object handle will be placed there
1175  *      DesiredAccess      [I] desired access to a handle (combination of IO_COMPLETION_*)
1176  *      ObjectAttributes   [I] completion object name
1177  *
1178  */
1179 NTSTATUS WINAPI NtOpenIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1180                                     POBJECT_ATTRIBUTES ObjectAttributes )
1181 {
1182     NTSTATUS status;
1183
1184     TRACE("(%p, 0x%x, %p)\n", CompletionPort, DesiredAccess, ObjectAttributes);
1185
1186     if (!CompletionPort || !ObjectAttributes || !ObjectAttributes->ObjectName)
1187         return STATUS_INVALID_PARAMETER;
1188
1189     SERVER_START_REQ( open_completion )
1190     {
1191         req->access     = DesiredAccess;
1192         req->rootdir    = wine_server_obj_handle( ObjectAttributes->RootDirectory );
1193         wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1194                                    ObjectAttributes->ObjectName->Length );
1195         if (!(status = wine_server_call( req )))
1196             *CompletionPort = wine_server_ptr_handle( reply->handle );
1197     }
1198     SERVER_END_REQ;
1199     return status;
1200 }
1201
1202 /******************************************************************
1203  *              NtQueryIoCompletion (NTDLL.@)
1204  *              ZwQueryIoCompletion (NTDLL.@)
1205  *
1206  * Requests information about given I/O completion object
1207  *
1208  * PARAMS
1209  *      CompletionPort        [I] HANDLE to completion port to request
1210  *      InformationClass      [I] information class
1211  *      CompletionInformation [O] user-provided buffer for data
1212  *      BufferLength          [I] buffer length
1213  *      RequiredLength        [O] required buffer length
1214  *
1215  */
1216 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE CompletionPort, IO_COMPLETION_INFORMATION_CLASS InformationClass,
1217                                      PVOID CompletionInformation, ULONG BufferLength, PULONG RequiredLength )
1218 {
1219     NTSTATUS status;
1220
1221     TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort, InformationClass, CompletionInformation,
1222           BufferLength, RequiredLength);
1223
1224     if (!CompletionInformation) return STATUS_INVALID_PARAMETER;
1225     switch( InformationClass )
1226     {
1227         case IoCompletionBasicInformation:
1228             {
1229                 ULONG *info = CompletionInformation;
1230
1231                 if (RequiredLength) *RequiredLength = sizeof(*info);
1232                 if (BufferLength != sizeof(*info))
1233                     status = STATUS_INFO_LENGTH_MISMATCH;
1234                 else
1235                 {
1236                     SERVER_START_REQ( query_completion )
1237                     {
1238                         req->handle = wine_server_obj_handle( CompletionPort );
1239                         if (!(status = wine_server_call( req )))
1240                             *info = reply->depth;
1241                     }
1242                     SERVER_END_REQ;
1243                 }
1244             }
1245             break;
1246         default:
1247             status = STATUS_INVALID_PARAMETER;
1248             break;
1249     }
1250     return status;
1251 }
1252
1253 NTSTATUS NTDLL_AddCompletion( HANDLE hFile, ULONG_PTR CompletionValue,
1254                               NTSTATUS CompletionStatus, ULONG Information )
1255 {
1256     NTSTATUS status;
1257
1258     SERVER_START_REQ( add_fd_completion )
1259     {
1260         req->handle      = wine_server_obj_handle( hFile );
1261         req->cvalue      = CompletionValue;
1262         req->status      = CompletionStatus;
1263         req->information = Information;
1264         status = wine_server_call( req );
1265     }
1266     SERVER_END_REQ;
1267     return status;
1268 }
1269
1270 /******************************************************************
1271  *              RtlRunOnceInitialize (NTDLL.@)
1272  */
1273 void WINAPI RtlRunOnceInitialize( RTL_RUN_ONCE *once )
1274 {
1275     once->Ptr = NULL;
1276 }
1277
1278 /******************************************************************
1279  *              RtlRunOnceBeginInitialize (NTDLL.@)
1280  */
1281 DWORD WINAPI RtlRunOnceBeginInitialize( RTL_RUN_ONCE *once, ULONG flags, void **context )
1282 {
1283     if (flags & RTL_RUN_ONCE_CHECK_ONLY)
1284     {
1285         ULONG_PTR val = (ULONG_PTR)once->Ptr;
1286
1287         if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
1288         if ((val & 3) != 2) return STATUS_UNSUCCESSFUL;
1289         if (context) *context = (void *)(val & ~3);
1290         return STATUS_SUCCESS;
1291     }
1292
1293     for (;;)
1294     {
1295         ULONG_PTR next, val = (ULONG_PTR)once->Ptr;
1296
1297         switch (val & 3)
1298         {
1299         case 0:  /* first time */
1300             if (!interlocked_cmpxchg_ptr( &once->Ptr,
1301                                           (flags & RTL_RUN_ONCE_ASYNC) ? (void *)3 : (void *)1, 0 ))
1302                 return STATUS_PENDING;
1303             break;
1304
1305         case 1:  /* in progress, wait */
1306             if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
1307             next = val & ~3;
1308             if (interlocked_cmpxchg_ptr( &once->Ptr, (void *)((ULONG_PTR)&next | 1),
1309                                          (void *)val ) == (void *)val)
1310                 NtWaitForKeyedEvent( keyed_event, &next, FALSE, NULL );
1311             break;
1312
1313         case 2:  /* done */
1314             if (context) *context = (void *)(val & ~3);
1315             return STATUS_SUCCESS;
1316
1317         case 3:  /* in progress, async */
1318             if (!(flags & RTL_RUN_ONCE_ASYNC)) return STATUS_INVALID_PARAMETER;
1319             return STATUS_PENDING;
1320         }
1321     }
1322 }
1323
1324 /******************************************************************
1325  *              RtlRunOnceComplete (NTDLL.@)
1326  */
1327 DWORD WINAPI RtlRunOnceComplete( RTL_RUN_ONCE *once, ULONG flags, void *context )
1328 {
1329     if ((ULONG_PTR)context & 3) return STATUS_INVALID_PARAMETER;
1330
1331     if (flags & RTL_RUN_ONCE_INIT_FAILED)
1332     {
1333         if (context) return STATUS_INVALID_PARAMETER;
1334         if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
1335     }
1336     else context = (void *)((ULONG_PTR)context | 2);
1337
1338     for (;;)
1339     {
1340         ULONG_PTR val = (ULONG_PTR)once->Ptr;
1341
1342         switch (val & 3)
1343         {
1344         case 1:  /* in progress */
1345             if (interlocked_cmpxchg_ptr( &once->Ptr, context, (void *)val ) != (void *)val) break;
1346             val &= ~3;
1347             while (val)
1348             {
1349                 ULONG_PTR next = *(ULONG_PTR *)val;
1350                 NtReleaseKeyedEvent( keyed_event, (void *)val, FALSE, NULL );
1351                 val = next;
1352             }
1353             return STATUS_SUCCESS;
1354
1355         case 3:  /* in progress, async */
1356             if (!(flags & RTL_RUN_ONCE_ASYNC)) return STATUS_INVALID_PARAMETER;
1357             if (interlocked_cmpxchg_ptr( &once->Ptr, context, (void *)val ) != (void *)val) break;
1358             return STATUS_SUCCESS;
1359
1360         default:
1361             return STATUS_UNSUCCESSFUL;
1362         }
1363     }
1364 }
1365
1366 /******************************************************************
1367  *              RtlRunOnceExecuteOnce (NTDLL.@)
1368  */
1369 DWORD WINAPI RtlRunOnceExecuteOnce( RTL_RUN_ONCE *once, PRTL_RUN_ONCE_INIT_FN func,
1370                                     void *param, void **context )
1371 {
1372     DWORD ret = RtlRunOnceBeginInitialize( once, 0, context );
1373
1374     if (ret != STATUS_PENDING) return ret;
1375
1376     if (!func( once, param, context ))
1377     {
1378         RtlRunOnceComplete( once, RTL_RUN_ONCE_INIT_FAILED, NULL );
1379         return STATUS_UNSUCCESSFUL;
1380     }
1381
1382     return RtlRunOnceComplete( once, 0, context ? *context : NULL );
1383 }
1384
1385
1386 /* SRW locks implementation
1387  *
1388  * The memory layout used by the lock is:
1389  *
1390  * 32 31            16               0
1391  *  ________________ ________________
1392  * | X| #exclusive  |    #shared     |
1393  *  ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1394  * Since there is no space left for a separate counter of shared access
1395  * threads inside the locked section the #shared field is used for multiple
1396  * purposes. The following table lists all possible states the lock can be
1397  * in, notation: [X, #exclusive, #shared]:
1398  *
1399  * [0,   0,   N] -> locked by N shared access threads, if N=0 its unlocked
1400  * [0, >=1, >=1] -> threads are requesting exclusive locks, but there are
1401  * still shared access threads inside. #shared should not be incremented
1402  * anymore!
1403  * [1, >=1, >=0] -> lock is owned by an exclusive thread and the #shared
1404  * counter can be used again to count the number of threads waiting in the
1405  * queue for shared access.
1406  *
1407  * the following states are invalid and will never occur:
1408  * [0, >=1,   0], [1,   0, >=0]
1409  *
1410  * The main problem arising from the fact that we have no separate counter
1411  * of shared access threads inside the locked section is that in the state
1412  * [0, >=1, >=1] above we cannot add additional waiting threads to the
1413  * shared access queue - it wouldn't be possible to distinguish waiting
1414  * threads and those that are still inside. To solve this problem the lock
1415  * uses the following approach: a thread that isn't able to allocate a
1416  * shared lock just uses the exclusive queue instead. As soon as the thread
1417  * is woken up it is in the state [1, >=1, >=0]. In this state it's again
1418  * possible to use the shared access queue. The thread atomically moves
1419  * itself to the shared access queue and releases the exclusive lock, so
1420  * that the "real" exclusive access threads have a chance. As soon as they
1421  * are all ready the shared access threads are processed.
1422  */
1423
1424 #define SRWLOCK_MASK_IN_EXCLUSIVE     0x80000000
1425 #define SRWLOCK_MASK_EXCLUSIVE_QUEUE  0x7fff0000
1426 #define SRWLOCK_MASK_SHARED_QUEUE     0x0000ffff
1427 #define SRWLOCK_RES_EXCLUSIVE         0x00010000
1428 #define SRWLOCK_RES_SHARED            0x00000001
1429
1430 #ifdef WORDS_BIGENDIAN
1431 #define srwlock_key_exclusive(lock)   (&lock->Ptr)
1432 #define srwlock_key_shared(lock)      ((void *)((char *)&lock->Ptr + 2))
1433 #else
1434 #define srwlock_key_exclusive(lock)   ((void *)((char *)&lock->Ptr + 2))
1435 #define srwlock_key_shared(lock)      (&lock->Ptr)
1436 #endif
1437
1438 static inline void srwlock_check_invalid( unsigned int val )
1439 {
1440     /* Throw exception if it's impossible to acquire/release this lock. */
1441     if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) == SRWLOCK_MASK_EXCLUSIVE_QUEUE ||
1442             (val & SRWLOCK_MASK_SHARED_QUEUE) == SRWLOCK_MASK_SHARED_QUEUE)
1443         RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);
1444 }
1445
1446 static inline unsigned int srwlock_lock_exclusive( unsigned int *dest, int incr )
1447 {
1448     unsigned int val, tmp;
1449     /* Atomically modifies the value of *dest by adding incr. If the shared
1450      * queue is empty and there are threads waiting for exclusive access, then
1451      * sets the mark SRWLOCK_MASK_IN_EXCLUSIVE to signal other threads that
1452      * they are allowed again to use the shared queue counter. */
1453     for (val = *dest;; val = tmp)
1454     {
1455         tmp = val + incr;
1456         srwlock_check_invalid( tmp );
1457         if ((tmp & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(tmp & SRWLOCK_MASK_SHARED_QUEUE))
1458             tmp |= SRWLOCK_MASK_IN_EXCLUSIVE;
1459         if ((tmp = interlocked_cmpxchg( (int *)dest, tmp, val )) == val)
1460             break;
1461     }
1462     return val;
1463 }
1464
1465 static inline unsigned int srwlock_unlock_exclusive( unsigned int *dest, int incr )
1466 {
1467     unsigned int val, tmp;
1468     /* Atomically modifies the value of *dest by adding incr. If the queue of
1469      * threads waiting for exclusive access is empty, then remove the
1470      * SRWLOCK_MASK_IN_EXCLUSIVE flag (only the shared queue counter will
1471      * remain). */
1472     for (val = *dest;; val = tmp)
1473     {
1474         tmp = val + incr;
1475         srwlock_check_invalid( tmp );
1476         if (!(tmp & SRWLOCK_MASK_EXCLUSIVE_QUEUE))
1477             tmp &= SRWLOCK_MASK_SHARED_QUEUE;
1478         if ((tmp = interlocked_cmpxchg( (int *)dest, tmp, val )) == val)
1479             break;
1480     }
1481     return val;
1482 }
1483
1484 static inline void srwlock_leave_exclusive( RTL_SRWLOCK *lock, unsigned int val )
1485 {
1486     /* Used when a thread leaves an exclusive section. If there are other
1487      * exclusive access threads they are processed first, followed by
1488      * the shared waiters. */
1489     if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
1490         NtReleaseKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
1491     else
1492     {
1493         val &= SRWLOCK_MASK_SHARED_QUEUE; /* remove SRWLOCK_MASK_IN_EXCLUSIVE */
1494         while (val--)
1495             NtReleaseKeyedEvent( keyed_event, srwlock_key_shared(lock), FALSE, NULL );
1496     }
1497 }
1498
1499 static inline void srwlock_leave_shared( RTL_SRWLOCK *lock, unsigned int val )
1500 {
1501     /* Wake up one exclusive thread as soon as the last shared access thread
1502      * has left. */
1503     if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_SHARED_QUEUE))
1504         NtReleaseKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
1505 }
1506
1507 /***********************************************************************
1508  *              RtlInitializeSRWLock (NTDLL.@)
1509  *
1510  * NOTES
1511  *  Please note that SRWLocks do not keep track of the owner of a lock.
1512  *  It doesn't make any difference which thread for example unlocks an
1513  *  SRWLock (see corresponding tests). This implementation uses two
1514  *  keyed events (one for the exclusive waiters and one for the shared
1515  *  waiters) and is limited to 2^15-1 waiting threads.
1516  */
1517 void WINAPI RtlInitializeSRWLock( RTL_SRWLOCK *lock )
1518 {
1519     lock->Ptr = NULL;
1520 }
1521
1522 /***********************************************************************
1523  *              RtlAcquireSRWLockExclusive (NTDLL.@)
1524  *
1525  * NOTES
1526  *  Unlike RtlAcquireResourceExclusive this function doesn't allow
1527  *  nested calls from the same thread. "Upgrading" a shared access lock
1528  *  to an exclusive access lock also doesn't seem to be supported.
1529  */
1530 void WINAPI RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
1531 {
1532     if (srwlock_lock_exclusive( (unsigned int *)&lock->Ptr, SRWLOCK_RES_EXCLUSIVE ))
1533         NtWaitForKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
1534 }
1535
1536 /***********************************************************************
1537  *              RtlAcquireSRWLockShared (NTDLL.@)
1538  *
1539  * NOTES
1540  *   Do not call this function recursively - it will only succeed when
1541  *   there are no threads waiting for an exclusive lock!
1542  */
1543 void WINAPI RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
1544 {
1545     unsigned int val, tmp;
1546     /* Acquires a shared lock. If it's currently not possible to add elements to
1547      * the shared queue, then request exclusive access instead. */
1548     for (val = *(unsigned int *)&lock->Ptr;; val = tmp)
1549     {
1550         if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_IN_EXCLUSIVE))
1551             tmp = val + SRWLOCK_RES_EXCLUSIVE;
1552         else
1553             tmp = val + SRWLOCK_RES_SHARED;
1554         if ((tmp = interlocked_cmpxchg( (int *)&lock->Ptr, tmp, val )) == val)
1555             break;
1556     }
1557
1558     /* Drop exclusive access again and instead requeue for shared access. */
1559     if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_IN_EXCLUSIVE))
1560     {
1561         NtWaitForKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
1562         val = srwlock_unlock_exclusive( (unsigned int *)&lock->Ptr, (SRWLOCK_RES_SHARED
1563                                         - SRWLOCK_RES_EXCLUSIVE) ) - SRWLOCK_RES_EXCLUSIVE;
1564         srwlock_leave_exclusive( lock, val );
1565     }
1566
1567     if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
1568         NtWaitForKeyedEvent( keyed_event, srwlock_key_shared(lock), FALSE, NULL );
1569 }
1570
1571 /***********************************************************************
1572  *              RtlReleaseSRWLockExclusive (NTDLL.@)
1573  */
1574 void WINAPI RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
1575 {
1576     srwlock_leave_exclusive( lock, srwlock_unlock_exclusive( (unsigned int *)&lock->Ptr,
1577                              - SRWLOCK_RES_EXCLUSIVE ) - SRWLOCK_RES_EXCLUSIVE );
1578 }
1579
1580 /***********************************************************************
1581  *              RtlReleaseSRWLockShared (NTDLL.@)
1582  */
1583 void WINAPI RtlReleaseSRWLockShared( RTL_SRWLOCK *lock )
1584 {
1585     srwlock_leave_shared( lock, srwlock_lock_exclusive( (unsigned int *)&lock->Ptr,
1586                           - SRWLOCK_RES_SHARED ) - SRWLOCK_RES_SHARED );
1587 }
1588
1589 /***********************************************************************
1590  *              RtlTryAcquireSRWLockExclusive (NTDLL.@)
1591  *
1592  * NOTES
1593  *  Similar to AcquireSRWLockExclusive recusive calls are not allowed
1594  *  and will fail with return value FALSE.
1595  */
1596 BOOLEAN WINAPI RtlTryAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
1597 {
1598     return interlocked_cmpxchg( (int *)&lock->Ptr, SRWLOCK_MASK_IN_EXCLUSIVE |
1599                                 SRWLOCK_RES_EXCLUSIVE, 0 ) == 0;
1600 }
1601
1602 /***********************************************************************
1603  *              RtlTryAcquireSRWLockShared (NTDLL.@)
1604  */
1605 BOOLEAN WINAPI RtlTryAcquireSRWLockShared( RTL_SRWLOCK *lock )
1606 {
1607     unsigned int val, tmp;
1608     for (val = *(unsigned int *)&lock->Ptr;; val = tmp)
1609     {
1610         if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
1611             return FALSE;
1612         if ((tmp = interlocked_cmpxchg( (int *)&lock->Ptr, val + SRWLOCK_RES_SHARED, val )) == val)
1613             break;
1614     }
1615     return TRUE;
1616 }
1617
1618 /***********************************************************************
1619  *           RtlInitializeConditionVariable   (NTDLL.@)
1620  *
1621  * Initializes the condition variable with NULL.
1622  *
1623  * PARAMS
1624  *  variable [O] condition variable
1625  *
1626  * RETURNS
1627  *  Nothing.
1628  */
1629 void WINAPI RtlInitializeConditionVariable( RTL_CONDITION_VARIABLE *variable )
1630 {
1631     variable->Ptr = NULL;
1632 }
1633
1634 /***********************************************************************
1635  *           RtlWakeConditionVariable   (NTDLL.@)
1636  *
1637  * Wakes up one thread waiting on the condition variable.
1638  *
1639  * PARAMS
1640  *  variable [I/O] condition variable to wake up.
1641  *
1642  * RETURNS
1643  *  Nothing.
1644  *
1645  * NOTES
1646  *  The calling thread does not have to own any lock in order to call
1647  *  this function.
1648  */
1649 void WINAPI RtlWakeConditionVariable( RTL_CONDITION_VARIABLE *variable )
1650 {
1651     if (interlocked_dec_if_nonzero( (int *)&variable->Ptr ))
1652         NtReleaseKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1653 }
1654
1655 /***********************************************************************
1656  *           RtlWakeAllConditionVariable   (NTDLL.@)
1657  *
1658  * See WakeConditionVariable, wakes up all waiting threads.
1659  */
1660 void WINAPI RtlWakeAllConditionVariable( RTL_CONDITION_VARIABLE *variable )
1661 {
1662     int val = interlocked_xchg( (int *)&variable->Ptr, 0 );
1663     while (val-- > 0)
1664         NtReleaseKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1665 }
1666
1667 /***********************************************************************
1668  *           RtlSleepConditionVariableCS   (NTDLL.@)
1669  *
1670  * Atomically releases the critical section and suspends the thread,
1671  * waiting for a Wake(All)ConditionVariable event. Afterwards it enters
1672  * the critical section again and returns.
1673  *
1674  * PARAMS
1675  *  variable  [I/O] condition variable
1676  *  crit      [I/O] critical section to leave temporarily
1677  *  timeout   [I]   timeout
1678  *
1679  * RETURNS
1680  *  see NtWaitForKeyedEvent for all possible return values.
1681  */
1682 NTSTATUS WINAPI RtlSleepConditionVariableCS( RTL_CONDITION_VARIABLE *variable, RTL_CRITICAL_SECTION *crit,
1683                                              const LARGE_INTEGER *timeout )
1684 {
1685     NTSTATUS status;
1686     interlocked_xchg_add( (int *)&variable->Ptr, 1 );
1687     RtlLeaveCriticalSection( crit );
1688
1689     status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, timeout );
1690     if (status != STATUS_SUCCESS)
1691     {
1692         if (!interlocked_dec_if_nonzero( (int *)&variable->Ptr ))
1693             status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1694     }
1695
1696     RtlEnterCriticalSection( crit );
1697     return status;
1698 }
1699
1700 /***********************************************************************
1701  *           RtlSleepConditionVariableSRW   (NTDLL.@)
1702  *
1703  * Atomically releases the SRWLock and suspends the thread,
1704  * waiting for a Wake(All)ConditionVariable event. Afterwards it enters
1705  * the SRWLock again with the same access rights and returns.
1706  *
1707  * PARAMS
1708  *  variable  [I/O] condition variable
1709  *  lock      [I/O] SRWLock to leave temporarily
1710  *  timeout   [I]   timeout
1711  *  flags     [I]   type of the current lock (exclusive / shared)
1712  *
1713  * RETURNS
1714  *  see NtWaitForKeyedEvent for all possible return values.
1715  *
1716  * NOTES
1717  *  the behaviour is undefined if the thread doesn't own the lock.
1718  */
1719 NTSTATUS WINAPI RtlSleepConditionVariableSRW( RTL_CONDITION_VARIABLE *variable, RTL_SRWLOCK *lock,
1720                                               const LARGE_INTEGER *timeout, ULONG flags )
1721 {
1722     NTSTATUS status;
1723     interlocked_xchg_add( (int *)&variable->Ptr, 1 );
1724
1725     if (flags & RTL_CONDITION_VARIABLE_LOCKMODE_SHARED)
1726         RtlReleaseSRWLockShared( lock );
1727     else
1728         RtlReleaseSRWLockExclusive( lock );
1729
1730     status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, timeout );
1731     if (status != STATUS_SUCCESS)
1732     {
1733         if (!interlocked_dec_if_nonzero( (int *)&variable->Ptr ))
1734             status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1735     }
1736
1737     if (flags & RTL_CONDITION_VARIABLE_LOCKMODE_SHARED)
1738         RtlAcquireSRWLockShared( lock );
1739     else
1740         RtlAcquireSRWLockExclusive( lock );
1741     return status;
1742 }