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 <stdio.h>
  26 #include <sys/types.h>
  27 #include "winerror.h"
  28 #include "winternl.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  32 WINE_DECLARE_DEBUG_CHANNEL(relay);
  33
  34 inline static LONG interlocked_inc( PLONG dest )
  35 {
  36     return interlocked_xchg_add( dest, 1 ) + 1;
  37 }
  38
  39 inline static LONG interlocked_dec( PLONG dest )
  40 {
  41     return interlocked_xchg_add( dest, -1 ) - 1;
  42 }
  43
  44 /***********************************************************************
  45  *           get_semaphore
  46  */
  47 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
  48 {
  49     HANDLE ret = crit->LockSemaphore;
  50     if (!ret)
  51     {
  52         HANDLE sem;
  53         if (NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 )) return 0;
  54         if (!(ret = (HANDLE)interlocked_cmpxchg_ptr( (PVOID *)&crit->LockSemaphore,
  55                                                      (PVOID)sem, 0 )))
  56             ret = sem;
  57         else
  58             NtClose(sem);  /* somebody beat us to it */
  59     }
  60     return ret;
  61 }
  62
  63 /***********************************************************************
  64  *           RtlInitializeCriticalSection   (NTDLL.@)
  65  *
  66  * Initialise a new RTL_CRITICAL_SECTION.
  67  *
  68  * PARAMS
  69  *  crit [O] Critical section to initialise
  70  *
  71  * RETURN
  72  *  STATUS_SUCCESS.
  73  */
  74 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
  75 {
  76     crit->DebugInfo      = NULL;
  77     crit->LockCount      = -1;
  78     crit->RecursionCount = 0;
  79     crit->OwningThread   = 0;
  80     crit->LockSemaphore  = 0;
  81     return STATUS_SUCCESS;
  82 }
  83
  84 /***********************************************************************
  85  *           RtlInitializeCriticalSectionAndSpinCount   (NTDLL.@)
  86  *
  87  * Initialise a new RTL_CRITICAL_SECTION with a given spin count.
  88  *
  89  * PARAMS
  90  *   crit      [O] Critical section to initialise
  91  *   spincount [I] Spin count for crit
  92  *
  93  * RETURNS
  94  *  STATUS_SUCCESS.
  95  *
  96  * NOTES
  97  * The InitializeCriticalSectionAndSpinCount() (KERNEL32) function is
  98  * available on NT4SP3 or later, and Win98 or later.
  99  * I am assuming that this is the correct definition given the MSDN
 100  * docs for the kernel32 functions.
 101  */
 102 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount )
 103 {
 104     if(spincount) TRACE("critsection=%p: spincount=%ld not supported\n", crit, spincount);
 105     crit->SpinCount = spincount;
 106     return RtlInitializeCriticalSection( crit );
 107 }
 108
 109
 110 /***********************************************************************
 111  *           RtlDeleteCriticalSection   (NTDLL.@)
 112  *
 113  * Free the resources used by an RTL_CRITICAL_SECTION.
 114  *
 115  * PARAMS
 116  *  crit [I/O] Critical section to free
 117  *
 118  * RETURNS
 119  *  STATUS_SUCCESS.
 120  */
 121 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
 122 {
 123     crit->LockCount      = -1;
 124     crit->RecursionCount = 0;
 125     crit->OwningThread   = 0;
 126     if (crit->LockSemaphore) NtClose( crit->LockSemaphore );
 127     crit->LockSemaphore  = 0;
 128     return STATUS_SUCCESS;
 129 }
 130
 131
 132 /***********************************************************************
 133  *           RtlpWaitForCriticalSection   (NTDLL.@)
 134  *
 135  * Wait for an RTL_CRITICAL_SECTION to become free.
 136  *
 137  * PARAMS
 138  *  crit [I/O] Critical section to wait for
 139  *
 140  * RETURNS
 141  *  STATUS_SUCCESS.
 142  */
 143 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
 144 {
 145     for (;;)
 146     {
 147         EXCEPTION_RECORD rec;
 148         HANDLE sem = get_semaphore( crit );
 149
 150         DWORD res = WaitForSingleObject( sem, 5000L );
 151         if ( res == WAIT_TIMEOUT )
 152         {
 153             const char *name = (char *)crit->DebugInfo;
 154             if (!name) name = "?";
 155             ERR( "section %p %s wait timed out, retrying (60 sec) tid=%04lx\n",
 156                  crit, debugstr_a(name), GetCurrentThreadId() );
 157             res = WaitForSingleObject( sem, 60000L );
 158             if ( res == WAIT_TIMEOUT && TRACE_ON(relay) )
 159             {
 160                 ERR( "section %p %s wait timed out, retrying (5 min) tid=%04lx\n",
 161                      crit, debugstr_a(name), GetCurrentThreadId() );
 162                 res = WaitForSingleObject( sem, 300000L );
 163             }
 164         }
 165         if (res == STATUS_WAIT_0) return STATUS_SUCCESS;
 166
 167         /* Throw exception only for Wine internal locks */
 168         if (!crit->DebugInfo) continue;
 169
 170         rec.ExceptionCode    = EXCEPTION_CRITICAL_SECTION_WAIT;
 171         rec.ExceptionFlags   = 0;
 172         rec.ExceptionRecord  = NULL;
 173         rec.ExceptionAddress = RtlRaiseException;  /* sic */
 174         rec.NumberParameters = 1;
 175         rec.ExceptionInformation[0] = (DWORD)crit;
 176         RtlRaiseException( &rec );
 177     }
 178 }
 179
 180
 181 /***********************************************************************
 182  *           RtlpUnWaitCriticalSection   (NTDLL.@)
 183  */
 184 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
 185 {
 186     HANDLE sem = get_semaphore( crit );
 187     NTSTATUS res = NtReleaseSemaphore( sem, 1, NULL );
 188     if (res) RtlRaiseStatus( res );
 189     return res;
 190 }
 191
 192
 193 /***********************************************************************
 194  *           RtlEnterCriticalSection   (NTDLL.@)
 195  *
 196  * Enter an RTL_CRITICAL_SECTION.
 197  *
 198  * PARAMS
 199  *  crit [I/O] Critical section to enter
 200  *
 201  * RETURNS
 202  *  STATUS_SUCCESS. The critical section is held by the caller.
 203  *
 204  * NOTES
 205  *  The caller will wait until the critical section is availale.
 206  */
 207 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 208 {
 209     if (interlocked_inc( &crit->LockCount ))
 210     {
 211         if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
 212         {
 213             crit->RecursionCount++;
 214             return STATUS_SUCCESS;
 215         }
 216
 217         /* Now wait for it */
 218         RtlpWaitForCriticalSection( crit );
 219     }
 220     crit->OwningThread   = (HANDLE)GetCurrentThreadId();
 221     crit->RecursionCount = 1;
 222     return STATUS_SUCCESS;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           RtlTryEnterCriticalSection   (NTDLL.@)
 228  *
 229  * Enter an RTL_CRITICAL_SECTION without waiting.
 230  *
 231  * PARAMS
 232  *  crit [I/O] Critical section to enter
 233  *
 234  * RETURNS
 235  *  Success: TRUE. The critical section is held by the caller.
 236  *  Failure: FALSE. The critical section is currently held by another thread.
 237  */
 238 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 239 {
 240     BOOL ret = FALSE;
 241     if (interlocked_cmpxchg( &crit->LockCount, 0L, -1 ) == -1)
 242     {
 243         crit->OwningThread   = (HANDLE)GetCurrentThreadId();
 244         crit->RecursionCount = 1;
 245         ret = TRUE;
 246     }
 247     else if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
 248     {
 249         interlocked_inc( &crit->LockCount );
 250         crit->RecursionCount++;
 251         ret = TRUE;
 252     }
 253     return ret;
 254 }
 255
 256
 257 /***********************************************************************
 258  *           RtlLeaveCriticalSection   (NTDLL.@)
 259  *
 260  * Leave an RTL_CRITICAL_SECTION.
 261  *
 262  * PARAMS
 263  *  crit [I/O] Critical section to enter
 264  *
 265  * RETURNS
 266  *  STATUS_SUCCESS.
 267  */
 268 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
 269 {
 270     if (--crit->RecursionCount) interlocked_dec( &crit->LockCount );
 271     else
 272     {
 273         crit->OwningThread = 0;
 274         if (interlocked_dec( &crit->LockCount ) >= 0)
 275         {
 276             /* someone is waiting */
 277             RtlpUnWaitCriticalSection( crit );
 278         }
 279     }
 280     return STATUS_SUCCESS;
 281 }