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 #include "ntstatus.h"
  52 #define WIN32_NO_STATUS
  53 #define NONAMELESSUNION
  54 #include "windef.h"
  55 #include "winternl.h"
  56 #include "wine/server.h"
  57 #include "wine/debug.h"
  58 #include "ntdll_misc.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  61
  62 HANDLE keyed_event = NULL;
  63
  64 static inline int interlocked_dec_if_nonzero( int *dest )
  65 {
  66     int val, tmp;
  67     for (val = *dest;; val = tmp)
  68     {
  69         if (!val || (tmp = interlocked_cmpxchg( dest, val - 1, val )) == val)
  70             break;
  71     }
  72     return val;
  73 }
  74
  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 )
  78 {
  79     unsigned int len = sizeof(**ret);
  80     PSID owner, group;
  81     ACL *dacl, *sacl;
  82     BOOLEAN owner_present, group_present, dacl_present, sacl_present, defaulted;
  83     PSECURITY_DESCRIPTOR sd;
  84     NTSTATUS status;
  85
  86     *ret = NULL;
  87     *ret_len = 0;
  88
  89     if (!attr) return STATUS_SUCCESS;
  90
  91     if (attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
  92
  93     if ((sd = attr->SecurityDescriptor))
  94     {
  95         len += sizeof(struct security_descriptor);
  96
  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;
 105
 106         /* fix alignment for the Unicode name that follows the structure */
 107         len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
 108     }
 109
 110     if (attr->ObjectName)
 111     {
 112         if (attr->ObjectName->Length & (sizeof(WCHAR) - 1)) return STATUS_OBJECT_NAME_INVALID;
 113         len += attr->ObjectName->Length;
 114     }
 115     else if (attr->RootDirectory) return STATUS_OBJECT_NAME_INVALID;
 116
 117     *ret = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, len );
 118     if (!*ret) return STATUS_NO_MEMORY;
 119
 120     (*ret)->rootdir = wine_server_obj_handle( attr->RootDirectory );
 121     (*ret)->attributes = attr->Attributes;
 122
 123     if (attr->SecurityDescriptor)
 124     {
 125         struct security_descriptor *descr = (struct security_descriptor *)(*ret + 1);
 126         unsigned char *ptr = (unsigned char *)(descr + 1);
 127
 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;
 133
 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);
 143     }
 144
 145     if (attr->ObjectName)
 146     {
 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 );
 150     }
 151
 152     *ret_len = len;
 153     return STATUS_SUCCESS;
 154 }
 155
 156 NTSTATUS validate_open_object_attributes( const OBJECT_ATTRIBUTES *attr )
 157 {
 158     if (!attr || attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
 159
 160     if (attr->ObjectName)
 161     {
 162         if (attr->ObjectName->Length & (sizeof(WCHAR) - 1)) return STATUS_OBJECT_NAME_INVALID;
 163     }
 164     else if (attr->RootDirectory) return STATUS_OBJECT_NAME_INVALID;
 165
 166     return STATUS_SUCCESS;
 167 }
 168
 169 /*
 170  *      Semaphores
 171  */
 172
 173 /******************************************************************************
 174  *  NtCreateSemaphore (NTDLL.@)
 175  */
 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 )
 181 {
 182     NTSTATUS ret;
 183     data_size_t len;
 184     struct object_attributes *objattr;
 185
 186     if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount)
 187         return STATUS_INVALID_PARAMETER;
 188
 189     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 190
 191     SERVER_START_REQ( create_semaphore )
 192     {
 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 );
 199     }
 200     SERVER_END_REQ;
 201
 202     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 203     return ret;
 204 }
 205
 206 /******************************************************************************
 207  *  NtOpenSemaphore (NTDLL.@)
 208  */
 209 NTSTATUS WINAPI NtOpenSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 210 {
 211     NTSTATUS ret;
 212
 213     if ((ret = validate_open_object_attributes( attr ))) return ret;
 214
 215     SERVER_START_REQ( open_semaphore )
 216     {
 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 );
 224     }
 225     SERVER_END_REQ;
 226     return ret;
 227 }
 228
 229 /******************************************************************************
 230  *  NtQuerySemaphore (NTDLL.@)
 231  */
 232 NTSTATUS WINAPI NtQuerySemaphore( HANDLE handle, SEMAPHORE_INFORMATION_CLASS class,
 233                                   void *info, ULONG len, ULONG *ret_len )
 234 {
 235     NTSTATUS ret;
 236     SEMAPHORE_BASIC_INFORMATION *out = info;
 237
 238     if (class != SemaphoreBasicInformation)
 239     {
 240         FIXME("(%p,%d,%u) Unknown class\n", handle, class, len);
 241         return STATUS_INVALID_INFO_CLASS;
 242     }
 243
 244     if (len != sizeof(SEMAPHORE_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 245
 246     SERVER_START_REQ( query_semaphore )
 247     {
 248         req->handle = wine_server_obj_handle( handle );
 249         if (!(ret = wine_server_call( req )))
 250         {
 251             out->CurrentCount = reply->current;
 252             out->MaximumCount = reply->max;
 253             if (ret_len) *ret_len = sizeof(SEMAPHORE_BASIC_INFORMATION);
 254         }
 255     }
 256     SERVER_END_REQ;
 257
 258     return ret;
 259 }
 260
 261 /******************************************************************************
 262  *  NtReleaseSemaphore (NTDLL.@)
 263  */
 264 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
 265 {
 266     NTSTATUS ret;
 267     SERVER_START_REQ( release_semaphore )
 268     {
 269         req->handle = wine_server_obj_handle( handle );
 270         req->count  = count;
 271         if (!(ret = wine_server_call( req )))
 272         {
 273             if (previous) *previous = reply->prev_count;
 274         }
 275     }
 276     SERVER_END_REQ;
 277     return ret;
 278 }
 279
 280 /*
 281  *      Events
 282  */
 283
 284 /**************************************************************************
 285  * NtCreateEvent (NTDLL.@)
 286  * ZwCreateEvent (NTDLL.@)
 287  */
 288 NTSTATUS WINAPI NtCreateEvent( PHANDLE EventHandle, ACCESS_MASK DesiredAccess,
 289                                const OBJECT_ATTRIBUTES *attr, EVENT_TYPE type, BOOLEAN InitialState)
 290 {
 291     NTSTATUS ret;
 292     data_size_t len;
 293     struct object_attributes *objattr;
 294
 295     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 296
 297     SERVER_START_REQ( create_event )
 298     {
 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 );
 305     }
 306     SERVER_END_REQ;
 307
 308     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 309     return ret;
 310 }
 311
 312 /******************************************************************************
 313  *  NtOpenEvent (NTDLL.@)
 314  *  ZwOpenEvent (NTDLL.@)
 315  */
 316 NTSTATUS WINAPI NtOpenEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 317 {
 318     NTSTATUS ret;
 319
 320     if ((ret = validate_open_object_attributes( attr ))) return ret;
 321
 322     SERVER_START_REQ( open_event )
 323     {
 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 );
 331     }
 332     SERVER_END_REQ;
 333     return ret;
 334 }
 335
 336
 337 /******************************************************************************
 338  *  NtSetEvent (NTDLL.@)
 339  *  ZwSetEvent (NTDLL.@)
 340  */
 341 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 342 {
 343     NTSTATUS ret;
 344
 345     /* FIXME: set NumberOfThreadsReleased */
 346
 347     SERVER_START_REQ( event_op )
 348     {
 349         req->handle = wine_server_obj_handle( handle );
 350         req->op     = SET_EVENT;
 351         ret = wine_server_call( req );
 352     }
 353     SERVER_END_REQ;
 354     return ret;
 355 }
 356
 357 /******************************************************************************
 358  *  NtResetEvent (NTDLL.@)
 359  */
 360 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 361 {
 362     NTSTATUS ret;
 363
 364     /* resetting an event can't release any thread... */
 365     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
 366
 367     SERVER_START_REQ( event_op )
 368     {
 369         req->handle = wine_server_obj_handle( handle );
 370         req->op     = RESET_EVENT;
 371         ret = wine_server_call( req );
 372     }
 373     SERVER_END_REQ;
 374     return ret;
 375 }
 376
 377 /******************************************************************************
 378  *  NtClearEvent (NTDLL.@)
 379  *
 380  * FIXME
 381  *   same as NtResetEvent ???
 382  */
 383 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 384 {
 385     return NtResetEvent( handle, NULL );
 386 }
 387
 388 /******************************************************************************
 389  *  NtPulseEvent (NTDLL.@)
 390  *
 391  * FIXME
 392  *   PulseCount
 393  */
 394 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 395 {
 396     NTSTATUS ret;
 397
 398     if (PulseCount)
 399       FIXME("(%p,%d)\n", handle, *PulseCount);
 400
 401     SERVER_START_REQ( event_op )
 402     {
 403         req->handle = wine_server_obj_handle( handle );
 404         req->op     = PULSE_EVENT;
 405         ret = wine_server_call( req );
 406     }
 407     SERVER_END_REQ;
 408     return ret;
 409 }
 410
 411 /******************************************************************************
 412  *  NtQueryEvent (NTDLL.@)
 413  */
 414 NTSTATUS WINAPI NtQueryEvent( HANDLE handle, EVENT_INFORMATION_CLASS class,
 415                               void *info, ULONG len, ULONG *ret_len )
 416 {
 417     NTSTATUS ret;
 418     EVENT_BASIC_INFORMATION *out = info;
 419
 420     if (class != EventBasicInformation)
 421     {
 422         FIXME("(%p, %d, %d) Unknown class\n",
 423               handle, class, len);
 424         return STATUS_INVALID_INFO_CLASS;
 425     }
 426
 427     if (len != sizeof(EVENT_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 428
 429     SERVER_START_REQ( query_event )
 430     {
 431         req->handle = wine_server_obj_handle( handle );
 432         if (!(ret = wine_server_call( req )))
 433         {
 434             out->EventType  = reply->manual_reset ? NotificationEvent : SynchronizationEvent;
 435             out->EventState = reply->state;
 436             if (ret_len) *ret_len = sizeof(EVENT_BASIC_INFORMATION);
 437         }
 438     }
 439     SERVER_END_REQ;
 440
 441     return ret;
 442 }
 443
 444 /*
 445  *      Mutants (known as Mutexes in Kernel32)
 446  */
 447
 448 /******************************************************************************
 449  *              NtCreateMutant                          [NTDLL.@]
 450  *              ZwCreateMutant                          [NTDLL.@]
 451  */
 452 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
 453                                IN ACCESS_MASK access,
 454                                IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
 455                                IN BOOLEAN InitialOwner)
 456 {
 457     NTSTATUS status;
 458     data_size_t len;
 459     struct object_attributes *objattr;
 460
 461     if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
 462
 463     SERVER_START_REQ( create_mutex )
 464     {
 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 );
 470     }
 471     SERVER_END_REQ;
 472
 473     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 474     return status;
 475 }
 476
 477 /**************************************************************************
 478  *              NtOpenMutant                            [NTDLL.@]
 479  *              ZwOpenMutant                            [NTDLL.@]
 480  */
 481 NTSTATUS WINAPI NtOpenMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 482 {
 483     NTSTATUS    status;
 484
 485     if ((status = validate_open_object_attributes( attr ))) return status;
 486
 487     SERVER_START_REQ( open_mutex )
 488     {
 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 );
 496     }
 497     SERVER_END_REQ;
 498     return status;
 499 }
 500
 501 /**************************************************************************
 502  *              NtReleaseMutant                         [NTDLL.@]
 503  *              ZwReleaseMutant                         [NTDLL.@]
 504  */
 505 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
 506 {
 507     NTSTATUS    status;
 508
 509     SERVER_START_REQ( release_mutex )
 510     {
 511         req->handle = wine_server_obj_handle( handle );
 512         status = wine_server_call( req );
 513         if (prev_count) *prev_count = reply->prev_count;
 514     }
 515     SERVER_END_REQ;
 516     return status;
 517 }
 518
 519 /******************************************************************
 520  *              NtQueryMutant                   [NTDLL.@]
 521  *              ZwQueryMutant                   [NTDLL.@]
 522  */
 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 )
 528 {
 529     FIXME("(%p %u %p %u %p): stub!\n",
 530           handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
 531     return STATUS_NOT_IMPLEMENTED;
 532 }
 533
 534 /*
 535  *      Jobs
 536  */
 537
 538 /******************************************************************************
 539  *              NtCreateJobObject   [NTDLL.@]
 540  *              ZwCreateJobObject   [NTDLL.@]
 541  */
 542 NTSTATUS WINAPI NtCreateJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 543 {
 544     NTSTATUS ret;
 545     data_size_t len;
 546     struct object_attributes *objattr;
 547
 548     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 549
 550     SERVER_START_REQ( create_job )
 551     {
 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 );
 556     }
 557     SERVER_END_REQ;
 558
 559     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 560     return ret;
 561 }
 562
 563 /******************************************************************************
 564  *              NtOpenJobObject   [NTDLL.@]
 565  *              ZwOpenJobObject   [NTDLL.@]
 566  */
 567 NTSTATUS WINAPI NtOpenJobObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 568 {
 569     NTSTATUS ret;
 570
 571     if ((ret = validate_open_object_attributes( attr ))) return ret;
 572
 573     SERVER_START_REQ( open_job )
 574     {
 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 );
 582     }
 583     SERVER_END_REQ;
 584     return ret;
 585 }
 586
 587 /******************************************************************************
 588  *              NtTerminateJobObject   [NTDLL.@]
 589  *              ZwTerminateJobObject   [NTDLL.@]
 590  */
 591 NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status )
 592 {
 593     NTSTATUS ret;
 594
 595     TRACE( "(%p, %d)\n", handle, status );
 596
 597     SERVER_START_REQ( terminate_job )
 598     {
 599         req->handle = wine_server_obj_handle( handle );
 600         req->status = status;
 601         ret = wine_server_call( req );
 602     }
 603     SERVER_END_REQ;
 604
 605     return ret;
 606 }
 607
 608 /******************************************************************************
 609  *              NtQueryInformationJobObject   [NTDLL.@]
 610  *              ZwQueryInformationJobObject   [NTDLL.@]
 611  */
 612 NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info,
 613                                              ULONG len, PULONG ret_len )
 614 {
 615     FIXME( "stub: %p %u %p %u %p\n", handle, class, info, len, ret_len );
 616
 617     if (class >= MaxJobObjectInfoClass)
 618         return STATUS_INVALID_PARAMETER;
 619
 620     switch (class)
 621     {
 622     case JobObjectExtendedLimitInformation:
 623         {
 624             JOBOBJECT_EXTENDED_LIMIT_INFORMATION *extended_limit;
 625             if (len < sizeof(*extended_limit))
 626                 return STATUS_INFO_LENGTH_MISMATCH;
 627
 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;
 632         }
 633
 634     case JobObjectBasicLimitInformation:
 635         {
 636             JOBOBJECT_BASIC_LIMIT_INFORMATION *basic_limit;
 637             if (len < sizeof(*basic_limit))
 638                 return STATUS_INFO_LENGTH_MISMATCH;
 639
 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;
 644         }
 645
 646     default:
 647         return STATUS_NOT_IMPLEMENTED;
 648     }
 649 }
 650
 651 /******************************************************************************
 652  *              NtSetInformationJobObject   [NTDLL.@]
 653  *              ZwSetInformationJobObject   [NTDLL.@]
 654  */
 655 NTSTATUS WINAPI NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info, ULONG len )
 656 {
 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;
 661
 662     TRACE( "(%p, %u, %p, %u)\n", handle, class, info, len );
 663
 664     if (class >= MaxJobObjectInfoClass)
 665         return STATUS_INVALID_PARAMETER;
 666
 667     switch (class)
 668     {
 669
 670     case JobObjectExtendedLimitInformation:
 671         info_size = sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION);
 672         limit_flags = JOB_OBJECT_EXTENDED_LIMIT_VALID_FLAGS;
 673         /* fallthrough */
 674     case JobObjectBasicLimitInformation:
 675         if (len != info_size)
 676             return STATUS_INVALID_PARAMETER;
 677
 678         basic_limit = info;
 679         if (basic_limit->LimitFlags & ~limit_flags)
 680             return STATUS_INVALID_PARAMETER;
 681
 682         SERVER_START_REQ( set_job_limits )
 683         {
 684             req->handle = wine_server_obj_handle( handle );
 685             req->limit_flags = basic_limit->LimitFlags;
 686             status = wine_server_call( req );
 687         }
 688         SERVER_END_REQ;
 689         break;
 690
 691     case JobObjectAssociateCompletionPortInformation:
 692         if (len != sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT))
 693             return STATUS_INVALID_PARAMETER;
 694
 695         SERVER_START_REQ( set_job_completion_port )
 696         {
 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);
 702         }
 703         SERVER_END_REQ;
 704         break;
 705
 706     case JobObjectBasicUIRestrictions:
 707         status = STATUS_SUCCESS;
 708         /* fallthrough */
 709     default:
 710         FIXME( "stub: %p %u %p %u\n", handle, class, info, len );
 711     }
 712
 713     return status;
 714 }
 715
 716 /******************************************************************************
 717  *              NtIsProcessInJob   [NTDLL.@]
 718  *              ZwIsProcessInJob   [NTDLL.@]
 719  */
 720 NTSTATUS WINAPI NtIsProcessInJob( HANDLE process, HANDLE job )
 721 {
 722     NTSTATUS status;
 723
 724     TRACE( "(%p %p)\n", job, process );
 725
 726     SERVER_START_REQ( process_in_job )
 727     {
 728         req->job     = wine_server_obj_handle( job );
 729         req->process = wine_server_obj_handle( process );
 730         status = wine_server_call( req );
 731     }
 732     SERVER_END_REQ;
 733
 734     return status;
 735 }
 736
 737 /******************************************************************************
 738  *              NtAssignProcessToJobObject   [NTDLL.@]
 739  *              ZwAssignProcessToJobObject   [NTDLL.@]
 740  */
 741 NTSTATUS WINAPI NtAssignProcessToJobObject( HANDLE job, HANDLE process )
 742 {
 743     NTSTATUS status;
 744
 745     TRACE( "(%p %p)\n", job, process );
 746
 747     SERVER_START_REQ( assign_job )
 748     {
 749         req->job     = wine_server_obj_handle( job );
 750         req->process = wine_server_obj_handle( process );
 751         status = wine_server_call( req );
 752     }
 753     SERVER_END_REQ;
 754
 755     return status;
 756 }
 757
 758 /*
 759  *      Timers
 760  */
 761
 762 /**************************************************************************
 763  *              NtCreateTimer                           [NTDLL.@]
 764  *              ZwCreateTimer                           [NTDLL.@]
 765  */
 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)
 770 {
 771     NTSTATUS status;
 772     data_size_t len;
 773     struct object_attributes *objattr;
 774
 775     if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
 776         return STATUS_INVALID_PARAMETER;
 777
 778     if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
 779
 780     SERVER_START_REQ( create_timer )
 781     {
 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 );
 787     }
 788     SERVER_END_REQ;
 789
 790     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 791     return status;
 792
 793 }
 794
 795 /**************************************************************************
 796  *              NtOpenTimer                             [NTDLL.@]
 797  *              ZwOpenTimer                             [NTDLL.@]
 798  */
 799 NTSTATUS WINAPI NtOpenTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 800 {
 801     NTSTATUS status;
 802
 803     if ((status = validate_open_object_attributes( attr ))) return status;
 804
 805     SERVER_START_REQ( open_timer )
 806     {
 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 );
 814     }
 815     SERVER_END_REQ;
 816     return status;
 817 }
 818
 819 /**************************************************************************
 820  *              NtSetTimer                              [NTDLL.@]
 821  *              ZwSetTimer                              [NTDLL.@]
 822  */
 823 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
 824                            IN const LARGE_INTEGER* when,
 825                            IN PTIMER_APC_ROUTINE callback,
 826                            IN PVOID callback_arg,
 827                            IN BOOLEAN resume,
 828                            IN ULONG period OPTIONAL,
 829                            OUT PBOOLEAN state OPTIONAL)
 830 {
 831     NTSTATUS    status = STATUS_SUCCESS;
 832
 833     TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
 834           handle, when, callback, callback_arg, resume, period, state);
 835
 836     SERVER_START_REQ( set_timer )
 837     {
 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;
 845     }
 846     SERVER_END_REQ;
 847
 848     /* set error but can still succeed */
 849     if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
 850     return status;
 851 }
 852
 853 /**************************************************************************
 854  *              NtCancelTimer                           [NTDLL.@]
 855  *              ZwCancelTimer                           [NTDLL.@]
 856  */
 857 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
 858 {
 859     NTSTATUS    status;
 860
 861     SERVER_START_REQ( cancel_timer )
 862     {
 863         req->handle = wine_server_obj_handle( handle );
 864         status = wine_server_call( req );
 865         if (state) *state = reply->signaled;
 866     }
 867     SERVER_END_REQ;
 868     return status;
 869 }
 870
 871 /******************************************************************************
 872  *  NtQueryTimer (NTDLL.@)
 873  *
 874  * Retrieves information about a timer.
 875  *
 876  * PARAMS
 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.
 882  *
 883  * RETURNS
 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
 889  *           to the timer.
 890  */
 891 NTSTATUS WINAPI NtQueryTimer(
 892     HANDLE TimerHandle,
 893     TIMER_INFORMATION_CLASS TimerInformationClass,
 894     PVOID TimerInformation,
 895     ULONG Length,
 896     PULONG ReturnLength)
 897 {
 898     TIMER_BASIC_INFORMATION * basic_info = TimerInformation;
 899     NTSTATUS status;
 900     LARGE_INTEGER now;
 901
 902     TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
 903        TimerInformation, Length, ReturnLength);
 904
 905     switch (TimerInformationClass)
 906     {
 907     case TimerBasicInformation:
 908         if (Length < sizeof(TIMER_BASIC_INFORMATION))
 909             return STATUS_INFO_LENGTH_MISMATCH;
 910
 911         SERVER_START_REQ(get_timer_info)
 912         {
 913             req->handle = wine_server_obj_handle( TimerHandle );
 914             status = wine_server_call(req);
 915
 916             /* convert server time to absolute NTDLL time */
 917             basic_info->RemainingTime.QuadPart = reply->when;
 918             basic_info->TimerState = reply->signaled;
 919         }
 920         SERVER_END_REQ;
 921
 922         /* convert from absolute into relative time */
 923         NtQuerySystemTime(&now);
 924         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
 925             basic_info->RemainingTime.QuadPart = 0;
 926         else
 927             basic_info->RemainingTime.QuadPart -= now.QuadPart;
 928
 929         if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
 930
 931         return status;
 932     }
 933
 934     FIXME("Unhandled class %d\n", TimerInformationClass);
 935     return STATUS_INVALID_INFO_CLASS;
 936 }
 937
 938
 939 /******************************************************************************
 940  * NtQueryTimerResolution [NTDLL.@]
 941  */
 942 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
 943                                        OUT ULONG* max_resolution,
 944                                        OUT ULONG* current_resolution)
 945 {
 946     FIXME("(%p,%p,%p), stub!\n",
 947           min_resolution, max_resolution, current_resolution);
 948
 949     return STATUS_NOT_IMPLEMENTED;
 950 }
 951
 952 /******************************************************************************
 953  * NtSetTimerResolution [NTDLL.@]
 954  */
 955 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
 956                                      IN BOOLEAN set_resolution,
 957                                      OUT ULONG* current_resolution )
 958 {
 959     FIXME("(%u,%u,%p), stub!\n",
 960           resolution, set_resolution, current_resolution);
 961
 962     return STATUS_NOT_IMPLEMENTED;
 963 }
 964
 965
 966
 967 /* wait operations */
 968
 969 static NTSTATUS wait_objects( DWORD count, const HANDLE *handles,
 970                               BOOLEAN wait_any, BOOLEAN alertable,
 971                               const LARGE_INTEGER *timeout )
 972 {
 973     select_op_t select_op;
 974     UINT i, flags = SELECT_INTERRUPTIBLE;
 975
 976     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
 977
 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 );
 982 }
 983
 984
 985 /******************************************************************
 986  *              NtWaitForMultipleObjects (NTDLL.@)
 987  */
 988 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
 989                                           BOOLEAN wait_any, BOOLEAN alertable,
 990                                           const LARGE_INTEGER *timeout )
 991 {
 992     return wait_objects( count, handles, wait_any, alertable, timeout );
 993 }
 994
 995
 996 /******************************************************************
 997  *              NtWaitForSingleObject (NTDLL.@)
 998  */
 999 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1000 {
1001     return wait_objects( 1, &handle, FALSE, alertable, timeout );
1002 }
1003
1004
1005 /******************************************************************
1006  *              NtSignalAndWaitForSingleObject (NTDLL.@)
1007  */
1008 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE hSignalObject, HANDLE hWaitObject,
1009                                                 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1010 {
1011     select_op_t select_op;
1012     UINT flags = SELECT_INTERRUPTIBLE;
1013
1014     if (!hSignalObject) return STATUS_INVALID_HANDLE;
1015
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 );
1021 }
1022
1023
1024 /******************************************************************
1025  *              NtYieldExecution (NTDLL.@)
1026  */
1027 NTSTATUS WINAPI NtYieldExecution(void)
1028 {
1029 #ifdef HAVE_SCHED_YIELD
1030     sched_yield();
1031     return STATUS_SUCCESS;
1032 #else
1033     return STATUS_NO_YIELD_PERFORMED;
1034 #endif
1035 }
1036
1037
1038 /******************************************************************
1039  *              NtDelayExecution (NTDLL.@)
1040  */
1041 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
1042 {
1043     /* if alertable, we need to query the server */
1044     if (alertable)
1045         return server_select( NULL, 0, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE, timeout );
1046
1047     if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE)  /* sleep forever */
1048     {
1049         for (;;) select( 0, NULL, NULL, NULL, NULL );
1050     }
1051     else
1052     {
1053         LARGE_INTEGER now;
1054         timeout_t when, diff;
1055
1056         if ((when = timeout->QuadPart) < 0)
1057         {
1058             NtQuerySystemTime( &now );
1059             when = now.QuadPart - when;
1060         }
1061
1062         /* Note that we yield after establishing the desired timeout */
1063         NtYieldExecution();
1064         if (!when) return STATUS_SUCCESS;
1065
1066         for (;;)
1067         {
1068             struct timeval tv;
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;
1075         }
1076     }
1077     return STATUS_SUCCESS;
1078 }
1079
1080
1081 /******************************************************************************
1082  *              NtCreateKeyedEvent (NTDLL.@)
1083  */
1084 NTSTATUS WINAPI NtCreateKeyedEvent( HANDLE *handle, ACCESS_MASK access,
1085                                     const OBJECT_ATTRIBUTES *attr, ULONG flags )
1086 {
1087     NTSTATUS ret;
1088     data_size_t len;
1089     struct object_attributes *objattr;
1090
1091     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
1092
1093     SERVER_START_REQ( create_keyed_event )
1094     {
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 );
1099     }
1100     SERVER_END_REQ;
1101
1102     RtlFreeHeap( GetProcessHeap(), 0, objattr );
1103     return ret;
1104 }
1105
1106 /******************************************************************************
1107  *              NtOpenKeyedEvent (NTDLL.@)
1108  */
1109 NTSTATUS WINAPI NtOpenKeyedEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1110 {
1111     NTSTATUS ret;
1112
1113     if ((ret = validate_open_object_attributes( attr ))) return ret;
1114
1115     SERVER_START_REQ( open_keyed_event )
1116     {
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 );
1124     }
1125     SERVER_END_REQ;
1126     return ret;
1127 }
1128
1129 /******************************************************************************
1130  *              NtWaitForKeyedEvent (NTDLL.@)
1131  */
1132 NTSTATUS WINAPI NtWaitForKeyedEvent( HANDLE handle, const void *key,
1133                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
1134 {
1135     select_op_t select_op;
1136     UINT flags = SELECT_INTERRUPTIBLE;
1137
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 );
1144 }
1145
1146 /******************************************************************************
1147  *              NtReleaseKeyedEvent (NTDLL.@)
1148  */
1149 NTSTATUS WINAPI NtReleaseKeyedEvent( HANDLE handle, const void *key,
1150                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
1151 {
1152     select_op_t select_op;
1153     UINT flags = SELECT_INTERRUPTIBLE;
1154
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 );
1161 }
1162
1163 /******************************************************************
1164  *              NtCreateIoCompletion (NTDLL.@)
1165  *              ZwCreateIoCompletion (NTDLL.@)
1166  *
1167  * Creates I/O completion object.
1168  *
1169  * PARAMS
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
1174  *
1175  */
1176 NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1177                                       POBJECT_ATTRIBUTES attr, ULONG NumberOfConcurrentThreads )
1178 {
1179     NTSTATUS status;
1180     data_size_t len;
1181     struct object_attributes *objattr;
1182
1183     TRACE("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess, attr, NumberOfConcurrentThreads);
1184
1185     if (!CompletionPort)
1186         return STATUS_INVALID_PARAMETER;
1187
1188     if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
1189
1190     SERVER_START_REQ( create_completion )
1191     {
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 );
1197     }
1198     SERVER_END_REQ;
1199
1200     RtlFreeHeap( GetProcessHeap(), 0, objattr );
1201     return status;
1202 }
1203
1204 /******************************************************************
1205  *              NtSetIoCompletion (NTDLL.@)
1206  *              ZwSetIoCompletion (NTDLL.@)
1207  *
1208  * Inserts completion message into queue
1209  *
1210  * PARAMS
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
1216  */
1217 NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKey,
1218                                    ULONG_PTR CompletionValue, NTSTATUS Status,
1219                                    SIZE_T NumberOfBytesTransferred )
1220 {
1221     NTSTATUS status;
1222
1223     TRACE("(%p, %lx, %lx, %x, %lx)\n", CompletionPort, CompletionKey,
1224           CompletionValue, Status, NumberOfBytesTransferred);
1225
1226     SERVER_START_REQ( add_completion )
1227     {
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 );
1234     }
1235     SERVER_END_REQ;
1236     return status;
1237 }
1238
1239 /******************************************************************
1240  *              NtRemoveIoCompletion (NTDLL.@)
1241  *              ZwRemoveIoCompletion (NTDLL.@)
1242  *
1243  * (Wait for and) retrieve first completion message from completion object's queue
1244  *
1245  * PARAMS
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
1251  *
1252  */
1253 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE CompletionPort, PULONG_PTR CompletionKey,
1254                                       PULONG_PTR CompletionValue, PIO_STATUS_BLOCK iosb,
1255                                       PLARGE_INTEGER WaitTime )
1256 {
1257     NTSTATUS status;
1258
1259     TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort, CompletionKey,
1260           CompletionValue, iosb, WaitTime);
1261
1262     for(;;)
1263     {
1264         SERVER_START_REQ( remove_completion )
1265         {
1266             req->handle = wine_server_obj_handle( CompletionPort );
1267             if (!(status = wine_server_call( req )))
1268             {
1269                 *CompletionKey    = reply->ckey;
1270                 *CompletionValue  = reply->cvalue;
1271                 iosb->Information = reply->information;
1272                 iosb->u.Status    = reply->status;
1273             }
1274         }
1275         SERVER_END_REQ;
1276         if (status != STATUS_PENDING) break;
1277
1278         status = NtWaitForSingleObject( CompletionPort, FALSE, WaitTime );
1279         if (status != WAIT_OBJECT_0) break;
1280     }
1281     return status;
1282 }
1283
1284 /******************************************************************
1285  *              NtOpenIoCompletion (NTDLL.@)
1286  *              ZwOpenIoCompletion (NTDLL.@)
1287  *
1288  * Opens I/O completion object
1289  *
1290  * PARAMS
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
1294  *
1295  */
1296 NTSTATUS WINAPI NtOpenIoCompletion( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1297 {
1298     NTSTATUS status;
1299
1300     if (!handle) return STATUS_INVALID_PARAMETER;
1301     if ((status = validate_open_object_attributes( attr ))) return status;
1302
1303     SERVER_START_REQ( open_completion )
1304     {
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 );
1312     }
1313     SERVER_END_REQ;
1314     return status;
1315 }
1316
1317 /******************************************************************
1318  *              NtQueryIoCompletion (NTDLL.@)
1319  *              ZwQueryIoCompletion (NTDLL.@)
1320  *
1321  * Requests information about given I/O completion object
1322  *
1323  * PARAMS
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
1329  *
1330  */
1331 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE CompletionPort, IO_COMPLETION_INFORMATION_CLASS InformationClass,
1332                                      PVOID CompletionInformation, ULONG BufferLength, PULONG RequiredLength )
1333 {
1334     NTSTATUS status;
1335
1336     TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort, InformationClass, CompletionInformation,
1337           BufferLength, RequiredLength);
1338
1339     if (!CompletionInformation) return STATUS_INVALID_PARAMETER;
1340     switch( InformationClass )
1341     {
1342         case IoCompletionBasicInformation:
1343             {
1344                 ULONG *info = CompletionInformation;
1345
1346                 if (RequiredLength) *RequiredLength = sizeof(*info);
1347                 if (BufferLength != sizeof(*info))
1348                     status = STATUS_INFO_LENGTH_MISMATCH;
1349                 else
1350                 {
1351                     SERVER_START_REQ( query_completion )
1352                     {
1353                         req->handle = wine_server_obj_handle( CompletionPort );
1354                         if (!(status = wine_server_call( req )))
1355                             *info = reply->depth;
1356                     }
1357                     SERVER_END_REQ;
1358                 }
1359             }
1360             break;
1361         default:
1362             status = STATUS_INVALID_PARAMETER;
1363             break;
1364     }
1365     return status;
1366 }
1367
1368 NTSTATUS NTDLL_AddCompletion( HANDLE hFile, ULONG_PTR CompletionValue,
1369                               NTSTATUS CompletionStatus, ULONG Information )
1370 {
1371     NTSTATUS status;
1372
1373     SERVER_START_REQ( add_fd_completion )
1374     {
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 );
1380     }
1381     SERVER_END_REQ;
1382     return status;
1383 }
1384
1385 /******************************************************************
1386  *              RtlRunOnceInitialize (NTDLL.@)
1387  */
1388 void WINAPI RtlRunOnceInitialize( RTL_RUN_ONCE *once )
1389 {
1390     once->Ptr = NULL;
1391 }
1392
1393 /******************************************************************
1394  *              RtlRunOnceBeginInitialize (NTDLL.@)
1395  */
1396 DWORD WINAPI RtlRunOnceBeginInitialize( RTL_RUN_ONCE *once, ULONG flags, void **context )
1397 {
1398     if (flags & RTL_RUN_ONCE_CHECK_ONLY)
1399     {
1400         ULONG_PTR val = (ULONG_PTR)once->Ptr;
1401
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;
1406     }
1407
1408     for (;;)
1409     {
1410         ULONG_PTR next, val = (ULONG_PTR)once->Ptr;
1411
1412         switch (val & 3)
1413         {
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;
1418             break;
1419
1420         case 1:  /* in progress, wait */
1421             if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
1422             next = val & ~3;
1423             if (interlocked_cmpxchg_ptr( &once->Ptr, (void *)((ULONG_PTR)&next | 1),
1424                                          (void *)val ) == (void *)val)
1425                 NtWaitForKeyedEvent( keyed_event, &next, FALSE, NULL );
1426             break;
1427
1428         case 2:  /* done */
1429             if (context) *context = (void *)(val & ~3);
1430             return STATUS_SUCCESS;
1431
1432         case 3:  /* in progress, async */
1433             if (!(flags & RTL_RUN_ONCE_ASYNC)) return STATUS_INVALID_PARAMETER;
1434             return STATUS_PENDING;
1435         }
1436     }
1437 }
1438
1439 /******************************************************************
1440  *              RtlRunOnceComplete (NTDLL.@)
1441  */
1442 DWORD WINAPI RtlRunOnceComplete( RTL_RUN_ONCE *once, ULONG flags, void *context )
1443 {
1444     if ((ULONG_PTR)context & 3) return STATUS_INVALID_PARAMETER;
1445
1446     if (flags & RTL_RUN_ONCE_INIT_FAILED)
1447     {
1448         if (context) return STATUS_INVALID_PARAMETER;
1449         if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
1450     }
1451     else context = (void *)((ULONG_PTR)context | 2);
1452
1453     for (;;)
1454     {
1455         ULONG_PTR val = (ULONG_PTR)once->Ptr;
1456
1457         switch (val & 3)
1458         {
1459         case 1:  /* in progress */
1460             if (interlocked_cmpxchg_ptr( &once->Ptr, context, (void *)val ) != (void *)val) break;
1461             val &= ~3;
1462             while (val)
1463             {
1464                 ULONG_PTR next = *(ULONG_PTR *)val;
1465                 NtReleaseKeyedEvent( keyed_event, (void *)val, FALSE, NULL );
1466                 val = next;
1467             }
1468             return STATUS_SUCCESS;
1469
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;
1474
1475         default:
1476             return STATUS_UNSUCCESSFUL;
1477         }
1478     }
1479 }
1480
1481 /******************************************************************
1482  *              RtlRunOnceExecuteOnce (NTDLL.@)
1483  */
1484 DWORD WINAPI RtlRunOnceExecuteOnce( RTL_RUN_ONCE *once, PRTL_RUN_ONCE_INIT_FN func,
1485                                     void *param, void **context )
1486 {
1487     DWORD ret = RtlRunOnceBeginInitialize( once, 0, context );
1488
1489     if (ret != STATUS_PENDING) return ret;
1490
1491     if (!func( once, param, context ))
1492     {
1493         RtlRunOnceComplete( once, RTL_RUN_ONCE_INIT_FAILED, NULL );
1494         return STATUS_UNSUCCESSFUL;
1495     }
1496
1497     return RtlRunOnceComplete( once, 0, context ? *context : NULL );
1498 }
1499
1500
1501 /* SRW locks implementation
1502  *
1503  * The memory layout used by the lock is:
1504  *
1505  * 32 31            16               0
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]:
1513  *
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
1517  * anymore!
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.
1521  *
1522  * the following states are invalid and will never occur:
1523  * [0, >=1,   0], [1,   0, >=0]
1524  *
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.
1537  */
1538
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
1544
1545 #ifdef WORDS_BIGENDIAN
1546 #define srwlock_key_exclusive(lock)   (&lock->Ptr)
1547 #define srwlock_key_shared(lock)      ((void *)((char *)&lock->Ptr + 2))
1548 #else
1549 #define srwlock_key_exclusive(lock)   ((void *)((char *)&lock->Ptr + 2))
1550 #define srwlock_key_shared(lock)      (&lock->Ptr)
1551 #endif
1552
1553 static inline void srwlock_check_invalid( unsigned int val )
1554 {
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);
1559 }
1560
1561 static inline unsigned int srwlock_lock_exclusive( unsigned int *dest, int incr )
1562 {
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)
1569     {
1570         tmp = val + incr;
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)
1575             break;
1576     }
1577     return val;
1578 }
1579
1580 static inline unsigned int srwlock_unlock_exclusive( unsigned int *dest, int incr )
1581 {
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
1586      * remain). */
1587     for (val = *dest;; val = tmp)
1588     {
1589         tmp = val + incr;
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)
1594             break;
1595     }
1596     return val;
1597 }
1598
1599 static inline void srwlock_leave_exclusive( RTL_SRWLOCK *lock, unsigned int val )
1600 {
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 );
1606     else
1607     {
1608         val &= SRWLOCK_MASK_SHARED_QUEUE; /* remove SRWLOCK_MASK_IN_EXCLUSIVE */
1609         while (val--)
1610             NtReleaseKeyedEvent( keyed_event, srwlock_key_shared(lock), FALSE, NULL );
1611     }
1612 }
1613
1614 static inline void srwlock_leave_shared( RTL_SRWLOCK *lock, unsigned int val )
1615 {
1616     /* Wake up one exclusive thread as soon as the last shared access thread
1617      * has left. */
1618     if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_SHARED_QUEUE))
1619         NtReleaseKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
1620 }
1621
1622 /***********************************************************************
1623  *              RtlInitializeSRWLock (NTDLL.@)
1624  *
1625  * NOTES
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.
1631  */
1632 void WINAPI RtlInitializeSRWLock( RTL_SRWLOCK *lock )
1633 {
1634     lock->Ptr = NULL;
1635 }
1636
1637 /***********************************************************************
1638  *              RtlAcquireSRWLockExclusive (NTDLL.@)
1639  *
1640  * NOTES
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.
1644  */
1645 void WINAPI RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
1646 {
1647     if (srwlock_lock_exclusive( (unsigned int *)&lock->Ptr, SRWLOCK_RES_EXCLUSIVE ))
1648         NtWaitForKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
1649 }
1650
1651 /***********************************************************************
1652  *              RtlAcquireSRWLockShared (NTDLL.@)
1653  *
1654  * NOTES
1655  *   Do not call this function recursively - it will only succeed when
1656  *   there are no threads waiting for an exclusive lock!
1657  */
1658 void WINAPI RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
1659 {
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)
1664     {
1665         if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_IN_EXCLUSIVE))
1666             tmp = val + SRWLOCK_RES_EXCLUSIVE;
1667         else
1668             tmp = val + SRWLOCK_RES_SHARED;
1669         if ((tmp = interlocked_cmpxchg( (int *)&lock->Ptr, tmp, val )) == val)
1670             break;
1671     }
1672
1673     /* Drop exclusive access again and instead requeue for shared access. */
1674     if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_IN_EXCLUSIVE))
1675     {
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 );
1680     }
1681
1682     if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
1683         NtWaitForKeyedEvent( keyed_event, srwlock_key_shared(lock), FALSE, NULL );
1684 }
1685
1686 /***********************************************************************
1687  *              RtlReleaseSRWLockExclusive (NTDLL.@)
1688  */
1689 void WINAPI RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
1690 {
1691     srwlock_leave_exclusive( lock, srwlock_unlock_exclusive( (unsigned int *)&lock->Ptr,
1692                              - SRWLOCK_RES_EXCLUSIVE ) - SRWLOCK_RES_EXCLUSIVE );
1693 }
1694
1695 /***********************************************************************
1696  *              RtlReleaseSRWLockShared (NTDLL.@)
1697  */
1698 void WINAPI RtlReleaseSRWLockShared( RTL_SRWLOCK *lock )
1699 {
1700     srwlock_leave_shared( lock, srwlock_lock_exclusive( (unsigned int *)&lock->Ptr,
1701                           - SRWLOCK_RES_SHARED ) - SRWLOCK_RES_SHARED );
1702 }
1703
1704 /***********************************************************************
1705  *              RtlTryAcquireSRWLockExclusive (NTDLL.@)
1706  *
1707  * NOTES
1708  *  Similar to AcquireSRWLockExclusive recusive calls are not allowed
1709  *  and will fail with return value FALSE.
1710  */
1711 BOOLEAN WINAPI RtlTryAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
1712 {
1713     return interlocked_cmpxchg( (int *)&lock->Ptr, SRWLOCK_MASK_IN_EXCLUSIVE |
1714                                 SRWLOCK_RES_EXCLUSIVE, 0 ) == 0;
1715 }
1716
1717 /***********************************************************************
1718  *              RtlTryAcquireSRWLockShared (NTDLL.@)
1719  */
1720 BOOLEAN WINAPI RtlTryAcquireSRWLockShared( RTL_SRWLOCK *lock )
1721 {
1722     unsigned int val, tmp;
1723     for (val = *(unsigned int *)&lock->Ptr;; val = tmp)
1724     {
1725         if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
1726             return FALSE;
1727         if ((tmp = interlocked_cmpxchg( (int *)&lock->Ptr, val + SRWLOCK_RES_SHARED, val )) == val)
1728             break;
1729     }
1730     return TRUE;
1731 }
1732
1733 /***********************************************************************
1734  *           RtlInitializeConditionVariable   (NTDLL.@)
1735  *
1736  * Initializes the condition variable with NULL.
1737  *
1738  * PARAMS
1739  *  variable [O] condition variable
1740  *
1741  * RETURNS
1742  *  Nothing.
1743  */
1744 void WINAPI RtlInitializeConditionVariable( RTL_CONDITION_VARIABLE *variable )
1745 {
1746     variable->Ptr = NULL;
1747 }
1748
1749 /***********************************************************************
1750  *           RtlWakeConditionVariable   (NTDLL.@)
1751  *
1752  * Wakes up one thread waiting on the condition variable.
1753  *
1754  * PARAMS
1755  *  variable [I/O] condition variable to wake up.
1756  *
1757  * RETURNS
1758  *  Nothing.
1759  *
1760  * NOTES
1761  *  The calling thread does not have to own any lock in order to call
1762  *  this function.
1763  */
1764 void WINAPI RtlWakeConditionVariable( RTL_CONDITION_VARIABLE *variable )
1765 {
1766     if (interlocked_dec_if_nonzero( (int *)&variable->Ptr ))
1767         NtReleaseKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1768 }
1769
1770 /***********************************************************************
1771  *           RtlWakeAllConditionVariable   (NTDLL.@)
1772  *
1773  * See WakeConditionVariable, wakes up all waiting threads.
1774  */
1775 void WINAPI RtlWakeAllConditionVariable( RTL_CONDITION_VARIABLE *variable )
1776 {
1777     int val = interlocked_xchg( (int *)&variable->Ptr, 0 );
1778     while (val-- > 0)
1779         NtReleaseKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1780 }
1781
1782 /***********************************************************************
1783  *           RtlSleepConditionVariableCS   (NTDLL.@)
1784  *
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.
1788  *
1789  * PARAMS
1790  *  variable  [I/O] condition variable
1791  *  crit      [I/O] critical section to leave temporarily
1792  *  timeout   [I]   timeout
1793  *
1794  * RETURNS
1795  *  see NtWaitForKeyedEvent for all possible return values.
1796  */
1797 NTSTATUS WINAPI RtlSleepConditionVariableCS( RTL_CONDITION_VARIABLE *variable, RTL_CRITICAL_SECTION *crit,
1798                                              const LARGE_INTEGER *timeout )
1799 {
1800     NTSTATUS status;
1801     interlocked_xchg_add( (int *)&variable->Ptr, 1 );
1802     RtlLeaveCriticalSection( crit );
1803
1804     status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, timeout );
1805     if (status != STATUS_SUCCESS)
1806     {
1807         if (!interlocked_dec_if_nonzero( (int *)&variable->Ptr ))
1808             status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1809     }
1810
1811     RtlEnterCriticalSection( crit );
1812     return status;
1813 }
1814
1815 /***********************************************************************
1816  *           RtlSleepConditionVariableSRW   (NTDLL.@)
1817  *
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.
1821  *
1822  * PARAMS
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)
1827  *
1828  * RETURNS
1829  *  see NtWaitForKeyedEvent for all possible return values.
1830  *
1831  * NOTES
1832  *  the behaviour is undefined if the thread doesn't own the lock.
1833  */
1834 NTSTATUS WINAPI RtlSleepConditionVariableSRW( RTL_CONDITION_VARIABLE *variable, RTL_SRWLOCK *lock,
1835                                               const LARGE_INTEGER *timeout, ULONG flags )
1836 {
1837     NTSTATUS status;
1838     interlocked_xchg_add( (int *)&variable->Ptr, 1 );
1839
1840     if (flags & RTL_CONDITION_VARIABLE_LOCKMODE_SHARED)
1841         RtlReleaseSRWLockShared( lock );
1842     else
1843         RtlReleaseSRWLockExclusive( lock );
1844
1845     status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, timeout );
1846     if (status != STATUS_SUCCESS)
1847     {
1848         if (!interlocked_dec_if_nonzero( (int *)&variable->Ptr ))
1849             status = NtWaitForKeyedEvent( keyed_event, &variable->Ptr, FALSE, NULL );
1850     }
1851
1852     if (flags & RTL_CONDITION_VARIABLE_LOCKMODE_SHARED)
1853         RtlAcquireSRWLockShared( lock );
1854     else
1855         RtlAcquireSRWLockExclusive( lock );
1856     return status;
1857 }