dlls/ntdll/unix/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 #if 0
  25 #pragma makedep unix
  26 #endif
  27
  28 #include "config.h"
  29 #include "wine/port.h"
  30
  31 #include <assert.h>
  32 #include <errno.h>
  33 #include <limits.h>
  34 #include <signal.h>
  35 #ifdef HAVE_SYS_SYSCALL_H
  36 #include <sys/syscall.h>
  37 #endif
  38 #ifdef HAVE_SYS_TIME_H
  39 # include <sys/time.h>
  40 #endif
  41 #ifdef HAVE_POLL_H
  42 #include <poll.h>
  43 #endif
  44 #ifdef HAVE_SYS_POLL_H
  45 # include <sys/poll.h>
  46 #endif
  47 #ifdef HAVE_UNISTD_H
  48 # include <unistd.h>
  49 #endif
  50 #ifdef HAVE_SCHED_H
  51 # include <sched.h>
  52 #endif
  53 #include <string.h>
  54 #include <stdarg.h>
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <time.h>
  58
  59 #include "ntstatus.h"
  60 #define WIN32_NO_STATUS
  61 #define NONAMELESSUNION
  62 #include "windef.h"
  63 #include "winternl.h"
  64 #include "wine/server.h"
  65 #include "wine/debug.h"
  66 #include "unix_private.h"
  67
  68 WINE_DEFAULT_DEBUG_CHANNEL(sync);
  69
  70
  71 HANDLE keyed_event = 0;
  72
  73
  74 /* create a struct security_descriptor and contained information in one contiguous piece of memory */
  75 static NTSTATUS alloc_object_attributes( const OBJECT_ATTRIBUTES *attr, struct object_attributes **ret,
  76                                          data_size_t *ret_len )
  77 {
  78     unsigned int len = sizeof(**ret);
  79     PSID owner = NULL, group = NULL;
  80     ACL *dacl, *sacl;
  81     BOOLEAN dacl_present, sacl_present, defaulted;
  82     PSECURITY_DESCRIPTOR sd;
  83     NTSTATUS status;
  84
  85     *ret = NULL;
  86     *ret_len = 0;
  87
  88     if (!attr) return STATUS_SUCCESS;
  89
  90     if (attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
  91
  92     if ((sd = attr->SecurityDescriptor))
  93     {
  94         len += sizeof(struct security_descriptor);
  95
  96         if ((status = RtlGetOwnerSecurityDescriptor( sd, &owner, &defaulted ))) return status;
  97         if ((status = RtlGetGroupSecurityDescriptor( sd, &group, &defaulted ))) return status;
  98         if ((status = RtlGetSaclSecurityDescriptor( sd, &sacl_present, &sacl, &defaulted ))) return status;
  99         if ((status = RtlGetDaclSecurityDescriptor( sd, &dacl_present, &dacl, &defaulted ))) return status;
 100         if (owner) len += RtlLengthSid( owner );
 101         if (group) len += RtlLengthSid( group );
 102         if (sacl_present && sacl) len += sacl->AclSize;
 103         if (dacl_present && dacl) len += dacl->AclSize;
 104
 105         /* fix alignment for the Unicode name that follows the structure */
 106         len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
 107     }
 108
 109     if (attr->ObjectName)
 110     {
 111         if (attr->ObjectName->Length & (sizeof(WCHAR) - 1)) return STATUS_OBJECT_NAME_INVALID;
 112         len += attr->ObjectName->Length;
 113     }
 114     else if (attr->RootDirectory) return STATUS_OBJECT_NAME_INVALID;
 115
 116     len = (len + 3) & ~3;  /* DWORD-align the entire structure */
 117
 118     *ret = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, len );
 119     if (!*ret) return STATUS_NO_MEMORY;
 120
 121     (*ret)->rootdir = wine_server_obj_handle( attr->RootDirectory );
 122     (*ret)->attributes = attr->Attributes;
 123
 124     if (attr->SecurityDescriptor)
 125     {
 126         struct security_descriptor *descr = (struct security_descriptor *)(*ret + 1);
 127         unsigned char *ptr = (unsigned char *)(descr + 1);
 128
 129         descr->control = ((SECURITY_DESCRIPTOR *)sd)->Control & ~SE_SELF_RELATIVE;
 130         if (owner) descr->owner_len = RtlLengthSid( owner );
 131         if (group) descr->group_len = RtlLengthSid( group );
 132         if (sacl_present && sacl) descr->sacl_len = sacl->AclSize;
 133         if (dacl_present && dacl) descr->dacl_len = dacl->AclSize;
 134
 135         memcpy( ptr, owner, descr->owner_len );
 136         ptr += descr->owner_len;
 137         memcpy( ptr, group, descr->group_len );
 138         ptr += descr->group_len;
 139         memcpy( ptr, sacl, descr->sacl_len );
 140         ptr += descr->sacl_len;
 141         memcpy( ptr, dacl, descr->dacl_len );
 142         (*ret)->sd_len = (sizeof(*descr) + descr->owner_len + descr->group_len + descr->sacl_len +
 143                           descr->dacl_len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
 144     }
 145
 146     if (attr->ObjectName)
 147     {
 148         unsigned char *ptr = (unsigned char *)(*ret + 1) + (*ret)->sd_len;
 149         (*ret)->name_len = attr->ObjectName->Length;
 150         memcpy( ptr, attr->ObjectName->Buffer, (*ret)->name_len );
 151     }
 152
 153     *ret_len = len;
 154     return STATUS_SUCCESS;
 155 }
 156
 157
 158 static NTSTATUS validate_open_object_attributes( const OBJECT_ATTRIBUTES *attr )
 159 {
 160     if (!attr || attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
 161
 162     if (attr->ObjectName)
 163     {
 164         if (attr->ObjectName->Length & (sizeof(WCHAR) - 1)) return STATUS_OBJECT_NAME_INVALID;
 165     }
 166     else if (attr->RootDirectory) return STATUS_OBJECT_NAME_INVALID;
 167
 168     return STATUS_SUCCESS;
 169 }
 170
 171
 172 /******************************************************************************
 173  *              NtCreateSemaphore (NTDLL.@)
 174  */
 175 NTSTATUS WINAPI NtCreateSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 176                                    LONG initial, LONG max )
 177 {
 178     NTSTATUS ret;
 179     data_size_t len;
 180     struct object_attributes *objattr;
 181
 182     if (max <= 0 || initial < 0 || initial > max) return STATUS_INVALID_PARAMETER;
 183     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 184
 185     SERVER_START_REQ( create_semaphore )
 186     {
 187         req->access  = access;
 188         req->initial = initial;
 189         req->max     = max;
 190         wine_server_add_data( req, objattr, len );
 191         ret = wine_server_call( req );
 192         *handle = wine_server_ptr_handle( reply->handle );
 193     }
 194     SERVER_END_REQ;
 195
 196     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 197     return ret;
 198 }
 199
 200
 201 /******************************************************************************
 202  *              NtOpenSemaphore (NTDLL.@)
 203  */
 204 NTSTATUS WINAPI NtOpenSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 205 {
 206     NTSTATUS ret;
 207
 208     if ((ret = validate_open_object_attributes( attr ))) return ret;
 209
 210     SERVER_START_REQ( open_semaphore )
 211     {
 212         req->access     = access;
 213         req->attributes = attr->Attributes;
 214         req->rootdir    = wine_server_obj_handle( attr->RootDirectory );
 215         if (attr->ObjectName)
 216             wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
 217         ret = wine_server_call( req );
 218         *handle = wine_server_ptr_handle( reply->handle );
 219     }
 220     SERVER_END_REQ;
 221     return ret;
 222 }
 223
 224
 225 /******************************************************************************
 226  *              NtQuerySemaphore (NTDLL.@)
 227  */
 228 NTSTATUS WINAPI NtQuerySemaphore( HANDLE handle, SEMAPHORE_INFORMATION_CLASS class,
 229                                   void *info, ULONG len, ULONG *ret_len )
 230 {
 231     NTSTATUS ret;
 232     SEMAPHORE_BASIC_INFORMATION *out = info;
 233
 234     TRACE("(%p, %u, %p, %u, %p)\n", handle, class, info, len, ret_len);
 235
 236     if (class != SemaphoreBasicInformation)
 237     {
 238         FIXME("(%p,%d,%u) Unknown class\n", handle, class, len);
 239         return STATUS_INVALID_INFO_CLASS;
 240     }
 241
 242     if (len != sizeof(SEMAPHORE_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 243
 244     SERVER_START_REQ( query_semaphore )
 245     {
 246         req->handle = wine_server_obj_handle( handle );
 247         if (!(ret = wine_server_call( req )))
 248         {
 249             out->CurrentCount = reply->current;
 250             out->MaximumCount = reply->max;
 251             if (ret_len) *ret_len = sizeof(SEMAPHORE_BASIC_INFORMATION);
 252         }
 253     }
 254     SERVER_END_REQ;
 255     return ret;
 256 }
 257
 258
 259 /******************************************************************************
 260  *              NtReleaseSemaphore (NTDLL.@)
 261  */
 262 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, ULONG *previous )
 263 {
 264     NTSTATUS ret;
 265
 266     SERVER_START_REQ( release_semaphore )
 267     {
 268         req->handle = wine_server_obj_handle( handle );
 269         req->count  = count;
 270         if (!(ret = wine_server_call( req )))
 271         {
 272             if (previous) *previous = reply->prev_count;
 273         }
 274     }
 275     SERVER_END_REQ;
 276     return ret;
 277 }
 278
 279
 280 /**************************************************************************
 281  *              NtCreateEvent (NTDLL.@)
 282  */
 283 NTSTATUS WINAPI NtCreateEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 284                                EVENT_TYPE type, BOOLEAN state )
 285 {
 286     NTSTATUS ret;
 287     data_size_t len;
 288     struct object_attributes *objattr;
 289
 290     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 291
 292     SERVER_START_REQ( create_event )
 293     {
 294         req->access = access;
 295         req->manual_reset = (type == NotificationEvent);
 296         req->initial_state = state;
 297         wine_server_add_data( req, objattr, len );
 298         ret = wine_server_call( req );
 299         *handle = wine_server_ptr_handle( reply->handle );
 300     }
 301     SERVER_END_REQ;
 302
 303     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 304     return ret;
 305 }
 306
 307
 308 /******************************************************************************
 309  *              NtOpenEvent (NTDLL.@)
 310  */
 311 NTSTATUS WINAPI NtOpenEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 312 {
 313     NTSTATUS ret;
 314
 315     if ((ret = validate_open_object_attributes( attr ))) return ret;
 316
 317     SERVER_START_REQ( open_event )
 318     {
 319         req->access     = access;
 320         req->attributes = attr->Attributes;
 321         req->rootdir    = wine_server_obj_handle( attr->RootDirectory );
 322         if (attr->ObjectName)
 323             wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
 324         ret = wine_server_call( req );
 325         *handle = wine_server_ptr_handle( reply->handle );
 326     }
 327     SERVER_END_REQ;
 328     return ret;
 329 }
 330
 331
 332 /******************************************************************************
 333  *              NtSetEvent (NTDLL.@)
 334  */
 335 NTSTATUS WINAPI NtSetEvent( HANDLE handle, LONG *prev_state )
 336 {
 337     NTSTATUS ret;
 338
 339     SERVER_START_REQ( event_op )
 340     {
 341         req->handle = wine_server_obj_handle( handle );
 342         req->op     = SET_EVENT;
 343         ret = wine_server_call( req );
 344         if (!ret && prev_state) *prev_state = reply->state;
 345     }
 346     SERVER_END_REQ;
 347     return ret;
 348 }
 349
 350
 351 /******************************************************************************
 352  *              NtResetEvent (NTDLL.@)
 353  */
 354 NTSTATUS WINAPI NtResetEvent( HANDLE handle, LONG *prev_state )
 355 {
 356     NTSTATUS ret;
 357
 358     SERVER_START_REQ( event_op )
 359     {
 360         req->handle = wine_server_obj_handle( handle );
 361         req->op     = RESET_EVENT;
 362         ret = wine_server_call( req );
 363         if (!ret && prev_state) *prev_state = reply->state;
 364     }
 365     SERVER_END_REQ;
 366     return ret;
 367 }
 368
 369
 370 /******************************************************************************
 371  *              NtClearEvent (NTDLL.@)
 372  */
 373 NTSTATUS WINAPI NtClearEvent( HANDLE handle )
 374 {
 375     /* FIXME: same as NtResetEvent ??? */
 376     return NtResetEvent( handle, NULL );
 377 }
 378
 379
 380 /******************************************************************************
 381  *              NtPulseEvent (NTDLL.@)
 382  */
 383 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, LONG *prev_state )
 384 {
 385     NTSTATUS ret;
 386
 387     SERVER_START_REQ( event_op )
 388     {
 389         req->handle = wine_server_obj_handle( handle );
 390         req->op     = PULSE_EVENT;
 391         ret = wine_server_call( req );
 392         if (!ret && prev_state) *prev_state = reply->state;
 393     }
 394     SERVER_END_REQ;
 395     return ret;
 396 }
 397
 398
 399 /******************************************************************************
 400  *              NtQueryEvent (NTDLL.@)
 401  */
 402 NTSTATUS WINAPI NtQueryEvent( HANDLE handle, EVENT_INFORMATION_CLASS class,
 403                               void *info, ULONG len, ULONG *ret_len )
 404 {
 405     NTSTATUS ret;
 406     EVENT_BASIC_INFORMATION *out = info;
 407
 408     TRACE("(%p, %u, %p, %u, %p)\n", handle, class, info, len, ret_len);
 409
 410     if (class != EventBasicInformation)
 411     {
 412         FIXME("(%p, %d, %d) Unknown class\n",
 413               handle, class, len);
 414         return STATUS_INVALID_INFO_CLASS;
 415     }
 416
 417     if (len != sizeof(EVENT_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 418
 419     SERVER_START_REQ( query_event )
 420     {
 421         req->handle = wine_server_obj_handle( handle );
 422         if (!(ret = wine_server_call( req )))
 423         {
 424             out->EventType  = reply->manual_reset ? NotificationEvent : SynchronizationEvent;
 425             out->EventState = reply->state;
 426             if (ret_len) *ret_len = sizeof(EVENT_BASIC_INFORMATION);
 427         }
 428     }
 429     SERVER_END_REQ;
 430     return ret;
 431 }
 432
 433
 434 /******************************************************************************
 435  *              NtCreateMutant (NTDLL.@)
 436  */
 437 NTSTATUS WINAPI NtCreateMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 438                                 BOOLEAN owned )
 439 {
 440     NTSTATUS ret;
 441     data_size_t len;
 442     struct object_attributes *objattr;
 443
 444     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 445
 446     SERVER_START_REQ( create_mutex )
 447     {
 448         req->access  = access;
 449         req->owned   = owned;
 450         wine_server_add_data( req, objattr, len );
 451         ret = wine_server_call( req );
 452         *handle = wine_server_ptr_handle( reply->handle );
 453     }
 454     SERVER_END_REQ;
 455
 456     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 457     return ret;
 458 }
 459
 460
 461 /**************************************************************************
 462  *              NtOpenMutant (NTDLL.@)
 463  */
 464 NTSTATUS WINAPI NtOpenMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 465 {
 466     NTSTATUS ret;
 467
 468     if ((ret = validate_open_object_attributes( attr ))) return ret;
 469
 470     SERVER_START_REQ( open_mutex )
 471     {
 472         req->access  = access;
 473         req->attributes = attr->Attributes;
 474         req->rootdir = wine_server_obj_handle( attr->RootDirectory );
 475         if (attr->ObjectName)
 476             wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
 477         ret = wine_server_call( req );
 478         *handle = wine_server_ptr_handle( reply->handle );
 479     }
 480     SERVER_END_REQ;
 481     return ret;
 482 }
 483
 484
 485 /**************************************************************************
 486  *              NtReleaseMutant (NTDLL.@)
 487  */
 488 NTSTATUS WINAPI NtReleaseMutant( HANDLE handle, LONG *prev_count )
 489 {
 490     NTSTATUS ret;
 491
 492     SERVER_START_REQ( release_mutex )
 493     {
 494         req->handle = wine_server_obj_handle( handle );
 495         ret = wine_server_call( req );
 496         if (prev_count) *prev_count = 1 - reply->prev_count;
 497     }
 498     SERVER_END_REQ;
 499     return ret;
 500 }
 501
 502
 503 /******************************************************************
 504  *              NtQueryMutant (NTDLL.@)
 505  */
 506 NTSTATUS WINAPI NtQueryMutant( HANDLE handle, MUTANT_INFORMATION_CLASS class,
 507                                void *info, ULONG len, ULONG *ret_len )
 508 {
 509     NTSTATUS ret;
 510     MUTANT_BASIC_INFORMATION *out = info;
 511
 512     TRACE("(%p, %u, %p, %u, %p)\n", handle, class, info, len, ret_len);
 513
 514     if (class != MutantBasicInformation)
 515     {
 516         FIXME( "(%p, %d, %d) Unknown class\n", handle, class, len );
 517         return STATUS_INVALID_INFO_CLASS;
 518     }
 519
 520     if (len != sizeof(MUTANT_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 521
 522     SERVER_START_REQ( query_mutex )
 523     {
 524         req->handle = wine_server_obj_handle( handle );
 525         if (!(ret = wine_server_call( req )))
 526         {
 527             out->CurrentCount   = 1 - reply->count;
 528             out->OwnedByCaller  = reply->owned;
 529             out->AbandonedState = reply->abandoned;
 530             if (ret_len) *ret_len = sizeof(MUTANT_BASIC_INFORMATION);
 531         }
 532     }
 533     SERVER_END_REQ;
 534     return ret;
 535 }
 536
 537
 538 /**************************************************************************
 539  *              NtCreateTimer (NTDLL.@)
 540  */
 541 NTSTATUS WINAPI NtCreateTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 542                                TIMER_TYPE type )
 543 {
 544     NTSTATUS ret;
 545     data_size_t len;
 546     struct object_attributes *objattr;
 547
 548     if (type != NotificationTimer && type != SynchronizationTimer) return STATUS_INVALID_PARAMETER;
 549
 550     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 551
 552     SERVER_START_REQ( create_timer )
 553     {
 554         req->access  = access;
 555         req->manual  = (type == NotificationTimer);
 556         wine_server_add_data( req, objattr, len );
 557         ret = wine_server_call( req );
 558         *handle = wine_server_ptr_handle( reply->handle );
 559     }
 560     SERVER_END_REQ;
 561
 562     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 563     return ret;
 564
 565 }
 566
 567
 568 /**************************************************************************
 569  *              NtOpenTimer (NTDLL.@)
 570  */
 571 NTSTATUS WINAPI NtOpenTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 572 {
 573     NTSTATUS ret;
 574
 575     if ((ret = validate_open_object_attributes( attr ))) return ret;
 576
 577     SERVER_START_REQ( open_timer )
 578     {
 579         req->access     = access;
 580         req->attributes = attr->Attributes;
 581         req->rootdir    = wine_server_obj_handle( attr->RootDirectory );
 582         if (attr->ObjectName)
 583             wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
 584         ret = wine_server_call( req );
 585         *handle = wine_server_ptr_handle( reply->handle );
 586     }
 587     SERVER_END_REQ;
 588     return ret;
 589 }
 590
 591
 592 /**************************************************************************
 593  *              NtSetTimer (NTDLL.@)
 594  */
 595 NTSTATUS WINAPI NtSetTimer( HANDLE handle, const LARGE_INTEGER *when, PTIMER_APC_ROUTINE callback,
 596                             void *arg, BOOLEAN resume, ULONG period, BOOLEAN *state )
 597 {
 598     NTSTATUS ret = STATUS_SUCCESS;
 599
 600     TRACE( "(%p,%p,%p,%p,%08x,0x%08x,%p)\n", handle, when, callback, arg, resume, period, state );
 601
 602     SERVER_START_REQ( set_timer )
 603     {
 604         req->handle   = wine_server_obj_handle( handle );
 605         req->period   = period;
 606         req->expire   = when->QuadPart;
 607         req->callback = wine_server_client_ptr( callback );
 608         req->arg      = wine_server_client_ptr( arg );
 609         ret = wine_server_call( req );
 610         if (state) *state = reply->signaled;
 611     }
 612     SERVER_END_REQ;
 613
 614     /* set error but can still succeed */
 615     if (resume && ret == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
 616     return ret;
 617 }
 618
 619
 620 /**************************************************************************
 621  *              NtCancelTimer (NTDLL.@)
 622  */
 623 NTSTATUS WINAPI NtCancelTimer( HANDLE handle, BOOLEAN *state )
 624 {
 625     NTSTATUS ret;
 626
 627     SERVER_START_REQ( cancel_timer )
 628     {
 629         req->handle = wine_server_obj_handle( handle );
 630         ret = wine_server_call( req );
 631         if (state) *state = reply->signaled;
 632     }
 633     SERVER_END_REQ;
 634     return ret;
 635 }
 636
 637
 638 /******************************************************************************
 639  *              NtQueryTimer (NTDLL.@)
 640  */
 641 NTSTATUS WINAPI NtQueryTimer( HANDLE handle, TIMER_INFORMATION_CLASS class,
 642                               void *info, ULONG len, ULONG *ret_len )
 643 {
 644     TIMER_BASIC_INFORMATION *basic_info = info;
 645     NTSTATUS ret;
 646     LARGE_INTEGER now;
 647
 648     TRACE( "(%p,%d,%p,0x%08x,%p)\n", handle, class, info, len, ret_len );
 649
 650     switch (class)
 651     {
 652     case TimerBasicInformation:
 653         if (len < sizeof(TIMER_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
 654
 655         SERVER_START_REQ( get_timer_info )
 656         {
 657             req->handle = wine_server_obj_handle( handle );
 658             ret = wine_server_call(req);
 659             /* convert server time to absolute NTDLL time */
 660             basic_info->RemainingTime.QuadPart = reply->when;
 661             basic_info->TimerState = reply->signaled;
 662         }
 663         SERVER_END_REQ;
 664
 665         /* convert into relative time */
 666         if (basic_info->RemainingTime.QuadPart > 0) NtQuerySystemTime( &now );
 667         else
 668         {
 669             RtlQueryPerformanceCounter( &now );
 670             basic_info->RemainingTime.QuadPart = -basic_info->RemainingTime.QuadPart;
 671         }
 672
 673         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
 674             basic_info->RemainingTime.QuadPart = 0;
 675         else
 676             basic_info->RemainingTime.QuadPart -= now.QuadPart;
 677
 678         if (ret_len) *ret_len = sizeof(TIMER_BASIC_INFORMATION);
 679         return ret;
 680     }
 681
 682     FIXME( "Unhandled class %d\n", class );
 683     return STATUS_INVALID_INFO_CLASS;
 684 }
 685
 686
 687 /******************************************************************
 688  *              NtWaitForMultipleObjects (NTDLL.@)
 689  */
 690 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles, BOOLEAN wait_any,
 691                                           BOOLEAN alertable, const LARGE_INTEGER *timeout )
 692 {
 693     select_op_t select_op;
 694     UINT i, flags = SELECT_INTERRUPTIBLE;
 695
 696     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
 697
 698     if (alertable) flags |= SELECT_ALERTABLE;
 699     select_op.wait.op = wait_any ? SELECT_WAIT : SELECT_WAIT_ALL;
 700     for (i = 0; i < count; i++) select_op.wait.handles[i] = wine_server_obj_handle( handles[i] );
 701     return server_wait( &select_op, offsetof( select_op_t, wait.handles[count] ), flags, timeout );
 702 }
 703
 704
 705 /******************************************************************
 706  *              NtWaitForSingleObject (NTDLL.@)
 707  */
 708 NTSTATUS WINAPI NtWaitForSingleObject( HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
 709 {
 710     return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
 711 }
 712
 713
 714 /******************************************************************
 715  *              NtSignalAndWaitForSingleObject (NTDLL.@)
 716  */
 717 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE signal, HANDLE wait,
 718                                                 BOOLEAN alertable, const LARGE_INTEGER *timeout )
 719 {
 720     select_op_t select_op;
 721     UINT flags = SELECT_INTERRUPTIBLE;
 722
 723     if (!signal) return STATUS_INVALID_HANDLE;
 724
 725     if (alertable) flags |= SELECT_ALERTABLE;
 726     select_op.signal_and_wait.op = SELECT_SIGNAL_AND_WAIT;
 727     select_op.signal_and_wait.wait = wine_server_obj_handle( wait );
 728     select_op.signal_and_wait.signal = wine_server_obj_handle( signal );
 729     return server_wait( &select_op, sizeof(select_op.signal_and_wait), flags, timeout );
 730 }
 731
 732
 733 /******************************************************************
 734  *              NtYieldExecution (NTDLL.@)
 735  */
 736 NTSTATUS WINAPI NtYieldExecution(void)
 737 {
 738 #ifdef HAVE_SCHED_YIELD
 739     sched_yield();
 740     return STATUS_SUCCESS;
 741 #else
 742     return STATUS_NO_YIELD_PERFORMED;
 743 #endif
 744 }
 745
 746
 747 /******************************************************************
 748  *              NtDelayExecution (NTDLL.@)
 749  */
 750 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
 751 {
 752     /* if alertable, we need to query the server */
 753     if (alertable) return server_wait( NULL, 0, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE, timeout );
 754
 755     if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE)  /* sleep forever */
 756     {
 757         for (;;) select( 0, NULL, NULL, NULL, NULL );
 758     }
 759     else
 760     {
 761         LARGE_INTEGER now;
 762         timeout_t when, diff;
 763
 764         if ((when = timeout->QuadPart) < 0)
 765         {
 766             NtQuerySystemTime( &now );
 767             when = now.QuadPart - when;
 768         }
 769
 770         /* Note that we yield after establishing the desired timeout */
 771         NtYieldExecution();
 772         if (!when) return STATUS_SUCCESS;
 773
 774         for (;;)
 775         {
 776             struct timeval tv;
 777             NtQuerySystemTime( &now );
 778             diff = (when - now.QuadPart + 9) / 10;
 779             if (diff <= 0) break;
 780             tv.tv_sec  = diff / 1000000;
 781             tv.tv_usec = diff % 1000000;
 782             if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
 783         }
 784     }
 785     return STATUS_SUCCESS;
 786 }
 787
 788
 789 /******************************************************************************
 790  *              NtCreateKeyedEvent (NTDLL.@)
 791  */
 792 NTSTATUS WINAPI NtCreateKeyedEvent( HANDLE *handle, ACCESS_MASK access,
 793                                     const OBJECT_ATTRIBUTES *attr, ULONG flags )
 794 {
 795     NTSTATUS ret;
 796     data_size_t len;
 797     struct object_attributes *objattr;
 798
 799     if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
 800
 801     SERVER_START_REQ( create_keyed_event )
 802     {
 803         req->access = access;
 804         wine_server_add_data( req, objattr, len );
 805         ret = wine_server_call( req );
 806         *handle = wine_server_ptr_handle( reply->handle );
 807     }
 808     SERVER_END_REQ;
 809
 810     RtlFreeHeap( GetProcessHeap(), 0, objattr );
 811     return ret;
 812 }
 813
 814
 815 /******************************************************************************
 816  *              NtOpenKeyedEvent (NTDLL.@)
 817  */
 818 NTSTATUS WINAPI NtOpenKeyedEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 819 {
 820     NTSTATUS ret;
 821
 822     if ((ret = validate_open_object_attributes( attr ))) return ret;
 823
 824     SERVER_START_REQ( open_keyed_event )
 825     {
 826         req->access     = access;
 827         req->attributes = attr->Attributes;
 828         req->rootdir    = wine_server_obj_handle( attr->RootDirectory );
 829         if (attr->ObjectName)
 830             wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
 831         ret = wine_server_call( req );
 832         *handle = wine_server_ptr_handle( reply->handle );
 833     }
 834     SERVER_END_REQ;
 835     return ret;
 836 }
 837
 838 /******************************************************************************
 839  *              NtWaitForKeyedEvent (NTDLL.@)
 840  */
 841 NTSTATUS WINAPI NtWaitForKeyedEvent( HANDLE handle, const void *key,
 842                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
 843 {
 844     select_op_t select_op;
 845     UINT flags = SELECT_INTERRUPTIBLE;
 846
 847     if (!handle) handle = keyed_event;
 848     if ((ULONG_PTR)key & 1) return STATUS_INVALID_PARAMETER_1;
 849     if (alertable) flags |= SELECT_ALERTABLE;
 850     select_op.keyed_event.op     = SELECT_KEYED_EVENT_WAIT;
 851     select_op.keyed_event.handle = wine_server_obj_handle( handle );
 852     select_op.keyed_event.key    = wine_server_client_ptr( key );
 853     return server_wait( &select_op, sizeof(select_op.keyed_event), flags, timeout );
 854 }
 855
 856
 857 /******************************************************************************
 858  *              NtReleaseKeyedEvent (NTDLL.@)
 859  */
 860 NTSTATUS WINAPI NtReleaseKeyedEvent( HANDLE handle, const void *key,
 861                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
 862 {
 863     select_op_t select_op;
 864     UINT flags = SELECT_INTERRUPTIBLE;
 865
 866     if (!handle) handle = keyed_event;
 867     if ((ULONG_PTR)key & 1) return STATUS_INVALID_PARAMETER_1;
 868     if (alertable) flags |= SELECT_ALERTABLE;
 869     select_op.keyed_event.op     = SELECT_KEYED_EVENT_RELEASE;
 870     select_op.keyed_event.handle = wine_server_obj_handle( handle );
 871     select_op.keyed_event.key    = wine_server_client_ptr( key );
 872     return server_wait( &select_op, sizeof(select_op.keyed_event), flags, timeout );
 873 }