VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/posix/semeventmulti-posix.cpp@ 8256

Last change on this file since 8256 was 8245, checked in by vboxsync, 17 years ago

rebranding: IPRT files again.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 13.8 KB
Line 
1/* $Id: semeventmulti-posix.cpp 8245 2008-04-21 17:24:28Z vboxsync $ */
2/** @file
3 * IPRT - Multiple Release Event Semaphore, POSIX.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31/*******************************************************************************
32* Header Files *
33*******************************************************************************/
34#include <iprt/semaphore.h>
35#include <iprt/assert.h>
36#include <iprt/alloc.h>
37#include <iprt/asm.h>
38#include <iprt/err.h>
39
40#include <errno.h>
41#include <pthread.h>
42#include <unistd.h>
43#include <sys/time.h>
44
45
46/*******************************************************************************
47* Structures and Typedefs *
48*******************************************************************************/
49/** Posix internal representation of a Mutex Multi semaphore.
50 * The POSIX implementation uses a mutex and a condition variable to implement
51 * the automatic reset event semaphore semantics. */
52struct RTSEMEVENTMULTIINTERNAL
53{
54 /** pthread condition. */
55 pthread_cond_t Cond;
56 /** pthread mutex which protects the condition and the event state. */
57 pthread_mutex_t Mutex;
58 /** The state of the semaphore.
59 * This is operated while owning mutex and using atomic updating. */
60 volatile uint32_t u32State;
61 /** Number of waiters. */
62 volatile uint32_t cWaiters;
63};
64
65/** The valus of the u32State variable in RTSEMEVENTMULTIINTERNAL.
66 * @{ */
67/** The object isn't initialized. */
68#define EVENTMULTI_STATE_UNINITIALIZED 0
69/** The semaphore is is signaled. */
70#define EVENTMULTI_STATE_SIGNALED 0xff00ff00
71/** The semaphore is not signaled. */
72#define EVENTMULTI_STATE_NOT_SIGNALED 0x00ff00ff
73/** @} */
74
75
76
77/**
78 * Validate an event multi semaphore handle passed to one of the interface.
79 *
80 * @returns true if valid.
81 * @returns false if invalid.
82 * @param pThis Pointer to the event semaphore to validate.
83 */
84inline bool rtsemEventMultiValid(struct RTSEMEVENTMULTIINTERNAL *pThis)
85{
86 if ((uintptr_t)pThis < 0x10000)
87 return false;
88
89 uint32_t u32 = pThis->u32State; /* this is volatile, so a explicit read like this is needed. */
90 if ( u32 != EVENTMULTI_STATE_NOT_SIGNALED
91 && u32 != EVENTMULTI_STATE_SIGNALED)
92 return false;
93
94 return true;
95}
96
97
98RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
99{
100 int rc;
101
102 /*
103 * Allocate semaphore handle.
104 */
105 struct RTSEMEVENTMULTIINTERNAL *pThis = (struct RTSEMEVENTMULTIINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTMULTIINTERNAL));
106 if (pThis)
107 {
108 /*
109 * Create the condition variable.
110 */
111 pthread_condattr_t CondAttr;
112 rc = pthread_condattr_init(&CondAttr);
113 if (!rc)
114 {
115 rc = pthread_cond_init(&pThis->Cond, &CondAttr);
116 if (!rc)
117 {
118 /*
119 * Create the semaphore.
120 */
121 pthread_mutexattr_t MutexAttr;
122 rc = pthread_mutexattr_init(&MutexAttr);
123 if (!rc)
124 {
125 rc = pthread_mutex_init(&pThis->Mutex, &MutexAttr);
126 if (!rc)
127 {
128 pthread_mutexattr_destroy(&MutexAttr);
129 pthread_condattr_destroy(&CondAttr);
130
131 ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_NOT_SIGNALED);
132 ASMAtomicXchgU32(&pThis->cWaiters, 0);
133
134 *pEventMultiSem = pThis;
135 return VINF_SUCCESS;
136 }
137
138 pthread_mutexattr_destroy(&MutexAttr);
139 }
140 pthread_cond_destroy(&pThis->Cond);
141 }
142 pthread_condattr_destroy(&CondAttr);
143 }
144
145 rc = RTErrConvertFromErrno(rc);
146 RTMemFree(pThis);
147 }
148 else
149 rc = VERR_NO_MEMORY;
150
151 return rc;
152
153}
154
155
156RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
157{
158 /*
159 * Validate handle.
160 */
161 if (!rtsemEventMultiValid(EventMultiSem))
162 {
163 AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem));
164 return VERR_INVALID_HANDLE;
165 }
166
167 /*
168 * Abort all waiters forcing them to return failure.
169 */
170 struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
171 int rc;
172 for (int i = 30; i > 0; i--)
173 {
174 ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_UNINITIALIZED);
175 rc = pthread_cond_destroy(&pThis->Cond);
176 if (rc != EBUSY)
177 break;
178 pthread_cond_broadcast(&pThis->Cond);
179 usleep(1000);
180 } while (rc == EBUSY);
181 if (rc)
182 {
183 AssertMsgFailed(("Failed to destroy event sem %p, rc=%d.\n", EventMultiSem, rc));
184 return RTErrConvertFromErrno(rc);
185 }
186
187 /*
188 * Destroy the semaphore
189 * If it's busy we'll wait a bit to give the threads a chance to be scheduled.
190 */
191 for (int i = 30; i > 0; i--)
192 {
193 rc = pthread_mutex_destroy(&pThis->Mutex);
194 if (rc != EBUSY)
195 break;
196 usleep(1000);
197 }
198 if (rc)
199 {
200 AssertMsgFailed(("Failed to destroy event sem %p, rc=%d. (mutex)\n", EventMultiSem, rc));
201 return RTErrConvertFromErrno(rc);
202 }
203
204 /*
205 * Free the semaphore memory and be gone.
206 */
207 RTMemFree(pThis);
208 return VINF_SUCCESS;
209}
210
211
212RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
213{
214 /*
215 * Validate input.
216 */
217 if (!rtsemEventMultiValid(EventMultiSem))
218 {
219 AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem));
220 return VERR_INVALID_HANDLE;
221 }
222
223 /*
224 * Lock the mutex semaphore.
225 */
226 struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
227 int rc = pthread_mutex_lock(&pThis->Mutex);
228 if (rc)
229 {
230 AssertMsgFailed(("Failed to lock event sem %p, rc=%d.\n", EventMultiSem, rc));
231 return RTErrConvertFromErrno(rc);
232 }
233
234 /*
235 * Check the state.
236 */
237 if (pThis->u32State == EVENTMULTI_STATE_NOT_SIGNALED)
238 {
239 ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_SIGNALED);
240 rc = pthread_cond_broadcast(&pThis->Cond);
241 AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d.\n", EventMultiSem, rc));
242 }
243 else if (pThis->u32State == EVENTMULTI_STATE_SIGNALED)
244 {
245 rc = pthread_cond_broadcast(&pThis->Cond); /* give'm another kick... */
246 AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d. (2)\n", EventMultiSem, rc));
247 }
248 else
249 rc = VERR_SEM_DESTROYED;
250
251 /*
252 * Release the mutex and return.
253 */
254 int rc2 = pthread_mutex_unlock(&pThis->Mutex);
255 AssertMsg(!rc2, ("Failed to unlock event sem %p, rc=%d.\n", EventMultiSem, rc));
256 if (rc)
257 return RTErrConvertFromErrno(rc);
258 if (rc2)
259 return RTErrConvertFromErrno(rc2);
260
261 return VINF_SUCCESS;
262}
263
264
265RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
266{
267 /*
268 * Validate input.
269 */
270 if (!rtsemEventMultiValid(EventMultiSem))
271 {
272 AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem));
273 return VERR_INVALID_HANDLE;
274 }
275
276 /*
277 * Lock the mutex semaphore.
278 */
279 struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
280 int rc = pthread_mutex_lock(&pThis->Mutex);
281 if (rc)
282 {
283 AssertMsgFailed(("Failed to lock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
284 return RTErrConvertFromErrno(rc);
285 }
286
287 /*
288 * Check the state.
289 */
290 if (pThis->u32State == EVENTMULTI_STATE_SIGNALED)
291 ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_NOT_SIGNALED);
292 else if (pThis->u32State != EVENTMULTI_STATE_NOT_SIGNALED)
293 rc = VERR_SEM_DESTROYED;
294
295 /*
296 * Release the mutex and return.
297 */
298 rc = pthread_mutex_unlock(&pThis->Mutex);
299 if (rc)
300 {
301 AssertMsgFailed(("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
302 return RTErrConvertFromErrno(rc);
303 }
304
305 return VINF_SUCCESS;
306
307}
308
309
310static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fAutoResume)
311{
312 /*
313 * Validate input.
314 */
315 if (!rtsemEventMultiValid(EventMultiSem))
316 {
317 AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem));
318 return VERR_INVALID_HANDLE;
319 }
320
321 /*
322 * Timed or indefinite wait?
323 */
324 struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
325 if (cMillies == RT_INDEFINITE_WAIT)
326 {
327 /* take mutex */
328 int rc = pthread_mutex_lock(&pThis->Mutex);
329 if (rc)
330 {
331 AssertMsgFailed(("Failed to lock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
332 return RTErrConvertFromErrno(rc);
333 }
334 ASMAtomicIncU32(&pThis->cWaiters);
335
336 for (;;)
337 {
338 /* check state. */
339 if (pThis->u32State == EVENTMULTI_STATE_SIGNALED)
340 {
341 ASMAtomicDecU32(&pThis->cWaiters);
342 rc = pthread_mutex_unlock(&pThis->Mutex);
343 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
344 return VINF_SUCCESS;
345 }
346 if (pThis->u32State == EVENTMULTI_STATE_UNINITIALIZED)
347 {
348 rc = pthread_mutex_unlock(&pThis->Mutex);
349 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
350 return VERR_SEM_DESTROYED;
351 }
352
353 /* wait */
354 rc = pthread_cond_wait(&pThis->Cond, &pThis->Mutex);
355 if (rc)
356 {
357 AssertMsgFailed(("Failed to wait on event multi sem %p, rc=%d.\n", EventMultiSem, rc));
358 ASMAtomicDecU32(&pThis->cWaiters);
359 int rc2 = pthread_mutex_unlock(&pThis->Mutex);
360 AssertMsg(!rc2, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc2)); NOREF(rc2);
361 return RTErrConvertFromErrno(rc);
362 }
363 }
364 }
365 else
366 {
367 /*
368 * Get current time and calc end of wait time.
369 */
370 struct timespec ts = {0,0};
371#ifdef RT_OS_DARWIN
372 struct timeval tv = {0,0};
373 gettimeofday(&tv, NULL);
374 ts.tv_sec = tv.tv_sec;
375 ts.tv_nsec = tv.tv_usec * 1000;
376#else
377 clock_gettime(CLOCK_REALTIME, &ts);
378#endif
379 if (cMillies != 0)
380 {
381 ts.tv_nsec += (cMillies % 1000) * 1000000;
382 ts.tv_sec += cMillies / 1000;
383 if (ts.tv_nsec >= 1000000000)
384 {
385 ts.tv_nsec -= 1000000000;
386 ts.tv_sec++;
387 }
388 }
389
390 /* take mutex */
391#ifdef RT_OS_DARWIN
392 int rc = pthread_mutex_lock(&pThis->Mutex);
393#else
394 int rc = pthread_mutex_timedlock(&pThis->Mutex, &ts);
395#endif
396 if (rc)
397 {
398 AssertMsg(rc == ETIMEDOUT, ("Failed to lock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
399 return RTErrConvertFromErrno(rc);
400 }
401 ASMAtomicIncU32(&pThis->cWaiters);
402
403 for (;;)
404 {
405 /* check state. */
406 if (pThis->u32State == EVENTMULTI_STATE_SIGNALED)
407 {
408 ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_NOT_SIGNALED);
409 ASMAtomicDecU32(&pThis->cWaiters);
410 rc = pthread_mutex_unlock(&pThis->Mutex);
411 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
412 return VINF_SUCCESS;
413 }
414 if (pThis->u32State == EVENTMULTI_STATE_UNINITIALIZED)
415 {
416 rc = pthread_mutex_unlock(&pThis->Mutex);
417 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
418 return VERR_SEM_DESTROYED;
419 }
420
421 /* wait */
422 rc = pthread_cond_timedwait(&pThis->Cond, &pThis->Mutex, &ts);
423 if (rc && (rc != EINTR || !fAutoResume)) /* according to SuS this function shall not return EINTR, but linux man page says differently. */
424 {
425 AssertMsg(rc == ETIMEDOUT, ("Failed to wait on event multi sem %p, rc=%d.\n", EventMultiSem, rc));
426 ASMAtomicDecU32(&pThis->cWaiters);
427 int rc2 = pthread_mutex_unlock(&pThis->Mutex);
428 AssertMsg(!rc2, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc2)); NOREF(rc2);
429 return RTErrConvertFromErrno(rc);
430 }
431 }
432 }
433}
434
435
436RTDECL(int) RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
437{
438 int rc = rtSemEventMultiWait(EventMultiSem, cMillies, true);
439 Assert(rc != VERR_INTERRUPTED);
440 return rc;
441}
442
443
444RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
445{
446 return rtSemEventMultiWait(EventMultiSem, cMillies, false);
447}
448
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