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