VirtualBox

Changeset 25720 in vbox for trunk/src/VBox/Runtime/r3


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/src/VBox/Runtime/r3
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • 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.

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