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