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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
28 #include <sys/types.h>
31 #define WIN32_NO_STATUS
34 #include "wine/debug.h"
35 #include "ntdll_misc.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
38 WINE_DECLARE_DEBUG_CHANNEL(relay);
40 static inline LONG interlocked_inc( PLONG dest )
42 return interlocked_xchg_add( dest, 1 ) + 1;
45 static inline LONG interlocked_dec( PLONG dest )
47 return interlocked_xchg_add( dest, -1 ) - 1;
50 static inline void small_pause(void)
53 __asm__ __volatile__( "rep;nop" : : : "memory" );
55 __asm__ __volatile__( "" : : : "memory" );
59 #if defined(linux) && defined(__i386__)
61 static inline int futex_wait( int *addr, int val, struct timespec *timeout )
64 __asm__ __volatile__( "xchgl %2,%%ebx\n\t"
68 : "0" (240) /* SYS_futex */, "D" (addr),
69 "c" (0) /* FUTEX_WAIT */, "d" (val), "S" (timeout) );
73 static inline int futex_wake( int *addr, int val )
76 __asm__ __volatile__( "xchgl %2,%%ebx\n\t"
80 : "0" (240) /* SYS_futex */, "D" (addr),
81 "c" (1) /* FUTEX_WAKE */, "d" (val) );
85 static inline int use_futexes(void)
87 static int supported = -1;
89 if (supported == -1) supported = (futex_wait( &supported, 10, NULL ) != -ENOSYS);
93 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
96 struct timespec timespec;
98 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
100 timespec.tv_sec = timeout;
101 timespec.tv_nsec = 0;
102 while ((val = interlocked_cmpxchg( (int *)&crit->LockSemaphore, 0, 1 )) != 1)
104 /* note: this may wait longer than specified in case of signals or */
105 /* multiple wake-ups, but that shouldn't be a problem */
106 if (futex_wait( (int *)&crit->LockSemaphore, val, ×pec ) == -ETIMEDOUT)
107 return STATUS_TIMEOUT;
109 return STATUS_WAIT_0;
112 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
114 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
116 *(int *)&crit->LockSemaphore = 1;
117 futex_wake( (int *)&crit->LockSemaphore, 1 );
118 return STATUS_SUCCESS;
121 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
123 if (!use_futexes()) NtClose( crit->LockSemaphore );
126 #elif defined(__APPLE__)
128 #include <mach/mach.h>
129 #include <mach/task.h>
130 #include <mach/semaphore.h>
132 static inline semaphore_t get_mach_semaphore( RTL_CRITICAL_SECTION *crit )
134 semaphore_t ret = *(int *)&crit->LockSemaphore;
138 if (semaphore_create( mach_task_self(), &sem, SYNC_POLICY_FIFO, 0 )) return 0;
139 if (!(ret = interlocked_cmpxchg( (int *)&crit->LockSemaphore, sem, 0 )))
142 semaphore_destroy( mach_task_self(), sem ); /* somebody beat us to it */
147 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
149 mach_timespec_t timespec;
150 semaphore_t sem = get_mach_semaphore( crit );
152 timespec.tv_sec = timeout;
153 timespec.tv_nsec = 0;
156 switch( semaphore_timedwait( sem, timespec ))
159 return STATUS_WAIT_0;
161 continue; /* got a signal, restart */
162 case KERN_OPERATION_TIMED_OUT:
163 return STATUS_TIMEOUT;
165 return STATUS_INVALID_HANDLE;
170 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
172 semaphore_t sem = get_mach_semaphore( crit );
173 semaphore_signal( sem );
174 return STATUS_SUCCESS;
177 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
179 semaphore_destroy( mach_task_self(), *(int *)&crit->LockSemaphore );
182 #else /* __APPLE__ */
184 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
186 return STATUS_NOT_IMPLEMENTED;
189 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
191 return STATUS_NOT_IMPLEMENTED;
194 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
196 NtClose( crit->LockSemaphore );
201 /***********************************************************************
204 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
206 HANDLE ret = crit->LockSemaphore;
210 if (NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 )) return 0;
211 if (!(ret = interlocked_cmpxchg_ptr( &crit->LockSemaphore, sem, 0 )))
214 NtClose(sem); /* somebody beat us to it */
219 /***********************************************************************
222 static inline NTSTATUS wait_semaphore( RTL_CRITICAL_SECTION *crit, int timeout )
226 /* debug info is cleared by MakeCriticalSectionGlobal */
227 if (!crit->DebugInfo || ((ret = fast_wait( crit, timeout )) == STATUS_NOT_IMPLEMENTED))
229 HANDLE sem = get_semaphore( crit );
232 time.QuadPart = timeout * (LONGLONG)-10000000;
233 ret = NTDLL_wait_for_multiple_objects( 1, &sem, 0, &time, 0 );
238 /***********************************************************************
239 * RtlInitializeCriticalSection (NTDLL.@)
241 * Initialises a new critical section.
244 * crit [O] Critical section to initialise
250 * RtlInitializeCriticalSectionAndSpinCount(), RtlDeleteCriticalSection(),
251 * RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
252 * RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
254 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
256 return RtlInitializeCriticalSectionAndSpinCount( crit, 0 );
259 /***********************************************************************
260 * RtlInitializeCriticalSectionAndSpinCount (NTDLL.@)
262 * Initialises a new critical section with a given spin count.
265 * crit [O] Critical section to initialise
266 * spincount [I] Spin count for crit
272 * Available on NT4 SP3 or later.
275 * RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
276 * RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
277 * RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
279 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
281 crit->DebugInfo = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_CRITICAL_SECTION_DEBUG));
284 crit->DebugInfo->Type = 0;
285 crit->DebugInfo->CreatorBackTraceIndex = 0;
286 crit->DebugInfo->CriticalSection = crit;
287 crit->DebugInfo->ProcessLocksList.Blink = &(crit->DebugInfo->ProcessLocksList);
288 crit->DebugInfo->ProcessLocksList.Flink = &(crit->DebugInfo->ProcessLocksList);
289 crit->DebugInfo->EntryCount = 0;
290 crit->DebugInfo->ContentionCount = 0;
291 memset( crit->DebugInfo->Spare, 0, sizeof(crit->DebugInfo->Spare) );
293 crit->LockCount = -1;
294 crit->RecursionCount = 0;
295 crit->OwningThread = 0;
296 crit->LockSemaphore = 0;
297 if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
298 crit->SpinCount = spincount & ~0x80000000;
299 return STATUS_SUCCESS;
302 /***********************************************************************
303 * RtlSetCriticalSectionSpinCount (NTDLL.@)
305 * Sets the spin count of a critical section.
308 * crit [I/O] Critical section
309 * spincount [I] Spin count for crit
312 * The previous spin count.
315 * If the system is not SMP, spincount is ignored and set to 0.
318 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
319 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
320 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
322 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
324 ULONG oldspincount = crit->SpinCount;
325 if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
326 crit->SpinCount = spincount;
330 /***********************************************************************
331 * RtlDeleteCriticalSection (NTDLL.@)
333 * Frees the resources used by a critical section.
336 * crit [I/O] Critical section to free
342 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
343 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
344 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
346 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
348 crit->LockCount = -1;
349 crit->RecursionCount = 0;
350 crit->OwningThread = 0;
353 /* only free the ones we made in here */
354 if (!crit->DebugInfo->Spare[0])
356 RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
357 crit->DebugInfo = NULL;
359 close_semaphore( crit );
361 else NtClose( crit->LockSemaphore );
362 crit->LockSemaphore = 0;
363 return STATUS_SUCCESS;
367 /***********************************************************************
368 * RtlpWaitForCriticalSection (NTDLL.@)
370 * Waits for a busy critical section to become free.
373 * crit [I/O] Critical section to wait for
379 * Use RtlEnterCriticalSection() instead of this function as it is often much
383 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
384 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
385 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
387 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
391 EXCEPTION_RECORD rec;
392 NTSTATUS status = wait_semaphore( crit, 5 );
394 if ( status == STATUS_TIMEOUT )
396 const char *name = NULL;
397 if (crit->DebugInfo) name = (char *)crit->DebugInfo->Spare[0];
398 if (!name) name = "?";
399 ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (60 sec)\n",
400 crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
401 status = wait_semaphore( crit, 60 );
402 if ( status == STATUS_TIMEOUT && TRACE_ON(relay) )
404 ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (5 min)\n",
405 crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
406 status = wait_semaphore( crit, 300 );
409 if (status == STATUS_WAIT_0) break;
411 /* Throw exception only for Wine internal locks */
412 if ((!crit->DebugInfo) || (!crit->DebugInfo->Spare[0])) continue;
414 rec.ExceptionCode = STATUS_POSSIBLE_DEADLOCK;
415 rec.ExceptionFlags = 0;
416 rec.ExceptionRecord = NULL;
417 rec.ExceptionAddress = RtlRaiseException; /* sic */
418 rec.NumberParameters = 1;
419 rec.ExceptionInformation[0] = (ULONG_PTR)crit;
420 RtlRaiseException( &rec );
422 if (crit->DebugInfo) crit->DebugInfo->ContentionCount++;
423 return STATUS_SUCCESS;
427 /***********************************************************************
428 * RtlpUnWaitCriticalSection (NTDLL.@)
430 * Notifies other threads waiting on the busy critical section that it has
434 * crit [I/O] Critical section
437 * Success: STATUS_SUCCESS.
438 * Failure: Any error returned by NtReleaseSemaphore()
441 * Use RtlLeaveCriticalSection() instead of this function as it is often much
445 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
446 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
447 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
449 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
453 /* debug info is cleared by MakeCriticalSectionGlobal */
454 if (!crit->DebugInfo || ((ret = fast_wake( crit )) == STATUS_NOT_IMPLEMENTED))
456 HANDLE sem = get_semaphore( crit );
457 ret = NtReleaseSemaphore( sem, 1, NULL );
459 if (ret) RtlRaiseStatus( ret );
464 /***********************************************************************
465 * RtlEnterCriticalSection (NTDLL.@)
467 * Enters a critical section, waiting for it to become available if necessary.
470 * crit [I/O] Critical section to enter
473 * STATUS_SUCCESS. The critical section is held by the caller.
476 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
477 * RtlDeleteCriticalSection(), RtlSetCriticalSectionSpinCount(),
478 * RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
480 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
486 if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
487 for (count = crit->SpinCount; count > 0; count--)
489 if (crit->LockCount > 0) break; /* more than one waiter, don't bother spinning */
490 if (crit->LockCount == -1) /* try again */
492 if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1) goto done;
498 if (interlocked_inc( &crit->LockCount ))
500 if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
502 crit->RecursionCount++;
503 return STATUS_SUCCESS;
506 /* Now wait for it */
507 RtlpWaitForCriticalSection( crit );
510 crit->OwningThread = ULongToHandle(GetCurrentThreadId());
511 crit->RecursionCount = 1;
512 return STATUS_SUCCESS;
516 /***********************************************************************
517 * RtlTryEnterCriticalSection (NTDLL.@)
519 * Tries to enter a critical section without waiting.
522 * crit [I/O] Critical section to enter
525 * Success: TRUE. The critical section is held by the caller.
526 * Failure: FALSE. The critical section is currently held by another thread.
529 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
530 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
531 * RtlLeaveCriticalSection(), RtlSetCriticalSectionSpinCount()
533 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
536 if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1)
538 crit->OwningThread = ULongToHandle(GetCurrentThreadId());
539 crit->RecursionCount = 1;
542 else if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
544 interlocked_inc( &crit->LockCount );
545 crit->RecursionCount++;
552 /***********************************************************************
553 * RtlLeaveCriticalSection (NTDLL.@)
555 * Leaves a critical section.
558 * crit [I/O] Critical section to leave.
564 * RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
565 * RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
566 * RtlSetCriticalSectionSpinCount(), RtlTryEnterCriticalSection()
568 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
570 if (--crit->RecursionCount) interlocked_dec( &crit->LockCount );
573 crit->OwningThread = 0;
574 if (interlocked_dec( &crit->LockCount ) >= 0)
576 /* someone is waiting */
577 RtlpUnWaitCriticalSection( crit );
580 return STATUS_SUCCESS;