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 <assert.h>
  22 #include <errno.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <sys/types.h>
  26 #include <time.h>
  27 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29 #include "windef.h"
  30 #include "winternl.h"
  31 #include "wine/debug.h"
  32 #include "ntdll_misc.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  35 WINE_DECLARE_DEBUG_CHANNEL(relay);
  36
  37 static inline void small_pause(void)
  38 {
  39 #ifdef __i386__
  40     __asm__ __volatile__( "rep;nop" : : : "memory" );
  41 #else
  42     __asm__ __volatile__( "" : : : "memory" );
  43 #endif
  44 }
  45
  46 static void *no_debug_info_marker = (void *)(ULONG_PTR)-1;
  47
  48 static BOOL crit_section_has_debuginfo(const RTL_CRITICAL_SECTION *crit)
  49 {
  50     return crit->DebugInfo != NULL && crit->DebugInfo != no_debug_info_marker;
  51 }
  52
  53 /***********************************************************************
  54  *           RtlInitializeCriticalSection   (NTDLL.@)
  55  *
  56  * Initialises a new critical section.
  57  *
  58  * PARAMS
  59  *  crit [O] Critical section to initialise
  60  *
  61  * RETURNS
  62  *  STATUS_SUCCESS.
  63  *
  64  * SEE
  65  *  RtlInitializeCriticalSectionEx(),
  66  *  RtlInitializeCriticalSectionAndSpinCount(), RtlDeleteCriticalSection(),
  67  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
  68  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
  69  */
  70 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
  71 {
  72     return RtlInitializeCriticalSectionEx( crit, 0, 0 );
  73 }
  74
  75 /***********************************************************************
  76  *           RtlInitializeCriticalSectionAndSpinCount   (NTDLL.@)
  77  *
  78  * Initialises a new critical section with a given spin count.
  79  *
  80  * PARAMS
  81  *   crit      [O] Critical section to initialise
  82  *   spincount [I] Spin count for crit
  83  *
  84  * RETURNS
  85  *  STATUS_SUCCESS.
  86  *
  87  * NOTES
  88  *  Available on NT4 SP3 or later.
  89  *
  90  * SEE
  91  *  RtlInitializeCriticalSectionEx(),
  92  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
  93  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
  94  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
  95  */
  96 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
  97 {
  98     return RtlInitializeCriticalSectionEx( crit, spincount, 0 );
  99 }
 100
 101 /***********************************************************************
 102  *           RtlInitializeCriticalSectionEx   (NTDLL.@)
 103  *
 104  * Initialises a new critical section with a given spin count and flags.
 105  *
 106  * PARAMS
 107  *   crit      [O] Critical section to initialise.
 108  *   spincount [I] Number of times to spin upon contention.
 109  *   flags     [I] RTL_CRITICAL_SECTION_FLAG_ flags from winnt.h.
 110  *
 111  * RETURNS
 112  *  STATUS_SUCCESS.
 113  *
 114  * NOTES
 115  *  Available on Vista or later.
 116  *
 117  * SEE
 118  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
 119  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
 120  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
 121  */
 122 NTSTATUS WINAPI RtlInitializeCriticalSectionEx( RTL_CRITICAL_SECTION *crit, ULONG spincount, ULONG flags )
 123 {
 124     if (flags & (RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN|RTL_CRITICAL_SECTION_FLAG_STATIC_INIT))
 125         FIXME("(%p,%u,0x%08x) semi-stub\n", crit, spincount, flags);
 126
 127     /* FIXME: if RTL_CRITICAL_SECTION_FLAG_STATIC_INIT is given, we should use
 128      * memory from a static pool to hold the debug info. Then heap.c could pass
 129      * this flag rather than initialising the process heap CS by hand. If this
 130      * is done, then debug info should be managed through Rtlp[Allocate|Free]DebugInfo
 131      * so (e.g.) MakeCriticalSectionGlobal() doesn't free it using HeapFree().
 132      */
 133     if (flags & RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO)
 134         crit->DebugInfo = no_debug_info_marker;
 135     else
 136     {
 137         crit->DebugInfo = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_CRITICAL_SECTION_DEBUG));
 138         if (crit->DebugInfo)
 139         {
 140             crit->DebugInfo->Type = 0;
 141             crit->DebugInfo->CreatorBackTraceIndex = 0;
 142             crit->DebugInfo->CriticalSection = crit;
 143             crit->DebugInfo->ProcessLocksList.Blink = &(crit->DebugInfo->ProcessLocksList);
 144             crit->DebugInfo->ProcessLocksList.Flink = &(crit->DebugInfo->ProcessLocksList);
 145             crit->DebugInfo->EntryCount = 0;
 146             crit->DebugInfo->ContentionCount = 0;
 147             memset( crit->DebugInfo->Spare, 0, sizeof(crit->DebugInfo->Spare) );
 148         }
 149     }
 150     crit->LockCount      = -1;
 151     crit->RecursionCount = 0;
 152     crit->OwningThread   = 0;
 153     crit->LockSemaphore  = 0;
 154     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 155     crit->SpinCount = spincount & ~0x80000000;
 156     return STATUS_SUCCESS;
 157 }
 158
 159 /***********************************************************************
 160  *           RtlSetCriticalSectionSpinCount   (NTDLL.@)
 161  *
 162  * Sets the spin count of a critical section.
 163  *
 164  * PARAMS
 165  *   crit      [I/O] Critical section
 166  *   spincount [I] Spin count for crit
 167  *
 168  * RETURNS
 169  *  The previous spin count.
 170  *
 171  * NOTES
 172  *  If the system is not SMP, spincount is ignored and set to 0.
 173  *
 174  * SEE
 175  *  RtlInitializeCriticalSectionEx(),
 176  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 177  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 178  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 179  */
 180 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 181 {
 182     ULONG oldspincount = crit->SpinCount;
 183     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 184     crit->SpinCount = spincount;
 185     return oldspincount;
 186 }
 187
 188 /***********************************************************************
 189  *           RtlDeleteCriticalSection   (NTDLL.@)
 190  *
 191  * Frees the resources used by a critical section.
 192  *
 193  * PARAMS
 194  *  crit [I/O] Critical section to free
 195  *
 196  * RETURNS
 197  *  STATUS_SUCCESS.
 198  *
 199  * SEE
 200  *  RtlInitializeCriticalSectionEx(),
 201  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 202  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 203  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 204  */
 205 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
 206 {
 207     crit->LockCount      = -1;
 208     crit->RecursionCount = 0;
 209     crit->OwningThread   = 0;
 210     if (crit_section_has_debuginfo( crit ))
 211     {
 212         /* only free the ones we made in here */
 213         if (!crit->DebugInfo->Spare[0])
 214         {
 215             RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 216             crit->DebugInfo = NULL;
 217         }
 218         if (unix_funcs->fast_RtlDeleteCriticalSection( crit ) == STATUS_NOT_IMPLEMENTED)
 219             NtClose( crit->LockSemaphore );
 220     }
 221     else NtClose( crit->LockSemaphore );
 222     crit->LockSemaphore = 0;
 223     return STATUS_SUCCESS;
 224 }
 225
 226
 227 /***********************************************************************
 228  *           RtlpWaitForCriticalSection   (NTDLL.@)
 229  *
 230  * Waits for a busy critical section to become free.
 231  *
 232  * PARAMS
 233  *  crit [I/O] Critical section to wait for
 234  *
 235  * RETURNS
 236  *  STATUS_SUCCESS.
 237  *
 238  * NOTES
 239  *  Use RtlEnterCriticalSection() instead of this function as it is often much
 240  *  faster.
 241  *
 242  * SEE
 243  *  RtlInitializeCriticalSectionEx(),
 244  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 245  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 246  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 247  */
 248 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
 249 {
 250     LONGLONG timeout = NtCurrentTeb()->Peb->CriticalSectionTimeout.QuadPart / -10000000;
 251
 252     /* Don't allow blocking on a critical section during process termination */
 253     if (RtlDllShutdownInProgress())
 254     {
 255         WARN( "process %s is shutting down, returning STATUS_SUCCESS\n",
 256               debugstr_w(NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer) );
 257         return STATUS_SUCCESS;
 258     }
 259
 260     for (;;)
 261     {
 262         EXCEPTION_RECORD rec;
 263         NTSTATUS status = unix_funcs->fast_RtlpWaitForCriticalSection( crit, 5 );
 264         timeout -= 5;
 265
 266         if ( status == STATUS_TIMEOUT )
 267         {
 268             const char *name = NULL;
 269             if (crit_section_has_debuginfo( crit )) name = (char *)crit->DebugInfo->Spare[0];
 270             if (!name) name = "?";
 271             ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (60 sec)\n",
 272                  crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
 273             status = unix_funcs->fast_RtlpWaitForCriticalSection( crit, 60 );
 274             timeout -= 60;
 275
 276             if ( status == STATUS_TIMEOUT && TRACE_ON(relay) )
 277             {
 278                 ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (5 min)\n",
 279                      crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
 280                 status = unix_funcs->fast_RtlpWaitForCriticalSection( crit, 300 );
 281                 timeout -= 300;
 282             }
 283         }
 284         if (status == STATUS_WAIT_0) break;
 285
 286         /* Throw exception only for Wine internal locks */
 287         if (!crit_section_has_debuginfo( crit ) || !crit->DebugInfo->Spare[0]) continue;
 288
 289         /* only throw deadlock exception if configured timeout is reached */
 290         if (timeout > 0) continue;
 291
 292         rec.ExceptionCode    = STATUS_POSSIBLE_DEADLOCK;
 293         rec.ExceptionFlags   = 0;
 294         rec.ExceptionRecord  = NULL;
 295         rec.ExceptionAddress = RtlRaiseException;  /* sic */
 296         rec.NumberParameters = 1;
 297         rec.ExceptionInformation[0] = (ULONG_PTR)crit;
 298         RtlRaiseException( &rec );
 299     }
 300     if (crit_section_has_debuginfo( crit )) crit->DebugInfo->ContentionCount++;
 301     return STATUS_SUCCESS;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           RtlpUnWaitCriticalSection   (NTDLL.@)
 307  *
 308  * Notifies other threads waiting on the busy critical section that it has
 309  * become free.
 310  *
 311  * PARAMS
 312  *  crit [I/O] Critical section
 313  *
 314  * RETURNS
 315  *  Success: STATUS_SUCCESS.
 316  *  Failure: Any error returned by NtReleaseSemaphore()
 317  *
 318  * NOTES
 319  *  Use RtlLeaveCriticalSection() instead of this function as it is often much
 320  *  faster.
 321  *
 322  * SEE
 323  *  RtlInitializeCriticalSectionEx(),
 324  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 325  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 326  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 327  */
 328 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
 329 {
 330     NTSTATUS ret = unix_funcs->fast_RtlpUnWaitCriticalSection( crit );
 331
 332     if (ret) RtlRaiseStatus( ret );
 333     return ret;
 334 }
 335
 336
 337 /***********************************************************************
 338  *           RtlEnterCriticalSection   (NTDLL.@)
 339  *
 340  * Enters a critical section, waiting for it to become available if necessary.
 341  *
 342  * PARAMS
 343  *  crit [I/O] Critical section to enter
 344  *
 345  * RETURNS
 346  *  STATUS_SUCCESS. The critical section is held by the caller.
 347  *
 348  * SEE
 349  *  RtlInitializeCriticalSectionEx(),
 350  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 351  *  RtlDeleteCriticalSection(), RtlSetCriticalSectionSpinCount(),
 352  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 353  */
 354 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 355 {
 356     if (crit->SpinCount)
 357     {
 358         ULONG count;
 359
 360         if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
 361         for (count = crit->SpinCount; count > 0; count--)
 362         {
 363             if (crit->LockCount > 0) break;  /* more than one waiter, don't bother spinning */
 364             if (crit->LockCount == -1)       /* try again */
 365             {
 366                 if (InterlockedCompareExchange( &crit->LockCount, 0, -1 ) == -1) goto done;
 367             }
 368             small_pause();
 369         }
 370     }
 371
 372     if (InterlockedIncrement( &crit->LockCount ))
 373     {
 374         if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
 375         {
 376             crit->RecursionCount++;
 377             return STATUS_SUCCESS;
 378         }
 379
 380         /* Now wait for it */
 381         RtlpWaitForCriticalSection( crit );
 382     }
 383 done:
 384     crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
 385     crit->RecursionCount = 1;
 386     return STATUS_SUCCESS;
 387 }
 388
 389
 390 /***********************************************************************
 391  *           RtlTryEnterCriticalSection   (NTDLL.@)
 392  *
 393  * Tries to enter a critical section without waiting.
 394  *
 395  * PARAMS
 396  *  crit [I/O] Critical section to enter
 397  *
 398  * RETURNS
 399  *  Success: TRUE. The critical section is held by the caller.
 400  *  Failure: FALSE. The critical section is currently held by another thread.
 401  *
 402  * SEE
 403  *  RtlInitializeCriticalSectionEx(),
 404  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 405  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 406  *  RtlLeaveCriticalSection(), RtlSetCriticalSectionSpinCount()
 407  */
 408 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 409 {
 410     BOOL ret = FALSE;
 411     if (InterlockedCompareExchange( &crit->LockCount, 0, -1 ) == -1)
 412     {
 413         crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
 414         crit->RecursionCount = 1;
 415         ret = TRUE;
 416     }
 417     else if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
 418     {
 419         InterlockedIncrement( &crit->LockCount );
 420         crit->RecursionCount++;
 421         ret = TRUE;
 422     }
 423     return ret;
 424 }
 425
 426
 427 /***********************************************************************
 428  *           RtlIsCriticalSectionLocked   (NTDLL.@)
 429  *
 430  * Checks if the critical section is locked by any thread.
 431  *
 432  * PARAMS
 433  *  crit [I/O] Critical section to check.
 434  *
 435  * RETURNS
 436  *  Success: TRUE. The critical section is locked.
 437  *  Failure: FALSE. The critical section is not locked.
 438  */
 439 BOOL WINAPI RtlIsCriticalSectionLocked( RTL_CRITICAL_SECTION *crit )
 440 {
 441     return crit->RecursionCount != 0;
 442 }
 443
 444
 445 /***********************************************************************
 446  *           RtlIsCriticalSectionLockedByThread   (NTDLL.@)
 447  *
 448  * Checks if the critical section is locked by the current thread.
 449  *
 450  * PARAMS
 451  *  crit [I/O] Critical section to check.
 452  *
 453  * RETURNS
 454  *  Success: TRUE. The critical section is locked.
 455  *  Failure: FALSE. The critical section is not locked.
 456  */
 457 BOOL WINAPI RtlIsCriticalSectionLockedByThread( RTL_CRITICAL_SECTION *crit )
 458 {
 459     return crit->OwningThread == ULongToHandle(GetCurrentThreadId()) &&
 460            crit->RecursionCount;
 461 }
 462
 463
 464 /***********************************************************************
 465  *           RtlLeaveCriticalSection   (NTDLL.@)
 466  *
 467  * Leaves a critical section.
 468  *
 469  * PARAMS
 470  *  crit [I/O] Critical section to leave.
 471  *
 472  * RETURNS
 473  *  STATUS_SUCCESS.
 474  *
 475  * SEE
 476  *  RtlInitializeCriticalSectionEx(),
 477  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 478  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 479  *  RtlSetCriticalSectionSpinCount(), RtlTryEnterCriticalSection()
 480  */
 481 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
 482 {
 483     if (--crit->RecursionCount)
 484     {
 485         if (crit->RecursionCount > 0) InterlockedDecrement( &crit->LockCount );
 486         else ERR( "section %p is not acquired\n", crit );
 487     }
 488     else
 489     {
 490         crit->OwningThread = 0;
 491         if (InterlockedDecrement( &crit->LockCount ) >= 0)
 492         {
 493             /* someone is waiting */
 494             RtlpUnWaitCriticalSection( crit );
 495         }
 496     }
 497     return STATUS_SUCCESS;
 498 }