VirtualBox

source: vbox/trunk/src/VBox/Runtime/generic/critsect-generic.cpp@ 59039

Last change on this file since 59039 was 59039, checked in by vboxsync, 9 years ago

IPRT: trace point build fix.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 18.2 KB
Line 
1/* $Id: critsect-generic.cpp 59039 2015-12-07 18:07:52Z vboxsync $ */
2/** @file
3 * IPRT - Critical Section, Generic.
4 */
5
6/*
7 * Copyright (C) 2006-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#define RTCRITSECT_WITHOUT_REMAPPING
32#include <iprt/critsect.h>
33#include "internal/iprt.h"
34
35#include <iprt/semaphore.h>
36#include <iprt/thread.h>
37#include <iprt/assert.h>
38#include <iprt/asm.h>
39#include <iprt/err.h>
40#include "internal/thread.h"
41#include "internal/strict.h"
42
43/* Two issues here, (1) the tracepoint generator uses IPRT, and (2) only one .d
44 file per module. */
45#ifdef IPRT_WITH_DTRACE
46# include IPRT_DTRACE_INCLUDE
47# ifdef IPRT_DTRACE_PREFIX
48# define IPRT_CRITSECT_ENTERED RT_CONCAT(IPRT_DTRACE_PREFIX,IPRT_CRITSECT_ENTERED)
49# define IPRT_CRITSECT_LEAVING RT_CONCAT(IPRT_DTRACE_PREFIX,IPRT_CRITSECT_LEAVING)
50# define IPRT_CRITSECT_BUSY RT_CONCAT(IPRT_DTRACE_PREFIX,IPRT_CRITSECT_BUSY)
51# define IPRT_CRITSECT_WAITING RT_CONCAT(IPRT_DTRACE_PREFIX,IPRT_CRITSECT_WAITING)
52# endif
53#else
54# define IPRT_CRITSECT_ENTERED(a_pvCritSect, a_pszName, a_cLockers, a_cNestings) do {} while (0)
55# define IPRT_CRITSECT_LEAVING(a_pvCritSect, a_pszName, a_cLockers, a_cNestings) do {} while (0)
56# define IPRT_CRITSECT_BUSY( a_pvCritSect, a_pszName, a_cLockers, a_pvNativeOwnerThread) do {} while (0)
57# define IPRT_CRITSECT_WAITING(a_pvCritSect, a_pszName, a_cLockers, a_pvNativeOwnerThread) do {} while (0)
58#endif
59
60
61
62RTDECL(int) RTCritSectInit(PRTCRITSECT pCritSect)
63{
64 return RTCritSectInitEx(pCritSect, 0, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "RTCritSect");
65}
66RT_EXPORT_SYMBOL(RTCritSectInit);
67
68
69RTDECL(int) RTCritSectInitEx(PRTCRITSECT pCritSect, uint32_t fFlags, RTLOCKVALCLASS hClass, uint32_t uSubClass,
70 const char *pszNameFmt, ...)
71{
72 AssertReturn(!(fFlags & ~(RTCRITSECT_FLAGS_NO_NESTING | RTCRITSECT_FLAGS_NO_LOCK_VAL | RTCRITSECT_FLAGS_BOOTSTRAP_HACK | RTCRITSECT_FLAGS_NOP)),
73 VERR_INVALID_PARAMETER);
74
75 /*
76 * Initialize the structure and
77 */
78 pCritSect->u32Magic = RTCRITSECT_MAGIC;
79#ifdef IN_RING0
80 pCritSect->fFlags = fFlags | RTCRITSECT_FLAGS_RING0;
81#else
82 pCritSect->fFlags = fFlags & ~RTCRITSECT_FLAGS_RING0;
83#endif
84 pCritSect->cNestings = 0;
85 pCritSect->cLockers = -1;
86 pCritSect->NativeThreadOwner = NIL_RTNATIVETHREAD;
87 pCritSect->pValidatorRec = NULL;
88 int rc = VINF_SUCCESS;
89#ifdef RTCRITSECT_STRICT
90 if (!(fFlags & (RTCRITSECT_FLAGS_BOOTSTRAP_HACK | RTCRITSECT_FLAGS_NOP)))
91 {
92 if (!pszNameFmt)
93 {
94 static uint32_t volatile s_iCritSectAnon = 0;
95 rc = RTLockValidatorRecExclCreate(&pCritSect->pValidatorRec, hClass, uSubClass, pCritSect,
96 !(fFlags & RTCRITSECT_FLAGS_NO_LOCK_VAL),
97 "RTCritSect-%u", ASMAtomicIncU32(&s_iCritSectAnon) - 1);
98 }
99 else
100 {
101 va_list va;
102 va_start(va, pszNameFmt);
103 rc = RTLockValidatorRecExclCreateV(&pCritSect->pValidatorRec, hClass, uSubClass, pCritSect,
104 !(fFlags & RTCRITSECT_FLAGS_NO_LOCK_VAL), pszNameFmt, va);
105 va_end(va);
106 }
107 }
108#endif
109 if (RT_SUCCESS(rc))
110 {
111#ifdef IN_RING0
112 rc = RTSemEventCreate(&pCritSect->EventSem);
113
114#else
115 rc = RTSemEventCreateEx(&pCritSect->EventSem,
116 fFlags & RTCRITSECT_FLAGS_BOOTSTRAP_HACK
117 ? RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK
118 : RTSEMEVENT_FLAGS_NO_LOCK_VAL,
119 NIL_RTLOCKVALCLASS,
120 NULL);
121#endif
122 if (RT_SUCCESS(rc))
123 return VINF_SUCCESS;
124#ifdef RTCRITSECT_STRICT
125 RTLockValidatorRecExclDestroy(&pCritSect->pValidatorRec);
126#endif
127 }
128
129 AssertRC(rc);
130 pCritSect->EventSem = NULL;
131 pCritSect->u32Magic = (uint32_t)rc;
132 return rc;
133}
134RT_EXPORT_SYMBOL(RTCritSectInitEx);
135
136
137RTDECL(uint32_t) RTCritSectSetSubClass(PRTCRITSECT pCritSect, uint32_t uSubClass)
138{
139# ifdef RTCRITSECT_STRICT
140 AssertPtrReturn(pCritSect, RTLOCKVAL_SUB_CLASS_INVALID);
141 AssertReturn(pCritSect->u32Magic == RTCRITSECT_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID);
142 AssertReturn(!(pCritSect->fFlags & RTCRITSECT_FLAGS_NOP), RTLOCKVAL_SUB_CLASS_INVALID);
143 return RTLockValidatorRecExclSetSubClass(pCritSect->pValidatorRec, uSubClass);
144# else
145 return RTLOCKVAL_SUB_CLASS_INVALID;
146# endif
147}
148
149
150DECL_FORCE_INLINE(int) rtCritSectTryEnter(PRTCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
151{
152 Assert(pCritSect);
153 Assert(pCritSect->u32Magic == RTCRITSECT_MAGIC);
154 /*AssertReturn(pCritSect->u32Magic == RTCRITSECT_MAGIC, VERR_SEM_DESTROYED);*/
155#ifdef IN_RING0
156 Assert(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0);
157#else
158 Assert(!(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0));
159#endif
160
161 /*
162 * Return straight away if NOP.
163 */
164 if (pCritSect->fFlags & RTCRITSECT_FLAGS_NOP)
165 return VINF_SUCCESS;
166
167 /*
168 * Try take the lock. (cLockers is -1 if it's free)
169 */
170 RTNATIVETHREAD NativeThreadSelf = RTThreadNativeSelf();
171 if (!ASMAtomicCmpXchgS32(&pCritSect->cLockers, 0, -1))
172 {
173 /*
174 * Somebody is owning it (or will be soon). Perhaps it's us?
175 */
176 if (pCritSect->NativeThreadOwner == NativeThreadSelf)
177 {
178 if (!(pCritSect->fFlags & RTCRITSECT_FLAGS_NO_NESTING))
179 {
180#ifdef RTCRITSECT_STRICT
181 int rc9 = RTLockValidatorRecExclRecursion(pCritSect->pValidatorRec, pSrcPos);
182 if (RT_FAILURE(rc9))
183 return rc9;
184#endif
185 int32_t cLockers = ASMAtomicIncS32(&pCritSect->cLockers); NOREF(cLockers);
186 pCritSect->cNestings++;
187 IPRT_CRITSECT_ENTERED(pCritSect, NULL, cLockers, pCritSect->cNestings);
188 return VINF_SUCCESS;
189 }
190 AssertMsgFailed(("Nested entry of critsect %p\n", pCritSect));
191 return VERR_SEM_NESTED;
192 }
193 IPRT_CRITSECT_BUSY(pCritSect, NULL, pCritSect->cLockers, (void *)pCritSect->NativeThreadOwner);
194 return VERR_SEM_BUSY;
195 }
196
197 /*
198 * First time
199 */
200 pCritSect->cNestings = 1;
201 ASMAtomicWriteHandle(&pCritSect->NativeThreadOwner, NativeThreadSelf);
202#ifdef RTCRITSECT_STRICT
203 RTLockValidatorRecExclSetOwner(pCritSect->pValidatorRec, NIL_RTTHREAD, pSrcPos, true);
204#endif
205 IPRT_CRITSECT_ENTERED(pCritSect, NULL, 0, 1);
206
207 return VINF_SUCCESS;
208}
209
210
211RTDECL(int) RTCritSectTryEnter(PRTCRITSECT pCritSect)
212{
213#ifndef RTCRTISECT_STRICT
214 return rtCritSectTryEnter(pCritSect, NULL);
215#else
216 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
217 return rtCritSectTryEnter(pCritSect, &SrcPos);
218#endif
219}
220RT_EXPORT_SYMBOL(RTCritSectTryEnter);
221
222
223RTDECL(int) RTCritSectTryEnterDebug(PRTCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
224{
225 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
226 return rtCritSectTryEnter(pCritSect, &SrcPos);
227}
228RT_EXPORT_SYMBOL(RTCritSectTryEnterDebug);
229
230
231DECL_FORCE_INLINE(int) rtCritSectEnter(PRTCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
232{
233 AssertPtr(pCritSect);
234 AssertReturn(pCritSect->u32Magic == RTCRITSECT_MAGIC, VERR_SEM_DESTROYED);
235#ifdef IN_RING0
236 Assert(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0);
237#else
238 Assert(!(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0));
239#endif
240
241 /*
242 * Return straight away if NOP.
243 */
244 if (pCritSect->fFlags & RTCRITSECT_FLAGS_NOP)
245 return VINF_SUCCESS;
246
247 /*
248 * How is calling and is the order right?
249 */
250 RTNATIVETHREAD NativeThreadSelf = RTThreadNativeSelf();
251#ifdef RTCRITSECT_STRICT
252 RTTHREAD hThreadSelf = pCritSect->pValidatorRec
253 ? RTThreadSelfAutoAdopt()
254 : RTThreadSelf();
255 int rc9;
256 if (pCritSect->pValidatorRec) /* (bootstap) */
257 {
258 rc9 = RTLockValidatorRecExclCheckOrder(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
259 if (RT_FAILURE(rc9))
260 return rc9;
261 }
262#endif
263
264 /*
265 * Increment the waiter counter.
266 * This becomes 0 when the section is free.
267 */
268 int32_t cLockers = ASMAtomicIncS32(&pCritSect->cLockers);
269 if (cLockers > 0)
270 {
271 /*
272 * Nested?
273 */
274 if (pCritSect->NativeThreadOwner == NativeThreadSelf)
275 {
276 if (!(pCritSect->fFlags & RTCRITSECT_FLAGS_NO_NESTING))
277 {
278#ifdef RTCRITSECT_STRICT
279 rc9 = RTLockValidatorRecExclRecursion(pCritSect->pValidatorRec, pSrcPos);
280 if (RT_FAILURE(rc9))
281 {
282 ASMAtomicDecS32(&pCritSect->cLockers);
283 return rc9;
284 }
285#endif
286 pCritSect->cNestings++;
287 IPRT_CRITSECT_ENTERED(pCritSect, NULL, cLockers, pCritSect->cNestings);
288 return VINF_SUCCESS;
289 }
290
291 AssertBreakpoint(); /* don't do normal assertion here, the logger uses this code too. */
292 ASMAtomicDecS32(&pCritSect->cLockers);
293 return VERR_SEM_NESTED;
294 }
295
296 /*
297 * Wait for the current owner to release it.
298 */
299 IPRT_CRITSECT_WAITING(pCritSect, NULL, cLockers, (void *)pCritSect->NativeThreadOwner);
300#ifndef RTCRITSECT_STRICT
301 RTTHREAD hThreadSelf = RTThreadSelf();
302#endif
303 for (;;)
304 {
305#ifdef RTCRITSECT_STRICT
306 rc9 = RTLockValidatorRecExclCheckBlocking(pCritSect->pValidatorRec, hThreadSelf, pSrcPos,
307 !(pCritSect->fFlags & RTCRITSECT_FLAGS_NO_NESTING),
308 RT_INDEFINITE_WAIT, RTTHREADSTATE_CRITSECT, false);
309 if (RT_FAILURE(rc9))
310 {
311 ASMAtomicDecS32(&pCritSect->cLockers);
312 return rc9;
313 }
314#elif defined(IN_RING3)
315 RTThreadBlocking(hThreadSelf, RTTHREADSTATE_CRITSECT, false);
316#endif
317 int rc = RTSemEventWait(pCritSect->EventSem, RT_INDEFINITE_WAIT);
318#ifdef IN_RING3
319 RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_CRITSECT);
320#endif
321
322 if (pCritSect->u32Magic != RTCRITSECT_MAGIC)
323 return VERR_SEM_DESTROYED;
324 if (rc == VINF_SUCCESS)
325 break;
326 AssertMsg(rc == VERR_TIMEOUT || rc == VERR_INTERRUPTED, ("rc=%Rrc\n", rc));
327 }
328 AssertMsg(pCritSect->NativeThreadOwner == NIL_RTNATIVETHREAD, ("pCritSect->NativeThreadOwner=%p\n", pCritSect->NativeThreadOwner));
329 }
330
331 /*
332 * First time
333 */
334 pCritSect->cNestings = 1;
335 ASMAtomicWriteHandle(&pCritSect->NativeThreadOwner, NativeThreadSelf);
336#ifdef RTCRITSECT_STRICT
337 RTLockValidatorRecExclSetOwner(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, true);
338#endif
339 IPRT_CRITSECT_ENTERED(pCritSect, NULL, 0, 1);
340
341 return VINF_SUCCESS;
342}
343
344
345RTDECL(int) RTCritSectEnter(PRTCRITSECT pCritSect)
346{
347#ifndef RTCRITSECT_STRICT
348 return rtCritSectEnter(pCritSect, NULL);
349#else
350 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
351 return rtCritSectEnter(pCritSect, &SrcPos);
352#endif
353}
354RT_EXPORT_SYMBOL(RTCritSectEnter);
355
356
357RTDECL(int) RTCritSectEnterDebug(PRTCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
358{
359 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
360 return rtCritSectEnter(pCritSect, &SrcPos);
361}
362RT_EXPORT_SYMBOL(RTCritSectEnterDebug);
363
364
365RTDECL(int) RTCritSectLeave(PRTCRITSECT pCritSect)
366{
367 /*
368 * Assert sanity and check for NOP.
369 */
370 Assert(pCritSect);
371 Assert(pCritSect->u32Magic == RTCRITSECT_MAGIC);
372#ifdef IN_RING0
373 Assert(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0);
374#else
375 Assert(!(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0));
376#endif
377 if (pCritSect->fFlags & RTCRITSECT_FLAGS_NOP)
378 return VINF_SUCCESS;
379
380 /*
381 * Assert ownership and so on.
382 */
383 Assert(pCritSect->cNestings > 0);
384 Assert(pCritSect->cLockers >= 0);
385 Assert(pCritSect->NativeThreadOwner == RTThreadNativeSelf());
386
387#ifdef RTCRITSECT_STRICT
388 int rc9 = RTLockValidatorRecExclReleaseOwner(pCritSect->pValidatorRec, pCritSect->cNestings == 1);
389 if (RT_FAILURE(rc9))
390 return rc9;
391#endif
392
393 /*
394 * Decrement nestings, if <= 0 when we'll release the critsec.
395 */
396 uint32_t cNestings = --pCritSect->cNestings;
397 IPRT_CRITSECT_LEAVING(pCritSect, NULL, ASMAtomicUoReadS32(&pCritSect->cLockers) - 1, cNestings);
398 if (cNestings > 0)
399 ASMAtomicDecS32(&pCritSect->cLockers);
400 else
401 {
402 /*
403 * Set owner to zero.
404 * Decrement waiters, if >= 0 then we have to wake one of them up.
405 */
406 ASMAtomicWriteHandle(&pCritSect->NativeThreadOwner, NIL_RTNATIVETHREAD);
407 if (ASMAtomicDecS32(&pCritSect->cLockers) >= 0)
408 {
409 int rc = RTSemEventSignal(pCritSect->EventSem);
410 AssertReleaseMsg(RT_SUCCESS(rc), ("RTSemEventSignal -> %Rrc\n", rc));
411 }
412 }
413 return VINF_SUCCESS;
414}
415RT_EXPORT_SYMBOL(RTCritSectLeave);
416
417
418
419#ifdef IN_RING3
420
421static int rtCritSectEnterMultiple(size_t cCritSects, PRTCRITSECT *papCritSects, PCRTLOCKVALSRCPOS pSrcPos)
422{
423 Assert(cCritSects > 0);
424 AssertPtr(papCritSects);
425
426 /*
427 * Try get them all.
428 */
429 int rc = VERR_INVALID_PARAMETER;
430 size_t i;
431 for (i = 0; i < cCritSects; i++)
432 {
433 rc = rtCritSectTryEnter(papCritSects[i], pSrcPos);
434 if (RT_FAILURE(rc))
435 break;
436 }
437 if (RT_SUCCESS(rc))
438 return rc;
439
440 /*
441 * The retry loop.
442 */
443 for (unsigned cTries = 0; ; cTries++)
444 {
445 /*
446 * We've failed, release any locks we might have gotten. ('i' is the lock that failed btw.)
447 */
448 size_t j = i;
449 while (j-- > 0)
450 {
451 int rc2 = RTCritSectLeave(papCritSects[j]);
452 AssertRC(rc2);
453 }
454 if (rc != VERR_SEM_BUSY)
455 return rc;
456
457 /*
458 * Try prevent any theoretical synchronous races with other threads.
459 */
460 Assert(cTries < 1000000);
461 if (cTries > 10000)
462 RTThreadSleep(cTries % 3);
463
464 /*
465 * Wait on the one we failed to get.
466 */
467 rc = rtCritSectEnter(papCritSects[i], pSrcPos);
468 if (RT_FAILURE(rc))
469 return rc;
470
471 /*
472 * Try take the others.
473 */
474 for (j = 0; j < cCritSects; j++)
475 {
476 if (j != i)
477 {
478 rc = rtCritSectTryEnter(papCritSects[j], pSrcPos);
479 if (RT_FAILURE(rc))
480 break;
481 }
482 }
483 if (RT_SUCCESS(rc))
484 return rc;
485
486 /*
487 * We failed.
488 */
489 if (i > j)
490 {
491 int rc2 = RTCritSectLeave(papCritSects[i]);
492 AssertRC(rc2);
493 }
494 i = j;
495 }
496}
497
498
499RTDECL(int) RTCritSectEnterMultiple(size_t cCritSects, PRTCRITSECT *papCritSects)
500{
501#ifndef RTCRITSECT_STRICT
502 return rtCritSectEnterMultiple(cCritSects, papCritSects, NULL);
503#else
504 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
505 return rtCritSectEnterMultiple(cCritSects, papCritSects, &SrcPos);
506#endif
507}
508RT_EXPORT_SYMBOL(RTCritSectEnterMultiple);
509
510
511RTDECL(int) RTCritSectEnterMultipleDebug(size_t cCritSects, PRTCRITSECT *papCritSects, RTHCUINTPTR uId, RT_SRC_POS_DECL)
512{
513 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
514 return rtCritSectEnterMultiple(cCritSects, papCritSects, &SrcPos);
515}
516RT_EXPORT_SYMBOL(RTCritSectEnterMultipleDebug);
517
518
519
520RTDECL(int) RTCritSectLeaveMultiple(size_t cCritSects, PRTCRITSECT *papCritSects)
521{
522 int rc = VINF_SUCCESS;
523 for (size_t i = 0; i < cCritSects; i++)
524 {
525 int rc2 = RTCritSectLeave(papCritSects[i]);
526 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
527 rc = rc2;
528 }
529 return rc;
530}
531RT_EXPORT_SYMBOL(RTCritSectLeaveMultiple);
532
533#endif /* IN_RING3 */
534
535
536
537RTDECL(int) RTCritSectDelete(PRTCRITSECT pCritSect)
538{
539 /*
540 * Assert free waiters and so on.
541 */
542 Assert(pCritSect);
543 Assert(pCritSect->u32Magic == RTCRITSECT_MAGIC);
544 Assert(pCritSect->cNestings == 0);
545 Assert(pCritSect->cLockers == -1);
546 Assert(pCritSect->NativeThreadOwner == NIL_RTNATIVETHREAD);
547#ifdef IN_RING0
548 Assert(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0);
549#else
550 Assert(!(pCritSect->fFlags & RTCRITSECT_FLAGS_RING0));
551#endif
552
553 /*
554 * Invalidate the structure and free the mutex.
555 * In case someone is waiting we'll signal the semaphore cLockers + 1 times.
556 */
557 ASMAtomicWriteU32(&pCritSect->u32Magic, ~RTCRITSECT_MAGIC);
558 pCritSect->fFlags = 0;
559 pCritSect->cNestings = 0;
560 pCritSect->NativeThreadOwner= NIL_RTNATIVETHREAD;
561 RTSEMEVENT EventSem = pCritSect->EventSem;
562 pCritSect->EventSem = NIL_RTSEMEVENT;
563
564 while (pCritSect->cLockers-- >= 0)
565 RTSemEventSignal(EventSem);
566 ASMAtomicWriteS32(&pCritSect->cLockers, -1);
567 int rc = RTSemEventDestroy(EventSem);
568 AssertRC(rc);
569
570#ifdef RTCRITSECT_STRICT
571 RTLockValidatorRecExclDestroy(&pCritSect->pValidatorRec);
572#endif
573
574 return rc;
575}
576RT_EXPORT_SYMBOL(RTCritSectDelete);
577
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette