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