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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <sys/types.h>
  28 #include "winerror.h"
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winreg.h"
  32 #include "winternl.h"
  33 #include "wine/debug.h"
  34 #include "ntdll_misc.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  37 WINE_DECLARE_DEBUG_CHANNEL(relay);
  38
  39 inline static LONG interlocked_inc( PLONG dest )
  40 {
  41     return interlocked_xchg_add( dest, 1 ) + 1;
  42 }
  43
  44 inline static LONG interlocked_dec( PLONG dest )
  45 {
  46     return interlocked_xchg_add( dest, -1 ) - 1;
  47 }
  48
  49 inline static void small_pause(void)
  50 {
  51 #ifdef __i386__
  52     __asm__ __volatile__( "rep;nop" : : : "memory" );
  53 #else
  54     __asm__ __volatile__( "" : : : "memory" );
  55 #endif
  56 }
  57
  58 /***********************************************************************
  59  *           get_semaphore
  60  */
  61 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
  62 {
  63     HANDLE ret = crit->LockSemaphore;
  64     if (!ret)
  65     {
  66         HANDLE sem;
  67         if (NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 )) return 0;
  68         if (!(ret = (HANDLE)interlocked_cmpxchg_ptr( (PVOID *)&crit->LockSemaphore,
  69                                                      (PVOID)sem, 0 )))
  70             ret = sem;
  71         else
  72             NtClose(sem);  /* somebody beat us to it */
  73     }
  74     return ret;
  75 }
  76
  77 /***********************************************************************
  78  *           RtlInitializeCriticalSection   (NTDLL.@)
  79  *
  80  * Initialises a new critical section.
  81  *
  82  * PARAMS
  83  *  crit [O] Critical section to initialise
  84  *
  85  * RETURNS
  86  *  STATUS_SUCCESS.
  87  *
  88  * SEE
  89  *  RtlInitializeCriticalSectionAndSpinCount(), RtlDeleteCriticalSection(),
  90  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
  91  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
  92  */
  93 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
  94 {
  95     return RtlInitializeCriticalSectionAndSpinCount( crit, 0 );
  96 }
  97
  98 /***********************************************************************
  99  *           RtlInitializeCriticalSectionAndSpinCount   (NTDLL.@)
 100  *
 101  * Initialises a new critical section with a given spin count.
 102  *
 103  * PARAMS
 104  *   crit      [O] Critical section to initialise
 105  *   spincount [I] Spin count for crit
 106  *
 107  * RETURNS
 108  *  STATUS_SUCCESS.
 109  *
 110  * NOTES
 111  *  Available on NT4 SP3 or later.
 112  *
 113  * SEE
 114  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
 115  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
 116  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
 117  */
 118 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 119 {
 120     if (!GetProcessHeap()) crit->DebugInfo = NULL;
 121     else
 122     {
 123         crit->DebugInfo = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(CRITICAL_SECTION_DEBUG));
 124         if (crit->DebugInfo)
 125         {
 126             crit->DebugInfo->Type = 0;
 127             crit->DebugInfo->CreatorBackTraceIndex = 0;
 128             crit->DebugInfo->CriticalSection = crit;
 129             crit->DebugInfo->ProcessLocksList.Blink = &(crit->DebugInfo->ProcessLocksList);
 130             crit->DebugInfo->ProcessLocksList.Flink = &(crit->DebugInfo->ProcessLocksList);
 131             crit->DebugInfo->EntryCount = 0;
 132             crit->DebugInfo->ContentionCount = 0;
 133             crit->DebugInfo->Spare[0] = 0;
 134             crit->DebugInfo->Spare[1] = 0;
 135         }
 136     }
 137     crit->LockCount      = -1;
 138     crit->RecursionCount = 0;
 139     crit->OwningThread   = 0;
 140     crit->LockSemaphore  = 0;
 141     crit->SpinCount      = spincount;
 142     return STATUS_SUCCESS;
 143 }
 144
 145 /***********************************************************************
 146  *           RtlSetCriticalSectionSpinCount   (NTDLL.@)
 147  *
 148  * Sets the spin count of a critical section.
 149  *
 150  * PARAMS
 151  *   crit      [I/O] Critical section
 152  *   spincount [I] Spin count for crit
 153  *
 154  * RETURNS
 155  *  The previous spin count.
 156  *
 157  * NOTES
 158  *  If the system is not SMP, spincount is ignored and set to 0.
 159  *
 160  * SEE
 161  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 162  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 163  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 164  */
 165 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
 166 {
 167     ULONG oldspincount = crit->SpinCount;
 168     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
 169     crit->SpinCount = spincount;
 170     return oldspincount;
 171 }
 172
 173 /***********************************************************************
 174  *           RtlDeleteCriticalSection   (NTDLL.@)
 175  *
 176  * Frees the resources used by a critical section.
 177  *
 178  * PARAMS
 179  *  crit [I/O] Critical section to free
 180  *
 181  * RETURNS
 182  *  STATUS_SUCCESS.
 183  *
 184  * SEE
 185  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 186  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 187  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 188  */
 189 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
 190 {
 191     crit->LockCount      = -1;
 192     crit->RecursionCount = 0;
 193     crit->OwningThread   = 0;
 194     if (crit->LockSemaphore) NtClose( crit->LockSemaphore );
 195     crit->LockSemaphore  = 0;
 196     if (crit->DebugInfo)
 197     {
 198         /* only free the ones we made in here */
 199         if (!crit->DebugInfo->Spare[1])
 200         {
 201             RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 202             crit->DebugInfo = NULL;
 203         }
 204     }
 205     return STATUS_SUCCESS;
 206 }
 207
 208
 209 /***********************************************************************
 210  *           RtlpWaitForCriticalSection   (NTDLL.@)
 211  *
 212  * Waits for a busy critical section to become free.
 213  *
 214  * PARAMS
 215  *  crit [I/O] Critical section to wait for
 216  *
 217  * RETURNS
 218  *  STATUS_SUCCESS.
 219  *
 220  * NOTES
 221  *  Use RtlEnterCriticalSection() instead of this function as it is often much
 222  *  faster.
 223  *
 224  * SEE
 225  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 226  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 227  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 228  */
 229 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
 230 {
 231     for (;;)
 232     {
 233         EXCEPTION_RECORD rec;
 234         HANDLE sem = get_semaphore( crit );
 235         LARGE_INTEGER time;
 236         DWORD status;
 237
 238         time.QuadPart = -5000 * 10000;  /* 5 seconds */
 239         status = NtWaitForSingleObject( sem, FALSE, &time );
 240         if ( status == WAIT_TIMEOUT )
 241         {
 242             const char *name = NULL;
 243             if (crit->DebugInfo) name = (char *)crit->DebugInfo->Spare[1];
 244             if (!name) name = "?";
 245             ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (60 sec)\n",
 246                  crit, debugstr_a(name), GetCurrentThreadId(), (DWORD)crit->OwningThread );
 247             time.QuadPart = -60000 * 10000;
 248             status = NtWaitForSingleObject( sem, FALSE, &time );
 249             if ( status == WAIT_TIMEOUT && TRACE_ON(relay) )
 250             {
 251                 ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (5 min)\n",
 252                      crit, debugstr_a(name), GetCurrentThreadId(), (DWORD) crit->OwningThread );
 253                 time.QuadPart = -300000 * (ULONGLONG)10000;
 254                 status = NtWaitForSingleObject( sem, FALSE, &time );
 255             }
 256         }
 257         if (status == STATUS_WAIT_0) return STATUS_SUCCESS;
 258
 259         /* Throw exception only for Wine internal locks */
 260         if ((!crit->DebugInfo) || (!crit->DebugInfo->Spare[1])) continue;
 261
 262         rec.ExceptionCode    = STATUS_POSSIBLE_DEADLOCK;
 263         rec.ExceptionFlags   = 0;
 264         rec.ExceptionRecord  = NULL;
 265         rec.ExceptionAddress = RtlRaiseException;  /* sic */
 266         rec.NumberParameters = 1;
 267         rec.ExceptionInformation[0] = (DWORD)crit;
 268         RtlRaiseException( &rec );
 269     }
 270 }
 271
 272
 273 /***********************************************************************
 274  *           RtlpUnWaitCriticalSection   (NTDLL.@)
 275  *
 276  * Notifies other threads waiting on the busy critical section that it has
 277  * become free.
 278  *
 279  * PARAMS
 280  *  crit [I/O] Critical section
 281  *
 282  * RETURNS
 283  *  Success: STATUS_SUCCESS.
 284  *  Failure: Any error returned by NtReleaseSemaphore()
 285  *
 286  * NOTES
 287  *  Use RtlLeaveCriticalSection() instead of this function as it is often much
 288  *  faster.
 289  *
 290  * SEE
 291  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 292  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 293  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 294  */
 295 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
 296 {
 297     HANDLE sem = get_semaphore( crit );
 298     NTSTATUS res = NtReleaseSemaphore( sem, 1, NULL );
 299     if (res) RtlRaiseStatus( res );
 300     return res;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           RtlEnterCriticalSection   (NTDLL.@)
 306  *
 307  * Enters a critical section, waiting for it to become available if necessary.
 308  *
 309  * PARAMS
 310  *  crit [I/O] Critical section to enter
 311  *
 312  * RETURNS
 313  *  STATUS_SUCCESS. The critical section is held by the caller.
 314  *
 315  * SEE
 316  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 317  *  RtlDeleteCriticalSection(), RtlSetCriticalSectionSpinCount(),
 318  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
 319  */
 320 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 321 {
 322     if (crit->SpinCount)
 323     {
 324         ULONG count;
 325
 326         if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
 327         for (count = crit->SpinCount; count > 0; count--)
 328         {
 329             if (crit->LockCount > 0) break;  /* more than one waiter, don't bother spinning */
 330             if (crit->LockCount == -1)       /* try again */
 331             {
 332                 if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1) goto done;
 333             }
 334             small_pause();
 335         }
 336     }
 337
 338     if (interlocked_inc( &crit->LockCount ))
 339     {
 340         if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
 341         {
 342             crit->RecursionCount++;
 343             return STATUS_SUCCESS;
 344         }
 345
 346         /* Now wait for it */
 347         RtlpWaitForCriticalSection( crit );
 348     }
 349 done:
 350     crit->OwningThread   = (HANDLE)GetCurrentThreadId();
 351     crit->RecursionCount = 1;
 352     return STATUS_SUCCESS;
 353 }
 354
 355
 356 /***********************************************************************
 357  *           RtlTryEnterCriticalSection   (NTDLL.@)
 358  *
 359  * Tries to enter a critical section without waiting.
 360  *
 361  * PARAMS
 362  *  crit [I/O] Critical section to enter
 363  *
 364  * RETURNS
 365  *  Success: TRUE. The critical section is held by the caller.
 366  *  Failure: FALSE. The critical section is currently held by another thread.
 367  *
 368  * SEE
 369  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 370  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 371  *  RtlLeaveCriticalSection(), RtlSetCriticalSectionSpinCount()
 372  */
 373 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 374 {
 375     BOOL ret = FALSE;
 376     if (interlocked_cmpxchg( &crit->LockCount, 0L, -1 ) == -1)
 377     {
 378         crit->OwningThread   = (HANDLE)GetCurrentThreadId();
 379         crit->RecursionCount = 1;
 380         ret = TRUE;
 381     }
 382     else if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
 383     {
 384         interlocked_inc( &crit->LockCount );
 385         crit->RecursionCount++;
 386         ret = TRUE;
 387     }
 388     return ret;
 389 }
 390
 391
 392 /***********************************************************************
 393  *           RtlLeaveCriticalSection   (NTDLL.@)
 394  *
 395  * Leaves a critical section.
 396  *
 397  * PARAMS
 398  *  crit [I/O] Critical section to leave.
 399  *
 400  * RETURNS
 401  *  STATUS_SUCCESS.
 402  *
 403  * SEE
 404  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
 405  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
 406  *  RtlSetCriticalSectionSpinCount(), RtlTryEnterCriticalSection()
 407  */
 408 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
 409 {
 410     if (--crit->RecursionCount) interlocked_dec( &crit->LockCount );
 411     else
 412     {
 413         crit->OwningThread = 0;
 414         if (interlocked_dec( &crit->LockCount ) >= 0)
 415         {
 416             /* someone is waiting */
 417             RtlpUnWaitCriticalSection( crit );
 418         }
 419     }
 420     return STATUS_SUCCESS;
 421 }