2 * Win32 critical sections
4 * Copyright 1998 Alexandre Julliard
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.
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.
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
22 #include "wine/port.h"
27 #include <sys/types.h>
30 #include "wine/debug.h"
31 #include "ntdll_misc.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
34 WINE_DECLARE_DEBUG_CHANNEL(relay);
36 inline static LONG interlocked_inc( PLONG dest )
38 return interlocked_xchg_add( dest, 1 ) + 1;
41 inline static LONG interlocked_dec( PLONG dest )
43 return interlocked_xchg_add( dest, -1 ) - 1;
46 inline static void small_pause(void)
49 __asm__ __volatile__( "rep;nop" : : : "memory" );
51 __asm__ __volatile__( "" : : : "memory" );
55 /***********************************************************************
58 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
60 HANDLE ret = crit->LockSemaphore;
64 if (NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 )) return 0;
65 if (!(ret = (HANDLE)interlocked_cmpxchg_ptr( (PVOID *)&crit->LockSemaphore,
69 NtClose(sem); /* somebody beat us to it */
74 /***********************************************************************
75 * RtlInitializeCriticalSection (NTDLL.@)
77 * Initialises a new critical section.
80 * crit [O] Critical section to initialise
86 * RtlInitializeCriticalSectionAndSpinCount(), RtlDeleteCriticalSection(),
87 * RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
88 * RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
90 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
92 return RtlInitializeCriticalSectionAndSpinCount( crit, 0 );
95 /***********************************************************************
96 * RtlInitializeCriticalSectionAndSpinCount (NTDLL.@)
98 * Initialises a new critical section with a given spin count.
101 * crit [O] Critical section to initialise
102 * spincount [I] Spin count for crit
108 * Available on NT4 SP3 or later.
111 * RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
112 * RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
113 * RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
115 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
117 if (!GetProcessHeap()) crit->DebugInfo = NULL;
120 crit->DebugInfo = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(CRITICAL_SECTION_DEBUG));
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;
134 crit->LockCount = -1;
135 crit->RecursionCount = 0;
136 crit->OwningThread = 0;
137 crit->LockSemaphore = 0;
138 crit->SpinCount = spincount;
139 return STATUS_SUCCESS;
142 /***********************************************************************
143 * RtlSetCriticalSectionSpinCount (NTDLL.@)
145 * Sets the spin count of a critical section.
148 * crit [I/O] Critical section
149 * spincount [I] Spin count for crit
152 * The previous spin count.
155 * If the system is not SMP, spincount is ignored and set to 0.
158 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
159 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
160 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
162 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
164 ULONG oldspincount = crit->SpinCount;
165 if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
166 crit->SpinCount = spincount;
170 /***********************************************************************
171 * RtlDeleteCriticalSection (NTDLL.@)
173 * Frees the resources used by a critical section.
176 * crit [I/O] Critical section to free
182 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
183 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
184 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
186 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
188 crit->LockCount = -1;
189 crit->RecursionCount = 0;
190 crit->OwningThread = 0;
191 if (crit->LockSemaphore) NtClose( crit->LockSemaphore );
192 crit->LockSemaphore = 0;
195 /* only free the ones we made in here */
196 if (!crit->DebugInfo->Spare[1])
198 RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
199 crit->DebugInfo = NULL;
202 return STATUS_SUCCESS;
206 /***********************************************************************
207 * RtlpWaitForCriticalSection (NTDLL.@)
209 * Waits for a busy critical section to become free.
212 * crit [I/O] Critical section to wait for
218 * Use RtlEnterCriticalSection() instead of this function as it is often much
222 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
223 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
224 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
226 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
230 EXCEPTION_RECORD rec;
231 HANDLE sem = get_semaphore( crit );
235 time.QuadPart = -5000 * 10000; /* 5 seconds */
236 status = NtWaitForSingleObject( sem, FALSE, &time );
237 if ( status == WAIT_TIMEOUT )
239 const char *name = NULL;
240 if (crit->DebugInfo) name = (char *)crit->DebugInfo->Spare[1];
241 if (!name) name = "?";
242 ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (60 sec)\n",
243 crit, debugstr_a(name), GetCurrentThreadId(), (DWORD)crit->OwningThread );
244 time.QuadPart = -60000 * 10000;
245 status = NtWaitForSingleObject( sem, FALSE, &time );
246 if ( status == WAIT_TIMEOUT && TRACE_ON(relay) )
248 ERR( "section %p %s wait timed out in thread %04lx, blocked by %04lx, retrying (5 min)\n",
249 crit, debugstr_a(name), GetCurrentThreadId(), (DWORD) crit->OwningThread );
250 time.QuadPart = -300000 * (ULONGLONG)10000;
251 status = NtWaitForSingleObject( sem, FALSE, &time );
254 if (status == STATUS_WAIT_0) return STATUS_SUCCESS;
256 /* Throw exception only for Wine internal locks */
257 if ((!crit->DebugInfo) || (!crit->DebugInfo->Spare[1])) continue;
259 rec.ExceptionCode = STATUS_POSSIBLE_DEADLOCK;
260 rec.ExceptionFlags = 0;
261 rec.ExceptionRecord = NULL;
262 rec.ExceptionAddress = RtlRaiseException; /* sic */
263 rec.NumberParameters = 1;
264 rec.ExceptionInformation[0] = (ULONG_PTR)crit;
265 RtlRaiseException( &rec );
270 /***********************************************************************
271 * RtlpUnWaitCriticalSection (NTDLL.@)
273 * Notifies other threads waiting on the busy critical section that it has
277 * crit [I/O] Critical section
280 * Success: STATUS_SUCCESS.
281 * Failure: Any error returned by NtReleaseSemaphore()
284 * Use RtlLeaveCriticalSection() instead of this function as it is often much
288 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
289 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
290 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
292 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
294 HANDLE sem = get_semaphore( crit );
295 NTSTATUS res = NtReleaseSemaphore( sem, 1, NULL );
296 if (res) RtlRaiseStatus( res );
301 /***********************************************************************
302 * RtlEnterCriticalSection (NTDLL.@)
304 * Enters a critical section, waiting for it to become available if necessary.
307 * crit [I/O] Critical section to enter
310 * STATUS_SUCCESS. The critical section is held by the caller.
313 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
314 * RtlDeleteCriticalSection(), RtlSetCriticalSectionSpinCount(),
315 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
317 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
323 if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
324 for (count = crit->SpinCount; count > 0; count--)
326 if (crit->LockCount > 0) break; /* more than one waiter, don't bother spinning */
327 if (crit->LockCount == -1) /* try again */
329 if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1) goto done;
335 if (interlocked_inc( &crit->LockCount ))
337 if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
339 crit->RecursionCount++;
340 return STATUS_SUCCESS;
343 /* Now wait for it */
344 RtlpWaitForCriticalSection( crit );
347 crit->OwningThread = (HANDLE)GetCurrentThreadId();
348 crit->RecursionCount = 1;
349 return STATUS_SUCCESS;
353 /***********************************************************************
354 * RtlTryEnterCriticalSection (NTDLL.@)
356 * Tries to enter a critical section without waiting.
359 * crit [I/O] Critical section to enter
362 * Success: TRUE. The critical section is held by the caller.
363 * Failure: FALSE. The critical section is currently held by another thread.
366 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
367 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
368 * RtlLeaveCriticalSection(), RtlSetCriticalSectionSpinCount()
370 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
373 if (interlocked_cmpxchg( &crit->LockCount, 0L, -1 ) == -1)
375 crit->OwningThread = (HANDLE)GetCurrentThreadId();
376 crit->RecursionCount = 1;
379 else if (crit->OwningThread == (HANDLE)GetCurrentThreadId())
381 interlocked_inc( &crit->LockCount );
382 crit->RecursionCount++;
389 /***********************************************************************
390 * RtlLeaveCriticalSection (NTDLL.@)
392 * Leaves a critical section.
395 * crit [I/O] Critical section to leave.
401 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
402 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
403 * RtlSetCriticalSectionSpinCount(), RtlTryEnterCriticalSection()
405 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
407 if (--crit->RecursionCount) interlocked_dec( &crit->LockCount );
410 crit->OwningThread = 0;
411 if (interlocked_dec( &crit->LockCount ) >= 0)
413 /* someone is waiting */
414 RtlpUnWaitCriticalSection( crit );
417 return STATUS_SUCCESS;