ntdll: Remove superfluous semicolon.
[wine] / 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <errno.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <sys/types.h>
29 #include <time.h>
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
34 #include "wine/debug.h"
35 #include "ntdll_misc.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
38 WINE_DECLARE_DEBUG_CHANNEL(relay);
39
40 static inline LONG interlocked_inc( PLONG dest )
41 {
42     return interlocked_xchg_add( dest, 1 ) + 1;
43 }
44
45 static inline LONG interlocked_dec( PLONG dest )
46 {
47     return interlocked_xchg_add( dest, -1 ) - 1;
48 }
49
50 static inline void small_pause(void)
51 {
52 #ifdef __i386__
53     __asm__ __volatile__( "rep;nop" : : : "memory" );
54 #else
55     __asm__ __volatile__( "" : : : "memory" );
56 #endif
57 }
58
59 #if defined(linux) && defined(__i386__)
60
61 static inline int futex_wait( int *addr, int val, struct timespec *timeout )
62 {
63     int res;
64     __asm__ __volatile__( "xchgl %2,%%ebx\n\t"
65                           "int $0x80\n\t"
66                           "xchgl %2,%%ebx"
67                           : "=a" (res)
68                           : "0" (240) /* SYS_futex */, "D" (addr),
69                             "c" (0) /* FUTEX_WAIT */, "d" (val), "S" (timeout) );
70     return res;
71 }
72
73 static inline int futex_wake( int *addr, int val )
74 {
75     int res;
76     __asm__ __volatile__( "xchgl %2,%%ebx\n\t"
77                           "int $0x80\n\t"
78                           "xchgl %2,%%ebx"
79                           : "=a" (res)
80                           : "0" (240) /* SYS_futex */, "D" (addr),
81                             "c" (1)  /* FUTEX_WAKE */, "d" (val) );
82     return res;
83 }
84
85 static inline int use_futexes(void)
86 {
87     static int supported = -1;
88
89     if (supported == -1) supported = (futex_wait( &supported, 10, NULL ) != -ENOSYS);
90     return supported;
91 }
92
93 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
94 {
95     int val;
96     struct timespec timespec;
97
98     if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
99
100     timespec.tv_sec  = timeout;
101     timespec.tv_nsec = 0;
102     while ((val = interlocked_cmpxchg( (int *)&crit->LockSemaphore, 0, 1 )) != 1)
103     {
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, &timespec ) == -ETIMEDOUT)
107             return STATUS_TIMEOUT;
108     }
109     return STATUS_WAIT_0;
110 }
111
112 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
113 {
114     if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
115
116     *(int *)&crit->LockSemaphore = 1;
117     futex_wake( (int *)&crit->LockSemaphore, 1 );
118     return STATUS_SUCCESS;
119 }
120
121 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
122 {
123     if (!use_futexes()) NtClose( crit->LockSemaphore );
124 }
125
126 #elif defined(__APPLE__)
127
128 #include <mach/mach.h>
129 #include <mach/task.h>
130 #include <mach/semaphore.h>
131
132 static inline semaphore_t get_mach_semaphore( RTL_CRITICAL_SECTION *crit )
133 {
134     semaphore_t ret = *(int *)&crit->LockSemaphore;
135     if (!ret)
136     {
137         semaphore_t sem;
138         if (semaphore_create( mach_task_self(), &sem, SYNC_POLICY_FIFO, 0 )) return 0;
139         if (!(ret = interlocked_cmpxchg( (int *)&crit->LockSemaphore, sem, 0 )))
140             ret = sem;
141         else
142             semaphore_destroy( mach_task_self(), sem );  /* somebody beat us to it */
143     }
144     return ret;
145 }
146
147 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
148 {
149     mach_timespec_t timespec;
150     semaphore_t sem = get_mach_semaphore( crit );
151
152     timespec.tv_sec = timeout;
153     timespec.tv_nsec = 0;
154     for (;;)
155     {
156         switch( semaphore_timedwait( sem, timespec ))
157         {
158         case KERN_SUCCESS:
159             return STATUS_WAIT_0;
160         case KERN_ABORTED:
161             continue;  /* got a signal, restart */
162         case KERN_OPERATION_TIMED_OUT:
163             return STATUS_TIMEOUT;
164         default:
165             return STATUS_INVALID_HANDLE;
166         }
167     }
168 }
169
170 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
171 {
172     semaphore_t sem = get_mach_semaphore( crit );
173     semaphore_signal( sem );
174     return STATUS_SUCCESS;
175 }
176
177 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
178 {
179     semaphore_destroy( mach_task_self(), *(int *)&crit->LockSemaphore );
180 }
181
182 #else  /* __APPLE__ */
183
184 static inline NTSTATUS fast_wait( RTL_CRITICAL_SECTION *crit, int timeout )
185 {
186     return STATUS_NOT_IMPLEMENTED;
187 }
188
189 static inline NTSTATUS fast_wake( RTL_CRITICAL_SECTION *crit )
190 {
191     return STATUS_NOT_IMPLEMENTED;
192 }
193
194 static inline void close_semaphore( RTL_CRITICAL_SECTION *crit )
195 {
196     NtClose( crit->LockSemaphore );
197 }
198
199 #endif
200
201 /***********************************************************************
202  *           get_semaphore
203  */
204 static inline HANDLE get_semaphore( RTL_CRITICAL_SECTION *crit )
205 {
206     HANDLE ret = crit->LockSemaphore;
207     if (!ret)
208     {
209         HANDLE sem;
210         if (NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 )) return 0;
211         if (!(ret = interlocked_cmpxchg_ptr( &crit->LockSemaphore, sem, 0 )))
212             ret = sem;
213         else
214             NtClose(sem);  /* somebody beat us to it */
215     }
216     return ret;
217 }
218
219 /***********************************************************************
220  *           wait_semaphore
221  */
222 static inline NTSTATUS wait_semaphore( RTL_CRITICAL_SECTION *crit, int timeout )
223 {
224     NTSTATUS ret;
225
226     /* debug info is cleared by MakeCriticalSectionGlobal */
227     if (!crit->DebugInfo || ((ret = fast_wait( crit, timeout )) == STATUS_NOT_IMPLEMENTED))
228     {
229         HANDLE sem = get_semaphore( crit );
230         LARGE_INTEGER time;
231
232         time.QuadPart = timeout * (LONGLONG)-10000000;
233         ret = NTDLL_wait_for_multiple_objects( 1, &sem, 0, &time, 0 );
234     }
235     return ret;
236 }
237
238 /***********************************************************************
239  *           RtlInitializeCriticalSection   (NTDLL.@)
240  *
241  * Initialises a new critical section.
242  *
243  * PARAMS
244  *  crit [O] Critical section to initialise
245  *
246  * RETURNS
247  *  STATUS_SUCCESS.
248  *
249  * SEE
250  *  RtlInitializeCriticalSectionEx(),
251  *  RtlInitializeCriticalSectionAndSpinCount(), RtlDeleteCriticalSection(),
252  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
253  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
254  */
255 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit )
256 {
257     return RtlInitializeCriticalSectionEx( crit, 0, 0 );
258 }
259
260 /***********************************************************************
261  *           RtlInitializeCriticalSectionAndSpinCount   (NTDLL.@)
262  *
263  * Initialises a new critical section with a given spin count.
264  *
265  * PARAMS
266  *   crit      [O] Critical section to initialise
267  *   spincount [I] Spin count for crit
268  * 
269  * RETURNS
270  *  STATUS_SUCCESS.
271  *
272  * NOTES
273  *  Available on NT4 SP3 or later.
274  *
275  * SEE
276  *  RtlInitializeCriticalSectionEx(),
277  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
278  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
279  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
280  */
281 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
282 {
283     return RtlInitializeCriticalSectionEx( crit, spincount, 0 );
284 }
285
286 /***********************************************************************
287  *           RtlInitializeCriticalSectionEx   (NTDLL.@)
288  *
289  * Initialises a new critical section with a given spin count and flags.
290  *
291  * PARAMS
292  *   crit      [O] Critical section to initialise.
293  *   spincount [I] Number of times to spin upon contention.
294  *   flags     [I] RTL_CRITICAL_SECTION_FLAG_ flags from winnt.h.
295  *
296  * RETURNS
297  *  STATUS_SUCCESS.
298  *
299  * NOTES
300  *  Available on Vista or later.
301  *
302  * SEE
303  *  RtlInitializeCriticalSection(), RtlDeleteCriticalSection(),
304  *  RtlEnterCriticalSection(), RtlLeaveCriticalSection(),
305  *  RtlTryEnterCriticalSection(), RtlSetCriticalSectionSpinCount()
306  */
307 NTSTATUS WINAPI RtlInitializeCriticalSectionEx( RTL_CRITICAL_SECTION *crit, ULONG spincount, ULONG flags )
308 {
309     if (flags & (RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN|RTL_CRITICAL_SECTION_FLAG_STATIC_INIT))
310         FIXME("(%p,%u,0x%08x) semi-stub\n", crit, spincount, flags);
311
312     /* FIXME: if RTL_CRITICAL_SECTION_FLAG_STATIC_INIT is given, we should use
313      * memory from a static pool to hold the debug info. Then heap.c could pass
314      * this flag rather than initialising the process heap CS by hand. If this
315      * is done, then debug info should be managed through Rtlp[Allocate|Free]DebugInfo
316      * so (e.g.) MakeCriticalSectionGlobal() doesn't free it using HeapFree().
317      */
318     if (flags & RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO)
319         crit->DebugInfo = NULL;
320     else
321         crit->DebugInfo = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_CRITICAL_SECTION_DEBUG));
322
323     if (crit->DebugInfo)
324     {
325         crit->DebugInfo->Type = 0;
326         crit->DebugInfo->CreatorBackTraceIndex = 0;
327         crit->DebugInfo->CriticalSection = crit;
328         crit->DebugInfo->ProcessLocksList.Blink = &(crit->DebugInfo->ProcessLocksList);
329         crit->DebugInfo->ProcessLocksList.Flink = &(crit->DebugInfo->ProcessLocksList);
330         crit->DebugInfo->EntryCount = 0;
331         crit->DebugInfo->ContentionCount = 0;
332         memset( crit->DebugInfo->Spare, 0, sizeof(crit->DebugInfo->Spare) );
333     }
334     crit->LockCount      = -1;
335     crit->RecursionCount = 0;
336     crit->OwningThread   = 0;
337     crit->LockSemaphore  = 0;
338     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
339     crit->SpinCount = spincount & ~0x80000000;
340     return STATUS_SUCCESS;
341 }
342
343 /***********************************************************************
344  *           RtlSetCriticalSectionSpinCount   (NTDLL.@)
345  *
346  * Sets the spin count of a critical section.
347  *
348  * PARAMS
349  *   crit      [I/O] Critical section
350  *   spincount [I] Spin count for crit
351  *
352  * RETURNS
353  *  The previous spin count.
354  *
355  * NOTES
356  *  If the system is not SMP, spincount is ignored and set to 0.
357  *
358  * SEE
359  *  RtlInitializeCriticalSectionEx(),
360  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
361  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
362  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
363  */
364 ULONG WINAPI RtlSetCriticalSectionSpinCount( RTL_CRITICAL_SECTION *crit, ULONG spincount )
365 {
366     ULONG oldspincount = crit->SpinCount;
367     if (NtCurrentTeb()->Peb->NumberOfProcessors <= 1) spincount = 0;
368     crit->SpinCount = spincount;
369     return oldspincount;
370 }
371
372 /***********************************************************************
373  *           RtlDeleteCriticalSection   (NTDLL.@)
374  *
375  * Frees the resources used by a critical section.
376  *
377  * PARAMS
378  *  crit [I/O] Critical section to free
379  *
380  * RETURNS
381  *  STATUS_SUCCESS.
382  *
383  * SEE
384  *  RtlInitializeCriticalSectionEx(),
385  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
386  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
387  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
388  */
389 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
390 {
391     crit->LockCount      = -1;
392     crit->RecursionCount = 0;
393     crit->OwningThread   = 0;
394     if (crit->DebugInfo)
395     {
396         /* only free the ones we made in here */
397         if (!crit->DebugInfo->Spare[0])
398         {
399             RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
400             crit->DebugInfo = NULL;
401         }
402         close_semaphore( crit );
403     }
404     else NtClose( crit->LockSemaphore );
405     crit->LockSemaphore = 0;
406     return STATUS_SUCCESS;
407 }
408
409
410 /***********************************************************************
411  *           RtlpWaitForCriticalSection   (NTDLL.@)
412  *
413  * Waits for a busy critical section to become free.
414  * 
415  * PARAMS
416  *  crit [I/O] Critical section to wait for
417  *
418  * RETURNS
419  *  STATUS_SUCCESS.
420  *
421  * NOTES
422  *  Use RtlEnterCriticalSection() instead of this function as it is often much
423  *  faster.
424  *
425  * SEE
426  *  RtlInitializeCriticalSectionEx(),
427  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
428  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
429  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
430  */
431 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit )
432 {
433     for (;;)
434     {
435         EXCEPTION_RECORD rec;
436         NTSTATUS status = wait_semaphore( crit, 5 );
437
438         if ( status == STATUS_TIMEOUT )
439         {
440             const char *name = NULL;
441             if (crit->DebugInfo) name = (char *)crit->DebugInfo->Spare[0];
442             if (!name) name = "?";
443             ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (60 sec)\n",
444                  crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
445             status = wait_semaphore( crit, 60 );
446             if ( status == STATUS_TIMEOUT && TRACE_ON(relay) )
447             {
448                 ERR( "section %p %s wait timed out in thread %04x, blocked by %04x, retrying (5 min)\n",
449                      crit, debugstr_a(name), GetCurrentThreadId(), HandleToULong(crit->OwningThread) );
450                 status = wait_semaphore( crit, 300 );
451             }
452         }
453         if (status == STATUS_WAIT_0) break;
454
455         /* Throw exception only for Wine internal locks */
456         if ((!crit->DebugInfo) || (!crit->DebugInfo->Spare[0])) continue;
457
458         rec.ExceptionCode    = STATUS_POSSIBLE_DEADLOCK;
459         rec.ExceptionFlags   = 0;
460         rec.ExceptionRecord  = NULL;
461         rec.ExceptionAddress = RtlRaiseException;  /* sic */
462         rec.NumberParameters = 1;
463         rec.ExceptionInformation[0] = (ULONG_PTR)crit;
464         RtlRaiseException( &rec );
465     }
466     if (crit->DebugInfo) crit->DebugInfo->ContentionCount++;
467     return STATUS_SUCCESS;
468 }
469
470
471 /***********************************************************************
472  *           RtlpUnWaitCriticalSection   (NTDLL.@)
473  *
474  * Notifies other threads waiting on the busy critical section that it has
475  * become free.
476  * 
477  * PARAMS
478  *  crit [I/O] Critical section
479  *
480  * RETURNS
481  *  Success: STATUS_SUCCESS.
482  *  Failure: Any error returned by NtReleaseSemaphore()
483  *
484  * NOTES
485  *  Use RtlLeaveCriticalSection() instead of this function as it is often much
486  *  faster.
487  *
488  * SEE
489  *  RtlInitializeCriticalSectionEx(),
490  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
491  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
492  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
493  */
494 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
495 {
496     NTSTATUS ret;
497
498     /* debug info is cleared by MakeCriticalSectionGlobal */
499     if (!crit->DebugInfo || ((ret = fast_wake( crit )) == STATUS_NOT_IMPLEMENTED))
500     {
501         HANDLE sem = get_semaphore( crit );
502         ret = NtReleaseSemaphore( sem, 1, NULL );
503     }
504     if (ret) RtlRaiseStatus( ret );
505     return ret;
506 }
507
508
509 /***********************************************************************
510  *           RtlEnterCriticalSection   (NTDLL.@)
511  *
512  * Enters a critical section, waiting for it to become available if necessary.
513  *
514  * PARAMS
515  *  crit [I/O] Critical section to enter
516  *
517  * RETURNS
518  *  STATUS_SUCCESS. The critical section is held by the caller.
519  *  
520  * SEE
521  *  RtlInitializeCriticalSectionEx(),
522  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
523  *  RtlDeleteCriticalSection(), RtlSetCriticalSectionSpinCount(),
524  *  RtlLeaveCriticalSection(), RtlTryEnterCriticalSection()
525  */
526 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
527 {
528     if (crit->SpinCount)
529     {
530         ULONG count;
531
532         if (RtlTryEnterCriticalSection( crit )) return STATUS_SUCCESS;
533         for (count = crit->SpinCount; count > 0; count--)
534         {
535             if (crit->LockCount > 0) break;  /* more than one waiter, don't bother spinning */
536             if (crit->LockCount == -1)       /* try again */
537             {
538                 if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1) goto done;
539             }
540             small_pause();
541         }
542     }
543
544     if (interlocked_inc( &crit->LockCount ))
545     {
546         if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
547         {
548             crit->RecursionCount++;
549             return STATUS_SUCCESS;
550         }
551
552         /* Now wait for it */
553         RtlpWaitForCriticalSection( crit );
554     }
555 done:
556     crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
557     crit->RecursionCount = 1;
558     return STATUS_SUCCESS;
559 }
560
561
562 /***********************************************************************
563  *           RtlTryEnterCriticalSection   (NTDLL.@)
564  *
565  * Tries to enter a critical section without waiting.
566  *
567  * PARAMS
568  *  crit [I/O] Critical section to enter
569  *
570  * RETURNS
571  *  Success: TRUE. The critical section is held by the caller.
572  *  Failure: FALSE. The critical section is currently held by another thread.
573  *
574  * SEE
575  *  RtlInitializeCriticalSectionEx(),
576  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
577  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
578  *  RtlLeaveCriticalSection(), RtlSetCriticalSectionSpinCount()
579  */
580 BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
581 {
582     BOOL ret = FALSE;
583     if (interlocked_cmpxchg( &crit->LockCount, 0, -1 ) == -1)
584     {
585         crit->OwningThread   = ULongToHandle(GetCurrentThreadId());
586         crit->RecursionCount = 1;
587         ret = TRUE;
588     }
589     else if (crit->OwningThread == ULongToHandle(GetCurrentThreadId()))
590     {
591         interlocked_inc( &crit->LockCount );
592         crit->RecursionCount++;
593         ret = TRUE;
594     }
595     return ret;
596 }
597
598
599 /***********************************************************************
600  *           RtlLeaveCriticalSection   (NTDLL.@)
601  *
602  * Leaves a critical section.
603  *
604  * PARAMS
605  *  crit [I/O] Critical section to leave.
606  *
607  * RETURNS
608  *  STATUS_SUCCESS.
609  *
610  * SEE
611  *  RtlInitializeCriticalSectionEx(),
612  *  RtlInitializeCriticalSection(), RtlInitializeCriticalSectionAndSpinCount(),
613  *  RtlDeleteCriticalSection(), RtlEnterCriticalSection(),
614  *  RtlSetCriticalSectionSpinCount(), RtlTryEnterCriticalSection()
615  */
616 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit )
617 {
618     if (--crit->RecursionCount) interlocked_dec( &crit->LockCount );
619     else
620     {
621         crit->OwningThread = 0;
622         if (interlocked_dec( &crit->LockCount ) >= 0)
623         {
624             /* someone is waiting */
625             RtlpUnWaitCriticalSection( crit );
626         }
627     }
628     return STATUS_SUCCESS;
629 }