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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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_SYS_POLL_H
  33 # include <sys/poll.h>
  34 #endif
  35 #ifdef HAVE_UNISTD_H
  36 # include <unistd.h>
  37 #endif
  38 #ifdef HAVE_SCHED_H
  39 # include <sched.h>
  40 #endif
  41 #include <string.h>
  42 #include <stdarg.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <time.h>
  46
  47 #define NONAMELESSUNION
  48 #define NONAMELESSSTRUCT
  49
  50 #include "windef.h"
  51 #include "winbase.h"
  52 #include "winreg.h"
  53 #include "winternl.h"
  54 #include "async.h"
  55 #include "thread.h"
  56 #include "wine/server.h"
  57 #include "wine/debug.h"
  58 #include "ntdll_misc.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  61
  62
  63 /*
  64  *      Semaphores
  65  */
  66
  67 /******************************************************************************
  68  *  NtCreateSemaphore (NTDLL.@)
  69  */
  70 NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
  71                                    IN ACCESS_MASK access,
  72                                    IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
  73                                    IN LONG InitialCount,
  74                                    IN LONG MaximumCount )
  75 {
  76     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
  77     NTSTATUS ret;
  78
  79     if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount)
  80         return STATUS_INVALID_PARAMETER;
  81     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
  82
  83     SERVER_START_REQ( create_semaphore )
  84     {
  85         req->access  = access;
  86         req->initial = InitialCount;
  87         req->max     = MaximumCount;
  88         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
  89         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
  90         ret = wine_server_call( req );
  91         *SemaphoreHandle = reply->handle;
  92     }
  93     SERVER_END_REQ;
  94     return ret;
  95 }
  96
  97 /******************************************************************************
  98  *  NtOpenSemaphore (NTDLL.@)
  99  */
 100 NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
 101                                  IN ACCESS_MASK access,
 102                                  IN const OBJECT_ATTRIBUTES *attr )
 103 {
 104     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 105     NTSTATUS ret;
 106
 107     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 108
 109     SERVER_START_REQ( open_semaphore )
 110     {
 111         req->access  = access;
 112         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 113         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 114         ret = wine_server_call( req );
 115         *SemaphoreHandle = reply->handle;
 116     }
 117     SERVER_END_REQ;
 118     return ret;
 119 }
 120
 121 /******************************************************************************
 122  *  NtQuerySemaphore (NTDLL.@)
 123  */
 124 NTSTATUS WINAPI NtQuerySemaphore(
 125         HANDLE SemaphoreHandle,
 126         PVOID SemaphoreInformationClass,
 127         OUT PVOID SemaphoreInformation,
 128         ULONG Length,
 129         PULONG ReturnLength)
 130 {
 131         FIXME("(%p,%p,%p,0x%08lx,%p) stub!\n",
 132         SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
 133         return STATUS_SUCCESS;
 134 }
 135
 136 /******************************************************************************
 137  *  NtReleaseSemaphore (NTDLL.@)
 138  */
 139 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
 140 {
 141     NTSTATUS ret;
 142     SERVER_START_REQ( release_semaphore )
 143     {
 144         req->handle = handle;
 145         req->count  = count;
 146         if (!(ret = wine_server_call( req )))
 147         {
 148             if (previous) *previous = reply->prev_count;
 149         }
 150     }
 151     SERVER_END_REQ;
 152     return ret;
 153 }
 154
 155 /*
 156  *      Events
 157  */
 158
 159 /**************************************************************************
 160  * NtCreateEvent (NTDLL.@)
 161  * ZwCreateEvent (NTDLL.@)
 162  */
 163 NTSTATUS WINAPI NtCreateEvent(
 164         OUT PHANDLE EventHandle,
 165         IN ACCESS_MASK DesiredAccess,
 166         IN const OBJECT_ATTRIBUTES *attr,
 167         IN BOOLEAN ManualReset,
 168         IN BOOLEAN InitialState)
 169 {
 170     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 171     NTSTATUS ret;
 172
 173     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 174
 175     SERVER_START_REQ( create_event )
 176     {
 177         req->access = DesiredAccess;
 178         req->manual_reset = ManualReset;
 179         req->initial_state = InitialState;
 180         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 181         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 182         ret = wine_server_call( req );
 183         *EventHandle = reply->handle;
 184     }
 185     SERVER_END_REQ;
 186     return ret;
 187 }
 188
 189 /******************************************************************************
 190  *  NtOpenEvent (NTDLL.@)
 191  *  ZwOpenEvent (NTDLL.@)
 192  */
 193 NTSTATUS WINAPI NtOpenEvent(
 194         OUT PHANDLE EventHandle,
 195         IN ACCESS_MASK DesiredAccess,
 196         IN const OBJECT_ATTRIBUTES *attr )
 197 {
 198     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 199     NTSTATUS ret;
 200
 201     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 202
 203     SERVER_START_REQ( open_event )
 204     {
 205         req->access  = DesiredAccess;
 206         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 207         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 208         ret = wine_server_call( req );
 209         *EventHandle = reply->handle;
 210     }
 211     SERVER_END_REQ;
 212     return ret;
 213 }
 214
 215
 216 /******************************************************************************
 217  *  NtSetEvent (NTDLL.@)
 218  *  ZwSetEvent (NTDLL.@)
 219  */
 220 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 221 {
 222     NTSTATUS ret;
 223
 224     /* FIXME: set NumberOfThreadsReleased */
 225
 226     SERVER_START_REQ( event_op )
 227     {
 228         req->handle = handle;
 229         req->op     = SET_EVENT;
 230         ret = wine_server_call( req );
 231     }
 232     SERVER_END_REQ;
 233     return ret;
 234 }
 235
 236 /******************************************************************************
 237  *  NtResetEvent (NTDLL.@)
 238  */
 239 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 240 {
 241     NTSTATUS ret;
 242
 243     /* resetting an event can't release any thread... */
 244     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
 245
 246     SERVER_START_REQ( event_op )
 247     {
 248         req->handle = handle;
 249         req->op     = RESET_EVENT;
 250         ret = wine_server_call( req );
 251     }
 252     SERVER_END_REQ;
 253     return ret;
 254 }
 255
 256 /******************************************************************************
 257  *  NtClearEvent (NTDLL.@)
 258  *
 259  * FIXME
 260  *   same as NtResetEvent ???
 261  */
 262 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 263 {
 264     return NtResetEvent( handle, NULL );
 265 }
 266
 267 /******************************************************************************
 268  *  NtPulseEvent (NTDLL.@)
 269  *
 270  * FIXME
 271  *   PulseCount
 272  */
 273 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 274 {
 275     NTSTATUS ret;
 276
 277     if (PulseCount)
 278       FIXME("(%p,%ld)\n", handle, *PulseCount);
 279
 280     SERVER_START_REQ( event_op )
 281     {
 282         req->handle = handle;
 283         req->op     = PULSE_EVENT;
 284         ret = wine_server_call( req );
 285     }
 286     SERVER_END_REQ;
 287     return ret;
 288 }
 289
 290 /******************************************************************************
 291  *  NtQueryEvent (NTDLL.@)
 292  */
 293 NTSTATUS WINAPI NtQueryEvent (
 294         IN  HANDLE EventHandle,
 295         IN  UINT EventInformationClass,
 296         OUT PVOID EventInformation,
 297         IN  ULONG EventInformationLength,
 298         OUT PULONG  ReturnLength)
 299 {
 300         FIXME("(%p)\n", EventHandle);
 301         return STATUS_SUCCESS;
 302 }
 303
 304 /*
 305  *      Mutants (known as Mutexes in Kernel32)
 306  */
 307
 308 /******************************************************************************
 309  *              NtCreateMutant                          [NTDLL.@]
 310  *              ZwCreateMutant                          [NTDLL.@]
 311  */
 312 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
 313                                IN ACCESS_MASK access,
 314                                IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
 315                                IN BOOLEAN InitialOwner)
 316 {
 317     NTSTATUS    status;
 318     DWORD       len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 319
 320     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 321
 322     SERVER_START_REQ( create_mutex )
 323     {
 324         req->access  = access;
 325         req->owned   = InitialOwner;
 326         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 327         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 328         status = wine_server_call( req );
 329         *MutantHandle = reply->handle;
 330     }
 331     SERVER_END_REQ;
 332     return status;
 333 }
 334
 335 /**************************************************************************
 336  *              NtOpenMutant                            [NTDLL.@]
 337  *              ZwOpenMutant                            [NTDLL.@]
 338  */
 339 NTSTATUS WINAPI NtOpenMutant(OUT HANDLE* MutantHandle,
 340                              IN ACCESS_MASK access,
 341                              IN const OBJECT_ATTRIBUTES* attr )
 342 {
 343     NTSTATUS    status;
 344     DWORD       len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 345
 346     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 347
 348     SERVER_START_REQ( open_mutex )
 349     {
 350         req->access  = access;
 351         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 352         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 353         status = wine_server_call( req );
 354         *MutantHandle = reply->handle;
 355     }
 356     SERVER_END_REQ;
 357     return status;
 358 }
 359
 360 /**************************************************************************
 361  *              NtReleaseMutant                         [NTDLL.@]
 362  *              ZwReleaseMutant                         [NTDLL.@]
 363  */
 364 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
 365 {
 366     NTSTATUS    status;
 367
 368     SERVER_START_REQ( release_mutex )
 369     {
 370         req->handle = handle;
 371         status = wine_server_call( req );
 372         if (prev_count) *prev_count = reply->prev_count;
 373     }
 374     SERVER_END_REQ;
 375     return status;
 376 }
 377
 378 /******************************************************************
 379  *              NtQueryMutant                   [NTDLL.@]
 380  *              ZwQueryMutant                   [NTDLL.@]
 381  */
 382 NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle,
 383                               IN MUTANT_INFORMATION_CLASS MutantInformationClass,
 384                               OUT PVOID MutantInformation,
 385                               IN ULONG MutantInformationLength,
 386                               OUT PULONG ResultLength OPTIONAL )
 387 {
 388     FIXME("(%p %u %p %lu %p): stub!\n",
 389           handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
 390     return STATUS_NOT_IMPLEMENTED;
 391 }
 392
 393 /*
 394  *      Timers
 395  */
 396
 397 /**************************************************************************
 398  *              NtCreateTimer                           [NTDLL.@]
 399  *              ZwCreateTimer                           [NTDLL.@]
 400  */
 401 NTSTATUS WINAPI NtCreateTimer(OUT HANDLE *handle,
 402                               IN ACCESS_MASK access,
 403                               IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
 404                               IN TIMER_TYPE timer_type)
 405 {
 406     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 407     NTSTATUS    status;
 408
 409     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 410
 411     if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
 412         return STATUS_INVALID_PARAMETER;
 413
 414     SERVER_START_REQ( create_timer )
 415     {
 416         req->access  = access;
 417         req->manual  = (timer_type == NotificationTimer) ? TRUE : FALSE;
 418         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 419         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 420         status = wine_server_call( req );
 421         *handle = reply->handle;
 422     }
 423     SERVER_END_REQ;
 424     return status;
 425
 426 }
 427
 428 /**************************************************************************
 429  *              NtOpenTimer                             [NTDLL.@]
 430  *              ZwOpenTimer                             [NTDLL.@]
 431  */
 432 NTSTATUS WINAPI NtOpenTimer(OUT PHANDLE handle,
 433                             IN ACCESS_MASK access,
 434                             IN const OBJECT_ATTRIBUTES* attr )
 435 {
 436     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 437     NTSTATUS    status;
 438
 439     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 440
 441     SERVER_START_REQ( open_timer )
 442     {
 443         req->access  = access;
 444         req->inherit = attr && (attr->Attributes & OBJ_INHERIT);
 445         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 446         status = wine_server_call( req );
 447         *handle = reply->handle;
 448     }
 449     SERVER_END_REQ;
 450     return status;
 451 }
 452
 453 /**************************************************************************
 454  *              NtSetTimer                              [NTDLL.@]
 455  *              ZwSetTimer                              [NTDLL.@]
 456  */
 457 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
 458                            IN const LARGE_INTEGER* when,
 459                            IN PTIMERAPCROUTINE callback,
 460                            IN PVOID callback_arg,
 461                            IN BOOLEAN resume,
 462                            IN ULONG period OPTIONAL,
 463                            OUT PBOOLEAN state OPTIONAL)
 464 {
 465     NTSTATUS    status = STATUS_SUCCESS;
 466
 467     TRACE("(%p,%p,%p,%p,%08x,0x%08lx,%p) stub\n",
 468           handle, when, callback, callback_arg, resume, period, state);
 469
 470     SERVER_START_REQ( set_timer )
 471     {
 472         if (!when->u.LowPart && !when->u.HighPart)
 473         {
 474             /* special case to start timeout on now+period without too many calculations */
 475             req->expire.sec  = 0;
 476             req->expire.usec = 0;
 477         }
 478         else NTDLL_get_server_timeout( &req->expire, when );
 479
 480         req->handle   = handle;
 481         req->period   = period;
 482         req->callback = callback;
 483         req->arg      = callback_arg;
 484         status = wine_server_call( req );
 485         if (state) *state = reply->signaled;
 486     }
 487     SERVER_END_REQ;
 488
 489     /* set error but can still succeed */
 490     if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
 491     return status;
 492 }
 493
 494 /**************************************************************************
 495  *              NtCancelTimer                           [NTDLL.@]
 496  *              ZwCancelTimer                           [NTDLL.@]
 497  */
 498 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
 499 {
 500     NTSTATUS    status;
 501
 502     SERVER_START_REQ( cancel_timer )
 503     {
 504         req->handle = handle;
 505         status = wine_server_call( req );
 506         if (state) *state = reply->signaled;
 507     }
 508     SERVER_END_REQ;
 509     return status;
 510 }
 511
 512 /******************************************************************************
 513  *  NtQueryTimer (NTDLL.@)
 514  *
 515  * Retrieves information about a timer.
 516  *
 517  * PARAMS
 518  *  TimerHandle           [I] The timer to retrieve information about.
 519  *  TimerInformationClass [I] The type of information to retrieve.
 520  *  TimerInformation      [O] Pointer to buffer to store information in.
 521  *  Length                [I] The length of the buffer pointed to by TimerInformation.
 522  *  ReturnLength          [O] Optional. The size of buffer actually used.
 523  *
 524  * RETURNS
 525  *  Success: STATUS_SUCCESS
 526  *  Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
 527  *           size for the class specified.
 528  *           STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
 529  *           STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
 530  *           to the timer.
 531  */
 532 NTSTATUS WINAPI NtQueryTimer(
 533     HANDLE TimerHandle,
 534     TIMER_INFORMATION_CLASS TimerInformationClass,
 535     PVOID TimerInformation,
 536     ULONG Length,
 537     PULONG ReturnLength)
 538 {
 539     TIMER_BASIC_INFORMATION * basic_info = (TIMER_BASIC_INFORMATION *)TimerInformation;
 540     NTSTATUS status;
 541     LARGE_INTEGER now;
 542
 543     TRACE("(%p,%d,%p,0x%08lx,%p)\n", TimerHandle, TimerInformationClass,
 544        TimerInformation, Length, ReturnLength);
 545
 546     switch (TimerInformationClass)
 547     {
 548     case TimerBasicInformation:
 549         if (Length < sizeof(TIMER_BASIC_INFORMATION))
 550             return STATUS_INFO_LENGTH_MISMATCH;
 551
 552         SERVER_START_REQ(get_timer_info)
 553         {
 554             req->handle = TimerHandle;
 555             status = wine_server_call(req);
 556
 557             /* convert server time to absolute NTDLL time */
 558             NTDLL_from_server_timeout(&basic_info->RemainingTime, &reply->when);
 559             basic_info->TimerState = reply->signaled;
 560         }
 561         SERVER_END_REQ;
 562
 563         /* convert from absolute into relative time */
 564         NtQuerySystemTime(&now);
 565         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
 566             basic_info->RemainingTime.QuadPart = 0;
 567         else
 568             basic_info->RemainingTime.QuadPart -= now.QuadPart;
 569
 570         if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
 571
 572         return status;
 573     }
 574
 575     FIXME("Unhandled class %d\n", TimerInformationClass);
 576     return STATUS_INVALID_INFO_CLASS;
 577 }
 578
 579
 580 /******************************************************************************
 581  * NtQueryTimerResolution [NTDLL.@]
 582  */
 583 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
 584                                        OUT ULONG* max_resolution,
 585                                        OUT ULONG* current_resolution)
 586 {
 587     FIXME("(%p,%p,%p), stub!\n",
 588           min_resolution, max_resolution, current_resolution);
 589
 590     return STATUS_NOT_IMPLEMENTED;
 591 }
 592
 593 /******************************************************************************
 594  * NtSetTimerResolution [NTDLL.@]
 595  */
 596 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
 597                                      IN BOOLEAN set_resolution,
 598                                      OUT ULONG* current_resolution )
 599 {
 600     FIXME("(%lu,%u,%p), stub!\n",
 601           resolution, set_resolution, current_resolution);
 602
 603     return STATUS_NOT_IMPLEMENTED;
 604 }
 605
 606
 607 /***********************************************************************
 608  *           check_async_list
 609  *
 610  * Process a status event from the server.
 611  */
 612 static void WINAPI check_async_list(async_private *asp, DWORD status)
 613 {
 614     async_private *ovp;
 615     DWORD ovp_status;
 616
 617     for( ovp = NtCurrentTeb()->pending_list; ovp && ovp != asp; ovp = ovp->next );
 618
 619     if(!ovp)
 620             return;
 621
 622     if( status != STATUS_ALERTED )
 623     {
 624         ovp_status = status;
 625         ovp->iosb->u.Status = status;
 626     }
 627     else ovp_status = ovp->iosb->u.Status;
 628
 629     if( ovp_status == STATUS_PENDING ) ovp->func( ovp );
 630
 631     /* This will destroy all but PENDING requests */
 632     register_old_async( ovp );
 633 }
 634
 635
 636 /***********************************************************************
 637  *              wait_reply
 638  *
 639  * Wait for a reply on the waiting pipe of the current thread.
 640  */
 641 static int wait_reply( void *cookie )
 642 {
 643     int signaled;
 644     struct wake_up_reply reply;
 645     for (;;)
 646     {
 647         int ret;
 648         ret = read( NtCurrentTeb()->wait_fd[0], &reply, sizeof(reply) );
 649         if (ret == sizeof(reply))
 650         {
 651             if (!reply.cookie) break;  /* thread got killed */
 652             if (reply.cookie == cookie) return reply.signaled;
 653             /* we stole another reply, wait for the real one */
 654             signaled = wait_reply( cookie );
 655             /* and now put the wrong one back in the pipe */
 656             for (;;)
 657             {
 658                 ret = write( NtCurrentTeb()->wait_fd[1], &reply, sizeof(reply) );
 659                 if (ret == sizeof(reply)) break;
 660                 if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
 661                 if (errno == EINTR) continue;
 662                 server_protocol_perror("wakeup write");
 663             }
 664             return signaled;
 665         }
 666         if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
 667         if (errno == EINTR) continue;
 668         server_protocol_perror("wakeup read");
 669     }
 670     /* the server closed the connection; time to die... */
 671     server_abort_thread(0);
 672 }
 673
 674
 675 /***********************************************************************
 676  *              call_apcs
 677  *
 678  * Call outstanding APCs.
 679  */
 680 static void call_apcs( BOOL alertable )
 681 {
 682     FARPROC proc;
 683     LARGE_INTEGER time;
 684     void *arg1, *arg2, *arg3;
 685
 686     for (;;)
 687     {
 688         int type = APC_NONE;
 689         SERVER_START_REQ( get_apc )
 690         {
 691             req->alertable = alertable;
 692             if (!wine_server_call( req )) type = reply->type;
 693             proc = reply->func;
 694             arg1 = reply->arg1;
 695             arg2 = reply->arg2;
 696             arg3 = reply->arg3;
 697         }
 698         SERVER_END_REQ;
 699
 700         switch(type)
 701         {
 702         case APC_NONE:
 703             return;  /* no more APCs */
 704         case APC_ASYNC:
 705             proc( arg1, arg2 );
 706             break;
 707         case APC_USER:
 708             proc( arg1, arg2, arg3 );
 709             break;
 710         case APC_TIMER:
 711             /* convert sec/usec to NT time */
 712             RtlSecondsSince1970ToTime( (time_t)arg1, &time );
 713             time.QuadPart += (DWORD)arg2 * 10;
 714             proc( arg3, time.u.LowPart, time.u.HighPart );
 715             break;
 716         case APC_ASYNC_IO:
 717             check_async_list( arg1, (DWORD) arg2 );
 718             break;
 719         default:
 720             server_protocol_error( "get_apc_request: bad type %d\n", type );
 721             break;
 722         }
 723     }
 724 }
 725
 726
 727 /***********************************************************************
 728  *              NTDLL_wait_for_multiple_objects
 729  *
 730  * Implementation of NtWaitForMultipleObjects
 731  */
 732 NTSTATUS NTDLL_wait_for_multiple_objects( UINT count, const HANDLE *handles, UINT flags,
 733                                           const LARGE_INTEGER *timeout )
 734 {
 735     NTSTATUS ret;
 736     int cookie;
 737
 738     if (timeout) flags |= SELECT_TIMEOUT;
 739     for (;;)
 740     {
 741         SERVER_START_REQ( select )
 742         {
 743             req->flags   = flags;
 744             req->cookie  = &cookie;
 745             NTDLL_get_server_timeout( &req->timeout, timeout );
 746             wine_server_add_data( req, handles, count * sizeof(HANDLE) );
 747             ret = wine_server_call( req );
 748         }
 749         SERVER_END_REQ;
 750         if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
 751         if (ret != STATUS_USER_APC) break;
 752         call_apcs( (flags & SELECT_ALERTABLE) != 0 );
 753         if (flags & SELECT_ALERTABLE) break;
 754     }
 755
 756     /* A test on Windows 2000 shows that Windows always yields during
 757        a wait, but a wait that is hit by an event gets a priority
 758        boost as well.  This seems to model that behavior the closest.  */
 759     if (ret == WAIT_TIMEOUT) NtYieldExecution();
 760
 761     return ret;
 762 }
 763
 764
 765 /* wait operations */
 766
 767 /******************************************************************
 768  *              NtWaitForMultipleObjects (NTDLL.@)
 769  */
 770 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
 771                                           BOOLEAN wait_all, BOOLEAN alertable,
 772                                           const LARGE_INTEGER *timeout )
 773 {
 774     UINT flags = SELECT_INTERRUPTIBLE;
 775
 776     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
 777
 778     if (wait_all) flags |= SELECT_ALL;
 779     if (alertable) flags |= SELECT_ALERTABLE;
 780     return NTDLL_wait_for_multiple_objects( count, handles, flags, timeout );
 781 }
 782
 783
 784 /******************************************************************
 785  *              NtWaitForSingleObject (NTDLL.@)
 786  */
 787 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
 788 {
 789     return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
 790 }
 791
 792
 793 /******************************************************************
 794  *              NtYieldExecution (NTDLL.@)
 795  */
 796 NTSTATUS WINAPI NtYieldExecution(void)
 797 {
 798 #ifdef HAVE_SCHED_YIELD
 799     sched_yield();
 800     return STATUS_SUCCESS;
 801 #else
 802     return STATUS_NO_YIELD_PERFORMED;
 803 #endif
 804 }
 805
 806
 807 /******************************************************************
 808  *              NtDelayExecution (NTDLL.@)
 809  */
 810 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
 811 {
 812     /* if alertable or async I/O in progress, we need to query the server */
 813     if (alertable || NtCurrentTeb()->pending_list)
 814     {
 815         UINT flags = SELECT_INTERRUPTIBLE;
 816         if (alertable) flags |= SELECT_ALERTABLE;
 817         return NTDLL_wait_for_multiple_objects( 0, NULL, flags, timeout );
 818     }
 819
 820     if (!timeout)  /* sleep forever */
 821     {
 822         for (;;) select( 0, NULL, NULL, NULL, NULL );
 823     }
 824     else
 825     {
 826         abs_time_t when;
 827
 828         NTDLL_get_server_timeout( &when, timeout );
 829
 830         /* Note that we yield after establishing the desired timeout */
 831         NtYieldExecution();
 832
 833         for (;;)
 834         {
 835             struct timeval tv;
 836             gettimeofday( &tv, 0 );
 837             tv.tv_sec = when.sec - tv.tv_sec;
 838             if ((tv.tv_usec = when.usec - tv.tv_usec) < 0)
 839             {
 840                 tv.tv_usec += 1000000;
 841                 tv.tv_sec--;
 842             }
 843             /* if our yield already passed enough time, we're done */
 844             if (tv.tv_sec < 0) break;
 845
 846             if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
 847         }
 848     }
 849     return STATUS_SUCCESS;
 850 }