dlls/ntdll/sync.c

   1 /*
   2  *      Process synchronisation
   3  *
   4  * Copyright 1996, 1997, 1998 Marcus Meissner
   5  * Copyright 1997, 1998, 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 <limits.h>
  25 #include <string.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <time.h>
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34 #include "winternl.h"
  35 #include "wine/debug.h"
  36 #include "wine/list.h"
  37 #include "wine/exception.h"
  38 #include "ntdll_misc.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(sync);
  41 WINE_DECLARE_DEBUG_CHANNEL(relay);
  42
  43 static const char *debugstr_timeout( const LARGE_INTEGER *timeout )
  44 {
  45     if (!timeout) return "(infinite)";
  46     return wine_dbgstr_longlong( timeout->QuadPart );
  47 }
  48
  49 /******************************************************************
  50  *              RtlRunOnceInitialize (NTDLL.@)
  51  */
  52 void WINAPI RtlRunOnceInitialize( RTL_RUN_ONCE *once )
  53 {
  54     once->Ptr = NULL;
  55 }
  56
  57 /******************************************************************
  58  *              RtlRunOnceBeginInitialize (NTDLL.@)
  59  */
  60 DWORD WINAPI RtlRunOnceBeginInitialize( RTL_RUN_ONCE *once, ULONG flags, void **context )
  61 {
  62     if (flags & RTL_RUN_ONCE_CHECK_ONLY)
  63     {
  64         ULONG_PTR val = (ULONG_PTR)once->Ptr;
  65
  66         if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
  67         if ((val & 3) != 2) return STATUS_UNSUCCESSFUL;
  68         if (context) *context = (void *)(val & ~3);
  69         return STATUS_SUCCESS;
  70     }
  71
  72     for (;;)
  73     {
  74         ULONG_PTR next, val = (ULONG_PTR)once->Ptr;
  75
  76         switch (val & 3)
  77         {
  78         case 0:  /* first time */
  79             if (!InterlockedCompareExchangePointer( &once->Ptr,
  80                                                     (flags & RTL_RUN_ONCE_ASYNC) ? (void *)3 : (void *)1, 0 ))
  81                 return STATUS_PENDING;
  82             break;
  83
  84         case 1:  /* in progress, wait */
  85             if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
  86             next = val & ~3;
  87             if (InterlockedCompareExchangePointer( &once->Ptr, (void *)((ULONG_PTR)&next | 1),
  88                                                    (void *)val ) == (void *)val)
  89                 NtWaitForKeyedEvent( 0, &next, FALSE, NULL );
  90             break;
  91
  92         case 2:  /* done */
  93             if (context) *context = (void *)(val & ~3);
  94             return STATUS_SUCCESS;
  95
  96         case 3:  /* in progress, async */
  97             if (!(flags & RTL_RUN_ONCE_ASYNC)) return STATUS_INVALID_PARAMETER;
  98             return STATUS_PENDING;
  99         }
 100     }
 101 }
 102
 103 /******************************************************************
 104  *              RtlRunOnceComplete (NTDLL.@)
 105  */
 106 DWORD WINAPI RtlRunOnceComplete( RTL_RUN_ONCE *once, ULONG flags, void *context )
 107 {
 108     if ((ULONG_PTR)context & 3) return STATUS_INVALID_PARAMETER;
 109
 110     if (flags & RTL_RUN_ONCE_INIT_FAILED)
 111     {
 112         if (context) return STATUS_INVALID_PARAMETER;
 113         if (flags & RTL_RUN_ONCE_ASYNC) return STATUS_INVALID_PARAMETER;
 114     }
 115     else context = (void *)((ULONG_PTR)context | 2);
 116
 117     for (;;)
 118     {
 119         ULONG_PTR val = (ULONG_PTR)once->Ptr;
 120
 121         switch (val & 3)
 122         {
 123         case 1:  /* in progress */
 124             if (InterlockedCompareExchangePointer( &once->Ptr, context, (void *)val ) != (void *)val) break;
 125             val &= ~3;
 126             while (val)
 127             {
 128                 ULONG_PTR next = *(ULONG_PTR *)val;
 129                 NtReleaseKeyedEvent( 0, (void *)val, FALSE, NULL );
 130                 val = next;
 131             }
 132             return STATUS_SUCCESS;
 133
 134         case 3:  /* in progress, async */
 135             if (!(flags & RTL_RUN_ONCE_ASYNC)) return STATUS_INVALID_PARAMETER;
 136             if (InterlockedCompareExchangePointer( &once->Ptr, context, (void *)val ) != (void *)val) break;
 137             return STATUS_SUCCESS;
 138
 139         default:
 140             return STATUS_UNSUCCESSFUL;
 141         }
 142     }
 143 }
 144
 145
 146 /***********************************************************************
 147  * Critical sections
 148  ***********************************************************************/
 149
 150
 151 static void *no_debug_info_marker = (void *)(ULONG_PTR)-1;
 152
 153 static BOOL crit_section_has_debuginfo( const RTL_CRITICAL_SECTION *crit )
 154 {
 155     return crit->DebugInfo != NULL && crit->DebugInfo != no_debug_info_marker;
 156 }
 157
 158 static const char *crit_section_get_name( const RTL_CRITICAL_SECTION *crit )
 159 {
 160     if (crit_section_has_debuginfo( crit ))
 161         return (char *)crit->DebugInfo->Spare[0];
 162     return "?";
 163 }
 164
 165 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
 166 {
 167     if ((ULONG_PTR)crit->LockSemaphore > 1) return crit->LockSemaphore;
 168     return NULL;
 169 }
 170
 171 static inline NTSTATUS wait_semaphore( RTL_CRITICAL_SECTION *crit, int timeout )
 172 {
 173     LARGE_INTEGER time = {.QuadPart = timeout * (LONGLONG)-10000000};
 174     HANDLE sem = get_semaphore( crit );
 175
 176     if (sem) return NtWaitForSingleObject( sem, FALSE, &time );
 177     else
 178     {
 179         LONG *lock = (LONG *)&crit->LockSemaphore;
 180         while (!InterlockedCompareExchange( lock, 0, 1 ))
 181         {
 182             static const LONG zero;
 183             /* this may wait longer than specified in case of multiple wake-ups */
 184             if (RtlWaitOnAddress( lock, &zero, sizeof(LONG), &time ) == STATUS_TIMEOUT)
 185                 return STATUS_TIMEOUT;
 186         }
 187         return STATUS_WAIT_0;
 188     }
 189 }
 190
 191 static ULONG crit_sect_default_flags(void)
 192 {
 193     if (NtCurrentTeb()->Peb->OSMajorVersion > 6 ||
 194         (NtCurrentTeb()->Peb->OSMajorVersion == 6 && NtCurrentTeb()->Peb->OSMinorVersion >= 2)) return 0;
 195     return RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO;
 196 }
 197
 198 /******************************************************************************
 199  *      RtlInitializeCriticalSection   (NTDLL.@)
 200  */
 201 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
 202 {
 203     return RtlInitializeCriticalSectionEx( crit, 0, crit_sect_default_flags() );
 204 }
 205
 206
 207 /******************************************************************************
 208  *      RtlInitializeCriticalSectionAndSpinCount   (NTDLL.@)
 209  */
 210 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 211 {
 212     return RtlInitializeCriticalSectionEx( crit, spincount, crit_sect_default_flags() );
 213 }
 214
 215
 216 /******************************************************************************
 217  *      RtlInitializeCriticalSectionEx   (NTDLL.@)
 218  */
 219 NTSTATUS WINAPI RtlInitializeCriticalSectionEx( RTL_CRITICAL_SECTION *crit, ULONG spincount, ULONG flags )
 220 {
 221     if (flags & (RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN|RTL_CRITICAL_SECTION_FLAG_STATIC_INIT))
 222         FIXME("(%p,%lu,0x%08lx) semi-stub\n", crit, spincount, flags);
 223
 224     /* FIXME: if RTL_CRITICAL_SECTION_FLAG_STATIC_INIT is given, we should use
 225      * memory from a static pool to hold the debug info. Then heap.c could pass
 226      * this flag rather than initialising the process heap CS by hand. If this
 227      * is done, then debug info should be managed through Rtlp[Allocate|Free]DebugInfo
 228      * so (e.g.) MakeCriticalSectionGlobal() doesn't free it using HeapFree().
 229      */
 230     if (!(flags & RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO))
 231         crit->DebugInfo = no_debug_info_marker;
 232     else
 233     {
 234         crit->DebugInfo = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(RTL_CRITICAL_SECTION_DEBUG ));
 235         if (crit->DebugInfo)
 236         {
 237             crit->DebugInfo->Type = 0;
 238             crit->DebugInfo->CreatorBackTraceIndex = 0;
 239             crit->DebugInfo->CriticalSection = crit;
 240             crit->DebugInfo->ProcessLocksList.Blink = &crit->DebugInfo->ProcessLocksList;
 241             crit->DebugInfo->ProcessLocksList.Flink = &crit->DebugInfo->ProcessLocksList;
 242             crit->DebugInfo->EntryCount = 0;
 243             crit->DebugInfo->ContentionCount = 0;
 244             memset( crit->DebugInfo->Spare, 0, sizeof(crit->DebugInfo->Spare) );
 245         }
 246     }
 247     crit->LockCount      = -1;
 248     crit->RecursionCount = 0;
 249     crit->OwningThread   = 0;
 250     crit->LockSemaphore  = 0;
 251     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 252     crit->SpinCount = spincount & ~0x80000000;
 253     return STATUS_SUCCESS;
 254 }
 255
 256
 257 /******************************************************************************
 258  *      RtlSetCriticalSectionSpinCount   (NTDLL.@)
 259  */
 260 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 261 {
 262     ULONG oldspincount = crit->SpinCount;
 263     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 264     crit->SpinCount = spincount;
 265     return oldspincount;
 266 }
 267
 268
 269 /******************************************************************************
 270  *      RtlDeleteCriticalSection   (NTDLL.@)
 271  */
 272 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
 273 {
 274     HANDLE sem;
 275
 276     crit->LockCount      = -1;
 277     crit->RecursionCount = 0;
 278     crit->OwningThread   = 0;
 279     if (crit_section_has_debuginfo( crit ))
 280     {
 281         /* only free the ones we made in here */
 282         if (!crit->DebugInfo->Spare[0])
 283         {
 284             RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 285             crit->DebugInfo = NULL;
 286         }
 287     }
 288     else crit->DebugInfo = NULL;
 289
 290     if ((sem = get_semaphore( crit ))) NtClose( sem );
 291     crit->LockSemaphore = 0;
 292     return STATUS_SUCCESS;
 293 }
 294
 295
 296 /******************************************************************************
 297  *      RtlpWaitForCriticalSection   (NTDLL.@)
 298  */
 299 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
 300 {
 301     unsigned int timeout = 5;
 302
 303     /* Don't allow blocking on a critical section during process termination */
 304     if (RtlDllShutdownInProgress())
 305     {
 306         WARN( "process %s is shutting down, returning STATUS_SUCCESS\n",
 307               debugstr_w(NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer) );
 308         return STATUS_SUCCESS;
 309     }
 310
 311     for (;;)
 312     {
 313         NTSTATUS status = wait_semaphore( crit, timeout );
 314
 315         if (status == STATUS_WAIT_0) break;
 316
 317         timeout = (TRACE_ON(relay) ? 300 : 60);
 318
 319         ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (%u sec)\n",
 320              crit, debugstr_a(crit_section_get_name(crit)), GetCurrentThreadId(), HandleToULong(crit->OwningThread), timeout );
 321     }
 322     if (crit_section_has_debuginfo( crit )) crit->DebugInfo->ContentionCount++;
 323     return STATUS_SUCCESS;
 324 }
 325
 326
 327 /******************************************************************************
 328  *      RtlpUnWaitCriticalSection   (NTDLL.@)
 329  */
 330 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
 331 {
 332     NTSTATUS ret;
 333     HANDLE sem = get_semaphore( crit );
 334
 335     if (sem) ret = NtReleaseSemaphore( sem, 1, NULL );
 336     else
 337     {
 338         LONG *lock = (LONG *)&crit->LockSemaphore;
 339         InterlockedExchange( lock, 1 );
 340         RtlWakeAddressSingle( lock );
 341         ret = STATUS_SUCCESS;
 342     }
 343     if (ret) RtlRaiseStatus( ret );
 344     return ret;
 345 }
 346
 347
 348 /******************************************************************************
 349  *      RtlEnterCriticalSection   (NTDLL.@)
 350  */
 351 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 352 {
 353     if (crit->SpinCount)
 354     {
 355         ULONG count;
 356
 357         if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
 358         for (count = crit->SpinCount; count > 0; count--)
 359         {
 360             if (crit->LockCount > 0) break;  /* more than one waiter, don't bother spinning */
 361             if (crit->LockCount == -1)       /* try again */
 362             {
 363                 if (InterlockedCompareExchange( &crit->LockCount, 0, -1 ) == -1) goto done;
 364             }
 365             YieldProcessor();
 366         }
 367     }
 368
 369     if (InterlockedIncrement( &crit->LockCount ))
 370     {
 371         if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
 372         {
 373             crit->RecursionCount++;
 374             return STATUS_SUCCESS;
 375         }
 376
 377         /* Now wait for it */
 378         RtlpWaitForCriticalSection( crit );
 379     }
 380 done:
 381     crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
 382     crit->RecursionCount = 1;
 383     return STATUS_SUCCESS;
 384 }
 385
 386
 387 /******************************************************************************
 388  *      RtlTryEnterCriticalSection   (NTDLL.@)
 389  */
 390 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 391 {
 392     BOOL ret = FALSE;
 393     if (InterlockedCompareExchange( &crit->LockCount, 0, -1 ) == -1)
 394     {
 395         crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
 396         crit->RecursionCount = 1;
 397         ret = TRUE;
 398     }
 399     else if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
 400     {
 401         InterlockedIncrement( &crit->LockCount );
 402         crit->RecursionCount++;
 403         ret = TRUE;
 404     }
 405     return ret;
 406 }
 407
 408
 409 /******************************************************************************
 410  *      RtlIsCriticalSectionLocked   (NTDLL.@)
 411  */
 412 BOOL WINAPI RtlIsCriticalSectionLocked( RTL_CRITICAL_SECTION *crit )
 413 {
 414     return crit->RecursionCount != 0;
 415 }
 416
 417
 418 /******************************************************************************
 419  *      RtlIsCriticalSectionLockedByThread   (NTDLL.@)
 420  */
 421 BOOL WINAPI RtlIsCriticalSectionLockedByThread( RTL_CRITICAL_SECTION *crit )
 422 {
 423     return crit->OwningThread == ULongToHandle(GetCurrentThreadId()) &&
 424            crit->RecursionCount;
 425 }
 426
 427
 428 /******************************************************************************
 429  *      RtlLeaveCriticalSection   (NTDLL.@)
 430  */
 431 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
 432 {
 433     if (--crit->RecursionCount)
 434     {
 435         if (crit->RecursionCount > 0) InterlockedDecrement( &crit->LockCount );
 436         else ERR( "section %p %s is not acquired\n", crit, debugstr_a( crit_section_get_name( crit )));
 437     }
 438     else
 439     {
 440         crit->OwningThread = 0;
 441         if (InterlockedDecrement( &crit->LockCount ) >= 0)
 442         {
 443             /* someone is waiting */
 444             RtlpUnWaitCriticalSection( crit );
 445         }
 446     }
 447     return STATUS_SUCCESS;
 448 }
 449
 450 /******************************************************************
 451  *              RtlRunOnceExecuteOnce (NTDLL.@)
 452  */
 453 DWORD WINAPI RtlRunOnceExecuteOnce( RTL_RUN_ONCE *once, PRTL_RUN_ONCE_INIT_FN func,
 454                                     void *param, void **context )
 455 {
 456     DWORD ret = RtlRunOnceBeginInitialize( once, 0, context );
 457
 458     if (ret != STATUS_PENDING) return ret;
 459
 460     if (!func( once, param, context ))
 461     {
 462         RtlRunOnceComplete( once, RTL_RUN_ONCE_INIT_FAILED, NULL );
 463         return STATUS_UNSUCCESSFUL;
 464     }
 465
 466     return RtlRunOnceComplete( once, 0, context ? *context : NULL );
 467 }
 468
 469 struct srw_lock
 470 {
 471     /* bit 0 - if the lock is held exclusive. bit 1.. - number of exclusive waiters. */
 472     short exclusive_waiters;
 473
 474     /* Number of owners.
 475      *
 476      * Sadly Windows has no equivalent to FUTEX_WAIT_BITSET, so in order to wake
 477      * up *only* exclusive or *only* shared waiters (and thus avoid spurious
 478      * wakeups), we need to wait on two different addresses.
 479      * RtlAcquireSRWLockShared() needs to know the values of "exclusive_waiters"
 480      * and "owners", but RtlAcquireSRWLockExclusive() only needs to know the
 481      * value of "owners", so the former can wait on the entire structure, and
 482      * the latter waits only on the "owners" member. Note then that "owners"
 483      * must not be the first element in the structure.
 484      */
 485     unsigned short owners;
 486 };
 487 C_ASSERT( sizeof(struct srw_lock) == 4 );
 488
 489 /***********************************************************************
 490  *              RtlInitializeSRWLock (NTDLL.@)
 491  *
 492  * NOTES
 493  *  Please note that SRWLocks do not keep track of the owner of a lock.
 494  *  It doesn't make any difference which thread for example unlocks an
 495  *  SRWLock (see corresponding tests). This implementation uses two
 496  *  keyed events (one for the exclusive waiters and one for the shared
 497  *  waiters) and is limited to 2^15-1 waiting threads.
 498  */
 499 void WINAPI RtlInitializeSRWLock( RTL_SRWLOCK *lock )
 500 {
 501     lock->Ptr = NULL;
 502 }
 503
 504 /***********************************************************************
 505  *              RtlAcquireSRWLockExclusive (NTDLL.@)
 506  *
 507  * NOTES
 508  *  Unlike RtlAcquireResourceExclusive this function doesn't allow
 509  *  nested calls from the same thread. "Upgrading" a shared access lock
 510  *  to an exclusive access lock also doesn't seem to be supported.
 511  */
 512 void WINAPI RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
 513 {
 514     union { RTL_SRWLOCK *rtl; struct srw_lock *s; LONG *l; } u = { lock };
 515
 516     InterlockedExchangeAdd16( &u.s->exclusive_waiters, 2 );
 517
 518     for (;;)
 519     {
 520         union { struct srw_lock s; LONG l; } old, new;
 521         BOOL wait;
 522
 523         do
 524         {
 525             old.s = *u.s;
 526             new.s = old.s;
 527
 528             if (!old.s.owners)
 529             {
 530                 /* Not locked exclusive or shared. We can try to grab it. */
 531                 new.s.owners = 1;
 532                 new.s.exclusive_waiters -= 2;
 533                 new.s.exclusive_waiters |= 1;
 534                 wait = FALSE;
 535             }
 536             else
 537             {
 538                 wait = TRUE;
 539             }
 540         } while (InterlockedCompareExchange( u.l, new.l, old.l ) != old.l);
 541
 542         if (!wait) return;
 543         RtlWaitOnAddress( &u.s->owners, &new.s.owners, sizeof(short), NULL );
 544     }
 545 }
 546
 547 /***********************************************************************
 548  *              RtlAcquireSRWLockShared (NTDLL.@)
 549  *
 550  * NOTES
 551  *   Do not call this function recursively - it will only succeed when
 552  *   there are no threads waiting for an exclusive lock!
 553  */
 554 void WINAPI RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
 555 {
 556     union { RTL_SRWLOCK *rtl; struct srw_lock *s; LONG *l; } u = { lock };
 557
 558     for (;;)
 559     {
 560         union { struct srw_lock s; LONG l; } old, new;
 561         BOOL wait;
 562
 563         do
 564         {
 565             old.s = *u.s;
 566             new = old;
 567
 568             if (!old.s.exclusive_waiters)
 569             {
 570                 /* Not locked exclusive, and no exclusive waiters.
 571                  * We can try to grab it. */
 572                 ++new.s.owners;
 573                 wait = FALSE;
 574             }
 575             else
 576             {
 577                 wait = TRUE;
 578             }
 579         } while (InterlockedCompareExchange( u.l, new.l, old.l ) != old.l);
 580
 581         if (!wait) return;
 582         RtlWaitOnAddress( u.s, &new.s, sizeof(struct srw_lock), NULL );
 583     }
 584 }
 585
 586 /***********************************************************************
 587  *              RtlReleaseSRWLockExclusive (NTDLL.@)
 588  */
 589 void WINAPI RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
 590 {
 591     union { RTL_SRWLOCK *rtl; struct srw_lock *s; LONG *l; } u = { lock };
 592     union { struct srw_lock s; LONG l; } old, new;
 593
 594     do
 595     {
 596         old.s = *u.s;
 597         new = old;
 598
 599         if (!(old.s.exclusive_waiters & 1)) ERR("Lock %p is not owned exclusive!\n", lock);
 600
 601         new.s.owners = 0;
 602         new.s.exclusive_waiters &= ~1;
 603     } while (InterlockedCompareExchange( u.l, new.l, old.l ) != old.l);
 604
 605     if (new.s.exclusive_waiters)
 606         RtlWakeAddressSingle( &u.s->owners );
 607     else
 608         RtlWakeAddressAll( u.s );
 609 }
 610
 611 /***********************************************************************
 612  *              RtlReleaseSRWLockShared (NTDLL.@)
 613  */
 614 void WINAPI RtlReleaseSRWLockShared( RTL_SRWLOCK *lock )
 615 {
 616     union { RTL_SRWLOCK *rtl; struct srw_lock *s; LONG *l; } u = { lock };
 617     union { struct srw_lock s; LONG l; } old, new;
 618
 619     do
 620     {
 621         old.s = *u.s;
 622         new = old;
 623
 624         if (old.s.exclusive_waiters & 1) ERR("Lock %p is owned exclusive!\n", lock);
 625         else if (!old.s.owners) ERR("Lock %p is not owned shared!\n", lock);
 626
 627         --new.s.owners;
 628     } while (InterlockedCompareExchange( u.l, new.l, old.l ) != old.l);
 629
 630     if (!new.s.owners)
 631         RtlWakeAddressSingle( &u.s->owners );
 632 }
 633
 634 /***********************************************************************
 635  *              RtlTryAcquireSRWLockExclusive (NTDLL.@)
 636  *
 637  * NOTES
 638  *  Similarly to AcquireSRWLockExclusive, recursive calls are not allowed
 639  *  and will fail with a FALSE return value.
 640  */
 641 BOOLEAN WINAPI RtlTryAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
 642 {
 643     union { RTL_SRWLOCK *rtl; struct srw_lock *s; LONG *l; } u = { lock };
 644     union { struct srw_lock s; LONG l; } old, new;
 645     BOOLEAN ret;
 646
 647     do
 648     {
 649         old.s = *u.s;
 650         new.s = old.s;
 651
 652         if (!old.s.owners)
 653         {
 654             /* Not locked exclusive or shared. We can try to grab it. */
 655             new.s.owners = 1;
 656             new.s.exclusive_waiters |= 1;
 657             ret = TRUE;
 658         }
 659         else
 660         {
 661             ret = FALSE;
 662         }
 663     } while (InterlockedCompareExchange( u.l, new.l, old.l ) != old.l);
 664
 665     return ret;
 666 }
 667
 668 /***********************************************************************
 669  *              RtlTryAcquireSRWLockShared (NTDLL.@)
 670  */
 671 BOOLEAN WINAPI RtlTryAcquireSRWLockShared( RTL_SRWLOCK *lock )
 672 {
 673     union { RTL_SRWLOCK *rtl; struct srw_lock *s; LONG *l; } u = { lock };
 674     union { struct srw_lock s; LONG l; } old, new;
 675     BOOLEAN ret;
 676
 677     do
 678     {
 679         old.s = *u.s;
 680         new.s = old.s;
 681
 682         if (!old.s.exclusive_waiters)
 683         {
 684             /* Not locked exclusive, and no exclusive waiters.
 685              * We can try to grab it. */
 686             ++new.s.owners;
 687             ret = TRUE;
 688         }
 689         else
 690         {
 691             ret = FALSE;
 692         }
 693     } while (InterlockedCompareExchange( u.l, new.l, old.l ) != old.l);
 694
 695     return ret;
 696 }
 697
 698 /***********************************************************************
 699  *           RtlInitializeConditionVariable   (NTDLL.@)
 700  *
 701  * Initializes the condition variable with NULL.
 702  *
 703  * PARAMS
 704  *  variable [O] condition variable
 705  *
 706  * RETURNS
 707  *  Nothing.
 708  */
 709 void WINAPI RtlInitializeConditionVariable( RTL_CONDITION_VARIABLE *variable )
 710 {
 711     variable->Ptr = NULL;
 712 }
 713
 714 /***********************************************************************
 715  *           RtlWakeConditionVariable   (NTDLL.@)
 716  *
 717  * Wakes up one thread waiting on the condition variable.
 718  *
 719  * PARAMS
 720  *  variable [I/O] condition variable to wake up.
 721  *
 722  * RETURNS
 723  *  Nothing.
 724  *
 725  * NOTES
 726  *  The calling thread does not have to own any lock in order to call
 727  *  this function.
 728  */
 729 void WINAPI RtlWakeConditionVariable( RTL_CONDITION_VARIABLE *variable )
 730 {
 731     InterlockedIncrement( (LONG *)&variable->Ptr );
 732     RtlWakeAddressSingle( variable );
 733 }
 734
 735 /***********************************************************************
 736  *           RtlWakeAllConditionVariable   (NTDLL.@)
 737  *
 738  * See WakeConditionVariable, wakes up all waiting threads.
 739  */
 740 void WINAPI RtlWakeAllConditionVariable( RTL_CONDITION_VARIABLE *variable )
 741 {
 742     InterlockedIncrement( (LONG *)&variable->Ptr );
 743     RtlWakeAddressAll( variable );
 744 }
 745
 746 /***********************************************************************
 747  *           RtlSleepConditionVariableCS   (NTDLL.@)
 748  *
 749  * Atomically releases the critical section and suspends the thread,
 750  * waiting for a Wake(All)ConditionVariable event. Afterwards it enters
 751  * the critical section again and returns.
 752  *
 753  * PARAMS
 754  *  variable  [I/O] condition variable
 755  *  crit      [I/O] critical section to leave temporarily
 756  *  timeout   [I]   timeout
 757  *
 758  * RETURNS
 759  *  see NtWaitForKeyedEvent for all possible return values.
 760  */
 761 NTSTATUS WINAPI RtlSleepConditionVariableCS( RTL_CONDITION_VARIABLE *variable, RTL_CRITICAL_SECTION *crit,
 762                                              const LARGE_INTEGER *timeout )
 763 {
 764     int value = *(int *)&variable->Ptr;
 765     NTSTATUS status;
 766
 767     RtlLeaveCriticalSection( crit );
 768     status = RtlWaitOnAddress( &variable->Ptr, &value, sizeof(value), timeout );
 769     RtlEnterCriticalSection( crit );
 770     return status;
 771 }
 772
 773 /***********************************************************************
 774  *           RtlSleepConditionVariableSRW   (NTDLL.@)
 775  *
 776  * Atomically releases the SRWLock and suspends the thread,
 777  * waiting for a Wake(All)ConditionVariable event. Afterwards it enters
 778  * the SRWLock again with the same access rights and returns.
 779  *
 780  * PARAMS
 781  *  variable  [I/O] condition variable
 782  *  lock      [I/O] SRWLock to leave temporarily
 783  *  timeout   [I]   timeout
 784  *  flags     [I]   type of the current lock (exclusive / shared)
 785  *
 786  * RETURNS
 787  *  see NtWaitForKeyedEvent for all possible return values.
 788  *
 789  * NOTES
 790  *  the behaviour is undefined if the thread doesn't own the lock.
 791  */
 792 NTSTATUS WINAPI RtlSleepConditionVariableSRW( RTL_CONDITION_VARIABLE *variable, RTL_SRWLOCK *lock,
 793                                               const LARGE_INTEGER *timeout, ULONG flags )
 794 {
 795     int value = *(int *)&variable->Ptr;
 796     NTSTATUS status;
 797
 798     if (flags & RTL_CONDITION_VARIABLE_LOCKMODE_SHARED)
 799         RtlReleaseSRWLockShared( lock );
 800     else
 801         RtlReleaseSRWLockExclusive( lock );
 802
 803     status = RtlWaitOnAddress( &variable->Ptr, &value, sizeof(value), timeout );
 804
 805     if (flags & RTL_CONDITION_VARIABLE_LOCKMODE_SHARED)
 806         RtlAcquireSRWLockShared( lock );
 807     else
 808         RtlAcquireSRWLockExclusive( lock );
 809     return status;
 810 }
 811
 812 /* RtlWaitOnAddress() and RtlWakeAddress*(), hereafter referred to as "Win32
 813  * futexes", offer futex-like semantics with a variable set of address sizes,
 814  * but are limited to a single process. They are also fair—the documentation
 815  * specifies this, and tests bear it out.
 816  *
 817  * On Windows they are implemented using NtAlertThreadByThreadId and
 818  * NtWaitForAlertByThreadId, which manipulate a single flag (similar to an
 819  * auto-reset event) per thread. This can be tested by attempting to wake a
 820  * thread waiting in RtlWaitOnAddress() via NtAlertThreadByThreadId.
 821  */
 822
 823 struct futex_entry
 824 {
 825     struct list entry;
 826     const void *addr;
 827     DWORD tid;
 828 };
 829
 830 struct futex_queue
 831 {
 832     struct list queue;
 833     LONG lock;
 834 };
 835
 836 static struct futex_queue futex_queues[256];
 837
 838 static struct futex_queue *get_futex_queue( const void *addr )
 839 {
 840     ULONG_PTR val = (ULONG_PTR)addr;
 841
 842     return &futex_queues[(val >> 4) % ARRAY_SIZE(futex_queues)];
 843 }
 844
 845 static void spin_lock( LONG *lock )
 846 {
 847     while (InterlockedCompareExchange( lock, -1, 0 ))
 848         YieldProcessor();
 849 }
 850
 851 static void spin_unlock( LONG *lock )
 852 {
 853     InterlockedExchange( lock, 0 );
 854 }
 855
 856 static BOOL compare_addr( const void *addr, const void *cmp, SIZE_T size )
 857 {
 858     switch (size)
 859     {
 860         case 1:
 861             return (*(const UCHAR *)addr == *(const UCHAR *)cmp);
 862         case 2:
 863             return (*(const USHORT *)addr == *(const USHORT *)cmp);
 864         case 4:
 865             return (*(const ULONG *)addr == *(const ULONG *)cmp);
 866         case 8:
 867             return (*(const ULONG64 *)addr == *(const ULONG64 *)cmp);
 868     }
 869
 870     return FALSE;
 871 }
 872
 873 /***********************************************************************
 874  *           RtlWaitOnAddress   (NTDLL.@)
 875  */
 876 NTSTATUS WINAPI RtlWaitOnAddress( const void *addr, const void *cmp, SIZE_T size,
 877                                   const LARGE_INTEGER *timeout )
 878 {
 879     struct futex_queue *queue = get_futex_queue( addr );
 880     struct futex_entry entry;
 881     NTSTATUS ret;
 882
 883     TRACE("addr %p cmp %p size %#Ix timeout %s\n", addr, cmp, size, debugstr_timeout( timeout ));
 884
 885     if (size != 1 && size != 2 && size != 4 && size != 8)
 886         return STATUS_INVALID_PARAMETER;
 887
 888     entry.addr = addr;
 889     entry.tid = GetCurrentThreadId();
 890
 891     spin_lock( &queue->lock );
 892
 893     /* Do the comparison inside of the spinlock, to reduce spurious wakeups. */
 894
 895     if (!compare_addr( addr, cmp, size ))
 896     {
 897         spin_unlock( &queue->lock );
 898         return STATUS_SUCCESS;
 899     }
 900
 901     if (!queue->queue.next)
 902         list_init( &queue->queue );
 903     list_add_tail( &queue->queue, &entry.entry );
 904
 905     spin_unlock( &queue->lock );
 906
 907     ret = NtWaitForAlertByThreadId( NULL, timeout );
 908
 909     /* We may have already been removed by a call to RtlWakeAddressSingle() or RtlWakeAddressAll(). */
 910     if (entry.addr)
 911     {
 912         spin_lock( &queue->lock );
 913         if (entry.addr)
 914             list_remove( &entry.entry );
 915         spin_unlock( &queue->lock );
 916     }
 917
 918     TRACE("returning %#lx\n", ret);
 919
 920     if (ret == STATUS_ALERTED) ret = STATUS_SUCCESS;
 921     return ret;
 922 }
 923
 924 /***********************************************************************
 925  *           RtlWakeAddressAll    (NTDLL.@)
 926  */
 927 void WINAPI RtlWakeAddressAll( const void *addr )
 928 {
 929     struct futex_queue *queue = get_futex_queue( addr );
 930     struct futex_entry *entry, *next;
 931     unsigned int count = 0, i;
 932     DWORD tids[256];
 933
 934     TRACE("%p\n", addr);
 935
 936     if (!addr) return;
 937
 938     spin_lock( &queue->lock );
 939
 940     if (!queue->queue.next)
 941         list_init(&queue->queue);
 942
 943     LIST_FOR_EACH_ENTRY_SAFE( entry, next, &queue->queue, struct futex_entry, entry )
 944     {
 945         if (entry->addr == addr)
 946         {
 947             entry->addr = NULL;
 948             list_remove( &entry->entry );
 949             /* Try to buffer wakes, so that we don't make a system call while
 950              * holding a spinlock. */
 951             if (count < ARRAY_SIZE(tids))
 952                 tids[count++] = entry->tid;
 953             else
 954                 NtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)entry->tid );
 955         }
 956     }
 957
 958     spin_unlock( &queue->lock );
 959
 960     for (i = 0; i < count; ++i)
 961         NtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)tids[i] );
 962 }
 963
 964 /***********************************************************************
 965  *           RtlWakeAddressSingle (NTDLL.@)
 966  */
 967 void WINAPI RtlWakeAddressSingle( const void *addr )
 968 {
 969     struct futex_queue *queue = get_futex_queue( addr );
 970     struct futex_entry *entry;
 971     DWORD tid = 0;
 972
 973     TRACE("%p\n", addr);
 974
 975     if (!addr) return;
 976
 977     spin_lock( &queue->lock );
 978
 979     if (!queue->queue.next)
 980         list_init(&queue->queue);
 981
 982     LIST_FOR_EACH_ENTRY( entry, &queue->queue, struct futex_entry, entry )
 983     {
 984         if (entry->addr == addr)
 985         {
 986             /* Try to buffer wakes, so that we don't make a system call while
 987              * holding a spinlock. */
 988             tid = entry->tid;
 989
 990             /* Remove this entry from the queue, so that a simultaneous call to
 991              * RtlWakeAddressSingle() will not also wake it—two simultaneous
 992              * calls must wake at least two waiters if they exist. */
 993             entry->addr = NULL;
 994             list_remove( &entry->entry );
 995             break;
 996         }
 997     }
 998
 999     spin_unlock( &queue->lock );
1000
1001     if (tid) NtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)tid );
1002 }
1003
1004 /*************************************************************************
1005  *           RtlInitializeSListHead (NTDLL.@)
1006  */
1007 void WINAPI RtlInitializeSListHead(PSLIST_HEADER list)
1008 {
1009 #ifdef _WIN64
1010     list->Alignment = list->Region = 0;
1011     list->Header16.HeaderType = 1;  /* we use the 16-byte header */
1012 #else
1013     list->Alignment = 0;
1014 #endif
1015 }
1016
1017 /*************************************************************************
1018  *           RtlQueryDepthSList (NTDLL.@)
1019  */
1020 WORD WINAPI RtlQueryDepthSList(PSLIST_HEADER list)
1021 {
1022 #ifdef _WIN64
1023     return list->Header16.Depth;
1024 #else
1025     return list->Depth;
1026 #endif
1027 }
1028
1029 /*************************************************************************
1030  *           RtlFirstEntrySList (NTDLL.@)
1031  */
1032 PSLIST_ENTRY WINAPI RtlFirstEntrySList(const SLIST_HEADER* list)
1033 {
1034 #ifdef _WIN64
1035     return (SLIST_ENTRY *)((ULONG_PTR)list->Header16.NextEntry << 4);
1036 #else
1037     return list->Next.Next;
1038 #endif
1039 }
1040
1041 /*************************************************************************
1042  *           RtlInterlockedFlushSList (NTDLL.@)
1043  */
1044 PSLIST_ENTRY WINAPI RtlInterlockedFlushSList(PSLIST_HEADER list)
1045 {
1046     SLIST_HEADER old, new;
1047
1048 #ifdef _WIN64
1049     if (!list->Header16.NextEntry) return NULL;
1050     new.Alignment = new.Region = 0;
1051     new.Header16.HeaderType = 1;  /* we use the 16-byte header */
1052     do
1053     {
1054         old = *list;
1055         new.Header16.Sequence = old.Header16.Sequence + 1;
1056     } while (!InterlockedCompareExchange128((__int64 *)list, new.Region, new.Alignment, (__int64 *)&old));
1057     return (SLIST_ENTRY *)((ULONG_PTR)old.Header16.NextEntry << 4);
1058 #else
1059     if (!list->Next.Next) return NULL;
1060     new.Alignment = 0;
1061     do
1062     {
1063         old = *list;
1064         new.Sequence = old.Sequence + 1;
1065     } while (InterlockedCompareExchange64((__int64 *)&list->Alignment, new.Alignment,
1066                                           old.Alignment) != old.Alignment);
1067     return old.Next.Next;
1068 #endif
1069 }
1070
1071 /*************************************************************************
1072  *           RtlInterlockedPushEntrySList (NTDLL.@)
1073  */
1074 PSLIST_ENTRY WINAPI RtlInterlockedPushEntrySList(PSLIST_HEADER list, PSLIST_ENTRY entry)
1075 {
1076     SLIST_HEADER old, new;
1077
1078 #ifdef _WIN64
1079     new.Header16.NextEntry = (ULONG_PTR)entry >> 4;
1080     do
1081     {
1082         old = *list;
1083         entry->Next = (SLIST_ENTRY *)((ULONG_PTR)old.Header16.NextEntry << 4);
1084         new.Header16.Depth = old.Header16.Depth + 1;
1085         new.Header16.Sequence = old.Header16.Sequence + 1;
1086     } while (!InterlockedCompareExchange128((__int64 *)list, new.Region, new.Alignment, (__int64 *)&old));
1087     return (SLIST_ENTRY *)((ULONG_PTR)old.Header16.NextEntry << 4);
1088 #else
1089     new.Next.Next = entry;
1090     do
1091     {
1092         old = *list;
1093         entry->Next = old.Next.Next;
1094         new.Depth = old.Depth + 1;
1095         new.Sequence = old.Sequence + 1;
1096     } while (InterlockedCompareExchange64((__int64 *)&list->Alignment, new.Alignment,
1097                                           old.Alignment) != old.Alignment);
1098     return old.Next.Next;
1099 #endif
1100 }
1101
1102 /*************************************************************************
1103  *           RtlInterlockedPopEntrySList (NTDLL.@)
1104  */
1105 PSLIST_ENTRY WINAPI RtlInterlockedPopEntrySList(PSLIST_HEADER list)
1106 {
1107     SLIST_HEADER old, new;
1108     PSLIST_ENTRY entry;
1109
1110 #ifdef _WIN64
1111     do
1112     {
1113         old = *list;
1114         if (!(entry = (SLIST_ENTRY *)((ULONG_PTR)old.Header16.NextEntry << 4))) return NULL;
1115         /* entry could be deleted by another thread */
1116         __TRY
1117         {
1118             new.Header16.NextEntry = (ULONG_PTR)entry->Next >> 4;
1119             new.Header16.Depth = old.Header16.Depth - 1;
1120             new.Header16.Sequence = old.Header16.Sequence + 1;
1121         }
1122         __EXCEPT_PAGE_FAULT
1123         {
1124         }
1125         __ENDTRY
1126     } while (!InterlockedCompareExchange128((__int64 *)list, new.Region, new.Alignment, (__int64 *)&old));
1127 #else
1128     do
1129     {
1130         old = *list;
1131         if (!(entry = old.Next.Next)) return NULL;
1132         /* entry could be deleted by another thread */
1133         __TRY
1134         {
1135             new.Next.Next = entry->Next;
1136             new.Depth = old.Depth - 1;
1137             new.Sequence = old.Sequence + 1;
1138         }
1139         __EXCEPT_PAGE_FAULT
1140         {
1141         }
1142         __ENDTRY
1143     } while (InterlockedCompareExchange64((__int64 *)&list->Alignment, new.Alignment,
1144                                           old.Alignment) != old.Alignment);
1145 #endif
1146     return entry;
1147 }
1148
1149 /*************************************************************************
1150  *           RtlInterlockedPushListSListEx (NTDLL.@)
1151  */
1152 PSLIST_ENTRY WINAPI RtlInterlockedPushListSListEx(PSLIST_HEADER list, PSLIST_ENTRY first,
1153                                                   PSLIST_ENTRY last, ULONG count)
1154 {
1155     SLIST_HEADER old, new;
1156
1157 #ifdef _WIN64
1158     new.Header16.NextEntry = (ULONG_PTR)first >> 4;
1159     do
1160     {
1161         old = *list;
1162         new.Header16.Depth = old.Header16.Depth + count;
1163         new.Header16.Sequence = old.Header16.Sequence + 1;
1164         last->Next = (SLIST_ENTRY *)((ULONG_PTR)old.Header16.NextEntry << 4);
1165     } while (!InterlockedCompareExchange128((__int64 *)list, new.Region, new.Alignment, (__int64 *)&old));
1166     return (SLIST_ENTRY *)((ULONG_PTR)old.Header16.NextEntry << 4);
1167 #else
1168     new.Next.Next = first;
1169     do
1170     {
1171         old = *list;
1172         new.Depth = old.Depth + count;
1173         new.Sequence = old.Sequence + 1;
1174         last->Next = old.Next.Next;
1175     } while (InterlockedCompareExchange64((__int64 *)&list->Alignment, new.Alignment,
1176                                           old.Alignment) != old.Alignment);
1177     return old.Next.Next;
1178 #endif
1179 }
1180
1181 /*************************************************************************
1182  *           RtlInterlockedPushListSList (NTDLL.@)
1183  */
1184 DEFINE_FASTCALL_WRAPPER(RtlInterlockedPushListSList, 16)
1185 PSLIST_ENTRY FASTCALL RtlInterlockedPushListSList(PSLIST_HEADER list, PSLIST_ENTRY first,
1186                                                   PSLIST_ENTRY last, ULONG count)
1187 {
1188     return RtlInterlockedPushListSListEx(list, first, last, count);
1189 }
1190
1191 /***********************************************************************
1192  *           RtlInitializeResource  (NTDLL.@)
1193  *
1194  * xxxResource() functions implement multiple-reader-single-writer lock.
1195  * The code is based on information published in WDJ January 1999 issue.
1196  */
1197 void WINAPI RtlInitializeResource(LPRTL_RWLOCK rwl)
1198 {
1199     if (!rwl) return;
1200     rwl->iNumberActive = 0;
1201     rwl->uExclusiveWaiters = 0;
1202     rwl->uSharedWaiters = 0;
1203     rwl->hOwningThreadId = 0;
1204     rwl->dwTimeoutBoost = 0; /* no info on this one, default value is 0 */
1205     RtlInitializeCriticalSectionEx( &rwl->rtlCS, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
1206     rwl->rtlCS.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RTL_RWLOCK.rtlCS");
1207     NtCreateSemaphore( &rwl->hExclusiveReleaseSemaphore, SEMAPHORE_ALL_ACCESS, NULL, 0, 65535 );
1208     NtCreateSemaphore( &rwl->hSharedReleaseSemaphore, SEMAPHORE_ALL_ACCESS, NULL, 0, 65535 );
1209 }
1210
1211 /***********************************************************************
1212  *           RtlDeleteResource   (NTDLL.@)
1213  */
1214 void WINAPI RtlDeleteResource(LPRTL_RWLOCK rwl)
1215 {
1216     if (!rwl) return;
1217     RtlEnterCriticalSection( &rwl->rtlCS );
1218     if( rwl->iNumberActive || rwl->uExclusiveWaiters || rwl->uSharedWaiters )
1219         ERR("Deleting active MRSW lock (%p), expect failure\n", rwl );
1220     rwl->hOwningThreadId = 0;
1221     rwl->uExclusiveWaiters = rwl->uSharedWaiters = 0;
1222     rwl->iNumberActive = 0;
1223     NtClose( rwl->hExclusiveReleaseSemaphore );
1224     NtClose( rwl->hSharedReleaseSemaphore );
1225     RtlLeaveCriticalSection( &rwl->rtlCS );
1226     rwl->rtlCS.DebugInfo->Spare[0] = 0;
1227     RtlDeleteCriticalSection( &rwl->rtlCS );
1228 }
1229
1230 /***********************************************************************
1231  *          RtlAcquireResourceExclusive (NTDLL.@)
1232  */
1233 BYTE WINAPI RtlAcquireResourceExclusive(LPRTL_RWLOCK rwl, BYTE fWait)
1234 {
1235     BYTE retVal = 0;
1236
1237     if (!rwl) return 0;
1238
1239     for (;;)
1240     {
1241         RtlEnterCriticalSection( &rwl->rtlCS );
1242         if( rwl->iNumberActive == 0 ) /* lock is free */
1243         {
1244             rwl->iNumberActive = -1;
1245             retVal = 1;
1246         }
1247         else if( rwl->iNumberActive < 0 ) /* exclusive lock in progress */
1248         {
1249             if( rwl->hOwningThreadId == ULongToHandle(GetCurrentThreadId()) )
1250             {
1251                 retVal = 1;
1252                 rwl->iNumberActive--;
1253                 break;
1254             }
1255         wait:
1256             if( fWait )
1257             {
1258                 NTSTATUS status;
1259
1260                 rwl->uExclusiveWaiters++;
1261
1262                 RtlLeaveCriticalSection( &rwl->rtlCS );
1263                 status = NtWaitForSingleObject( rwl->hExclusiveReleaseSemaphore, FALSE, NULL );
1264                 if( HIWORD(status) ) break;
1265                 continue; /* restart the acquisition to avoid deadlocks */
1266             }
1267         }
1268         else  /* one or more shared locks are in progress */
1269             if( fWait )
1270                 goto wait;
1271
1272         if( retVal == 1 ) rwl->hOwningThreadId = ULongToHandle(GetCurrentThreadId());
1273         break;
1274     }
1275     RtlLeaveCriticalSection( &rwl->rtlCS );
1276     return retVal;
1277 }
1278
1279 /***********************************************************************
1280  *          RtlAcquireResourceShared  (NTDLL.@)
1281  */
1282 BYTE WINAPI RtlAcquireResourceShared(LPRTL_RWLOCK rwl, BYTE fWait)
1283 {
1284     NTSTATUS status = STATUS_UNSUCCESSFUL;
1285     BYTE retVal = 0;
1286
1287     if (!rwl) return 0;
1288     for (;;)
1289     {
1290         RtlEnterCriticalSection( &rwl->rtlCS );
1291         if( rwl->iNumberActive < 0 )
1292         {
1293             if( rwl->hOwningThreadId == ULongToHandle(GetCurrentThreadId()) )
1294             {
1295                 rwl->iNumberActive--;
1296                 retVal = 1;
1297                 break;
1298             }
1299
1300             if( fWait )
1301             {
1302                 rwl->uSharedWaiters++;
1303                 RtlLeaveCriticalSection( &rwl->rtlCS );
1304                 status = NtWaitForSingleObject( rwl->hSharedReleaseSemaphore, FALSE, NULL );
1305                 if( HIWORD(status) ) break;
1306                 continue;
1307             }
1308         }
1309         else
1310         {
1311             if( status != STATUS_WAIT_0 ) /* otherwise RtlReleaseResource() has already done it */
1312                 rwl->iNumberActive++;
1313             retVal = 1;
1314         }
1315         break;
1316     }
1317     RtlLeaveCriticalSection( &rwl->rtlCS );
1318     return retVal;
1319 }
1320
1321
1322 /***********************************************************************
1323  *           RtlReleaseResource  (NTDLL.@)
1324  */
1325 void WINAPI RtlReleaseResource(LPRTL_RWLOCK rwl)
1326 {
1327     RtlEnterCriticalSection( &rwl->rtlCS );
1328
1329     if( rwl->iNumberActive > 0 ) /* have one or more readers */
1330     {
1331         if( --rwl->iNumberActive == 0 )
1332         {
1333             if( rwl->uExclusiveWaiters )
1334             {
1335                 rwl->uExclusiveWaiters--;
1336                 NtReleaseSemaphore( rwl->hExclusiveReleaseSemaphore, 1, NULL );
1337             }
1338         }
1339     }
1340     else if( rwl->iNumberActive < 0 ) /* have a writer, possibly recursive */
1341     {
1342         if( ++rwl->iNumberActive == 0 )
1343         {
1344             rwl->hOwningThreadId = 0;
1345             if( rwl->uExclusiveWaiters )
1346             {
1347                 rwl->uExclusiveWaiters--;
1348                 NtReleaseSemaphore( rwl->hExclusiveReleaseSemaphore, 1, NULL );
1349             }
1350             else if( rwl->uSharedWaiters )
1351             {
1352                 UINT n = rwl->uSharedWaiters;
1353                 rwl->iNumberActive = rwl->uSharedWaiters; /* prevent new writers from joining until
1354                                                            * all queued readers have done their thing */
1355                 rwl->uSharedWaiters = 0;
1356                 NtReleaseSemaphore( rwl->hSharedReleaseSemaphore, n, NULL );
1357             }
1358         }
1359     }
1360     RtlLeaveCriticalSection( &rwl->rtlCS );
1361 }
1362
1363
1364 /***********************************************************************
1365  *           RtlDumpResource            (NTDLL.@)
1366  */
1367 void WINAPI RtlDumpResource(LPRTL_RWLOCK rwl)
1368 {
1369     if (!rwl) return;
1370     ERR( "%p: active count = %i waiting readers = %i waiting writers = %i owner thread = %p",
1371          rwl, rwl->iNumberActive, rwl->uSharedWaiters, rwl->uExclusiveWaiters, rwl->hOwningThreadId );
1372     ERR( "\n" );
1373 }