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 : "" (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 : "" (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, ×pec ) == -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 }
630
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.