dlls/ntdll/sync.c

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