r3/posix/semevent-posix.cpp

	semevent-posix.cpp revision 0fcf82b2591711fa8980e8f5d9cad1b8f222d6d7
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/* $Id$ */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** @file
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * IPRT - Event Semaphore, POSIX.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/*
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * Copyright (C) 2006-2010 Sun Microsystems, Inc.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync *
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * available from http://www.virtualbox.org. This file is free software;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * you can redistribute it and/or modify it under the terms of the GNU
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * General Public License (GPL) as published by the Free Software
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync *
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * The contents of this file may alternatively be used under the terms
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * of the Common Development and Distribution License Version 1.0
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * VirtualBox OSE distribution, in which case the provisions of the
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * CDDL are applicable instead of those of the GPL.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync *
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * You may elect to license modified versions of this file under the
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * terms and conditions of either the GPL or the CDDL or both.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync *
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * additional information or have any questions.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/*******************************************************************************
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync*   Header Files                                                               *
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync*******************************************************************************/
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <iprt/semaphore.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include "internal/iprt.h"
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <iprt/asm.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <iprt/assert.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <iprt/err.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <iprt/mem.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <iprt/lockvalidator.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include "internal/strict.h"
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <errno.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <pthread.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <unistd.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#include <sys/time.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#ifdef RT_OS_DARWIN
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync# define pthread_yield() pthread_yield_np()
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#endif
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#ifdef RT_OS_SOLARIS
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync# include <sched.h>
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync# define pthread_yield() sched_yield()
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#endif
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/*******************************************************************************
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync*   Structures and Typedefs                                                    *
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync*******************************************************************************/
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** Internal representation of the POSIX implementation of an Event semaphore.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * The POSIX implementation uses a mutex and a condition variable to implement
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * the automatic reset event semaphore semantics.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsyncstruct RTSEMEVENTINTERNAL
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync{
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /** pthread condition. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    pthread_cond_t      Cond;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /** pthread mutex which protects the condition and the event state. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    pthread_mutex_t     Mutex;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /** The state of the semaphore.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync     * This is operated while owning mutex and using atomic updating. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    volatile uint32_t   u32State;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /** Number of waiters. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    volatile uint32_t   cWaiters;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#ifdef RTSEMEVENT_STRICT
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /** Signallers. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    RTLOCKVALRECSHRD    Signallers;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /** Indicates that lock validation should be performed. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    bool volatile       fEverHadSignallers;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#endif
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync};
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** The valus of the u32State variable in a RTSEMEVENTINTERNAL.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync * @{ */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** The object isn't initialized. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#define EVENT_STATE_UNINITIALIZED   0
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** The semaphore is signaled. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#define EVENT_STATE_SIGNALED        0xff00ff00
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** The semaphore is not signaled. */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync#define EVENT_STATE_NOT_SIGNALED    0x00ff00ff
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync/** @} */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsyncRTDECL(int)  RTSemEventCreate(PRTSEMEVENT pEventSem)
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync{
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    int rc;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    /*
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync     * Allocate semaphore handle.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync     */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    struct RTSEMEVENTINTERNAL *pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTINTERNAL));
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    if (pThis)
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync    {
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync        /*
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync         * Create the condition variable.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync         */
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync        pthread_condattr_t CondAttr;
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync        rc = pthread_condattr_init(&CondAttr);
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync        if (!rc)
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync        {
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync            rc = pthread_cond_init(&pThis->Cond, &CondAttr);
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync            if (!rc)
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync            {
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync                /*
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync                 * Create the semaphore.
897afdda769ec9fd3dbe35b57a3a041cfde0d6a7vboxsync                 */
                pthread_mutexattr_t MutexAttr;
                rc = pthread_mutexattr_init(&MutexAttr);
                if (!rc)
                {
                    rc = pthread_mutex_init(&pThis->Mutex, &MutexAttr);
                    if (!rc)
                    {
                        pthread_mutexattr_destroy(&MutexAttr);
                        pthread_condattr_destroy(&CondAttr);

                        ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
                        ASMAtomicXchgU32(&pThis->cWaiters, 0);
#ifdef RTSEMEVENT_STRICT
                        RTLockValidatorRecSharedInit(&pThis->Signallers,
                                                     NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_ANY,
                                                     "RTSemEvent", pThis, true /*fSignaller*/);
                        pThis->fEverHadSignallers = false;
#endif

                        *pEventSem = pThis;
                        return VINF_SUCCESS;
                    }
                    pthread_mutexattr_destroy(&MutexAttr);
                }
                pthread_cond_destroy(&pThis->Cond);
            }
            pthread_condattr_destroy(&CondAttr);
        }

        rc = RTErrConvertFromErrno(rc);
        RTMemFree(pThis);
    }
    else
        rc = VERR_NO_MEMORY;

    return rc;
}


RTDECL(int)  RTSemEventDestroy(RTSEMEVENT EventSem)
{
    /*
     * Validate handle.
     */
    struct RTSEMEVENTINTERNAL *pThis = EventSem;
    if (pThis == NIL_RTSEMEVENT)        /* don't bitch */
        return VERR_INVALID_HANDLE;
    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    uint32_t    u32 = pThis->u32State;
    AssertReturn(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED, VERR_INVALID_HANDLE);

    /*
     * Abort all waiters forcing them to return failure.
     */
    int rc;
    for (int i = 30; i > 0; i--)
    {
        ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_UNINITIALIZED);
        rc = pthread_cond_destroy(&pThis->Cond);
        if (rc != EBUSY)
            break;
        pthread_cond_broadcast(&pThis->Cond);
        usleep(1000);
    }
    if (rc)
    {
        AssertMsgFailed(("Failed to destroy event sem %p, rc=%d.\n", EventSem, rc));
        return RTErrConvertFromErrno(rc);
    }

    /*
     * Destroy the semaphore
     * If it's busy we'll wait a bit to give the threads a chance to be scheduled.
     */
    for (int i = 30; i > 0; i--)
    {
        rc = pthread_mutex_destroy(&pThis->Mutex);
        if (rc != EBUSY)
            break;
        usleep(1000);
    }
    if (rc)
    {
        AssertMsgFailed(("Failed to destroy event sem %p, rc=%d. (mutex)\n", EventSem, rc));
        return RTErrConvertFromErrno(rc);
    }

    /*
     * Free the semaphore memory and be gone.
     */
#ifdef RTSEMEVENT_STRICT
    RTLockValidatorRecSharedDelete(&pThis->Signallers);
#endif
    RTMemFree(pThis);
    return VINF_SUCCESS;
}


RTDECL(int)  RTSemEventSignal(RTSEMEVENT EventSem)
{
    /*
     * Validate input.
     */
    struct RTSEMEVENTINTERNAL *pThis = EventSem;
    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    uint32_t    u32 = pThis->u32State;
    AssertReturn(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED, VERR_INVALID_HANDLE);

#ifdef RTSEMEVENT_STRICT
    if (pThis->fEverHadSignallers)
    {
        int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD);
        if (RT_FAILURE(rc9))
            return rc9;
    }
#endif

    /*
     * Lock the mutex semaphore.
     */
    int rc = pthread_mutex_lock(&pThis->Mutex);
    if (rc)
    {
        AssertMsgFailed(("Failed to lock event sem %p, rc=%d.\n", EventSem, rc));
        return RTErrConvertFromErrno(rc);
    }

    /*
     * Check the state.
     */
    if (pThis->u32State == EVENT_STATE_NOT_SIGNALED)
    {
        ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_SIGNALED);
        rc = pthread_cond_signal(&pThis->Cond);
        AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d.\n", EventSem, rc));
    }
    else if (pThis->u32State == EVENT_STATE_SIGNALED)
    {
        rc = pthread_cond_signal(&pThis->Cond); /* give'm another kick... */
        AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d. (2)\n", EventSem, rc));
    }
    else
        rc = VERR_SEM_DESTROYED;

    /*
     * Release the mutex and return.
     */
    int rc2 = pthread_mutex_unlock(&pThis->Mutex);
    AssertMsg(!rc2, ("Failed to unlock event sem %p, rc=%d.\n", EventSem, rc));
    if (rc)
        return RTErrConvertFromErrno(rc);
    if (rc2)
        return RTErrConvertFromErrno(rc2);

    return VINF_SUCCESS;
}


DECL_FORCE_INLINE(int) rtSemEventWait(RTSEMEVENT EventSem, unsigned cMillies, bool fAutoResume)
{
    PCRTLOCKVALSRCPOS  pSrcPos = NULL;

    /*
     * Validate input.
     */
    struct RTSEMEVENTINTERNAL *pThis = EventSem;
    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    uint32_t    u32 = pThis->u32State;
    AssertReturn(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED, VERR_INVALID_HANDLE);

    /*
     * Timed or indefinite wait?
     */
    if (cMillies == RT_INDEFINITE_WAIT)
    {
        /* for fairness, yield before going to sleep. */
        if (    ASMAtomicIncU32(&pThis->cWaiters) > 1
            &&  pThis->u32State == EVENT_STATE_SIGNALED)
            pthread_yield();

         /* take mutex */
        int rc = pthread_mutex_lock(&pThis->Mutex);
        if (rc)
        {
            ASMAtomicDecU32(&pThis->cWaiters);
            AssertMsgFailed(("Failed to lock event sem %p, rc=%d.\n", EventSem, rc));
            return RTErrConvertFromErrno(rc);
        }

        for (;;)
        {
            /* check state. */
            if (pThis->u32State == EVENT_STATE_SIGNALED)
            {
                ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
                ASMAtomicDecU32(&pThis->cWaiters);
                rc = pthread_mutex_unlock(&pThis->Mutex);
                AssertMsg(!rc, ("Failed to unlock event sem %p, rc=%d.\n", EventSem, rc)); NOREF(rc);
                return VINF_SUCCESS;
            }
            if (pThis->u32State == EVENT_STATE_UNINITIALIZED)
            {
                rc = pthread_mutex_unlock(&pThis->Mutex);
                AssertMsg(!rc, ("Failed to unlock event sem %p, rc=%d.\n", EventSem, rc)); NOREF(rc);
                return VERR_SEM_DESTROYED;
            }

            /* wait */
#ifdef RTSEMEVENT_STRICT
            RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
            if (pThis->fEverHadSignallers)
            {
                rc = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false,
                                                           RTTHREADSTATE_EVENT, true);
                if (RT_FAILURE(rc))
                {
                    ASMAtomicDecU32(&pThis->cWaiters);
                    pthread_mutex_unlock(&pThis->Mutex);
                    return rc;
                }
            }
#else
            RTTHREAD hThreadSelf = RTThreadSelf();
#endif
            RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT, true);
            rc = pthread_cond_wait(&pThis->Cond, &pThis->Mutex);
            RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT);
            if (rc)
            {
                AssertMsgFailed(("Failed to wait on event sem %p, rc=%d.\n", EventSem, rc));
                ASMAtomicDecU32(&pThis->cWaiters);
                int rc2 = pthread_mutex_unlock(&pThis->Mutex);
                AssertMsg(!rc2, ("Failed to unlock event sem %p, rc=%d.\n", EventSem, rc2)); NOREF(rc2);
                return RTErrConvertFromErrno(rc);
            }
        }
    }
    else
    {
        /*
         * Get current time and calc end of wait time.
         */
        struct timespec     ts = {0,0};
#ifdef RT_OS_DARWIN
        struct timeval      tv = {0,0};
        gettimeofday(&tv, NULL);
        ts.tv_sec = tv.tv_sec;
        ts.tv_nsec = tv.tv_usec * 1000;
#else
        clock_gettime(CLOCK_REALTIME, &ts);
#endif
        if (cMillies != 0)
        {
            ts.tv_nsec += (cMillies % 1000) * 1000000;
            ts.tv_sec  += cMillies / 1000;
            if (ts.tv_nsec >= 1000000000)
            {
                ts.tv_nsec -= 1000000000;
                ts.tv_sec++;
            }
        }

        /* for fairness, yield before going to sleep. */
        if (ASMAtomicIncU32(&pThis->cWaiters) > 1 && cMillies)
            pthread_yield();

        /* take mutex */
        int rc = pthread_mutex_lock(&pThis->Mutex);
        if (rc)
        {
            ASMAtomicDecU32(&pThis->cWaiters);
            AssertMsg(rc == ETIMEDOUT, ("Failed to lock event sem %p, rc=%d.\n", EventSem, rc));
            return RTErrConvertFromErrno(rc);
        }

        for (;;)
        {
            /* check state. */
            if (pThis->u32State == EVENT_STATE_SIGNALED)
            {
                ASMAtomicXchgU32(&pThis->u32State, EVENT_STATE_NOT_SIGNALED);
                ASMAtomicDecU32(&pThis->cWaiters);
                rc = pthread_mutex_unlock(&pThis->Mutex);
                AssertMsg(!rc, ("Failed to unlock event sem %p, rc=%d.\n", EventSem, rc)); NOREF(rc);
                return VINF_SUCCESS;
            }
            if (pThis->u32State == EVENT_STATE_UNINITIALIZED)
            {
                rc = pthread_mutex_unlock(&pThis->Mutex);
                AssertMsg(!rc, ("Failed to unlock event sem %p, rc=%d.\n", EventSem, rc)); NOREF(rc);
                return VERR_SEM_DESTROYED;
            }

            /* we're done if the timeout is 0. */
            if (!cMillies)
            {
                ASMAtomicDecU32(&pThis->cWaiters);
                rc = pthread_mutex_unlock(&pThis->Mutex);
                return VERR_SEM_BUSY;
            }

            /* wait */
#ifdef RTSEMEVENT_STRICT
            RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
            if (pThis->fEverHadSignallers)
            {
                rc = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false,
                                                           RTTHREADSTATE_EVENT, true);
                if (RT_FAILURE(rc))
                {
                    ASMAtomicDecU32(&pThis->cWaiters);
                    pthread_mutex_unlock(&pThis->Mutex);
                    return rc;
                }
            }
#else
            RTTHREAD hThreadSelf = RTThreadSelf();
#endif
            RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT, true);
            rc = pthread_cond_timedwait(&pThis->Cond, &pThis->Mutex, &ts);
            RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT);
            if (rc && (rc != EINTR || !fAutoResume)) /* according to SuS this function shall not return EINTR, but linux man page says differently. */
            {
                AssertMsg(rc == ETIMEDOUT, ("Failed to wait on event sem %p, rc=%d.\n", EventSem, rc));
                ASMAtomicDecU32(&pThis->cWaiters);
                int rc2 = pthread_mutex_unlock(&pThis->Mutex);
                AssertMsg(!rc2, ("Failed to unlock event sem %p, rc2=%d.\n", EventSem, rc2)); NOREF(rc2);
                return RTErrConvertFromErrno(rc);
            }
        } /* for (;;) */
    }
}


RTDECL(int)  RTSemEventWait(RTSEMEVENT EventSem, unsigned cMillies)
{
    int rc = rtSemEventWait(EventSem, cMillies, true);
    Assert(rc != VERR_INTERRUPTED);
    return rc;
}


RTDECL(int)  RTSemEventWaitNoResume(RTSEMEVENT EventSem, unsigned cMillies)
{
    return rtSemEventWait(EventSem, cMillies, false);
}


RTDECL(void) RTSemEventSetSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
{
#ifdef RTSEMEVENT_STRICT
    struct RTSEMEVENTINTERNAL *pThis = hEventSem;
    AssertPtrReturnVoid(pThis);
    uint32_t u32 = pThis->u32State;
    AssertReturnVoid(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED);

    ASMAtomicWriteBool(&pThis->fEverHadSignallers, true);
    RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL);
#endif
}


RTDECL(void) RTSemEventAddSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
{
#ifdef RTSEMEVENT_STRICT
    struct RTSEMEVENTINTERNAL *pThis = hEventSem;
    AssertPtrReturnVoid(pThis);
    uint32_t u32 = pThis->u32State;
    AssertReturnVoid(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED);

    ASMAtomicWriteBool(&pThis->fEverHadSignallers, true);
    RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL);
#endif
}


RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
{
#ifdef RTSEMEVENT_STRICT
    struct RTSEMEVENTINTERNAL *pThis = hEventSem;
    AssertPtrReturnVoid(pThis);
    uint32_t u32 = pThis->u32State;
    AssertReturnVoid(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED);

    RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread);
#endif
}