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
  26 #include <assert.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #ifdef HAVE_SYS_TIME_H
  30 # include <sys/time.h>
  31 #endif
  32 #ifdef HAVE_POLL_H
  33 #include <poll.h>
  34 #endif
  35 #ifdef HAVE_SYS_POLL_H
  36 # include <sys/poll.h>
  37 #endif
  38 #ifdef HAVE_UNISTD_H
  39 # include <unistd.h>
  40 #endif
  41 #ifdef HAVE_SCHED_H
  42 # include <sched.h>
  43 #endif
  44 #include <string.h>
  45 #include <stdarg.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <time.h>
  49
  50 #define NONAMELESSUNION
  51 #define NONAMELESSSTRUCT
  52
  53 #include "ntstatus.h"
  54 #define WIN32_NO_STATUS
  55 #include "windef.h"
  56 #include "thread.h"
  57 #include "wine/server.h"
  58 #include "wine/debug.h"
  59 #include "ntdll_misc.h"
  60
  61 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  62
  63 /* creates a struct security_descriptor and contained information in one contiguous piece of memory */
  64 NTSTATUS NTDLL_create_struct_sd(PSECURITY_DESCRIPTOR nt_sd, struct security_descriptor **server_sd,
  65                                 data_size_t *server_sd_len)
  66 {
  67     unsigned int len;
  68     PSID owner, group;
  69     ACL *dacl, *sacl;
  70     BOOLEAN owner_present, group_present, dacl_present, sacl_present;
  71     BOOLEAN defaulted;
  72     NTSTATUS status;
  73     unsigned char *ptr;
  74
  75     if (!nt_sd)
  76     {
  77         *server_sd = NULL;
  78         *server_sd_len = 0;
  79         return STATUS_SUCCESS;
  80     }
  81
  82     len = sizeof(struct security_descriptor);
  83
  84     status = RtlGetOwnerSecurityDescriptor(nt_sd, &owner, &owner_present);
  85     if (status != STATUS_SUCCESS) return status;
  86     status = RtlGetGroupSecurityDescriptor(nt_sd, &group, &group_present);
  87     if (status != STATUS_SUCCESS) return status;
  88     status = RtlGetSaclSecurityDescriptor(nt_sd, &sacl_present, &sacl, &defaulted);
  89     if (status != STATUS_SUCCESS) return status;
  90     status = RtlGetDaclSecurityDescriptor(nt_sd, &dacl_present, &dacl, &defaulted);
  91     if (status != STATUS_SUCCESS) return status;
  92
  93     if (owner_present)
  94         len += RtlLengthSid(owner);
  95     if (group_present)
  96         len += RtlLengthSid(group);
  97     if (sacl_present && sacl)
  98         len += sacl->AclSize;
  99     if (dacl_present && dacl)
 100         len += dacl->AclSize;
 101
 102     /* fix alignment for the Unicode name that follows the structure */
 103     len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
 104     *server_sd = RtlAllocateHeap(GetProcessHeap(), 0, len);
 105     if (!*server_sd) return STATUS_NO_MEMORY;
 106
 107     (*server_sd)->control = ((SECURITY_DESCRIPTOR *)nt_sd)->Control & ~SE_SELF_RELATIVE;
 108     (*server_sd)->owner_len = owner_present ? RtlLengthSid(owner) : 0;
 109     (*server_sd)->group_len = group_present ? RtlLengthSid(group) : 0;
 110     (*server_sd)->sacl_len = (sacl_present && sacl) ? sacl->AclSize : 0;
 111     (*server_sd)->dacl_len = (dacl_present && dacl) ? dacl->AclSize : 0;
 112
 113     ptr = (unsigned char *)(*server_sd + 1);
 114     memcpy(ptr, owner, (*server_sd)->owner_len);
 115     ptr += (*server_sd)->owner_len;
 116     memcpy(ptr, group, (*server_sd)->group_len);
 117     ptr += (*server_sd)->group_len;
 118     memcpy(ptr, sacl, (*server_sd)->sacl_len);
 119     ptr += (*server_sd)->sacl_len;
 120     memcpy(ptr, dacl, (*server_sd)->dacl_len);
 121
 122     *server_sd_len = len;
 123
 124     return STATUS_SUCCESS;
 125 }
 126
 127 /* frees a struct security_descriptor allocated by NTDLL_create_struct_sd */
 128 void NTDLL_free_struct_sd(struct security_descriptor *server_sd)
 129 {
 130     RtlFreeHeap(GetProcessHeap(), 0, server_sd);
 131 }
 132
 133 /*
 134  *      Semaphores
 135  */
 136
 137 /******************************************************************************
 138  *  NtCreateSemaphore (NTDLL.@)
 139  */
 140 NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
 141                                    IN ACCESS_MASK access,
 142                                    IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
 143                                    IN LONG InitialCount,
 144                                    IN LONG MaximumCount )
 145 {
 146     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 147     NTSTATUS ret;
 148     struct object_attributes objattr;
 149     struct security_descriptor *sd = NULL;
 150
 151     if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount)
 152         return STATUS_INVALID_PARAMETER;
 153     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 154
 155     objattr.rootdir =  attr ? attr->RootDirectory : 0;
 156     objattr.sd_len = 0;
 157     if (attr)
 158     {
 159         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 160         if (ret != STATUS_SUCCESS) return ret;
 161     }
 162
 163     SERVER_START_REQ( create_semaphore )
 164     {
 165         req->access  = access;
 166         req->attributes = (attr) ? attr->Attributes : 0;
 167         req->initial = InitialCount;
 168         req->max     = MaximumCount;
 169         wine_server_add_data( req, &objattr, sizeof(objattr) );
 170         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 171         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 172         ret = wine_server_call( req );
 173         *SemaphoreHandle = reply->handle;
 174     }
 175     SERVER_END_REQ;
 176
 177     NTDLL_free_struct_sd( sd );
 178
 179     return ret;
 180 }
 181
 182 /******************************************************************************
 183  *  NtOpenSemaphore (NTDLL.@)
 184  */
 185 NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
 186                                  IN ACCESS_MASK access,
 187                                  IN const OBJECT_ATTRIBUTES *attr )
 188 {
 189     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 190     NTSTATUS ret;
 191
 192     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 193
 194     SERVER_START_REQ( open_semaphore )
 195     {
 196         req->access  = access;
 197         req->attributes = (attr) ? attr->Attributes : 0;
 198         req->rootdir = attr ? attr->RootDirectory : 0;
 199         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 200         ret = wine_server_call( req );
 201         *SemaphoreHandle = reply->handle;
 202     }
 203     SERVER_END_REQ;
 204     return ret;
 205 }
 206
 207 /******************************************************************************
 208  *  NtQuerySemaphore (NTDLL.@)
 209  */
 210 NTSTATUS WINAPI NtQuerySemaphore(
 211         HANDLE SemaphoreHandle,
 212         SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
 213         PVOID SemaphoreInformation,
 214         ULONG Length,
 215         PULONG ReturnLength)
 216 {
 217         FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
 218         SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
 219         return STATUS_SUCCESS;
 220 }
 221
 222 /******************************************************************************
 223  *  NtReleaseSemaphore (NTDLL.@)
 224  */
 225 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
 226 {
 227     NTSTATUS ret;
 228     SERVER_START_REQ( release_semaphore )
 229     {
 230         req->handle = handle;
 231         req->count  = count;
 232         if (!(ret = wine_server_call( req )))
 233         {
 234             if (previous) *previous = reply->prev_count;
 235         }
 236     }
 237     SERVER_END_REQ;
 238     return ret;
 239 }
 240
 241 /*
 242  *      Events
 243  */
 244
 245 /**************************************************************************
 246  * NtCreateEvent (NTDLL.@)
 247  * ZwCreateEvent (NTDLL.@)
 248  */
 249 NTSTATUS WINAPI NtCreateEvent(
 250         OUT PHANDLE EventHandle,
 251         IN ACCESS_MASK DesiredAccess,
 252         IN const OBJECT_ATTRIBUTES *attr,
 253         IN BOOLEAN ManualReset,
 254         IN BOOLEAN InitialState)
 255 {
 256     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 257     NTSTATUS ret;
 258     struct security_descriptor *sd = NULL;
 259     struct object_attributes objattr;
 260
 261     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 262
 263     objattr.rootdir = attr ? attr->RootDirectory : 0;
 264     objattr.sd_len = 0;
 265     if (attr)
 266     {
 267         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 268         if (ret != STATUS_SUCCESS) return ret;
 269     }
 270
 271     SERVER_START_REQ( create_event )
 272     {
 273         req->access = DesiredAccess;
 274         req->attributes = (attr) ? attr->Attributes : 0;
 275         req->manual_reset = ManualReset;
 276         req->initial_state = InitialState;
 277         wine_server_add_data( req, &objattr, sizeof(objattr) );
 278         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 279         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 280         ret = wine_server_call( req );
 281         *EventHandle = reply->handle;
 282     }
 283     SERVER_END_REQ;
 284
 285     NTDLL_free_struct_sd( sd );
 286
 287     return ret;
 288 }
 289
 290 /******************************************************************************
 291  *  NtOpenEvent (NTDLL.@)
 292  *  ZwOpenEvent (NTDLL.@)
 293  */
 294 NTSTATUS WINAPI NtOpenEvent(
 295         OUT PHANDLE EventHandle,
 296         IN ACCESS_MASK DesiredAccess,
 297         IN const OBJECT_ATTRIBUTES *attr )
 298 {
 299     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 300     NTSTATUS ret;
 301
 302     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 303
 304     SERVER_START_REQ( open_event )
 305     {
 306         req->access  = DesiredAccess;
 307         req->attributes = (attr) ? attr->Attributes : 0;
 308         req->rootdir = attr ? attr->RootDirectory : 0;
 309         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 310         ret = wine_server_call( req );
 311         *EventHandle = reply->handle;
 312     }
 313     SERVER_END_REQ;
 314     return ret;
 315 }
 316
 317
 318 /******************************************************************************
 319  *  NtSetEvent (NTDLL.@)
 320  *  ZwSetEvent (NTDLL.@)
 321  */
 322 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 323 {
 324     NTSTATUS ret;
 325
 326     /* FIXME: set NumberOfThreadsReleased */
 327
 328     SERVER_START_REQ( event_op )
 329     {
 330         req->handle = handle;
 331         req->op     = SET_EVENT;
 332         ret = wine_server_call( req );
 333     }
 334     SERVER_END_REQ;
 335     return ret;
 336 }
 337
 338 /******************************************************************************
 339  *  NtResetEvent (NTDLL.@)
 340  */
 341 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 342 {
 343     NTSTATUS ret;
 344
 345     /* resetting an event can't release any thread... */
 346     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
 347
 348     SERVER_START_REQ( event_op )
 349     {
 350         req->handle = handle;
 351         req->op     = RESET_EVENT;
 352         ret = wine_server_call( req );
 353     }
 354     SERVER_END_REQ;
 355     return ret;
 356 }
 357
 358 /******************************************************************************
 359  *  NtClearEvent (NTDLL.@)
 360  *
 361  * FIXME
 362  *   same as NtResetEvent ???
 363  */
 364 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 365 {
 366     return NtResetEvent( handle, NULL );
 367 }
 368
 369 /******************************************************************************
 370  *  NtPulseEvent (NTDLL.@)
 371  *
 372  * FIXME
 373  *   PulseCount
 374  */
 375 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 376 {
 377     NTSTATUS ret;
 378
 379     if (PulseCount)
 380       FIXME("(%p,%d)\n", handle, *PulseCount);
 381
 382     SERVER_START_REQ( event_op )
 383     {
 384         req->handle = handle;
 385         req->op     = PULSE_EVENT;
 386         ret = wine_server_call( req );
 387     }
 388     SERVER_END_REQ;
 389     return ret;
 390 }
 391
 392 /******************************************************************************
 393  *  NtQueryEvent (NTDLL.@)
 394  */
 395 NTSTATUS WINAPI NtQueryEvent (
 396         IN  HANDLE EventHandle,
 397         IN  EVENT_INFORMATION_CLASS EventInformationClass,
 398         OUT PVOID EventInformation,
 399         IN  ULONG EventInformationLength,
 400         OUT PULONG  ReturnLength)
 401 {
 402         FIXME("(%p)\n", EventHandle);
 403         return STATUS_SUCCESS;
 404 }
 405
 406 /*
 407  *      Mutants (known as Mutexes in Kernel32)
 408  */
 409
 410 /******************************************************************************
 411  *              NtCreateMutant                          [NTDLL.@]
 412  *              ZwCreateMutant                          [NTDLL.@]
 413  */
 414 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
 415                                IN ACCESS_MASK access,
 416                                IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
 417                                IN BOOLEAN InitialOwner)
 418 {
 419     NTSTATUS status;
 420     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 421     struct security_descriptor *sd = NULL;
 422     struct object_attributes objattr;
 423
 424     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 425
 426     objattr.rootdir = attr ? attr->RootDirectory : 0;
 427     objattr.sd_len = 0;
 428     if (attr)
 429     {
 430         status = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 431         if (status != STATUS_SUCCESS) return status;
 432     }
 433
 434     SERVER_START_REQ( create_mutex )
 435     {
 436         req->access  = access;
 437         req->attributes = (attr) ? attr->Attributes : 0;
 438         req->owned   = InitialOwner;
 439         wine_server_add_data( req, &objattr, sizeof(objattr) );
 440         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 441         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 442         status = wine_server_call( req );
 443         *MutantHandle = reply->handle;
 444     }
 445     SERVER_END_REQ;
 446
 447     NTDLL_free_struct_sd( sd );
 448
 449     return status;
 450 }
 451
 452 /**************************************************************************
 453  *              NtOpenMutant                            [NTDLL.@]
 454  *              ZwOpenMutant                            [NTDLL.@]
 455  */
 456 NTSTATUS WINAPI NtOpenMutant(OUT HANDLE* MutantHandle,
 457                              IN ACCESS_MASK access,
 458                              IN const OBJECT_ATTRIBUTES* attr )
 459 {
 460     NTSTATUS    status;
 461     DWORD       len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 462
 463     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 464
 465     SERVER_START_REQ( open_mutex )
 466     {
 467         req->access  = access;
 468         req->attributes = (attr) ? attr->Attributes : 0;
 469         req->rootdir = attr ? attr->RootDirectory : 0;
 470         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 471         status = wine_server_call( req );
 472         *MutantHandle = reply->handle;
 473     }
 474     SERVER_END_REQ;
 475     return status;
 476 }
 477
 478 /**************************************************************************
 479  *              NtReleaseMutant                         [NTDLL.@]
 480  *              ZwReleaseMutant                         [NTDLL.@]
 481  */
 482 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
 483 {
 484     NTSTATUS    status;
 485
 486     SERVER_START_REQ( release_mutex )
 487     {
 488         req->handle = handle;
 489         status = wine_server_call( req );
 490         if (prev_count) *prev_count = reply->prev_count;
 491     }
 492     SERVER_END_REQ;
 493     return status;
 494 }
 495
 496 /******************************************************************
 497  *              NtQueryMutant                   [NTDLL.@]
 498  *              ZwQueryMutant                   [NTDLL.@]
 499  */
 500 NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle,
 501                               IN MUTANT_INFORMATION_CLASS MutantInformationClass,
 502                               OUT PVOID MutantInformation,
 503                               IN ULONG MutantInformationLength,
 504                               OUT PULONG ResultLength OPTIONAL )
 505 {
 506     FIXME("(%p %u %p %u %p): stub!\n",
 507           handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
 508     return STATUS_NOT_IMPLEMENTED;
 509 }
 510
 511 /*
 512  *      Timers
 513  */
 514
 515 /**************************************************************************
 516  *              NtCreateTimer                           [NTDLL.@]
 517  *              ZwCreateTimer                           [NTDLL.@]
 518  */
 519 NTSTATUS WINAPI NtCreateTimer(OUT HANDLE *handle,
 520                               IN ACCESS_MASK access,
 521                               IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
 522                               IN TIMER_TYPE timer_type)
 523 {
 524     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 525     NTSTATUS    status;
 526
 527     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 528
 529     if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
 530         return STATUS_INVALID_PARAMETER;
 531
 532     SERVER_START_REQ( create_timer )
 533     {
 534         req->access  = access;
 535         req->attributes = (attr) ? attr->Attributes : 0;
 536         req->rootdir = attr ? attr->RootDirectory : 0;
 537         req->manual  = (timer_type == NotificationTimer) ? TRUE : FALSE;
 538         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 539         status = wine_server_call( req );
 540         *handle = reply->handle;
 541     }
 542     SERVER_END_REQ;
 543     return status;
 544
 545 }
 546
 547 /**************************************************************************
 548  *              NtOpenTimer                             [NTDLL.@]
 549  *              ZwOpenTimer                             [NTDLL.@]
 550  */
 551 NTSTATUS WINAPI NtOpenTimer(OUT PHANDLE handle,
 552                             IN ACCESS_MASK access,
 553                             IN const OBJECT_ATTRIBUTES* attr )
 554 {
 555     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 556     NTSTATUS    status;
 557
 558     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 559
 560     SERVER_START_REQ( open_timer )
 561     {
 562         req->access  = access;
 563         req->attributes = (attr) ? attr->Attributes : 0;
 564         req->rootdir = attr ? attr->RootDirectory : 0;
 565         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 566         status = wine_server_call( req );
 567         *handle = reply->handle;
 568     }
 569     SERVER_END_REQ;
 570     return status;
 571 }
 572
 573 /**************************************************************************
 574  *              NtSetTimer                              [NTDLL.@]
 575  *              ZwSetTimer                              [NTDLL.@]
 576  */
 577 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
 578                            IN const LARGE_INTEGER* when,
 579                            IN PTIMER_APC_ROUTINE callback,
 580                            IN PVOID callback_arg,
 581                            IN BOOLEAN resume,
 582                            IN ULONG period OPTIONAL,
 583                            OUT PBOOLEAN state OPTIONAL)
 584 {
 585     NTSTATUS    status = STATUS_SUCCESS;
 586
 587     TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
 588           handle, when, callback, callback_arg, resume, period, state);
 589
 590     SERVER_START_REQ( set_timer )
 591     {
 592         req->handle   = handle;
 593         req->period   = period;
 594         req->expire   = when->QuadPart;
 595         req->callback = callback;
 596         req->arg      = callback_arg;
 597         status = wine_server_call( req );
 598         if (state) *state = reply->signaled;
 599     }
 600     SERVER_END_REQ;
 601
 602     /* set error but can still succeed */
 603     if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
 604     return status;
 605 }
 606
 607 /**************************************************************************
 608  *              NtCancelTimer                           [NTDLL.@]
 609  *              ZwCancelTimer                           [NTDLL.@]
 610  */
 611 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
 612 {
 613     NTSTATUS    status;
 614
 615     SERVER_START_REQ( cancel_timer )
 616     {
 617         req->handle = handle;
 618         status = wine_server_call( req );
 619         if (state) *state = reply->signaled;
 620     }
 621     SERVER_END_REQ;
 622     return status;
 623 }
 624
 625 /******************************************************************************
 626  *  NtQueryTimer (NTDLL.@)
 627  *
 628  * Retrieves information about a timer.
 629  *
 630  * PARAMS
 631  *  TimerHandle           [I] The timer to retrieve information about.
 632  *  TimerInformationClass [I] The type of information to retrieve.
 633  *  TimerInformation      [O] Pointer to buffer to store information in.
 634  *  Length                [I] The length of the buffer pointed to by TimerInformation.
 635  *  ReturnLength          [O] Optional. The size of buffer actually used.
 636  *
 637  * RETURNS
 638  *  Success: STATUS_SUCCESS
 639  *  Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
 640  *           size for the class specified.
 641  *           STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
 642  *           STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
 643  *           to the timer.
 644  */
 645 NTSTATUS WINAPI NtQueryTimer(
 646     HANDLE TimerHandle,
 647     TIMER_INFORMATION_CLASS TimerInformationClass,
 648     PVOID TimerInformation,
 649     ULONG Length,
 650     PULONG ReturnLength)
 651 {
 652     TIMER_BASIC_INFORMATION * basic_info = (TIMER_BASIC_INFORMATION *)TimerInformation;
 653     NTSTATUS status;
 654     LARGE_INTEGER now;
 655
 656     TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
 657        TimerInformation, Length, ReturnLength);
 658
 659     switch (TimerInformationClass)
 660     {
 661     case TimerBasicInformation:
 662         if (Length < sizeof(TIMER_BASIC_INFORMATION))
 663             return STATUS_INFO_LENGTH_MISMATCH;
 664
 665         SERVER_START_REQ(get_timer_info)
 666         {
 667             req->handle = TimerHandle;
 668             status = wine_server_call(req);
 669
 670             /* convert server time to absolute NTDLL time */
 671             basic_info->RemainingTime.QuadPart = reply->when;
 672             basic_info->TimerState = reply->signaled;
 673         }
 674         SERVER_END_REQ;
 675
 676         /* convert from absolute into relative time */
 677         NtQuerySystemTime(&now);
 678         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
 679             basic_info->RemainingTime.QuadPart = 0;
 680         else
 681             basic_info->RemainingTime.QuadPart -= now.QuadPart;
 682
 683         if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
 684
 685         return status;
 686     }
 687
 688     FIXME("Unhandled class %d\n", TimerInformationClass);
 689     return STATUS_INVALID_INFO_CLASS;
 690 }
 691
 692
 693 /******************************************************************************
 694  * NtQueryTimerResolution [NTDLL.@]
 695  */
 696 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
 697                                        OUT ULONG* max_resolution,
 698                                        OUT ULONG* current_resolution)
 699 {
 700     FIXME("(%p,%p,%p), stub!\n",
 701           min_resolution, max_resolution, current_resolution);
 702
 703     return STATUS_NOT_IMPLEMENTED;
 704 }
 705
 706 /******************************************************************************
 707  * NtSetTimerResolution [NTDLL.@]
 708  */
 709 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
 710                                      IN BOOLEAN set_resolution,
 711                                      OUT ULONG* current_resolution )
 712 {
 713     FIXME("(%u,%u,%p), stub!\n",
 714           resolution, set_resolution, current_resolution);
 715
 716     return STATUS_NOT_IMPLEMENTED;
 717 }
 718
 719
 720 /***********************************************************************
 721  *              wait_reply
 722  *
 723  * Wait for a reply on the waiting pipe of the current thread.
 724  */
 725 static int wait_reply( void *cookie )
 726 {
 727     int signaled;
 728     struct wake_up_reply reply;
 729     for (;;)
 730     {
 731         int ret;
 732         ret = read( ntdll_get_thread_data()->wait_fd[0], &reply, sizeof(reply) );
 733         if (ret == sizeof(reply))
 734         {
 735             if (!reply.cookie) break;  /* thread got killed */
 736             if (reply.cookie == cookie) return reply.signaled;
 737             /* we stole another reply, wait for the real one */
 738             signaled = wait_reply( cookie );
 739             /* and now put the wrong one back in the pipe */
 740             for (;;)
 741             {
 742                 ret = write( ntdll_get_thread_data()->wait_fd[1], &reply, sizeof(reply) );
 743                 if (ret == sizeof(reply)) break;
 744                 if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
 745                 if (errno == EINTR) continue;
 746                 server_protocol_perror("wakeup write");
 747             }
 748             return signaled;
 749         }
 750         if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
 751         if (errno == EINTR) continue;
 752         server_protocol_perror("wakeup read");
 753     }
 754     /* the server closed the connection; time to die... */
 755     server_abort_thread(0);
 756 }
 757
 758
 759 /***********************************************************************
 760  *              invoke_apc
 761  *
 762  * Invoke a single APC. Return TRUE if a user APC has been run.
 763  */
 764 static BOOL invoke_apc( const apc_call_t *call, apc_result_t *result )
 765 {
 766     BOOL user_apc = FALSE;
 767
 768     memset( result, 0, sizeof(*result) );
 769
 770     switch (call->type)
 771     {
 772     case APC_NONE:
 773         break;
 774     case APC_USER:
 775         call->user.func( call->user.args[0], call->user.args[1], call->user.args[2] );
 776         user_apc = TRUE;
 777         break;
 778     case APC_TIMER:
 779         call->timer.func( call->timer.arg, (DWORD)call->timer.time, (DWORD)(call->timer.time >> 32) );
 780         user_apc = TRUE;
 781         break;
 782     case APC_ASYNC_IO:
 783         result->type = call->type;
 784         result->async_io.status = call->async_io.func( call->async_io.user,
 785                                                        call->async_io.sb,
 786                                                        call->async_io.status );
 787         break;
 788     case APC_VIRTUAL_ALLOC:
 789         result->type = call->type;
 790         result->virtual_alloc.addr = call->virtual_alloc.addr;
 791         result->virtual_alloc.size = call->virtual_alloc.size;
 792         result->virtual_alloc.status = NtAllocateVirtualMemory( NtCurrentProcess(),
 793                                                                 &result->virtual_alloc.addr,
 794                                                                 call->virtual_alloc.zero_bits,
 795                                                                 &result->virtual_alloc.size,
 796                                                                 call->virtual_alloc.op_type,
 797                                                                 call->virtual_alloc.prot );
 798         break;
 799     case APC_VIRTUAL_FREE:
 800         result->type = call->type;
 801         result->virtual_free.addr = call->virtual_free.addr;
 802         result->virtual_free.size = call->virtual_free.size;
 803         result->virtual_free.status = NtFreeVirtualMemory( NtCurrentProcess(),
 804                                                            &result->virtual_free.addr,
 805                                                            &result->virtual_free.size,
 806                                                            call->virtual_free.op_type );
 807         break;
 808     case APC_VIRTUAL_QUERY:
 809     {
 810         MEMORY_BASIC_INFORMATION info;
 811         result->type = call->type;
 812         result->virtual_query.status = NtQueryVirtualMemory( NtCurrentProcess(),
 813                                                              call->virtual_query.addr,
 814                                                              MemoryBasicInformation, &info,
 815                                                              sizeof(info), NULL );
 816         if (result->virtual_query.status == STATUS_SUCCESS)
 817         {
 818             result->virtual_query.base       = info.BaseAddress;
 819             result->virtual_query.alloc_base = info.AllocationBase;
 820             result->virtual_query.size       = info.RegionSize;
 821             result->virtual_query.state      = info.State;
 822             result->virtual_query.prot       = info.Protect;
 823             result->virtual_query.alloc_prot = info.AllocationProtect;
 824             result->virtual_query.alloc_type = info.Type;
 825         }
 826         break;
 827     }
 828     case APC_VIRTUAL_PROTECT:
 829         result->type = call->type;
 830         result->virtual_protect.addr = call->virtual_protect.addr;
 831         result->virtual_protect.size = call->virtual_protect.size;
 832         result->virtual_protect.status = NtProtectVirtualMemory( NtCurrentProcess(),
 833                                                                  &result->virtual_protect.addr,
 834                                                                  &result->virtual_protect.size,
 835                                                                  call->virtual_protect.prot,
 836                                                                  &result->virtual_protect.prot );
 837         break;
 838     case APC_VIRTUAL_FLUSH:
 839         result->type = call->type;
 840         result->virtual_flush.addr = call->virtual_flush.addr;
 841         result->virtual_flush.size = call->virtual_flush.size;
 842         result->virtual_flush.status = NtFlushVirtualMemory( NtCurrentProcess(),
 843                                                              &result->virtual_flush.addr,
 844                                                              &result->virtual_flush.size, 0 );
 845         break;
 846     case APC_VIRTUAL_LOCK:
 847         result->type = call->type;
 848         result->virtual_lock.addr = call->virtual_lock.addr;
 849         result->virtual_lock.size = call->virtual_lock.size;
 850         result->virtual_lock.status = NtLockVirtualMemory( NtCurrentProcess(),
 851                                                            &result->virtual_lock.addr,
 852                                                            &result->virtual_lock.size, 0 );
 853         break;
 854     case APC_VIRTUAL_UNLOCK:
 855         result->type = call->type;
 856         result->virtual_unlock.addr = call->virtual_unlock.addr;
 857         result->virtual_unlock.size = call->virtual_unlock.size;
 858         result->virtual_unlock.status = NtUnlockVirtualMemory( NtCurrentProcess(),
 859                                                                &result->virtual_unlock.addr,
 860                                                                &result->virtual_unlock.size, 0 );
 861         break;
 862     case APC_MAP_VIEW:
 863     {
 864         LARGE_INTEGER offset;
 865         result->type = call->type;
 866         result->map_view.addr   = call->map_view.addr;
 867         result->map_view.size   = call->map_view.size;
 868         offset.QuadPart         = call->map_view.offset;
 869         result->map_view.status = NtMapViewOfSection( call->map_view.handle, NtCurrentProcess(),
 870                                                       &result->map_view.addr, call->map_view.zero_bits,
 871                                                       0, &offset, &result->map_view.size, ViewShare,
 872                                                       call->map_view.alloc_type, call->map_view.prot );
 873         NtClose( call->map_view.handle );
 874         break;
 875     }
 876     case APC_UNMAP_VIEW:
 877         result->type = call->type;
 878         result->unmap_view.status = NtUnmapViewOfSection( NtCurrentProcess(), call->unmap_view.addr );
 879         break;
 880     case APC_CREATE_THREAD:
 881     {
 882         CLIENT_ID id;
 883         result->type = call->type;
 884         result->create_thread.status = RtlCreateUserThread( NtCurrentProcess(), NULL,
 885                                                             call->create_thread.suspend, NULL,
 886                                                             call->create_thread.reserve,
 887                                                             call->create_thread.commit,
 888                                                             call->create_thread.func,
 889                                                             call->create_thread.arg,
 890                                                             &result->create_thread.handle, &id );
 891         result->create_thread.tid = HandleToULong(id.UniqueThread);
 892         break;
 893     }
 894     default:
 895         server_protocol_error( "get_apc_request: bad type %d\n", call->type );
 896         break;
 897     }
 898     return user_apc;
 899 }
 900
 901 /***********************************************************************
 902  *           NTDLL_queue_process_apc
 903  */
 904 NTSTATUS NTDLL_queue_process_apc( HANDLE process, const apc_call_t *call, apc_result_t *result )
 905 {
 906     for (;;)
 907     {
 908         NTSTATUS ret;
 909         HANDLE handle = 0;
 910         BOOL self = FALSE;
 911
 912         SERVER_START_REQ( queue_apc )
 913         {
 914             req->process = process;
 915             req->call = *call;
 916             if (!(ret = wine_server_call( req )))
 917             {
 918                 handle = reply->handle;
 919                 self = reply->self;
 920             }
 921         }
 922         SERVER_END_REQ;
 923         if (ret != STATUS_SUCCESS) return ret;
 924
 925         if (self)
 926         {
 927             invoke_apc( call, result );
 928         }
 929         else
 930         {
 931             NtWaitForSingleObject( handle, FALSE, NULL );
 932
 933             SERVER_START_REQ( get_apc_result )
 934             {
 935                 req->handle = handle;
 936                 if (!(ret = wine_server_call( req ))) *result = reply->result;
 937             }
 938             SERVER_END_REQ;
 939
 940             if (!ret && result->type == APC_NONE) continue;  /* APC didn't run, try again */
 941             if (ret) NtClose( handle );
 942         }
 943         return ret;
 944     }
 945 }
 946
 947
 948 /***********************************************************************
 949  *              NTDLL_wait_for_multiple_objects
 950  *
 951  * Implementation of NtWaitForMultipleObjects
 952  */
 953 NTSTATUS NTDLL_wait_for_multiple_objects( UINT count, const HANDLE *handles, UINT flags,
 954                                           const LARGE_INTEGER *timeout, HANDLE signal_object )
 955 {
 956     NTSTATUS ret;
 957     int cookie;
 958     BOOL user_apc = FALSE;
 959     obj_handle_t apc_handle = 0;
 960     apc_call_t call;
 961     apc_result_t result;
 962     timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE;
 963
 964     memset( &result, 0, sizeof(result) );
 965
 966     for (;;)
 967     {
 968         SERVER_START_REQ( select )
 969         {
 970             req->flags    = flags;
 971             req->cookie   = &cookie;
 972             req->signal   = signal_object;
 973             req->prev_apc = apc_handle;
 974             req->timeout  = abs_timeout;
 975             wine_server_add_data( req, &result, sizeof(result) );
 976             wine_server_add_data( req, handles, count * sizeof(HANDLE) );
 977             ret = wine_server_call( req );
 978             abs_timeout = reply->timeout;
 979             apc_handle  = reply->apc_handle;
 980             call        = reply->call;
 981         }
 982         SERVER_END_REQ;
 983         if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
 984         if (ret != STATUS_USER_APC) break;
 985         if (invoke_apc( &call, &result ))
 986         {
 987             /* if we ran a user apc we have to check once more if an object got signaled,
 988              * but we don't want to wait */
 989             abs_timeout = 0;
 990             user_apc = TRUE;
 991         }
 992         signal_object = 0;  /* don't signal it multiple times */
 993     }
 994
 995     if (ret == STATUS_TIMEOUT && user_apc) ret = STATUS_USER_APC;
 996
 997     /* A test on Windows 2000 shows that Windows always yields during
 998        a wait, but a wait that is hit by an event gets a priority
 999        boost as well.  This seems to model that behavior the closest.  */
1000     if (ret == STATUS_TIMEOUT) NtYieldExecution();
1001
1002     return ret;
1003 }
1004
1005
1006 /* wait operations */
1007
1008 /******************************************************************
1009  *              NtWaitForMultipleObjects (NTDLL.@)
1010  */
1011 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
1012                                           BOOLEAN wait_all, BOOLEAN alertable,
1013                                           const LARGE_INTEGER *timeout )
1014 {
1015     UINT flags = SELECT_INTERRUPTIBLE;
1016
1017     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
1018
1019     if (wait_all) flags |= SELECT_ALL;
1020     if (alertable) flags |= SELECT_ALERTABLE;
1021     return NTDLL_wait_for_multiple_objects( count, handles, flags, timeout, 0 );
1022 }
1023
1024
1025 /******************************************************************
1026  *              NtWaitForSingleObject (NTDLL.@)
1027  */
1028 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1029 {
1030     return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
1031 }
1032
1033
1034 /******************************************************************
1035  *              NtSignalAndWaitForSingleObject (NTDLL.@)
1036  */
1037 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE hSignalObject, HANDLE hWaitObject,
1038                                                 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1039 {
1040     UINT flags = SELECT_INTERRUPTIBLE;
1041
1042     if (!hSignalObject) return STATUS_INVALID_HANDLE;
1043     if (alertable) flags |= SELECT_ALERTABLE;
1044     return NTDLL_wait_for_multiple_objects( 1, &hWaitObject, flags, timeout, hSignalObject );
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 NTDLL_wait_for_multiple_objects( 0, NULL, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE,
1070                                                 timeout, 0 );
1071
1072     if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE)  /* sleep forever */
1073     {
1074         for (;;) select( 0, NULL, NULL, NULL, NULL );
1075     }
1076     else
1077     {
1078         LARGE_INTEGER now;
1079         timeout_t when, diff;
1080
1081         if ((when = timeout->QuadPart) < 0)
1082         {
1083             NtQuerySystemTime( &now );
1084             when = now.QuadPart - when;
1085         }
1086
1087         /* Note that we yield after establishing the desired timeout */
1088         NtYieldExecution();
1089         if (!when) return STATUS_SUCCESS;
1090
1091         for (;;)
1092         {
1093             struct timeval tv;
1094             NtQuerySystemTime( &now );
1095             diff = (when - now.QuadPart + 9) / 10;
1096             if (diff <= 0) break;
1097             tv.tv_sec  = diff / 1000000;
1098             tv.tv_usec = diff % 1000000;
1099             if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
1100         }
1101     }
1102     return STATUS_SUCCESS;
1103 }
1104
1105 /******************************************************************
1106  *              NtCreateIoCompletion (NTDLL.@)
1107  *              ZwCreateIoCompletion (NTDLL.@)
1108  *
1109  * Creates I/O completion object.
1110  *
1111  * PARAMS
1112  *      CompletionPort            [O] created completion object handle will be placed there
1113  *      DesiredAccess             [I] desired access to a handle (combination of IO_COMPLETION_*)
1114  *      ObjectAttributes          [I] completion object attributes
1115  *      NumberOfConcurrentThreads [I] desired number of concurrent active worker threads
1116  *
1117  */
1118 NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1119                                       POBJECT_ATTRIBUTES ObjectAttributes, ULONG NumberOfConcurrentThreads )
1120 {
1121     NTSTATUS status;
1122
1123     TRACE("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess,
1124           ObjectAttributes, NumberOfConcurrentThreads);
1125
1126     if (!CompletionPort)
1127         return STATUS_INVALID_PARAMETER;
1128
1129     SERVER_START_REQ( create_completion )
1130     {
1131         req->access     = DesiredAccess;
1132         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
1133         req->rootdir    = ObjectAttributes ? ObjectAttributes->RootDirectory : NULL;
1134         req->concurrent = NumberOfConcurrentThreads;
1135         if (ObjectAttributes && ObjectAttributes->ObjectName)
1136             wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1137                                        ObjectAttributes->ObjectName->Length );
1138         if (!(status = wine_server_call( req )))
1139             *CompletionPort = reply->handle;
1140     }
1141     SERVER_END_REQ;
1142     return status;
1143 }
1144
1145 /******************************************************************
1146  *              NtSetIoCompletion (NTDLL.@)
1147  *              ZwSetIoCompletion (NTDLL.@)
1148  *
1149  * Inserts completion message into queue
1150  *
1151  * PARAMS
1152  *      CompletionPort           [I] HANDLE to completion object
1153  *      CompletionKey            [I] completion key
1154  *      CompletionValue          [I] completion value (usually pointer to OVERLAPPED)
1155  *      Status                   [I] operation status
1156  *      NumberOfBytesTransferred [I] number of bytes transferred
1157  */
1158 NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKey,
1159                                    ULONG_PTR CompletionValue, NTSTATUS Status,
1160                                    ULONG NumberOfBytesTransferred )
1161 {
1162     NTSTATUS status;
1163
1164     TRACE("(%p, %lx, %lx, %x, %d)\n", CompletionPort, CompletionKey,
1165           CompletionValue, Status, NumberOfBytesTransferred);
1166
1167     SERVER_START_REQ( add_completion )
1168     {
1169         req->handle      = CompletionPort;
1170         req->ckey        = CompletionKey;
1171         req->cvalue      = CompletionValue;
1172         req->status      = Status;
1173         req->information = NumberOfBytesTransferred;
1174         status = wine_server_call( req );
1175     }
1176     SERVER_END_REQ;
1177     return status;
1178 }
1179
1180 /******************************************************************
1181  *              NtRemoveIoCompletion (NTDLL.@)
1182  *              ZwRemoveIoCompletion (NTDLL.@)
1183  *
1184  * (Wait for and) retrieve first completion message from completion object's queue
1185  *
1186  * PARAMS
1187  *      CompletionPort  [I] HANDLE to I/O completion object
1188  *      CompletionKey   [O] completion key
1189  *      CompletionValue [O] Completion value given in NtSetIoCompletion or in async operation
1190  *      iosb            [O] IO_STATUS_BLOCK of completed asynchronous operation
1191  *      WaitTime        [I] optional wait time in NTDLL format
1192  *
1193  */
1194 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE CompletionPort, PULONG_PTR CompletionKey,
1195                                       PULONG_PTR CompletionValue, PIO_STATUS_BLOCK iosb,
1196                                       PLARGE_INTEGER WaitTime )
1197 {
1198     NTSTATUS status;
1199
1200     TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort, CompletionKey,
1201           CompletionValue, iosb, WaitTime);
1202
1203     for(;;)
1204     {
1205         SERVER_START_REQ( remove_completion )
1206         {
1207             req->handle = CompletionPort;
1208             if (!(status = wine_server_call( req )))
1209             {
1210                 *CompletionKey    = reply->ckey;
1211                 *CompletionValue  = reply->cvalue;
1212                 iosb->Information = reply->information;
1213                 iosb->u.Status    = reply->status;
1214             }
1215         }
1216         SERVER_END_REQ;
1217         if (status != STATUS_PENDING) break;
1218
1219         status = NtWaitForSingleObject( CompletionPort, FALSE, WaitTime );
1220         if (status != WAIT_OBJECT_0) break;
1221     }
1222     return status;
1223 }
1224
1225 /******************************************************************
1226  *              NtOpenIoCompletion (NTDLL.@)
1227  *              ZwOpenIoCompletion (NTDLL.@)
1228  *
1229  * Opens I/O completion object
1230  *
1231  * PARAMS
1232  *      CompletionPort     [O] completion object handle will be placed there
1233  *      DesiredAccess      [I] desired access to a handle (combination of IO_COMPLETION_*)
1234  *      ObjectAttributes   [I] completion object name
1235  *
1236  */
1237 NTSTATUS WINAPI NtOpenIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1238                                     POBJECT_ATTRIBUTES ObjectAttributes )
1239 {
1240     NTSTATUS status;
1241
1242     TRACE("(%p, 0x%x, %p)\n", CompletionPort, DesiredAccess, ObjectAttributes);
1243
1244     if (!CompletionPort || !ObjectAttributes || !ObjectAttributes->ObjectName)
1245         return STATUS_INVALID_PARAMETER;
1246
1247     SERVER_START_REQ( open_completion )
1248     {
1249         req->access     = DesiredAccess;
1250         req->rootdir    = ObjectAttributes->RootDirectory;
1251         wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1252                                    ObjectAttributes->ObjectName->Length );
1253         if (!(status = wine_server_call( req )))
1254             *CompletionPort = reply->handle;
1255     }
1256     SERVER_END_REQ;
1257     return status;
1258 }
1259
1260 /******************************************************************
1261  *              NtQueryIoCompletion (NTDLL.@)
1262  *              ZwQueryIoCompletion (NTDLL.@)
1263  *
1264  * Requests information about given I/O completion object
1265  *
1266  * PARAMS
1267  *      CompletionPort        [I] HANDLE to completion port to request
1268  *      InformationClass      [I] information class
1269  *      CompletionInformation [O] user-provided buffer for data
1270  *      BufferLength          [I] buffer length
1271  *      RequiredLength        [O] required buffer length
1272  *
1273  */
1274 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE CompletionPort, IO_COMPLETION_INFORMATION_CLASS InformationClass,
1275                                      PVOID CompletionInformation, ULONG BufferLength, PULONG RequiredLength )
1276 {
1277     NTSTATUS status;
1278
1279     TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort, InformationClass, CompletionInformation,
1280           BufferLength, RequiredLength);
1281
1282     if (!CompletionInformation) return STATUS_INVALID_PARAMETER;
1283     switch( InformationClass )
1284     {
1285         case IoCompletionBasicInformation:
1286             {
1287                 ULONG *info = (ULONG *)CompletionInformation;
1288
1289                 if (RequiredLength) *RequiredLength = sizeof(*info);
1290                 if (BufferLength != sizeof(*info))
1291                     status = STATUS_INFO_LENGTH_MISMATCH;
1292                 else
1293                 {
1294                     SERVER_START_REQ( query_completion )
1295                     {
1296                         req->handle = CompletionPort;
1297                         if (!(status = wine_server_call( req )))
1298                             *info = reply->depth;
1299                     }
1300                     SERVER_END_REQ;
1301                 }
1302             }
1303             break;
1304         default:
1305             status = STATUS_INVALID_PARAMETER;
1306             break;
1307     }
1308     return status;
1309 }