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