dlls/ntdll/critsection.c

   1 /*
   2  * Win32 critical sections
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <errno.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <sys/types.h>
  29 #ifdef HAVE_SYS_SYSCALL_H
  30 #include <sys/syscall.h>
  31 #endif
  32 #include <time.h>
  33 #include "ntstatus.h"
  34 #define WIN32_NO_STATUS
  35 #include "windef.h"
  36 #include "winternl.h"
  37 #include "wine/debug.h"
  38 #include "ntdll_misc.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  41 WINE_DECLARE_DEBUG_CHANNEL(relay);
  42
  43 static inline LONG interlocked_inc( PLONG dest )
  44 {
  45     return interlocked_xchg_add( dest, 1 ) + 1;
  46 }
  47
  48 static inline LONG interlocked_dec( PLONG dest )
  49 {
  50     return interlocked_xchg_add( dest, -1 ) - 1;
  51 }
  52
  53 static inline void small_pause(void)
  54 {
  55 #ifdef __i386__
  56     __asm__ __volatile__( "rep;nop" : : : "memory" );
  57 #else
  58     __asm__ __volatile__( "" : : : "memory" );
  59 #endif
  60 }
  61
  62 #ifdef __linux__
  63
  64 static int wait_op = 128; /*FUTEX_WAIT|FUTEX_PRIVATE_FLAG*/
  65 static int wake_op = 129; /*FUTEX_WAKE|FUTEX_PRIVATE_FLAG*/
  66
  67 static inline int futex_wait( int *addr, int val, struct timespec *timeout )
  68 {
  69     return syscall( __NR_futex, addr, wait_op, val, timeout, 0, 0 );
  70 }
  71
  72 static inline int futex_wake( int *addr, int val )
  73 {
  74     return syscall( __NR_futex, addr, wake_op, val, NULL, 0, 0 );
  75 }
  76
  77 static inline int use_futexes(void)
  78 {
  79     static int supported = -1;
  80
  81     if (supported == -1)
  82     {
  83         futex_wait( &supported, 10, NULL );
  84         if (errno == ENOSYS)
  85         {
  86             wait_op = 0; /*FUTEX_WAIT*/
  87             wake_op = 1; /*FUTEX_WAKE*/
  88             futex_wait( &supported, 10, NULL );
  89         }
  90         supported = (errno != ENOSYS);
  91     }
  92     return supported;
  93 }
  94
  95 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
  96 {
  97     int val;
  98     struct timespec timespec;
  99
 100     if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
 101
 102     timespec.tv_sec  = timeout;
 103     timespec.tv_nsec = 0;
 104     while ((val = interlocked_cmpxchg( (int *)&crit->LockSemaphore, 0, 1 )) != 1)
 105     {
 106         /* note: this may wait longer than specified in case of signals or */
 107         /*       multiple wake-ups, but that shouldn't be a problem */
 108         if (futex_wait( (int *)&crit->LockSemaphore, val, &timespec ) == -1 && errno == ETIMEDOUT)
 109             return STATUS_TIMEOUT;
 110     }
 111     return STATUS_WAIT_0;
 112 }
 113
 114 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
 115 {
 116     if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
 117
 118     *(int *)&crit->LockSemaphore = 1;
 119     futex_wake( (int *)&crit->LockSemaphore, 1 );
 120     return STATUS_SUCCESS;
 121 }
 122
 123 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
 124 {
 125     if (!use_futexes()) NtClose( crit->LockSemaphore );
 126 }
 127
 128 #elif defined(__APPLE__)
 129
 130 #include <mach/mach.h>
 131 #include <mach/task.h>
 132 #include <mach/semaphore.h>
 133
 134 static inline semaphore_t get_mach_semaphore( RTL_CRITICAL_SECTION *crit )
 135 {
 136     semaphore_t ret = *(int *)&crit->LockSemaphore;
 137     if (!ret)
 138     {
 139         semaphore_t sem;
 140         if (semaphore_create( mach_task_self(), &sem, SYNC_POLICY_FIFO, 0 )) return 0;
 141         if (!(ret = interlocked_cmpxchg( (int *)&crit->LockSemaphore, sem, 0 )))
 142             ret = sem;
 143         else
 144             semaphore_destroy( mach_task_self(), sem );  /* somebody beat us to it */
 145     }
 146     return ret;
 147 }
 148
 149 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
 150 {
 151     mach_timespec_t timespec;
 152     semaphore_t sem = get_mach_semaphore( crit );
 153
 154     timespec.tv_sec = timeout;
 155     timespec.tv_nsec = 0;
 156     for (;;)
 157     {
 158         switch( semaphore_timedwait( sem, timespec ))
 159         {
 160         case KERN_SUCCESS:
 161             return STATUS_WAIT_0;
 162         case KERN_ABORTED:
 163             continue;  /* got a signal, restart */
 164         case KERN_OPERATION_TIMED_OUT:
 165             return STATUS_TIMEOUT;
 166         default:
 167             return STATUS_INVALID_HANDLE;
 168         }
 169     }
 170 }
 171
 172 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
 173 {
 174     semaphore_t sem = get_mach_semaphore( crit );
 175     semaphore_signal( sem );
 176     return STATUS_SUCCESS;
 177 }
 178
 179 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
 180 {
 181     semaphore_destroy( mach_task_self(), *(int *)&crit->LockSemaphore );
 182 }
 183
 184 #else  /* __APPLE__ */
 185
 186 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
 187 {
 188     return STATUS_NOT_IMPLEMENTED;
 189 }
 190
 191 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
 192 {
 193     return STATUS_NOT_IMPLEMENTED;
 194 }
 195
 196 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
 197 {
 198     NtClose( crit->LockSemaphore );
 199 }
 200
 201 #endif
 202
 203 /***********************************************************************
 204  *           get_semaphore
 205  */
 206 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
 207 {
 208     HANDLE ret = crit->LockSemaphore;
 209     if (!ret)
 210     {
 211         HANDLE sem;
 212         if (NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 )) return 0;
 213         if (!(ret = interlocked_cmpxchg_ptr( &crit->LockSemaphore, sem, 0 )))
 214             ret = sem;
 215         else
 216             NtClose(sem);  /* somebody beat us to it */
 217     }
 218     return ret;
 219 }
 220
 221 /***********************************************************************
 222  *           wait_semaphore
 223  */
 224 static inline NTSTATUS wait_semaphore( RTL_CRITICAL_SECTION *crit, int timeout )
 225 {
 226     NTSTATUS ret;
 227
 228     /* debug info is cleared by MakeCriticalSectionGlobal */
 229     if (!crit->DebugInfo || ((ret = fast_wait( crit, timeout )) == STATUS_NOT_IMPLEMENTED))
 230     {
 231         HANDLE sem = get_semaphore( crit );
 232         LARGE_INTEGER time;
 233         select_op_t select_op;
 234
 235         time.QuadPart = timeout * (LONGLONG)-10000000;
 236         select_op.wait.op = SELECT_WAIT;
 237         select_op.wait.handles[0] = wine_server_obj_handle( sem );
 238         ret = server_select( &select_op, offsetof( select_op_t, wait.handles[1] ), 0, &time );
 239     }
 240     return ret;
 241 }
 242
 243 /***********************************************************************
 244  *           RtlInitializeCriticalSection   (NTDLL.@)
 245  *
 246  * Initialises a new critical section.
 247  *
 248  * PARAMS
 249  *  crit [O] Critical section to initialise
 250  *
 251  * RETURNS
 252  *  STATUS_SUCCESS.
 253  *
 254  * SEE
 255  *  RtlInitializeCriticalSectionEx(),
 256  *  RtlInitializeCriticalSectionAndSpinCount(), RtlDeleteCriticalSection(),
 257  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
 258  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
 259  */
 260 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
 261 {
 262     return RtlInitializeCriticalSectionEx( crit, 0, 0 );
 263 }
 264
 265 /***********************************************************************
 266  *           RtlInitializeCriticalSectionAndSpinCount   (NTDLL.@)
 267  *
 268  * Initialises a new critical section with a given spin count.
 269  *
 270  * PARAMS
 271  *   crit      [O] Critical section to initialise
 272  *   spincount [I] Spin count for crit
 273  *
 274  * RETURNS
 275  *  STATUS_SUCCESS.
 276  *
 277  * NOTES
 278  *  Available on NT4 SP3 or later.
 279  *
 280  * SEE
 281  *  RtlInitializeCriticalSectionEx(),
 282  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
 283  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
 284  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
 285  */
 286 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 287 {
 288     return RtlInitializeCriticalSectionEx( crit, spincount, 0 );
 289 }
 290
 291 /***********************************************************************
 292  *           RtlInitializeCriticalSectionEx   (NTDLL.@)
 293  *
 294  * Initialises a new critical section with a given spin count and flags.
 295  *
 296  * PARAMS
 297  *   crit      [O] Critical section to initialise.
 298  *   spincount [I] Number of times to spin upon contention.
 299  *   flags     [I] RTL_CRITICAL_SECTION_FLAG_ flags from winnt.h.
 300  *
 301  * RETURNS
 302  *  STATUS_SUCCESS.
 303  *
 304  * NOTES
 305  *  Available on Vista or later.
 306  *
 307  * SEE
 308  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
 309  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
 310  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
 311  */
 312 NTSTATUS WINAPI RtlInitializeCriticalSectionEx( RTL_CRITICAL_SECTION *crit, ULONG spincount, ULONG flags )
 313 {
 314     if (flags & (RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN|RTL_CRITICAL_SECTION_FLAG_STATIC_INIT))
 315         FIXME("(%p,%u,0x%08x) semi-stub\n", crit, spincount, flags);
 316
 317     /* FIXME: if RTL_CRITICAL_SECTION_FLAG_STATIC_INIT is given, we should use
 318      * memory from a static pool to hold the debug info. Then heap.c could pass
 319      * this flag rather than initialising the process heap CS by hand. If this
 320      * is done, then debug info should be managed through Rtlp[Allocate|Free]DebugInfo
 321      * so (e.g.) MakeCriticalSectionGlobal() doesn't free it using HeapFree().
 322      */
 323     if (flags & RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO)
 324         crit->DebugInfo = NULL;
 325     else
 326         crit->DebugInfo = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_CRITICAL_SECTION_DEBUG));
 327
 328     if (crit->DebugInfo)
 329     {
 330         crit->DebugInfo->Type = 0;
 331         crit->DebugInfo->CreatorBackTraceIndex = 0;
 332         crit->DebugInfo->CriticalSection = crit;
 333         crit->DebugInfo->ProcessLocksList.Blink = &(crit->DebugInfo->ProcessLocksList);
 334         crit->DebugInfo->ProcessLocksList.Flink = &(crit->DebugInfo->ProcessLocksList);
 335         crit->DebugInfo->EntryCount = 0;
 336         crit->DebugInfo->ContentionCount = 0;
 337         memset( crit->DebugInfo->Spare, 0, sizeof(crit->DebugInfo->Spare) );
 338     }
 339     crit->LockCount      = -1;
 340     crit->RecursionCount = 0;
 341     crit->OwningThread   = 0;
 342     crit->LockSemaphore  = 0;
 343     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 344     crit->SpinCount = spincount & ~0x80000000;
 345     return STATUS_SUCCESS;
 346 }
 347
 348 /***********************************************************************
 349  *           RtlSetCriticalSectionSpinCount   (NTDLL.@)
 350  *
 351  * Sets the spin count of a critical section.
 352  *
 353  * PARAMS
 354  *   crit      [I/O] Critical section
 355  *   spincount [I] Spin count for crit
 356  *
 357  * RETURNS
 358  *  The previous spin count.
 359  *
 360  * NOTES
 361  *  If the system is not SMP, spincount is ignored and set to 0.
 362  *
 363  * SEE
 364  *  RtlInitializeCriticalSectionEx(),
 365  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 366  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 367  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 368  */
 369 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 370 {
 371     ULONG oldspincount = crit->SpinCount;
 372     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 373     crit->SpinCount = spincount;
 374     return oldspincount;
 375 }
 376
 377 /***********************************************************************
 378  *           RtlDeleteCriticalSection   (NTDLL.@)
 379  *
 380  * Frees the resources used by a critical section.
 381  *
 382  * PARAMS
 383  *  crit [I/O] Critical section to free
 384  *
 385  * RETURNS
 386  *  STATUS_SUCCESS.
 387  *
 388  * SEE
 389  *  RtlInitializeCriticalSectionEx(),
 390  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 391  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 392  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 393  */
 394 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
 395 {
 396     crit->LockCount      = -1;
 397     crit->RecursionCount = 0;
 398     crit->OwningThread   = 0;
 399     if (crit->DebugInfo)
 400     {
 401         /* only free the ones we made in here */
 402         if (!crit->DebugInfo->Spare[0])
 403         {
 404             RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 405             crit->DebugInfo = NULL;
 406         }
 407         close_semaphore( crit );
 408     }
 409     else NtClose( crit->LockSemaphore );
 410     crit->LockSemaphore = 0;
 411     return STATUS_SUCCESS;
 412 }
 413
 414
 415 /***********************************************************************
 416  *           RtlpWaitForCriticalSection   (NTDLL.@)
 417  *
 418  * Waits for a busy critical section to become free.
 419  *
 420  * PARAMS
 421  *  crit [I/O] Critical section to wait for
 422  *
 423  * RETURNS
 424  *  STATUS_SUCCESS.
 425  *
 426  * NOTES
 427  *  Use RtlEnterCriticalSection() instead of this function as it is often much
 428  *  faster.
 429  *
 430  * SEE
 431  *  RtlInitializeCriticalSectionEx(),
 432  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 433  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 434  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 435  */
 436 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
 437 {
 438     LONGLONG timeout = NtCurrentTeb()->Peb->CriticalSectionTimeout.QuadPart / -10000000;
 439     for (;;)
 440     {
 441         EXCEPTION_RECORD rec;
 442         NTSTATUS status = wait_semaphore( crit, 5 );
 443         timeout -= 5;
 444
 445         if ( status == STATUS_TIMEOUT )
 446         {
 447             const char *name = NULL;
 448             if (crit->DebugInfo) name = (char *)crit->DebugInfo->Spare[0];
 449             if (!name) name = "?";
 450             ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (60 sec)\n",
 451                  crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
 452             status = wait_semaphore( crit, 60 );
 453             timeout -= 60;
 454
 455             if ( status == STATUS_TIMEOUT && TRACE_ON(relay) )
 456             {
 457                 ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (5 min)\n",
 458                      crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
 459                 status = wait_semaphore( crit, 300 );
 460                 timeout -= 300;
 461             }
 462         }
 463         if (status == STATUS_WAIT_0) break;
 464
 465         /* Throw exception only for Wine internal locks */
 466         if ((!crit->DebugInfo) || (!crit->DebugInfo->Spare[0])) continue;
 467
 468         /* only throw deadlock exception if configured timeout is reached */
 469         if (timeout > 0) continue;
 470
 471         rec.ExceptionCode    = STATUS_POSSIBLE_DEADLOCK;
 472         rec.ExceptionFlags   = 0;
 473         rec.ExceptionRecord  = NULL;
 474         rec.ExceptionAddress = RtlRaiseException;  /* sic */
 475         rec.NumberParameters = 1;
 476         rec.ExceptionInformation[0] = (ULONG_PTR)crit;
 477         RtlRaiseException( &rec );
 478     }
 479     if (crit->DebugInfo) crit->DebugInfo->ContentionCount++;
 480     return STATUS_SUCCESS;
 481 }
 482
 483
 484 /***********************************************************************
 485  *           RtlpUnWaitCriticalSection   (NTDLL.@)
 486  *
 487  * Notifies other threads waiting on the busy critical section that it has
 488  * become free.
 489  *
 490  * PARAMS
 491  *  crit [I/O] Critical section
 492  *
 493  * RETURNS
 494  *  Success: STATUS_SUCCESS.
 495  *  Failure: Any error returned by NtReleaseSemaphore()
 496  *
 497  * NOTES
 498  *  Use RtlLeaveCriticalSection() instead of this function as it is often much
 499  *  faster.
 500  *
 501  * SEE
 502  *  RtlInitializeCriticalSectionEx(),
 503  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 504  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 505  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 506  */
 507 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
 508 {
 509     NTSTATUS ret;
 510
 511     /* debug info is cleared by MakeCriticalSectionGlobal */
 512     if (!crit->DebugInfo || ((ret = fast_wake( crit )) == STATUS_NOT_IMPLEMENTED))
 513     {
 514         HANDLE sem = get_semaphore( crit );
 515         ret = NtReleaseSemaphore( sem, 1, NULL );
 516     }
 517     if (ret) RtlRaiseStatus( ret );
 518     return ret;
 519 }
 520
 521
 522 /***********************************************************************
 523  *           RtlEnterCriticalSection   (NTDLL.@)
 524  *
 525  * Enters a critical section, waiting for it to become available if necessary.
 526  *
 527  * PARAMS
 528  *  crit [I/O] Critical section to enter
 529  *
 530  * RETURNS
 531  *  STATUS_SUCCESS. The critical section is held by the caller.
 532  *
 533  * SEE
 534  *  RtlInitializeCriticalSectionEx(),
 535  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 536  *  RtlDeleteCriticalSection(), RtlSetCriticalSectionSpinCount(),
 537  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 538  */
 539 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 540 {
 541     if (crit->SpinCount)
 542     {
 543         ULONG count;
 544
 545         if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
 546         for (count = crit->SpinCount; count > 0; count--)
 547         {
 548             if (crit->LockCount > 0) break;  /* more than one waiter, don't bother spinning */
 549             if (crit->LockCount == -1)       /* try again */
 550             {
 551                 if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1) goto done;
 552             }
 553             small_pause();
 554         }
 555     }
 556
 557     if (interlocked_inc( &crit->LockCount ))
 558     {
 559         if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
 560         {
 561             crit->RecursionCount++;
 562             return STATUS_SUCCESS;
 563         }
 564
 565         /* Now wait for it */
 566         RtlpWaitForCriticalSection( crit );
 567     }
 568 done:
 569     crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
 570     crit->RecursionCount = 1;
 571     return STATUS_SUCCESS;
 572 }
 573
 574
 575 /***********************************************************************
 576  *           RtlTryEnterCriticalSection   (NTDLL.@)
 577  *
 578  * Tries to enter a critical section without waiting.
 579  *
 580  * PARAMS
 581  *  crit [I/O] Critical section to enter
 582  *
 583  * RETURNS
 584  *  Success: TRUE. The critical section is held by the caller.
 585  *  Failure: FALSE. The critical section is currently held by another thread.
 586  *
 587  * SEE
 588  *  RtlInitializeCriticalSectionEx(),
 589  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 590  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 591  *  RtlLeaveCriticalSection(), RtlSetCriticalSectionSpinCount()
 592  */
 593 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 594 {
 595     BOOL ret = FALSE;
 596     if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1)
 597     {
 598         crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
 599         crit->RecursionCount = 1;
 600         ret = TRUE;
 601     }
 602     else if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
 603     {
 604         interlocked_inc( &crit->LockCount );
 605         crit->RecursionCount++;
 606         ret = TRUE;
 607     }
 608     return ret;
 609 }
 610
 611
 612 /***********************************************************************
 613  *           RtlIsCriticalSectionLocked   (NTDLL.@)
 614  *
 615  * Checks if the critical section is locked by any thread.
 616  *
 617  * PARAMS
 618  *  crit [I/O] Critical section to check.
 619  *
 620  * RETURNS
 621  *  Success: TRUE. The critical section is locked.
 622  *  Failure: FALSE. The critical section is not locked.
 623  */
 624 BOOL WINAPI RtlIsCriticalSectionLocked( RTL_CRITICAL_SECTION *crit )
 625 {
 626     return crit->RecursionCount != 0;
 627 }
 628
 629
 630 /***********************************************************************
 631  *           RtlIsCriticalSectionLockedByThread   (NTDLL.@)
 632  *
 633  * Checks if the critical section is locked by the current thread.
 634  *
 635  * PARAMS
 636  *  crit [I/O] Critical section to check.
 637  *
 638  * RETURNS
 639  *  Success: TRUE. The critical section is locked.
 640  *  Failure: FALSE. The critical section is not locked.
 641  */
 642 BOOL WINAPI RtlIsCriticalSectionLockedByThread( RTL_CRITICAL_SECTION *crit )
 643 {
 644     return crit->OwningThread == ULongToHandle(GetCurrentThreadId()) &&
 645            crit->RecursionCount;
 646 }
 647
 648
 649 /***********************************************************************
 650  *           RtlLeaveCriticalSection   (NTDLL.@)
 651  *
 652  * Leaves a critical section.
 653  *
 654  * PARAMS
 655  *  crit [I/O] Critical section to leave.
 656  *
 657  * RETURNS
 658  *  STATUS_SUCCESS.
 659  *
 660  * SEE
 661  *  RtlInitializeCriticalSectionEx(),
 662  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 663  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 664  *  RtlSetCriticalSectionSpinCount(), RtlTryEnterCriticalSection()
 665  */
 666 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
 667 {
 668     if (--crit->RecursionCount)
 669     {
 670         if (crit->RecursionCount > 0) interlocked_dec( &crit->LockCount );
 671         else ERR( "section %p is not acquired\n", crit );
 672     }
 673     else
 674     {
 675         crit->OwningThread = 0;
 676         if (interlocked_dec( &crit->LockCount ) >= 0)
 677         {
 678             /* someone is waiting */
 679             RtlpUnWaitCriticalSection( crit );
 680         }
 681     }
 682     return STATUS_SUCCESS;
 683 }