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         LARGE_INTEGER time;
 150         DWORD status;
 151
 152         time.QuadPart = -5000 * 10000;  /* 5 seconds */
 153         status = NtWaitForSingleObject( sem, FALSE, &time );
 154         if ( status == WAIT_TIMEOUT )
 155         {
 156             const char *name = (char *)crit->DebugInfo;
 157             if (!name) name = "?";
 158             ERR( "section %p %s wait timed out, retrying (60 sec) tid=%04lx\n",
 159                  crit, debugstr_a(name), GetCurrentThreadId() );
 160             time.QuadPart = -60000 * 10000;
 161             status = NtWaitForSingleObject( sem, FALSE, &time );
 162             if ( status == WAIT_TIMEOUT && TRACE_ON(relay) )
 163             {
 164                 ERR( "section %p %s wait timed out, retrying (5 min) tid=%04lx\n",
 165                      crit, debugstr_a(name), GetCurrentThreadId() );
 166                 time.QuadPart = -300000 * (ULONGLONG)10000;
 167                 status = NtWaitForSingleObject( sem, FALSE, &time );
 168             }
 169         }
 170         if (status == STATUS_WAIT_0) return STATUS_SUCCESS;
 171
 172         /* Throw exception only for Wine internal locks */
 173         if (!crit->DebugInfo) continue;
 174
 175         rec.ExceptionCode    = STATUS_POSSIBLE_DEADLOCK;
 176         rec.ExceptionFlags   = 0;
 177         rec.ExceptionRecord  = NULL;
 178         rec.ExceptionAddress = RtlRaiseException;  /* sic */
 179         rec.NumberParameters = 1;
 180         rec.ExceptionInformation[0] = (DWORD)crit;
 181         RtlRaiseException( &rec );
 182     }
 183 }
 184
 185
 186 /***********************************************************************
 187  *           RtlpUnWaitCriticalSection   (NTDLL.@)
 188  */
 189 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
 190 {
 191     HANDLE sem = get_semaphore( crit );
 192     NTSTATUS res = NtReleaseSemaphore( sem, 1, NULL );
 193     if (res) RtlRaiseStatus( res );
 194     return res;
 195 }
 196
 197
 198 /***********************************************************************
 199  *           RtlEnterCriticalSection   (NTDLL.@)
 200  *
 201  * Enter an RTL_CRITICAL_SECTION.
 202  *
 203  * PARAMS
 204  *  crit [I/O] Critical section to enter
 205  *
 206  * RETURNS
 207  *  STATUS_SUCCESS. The critical section is held by the caller.
 208  *
 209  * NOTES
 210  *  The caller will wait until the critical section is availale.
 211  */
 212 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 213 {
 214     if (interlocked_inc( &crit->LockCount ))
 215     {
 216         if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
 217         {
 218             crit->RecursionCount++;
 219             return STATUS_SUCCESS;
 220         }
 221
 222         /* Now wait for it */
 223         RtlpWaitForCriticalSection( crit );
 224     }
 225     crit->OwningThread   = (HANDLE)GetCurrentThreadId();
 226     crit->RecursionCount = 1;
 227     return STATUS_SUCCESS;
 228 }
 229
 230
 231 /***********************************************************************
 232  *           RtlTryEnterCriticalSection   (NTDLL.@)
 233  *
 234  * Enter an RTL_CRITICAL_SECTION without waiting.
 235  *
 236  * PARAMS
 237  *  crit [I/O] Critical section to enter
 238  *
 239  * RETURNS
 240  *  Success: TRUE. The critical section is held by the caller.
 241  *  Failure: FALSE. The critical section is currently held by another thread.
 242  */
 243 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 244 {
 245     BOOL ret = FALSE;
 246     if (interlocked_cmpxchg( &crit->LockCount, 0L, -1 ) == -1)
 247     {
 248         crit->OwningThread   = (HANDLE)GetCurrentThreadId();
 249         crit->RecursionCount = 1;
 250         ret = TRUE;
 251     }
 252     else if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
 253     {
 254         interlocked_inc( &crit->LockCount );
 255         crit->RecursionCount++;
 256         ret = TRUE;
 257     }
 258     return ret;
 259 }
 260
 261
 262 /***********************************************************************
 263  *           RtlLeaveCriticalSection   (NTDLL.@)
 264  *
 265  * Leave an RTL_CRITICAL_SECTION.
 266  *
 267  * PARAMS
 268  *  crit [I/O] Critical section to enter
 269  *
 270  * RETURNS
 271  *  STATUS_SUCCESS.
 272  */
 273 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
 274 {
 275     if (--crit->RecursionCount) interlocked_dec( &crit->LockCount );
 276     else
 277     {
 278         crit->OwningThread = 0;
 279         if (interlocked_dec( &crit->LockCount ) >= 0)
 280         {
 281             /* someone is waiting */
 282             RtlpUnWaitCriticalSection( crit );
 283         }
 284     }
 285     return STATUS_SUCCESS;
 286 }