VirtualBox

Changeset 25720 in vbox


Ignore:
Timestamp:
Jan 11, 2010 1:57:09 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
56460
Message:

iprt: Added RTSemEventMultiCreateEx and did some cleanups of the RTSemEventMultiDestroy behavior wrt NIL handles.

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/semaphore.h

    r25717 r25720  
    5959
    6060/**
    61  * Create a event semaphore.
     61 * Create an event semaphore.
    6262 *
    6363 * @returns iprt status code.
    … …  
    6868
    6969/**
    70  * Creates a read/write semaphore.
     70 * Create an event semaphore.
    7171 *
    7272 * @returns iprt status code.
    … …  
    9191/** @} */
    9292
    93 
    9493/**
    9594 * Destroy an event semaphore.
    … …  
    183182
    184183/**
    185  * Create a event multi semaphore.
    186  *
    187  * @returns iprt status code.
    188  * @param   pEventMultiSem  Where to store the event multi semaphore handle.
    189  */
    190 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem);
     184 * Creates a multiple release event semaphore.
     185 *
     186 * @returns iprt status code.
     187 * @param   phEventMultiSem     Where to store the handle to the newly created
     188 *                              multiple release event semaphore.
     189 */
     190RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem);
     191
     192/**
     193 * Creates a multiple release event semaphore.
     194 *
     195 * @returns iprt status code.
     196 * @param   phEventMultiSem     Where to store the handle to the newly created
     197 *                              multiple release event semaphore.
     198 * @param   fFlags              Flags, any combination of the
     199 *                              RTSEMEVENTMULTI_FLAGS_XXX \#defines.
     200 * @param   hClass              The class (no reference consumed).  Since we
     201 *                              don't do order checks on event semaphores, the
     202 *                              use of the class is limited to controlling the
     203 *                              timeout threshold for deadlock detection.
     204 * @param   pszNameFmt          Name format string for the lock validator,
     205 *                              optional (NULL).  Max length is 32 bytes.
     206 * @param   ...                 Format string arguments.
     207 */
     208RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     209                                     const char *pszNameFmt, ...);
     210
     211/** @name RTSemMutexCreateEx flags
     212 * @{ */
     213/** Disables lock validation. */
     214#define RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL   UINT32_C(0x00000001)
     215/** @} */
    191216
    192217/**
    … …  
    194219 *
    195220 * @returns iprt status code.
    196  * @param   EventMultiSem   The event multi sempahore to destroy.
    197  */
    198 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem);
     221 * @param   hEventMultiSem      The multiple release event sempahore.  NIL is
     222 *                              quietly ignored (VINF_SUCCESS).
     223 */
     224RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem);
    199225
    200226/**
    … …  
    202228 *
    203229 * @returns iprt status code.
    204  * @param   EventMultiSem   The event multi semaphore to signal.
    205  */
    206 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem);
     230 * @param   hEventMultiSem      The multiple release event sempahore.
     231 */
     232RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem);
    207233
    208234/**
    … …  
    210236 *
    211237 * @returns iprt status code.
    212  * @param   EventMultiSem   The event multi semaphore to reset.
    213  */
    214 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem);
     238 * @param   hEventMultiSem      The multiple release event sempahore.
     239 */
     240RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem);
    215241
    216242/**
    … …  
    222248 * @returns iprt status code.
    223249 *          Will not return VERR_INTERRUPTED.
    224  * @param   EventMultiSem   The event multi semaphore to wait on.
    225  * @param   cMillies        Number of milliseconds to wait.
    226  */
    227 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
     250 * @param   hEventMultiSem      The multiple release event sempahore.
     251 * @param   cMillies            Number of milliseconds to wait.
     252 */
     253RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies);
    228254
    229255
    … …  
    234260 *
    235261 * @returns iprt status code.
    236  * @param   EventMultiSem   The event multi semaphore to wait on.
    237  * @param   cMillies        Number of milliseconds to wait.
    238  */
    239 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies);
     262 * @param   hEventMultiSem      The multiple release event sempahore.
     263 * @param   cMillies            Number of milliseconds to wait.
     264 */
     265RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies);
    240266
    241267/**

  • trunk/src/VBox/Runtime/r0drv/darwin/semaphore-r0drv-darwin.cpp

    r25717 r25720  
    219219    PRTSEMEVENTINTERNAL pThis = (PRTSEMEVENTINTERNAL)hEventSem;
    220220    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    221     AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC,
    222                     ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    223                     VERR_INVALID_HANDLE);
     221    AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
    224222    if (cMillies)
    225223        RT_ASSERT_PREEMPTIBLE();
    … …  
    320318
    321319
    322 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    323 {
    324     Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
    325     AssertPtrReturn(pEventMultiSem, VERR_INVALID_POINTER);
     320RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     321{
     322    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     323}
     324
     325
     326RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     327                                     const char *pszNameFmt, ...)
     328{
     329    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     330    AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
     331    AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);
    326332    RT_ASSERT_PREEMPTIBLE();
    327333
    328     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pEventMultiInt));
    329     if (pEventMultiInt)
    330     {
    331         pEventMultiInt->u32Magic = RTSEMEVENTMULTI_MAGIC;
    332         pEventMultiInt->cWaiters = 0;
    333         pEventMultiInt->cWaking = 0;
    334         pEventMultiInt->fSignaled = 0;
     334    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
     335    if (pThis)
     336    {
     337        pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
     338        pThis->cWaiters = 0;
     339        pThis->cWaking = 0;
     340        pThis->fSignaled = 0;
    335341        Assert(g_pDarwinLockGroup);
    336         pEventMultiInt->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
    337         if (pEventMultiInt->pSpinlock)
     342        pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
     343        if (pThis->pSpinlock)
    338344        {
    339             *pEventMultiSem = pEventMultiInt;
     345            *phEventMultiSem = pThis;
    340346            return VINF_SUCCESS;
    341347        }
    342348
    343         pEventMultiInt->u32Magic = 0;
    344         RTMemFree(pEventMultiInt);
     349        pThis->u32Magic = 0;
     350        RTMemFree(pThis);
    345351    }
    346352    return VERR_NO_MEMORY;
    … …  
    348354
    349355
    350 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
    351 {
    352     if (EventMultiSem == NIL_RTSEMEVENTMULTI)     /* don't bitch */
    353         return VERR_INVALID_HANDLE;
    354     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    355     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    356     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    357                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
    358                     VERR_INVALID_HANDLE);
     356RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
     357{
     358    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     359    if (pThis == NIL_RTSEMEVENTMULTI)
     360        return VINF_SUCCESS;
     361    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     362    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
    359363    RT_ASSERT_INTS_ON();
    360364
    361     lck_spin_lock(pEventMultiInt->pSpinlock);
    362     ASMAtomicIncU32(&pEventMultiInt->u32Magic); /* make the handle invalid */
    363     if (pEventMultiInt->cWaiters > 0)
     365    lck_spin_lock(pThis->pSpinlock);
     366    ASMAtomicIncU32(&pThis->u32Magic); /* make the handle invalid */
     367    if (pThis->cWaiters > 0)
    364368    {
    365369        /* abort waiting thread, last man cleans up. */
    366         ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
    367         thread_wakeup_prim((event_t)pEventMultiInt, FALSE /* all threads */, THREAD_RESTART);
    368         lck_spin_unlock(pEventMultiInt->pSpinlock);
    369     }
    370     else if (pEventMultiInt->cWaking)
     370        ASMAtomicXchgU32(&pThis->cWaking, pThis->cWaking + pThis->cWaiters);
     371        thread_wakeup_prim((event_t)pThis, FALSE /* all threads */, THREAD_RESTART);
     372        lck_spin_unlock(pThis->pSpinlock);
     373    }
     374    else if (pThis->cWaking)
    371375        /* the last waking thread is gonna do the cleanup */
    372         lck_spin_unlock(pEventMultiInt->pSpinlock);
     376        lck_spin_unlock(pThis->pSpinlock);
    373377    else
    374378    {
    375         lck_spin_unlock(pEventMultiInt->pSpinlock);
    376         lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
    377         RTMemFree(pEventMultiInt);
    378     }
    379 
    380     return VINF_SUCCESS;
    381 }
    382 
    383 
    384 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
    385 {
    386     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    387     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    388     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    389                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
    390                     VERR_INVALID_HANDLE);
     379        lck_spin_unlock(pThis->pSpinlock);
     380        lck_spin_destroy(pThis->pSpinlock, g_pDarwinLockGroup);
     381        RTMemFree(pThis);
     382    }
     383
     384    return VINF_SUCCESS;
     385}
     386
     387
     388RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
     389{
     390    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     391    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     392    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
    391393    RT_ASSERT_PREEMPT_CPUID_VAR();
    392394    RT_ASSERT_INTS_ON();
    393395
    394     lck_spin_lock(pEventMultiInt->pSpinlock);
    395 
    396     ASMAtomicXchgU8(&pEventMultiInt->fSignaled, true);
    397     if (pEventMultiInt->cWaiters > 0)
    398     {
    399         ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
    400         ASMAtomicXchgU32(&pEventMultiInt->cWaiters, 0);
    401         thread_wakeup_prim((event_t)pEventMultiInt, FALSE /* all threads */, THREAD_AWAKENED);
    402     }
    403 
    404     lck_spin_unlock(pEventMultiInt->pSpinlock);
     396    lck_spin_lock(pThis->pSpinlock);
     397
     398    ASMAtomicXchgU8(&pThis->fSignaled, true);
     399    if (pThis->cWaiters > 0)
     400    {
     401        ASMAtomicXchgU32(&pThis->cWaking, pThis->cWaking + pThis->cWaiters);
     402        ASMAtomicXchgU32(&pThis->cWaiters, 0);
     403        thread_wakeup_prim((event_t)pThis, FALSE /* all threads */, THREAD_AWAKENED);
     404    }
     405
     406    lck_spin_unlock(pThis->pSpinlock);
    405407
    406408    RT_ASSERT_PREEMPT_CPUID();
    … …  
    409411
    410412
    411 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
    412 {
    413     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    414     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    415     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    416                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
    417                     VERR_INVALID_HANDLE);
     413RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
     414{
     415    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     416    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     417    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
    418418    RT_ASSERT_PREEMPT_CPUID_VAR();
    419419    RT_ASSERT_INTS_ON();
    420420
    421     lck_spin_lock(pEventMultiInt->pSpinlock);
    422     ASMAtomicXchgU8(&pEventMultiInt->fSignaled, false);
    423     lck_spin_unlock(pEventMultiInt->pSpinlock);
     421    lck_spin_lock(pThis->pSpinlock);
     422    ASMAtomicXchgU8(&pThis->fSignaled, false);
     423    lck_spin_unlock(pThis->pSpinlock);
    424424
    425425    RT_ASSERT_PREEMPT_CPUID();
    … …  
    428428
    429429
    430 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, wait_interrupt_t fInterruptible)
    431 {
    432     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    433     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    434     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    435                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
    436                     VERR_INVALID_HANDLE);
     430static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, wait_interrupt_t fInterruptible)
     431{
     432    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     433    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     434    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
    437435    if (cMillies)
    438436        RT_ASSERT_PREEMPTIBLE();
    439437
    440     lck_spin_lock(pEventMultiInt->pSpinlock);
     438    lck_spin_lock(pThis->pSpinlock);
    441439
    442440    int rc;
    443     if (pEventMultiInt->fSignaled)
     441    if (pThis->fSignaled)
    444442        rc = VINF_SUCCESS;
    445443    else if (!cMillies)
    … …  
    447445    else
    448446    {
    449         ASMAtomicIncU32(&pEventMultiInt->cWaiters);
     447        ASMAtomicIncU32(&pThis->cWaiters);
    450448
    451449        wait_result_t rcWait;
    452450        if (cMillies == RT_INDEFINITE_WAIT)
    453             rcWait = lck_spin_sleep(pEventMultiInt->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pEventMultiInt, fInterruptible);
     451            rcWait = lck_spin_sleep(pThis->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pThis, fInterruptible);
    454452        else
    455453        {
    … …  
    458456            u64AbsTime += mach_absolute_time();
    459457
    460             rcWait = lck_spin_sleep_deadline(pEventMultiInt->pSpinlock, LCK_SLEEP_DEFAULT,
    461                                              (event_t)pEventMultiInt, fInterruptible, u64AbsTime);
     458            rcWait = lck_spin_sleep_deadline(pThis->pSpinlock, LCK_SLEEP_DEFAULT,
     459                                             (event_t)pThis, fInterruptible, u64AbsTime);
    462460        }
    463461        switch (rcWait)
    464462        {
    465463            case THREAD_AWAKENED:
    466                 Assert(pEventMultiInt->cWaking > 0);
    467                 if (    !ASMAtomicDecU32(&pEventMultiInt->cWaking)
    468                     &&  pEventMultiInt->u32Magic != RTSEMEVENTMULTI_MAGIC)
     464                Assert(pThis->cWaking > 0);
     465                if (    !ASMAtomicDecU32(&pThis->cWaking)
     466                    &&  pThis->u32Magic != RTSEMEVENTMULTI_MAGIC)
    469467                {
    470468                    /* the event was destroyed after we woke up, as the last thread do the cleanup. */
    471                     lck_spin_unlock(pEventMultiInt->pSpinlock);
     469                    lck_spin_unlock(pThis->pSpinlock);
    472470                    Assert(g_pDarwinLockGroup);
    473                     lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
    474                     RTMemFree(pEventMultiInt);
     471                    lck_spin_destroy(pThis->pSpinlock, g_pDarwinLockGroup);
     472                    RTMemFree(pThis);
    475473                    return VINF_SUCCESS;
    476474                }
    … …  
    480478            case THREAD_TIMED_OUT:
    481479                Assert(cMillies != RT_INDEFINITE_WAIT);
    482                 ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     480                ASMAtomicDecU32(&pThis->cWaiters);
    483481                rc = VERR_TIMEOUT;
    484482                break;
    … …  
    486484            case THREAD_INTERRUPTED:
    487485                Assert(fInterruptible);
    488                 ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     486                ASMAtomicDecU32(&pThis->cWaiters);
    489487                rc = VERR_INTERRUPTED;
    490488                break;
    … …  
    492490            case THREAD_RESTART:
    493491                /* Last one out does the cleanup. */
    494                 if (!ASMAtomicDecU32(&pEventMultiInt->cWaking))
     492                if (!ASMAtomicDecU32(&pThis->cWaking))
    495493                {
    496                     lck_spin_unlock(pEventMultiInt->pSpinlock);
     494                    lck_spin_unlock(pThis->pSpinlock);
    497495                    Assert(g_pDarwinLockGroup);
    498                     lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
    499                     RTMemFree(pEventMultiInt);
     496                    lck_spin_destroy(pThis->pSpinlock, g_pDarwinLockGroup);
     497                    RTMemFree(pThis);
    500498                    return VERR_SEM_DESTROYED;
    501499                }
    … …  
    511509    }
    512510
    513     lck_spin_unlock(pEventMultiInt->pSpinlock);
     511    lck_spin_unlock(pThis->pSpinlock);
    514512    return rc;
    515513}
    516514
    517515
    518 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    519 {
    520     return rtSemEventMultiWait(EventMultiSem, cMillies, THREAD_UNINT);
    521 }
    522 
    523 
    524 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    525 {
    526     return rtSemEventMultiWait(EventMultiSem, cMillies, THREAD_ABORTSAFE);
     516RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     517{
     518    return rtSemEventMultiWait(hEventMultiSem, cMillies, THREAD_UNINT);
     519}
     520
     521
     522RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     523{
     524    return rtSemEventMultiWait(hEventMultiSem, cMillies, THREAD_ABORTSAFE);
    527525}
    528526
    … …  
    536534    RT_ASSERT_PREEMPTIBLE();
    537535    AssertCompile(sizeof(RTSEMMUTEXINTERNAL) > sizeof(void *));
    538     PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)RTMemAlloc(sizeof(*pMutexInt));
    539     if (pMutexInt)
    540     {
    541         pMutexInt->u32Magic = RTSEMMUTEX_MAGIC;
     536    PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)RTMemAlloc(sizeof(*pThis));
     537    if (pThis)
     538    {
     539        pThis->u32Magic = RTSEMMUTEX_MAGIC;
    542540        Assert(g_pDarwinLockGroup);
    543         pMutexInt->pMtx = lck_mtx_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
    544         if (pMutexInt->pMtx)
     541        pThis->pMtx = lck_mtx_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
     542        if (pThis->pMtx)
    545543        {
    546             *pMutexSem = pMutexInt;
     544            *pMutexSem = pThis;
    547545            return VINF_SUCCESS;
    548546        }
    549         RTMemFree(pMutexInt);
     547        RTMemFree(pThis);
    550548    }
    551549    return VERR_NO_MEMORY;
    … …  
    558556     * Validate input.
    559557     */
    560     PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)MutexSem;
    561     if (!pMutexInt)
     558    PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)MutexSem;
     559    if (!pThis)
    562560        return VERR_INVALID_PARAMETER;
    563     AssertPtrReturn(pMutexInt, VERR_INVALID_POINTER);
    564     AssertMsg(pMutexInt->u32Magic == RTSEMMUTEX_MAGIC,
    565               ("pMutexInt->u32Magic=%RX32 pMutexInt=%p\n", pMutexInt->u32Magic, pMutexInt)
    566               VERR_INVALID_PARAMETER);
     561    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     562    AssertMsg(pThis->u32Magic == RTSEMMUTEX_MAGIC, ("u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis), VERR_INVALID_HANDLE);
    567563    RT_ASSERT_INTS_ON();
    568564
    … …  
    570566     * Invalidate it and signal the object just in case.
    571567     */
    572     ASMAtomicIncU32(&pMutexInt->u32Magic);
     568    ASMAtomicIncU32(&pThis->u32Magic);
    573569
    574570    Assert(g_pDarwinLockGroup);
    575     lck_mtx_free(pMutexInt->pMtx, g_pDarwinLockGroup);
    576     pMutexInt->pMtx = NULL;
    577 
    578     RTMemFree(pMutexInt);
     571    lck_mtx_free(pThis->pMtx, g_pDarwinLockGroup);
     572    pThis->pMtx = NULL;
     573
     574    RTMemFree(pThis);
    579575    return VINF_SUCCESS;
    580576}
    … …  
    586582     * Validate input.
    587583     */
    588     PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)MutexSem;
    589     if (!pMutexInt)
     584    PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)MutexSem;
     585    if (!pThis)
    590586        return VERR_INVALID_PARAMETER;
    591     AssertPtrReturn(pMutexInt, VERR_INVALID_POINTER);
    592     AssertMsg(pMutexInt->u32Magic == RTSEMMUTEX_MAGIC,
    593               ("pMutexInt->u32Magic=%RX32 pMutexInt=%p\n", pMutexInt->u32Magic, pMutexInt)
    594               VERR_INVALID_PARAMETER);
     587    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     588    AssertMsg(pThis->u32Magic == RTSEMMUTEX_MAGIC, ("u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis), VERR_INVALID_HANDLE);
    595589    if (cMillies)
    596590        RT_ASSERT_PREEMPTIBLE();
    … …  
    604598    NTSTATUS rcNt;
    605599    if (cMillies == RT_INDEFINITE_WAIT)
    606         rcNt = KeWaitForSingleObject(&pMutexInt->Mutex, Executive, KernelMode, TRUE, NULL);
     600        rcNt = KeWaitForSingleObject(&pThis->Mutex, Executive, KernelMode, TRUE, NULL);
    607601    else
    608602    {
    609603        LARGE_INTEGER Timeout;
    610604        Timeout.QuadPart = -(int64_t)cMillies * 10000;
    611         rcNt = KeWaitForSingleObject(&pMutexInt->Mutex, Executive, KernelMode, TRUE, &Timeout);
     605        rcNt = KeWaitForSingleObject(&pThis->Mutex, Executive, KernelMode, TRUE, &Timeout);
    612606    }
    613607    switch (rcNt)
    614608    {
    615609        case STATUS_SUCCESS:
    616             if (pMutexInt->u32Magic == RTSEMMUTEX_MAGIC)
     610            if (pThis->u32Magic == RTSEMMUTEX_MAGIC)
    617611                return VINF_SUCCESS;
    618612            return VERR_SEM_DESTROYED;
    … …  
    624618            return VERR_TIMEOUT;
    625619        default:
    626             AssertMsgFailed(("pMutexInt->u32Magic=%RX32 pMutexInt=%p: wait returned %lx!\n",
    627                              pMutexInt->u32Magic, pMutexInt, (long)rcNt));
     620            AssertMsgFailed(("pThis->u32Magic=%RX32 pThis=%p: wait returned %lx!\n",
     621                             pThis->u32Magic, pThis, (long)rcNt));
    628622            return VERR_INTERNAL_ERROR;
    629623    }
    … …  
    638632     * Validate input.
    639633     */
    640     PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)MutexSem;
    641     if (!pMutexInt)
    642         return VERR_INVALID_PARAMETER;
    643     if (    !pMutexInt
    644         ||  pMutexInt->u32Magic != RTSEMMUTEX_MAGIC)
    645     {
    646         AssertMsgFailed(("pMutexInt->u32Magic=%RX32 pMutexInt=%p\n", pMutexInt ? pMutexInt->u32Magic : 0, pMutexInt));
    647         return VERR_INVALID_PARAMETER;
    648     }
     634    PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)MutexSem;
     635    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     636    AssertMsg(pThis->u32Magic == RTSEMMUTEX_MAGIC, ("u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis), VERR_INVALID_HANDLE);
    649637    RT_ASSERT_PREEMPTIBLE();
    650638
    … …  
    653641     */
    654642#ifdef RT_USE_FAST_MUTEX
    655     ExReleaseFastMutex(&pMutexInt->Mutex);
     643    ExReleaseFastMutex(&pThis->Mutex);
    656644#else
    657     KeReleaseMutex(&pMutexInt->Mutex, FALSE);
     645    KeReleaseMutex(&pThis->Mutex, FALSE);
    658646#endif
    659647    return VINF_SUCCESS;

  • trunk/src/VBox/Runtime/r0drv/freebsd/semeventmulti-r0drv-freebsd.c

    r22819 r25720  
    6464
    6565
    66 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    67 {
    68     Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
    69     AssertPtrReturn(pEventMultiSem, VERR_INVALID_POINTER);
    70 
    71     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)RTMemAllocZ(sizeof(*pEventMultiInt));
    72     if (pEventMultiInt)
    73     {
    74         pEventMultiInt->u32Magic = RTSEMEVENTMULTI_MAGIC;
    75         pEventMultiInt->cWaiters = 0;
    76         pEventMultiInt->cWaking = 0;
    77         pEventMultiInt->fSignaled = 0;
    78         int rc = RTSpinlockCreate(&pEventMultiInt->hSpinLock);
     66RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     67{
     68    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     69}
     70
     71
     72RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     73                                     const char *pszNameFmt, ...)
     74{
     75    AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
     76    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     77    AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);
     78
     79    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAllocZ(sizeof(*pThis));
     80    if (pThis)
     81    {
     82        pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
     83        pThis->cWaiters = 0;
     84        pThis->cWaking = 0;
     85        pThis->fSignaled = 0;
     86        int rc = RTSpinlockCreate(&pThis->hSpinLock);
    7987        if (RT_SUCCESS(rc))
    8088        {
    81             *pEventMultiSem = pEventMultiInt;
     89            *phEventMultiSem = pThis;
    8290            return VINF_SUCCESS;
    8391        }
    8492
    85         RTMemFree(pEventMultiInt);
     93        RTMemFree(pThis);
    8694        return rc;
    8795    }
    … …  
    9098
    9199
    92 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
    93 {
    94     if (EventMultiSem == NIL_RTSEMEVENTMULTI)     /* don't bitch */
    95         return VERR_INVALID_HANDLE;
    96     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     100RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
     101{
     102    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    97103    RTSPINLOCKTMP            Tmp = RTSPINLOCKTMP_INITIALIZER;
    98104
    99     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    100     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    101                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     105    if (pThis == NIL_RTSEMEVENTMULTI)
     106        return VINF_SUCCESS;
     107    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     108    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
     109
     110    RTSpinlockAcquire(pThis->hSpinLock, &Tmp);
     111    ASMAtomicIncU32(&pThis->u32Magic); /* make the handle invalid */
     112    if (pThis->cWaiters > 0)
     113    {
     114        /* abort waiting thread, last man cleans up. */
     115        ASMAtomicXchgU32(&pThis->cWaking, pThis->cWaking + pThis->cWaiters);
     116        sleepq_lock(pThis);
     117        sleepq_broadcast(pThis, SLEEPQ_CONDVAR, 0, 0);
     118        sleepq_release(pThis);
     119        RTSpinlockRelease(pThis->hSpinLock, &Tmp);
     120    }
     121    else if (pThis->cWaking)
     122        /* the last waking thread is gonna do the cleanup */
     123        RTSpinlockRelease(pThis->hSpinLock, &Tmp);
     124    else
     125    {
     126        RTSpinlockRelease(pThis->hSpinLock, &Tmp);
     127        RTSpinlockDestroy(pThis->hSpinLock);
     128        RTMemFree(pThis);
     129    }
     130
     131    return VINF_SUCCESS;
     132}
     133
     134
     135RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
     136{
     137    RTSPINLOCKTMP            Tmp = RTSPINLOCKTMP_INITIALIZER;
     138    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     139    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     140    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
     141                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    102142                    VERR_INVALID_HANDLE);
    103143
    104     RTSpinlockAcquire(pEventMultiInt->hSpinLock, &Tmp);
    105     ASMAtomicIncU32(&pEventMultiInt->u32Magic); /* make the handle invalid */
    106     if (pEventMultiInt->cWaiters > 0)
    107     {
    108         /* abort waiting thread, last man cleans up. */
    109         ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
    110         sleepq_lock(pEventMultiInt);
    111         sleepq_broadcast(pEventMultiInt, SLEEPQ_CONDVAR, 0, 0);
    112         sleepq_release(pEventMultiInt);
    113         RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
    114     }
    115     else if (pEventMultiInt->cWaking)
    116         /* the last waking thread is gonna do the cleanup */
    117         RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
    118     else
    119     {
    120         RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
    121         RTSpinlockDestroy(pEventMultiInt->hSpinLock);
    122         RTMemFree(pEventMultiInt);
    123     }
    124 
    125     return VINF_SUCCESS;
    126 }
    127 
    128 
    129 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
    130 {
    131     RTSPINLOCKTMP            Tmp = RTSPINLOCKTMP_INITIALIZER;
    132     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    133     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    134     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    135                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
    136                     VERR_INVALID_HANDLE);
    137 
    138     RTSpinlockAcquire(pEventMultiInt->hSpinLock, &Tmp);
    139 
    140     ASMAtomicXchgU8(&pEventMultiInt->fSignaled, true);
    141     if (pEventMultiInt->cWaiters > 0)
    142     {
    143         ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
    144         ASMAtomicXchgU32(&pEventMultiInt->cWaiters, 0);
    145         sleepq_lock(pEventMultiInt);
    146         int fWakeupSwapProc = sleepq_signal(pEventMultiInt, SLEEPQ_CONDVAR, 0, 0);
    147         sleepq_release(pEventMultiInt);
     144    RTSpinlockAcquire(pThis->hSpinLock, &Tmp);
     145
     146    ASMAtomicXchgU8(&pThis->fSignaled, true);
     147    if (pThis->cWaiters > 0)
     148    {
     149        ASMAtomicXchgU32(&pThis->cWaking, pThis->cWaking + pThis->cWaiters);
     150        ASMAtomicXchgU32(&pThis->cWaiters, 0);
     151        sleepq_lock(pThis);
     152        int fWakeupSwapProc = sleepq_signal(pThis, SLEEPQ_CONDVAR, 0, 0);
     153        sleepq_release(pThis);
    148154        if (fWakeupSwapProc)
    149155            kick_proc0();
    150156    }
    151157
    152     RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
     158    RTSpinlockRelease(pThis->hSpinLock, &Tmp);
    153159    return VINF_SUCCESS;
    154160}
    155161
    156162
    157 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     163RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    158164{
    159165    RTSPINLOCKTMP            Tmp = RTSPINLOCKTMP_INITIALIZER;
    160     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    161     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    162     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    163                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     166    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     167    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     168    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
     169                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    164170                    VERR_INVALID_HANDLE);
    165171
    166     RTSpinlockAcquire(pEventMultiInt->hSpinLock, &Tmp);
    167     ASMAtomicXchgU8(&pEventMultiInt->fSignaled, false);
    168     RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
     172    RTSpinlockAcquire(pThis->hSpinLock, &Tmp);
     173    ASMAtomicXchgU8(&pThis->fSignaled, false);
     174    RTSpinlockRelease(pThis->hSpinLock, &Tmp);
    169175    return VINF_SUCCESS;
    170176}
    171177
    172178
    173 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fInterruptible)
     179static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, bool fInterruptible)
    174180{
    175181    int rc;
    176182    RTSPINLOCKTMP            Tmp = RTSPINLOCKTMP_INITIALIZER;
    177     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    178     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    179     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    180                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     183    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     184    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     185    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
     186                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    181187                    VERR_INVALID_HANDLE);
    182188
    183     RTSpinlockAcquire(pEventMultiInt->hSpinLock, &Tmp);
    184 
    185     if (pEventMultiInt->fSignaled)
     189    RTSpinlockAcquire(pThis->hSpinLock, &Tmp);
     190
     191    if (pThis->fSignaled)
    186192        rc = VINF_SUCCESS;
    187193    else
    … …  
    191197        else
    192198        {
    193             ASMAtomicIncU32(&pEventMultiInt->cWaiters);
     199            ASMAtomicIncU32(&pThis->cWaiters);
    194200
    195201            int fFlags = SLEEPQ_CONDVAR;
    … …  
    198204                fFlags |= SLEEPQ_INTERRUPTIBLE;
    199205
    200             sleepq_lock(pEventMultiInt);
    201             sleepq_add(pEventMultiInt, NULL, "IPRT Event Semaphore", fFlags, 0);
     206            sleepq_lock(pThis);
     207            sleepq_add(pThis, NULL, "IPRT Event Semaphore", fFlags, 0);
    202208
    203209            if (cMillies != RT_INDEFINITE_WAIT)
    … …  
    211217                tv.tv_usec = (cMillies % 1000) * 1000;
    212218
    213                 sleepq_set_timeout(pEventMultiInt, tvtohz(&tv));
    214 
    215                 RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
     219                sleepq_set_timeout(pThis, tvtohz(&tv));
     220
     221                RTSpinlockRelease(pThis->hSpinLock, &Tmp);
    216222
    217223                if (fInterruptible)
    218                     rc = SLEEPQ_TIMEDWAIT_SIG(pEventMultiInt);
     224                    rc = SLEEPQ_TIMEDWAIT_SIG(pThis);
    219225                else
    220                     rc = SLEEPQ_TIMEDWAIT(pEventMultiInt);
     226                    rc = SLEEPQ_TIMEDWAIT(pThis);
    221227            }
    222228            else
    223229            {
    224                 RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
     230                RTSpinlockRelease(pThis->hSpinLock, &Tmp);
    225231
    226232                if (fInterruptible)
    227                     rc = SLEEPQ_WAIT_SIG(pEventMultiInt);
     233                    rc = SLEEPQ_WAIT_SIG(pThis);
    228234                else
    229235                {
    230236                    rc = 0;
    231                     SLEEPQ_WAIT(pEventMultiInt);
     237                    SLEEPQ_WAIT(pThis);
    232238                }
    233239            }
    234240
    235             RTSpinlockAcquire(pEventMultiInt->hSpinLock, &Tmp);
     241            RTSpinlockAcquire(pThis->hSpinLock, &Tmp);
    236242
    237243            switch (rc)
    238244            {
    239245                case 0:
    240                     if (pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC)
     246                    if (pThis->u32Magic == RTSEMEVENTMULTI_MAGIC)
    241247                    {
    242                         ASMAtomicDecU32(&pEventMultiInt->cWaking);
     248                        ASMAtomicDecU32(&pThis->cWaking);
    243249                        rc = VINF_SUCCESS;
    244250                    }
    … …  
    247253                        rc = VERR_SEM_DESTROYED; /** @todo this isn't necessarily correct, we've
    248254                                                  * could've woken up just before destruction... */
    249                         if (!ASMAtomicDecU32(&pEventMultiInt->cWaking))
     255                        if (!ASMAtomicDecU32(&pThis->cWaking))
    250256                        {
    251257                            /* The event was destroyed, as the last thread do the cleanup.
    252258                               we don't actually know whether */
    253                             RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
    254                             RTSpinlockDestroy(pEventMultiInt->hSpinLock);
    255                             RTMemFree(pEventMultiInt);
     259                            RTSpinlockRelease(pThis->hSpinLock, &Tmp);
     260                            RTSpinlockDestroy(pThis->hSpinLock);
     261                            RTMemFree(pThis);
    256262                            return rc;
    257263                        }
    … …  
    261267                case EWOULDBLOCK:
    262268                    Assert(cMillies != RT_INDEFINITE_WAIT);
    263                     if (pEventMultiInt->cWaiters > 0)
    264                         ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     269                    if (pThis->cWaiters > 0)
     270                        ASMAtomicDecU32(&pThis->cWaiters);
    265271                    rc = VERR_TIMEOUT;
    266272                    break;
    … …  
    269275                case ERESTART:
    270276                    Assert(fInterruptible);
    271                     if (pEventMultiInt->cWaiters > 0)
    272                         ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     277                    if (pThis->cWaiters > 0)
     278                        ASMAtomicDecU32(&pThis->cWaiters);
    273279                    rc = VERR_INTERRUPTED;
    274280                    break;
    … …  
    282288    }
    283289
    284     RTSpinlockRelease(pEventMultiInt->hSpinLock, &Tmp);
     290    RTSpinlockRelease(pThis->hSpinLock, &Tmp);
    285291    return rc;
    286292}
    287293
    288294
    289 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    290 {
    291     return rtSemEventMultiWait(EventMultiSem, cMillies, false /* not interruptible */);
    292 }
    293 
    294 
    295 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    296 {
    297     return rtSemEventMultiWait(EventMultiSem, cMillies, true /* interruptible */);
    298 }
    299 
     295RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     296{
     297    return rtSemEventMultiWait(hEventMultiSem, cMillies, false /* not interruptible */);
     298}
     299
     300
     301RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     302{
     303    return rtSemEventMultiWait(hEventMultiSem, cMillies, true /* interruptible */);
     304}
     305

  • trunk/src/VBox/Runtime/r0drv/linux/semeventmulti-r0drv-linux.c

    r24956 r25720  
    6262
    6363
    64 RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    65 {
     64RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     65{
     66    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     67}
     68
     69
     70RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     71                                     const char *pszNameFmt, ...)
     72{
     73    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     74
    6675    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
    6776    if (pThis)
    … …  
    7079        pThis->fState   = 0;
    7180        init_waitqueue_head(&pThis->Head);
    72         *pEventMultiSem = pThis;
     81
     82        *phEventMultiSem = pThis;
    7383        return VINF_SUCCESS;
    7484    }
    … …  
    7888
    7989
    80 RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
     90RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
    8191{
    8292    /*
    8393     * Validate input.
    8494     */
    85     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    86     if (!pThis)
    87         return VERR_INVALID_PARAMETER;
     95    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     96    if (pThis == NIL_RTSEMEVENTMULTI)
     97        return VINF_SUCCESS;
    8898    AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
    8999    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
    … …  
    92102     * Invalidate it and signal the object just in case.
    93103     */
    94     ASMAtomicIncU32(&pThis->u32Magic);
     104    ASMAtomicWriteU32(&pThis->u32Magic, ~RTSEMEVENTMULTI_MAGIC);
    95105    ASMAtomicXchgU32(&pThis->fState, 0);
    96106    Assert(!waitqueue_active(&pThis->Head));
    … …  
    102112
    103113
    104 RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     114RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    105115{
    106116    /*
    107117     * Validate input.
    108118     */
    109     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     119    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    110120    if (!pThis)
    111121        return VERR_INVALID_PARAMETER;
    … …  
    123133
    124134
    125 RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     135RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    126136{
    127137    /*
    128138     * Validate input.
    129139     */
    130     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     140    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    131141    if (!pThis)
    132142        return VERR_INVALID_PARAMETER;
    … …  
    206216
    207217
    208 RTDECL(int) RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    209 {
    210     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     218RTDECL(int) RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     219{
     220    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    211221    if (!pThis)
    212222        return VERR_INVALID_PARAMETER;
    … …  
    221231
    222232
    223 RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    224 {
    225     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     233RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     234{
     235    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    226236    if (!pThis)
    227237        return VERR_INVALID_PARAMETER;

  • trunk/src/VBox/Runtime/r0drv/nt/semeventmulti-r0drv-nt.cpp

    r20923 r25720  
    5858
    5959
    60 RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventSem)
     60RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
    6161{
    62     Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
     62    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     63}
     64
     65
     66RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     67                                     const char *pszNameFmt, ...)
     68{
     69    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     70
     71    AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
    6372    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
    6473    if (pThis)
    … …  
    6675        pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
    6776        KeInitializeEvent(&pThis->Event, NotificationEvent, FALSE /* not signalled */);
    68         *pEventSem = pThis;
     77
     78        *phEventSem = pThis;
    6979        return VINF_SUCCESS;
    7080    }
    … …  
    7383
    7484
    75 RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
     85RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
    7686{
    7787    /*
    7888     * Validate input.
    7989     */
    80     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    81     if (!pThis)
    82         return VERR_INVALID_PARAMETER;
     90    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     91    if (pThis == NIL_RTSEMEVENTMULTI)
     92        return VINF_SUCCESS;
    8393    AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
    8494    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
    … …  
    94104
    95105
    96 RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     106RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    97107{
    98108    /*
    99109     * Validate input.
    100110     */
    101     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     111    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    102112    if (!pThis)
    103113        return VERR_INVALID_PARAMETER;
    … …  
    113123
    114124
    115 RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     125RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    116126{
    117127    /*
    118128     * Validate input.
    119129     */
    120     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     130    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    121131    if (!pThis)
    122132        return VERR_INVALID_PARAMETER;
    … …  
    132142
    133143
    134 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fInterruptible)
     144static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, bool fInterruptible)
    135145{
    136146    /*
    137147     * Validate input.
    138148     */
    139     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     149    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    140150    if (!pThis)
    141151        return VERR_INVALID_PARAMETER;
    … …  
    177187
    178188
    179 RTDECL(int) RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
     189RTDECL(int) RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
    180190{
    181     return rtSemEventMultiWait(EventMultiSem, cMillies, false /* fInterruptible */);
     191    return rtSemEventMultiWait(hEventMultiSem, cMillies, false /* fInterruptible */);
    182192}
    183193
    184194
    185 RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
     195RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
    186196{
    187     return rtSemEventMultiWait(EventMultiSem, cMillies, true /* fInterruptible */);
     197    return rtSemEventMultiWait(hEventMultiSem, cMillies, true /* fInterruptible */);
    188198}
    189199

  • trunk/src/VBox/Runtime/r0drv/os2/semeventmulti-r0drv-os2.cpp

    r8245 r25720  
    6464
    6565
    66 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    67 {
    68     Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
    69     AssertPtrReturn(pEventMultiSem, VERR_INVALID_POINTER);
    70 
    71     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pEventMultiInt));
    72     if (pEventMultiInt)
    73     {
    74         pEventMultiInt->u32Magic = RTSEMEVENTMULTI_MAGIC;
    75         pEventMultiInt->cWaiters = 0;
    76         pEventMultiInt->cWaking = 0;
    77         pEventMultiInt->fSignaled = 0;
    78         KernAllocSpinLock(&pEventMultiInt->Spinlock);
    79         *pEventMultiSem = pEventMultiInt;
     66RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     67{
     68    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     69}
     70
     71
     72RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     73                                     const char *pszNameFmt, ...)
     74{
     75    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     76    AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);
     77
     78    AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
     79    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
     80    if (pThis)
     81    {
     82        pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
     83        pThis->cWaiters = 0;
     84        pThis->cWaking = 0;
     85        pThis->fSignaled = 0;
     86        KernAllocSpinLock(&pThis->Spinlock);
     87
     88        *phEventMultiSem = pThis;
    8089        return VINF_SUCCESS;
    8190    }
    … …  
    8493
    8594
    86 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
    87 {
    88     if (EventMultiSem == NIL_RTSEMEVENTMULTI)     /* don't bitch */
    89         return VERR_INVALID_HANDLE;
    90     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    91     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    92     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    93                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     95RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
     96{
     97    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     98    if (pThis == NIL_RTSEMEVENTMULTI)
     99        return VINF_SUCCESS;
     100    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     101    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
     102
     103    KernAcquireSpinLock(&pThis->Spinlock);
     104    ASMAtomicIncU32(&pThis->u32Magic); /* make the handle invalid */
     105    if (pThis->cWaiters > 0)
     106    {
     107        /* abort waiting thread, last man cleans up. */
     108        ASMAtomicXchgU32(&pThis->cWaking, pThis->cWaking + pThis->cWaiters);
     109        ULONG cThreads;
     110        KernWakeup((ULONG)pThis, WAKEUP_DATA | WAKEUP_BOOST, &cThreads, (ULONG)VERR_SEM_DESTROYED);
     111        KernReleaseSpinLock(&pThis->Spinlock);
     112    }
     113    else if (pThis->cWaking)
     114        /* the last waking thread is gonna do the cleanup */
     115        KernReleaseSpinLock(&pThis->Spinlock);
     116    else
     117    {
     118        KernReleaseSpinLock(&pThis->Spinlock);
     119        KernFreeSpinLock(&pThis->Spinlock);
     120        RTMemFree(pThis);
     121    }
     122
     123    return VINF_SUCCESS;
     124}
     125
     126
     127RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
     128{
     129    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     130    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     131    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
     132                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    94133                    VERR_INVALID_HANDLE);
    95134
    96     KernAcquireSpinLock(&pEventMultiInt->Spinlock);
    97     ASMAtomicIncU32(&pEventMultiInt->u32Magic); /* make the handle invalid */
    98     if (pEventMultiInt->cWaiters > 0)
    99     {
    100         /* abort waiting thread, last man cleans up. */
    101         ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
     135    KernAcquireSpinLock(&pThis->Spinlock);
     136
     137    ASMAtomicXchgU8(&pThis->fSignaled, true);
     138    if (pThis->cWaiters > 0)
     139    {
     140        ASMAtomicXchgU32(&pThis->cWaking, pThis->cWaking + pThis->cWaiters);
     141        ASMAtomicXchgU32(&pThis->cWaiters, 0);
    102142        ULONG cThreads;
    103         KernWakeup((ULONG)pEventMultiInt, WAKEUP_DATA | WAKEUP_BOOST, &cThreads, (ULONG)VERR_SEM_DESTROYED);
    104         KernReleaseSpinLock(&pEventMultiInt->Spinlock);
    105     }
    106     else if (pEventMultiInt->cWaking)
    107         /* the last waking thread is gonna do the cleanup */
    108         KernReleaseSpinLock(&pEventMultiInt->Spinlock);
    109     else
    110     {
    111         KernReleaseSpinLock(&pEventMultiInt->Spinlock);
    112         KernFreeSpinLock(&pEventMultiInt->Spinlock);
    113         RTMemFree(pEventMultiInt);
    114     }
    115 
     143        KernWakeup((ULONG)pThis, WAKEUP_DATA, &cThreads, VINF_SUCCESS);
     144    }
     145
     146    KernReleaseSpinLock(&pThis->Spinlock);
    116147    return VINF_SUCCESS;
    117148}
    118149
    119150
    120 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
    121 {
    122     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    123     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    124     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    125                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     151RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
     152{
     153    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     154    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     155    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
     156                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    126157                    VERR_INVALID_HANDLE);
    127158
    128     KernAcquireSpinLock(&pEventMultiInt->Spinlock);
    129 
    130     ASMAtomicXchgU8(&pEventMultiInt->fSignaled, true);
    131     if (pEventMultiInt->cWaiters > 0)
    132     {
    133         ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
    134         ASMAtomicXchgU32(&pEventMultiInt->cWaiters, 0);
    135         ULONG cThreads;
    136         KernWakeup((ULONG)pEventMultiInt, WAKEUP_DATA, &cThreads, VINF_SUCCESS);
    137     }
    138 
    139     KernReleaseSpinLock(&pEventMultiInt->Spinlock);
     159    KernAcquireSpinLock(&pThis->Spinlock);
     160    ASMAtomicXchgU8(&pThis->fSignaled, false);
     161    KernReleaseSpinLock(&pThis->Spinlock);
    140162    return VINF_SUCCESS;
    141163}
    142164
    143165
    144 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
    145 {
    146     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    147     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    148     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    149                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     166static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, bool fInterruptible)
     167{
     168    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     169    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     170    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
     171                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    150172                    VERR_INVALID_HANDLE);
    151173
    152     KernAcquireSpinLock(&pEventMultiInt->Spinlock);
    153     ASMAtomicXchgU8(&pEventMultiInt->fSignaled, false);
    154     KernReleaseSpinLock(&pEventMultiInt->Spinlock);
    155     return VINF_SUCCESS;
    156 }
    157 
    158 
    159 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fInterruptible)
    160 {
    161     PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
    162     AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
    163     AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
    164                     ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
    165                     VERR_INVALID_HANDLE);
    166 
    167     KernAcquireSpinLock(&pEventMultiInt->Spinlock);
     174    KernAcquireSpinLock(&pThis->Spinlock);
    168175
    169176    int rc;
    170     if (pEventMultiInt->fSignaled)
     177    if (pThis->fSignaled)
    171178        rc = VINF_SUCCESS;
    172179    else
    173180    {
    174         ASMAtomicIncU32(&pEventMultiInt->cWaiters);
     181        ASMAtomicIncU32(&pThis->cWaiters);
    175182
    176183        ULONG ulData = (ULONG)VERR_INTERNAL_ERROR;
    177         rc = KernBlock((ULONG)pEventMultiInt,
     184        rc = KernBlock((ULONG)pThis,
    178185                       cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies,
    179186                       BLOCK_SPINLOCK | (!fInterruptible ? BLOCK_UNINTERRUPTABLE : 0),
    180                        &pEventMultiInt->Spinlock,
     187                       &pThis->Spinlock,
    181188                       &ulData);
    182189        switch (rc)
    … …  
    185192                rc = (int)ulData;
    186193                Assert(rc == VINF_SUCCESS || rc == VERR_SEM_DESTROYED);
    187                 Assert(pEventMultiInt->cWaking > 0);
    188                 if (    !ASMAtomicDecU32(&pEventMultiInt->cWaking)
    189                     &&  pEventMultiInt->u32Magic != RTSEMEVENTMULTI_MAGIC)
     194                Assert(pThis->cWaking > 0);
     195                if (    !ASMAtomicDecU32(&pThis->cWaking)
     196                    &&  pThis->u32Magic != RTSEMEVENTMULTI_MAGIC)
    190197                {
    191198                    /* The event was destroyed (ulData == VINF_SUCCESS if it was after we awoke), as
    192199                       the last thread do the cleanup. */
    193                     KernReleaseSpinLock(&pEventMultiInt->Spinlock);
    194                     KernFreeSpinLock(&pEventMultiInt->Spinlock);
    195                     RTMemFree(pEventMultiInt);
     200                    KernReleaseSpinLock(&pThis->Spinlock);
     201                    KernFreeSpinLock(&pThis->Spinlock);
     202                    RTMemFree(pThis);
    196203                    return VINF_SUCCESS;
    197204                }
    … …  
    201208            case ERROR_TIMEOUT:
    202209                Assert(cMillies != RT_INDEFINITE_WAIT);
    203                 ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     210                ASMAtomicDecU32(&pThis->cWaiters);
    204211                rc = VERR_TIMEOUT;
    205212                break;
    … …  
    207214            case ERROR_INTERRUPT:
    208215                Assert(fInterruptible);
    209                 ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     216                ASMAtomicDecU32(&pThis->cWaiters);
    210217                rc = VERR_INTERRUPTED;
    211218                break;
    … …  
    218225    }
    219226
    220     KernReleaseSpinLock(&pEventMultiInt->Spinlock);
     227    KernReleaseSpinLock(&pThis->Spinlock);
    221228    return rc;
    222229}
    223230
    224231
    225 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    226 {
    227     return rtSemEventMultiWait(EventMultiSem, cMillies, false /* not interruptible */);
    228 }
    229 
    230 
    231 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    232 {
    233     return rtSemEventMultiWait(EventMultiSem, cMillies, true /* interruptible */);
    234 }
    235 
     232RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     233{
     234    return rtSemEventMultiWait(hEventMultiSem, cMillies, false /* not interruptible */);
     235}
     236
     237
     238RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     239{
     240    return rtSemEventMultiWait(hEventMultiSem, cMillies, true /* interruptible */);
     241}
     242

  • trunk/src/VBox/Runtime/r0drv/solaris/semeventmulti-r0drv-solaris.c

    r25183 r25720  
    7070
    7171
    72 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    73 {
    74     Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
    75     AssertPtrReturn(pEventMultiSem, VERR_INVALID_POINTER);
     72RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     73{
     74    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     75}
     76
     77
     78RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     79                                     const char *pszNameFmt, ...)
     80{
     81    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     82    AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);
    7683    RT_ASSERT_PREEMPTIBLE();
    7784
     85    AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
    7886    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
    7987    if (pThis)
    … …  
    8593        mutex_init(&pThis->Mtx, "IPRT Multiple Release Event Semaphore", MUTEX_DRIVER, (void *)ipltospl(DISP_LEVEL));
    8694        cv_init(&pThis->Cnd, "IPRT CV", CV_DRIVER, NULL);
    87         *pEventMultiSem = pThis;
     95
     96        *phEventMultiSem = pThis;
    8897        return VINF_SUCCESS;
    8998    }
    … …  
    92101
    93102
    94 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
    95 {
    96     if (EventMultiSem == NIL_RTSEMEVENTMULTI)     /* don't bitch */
    97         return VERR_INVALID_HANDLE;
    98     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     103RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
     104{
     105    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
     106    if (pThis == NIL_RTSEMEVENTMULTI)
     107        return VINF_SUCCESS;
    99108    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    100     AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    101                     ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
    102                     VERR_INVALID_HANDLE);
     109    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
    103110    RT_ASSERT_INTS_ON();
    104111
    … …  
    127134
    128135
    129 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
    130 {
    131     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     136RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
     137{
     138    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    132139    RT_ASSERT_PREEMPT_CPUID_VAR();
    133140
    … …  
    172179
    173180
    174 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
    175 {
    176     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     181RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
     182{
     183    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    177184    RT_ASSERT_PREEMPT_CPUID_VAR();
    178185
    … …  
    210217
    211218
    212 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fInterruptible)
     219static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, bool fInterruptible)
    213220{
    214221    int rc;
    215     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     222    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
    216223    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    217224    AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    … …  
    294301
    295302
    296 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    297 {
    298     return rtSemEventMultiWait(EventMultiSem, cMillies, false /* not interruptible */);
    299 }
    300 
    301 
    302 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    303 {
    304     return rtSemEventMultiWait(EventMultiSem, cMillies, true /* interruptible */);
    305 }
    306 
     303RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     304{
     305    return rtSemEventMultiWait(hEventMultiSem, cMillies, false /* not interruptible */);
     306}
     307
     308
     309RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     310{
     311    return rtSemEventMultiWait(hEventMultiSem, cMillies, true /* interruptible */);
     312}
     313

  • trunk/src/VBox/Runtime/r3/linux/semeventmulti-linux.cpp

    r25704 r25720  
    3131
    3232#include <features.h>
    33 #if __GLIBC_PREREQ(2,6) && !defined(IPRT_WITH_FUTEX_BASED_SEMS) && !defined(DEBUG_bird)
     33#if __GLIBC_PREREQ(2,6) && !defined(IPRT_WITH_FUTEX_BASED_SEMS)
    3434
    3535/*
    … …  
    119119
    120120
    121 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    122 {
     121RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     122{
     123    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     124}
     125
     126
     127RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     128                                     const char *pszNameFmt, ...)
     129{
     130    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     131
    123132    /*
    124133     * Allocate semaphore handle.
    … …  
    130139        pThis->iState   = 0;
    131140#ifdef RTSEMEVENTMULTI_STRICT
    132         RTLockValidatorRecSharedInit(&pThis->Signallers,
    133                                      NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_ANY,
    134                                      pThis, true /*fSignaller*/, true /*fEnabled*/, "RTSemEvent");
     141        va_list va;
     142        va_start(va, pszNameFmt);
     143        RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
     144                                      true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL),
     145                                      pszNameFmt, va);
     146        va_end(va);
    135147        pThis->fEverHadSignallers = false;
    136148#endif
    137         *pEventMultiSem = pThis;
     149
     150        *phEventMultiSem = pThis;
    138151        return VINF_SUCCESS;
    139152    }
    … …  
    142155
    143156
    144 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
     157RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
    145158{
    146159    /*
    147160     * Validate input.
    148161     */
    149     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
    150     AssertReturn(VALID_PTR(pThis) && pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    151                  VERR_INVALID_HANDLE);
     162    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
     163    if (pThis == NIL_RTSEMEVENTMULTI)
     164        return VINF_SUCCESS;
     165    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     166    AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
    152167
    153168    /*
    … …  
    172187
    173188
    174 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     189RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    175190{
    176191    /*
    177192     * Validate input.
    178193     */
    179     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     194    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    180195    AssertReturn(VALID_PTR(pThis) && pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    181196                 VERR_INVALID_HANDLE);
    … …  
    206221
    207222
    208 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     223RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    209224{
    210225    /*
    211226     * Validate input.
    212227     */
    213     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     228    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    214229    AssertReturn(VALID_PTR(pThis) && pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    215230                 VERR_INVALID_HANDLE);
    … …  
    227242
    228243
    229 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fAutoResume)
     244static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, bool fAutoResume)
    230245{
    231246    PCRTLOCKVALSRCPOS pSrcPos = NULL;
    … …  
    234249     * Validate input.
    235250     */
    236     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     251    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    237252    AssertReturn(VALID_PTR(pThis) && pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    238253                 VERR_INVALID_HANDLE);
    … …  
    339354
    340355
    341 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    342 {
    343     int rc = rtSemEventMultiWait(EventMultiSem, cMillies, true);
     356RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     357{
     358    int rc = rtSemEventMultiWait(hEventMultiSem, cMillies, true);
    344359    Assert(rc != VERR_INTERRUPTED);
    345360    return rc;
    … …  
    347362
    348363
    349 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    350 {
    351     return rtSemEventMultiWait(EventMultiSem, cMillies, false);
     364RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     365{
     366    return rtSemEventMultiWait(hEventMultiSem, cMillies, false);
    352367}
    353368

  • trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp

    r25717 r25720  
    148148
    149149
    150 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    151 {
     150RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     151{
     152    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     153}
     154
     155
     156RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     157                                     const char *pszNameFmt, ...)
     158{
     159    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     160
    152161    /*
    153162     * Create the semaphore.
    … …  
    158167    if (!rc)
    159168    {
    160         *pEventMultiSem = (RTSEMEVENTMULTI)(void *)hev;
    161         return VINF_SUCCESS;
    162     }
    163     return RTErrConvertFromOS2(rc);
    164 }
    165 
    166 
    167 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
    168 {
     169        *phEventMultiSem = (RTSEMEVENTMULTI)(void *)hev;
     170        return VINF_SUCCESS;
     171    }
     172    return RTErrConvertFromOS2(rc);
     173}
     174
     175
     176RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
     177{
     178    if (hEventMultiSem == NIL_RTSEMEVENTMULTI)
     179        return VINF_SUCCESS;
     180
    169181    /*
    170182     * Close semaphore handle.
    171183     */
    172     int rc = DosCloseEventSem(SEM2HND(EventMultiSem));
    173     if (!rc)
    174         return VINF_SUCCESS;
    175     AssertMsgFailed(("Destroy EventMultiSem %p failed, rc=%d\n", EventMultiSem, rc));
    176     return RTErrConvertFromOS2(rc);
    177 }
    178 
    179 
    180 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     184    int rc = DosCloseEventSem(SEM2HND(hEventMultiSem));
     185    if (!rc)
     186        return VINF_SUCCESS;
     187    AssertMsgFailed(("Destroy hEventMultiSem %p failed, rc=%d\n", hEventMultiSem, rc));
     188    return RTErrConvertFromOS2(rc);
     189}
     190
     191
     192RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    181193{
    182194    /*
    183195     * Signal the object.
    184196     */
    185     int rc = DosPostEventSem(SEM2HND(EventMultiSem));
     197    int rc = DosPostEventSem(SEM2HND(hEventMultiSem));
    186198    switch (rc)
    187199    {
    … …  
    196208
    197209
    198 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     210RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    199211{
    200212    /*
    … …  
    202214     */
    203215    ULONG ulIgnore;
    204     int rc = DosResetEventSem(SEM2HND(EventMultiSem), &ulIgnore);
     216    int rc = DosResetEventSem(SEM2HND(hEventMultiSem), &ulIgnore);
    205217    switch (rc)
    206218    {
    … …  
    214226
    215227
    216 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
     228RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
    217229{
    218230    /*
    219231     * Wait for condition.
    220232     */
    221     int rc = DosWaitEventSem(SEM2HND(EventMultiSem), cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies);
     233    int rc = DosWaitEventSem(SEM2HND(hEventMultiSem), cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies);
    222234    switch (rc)
    223235    {
    … …  
    228240        default:
    229241        {
    230             AssertMsgFailed(("Wait on EventMultiSem %p failed, rc=%d\n", EventMultiSem, rc));
     242            AssertMsgFailed(("Wait on hEventMultiSem %p failed, rc=%d\n", hEventMultiSem, rc));
    231243            return RTErrConvertFromOS2(rc);
    232244        }

  • trunk/src/VBox/Runtime/r3/posix/semeventmulti-posix.cpp

    r25704 r25720  
    8686
    8787
    88 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    89 {
     88RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     89{
     90    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     91}
     92
     93
     94RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     95                                     const char *pszNameFmt, ...)
     96{
     97    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     98
     99    /*
     100     * Allocate semaphore handle.
     101     */
    90102    int rc;
    91 
    92     /*
    93      * Allocate semaphore handle.
    94      */
    95103    struct RTSEMEVENTMULTIINTERNAL *pThis = (struct RTSEMEVENTMULTIINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTMULTIINTERNAL));
    96104    if (pThis)
    … …  
    122130                        ASMAtomicXchgU32(&pThis->cWaiters, 0);
    123131#ifdef RTSEMEVENTMULTI_STRICT
    124                         RTLockValidatorRecSharedInit(&pThis->Signallers,
    125                                                      NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_ANY,
    126                                                      pThis, true /*fSignaller*/, true /*fEnabled*/, "RTSemEvent");
     132                        va_list va;
     133                        va_start(va, pszNameFmt);
     134                        RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
     135                                                      true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL),
     136                                                      pszNameFmt, va);
     137                        va_end(va);
    127138                        pThis->fEverHadSignallers = false;
    128139#endif
    129140
    130                         *pEventMultiSem = pThis;
     141                        *phEventMultiSem = pThis;
    131142                        return VINF_SUCCESS;
    132143                    }
    … …  
    150161
    151162
    152 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
     163RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
    153164{
    154165    /*
    155166     * Validate handle.
    156167     */
    157     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     168    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    158169    if (pThis == NIL_RTSEMEVENTMULTI)
    159170        return VINF_SUCCESS;
    … …  
    177188    if (rc)
    178189    {
    179         AssertMsgFailed(("Failed to destroy event sem %p, rc=%d.\n", EventMultiSem, rc));
     190        AssertMsgFailed(("Failed to destroy event sem %p, rc=%d.\n", hEventMultiSem, rc));
    180191        return RTErrConvertFromErrno(rc);
    181192    }
    … …  
    194205    if (rc)
    195206    {
    196         AssertMsgFailed(("Failed to destroy event sem %p, rc=%d. (mutex)\n", EventMultiSem, rc));
     207        AssertMsgFailed(("Failed to destroy event sem %p, rc=%d. (mutex)\n", hEventMultiSem, rc));
    197208        return RTErrConvertFromErrno(rc);
    198209    }
    … …  
    209220
    210221
    211 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     222RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    212223{
    213224    /*
    214225     * Validate input.
    215226     */
    216     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     227    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    217228    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    218229    uint32_t u32 = pThis->u32State;
    … …  
    234245    if (rc)
    235246    {
    236         AssertMsgFailed(("Failed to lock event sem %p, rc=%d.\n", EventMultiSem, rc));
     247        AssertMsgFailed(("Failed to lock event sem %p, rc=%d.\n", hEventMultiSem, rc));
    237248        return RTErrConvertFromErrno(rc);
    238249    }
    … …  
    245256        ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_SIGNALED);
    246257        rc = pthread_cond_broadcast(&pThis->Cond);
    247         AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d.\n", EventMultiSem, rc));
     258        AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d.\n", hEventMultiSem, rc));
    248259    }
    249260    else if (pThis->u32State == EVENTMULTI_STATE_SIGNALED)
    250261    {
    251262        rc = pthread_cond_broadcast(&pThis->Cond); /* give'm another kick... */
    252         AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d. (2)\n", EventMultiSem, rc));
     263        AssertMsg(!rc, ("Failed to signal event sem %p, rc=%d. (2)\n", hEventMultiSem, rc));
    253264    }
    254265    else
    … …  
    259270     */
    260271    int rc2 = pthread_mutex_unlock(&pThis->Mutex);
    261     AssertMsg(!rc2, ("Failed to unlock event sem %p, rc=%d.\n", EventMultiSem, rc));
     272    AssertMsg(!rc2, ("Failed to unlock event sem %p, rc=%d.\n", hEventMultiSem, rc));
    262273    if (rc)
    263274        return RTErrConvertFromErrno(rc);
    … …  
    269280
    270281
    271 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     282RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    272283{
    273284    /*
    274285     * Validate input.
    275286     */
    276     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     287    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    277288    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    278289    uint32_t u32 = pThis->u32State;
    … …  
    285296    if (rc)
    286297    {
    287         AssertMsgFailed(("Failed to lock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
     298        AssertMsgFailed(("Failed to lock event multi sem %p, rc=%d.\n", hEventMultiSem, rc));
    288299        return RTErrConvertFromErrno(rc);
    289300    }
    … …  
    303314    if (rc)
    304315    {
    305         AssertMsgFailed(("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
     316        AssertMsgFailed(("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc));
    306317        return RTErrConvertFromErrno(rc);
    307318    }
    … …  
    312323
    313324
    314 static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fAutoResume)
     325static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies, bool fAutoResume)
    315326{
    316327    PCRTLOCKVALSRCPOS pSrcPos = NULL;
    … …  
    319330     * Validate input.
    320331     */
    321     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     332    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    322333    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    323334    uint32_t u32 = pThis->u32State;
    … …  
    333344        if (rc)
    334345        {
    335             AssertMsgFailed(("Failed to lock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
     346            AssertMsgFailed(("Failed to lock event multi sem %p, rc=%d.\n", hEventMultiSem, rc));
    336347            return RTErrConvertFromErrno(rc);
    337348        }
    … …  
    345356                ASMAtomicDecU32(&pThis->cWaiters);
    346357                rc = pthread_mutex_unlock(&pThis->Mutex);
    347                 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
     358                AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc)); NOREF(rc);
    348359                return VINF_SUCCESS;
    349360            }
    … …  
    351362            {
    352363                rc = pthread_mutex_unlock(&pThis->Mutex);
    353                 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
     364                AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc)); NOREF(rc);
    354365                return VERR_SEM_DESTROYED;
    355366            }
    … …  
    377388            if (rc)
    378389            {
    379                 AssertMsgFailed(("Failed to wait on event multi sem %p, rc=%d.\n", EventMultiSem, rc));
     390                AssertMsgFailed(("Failed to wait on event multi sem %p, rc=%d.\n", hEventMultiSem, rc));
    380391                ASMAtomicDecU32(&pThis->cWaiters);
    381392                int rc2 = pthread_mutex_unlock(&pThis->Mutex);
    382                 AssertMsg(!rc2, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc2)); NOREF(rc2);
     393                AssertMsg(!rc2, ("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc2)); NOREF(rc2);
    383394                return RTErrConvertFromErrno(rc);
    384395            }
    … …  
    421432        if (rc)
    422433        {
    423             AssertMsg(rc == ETIMEDOUT, ("Failed to lock event multi sem %p, rc=%d.\n", EventMultiSem, rc));
     434            AssertMsg(rc == ETIMEDOUT, ("Failed to lock event multi sem %p, rc=%d.\n", hEventMultiSem, rc));
    424435            return RTErrConvertFromErrno(rc);
    425436        }
    … …  
    433444                ASMAtomicDecU32(&pThis->cWaiters);
    434445                rc = pthread_mutex_unlock(&pThis->Mutex);
    435                 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
     446                AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc)); NOREF(rc);
    436447                return VINF_SUCCESS;
    437448            }
    … …  
    439450            {
    440451                rc = pthread_mutex_unlock(&pThis->Mutex);
    441                 AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc)); NOREF(rc);
     452                AssertMsg(!rc, ("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc)); NOREF(rc);
    442453                return VERR_SEM_DESTROYED;
    443454            }
    … …  
    473484            if (rc && (rc != EINTR || !fAutoResume)) /* according to SuS this function shall not return EINTR, but linux man page says differently. */
    474485            {
    475                 AssertMsg(rc == ETIMEDOUT, ("Failed to wait on event multi sem %p, rc=%d.\n", EventMultiSem, rc));
     486                AssertMsg(rc == ETIMEDOUT, ("Failed to wait on event multi sem %p, rc=%d.\n", hEventMultiSem, rc));
    476487                ASMAtomicDecU32(&pThis->cWaiters);
    477488                int rc2 = pthread_mutex_unlock(&pThis->Mutex);
    478                 AssertMsg(!rc2, ("Failed to unlock event multi sem %p, rc=%d.\n", EventMultiSem, rc2)); NOREF(rc2);
     489                AssertMsg(!rc2, ("Failed to unlock event multi sem %p, rc=%d.\n", hEventMultiSem, rc2)); NOREF(rc2);
    479490                return RTErrConvertFromErrno(rc);
    480491            }
    … …  
    484495
    485496
    486 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    487 {
    488     int rc = rtSemEventMultiWait(EventMultiSem, cMillies, true);
     497RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     498{
     499    int rc = rtSemEventMultiWait(hEventMultiSem, cMillies, true);
    489500    Assert(rc != VERR_INTERRUPTED);
    490501    return rc;
    … …  
    492503
    493504
    494 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
    495 {
    496     return rtSemEventMultiWait(EventMultiSem, cMillies, false);
     505RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
     506{
     507    return rtSemEventMultiWait(hEventMultiSem, cMillies, false);
    497508}
    498509

  • trunk/src/VBox/Runtime/r3/win/semeventmulti-win.cpp

    r25704 r25720  
    7070
    7171
    72 /* Undefine debug mappings. */
    73 #undef RTSemEventMultiWait
    74 #undef RTSemEventMultiWaitNoResume
    75 
    76 
    77 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
    78 {
     72
     73RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
     74{
     75    return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
     76}
     77
     78
     79RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
     80                                     const char *pszNameFmt, ...)
     81{
     82    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
     83
    7984    struct RTSEMEVENTMULTIINTERNAL *pThis = (struct RTSEMEVENTMULTIINTERNAL *)RTMemAlloc(sizeof(*pThis));
    8085    if (!pThis)
    … …  
    9095        pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
    9196#ifdef RTSEMEVENT_STRICT
    92         RTLockValidatorRecSharedInit(&pThis->Signallers,
    93                                      NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_ANY,
    94                                      pThis, true /*fSignaller*/, true /*fEnabled*/, "RTSemEvent");
     97        va_list va;
     98        va_start(va, pszNameFmt);
     99        RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
     100                                      true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL),
     101                                      pszNameFmt, va);
     102        va_end(va);
    95103        pThis->fEverHadSignallers = false;
    96104#endif
    97105
    98         *pEventMultiSem = pThis;
     106        *phEventMultiSem = pThis;
    99107        return VINF_SUCCESS;
    100108    }
    … …  
    106114
    107115
    108 RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
    109 {
    110     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     116RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
     117{
     118    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    111119    if (pThis == NIL_RTSEMEVENT)        /* don't bitch */
    112         return VERR_INVALID_HANDLE;
     120        return VINF_SUCCESS;
    113121    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    114122    AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
    … …  
    130138        DWORD dwErr = GetLastError();
    131139        rc = RTErrConvertFromWin32(dwErr);
    132         AssertMsgFailed(("Destroy EventMultiSem %p failed, lasterr=%u (%Rrc)\n", pThis, dwErr, rc));
     140        AssertMsgFailed(("Destroy hEventMultiSem %p failed, lasterr=%u (%Rrc)\n", pThis, dwErr, rc));
    133141        /* Leak it. */
    134142    }
    … …  
    138146
    139147
    140 RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     148RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    141149{
    142150    /*
    143151     * Validate input.
    144152     */
    145     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     153    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    146154    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    147155    AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
    … …  
    162170        return VINF_SUCCESS;
    163171    DWORD dwErr = GetLastError();
    164     AssertMsgFailed(("Signaling EventMultiSem %p failed, lasterr=%d\n", pThis, dwErr));
     172    AssertMsgFailed(("Signaling hEventMultiSem %p failed, lasterr=%d\n", pThis, dwErr));
    165173    return RTErrConvertFromWin32(dwErr);
    166174}
    167175
    168176
    169 RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     177RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
    170178{
    171179    /*
    172180     * Validate input.
    173181     */
    174     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     182    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    175183    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    176184    AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
    … …  
    182190        return VINF_SUCCESS;
    183191    DWORD dwErr = GetLastError();
    184     AssertMsgFailed(("Resetting EventMultiSem %p failed, lasterr=%d\n", pThis, dwErr));
     192    AssertMsgFailed(("Resetting hEventMultiSem %p failed, lasterr=%d\n", pThis, dwErr));
    185193    return RTErrConvertFromWin32(dwErr);
    186194}
    … …  
    201209        {
    202210            int rc2 = RTErrConvertFromWin32(GetLastError());
    203             AssertMsgFailed(("Wait on EventMultiSem %p failed, rc=%d lasterr=%d\n", pThis, rc, GetLastError()));
     211            AssertMsgFailed(("Wait on hEventMultiSem %p failed, rc=%d lasterr=%d\n", pThis, rc, GetLastError()));
    204212            if (rc2)
    205213                return rc2;
    … …  
    212220
    213221
    214 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
     222#undef RTSemEventMultiWaitNoResume
     223RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, unsigned cMillies)
    215224{
    216225    PCRTLOCKVALSRCPOS pSrcPos = NULL;
    … …  
    219228     * Validate input.
    220229     */
    221     struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem;
     230    struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    222231    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    223232    AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
Note: See TracChangeset for help on using the changeset viewer.

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