VirtualBox

Changeset 30111 in vbox for trunk


Ignore:
Timestamp:
Jun 9, 2010 12:14:59 PM (15 years ago)
Author:
vboxsync
Message:

iprt/asm.h,*: Revised the ASMAtomic*Ptr functions and macros. The new saves lots of unsafe (void * volatile *) casts as well as adding some type safety when using GCC (typeof rulez).

Location:
trunk
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/asm.h

    r29286 r30111  
    470470#endif
    471471}
     472
     473
     474/**
     475 * Convenience macro for avoiding the annoying casting with ASMAtomicXchgPtr.
     476 *
     477 * @returns Current *pv value
     478 * @param   ppv     Pointer to the pointer variable to update.
     479 * @param   pv      The pointer value to assign to *ppv.
     480 * @param   Type    The type of *ppv, sans volatile.
     481 */
     482#ifdef __GNUC__
     483# define ASMAtomicXchgPtrT(ppv, pv, Type) \
     484    __extension__ \
     485    ({\
     486        __typeof__(*(ppv)) volatile * const ppvTypeChecked = (ppv); \
     487        Type                          const pvTypeChecked  = (pv); \
     488        Type pvTypeCheckedRet = (__typeof__(*(ppv))) ASMAtomicXchgPtr((void * volatile *)ppvTypeChecked, (void *)pvTypeChecked); \
     489        pvTypeCheckedRet; \
     490     })
     491#else
     492# define ASMAtomicXchgPtrT(ppv, pv, Type) \
     493    (Type)ASMAtomicXchgPtr((void * volatile *)(ppv), (void *)(pv))
     494#endif
    472495
    473496
    … …  
    849872 * @param   pvOld       The old value to *ppv compare with.
    850873 */
    851 DECLINLINE(bool) ASMAtomicCmpXchgPtr(void * volatile *ppv, const void *pvNew, const void *pvOld)
     874DECLINLINE(bool) ASMAtomicCmpXchgPtrVoid(void * volatile *ppv, const void *pvNew, const void *pvOld)
    852875{
    853876#if ARCH_BITS == 32
    … …  
    859882#endif
    860883}
     884
     885
     886/**
     887 * Atomically Compare and Exchange a pointer value, ordered.
     888 *
     889 * @returns true if xchg was done.
     890 * @returns false if xchg wasn't done.
     891 *
     892 * @param   ppv         Pointer to the value to update.
     893 * @param   pvNew       The new value to assigned to *ppv.
     894 * @param   pvOld       The old value to *ppv compare with.
     895 *
     896 * @remarks This is relatively type safe on GCC platforms.
     897 */
     898#ifdef __GNUC__
     899# define ASMAtomicCmpXchgPtr(ppv, pvNew, pvOld) \
     900    __extension__ \
     901    ({\
     902        __typeof__(*(ppv)) volatile * const ppvTypeChecked   = (ppv); \
     903        __typeof__(*(ppv))            const pvNewTypeChecked = (pvNew); \
     904        __typeof__(*(ppv))            const pvOldTypeChecked = (pvOld); \
     905        bool fMacroRet = ASMAtomicCmpXchgPtrVoid((void * volatile *)ppvTypeChecked, \
     906                                                 (void *)pvNewTypeChecked, (void *)pvOldTypeChecked); \
     907        fMacroRet; \
     908     })
     909#else
     910# define ASMAtomicCmpXchgPtr(ppv, pvNew, pvOld) \
     911    ASMAtomicCmpXchgPtrVoid((void * volatile *)(ppv), (void *)(pvNew), (void *)(pvOld))
     912#endif
    861913
    862914
    … …  
    11761228 * @param   ppvOld      Pointer store the old value at.
    11771229 */
    1178 DECLINLINE(bool) ASMAtomicCmpXchgExPtr(void * volatile *ppv, const void *pvNew, const void *pvOld, void **ppvOld)
     1230DECLINLINE(bool) ASMAtomicCmpXchgExPtrVoid(void * volatile *ppv, const void *pvNew, const void *pvOld, void **ppvOld)
    11791231{
    11801232#if ARCH_BITS == 32
    … …  
    11861238#endif
    11871239}
     1240
     1241
     1242/**
     1243 * Atomically Compare and Exchange a pointer value, additionally
     1244 * passing back old value, ordered.
     1245 *
     1246 * @returns true if xchg was done.
     1247 * @returns false if xchg wasn't done.
     1248 *
     1249 * @param   ppv         Pointer to the value to update.
     1250 * @param   pvNew       The new value to assigned to *ppv.
     1251 * @param   pvOld       The old value to *ppv compare with.
     1252 * @param   ppvOld      Pointer store the old value at.
     1253 *
     1254 * @remarks This is relatively type safe on GCC platforms.
     1255 */
     1256#ifdef __GNUC__
     1257# define ASMAtomicCmpXchgExPtr(ppv, pvNew, pvOld, ppvOld) \
     1258    __extension__ \
     1259    ({\
     1260        __typeof__(*(ppv)) volatile * const ppvTypeChecked    = (ppv); \
     1261        __typeof__(*(ppv))            const pvNewTypeChecked  = (pvNew); \
     1262        __typeof__(*(ppv))            const pvOldTypeChecked  = (pvOld); \
     1263        __typeof__(*(ppv)) *          const ppvOldTypeChecked = (ppvOld); \
     1264        bool fMacroRet = ASMAtomicCmpXchgExPtrVoid((void * volatile *)ppvTypeChecked, \
     1265                                                   (void *)pvNewTypeChecked, (void *)pvOldTypeChecked, \
     1266                                                   (void **)ppvOld); \
     1267        fMacroRet; \
     1268     })
     1269#else
     1270# define ASMAtomicCmpXchgExPtr(ppv, pvNew, pvOld, ppvOld) \
     1271    ASMAtomicCmpXchgExPtrVoid((void * volatile *)(ppv), (void *)(pvNew), (void *)pvOld, (void **)ppvOld)
     1272#endif
    11881273
    11891274
    … …  
    19031988 * @returns Current *pv value
    19041989 * @param   ppv     Pointer to the pointer variable to read.
     1990 *
     1991 * @remarks Please use ASMAtomicReadPtrT, it provides better type safety and
     1992 *          requires less typing (no casts).
    19051993 */
    19061994DECLINLINE(void *) ASMAtomicReadPtr(void * volatile *ppv)
    … …  
    19152003}
    19162004
    1917 
    1918 /**
    1919  * Atomically reads a pointer value, unordered.
     2005/**
     2006 * Convenience macro for avoiding the annoying casting with ASMAtomicReadPtr.
    19202007 *
    19212008 * @returns Current *pv value
    19222009 * @param   ppv     Pointer to the pointer variable to read.
     2010 * @param   Type    The type of *ppv, sans volatile.
     2011 */
     2012#ifdef __GNUC__
     2013# define ASMAtomicReadPtrT(ppv, Type) \
     2014    __extension__ \
     2015    ({\
     2016        __typeof__(*(ppv)) volatile *ppvTypeChecked = (ppv); \
     2017        Type pvTypeChecked = (__typeof__(*(ppv))) ASMAtomicReadPtr((void * volatile *)ppvTypeChecked); \
     2018        pvTypeChecked; \
     2019     })
     2020#else
     2021# define ASMAtomicReadPtrT(ppv, Type) \
     2022    (Type)ASMAtomicReadPtr((void * volatile *)(ppv))
     2023#endif
     2024
     2025
     2026/**
     2027 * Atomically reads a pointer value, unordered.
     2028 *
     2029 * @returns Current *pv value
     2030 * @param   ppv     Pointer to the pointer variable to read.
     2031 *
     2032 * @remarks Please use ASMAtomicUoReadPtrT, it provides better type safety and
     2033 *          requires less typing (no casts).
    19232034 */
    19242035DECLINLINE(void *) ASMAtomicUoReadPtr(void * volatile *ppv)
    … …  
    19322043#endif
    19332044}
     2045
     2046
     2047/**
     2048 * Convenience macro for avoiding the annoying casting with ASMAtomicUoReadPtr.
     2049 *
     2050 * @returns Current *pv value
     2051 * @param   ppv     Pointer to the pointer variable to read.
     2052 * @param   Type    The type of *ppv, sans volatile.
     2053 */
     2054#ifdef __GNUC__
     2055# define ASMAtomicUoReadPtrT(ppv, Type) \
     2056    __extension__ \
     2057    ({\
     2058        __typeof__(*(ppv)) volatile * const ppvTypeChecked = (ppv); \
     2059        Type pvTypeChecked = (__typeof__(*(ppv))) ASMAtomicUoReadPtr((void * volatile *)ppvTypeChecked); \
     2060        pvTypeChecked; \
     2061     })
     2062#else
     2063# define ASMAtomicUoReadPtrT(ppv, Type) \
     2064    (Type)ASMAtomicUoReadPtr((void * volatile *)(ppv))
     2065#endif
    19342066
    19352067
    … …  
    22862418 * @returns Current *pv value
    22872419 * @param   ppv     Pointer to the pointer variable.
    2288  * @param   pv      The pointer value to assigne to *ppv.
    2289  */
    2290 DECLINLINE(void) ASMAtomicWritePtr(void * volatile *ppv, const void *pv)
     2420 * @param   pv      The pointer value to assign to *ppv.
     2421 */
     2422DECLINLINE(void) ASMAtomicWritePtrVoid(void * volatile *ppv, const void *pv)
    22912423{
    22922424#if ARCH_BITS == 32
    … …  
    23012433
    23022434/**
    2303  * Atomically writes a pointer value, unordered.
     2435 * Convenience macro for avoiding the annoying casting with ASMAtomicWritePtr.
    23042436 *
    23052437 * @returns Current *pv value
    23062438 * @param   ppv     Pointer to the pointer variable.
    2307  * @param   pv      The pointer value to assigne to *ppv.
    2308  */
    2309 DECLINLINE(void) ASMAtomicUoWritePtr(void * volatile *ppv, const void *pv)
    2310 {
    2311 #if ARCH_BITS == 32
    2312     ASMAtomicUoWriteU32((volatile uint32_t *)(void *)ppv, (uint32_t)pv);
    2313 #elif ARCH_BITS == 64
    2314     ASMAtomicUoWriteU64((volatile uint64_t *)(void *)ppv, (uint64_t)pv);
    2315 #else
    2316 # error "ARCH_BITS is bogus"
    2317 #endif
    2318 }
     2439 * @param   pv      The pointer value to assign to *ppv. If NULL, you may have
     2440 *                  to cast it to the right pointer type for GCC to be happy.
     2441 *
     2442 * @remarks This is relatively type safe on GCC platforms when @a pv isn't
     2443 *          NULL.
     2444 */
     2445#ifdef __GNUC__
     2446# define ASMAtomicWritePtr(ppv, pv) \
     2447    do \
     2448    { \
     2449        __typeof__(*(ppv)) volatile * const ppvTypeChecked = (ppv); \
     2450        __typeof__(*(ppv))            const pvTypeChecked  = (pv); \
     2451        \
     2452        AssertCompile(sizeof(*ppv) == sizeof(void *)); \
     2453        AssertCompile(sizeof(pv) == sizeof(void *)); \
     2454        Assert(!( (uintptr_t)ppv & ((ARCH_BITS / 8) - 1) )); \
     2455        \
     2456        ASMAtomicWritePtrVoid((void * volatile *)(ppvTypeChecked), (void *)(pvTypeChecked)); \
     2457    } while (0)
     2458#else
     2459# define ASMAtomicWritePtr(ppv, pv) \
     2460    do \
     2461    { \
     2462        AssertCompile(sizeof(*ppv) == sizeof(void *)); \
     2463        AssertCompile(sizeof(pv) == sizeof(void *)); \
     2464        Assert(!( (uintptr_t)ppv & ((ARCH_BITS / 8) - 1) )); \
     2465        \
     2466        ASMAtomicWritePtrVoid((void * volatile *)(ppv), (void *)(pv)); \
     2467    } while (0)
     2468#endif
     2469
     2470
     2471/**
     2472 * Convenience macro for avoiding the annoying casting involved when using
     2473 * ASMAtomicWritePtr.
     2474 *
     2475 * @returns Current *pv value
     2476 * @param   ppv     Pointer to the pointer variable.
     2477 * @param   pv      The pointer value to assign to *ppv.
     2478 *
     2479 * @remarks This is relatively type safe on GCC platforms when @a pv isn't
     2480 *          NULL.
     2481 */
     2482#ifdef __GNUC__
     2483# define ASMAtomicUoWritePtr(ppv, pv) \
     2484    do \
     2485    { \
     2486        __typeof__(*(ppv)) volatile * const ppvTypeChecked = (ppv); \
     2487        __typeof__(*(ppv))            const pvTypeChecked  = (pv); \
     2488        \
     2489        AssertCompile(sizeof(*ppv) == sizeof(void *)); \
     2490        AssertCompile(sizeof(pv) == sizeof(void *)); \
     2491        Assert(!( (uintptr_t)ppv & ((ARCH_BITS / 8) - 1) )); \
     2492        \
     2493        *(ppvTypeChecked) = pvTypeChecked; \
     2494    } while (0)
     2495#else
     2496# define ASMAtomicUoWritePtr(ppv, pv) \
     2497    do \
     2498    { \
     2499        AssertCompile(sizeof(*ppv) == sizeof(void *)); \
     2500        AssertCompile(sizeof(pv) == sizeof(void *)); \
     2501        Assert(!( (uintptr_t)ppv & ((ARCH_BITS / 8) - 1) )); \
     2502        *(ppv) = pv; \
     2503    } while (0)
     2504#endif
    23192505
    23202506

  • trunk/src/VBox/Devices/Network/SrvIntNetR0.cpp

    r30029 r30111  
    17751775                    PINTNETDSTTAB pOld = pIf->pDstTab;
    17761776                    if (   pOld
    1777                         && ASMAtomicCmpXchgPtr((void * volatile *)&pIf->pDstTab, pNew, pOld))
     1777                        && ASMAtomicCmpXchgPtr(&pIf->pDstTab, pNew, pOld))
    17781778                    {
    17791779                        RTMemFree(pOld);
    … …  
    32943294         * Grab the destination table.
    32953295         */
    3296         PINTNETDSTTAB pDstTab = (PINTNETDSTTAB)ASMAtomicXchgPtr((void * volatile *)&pIf->pDstTab, NULL);
     3296        PINTNETDSTTAB pDstTab = ASMAtomicXchgPtrT(&pIf->pDstTab, NULL, PINTNETDSTTAB);
    32973297        if (RT_LIKELY(pDstTab))
    32983298        {
    … …  
    33573357             */
    33583358            Assert(!pIf->pDstTab);
    3359             ASMAtomicWritePtr((void * volatile *)&pIf->pDstTab, pDstTab);
     3359            ASMAtomicWritePtr(&pIf->pDstTab, pDstTab);
    33603360        }
    33613361        else

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r29879 r30111  
    38923892    bool fAssertIntr = false;
    38933893    PAHCI pAhci = pAhciPort->CTX_SUFF(pAhci);
    3894     PAHCIPORTTASKSTATE pTaskErr = (PAHCIPORTTASKSTATE)ASMAtomicReadPtr((void * volatile *)&pAhciPort->pTaskErr);
     3894    PAHCIPORTTASKSTATE pTaskErr = ASMAtomicReadPtrT(&pAhciPort->pTaskErr, PAHCIPORTTASKSTATE);
    38953895
    38963896    ahciLog(("%s: Building SDB FIS\n", __FUNCTION__));
    … …  
    49004900                        pAhciPortTaskState->cbTransfer, rcReq));
    49014901        }
    4902         ASMAtomicCmpXchgPtr((void * volatile *)&pAhciPort->pTaskErr, pAhciPortTaskState, NULL);
     4902        ASMAtomicCmpXchgPtr(&pAhciPort->pTaskErr, pAhciPortTaskState, NULL);
    49034903    }
    49044904    else
    … …  
    49324932        cOutstandingTasks = ASMAtomicDecU32(&pAhciPort->uActTasksActive);
    49334933        ahciLog(("%s: After decrement uActTasksActive=%u\n", __FUNCTION__, cOutstandingTasks));
    4934         if (RT_SUCCESS(rcReq) && !ASMAtomicReadPtr((void * volatile *)&pAhciPort->pTaskErr))
     4934        if (RT_SUCCESS(rcReq) && !ASMAtomicReadPtrT(&pAhciPort->pTaskErr, PAHCIPORTTASKSTATE))
    49354935            ASMAtomicOrU32(&pAhciPort->u32QueuedTasksFinished, (1 << pAhciPortTaskState->uTag));
    49364936
    … …  
    51905190                    {
    51915191                        LogFlow(("Reading error page\n"));
    5192                         PAHCIPORTTASKSTATE pTaskErr = (PAHCIPORTTASKSTATE)ASMAtomicXchgPtr((void * volatile *)&pAhciPort->pTaskErr, NULL);
     5192                        PAHCIPORTTASKSTATE pTaskErr = ASMAtomicXchgPtrT(&pAhciPort->pTaskErr, NULL, PAHCIPORTTASKSTATE);
    51935193                        if (pTaskErr)
    51945194                        {

  • trunk/src/VBox/Devices/Storage/DrvDiskIntegrity.cpp

    r29495 r30111  
    490490    Assert(pReqActive->pIoReq == pIoReq);
    491491
    492     ASMAtomicXchgPtr((void * volatile *)&pReqActive->pIoReq, NULL);
     492    ASMAtomicWritePtr(&pReqActive->pIoReq, NULL);
    493493}
    494494
    … …  
    520520        {
    521521            PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[i];
    522             PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)ASMAtomicReadPtr((void * volatile *)&pReqActive->pIoReq);
     522            PDRVDISKAIOREQ pIoReq = ASMAtomicReadPtrT(&pReqActive->pIoReq, PDRVDISKAIOREQ);
    523523
    524524            if (   pIoReq

  • trunk/src/VBox/Devices/Storage/DrvVD.cpp

    r29135 r30111  
    11591159    PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
    11601160
    1161     RTSEMFASTMUTEX mutex = (RTSEMFASTMUTEX)ASMAtomicXchgPtr((void **)&pThis->MergeCompleteMutex,
    1162                                                             (void *)NIL_RTSEMFASTMUTEX);
     1161    RTSEMFASTMUTEX mutex;
     1162    ASMAtomicXchgHandle(&pThis->MergeCompleteMutex, NIL_RTSEMFASTMUTEX, &mutex);
    11631163    if (mutex != NIL_RTSEMFASTMUTEX)
    11641164    {

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBufferQuartz2D.cpp

    r28800 r30111  
    9292     * ASMAtomic(Cmp)XchgPtr and a struct { cAllocated; cRects; aRects[1]; }
    9393     * *mRegion, *mUnusedRegion; should suffice (and permit you to reuse allocations). */
    94     RegionRects *rgnRcts = (RegionRects *)ASMAtomicXchgPtr((void * volatile *) &mRegionUnused, NULL);
     94    RegionRects *rgnRcts = ASMAtomicXchgPtrT(&mRegionUnused, NULL, RegionRects *);
    9595    if (rgnRcts && rgnRcts->allocated < aCount)
    9696    {
    … …  
    143143//    printf ("..................................\n");
    144144
    145     void *pvOld = ASMAtomicXchgPtr((void * volatile *)&mRegion, rgnRcts);
    146     if (    pvOld
    147         &&  !ASMAtomicCmpXchgPtr((void * volatile *)&mRegionUnused, pvOld, NULL))
    148         RTMemFree (pvOld);
     145    RegionRects *pOld = ASMAtomicXchgPtrT(&mRegion, rgnRcts, RegionRects *);
     146    if (    pOld
     147        &&  !ASMAtomicCmpXchgPtr(&mRegionUnused, pOld, NULL))
     148        RTMemFree(pOld);
    149149
    150150    QApplication::postEvent(m_pMachineView, new UISetRegionEvent (reg));
    … …  
    203203#endif
    204204        /* Grab the current visible region. */
    205         RegionRects *rgnRcts = (RegionRects *)ASMAtomicXchgPtr((void * volatile *)&mRegion, NULL);
     205        RegionRects *rgnRcts = ASMAtomicXchgPtrT(&mRegion, NULL, RegionRects *);
    206206        if (rgnRcts)
    207207        {
    … …  
    216216            }
    217217            /* Put back the visible region, free if we cannot (2+ SetVisibleRegion calls). */
    218             if (    !ASMAtomicCmpXchgPtr((void * volatile *)&mRegion, rgnRcts, NULL)
    219                 &&  !ASMAtomicCmpXchgPtr((void * volatile *)&mRegionUnused, rgnRcts, NULL))
     218            if (    !ASMAtomicCmpXchgPtr(&mRegion, rgnRcts, NULL)
     219                &&  !ASMAtomicCmpXchgPtr(&mRegionUnused, rgnRcts, NULL))
    220220                RTMemFree(rgnRcts);
    221221        }

  • trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

    r28800 r30111  
    508508        if (g_pSUPGlobalInfoPage)
    509509        {
    510             ASMAtomicXchgPtr((void * volatile *)&g_pSUPGlobalInfoPage, NULL);
    511             ASMAtomicXchgPtr((void * volatile *)&g_pSUPGlobalInfoPageR0, NULL);
    512             ASMAtomicXchgSize(&g_HCPhysSUPGlobalInfoPage, NIL_RTHCPHYS);
     510            ASMAtomicWritePtr((void * volatile *)&g_pSUPGlobalInfoPage, NULL);
     511            ASMAtomicWritePtr((void * volatile *)&g_pSUPGlobalInfoPageR0, NULL);
     512            ASMAtomicWriteSize(&g_HCPhysSUPGlobalInfoPage, NIL_RTHCPHYS);
    513513            /* just a little safe guard against threads using the page. */
    514514            RTThreadSleep(50);

  • trunk/src/VBox/HostDrivers/Support/SUPR0IdcClient.c

    r29261 r30111  
    125125            &&  (Req.u.Out.uSessionVersion & UINT32_C(0xffff0000)) == (SUPDRV_IDC_VERSION & UINT32_C(0xffff0000)))
    126126        {
    127             ASMAtomicCmpXchgPtr((void * volatile *)&g_pMainHandle, pHandle, NULL);
     127            ASMAtomicCmpXchgPtr(&g_pMainHandle, pHandle, NULL);
    128128            return rc;
    129129        }
    … …  
    167167    {
    168168        pHandle->s.pSession = NULL;
    169         ASMAtomicCmpXchgPtr((void * volatile *)&g_pMainHandle, NULL, pHandle);
     169        ASMAtomicCmpXchgPtr(&g_pMainHandle, NULL, pHandle);
    170170    }
    171171    return rc;
    … …  
    203203PSUPDRVIDCHANDLE supR0IdcGetHandleFromSession(PSUPDRVSESSION pSession)
    204204{
    205     PSUPDRVIDCHANDLE pHandle = (PSUPDRVIDCHANDLE)ASMAtomicUoReadPtr((void * volatile *)&g_pMainHandle);
     205    PSUPDRVIDCHANDLE pHandle = ASMAtomicUoReadPtrT(&g_pMainHandle, PSUPDRVIDCHANDLE);
    206206    if (    VALID_PTR(pHandle)
    207207        &&  pHandle->s.pSession == pSession)

  • trunk/src/VBox/HostDrivers/Support/SUPSvcGrant.cpp

    r28800 r30111  
    179179     * Clean up the session.
    180180     */
    181     PSUPSVCGRANT pParent = (PSUPSVCGRANT)ASMAtomicReadPtr((void * volatile *)&pThis->pParent);
     181    PSUPSVCGRANT pParent = ASMAtomicReadPtrT(&pThis->pParent, PSUPSVCGRANT);
    182182    if (pParent)
    183183        RTCritSectEnter(&pParent->CritSect);
    … …  
    975975    unsigned cSessions = 0;
    976976    for (PSUPSVCGRANTSESSION pCur = pThis->pSessionHead; pCur; pCur = pCur->pNext)
    977         ASMAtomicWritePtr((void * volatile *)&pCur->pParent, NULL);
     977        ASMAtomicWritePtr(&pCur->pParent, NULL);
    978978
    979979    RTCritSectLeave(&pThis->CritSect);

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/darwin/VBoxNetFlt-darwin.cpp

    r29662 r30111  
    236236    if (!ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost))
    237237    {
    238         pIfNet = (ifnet_t)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pIfNet);
     238        pIfNet = ASMAtomicUoReadPtrT(&pThis->u.s.pIfNet, ifnet_t);
    239239        if (pIfNet)
    240240            ifnet_reference(pIfNet);
    … …  
    666666    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    667667
    668     pIfNet = (ifnet_t)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pIfNet);
     668    pIfNet = ASMAtomicUoReadPtrT(&pThis->u.s.pIfNet, ifnet_t);
    669669    int cPromisc = VALID_PTR(pIfNet) ? VBOX_GET_PCOUNT(pIfNet) : - 1;
    670670
    671     ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pIfNet, NULL);
    672     ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pIfFilter, NULL);
     671    ASMAtomicUoWritePtr(&pThis->u.s.pIfNet, NULL);
     672    ASMAtomicUoWritePtr(&pThis->u.s.pIfFilter, NULL);
    673673    ASMAtomicWriteBool(&pThis->u.s.fNeedSetPromiscuous, false);
    674674    pThis->u.s.fSetPromiscuous = false;
    … …  
    914914    RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
    915915    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    916     ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pIfNet, pIfNet);
     916    ASMAtomicUoWritePtr(&pThis->u.s.pIfNet, pIfNet);
    917917    RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);
    918918
    … …  
    940940
    941941        RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    942         pIfNet = (ifnet_t)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pIfNet);
     942        pIfNet = ASMAtomicUoReadPtrT(&pThis->u.s.pIfNet, ifnet_t);
    943943        if (pIfNet && !err)
    944944        {
    945945            ASMAtomicUoWriteBool(&pThis->fDisconnectedFromHost, false);
    946             ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pIfFilter, pIfFilter);
     946            ASMAtomicUoWritePtr(&pThis->u.s.pIfFilter, pIfFilter);
    947947            pIfNet = NULL; /* don't dereference it */
    948948        }
    … …  
    11621162     */
    11631163    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    1164     pIfFilter = (interface_filter_t)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pIfFilter);
     1164    pIfFilter = ASMAtomicUoReadPtrT(&pThis->u.s.pIfFilter, interface_filter_t);
    11651165    if (pIfFilter)
    1166         ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pIfFilter, NULL);
     1166        ASMAtomicUoWritePtr(&pThis->u.s.pIfFilter, NULL);
    11671167    RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);
    11681168

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/freebsd/VBoxNetFlt-freebsd.c

    r29747 r30111  
    498498    int error;
    499499
    500     ifp = (void *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.ifp);
     500    ifp = ASMAtomicUoReadPtrT(&pThis->u.s.ifp, struct ifnet *);
    501501
    502502    if (fDst & INTNETTRUNKDIR_WIRE)
    … …  
    568568    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    569569
    570     ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.ifp, ifp);
     570    ASMAtomicUoWritePtr(&pThis->u.s.ifp, ifp);
    571571    pThis->u.s.node = node;
    572572    bcopy(IF_LLADDR(ifp), &pThis->u.s.MacAddr, ETHER_ADDR_LEN);
    … …  
    611611    struct ifnet *ifp, *ifp0;
    612612
    613     ifp = (struct ifnet *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.ifp);
     613    ifp = ASMAtomicUoReadPtrT(&pThis->u.s.ifp, struct ifnet *);
    614614    /*
    615615     * Attempt to check if the interface is still there and re-initialize if
    … …  
    669669    Log(("%s: fActive:%d\n", __func__, fActive));
    670670
    671     ifp = (struct ifnet *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.ifp);
    672     node = (node_p)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.node);
     671    ifp = ASMAtomicUoReadPtrT(&pThis->u.s.ifp, struct ifnet *);
     672    node = ASMAtomicUoReadPtrT(&pThis->u.s.node, node_p);
    673673
    674674    memset(&ifreq, 0, sizeof(struct ifreq));

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/linux/VBoxNetFlt-linux.c

    r30059 r30111  
    171171#ifdef VBOXNETFLT_WITH_QDISC
    172172//#define QDISC_LOG(x) printk x
    173 #define QDISC_LOG(x)
     173#define QDISC_LOG(x) do { } while (0)
    174174
    175175#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
    … …  
    593593#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
    594594        pPriv->ppSaved[0] = pDev->qdisc_sleeping;
    595         ASMAtomicWritePtr((void * volatile *)&pDev->qdisc_sleeping, pNew);
    596         ASMAtomicWritePtr((void * volatile *)&pDev->qdisc, pNew);
     595        ASMAtomicWritePtr(&pDev->qdisc_sleeping, pNew);
     596        ASMAtomicWritePtr(&pDev->qdisc, pNew);
    597597#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27) */
    598598        for (i = 0; i < pDev->num_tx_queues; i++)
    … …  
    601601
    602602            pPriv->ppSaved[i] = pQueue->qdisc_sleeping;
    603             ASMAtomicWritePtr((void * volatile *)&pQueue->qdisc_sleeping, pNew);
    604             ASMAtomicWritePtr((void * volatile *)&pQueue->qdisc, pNew);
     603            ASMAtomicWritePtr(&pQueue->qdisc_sleeping, pNew);
     604            ASMAtomicWritePtr(&pQueue->qdisc, pNew);
    605605            if (i)
    606606                atomic_inc(&pNew->refcnt);
    … …  
    609609# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
    610610        pPriv->ppSaved[pDev->num_tx_queues] = pDev->qdisc;
    611         ASMAtomicWritePtr((void * volatile *)&pDev->qdisc, pNew);
     611        ASMAtomicWritePtr(&pDev->qdisc, pNew);
    612612        atomic_inc(&pNew->refcnt);
    613613# endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32) */
    … …  
    619619        pPriv = qdisc_priv(pExisting);
    620620    }
    621     ASMAtomicWritePtr((void * volatile *)&pPriv->pVBoxNetFlt, pThis);
     621    ASMAtomicWritePtr(&pPriv->pVBoxNetFlt, pThis);
    622622    QDISC_LOG(("vboxNetFltLinuxInstallQdisc: pThis=%p\n", pPriv->pVBoxNetFlt));
    623623}
    … …  
    631631    struct Qdisc *pQdisc;
    632632    if (!pDev)
    633         pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     633        pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    634634    if (!VALID_PTR(pDev))
    635635    {
    … …  
    651651    pPriv = qdisc_priv(pQdisc);
    652652    Assert(pPriv->pVBoxNetFlt == pThis);
    653     ASMAtomicWritePtr((void * volatile *)&pPriv->pVBoxNetFlt, NULL);
    654 
    655     QDISC_LOG(("vboxNetFltLinuxQdiscRemove: refcnt=%d num_tx_queues=%d\n", 
     653    ASMAtomicWritePtr(&pPriv->pVBoxNetFlt, NULL);
     654
     655    QDISC_LOG(("vboxNetFltLinuxQdiscRemove: refcnt=%d num_tx_queues=%d\n",
    656656               atomic_read(&pQdisc->refcnt), pDev->num_tx_queues));
    657657#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
    … …  
    659659    if (pPriv->ppSaved[0])
    660660    {
    661         ASMAtomicWritePtr((void * volatile *)&pDev->qdisc_sleeping,
    662                           pPriv->ppSaved[0]);
    663         ASMAtomicWritePtr((void * volatile *)&pDev->qdisc,
    664                           pPriv->ppSaved[0]);
     661        ASMAtomicWritePtr(&pDev->qdisc_sleeping, pPriv->ppSaved[0]);
     662        ASMAtomicWritePtr(&pDev->qdisc, pPriv->ppSaved[0]);
    665663        pPriv->ppSaved[0] = NULL;
    666664        while (QDISC_IS_BUSY(pDev, pQdisc))
    … …  
    675673        {
    676674            Assert(pQueue->qdisc_sleeping == pQdisc);
    677             ASMAtomicWritePtr((void * volatile *)&pQueue->qdisc_sleeping,
    678                               pPriv->ppSaved[i]);
    679             ASMAtomicWritePtr((void * volatile *)&pQueue->qdisc,
    680                               pPriv->ppSaved[i]);
     675            ASMAtomicWritePtr(&pQueue->qdisc_sleeping, pPriv->ppSaved[i]);
     676            ASMAtomicWritePtr(&pQueue->qdisc, pPriv->ppSaved[i]);
    681677            pPriv->ppSaved[i] = NULL;
    682678            while (QDISC_IS_BUSY(pDev, pQdisc))
    … …  
    687683    /* Newer kernels store root qdisc in netdev structure as well. */
    688684#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
    689     ASMAtomicWritePtr((void * volatile *)&pDev->qdisc,
    690                       pPriv->ppSaved[pDev->num_tx_queues]);
     685    ASMAtomicWritePtr(&pDev->qdisc, pPriv->ppSaved[pDev->num_tx_queues]);
    691686    pPriv->ppSaved[pDev->num_tx_queues] = NULL;
    692687    while (QDISC_IS_BUSY(pDev, pQdisc))
    … …  
    912907
    913908    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp); /* (this isn't necessary, but so what) */
    914     ASMAtomicXchgPtr((void * volatile *)&pDev->netdev_ops, pOverride);
     909    ASMAtomicWritePtr((void * volatile *)&pDev->netdev_ops, pOverride);
    915910    RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);
    916911}
    … …  
    930925    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    931926    if (!pDev)
    932         pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     927        pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    933928    if (VALID_PTR(pDev))
    934929    {
    … …  
    939934           )
    940935        {
    941             ASMAtomicXchgPtr((void * volatile *)&pDev->netdev_ops, pOverride->pOrgOps);
     936            ASMAtomicWritePtr((void * volatile *)&pDev->netdev_ops, pOverride->pOrgOps);
    942937            ASMAtomicWriteU32(&pOverride->u32Magic, 0);
    943938        }
    … …  
    990985    return pDev;
    991986#else
    992     return (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     987    return ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    993988#endif
    994989}
    … …  
    10601055     * Allocate a packet and copy over the data.
    10611056     */
    1062     pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     1057    pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    10631058    pPkt = dev_alloc_skb(pSG->cbTotal + NET_IP_ALIGN);
    10641059    if (RT_UNLIKELY(!pPkt))
    … …  
    12821277
    12831278    pThis = VBOX_FLT_PT_TO_INST(pPacketType);
    1284     pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     1279    pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    12851280    if (pThis->u.s.pDev != pSkbDev)
    12861281    {
    … …  
    18201815
    18211816        pSwitchPort = pThis->pSwitchPort; /* this doesn't need to be here, but it doesn't harm. */
    1822         pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     1817        pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    18231818        if (pDev)
    18241819            fFeatures = pDev->features;
    … …  
    18871882
    18881883    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    1889     ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, pDev);
     1884    ASMAtomicUoWritePtr(&pThis->u.s.pDev, pDev);
    18901885    RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);
    18911886
    18921887    Log(("vboxNetFltLinuxAttachToInterface: Device %p(%s) retained. ref=%d\n", pDev, pDev->name, atomic_read(&pDev->refcnt)));
    1893     Log(("vboxNetFltLinuxAttachToInterface: Got pDev=%p pThis=%p pThis->u.s.pDev=%p\n", pDev, pThis, ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev)));
     1888    Log(("vboxNetFltLinuxAttachToInterface: Got pDev=%p pThis=%p pThis->u.s.pDev=%p\n", pDev, pThis, ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *)));
    18941889
    18951890    /* Get the mac address while we still have a valid net_device reference. */
    … …  
    19161911     */
    19171912    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    1918     pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     1913    pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    19191914    if (pDev)
    19201915    {
    … …  
    19511946#endif /* VBOXNETFLT_WITH_QDISC */
    19521947        RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    1953         ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, NULL);
     1948        ASMAtomicUoWritePtr(&pThis->u.s.pDev, NULL);
    19541949        RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);
    19551950        dev_put(pDev);
    … …  
    19781973    ASMAtomicWriteBool(&pThis->u.s.fRegistered, false);
    19791974    ASMAtomicWriteBool(&pThis->fDisconnectedFromHost, true);
    1980     ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pDev, NULL);
     1975    ASMAtomicUoWritePtr(&pThis->u.s.pDev, NULL);
    19811976    RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);
    19821977
    … …  
    20682063
    20692064    Log(("VBoxNetFlt: got event %s(0x%lx) on %s, pDev=%p pThis=%p pThis->u.s.pDev=%p\n",
    2070          vboxNetFltLinuxGetNetDevEventName(ulEventType), ulEventType, pDev->name, pDev, pThis, ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev)));
     2065         vboxNetFltLinuxGetNetDevEventName(ulEventType), ulEventType, pDev->name, pDev, pThis, ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *)));
    20712066    if (    ulEventType == NETDEV_REGISTER
    20722067        && !strcmp(pDev->name, pThis->szName))
    … …  
    20762071    else
    20772072    {
    2078         pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     2073        pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    20792074        if (pDev == ptr)
    20802075        {
    … …  
    21112106int  vboxNetFltPortOsXmit(PVBOXNETFLTINS pThis, void *pvIfData, PINTNETSG pSG, uint32_t fDst)
    21122107{
    2113     NOREF(pvIfData);
    2114 
    21152108    struct net_device * pDev;
    21162109    int err;
    21172110    int rc = VINF_SUCCESS;
     2111    NOREF(pvIfData);
    21182112
    21192113    LogFlow(("vboxNetFltPortOsXmit: pThis=%p (%s)\n", pThis, pThis->szName));
    … …  
    22742268
    22752269    RTSpinlockAcquireNoInts(pThis->hSpinlock, &Tmp);
    2276     pDev = (struct net_device *)ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pDev);
     2270    pDev = ASMAtomicUoReadPtrT(&pThis->u.s.pDev, struct net_device *);
    22772271    fRegistered = ASMAtomicUoReadBool(&pThis->u.s.fRegistered);
    22782272    RTSpinlockReleaseNoInts(pThis->hSpinlock, &Tmp);

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/solaris/VBoxNetFlt-solaris.c

    r29662 r30111  
    777777     * the one that we will associate this stream with.
    778778     */
    779     ASMAtomicUoWritePtr((void * volatile *)&pStream->pThis, pThis);
     779    ASMAtomicUoWritePtr(&pStream->pThis, pThis);
    780780    pStream->Type = g_VBoxNetFltSolarisStreamType;
    781781    switch (pStream->Type)
    782782    {
    783         case kIp4Stream:        ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pvIp4Stream, pStream);        break;
    784         case kIp6Stream:        ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pvIp6Stream, pStream);        break;
    785         case kArpStream:        ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pvArpStream, pStream);        break;
    786         case kPromiscStream:    ASMAtomicUoWritePtr((void * volatile *)&pThis->u.s.pvPromiscStream, pStream);    break;
     783        case kIp4Stream:        ASMAtomicUoWritePtr(&pThis->u.s.pvIp4Stream, pStream);        break;
     784        case kIp6Stream:        ASMAtomicUoWritePtr(&pThis->u.s.pvIp6Stream, pStream);        break;
     785        case kArpStream:        ASMAtomicUoWritePtr(&pThis->u.s.pvArpStream, pStream);        break;
     786        case kPromiscStream:    ASMAtomicUoWritePtr(&pThis->u.s.pvPromiscStream, pStream);    break;
    787787        default:    /* Heh. */
    788788        {
    … …  
    924924            RTTimerStop(pPromiscStream->pIp6Timer);
    925925            RTTimerDestroy(pPromiscStream->pIp6Timer);
    926             ASMAtomicUoWritePtr((void * volatile *)&pPromiscStream->pIp6Timer, NULL);
     926            ASMAtomicUoWritePtr(&pPromiscStream->pIp6Timer, NULL);
    927927        }
    928928#endif
    … …  
    999999    {
    10001000        fSendUpstream = false;
    1001         pThis = ASMAtomicUoReadPtr((void * volatile *)&pStream->pThis);
     1001        pThis = ASMAtomicUoReadPtrT(&pStream->pThis, PVBOXNETFLTINS);
    10021002        if (RT_LIKELY(pThis))
    10031003        {
    … …  
    24762476        && RT_LIKELY(pTimer))
    24772477    {
    2478         vboxnetflt_stream_t *pIp6Stream  = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvIp6Stream);
     2478        vboxnetflt_stream_t *pIp6Stream  = ASMAtomicUoReadPtrT(pThis->u.s.pvIp6Stream, vboxnetflt_stream_t *);
    24792479        bool fIp6Attaching = ASMAtomicUoReadBool(&pThis->u.s.fAttaching);
    24802480        if (   !pIp6Stream
    … …  
    25122512
    25132513    int rc = VERR_GENERAL_FAILURE;
    2514     vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
     2514    vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtrT(&pThis->u.s.pvPromiscStream, vboxnetflt_promisc_stream_t *);
    25152515    if (RT_LIKELY(pPromiscStream))
    25162516    {
    … …  
    25722572
    25732573#ifdef VBOXNETFLT_SOLARIS_IPV6_POLLING
    2574     vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
     2574    vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtrT(&pThis->u.s.pvPromiscStream, vboxnetflt_promisc_stream_t *);
    25752575    if (   pPromiscStream
    25762576        && pPromiscStream->pIp6Timer == NULL)
    … …  
    25782578        RTTimerStop(pPromiscStream->pIp6Timer);
    25792579        RTTimerDestroy(pPromiscStream->pIp6Timer);
    2580         ASMAtomicUoWritePtr((void * volatile *)&pPromiscStream->pIp6Timer, NULL);
     2580        ASMAtomicUoWritePtr(&pPromiscStream->pIp6Timer, NULL);
    25812581    }
    25822582#endif
    … …  
    31983198    Assert(pStream->Type == kPromiscStream);
    31993199
    3200     vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
     3200    vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtrT(&pThis->u.s.pvPromiscStream, vboxnetflt_promisc_stream_t *);
    32013201    if (RT_UNLIKELY(!pPromiscStream))
    32023202    {
    … …  
    35793579     * Enable/disable promiscuous mode.
    35803580     */
    3581     vboxnetflt_stream_t *pStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
     3581    vboxnetflt_stream_t *pStream = ASMAtomicUoReadPtrT(&pThis->u.s.pvPromiscStream, vboxnetflt_stream_t *);
    35823582    if (pStream)
    35833583    {
    … …  
    38043804        }
    38053805#else
    3806         vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
     3806        vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtrT(&pThis->u.s.pvPromiscStream, vboxnetflt_promisc_stream_t *);
    38073807        if (RT_LIKELY(pPromiscStream))
    38083808        {
    … …  
    38303830         * We either bind to both or neither; so atomic reading one should be sufficient.
    38313831         */
    3832         vboxnetflt_stream_t *pIp4Stream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvIp4Stream);
     3832        vboxnetflt_stream_t *pIp4Stream = ASMAtomicUoReadPtrT(&pThis->u.s.pvIp4Stream, vboxnetflt_stream_t *);
    38333833        if (!pIp4Stream)
    38343834            return rc;
    … …  
    38493849                LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_HOST ARP\n"));
    38503850
    3851                 vboxnetflt_stream_t *pArpStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvArpStream);
     3851                vboxnetflt_stream_t *pArpStream = ASMAtomicUoReadPtrT(&pThis->u.s.pvArpStream, vboxnetflt_stream_t *);
    38523852                if (pArpStream)
    38533853                {
    … …  
    38763876            else
    38773877            {
    3878                  vboxnetflt_stream_t *pIp6Stream  = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvIp6Stream);
     3878                 vboxnetflt_stream_t *pIp6Stream  = ASMAtomicUoReadPtrT(&pThis->u.s.pvIp6Stream, vboxnetflt_stream_t *);
    38793879                 if (   pEthHdr->EtherType == RT_H2BE_U16(RTNET_ETHERTYPE_IPV6)
    38803880                     && pIp6Stream)

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/win/VBoxNetFlt-win.h

    r29643 r30111  
    202202
    203203/** assignes the packet to the packet info */
    204 #define SET_PACKET_TO_INFO(_pPacketInfo, _pPacket) (ASMAtomicUoWritePtr((void * volatile *)&(_pPacketInfo)->pPacket, (_pPacket)))
     204#define SET_PACKET_TO_INFO(_pPacketInfo, _pPacket) (ASMAtomicUoWritePtr(&(_pPacketInfo)->pPacket, (_pPacket)))
    205205
    206206/** returns the flags the packet info contains */

  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r29971 r30111  
    80888088        if (RT_FAILURE(rc))
    80898089            pLed = NULL;
    8090         ASMAtomicXchgPtr((void * volatile *)&pData->papLeds[iLUN - pData->iFirstLUN], pLed);
     8090        ASMAtomicWritePtr(&pData->papLeds[iLUN - pData->iFirstLUN], pLed);
    80918091        Log(("drvStatus_UnitChanged: iLUN=%d pLed=%p\n", iLUN, pLed));
    80928092    }
    … …  
    81238123        unsigned iLed = pData->iLastLUN - pData->iFirstLUN + 1;
    81248124        while (iLed-- > 0)
    8125             ASMAtomicXchgPtr((void * volatile *)&pData->papLeds[iLed], NULL);
     8125            ASMAtomicWritePtr(&pData->papLeds[iLed], NULL);
    81268126    }
    81278127}

  • trunk/src/VBox/Main/VirtualBoxBase.cpp

    r28800 r30111  
    9191        // one of the locking classes listed at the top of AutoLock.h
    9292        RWLockHandle *objLock = new RWLockHandle(getLockingClass());
    93         if (!ASMAtomicCmpXchgPtr ((void * volatile *) &mObjectLock, objLock, NULL))
     93        if (!ASMAtomicCmpXchgPtr(&mObjectLock, objLock, NULL))
    9494        {
    9595            delete objLock;
    96             objLock = (RWLockHandle *) ASMAtomicReadPtr ((void * volatile *) &mObjectLock);
     96            objLock = ASMAtomicReadPtrT(&mObjectLock, RWLockHandle *);
    9797        }
    9898        return objLock;

  • trunk/src/VBox/Runtime/common/alloc/memcache.cpp

    r28800 r30111  
    308308
    309309            /* Make it the hint. */
    310             ASMAtomicWritePtr((void * volatile *)&pThis->pPageHint, pPage);
     310            ASMAtomicWritePtr(&pThis->pPageHint, pPage);
    311311
    312312            /* Link the page. */
    313313            PRTMEMCACHEPAGE pPrevPage = pThis->pPageHead;
    314314            if (!pPrevPage)
    315                 ASMAtomicWritePtr((void * volatile *)&pThis->pPageHead, pPage);
     315                ASMAtomicWritePtr(&pThis->pPageHead, pPage);
    316316            else
    317317            {
    318318                while (pPrevPage->pNext)
    319319                    pPrevPage = pPrevPage->pNext;
    320                 ASMAtomicWritePtr((void * volatile *)&pPrevPage->pNext, pPage);
     320                ASMAtomicWritePtr(&pPrevPage->pNext, pPage);
    321321            }
    322322
    … …  
    359359     * Try grab a free object from the stack.
    360360     */
    361     PRTMEMCACHEFREEOBJ pObj = (PRTMEMCACHEFREEOBJ)ASMAtomicUoReadPtr((void * volatile *)&pThis->pFreeTop);
     361    PRTMEMCACHEFREEOBJ pObj = ASMAtomicUoReadPtrT(&pThis->pFreeTop, PRTMEMCACHEFREEOBJ);
    362362    if (pObj)
    363363    {
    … …  
    365365        do
    366366        {
    367             pNext = (PRTMEMCACHEFREEOBJ)ASMAtomicUoReadPtr((void * volatile *)&pObj->pNext);
    368             if (ASMAtomicCmpXchgPtr((void * volatile *)&pThis->pFreeTop, pNext, pObj))
     367            pNext = ASMAtomicUoReadPtrT(&pObj->pNext, PRTMEMCACHEFREEOBJ);
     368            if (ASMAtomicCmpXchgPtr(&pThis->pFreeTop, pNext, pObj))
    369369            {
    370370                *ppvObj = pObj;
    371371                return VINF_SUCCESS;
    372372            }
    373             pObj = (PRTMEMCACHEFREEOBJ)ASMAtomicUoReadPtr((void * volatile *)&pThis->pFreeTop);
     373            pObj = ASMAtomicUoReadPtrT(&pThis->pFreeTop, PRTMEMCACHEFREEOBJ);
    374374        } while (pObj);
    375375    }
    … …  
    400400     * Grab a free object at the page level.
    401401     */
    402     PRTMEMCACHEPAGE pPage = (PRTMEMCACHEPAGE)ASMAtomicReadPtr((void * volatile *)&pThis->pPageHint);
     402    PRTMEMCACHEPAGE pPage = ASMAtomicReadPtrT(&pThis->pPageHint, PRTMEMCACHEPAGE);
    403403    int32_t iObj = pPage ? rtMemCacheGrabObj(pPage) : -1;
    404404    if (iObj < 0)
    … …  
    412412                {
    413413                    if (iObj > 0)
    414                         ASMAtomicWritePtr((void * volatile *)&pThis->pPageHint, pPage);
     414                        ASMAtomicWritePtr(&pThis->pPageHint, pPage);
    415415                    break;
    416416                }
    … …  
    511511        do
    512512        {
    513             pNext = (PRTMEMCACHEFREEOBJ)ASMAtomicUoReadPtr((void * volatile *)&pThis->pFreeTop);
     513            pNext = ASMAtomicUoReadPtrT(&pThis->pFreeTop, PRTMEMCACHEFREEOBJ);
    514514            pObj->pNext = pNext;
    515         } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pThis->pFreeTop, pObj, pNext));
     515        } while (!ASMAtomicCmpXchgPtr(&pThis->pFreeTop, pObj, pNext));
    516516    }
    517517    else

  • trunk/src/VBox/Runtime/common/log/log.cpp

    r29263 r30111  
    18261826RTDECL(PRTLOGGER) RTLogSetDefaultInstance(PRTLOGGER pLogger)
    18271827{
    1828     return (PRTLOGGER)ASMAtomicXchgPtr((void * volatile *)&g_pLogger, pLogger);
     1828    return ASMAtomicXchgPtrT(&g_pLogger, pLogger, PRTLOGGER);
    18291829}
    18301830RT_EXPORT_SYMBOL(RTLogSetDefaultInstance);
    … …  
    18611861            if (g_aPerThreadLoggers[i].NativeThread == Self)
    18621862            {
    1863                 ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)uKey);
     1863                ASMAtomicWritePtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)uKey);
    18641864                g_aPerThreadLoggers[i].pLogger = pLogger;
    18651865                return VINF_SUCCESS;
    … …  
    18851885                    &&  ASMAtomicCmpXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].NativeThread, (void *)Self, (void *)NIL_RTNATIVETHREAD))
    18861886                {
    1887                     ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)uKey);
    1888                     ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].pLogger, pLogger);
     1887                    ASMAtomicWritePtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)uKey);
     1888                    ASMAtomicWritePtr(&g_aPerThreadLoggers[i].pLogger, pLogger);
    18891889                    return VINF_SUCCESS;
    18901890                }
    … …  
    19051905                ||  g_aPerThreadLoggers[i].uKey == uKey)
    19061906            {
    1907                 ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, NULL);
    1908                 ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].pLogger, NULL);
    1909                 ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].NativeThread, (void *)NIL_RTNATIVETHREAD);
     1907                ASMAtomicWritePtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, (void *)NULL);
     1908                ASMAtomicWritePtr(&g_aPerThreadLoggers[i].pLogger, (PRTLOGGER)NULL);
     1909                ASMAtomicWriteHandle(&g_aPerThreadLoggers[i].NativeThread, NIL_RTNATIVETHREAD);
    19101910                ASMAtomicDecS32(&g_cPerThreadLoggers);
    19111911            }

  • trunk/src/VBox/Runtime/common/log/logrel.cpp

    r28800 r30111  
    9696RTDECL(PRTLOGGER) RTLogRelSetDefaultInstance(PRTLOGGER pLogger)
    9797{
    98     return (PRTLOGGER)ASMAtomicXchgPtr((void * volatile *)&g_pRelLogger, pLogger);
     98    return ASMAtomicXchgPtrT(&g_pRelLogger, pLogger, PRTLOGGER);
    9999}
    100100RT_EXPORT_SYMBOL(RTLogRelSetDefaultInstance);

  • trunk/src/VBox/Runtime/common/misc/assert.cpp

    r28800 r30111  
    107107     * Fill in the globals.
    108108     */
    109     ASMAtomicUoWritePtr((void * volatile *)&g_pszRTAssertExpr, (void *)pszExpr);
    110     ASMAtomicUoWritePtr((void * volatile *)&g_pszRTAssertFile, (void *)pszFile);
    111     ASMAtomicUoWritePtr((void * volatile *)&g_pszRTAssertFunction, (void *)pszFunction);
     109    ASMAtomicUoWritePtr(&g_pszRTAssertExpr, pszExpr);
     110    ASMAtomicUoWritePtr(&g_pszRTAssertFile, pszFile);
     111    ASMAtomicUoWritePtr(&g_pszRTAssertFunction, pszFunction);
    112112    ASMAtomicUoWriteU32(&g_u32RTAssertLine, uLine);
    113113    RTStrPrintf(g_szRTAssertMsg1, sizeof(g_szRTAssertMsg1),

  • trunk/src/VBox/Runtime/common/misc/lockvalidator.cpp

    r28800 r30111  
    341341DECL_FORCE_INLINE(PRTLOCKVALRECUNION) rtLockValidatorReadRecUnionPtr(PRTLOCKVALRECUNION volatile *ppRec)
    342342{
    343     PRTLOCKVALRECUNION p = (PRTLOCKVALRECUNION)ASMAtomicReadPtr((void * volatile *)ppRec);
     343    PRTLOCKVALRECUNION p = ASMAtomicReadPtrT(ppRec, PRTLOCKVALRECUNION);
    344344    RTLOCKVAL_ASSERT_PTR_ALIGN(p);
    345345    return p;
    … …  
    351351{
    352352    RTLOCKVAL_ASSERT_PTR_ALIGN(pRecNew);
    353     ASMAtomicWritePtr((void * volatile *)ppRec, pRecNew);
     353    ASMAtomicWritePtr(ppRec, pRecNew);
    354354}
    355355
    … …  
    358358DECL_FORCE_INLINE(PRTTHREADINT) rtLockValidatorReadThreadHandle(RTTHREAD volatile *phThread)
    359359{
    360     PRTTHREADINT p = (PRTTHREADINT)ASMAtomicReadPtr((void * volatile *)phThread);
     360    PRTTHREADINT p = ASMAtomicReadPtrT(phThread, PRTTHREADINT);
    361361    RTLOCKVAL_ASSERT_PTR_ALIGN(p);
    362362    return p;
    … …  
    367367DECL_FORCE_INLINE(PRTLOCKVALRECSHRDOWN) rtLockValidatorUoReadSharedOwner(PRTLOCKVALRECSHRDOWN volatile *ppOwner)
    368368{
    369     PRTLOCKVALRECSHRDOWN p = (PRTLOCKVALRECSHRDOWN)ASMAtomicUoReadPtr((void * volatile *)ppOwner);
     369    PRTLOCKVALRECSHRDOWN p = ASMAtomicUoReadPtrT(ppOwner, PRTLOCKVALRECSHRDOWN);
    370370    RTLOCKVAL_ASSERT_PTR_ALIGN(p);
    371371    return p;
    … …  
    819819    if (pSrc)
    820820    {
    821         ASMAtomicUoWriteU32(&pDst->uLine,                           pSrc->uLine);
    822         ASMAtomicUoWritePtr((void * volatile *)&pDst->pszFile,      pSrc->pszFile);
    823         ASMAtomicUoWritePtr((void * volatile *)&pDst->pszFunction,  pSrc->pszFunction);
    824         ASMAtomicUoWritePtr((void * volatile *)&pDst->uId,          (void *)pSrc->uId);
     821        ASMAtomicUoWriteU32(&pDst->uLine,        pSrc->uLine);
     822        ASMAtomicUoWritePtr(&pDst->pszFile,      pSrc->pszFile);
     823        ASMAtomicUoWritePtr(&pDst->pszFunction,  pSrc->pszFunction);
     824        ASMAtomicUoWritePtr((void * volatile *)&pDst->uId, (void *)pSrc->uId);
    825825    }
    826826    else
    827827    {
    828         ASMAtomicUoWriteU32(&pDst->uLine,                           0);
    829         ASMAtomicUoWritePtr((void * volatile *)&pDst->pszFile,      NULL);
    830         ASMAtomicUoWritePtr((void * volatile *)&pDst->pszFunction,  NULL);
    831         ASMAtomicUoWritePtr((void * volatile *)&pDst->uId,          0);
     828        ASMAtomicUoWriteU32(&pDst->uLine,        0);
     829        ASMAtomicUoWritePtr(&pDst->pszFile,      NULL);
     830        ASMAtomicUoWritePtr(&pDst->pszFunction,  NULL);
     831        ASMAtomicUoWritePtr(&pDst->uId, (RTHCUINTPTR)0);
    832832    }
    833833}
    … …  
    13591359                if (    !(*ppHashEntry)
    13601360                    ||  (*ppHashEntry)->cLookups + 128 < cLookups)
    1361                     ASMAtomicWritePtr((void * volatile *)ppHashEntry, &pChunk->aRefs[i]);
     1361                    ASMAtomicWritePtr(ppHashEntry, &pChunk->aRefs[i]);
    13621362
    13631363#ifdef RTLOCKVAL_WITH_CLASS_HASH_STATS
    … …  
    14691469                    pNew->aRefs[0].fAutodidacticism = fAutodidacticism;
    14701470
    1471                     ASMAtomicWritePtr((void * volatile *)&pChunk->pNext, pNew);
     1471                    ASMAtomicWritePtr(&pChunk->pNext, pNew);
    14721472                    rtLockValidatorClassRetain(pPriorClass);
    14731473                    rc = VINF_SUCCESS;
    … …  
    15471547        if (RT_UNLIKELY(ppCoreNext))
    15481548            break;
    1549         pSibling = (PRTLOCKVALRECUNION)ASMAtomicXchgPtr((void * volatile *)ppCoreNext, NULL);
     1549        pSibling = ASMAtomicXchgPtrT(ppCoreNext, NULL, PRTLOCKVALRECUNION);
    15501550    }
    15511551}
    … …  
    34723472    {
    34733473        PRTLOCKVALRECSHRDOWN volatile *papOwners = pRec->papOwners;
    3474         ASMAtomicUoWritePtr((void * volatile *)&pRec->papOwners, NULL);
     3474        ASMAtomicUoWritePtr(&pRec->papOwners, NULL);
    34753475        ASMAtomicUoWriteU32(&pRec->cAllocated, 0);
    34763476
    … …  
    38153815                }
    38163816
    3817                 ASMAtomicWritePtr((void * volatile *)&pShared->papOwners, papOwners);
     3817                ASMAtomicWritePtr(&pShared->papOwners, papOwners);
    38183818                ASMAtomicWriteU32(&pShared->cAllocated, cAllocated);
    38193819            }
    … …  
    38583858            for (uint32_t iEntry = 0; iEntry < cMax; iEntry++)
    38593859            {
    3860                 if (ASMAtomicCmpXchgPtr((void * volatile *)&papOwners[iEntry], pEntry, NULL))
     3860                if (ASMAtomicCmpXchgPtr(&papOwners[iEntry], pEntry, NULL))
    38613861                {
    38623862                    rtLockValidatorSerializeDetectionLeave();
    … …  
    38893889    AssertReturnVoidStmt(pShared->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, rtLockValidatorSerializeDetectionLeave());
    38903890    if (RT_UNLIKELY(   iEntry >= pShared->cAllocated
    3891                     || !ASMAtomicCmpXchgPtr((void * volatile *)&pShared->papOwners[iEntry], NULL, pEntry)))
     3891                    || !ASMAtomicCmpXchgPtr(&pShared->papOwners[iEntry], NULL, pEntry)))
    38923892    {
    38933893        /* this shouldn't happen yet... */
    … …  
    38963896        uint32_t const                  cMax      = pShared->cAllocated;
    38973897        for (iEntry = 0; iEntry < cMax; iEntry++)
    3898             if (ASMAtomicCmpXchgPtr((void * volatile *)&papOwners[iEntry], NULL, pEntry))
     3898            if (ASMAtomicCmpXchgPtr(&papOwners[iEntry], NULL, pEntry))
    38993899               break;
    39003900        AssertReturnVoidStmt(iEntry < cMax, rtLockValidatorSerializeDetectionLeave());
    … …  
    39313931        while (iEntry < cEntries)
    39323932        {
    3933             PRTLOCKVALRECSHRDOWN pEntry = (PRTLOCKVALRECSHRDOWN)ASMAtomicXchgPtr((void * volatile *)&papEntries[iEntry], NULL);
     3933            PRTLOCKVALRECSHRDOWN pEntry = ASMAtomicXchgPtrT(&papEntries[iEntry], NULL, PRTLOCKVALRECSHRDOWN);
    39343934            if (pEntry)
    39353935            {

  • trunk/src/VBox/Runtime/common/misc/req.cpp

    r28800 r30111  
    129129         * Get pending requests.
    130130         */
    131         PRTREQ pReqs = (PRTREQ)ASMAtomicXchgPtr((void * volatile *)&pQueue->pReqs, NULL);
     131        PRTREQ pReqs = ASMAtomicXchgPtrT(&pQueue->pReqs, NULL, PRTREQ);
    132132        if (!pReqs)
    133133        {
    … …  
    393393    for (unsigned cIterations = 0;; cIterations++)
    394394    {
    395         PRTREQ pHead = (PRTREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, pList);
     395        PRTREQ pHead = ASMAtomicXchgPtrT(ppHead, pList, PRTREQ);
    396396        if (!pHead)
    397397            return;
    … …  
    400400            pTail = pTail->pNext;
    401401        pTail->pNext = pList;
    402         if (ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (void *)pHead, pList))
     402        if (ASMAtomicCmpXchgPtr(ppHead, pHead, pList))
    403403            return;
    404404        pTail->pNext = NULL;
    405         if (ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (void *)pHead, NULL))
     405        if (ASMAtomicCmpXchgPtr(ppHead, pHead, NULL))
    406406            return;
    407407        pList = pHead;
    … …  
    478478        PRTREQ pReq = *ppHead;
    479479        if (    pReq
    480             &&  !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq)
     480            &&  !ASMAtomicCmpXchgPtr(ppHead, (pNext = pReq->pNext), pReq)
    481481            &&  (pReq = *ppHead)
    482             &&  !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq))
     482            &&  !ASMAtomicCmpXchgPtr(ppHead, (pNext = pReq->pNext), pReq))
    483483            pReq = NULL;
    484484        if (pReq)
    … …  
    486486            Assert(pReq->pNext == pNext); NOREF(pReq);
    487487#else
    488         PRTREQ pReq = (PRTREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, NULL);
     488        PRTREQ pReq = ASMAtomicXchgPtrT(ppHead, NULL, PRTREQ);
    489489        if (pReq)
    490490        {
    491491            PRTREQ pNext = pReq->pNext;
    492492            if (    pNext
    493                 &&  !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, pNext, NULL))
     493                &&  !ASMAtomicCmpXchgPtr(ppHead, pNext, NULL))
    494494            {
    495495                vmr3ReqJoinFree(pQueue, pReq->pNext);
    … …  
    621621        {
    622622            pNext = *ppHead;
    623             ASMAtomicXchgPtr((void * volatile *)&pReq->pNext, pNext);
    624         } while (!ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (void *)pReq, (void *)pNext));
     623            ASMAtomicWritePtr(&pReq->pNext, pNext);
     624        } while (!ASMAtomicCmpXchgPtr(ppHead, pReq, pNext));
    625625    }
    626626    else
    … …  
    691691        pReq->pNext = pNext;
    692692        ASMAtomicWriteBool(&pQueue->fBusy, true);
    693     } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pQueue->pReqs, (void *)pReq, (void *)pNext));
     693    } while (!ASMAtomicCmpXchgPtr(&pQueue->pReqs, pReq, pNext));
    694694
    695695    /*
    … …  
    931931    if (ASMAtomicReadBool(&pQueue->fBusy))
    932932        return true;
    933     if (ASMAtomicReadPtr((void * volatile *)&pQueue->pReqs) != NULL)
     933    if (ASMAtomicReadPtrT(&pQueue->pReqs, PRTREQ) != NULL)
    934934        return true;
    935935    if (ASMAtomicReadBool(&pQueue->fBusy))

  • trunk/src/VBox/Runtime/common/misc/thread.cpp

    r28903 r30111  
    13491349            if (   pThread->LockValidator.pRec
    13501350                && pThread->LockValidator.enmRecState == enmCurState)
    1351                 ASMAtomicWritePtr((void * volatile *)&pThread->LockValidator.pRec, NULL);
     1351                ASMAtomicWritePtr(&pThread->LockValidator.pRec, NULL);
    13521352        }
    13531353        /* This is a bit ugly... :-/ */
    … …  
    13551355                     || enmActualState == RTTHREADSTATE_INITIALIZING)
    13561356                 && pThread->LockValidator.pRec)
    1357             ASMAtomicWritePtr((void * volatile *)&pThread->LockValidator.pRec, NULL);
     1357            ASMAtomicWritePtr(&pThread->LockValidator.pRec, NULL);
    13581358        Assert(   pThread->LockValidator.pRec == NULL
    13591359               || RTTHREAD_IS_SLEEPING(enmActualState));

  • trunk/src/VBox/Runtime/generic/tls-generic.cpp

    r28800 r30111  
    8989        return VERR_INVALID_PARAMETER;
    9090
    91     ASMAtomicWritePtr((void * volatile *)&g_apfnDestructors[iTls], NULL);
     91    ASMAtomicWritePtr(&g_apfnDestructors[iTls], NULL);
    9292    rtThreadClearTlsEntry(iTls);
    9393    ASMAtomicBitClear(&g_au32AllocatedBitmap[0], iTls);

  • trunk/src/VBox/Runtime/r3/darwin/sched-darwin.cpp

    r28800 r30111  
    270270        }
    271271    Assert(pProcessPriority != &g_aDefaultPriority);
    272     ASMAtomicUoWritePtr((void **)&g_pProcessPriority, pProcessPriority);
     272    ASMAtomicUoWritePtr(&g_pProcessPriority, pProcessPriority);
    273273
    274274    return VINF_SUCCESS;

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

    r29477 r30111  
    198198        for (unsigned iSlot = 0; iSlot < RT_ELEMENTS(pCtxInt->apReqsNewHead); iSlot++)
    199199        {
    200             PRTFILEAIOREQINTERNAL pReqHead = (PRTFILEAIOREQINTERNAL)ASMAtomicXchgPtr((void* volatile*)&pCtxInt->apReqsNewHead[iSlot],
    201                                                                                      NULL);
     200            PRTFILEAIOREQINTERNAL pReqHead = ASMAtomicXchgPtrT(&pCtxInt->apReqsNewHead[iSlot], NULL, PRTFILEAIOREQINTERNAL);
    202201
    203202            while (  (pCtxInt->iFirstFree < pCtxInt->cReqsWaitMax)
    … …  
    249248
    250249        /* Check if a request needs to be canceled. */
    251         PRTFILEAIOREQINTERNAL pReqToCancel = (PRTFILEAIOREQINTERNAL)ASMAtomicReadPtr((void* volatile*)&pCtxInt->pReqToCancel);
     250        PRTFILEAIOREQINTERNAL pReqToCancel = ASMAtomicReadPtrT(&pCtxInt->pReqToCancel, PRTFILEAIOREQINTERNAL);
    252251        if (pReqToCancel)
    253252        {
    … …  
    487486
    488487        Assert(!pCtxInt->pReqToCancel);
    489         ASMAtomicWritePtr((void* volatile*)&pCtxInt->pReqToCancel, pReqInt);
     488        ASMAtomicWritePtr(&pCtxInt->pReqToCancel, pReqInt);
    490489        rtFileAioCtxWakeup(pCtxInt);
    491490
    … …  
    494493        AssertRC(rc);
    495494
    496         ASMAtomicWritePtr((void* volatile*)&pCtxInt->pReqToCancel, NULL);
     495        ASMAtomicWritePtr(&pCtxInt->pReqToCancel, NULL);
    497496        pReqInt->Rc = VERR_FILE_AIO_CANCELED;
    498497        RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
    … …  
    819818        unsigned iSlot = 0;
    820819        while (  (iSlot < RT_ELEMENTS(pCtxInt->apReqsNewHead))
    821                && !ASMAtomicCmpXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[iSlot], pHead, NULL))
     820               && !ASMAtomicCmpXchgPtr(&pCtxInt->apReqsNewHead[iSlot], pHead, NULL))
    822821            iSlot++;
    823822
    … …  
    825824        {
    826825            /* Nothing found. */
    827             PRTFILEAIOREQINTERNAL pOldHead = (PRTFILEAIOREQINTERNAL)ASMAtomicXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[0],
    828                                                                                       NULL);
     826            PRTFILEAIOREQINTERNAL pOldHead = ASMAtomicXchgPtrT(&pCtxInt->apReqsNewHead[0], NULL, PRTFILEAIOREQINTERNAL);
    829827
    830828            /* Find the end of the current head and link the old list to the current. */
    … …  
    835833            pTail->pNext = pOldHead;
    836834
    837             ASMAtomicXchgPtr((void * volatile *)&pCtxInt->apReqsNewHead[0], pHead);
     835            ASMAtomicWritePtr(&pCtxInt->apReqsNewHead[0], pHead);
    838836        }
    839837

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

    r28800 r30111  
    5252/** @todo move this to r3/posix/something.h. */
    5353#ifdef RT_OS_SOLARIS
    54 # define ATOMIC_GET_PTHREAD_T(pvVar, pThread) ASMAtomicReadSize(pvVar, pThread)
    55 # define ATOMIC_SET_PTHREAD_T(pvVar, pThread) ASMAtomicWriteSize(pvVar, pThread)
     54# define ATOMIC_GET_PTHREAD_T(ppvVar, pThread) ASMAtomicReadSize(ppvVar, pThread)
     55# define ATOMIC_SET_PTHREAD_T(ppvVar, pThread) ASMAtomicWriteSize(ppvVar, pThread)
    5656#else
    5757AssertCompileSize(pthread_t, sizeof(void *));
    58 # define ATOMIC_GET_PTHREAD_T(pvVar, pThread) do { *(pThread) = (pthread_t)ASMAtomicReadPtr((void *volatile *)pvVar); } while (0)
    59 # define ATOMIC_SET_PTHREAD_T(pvVar, pThread) ASMAtomicWritePtr((void *volatile *)pvVar, (void *)pThread)
     58# define ATOMIC_GET_PTHREAD_T(ppvVar, pThread) do { *(pThread) = (pthread_t)ASMAtomicReadPtr((void * volatile *)ppvVar); } while (0)
     59# define ATOMIC_SET_PTHREAD_T(ppvVar, pThread) ASMAtomicWritePtr((void * volatile *)ppvVar, (void *)pThread)
    6060#endif
    6161

  • trunk/src/VBox/Runtime/r3/stream.cpp

    r28800 r30111  
    143143        if (RT_SUCCESS(rc))
    144144        {
    145             if (RT_LIKELY(ASMAtomicCmpXchgPtr((void * volatile *)&pStream->pCritSect, pCritSect, NULL)))
     145            if (RT_LIKELY(ASMAtomicCmpXchgPtr(&pStream->pCritSect, pCritSect, NULL)))
    146146                return VINF_SUCCESS;
    147147
    … …  
    153153
    154154    /* Handle the lost race case... */
    155     pCritSect = (PRTCRITSECT)ASMAtomicReadPtr((void * volatile *)&pStream->pCritSect);
     155    pCritSect = ASMAtomicReadPtrT(&pStream->pCritSect, PRTCRITSECT);
    156156    if (pCritSect)
    157157        return RTCritSectEnter(pCritSect);

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

    r28800 r30111  
    138138    AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSEMMUTEX_MAGIC_DEAD, RTSEMMUTEX_MAGIC), VERR_INVALID_HANDLE);
    139139    HANDLE hMtx = pThis->hMtx;
    140     ASMAtomicWritePtr((void * volatile *)&pThis->hMtx, (void *)INVALID_HANDLE_VALUE);
     140    ASMAtomicWritePtr(&pThis->hMtx, INVALID_HANDLE_VALUE);
    141141
    142142    int rc = VINF_SUCCESS;

  • trunk/src/VBox/VMM/PDMAsyncCompletionFile.cpp

    r29587 r30111  
    120120     * Get pending tasks.
    121121     */
    122     pTasks = (PPDMACTASKFILE)ASMAtomicXchgPtr((void * volatile *)&pEndpoint->pTasksNewHead, NULL);
     122    pTasks = ASMAtomicXchgPtrT(&pEndpoint->pTasksNewHead, NULL, PPDMACTASKFILE);
    123123
    124124    /* Reverse the list to process in FIFO order. */
    … …  
    185185    AssertRCReturn(rc, rc);
    186186
    187     ASMAtomicWritePtr((void * volatile *)&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint, pEndpoint);
     187    ASMAtomicWritePtr(&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint, pEndpoint);
    188188    rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT);
    189189
    … …  
    191191
    192192    if (RT_SUCCESS(rc))
    193         ASMAtomicWritePtr((void * volatile *)&pEndpoint->pAioMgr, pAioMgr);
     193        ASMAtomicWritePtr(&pEndpoint->pAioMgr, pAioMgr);
    194194
    195195    return rc;
    … …  
    203203    AssertRCReturn(rc, rc);
    204204
    205     ASMAtomicWritePtr((void * volatile *)&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint, pEndpoint);
     205    ASMAtomicWritePtr(&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint, pEndpoint);
    206206    rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT);
    207207
    … …  
    218218    AssertRCReturn(rc, rc);
    219219
    220     ASMAtomicWritePtr((void * volatile *)&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint, pEndpoint);
     220    ASMAtomicWritePtr(&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint, pEndpoint);
    221221    rc = pdmacFileAioMgrWaitForBlockingEvent(pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT);
    222222
    … …  
    247247        pNext = pEndpoint->pTasksNewHead;
    248248        pTask->pNext = pNext;
    249     } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pEndpoint->pTasksNewHead, (void *)pTask, (void *)pNext));
    250 
    251     pdmacFileAioMgrWakeup((PPDMACEPFILEMGR)ASMAtomicReadPtr((void * volatile *)&pEndpoint->pAioMgr));
     249    } while (!ASMAtomicCmpXchgPtr(&pEndpoint->pTasksNewHead, pTask, pNext));
     250
     251    pdmacFileAioMgrWakeup(ASMAtomicReadPtrT(&pEndpoint->pAioMgr, PPDMACEPFILEMGR));
    252252
    253253    return VINF_SUCCESS;

  • trunk/src/VBox/VMM/PDMAsyncCompletionFileNormal.cpp

    r29474 r30111  
    11941194        case PDMACEPFILEAIOMGRBLOCKINGEVENT_ADD_ENDPOINT:
    11951195        {
    1196             PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointNew = (PPDMASYNCCOMPLETIONENDPOINTFILE)ASMAtomicReadPtr((void * volatile *)&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint);
     1196            PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointNew = ASMAtomicReadPtrT(&pAioMgr->BlockingEventData.AddEndpoint.pEndpoint, PPDMASYNCCOMPLETIONENDPOINTFILE);
    11971197            AssertMsg(VALID_PTR(pEndpointNew), ("Adding endpoint event without a endpoint to add\n"));
    11981198
    … …  
    12131213        case PDMACEPFILEAIOMGRBLOCKINGEVENT_REMOVE_ENDPOINT:
    12141214        {
    1215             PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointRemove = (PPDMASYNCCOMPLETIONENDPOINTFILE)ASMAtomicReadPtr((void * volatile *)&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint);
     1215            PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointRemove = ASMAtomicReadPtrT(&pAioMgr->BlockingEventData.RemoveEndpoint.pEndpoint, PPDMASYNCCOMPLETIONENDPOINTFILE);
    12161216            AssertMsg(VALID_PTR(pEndpointRemove), ("Removing endpoint event without a endpoint to remove\n"));
    12171217
    … …  
    12221222        case PDMACEPFILEAIOMGRBLOCKINGEVENT_CLOSE_ENDPOINT:
    12231223        {
    1224             PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointClose = (PPDMASYNCCOMPLETIONENDPOINTFILE)ASMAtomicReadPtr((void * volatile *)&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint);
     1224            PPDMASYNCCOMPLETIONENDPOINTFILE pEndpointClose = ASMAtomicReadPtrT(&pAioMgr->BlockingEventData.CloseEndpoint.pEndpoint, PPDMASYNCCOMPLETIONENDPOINTFILE);
    12251225            AssertMsg(VALID_PTR(pEndpointClose), ("Close endpoint event without a endpoint to close\n"));
    12261226

  • trunk/src/VBox/VMM/PDMQueue.cpp

    r29910 r30111  
    710710     * Get the lists.
    711711     */
    712     PPDMQUEUEITEMCORE pItems   = (PPDMQUEUEITEMCORE)ASMAtomicXchgPtr((void * volatile *)&pQueue->pPendingR3, NULL);
     712    PPDMQUEUEITEMCORE pItems   = ASMAtomicXchgPtrT(&pQueue->pPendingR3, NULL, PPDMQUEUEITEMCORE);
    713713    RTRCPTR           pItemsRC = ASMAtomicXchgRCPtr(&pQueue->pPendingRC, NIL_RTRCPTR);
    714714    RTR0PTR           pItemsR0 = ASMAtomicXchgR0Ptr(&pQueue->pPendingR0, NIL_RTR0PTR);
    … …  
    835835        for (;;)
    836836        {
    837             if (ASMAtomicCmpXchgPtr((void * volatile *)&pQueue->pPendingR3, pItems, NULL))
     837            if (ASMAtomicCmpXchgPtr(&pQueue->pPendingR3, pItems, NULL))
    838838                break;
    839             PPDMQUEUEITEMCORE pPending = (PPDMQUEUEITEMCORE)ASMAtomicXchgPtr((void * volatile *)&pQueue->pPendingR3, NULL);
     839            PPDMQUEUEITEMCORE pPending = ASMAtomicXchgPtrT(&pQueue->pPendingR3, NULL, PPDMQUEUEITEMCORE);
    840840            if (pPending)
    841841            {

  • trunk/src/VBox/VMM/SSM.cpp

    r29954 r30111  
    18991899    for (;;)
    19001900    {
    1901         PSSMSTRMBUF pCurFreeHead = (PSSMSTRMBUF)ASMAtomicUoReadPtr((void * volatile *)&pStrm->pFree);
    1902         ASMAtomicUoWritePtr((void * volatile *)&pBuf->pNext, pCurFreeHead);
    1903         if (ASMAtomicCmpXchgPtr((void * volatile *)&pStrm->pFree, pBuf, pCurFreeHead))
     1901        PSSMSTRMBUF pCurFreeHead = ASMAtomicUoReadPtrT(&pStrm->pFree, PSSMSTRMBUF);
     1902        ASMAtomicUoWritePtr(&pBuf->pNext, pCurFreeHead);
     1903        if (ASMAtomicCmpXchgPtr(&pStrm->pFree, pBuf, pCurFreeHead))
    19041904        {
    19051905            int rc = RTSemEventSignal(pStrm->hEvtFree);
    … …  
    19231923    for (;;)
    19241924    {
    1925         PSSMSTRMBUF pMine = (PSSMSTRMBUF)ASMAtomicUoReadPtr((void * volatile *)&pStrm->pFree);
     1925        PSSMSTRMBUF pMine = ASMAtomicUoReadPtrT(&pStrm->pFree, PSSMSTRMBUF);
    19261926        if (!pMine)
    19271927        {
    … …  
    19441944        }
    19451945
    1946         if (ASMAtomicCmpXchgPtr((void * volatile *)&pStrm->pFree, pMine->pNext, pMine))
     1946        if (ASMAtomicCmpXchgPtr(&pStrm->pFree, pMine->pNext, pMine))
    19471947        {
    19481948            pMine->offStream    = UINT64_MAX;
    … …  
    19681968    for (;;)
    19691969    {
    1970         PSSMSTRMBUF pCurHead = (PSSMSTRMBUF)ASMAtomicUoReadPtr((void * volatile *)&pStrm->pHead);
    1971         ASMAtomicUoWritePtr((void * volatile *)&pBuf->pNext, pCurHead);
    1972         if (ASMAtomicCmpXchgPtr((void * volatile *)&pStrm->pHead, pBuf, pCurHead))
     1970        PSSMSTRMBUF pCurHead = ASMAtomicUoReadPtrT(&pStrm->pHead, PSSMSTRMBUF);
     1971        ASMAtomicUoWritePtr(&pBuf->pNext, pCurHead);
     1972        if (ASMAtomicCmpXchgPtr(&pStrm->pHead, pBuf, pCurHead))
    19731973        {
    19741974            int rc = RTSemEventSignal(pStrm->hEvtHead);
    … …  
    20212021        }
    20222022
    2023         pMine = (PSSMSTRMBUF)ASMAtomicXchgPtr((void * volatile *)&pStrm->pHead, NULL);
     2023        pMine = ASMAtomicXchgPtrT(&pStrm->pHead, NULL, PSSMSTRMBUF);
    20242024        if (pMine)
    20252025            pStrm->pPending = ssmR3StrmReverseList(pMine);
    … …  
    21172117     * Grab the pending list and write it out.
    21182118     */
    2119     PSSMSTRMBUF pHead = (PSSMSTRMBUF)ASMAtomicXchgPtr((void * volatile *)&pStrm->pHead, NULL);
     2119    PSSMSTRMBUF pHead = ASMAtomicXchgPtrT(&pStrm->pHead, NULL, PSSMSTRMBUF);
    21202120    if (!pHead)
    21212121        return VINF_SUCCESS;
    … …  
    28232823            if (ASMAtomicReadBool(&pStrm->fTerminating))
    28242824            {
    2825                 if (!ASMAtomicReadPtr((void * volatile *)&pStrm->pHead))
     2825                if (!ASMAtomicReadPtrT(&pStrm->pHead, PSSMSTRMBUF))
    28262826                {
    28272827                    Log(("ssmR3StrmIoThread: quitting writing because of pending termination.\n"));
    … …  
    28302830                Log(("ssmR3StrmIoThread: postponing termination because of pending buffers.\n"));
    28312831            }
    2832             else if (!ASMAtomicReadPtr((void * volatile *)&pStrm->pHead))
     2832            else if (!ASMAtomicReadPtrT(&pStrm->pHead, PSSMSTRMBUF))
    28332833            {
    28342834                rc = RTSemEventWait(pStrm->hEvtHead, RT_INDEFINITE_WAIT);

  • trunk/src/VBox/VMM/VM.cpp

    r29329 r30111  
    24242424    for (unsigned i = 0; i < 10; i++)
    24252425    {
    2426         PVMREQ pReqHead = (PVMREQ)ASMAtomicXchgPtr((void * volatile *)&pUVM->vm.s.pReqs, NULL);
     2426        PVMREQ pReqHead = ASMAtomicXchgPtrT(&pUVM->vm.s.pReqs, NULL, PVMREQ);
    24272427        AssertMsg(!pReqHead, ("This isn't supposed to happen! VMR3Destroy caller has to serialize this.\n"));
    24282428        if (!pReqHead)
    … …  
    24492449        for (unsigned i = 0; i < 10; i++)
    24502450        {
    2451             PVMREQ pReqHead = (PVMREQ)ASMAtomicXchgPtr((void * volatile *)&pUVCpu->vm.s.pReqs, NULL);
     2451            PVMREQ pReqHead = ASMAtomicXchgPtrT(&pUVCpu->vm.s.pReqs, NULL, PVMREQ);
    24522452            AssertMsg(!pReqHead, ("This isn't supposed to happen! VMR3Destroy caller has to serialize this.\n"));
    24532453            if (!pReqHead)

  • trunk/src/VBox/VMM/VMMAll/PDMAllQueue.cpp

    r29902 r30111  
    8585        pvNext = ASMAtomicUoReadPtr((void * volatile *)&pQueue->CTX_SUFF(pPending));
    8686        ASMAtomicUoWritePtr((void * volatile *)&pItem->CTX_SUFF(pNext), pvNext);
    87     } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pQueue->CTX_SUFF(pPending), pItem, pvNext));
     87    } while (!ASMAtomicCmpXchgPtr(&pQueue->CTX_SUFF(pPending), pItem, pvNext));
    8888#else
    8989    PPDMQUEUEITEMCORE pNext;
    … …  
    9292        pNext = pQueue->CTX_SUFF(pPending);
    9393        pItem->CTX_SUFF(pNext) = pNext;
    94     } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pQueue->CTX_SUFF(pPending), pItem, pNext));
     94    } while (!ASMAtomicCmpXchgPtr(&pQueue->CTX_SUFF(pPending), pItem, pNext));
    9595#endif
    9696

  • trunk/src/VBox/VMM/VMMR0/GVMMR0.cpp

    r29250 r30111  
    10671067    pHandle->iNext = pGVMM->iFreeHead;
    10681068    pGVMM->iFreeHead = iHandle;
    1069     ASMAtomicXchgPtr((void * volatile *)&pHandle->pGVM, NULL);
    1070     ASMAtomicXchgPtr((void * volatile *)&pHandle->pVM, NULL);
    1071     ASMAtomicXchgPtr((void * volatile *)&pHandle->pvObj, NULL);
    1072     ASMAtomicXchgPtr((void * volatile *)&pHandle->pSession, NULL);
    1073     ASMAtomicXchgSize(&pHandle->hEMT0, NIL_RTNATIVETHREAD);
    1074     ASMAtomicXchgSize(&pHandle->ProcId, NIL_RTPROCESS);
     1069    ASMAtomicWritePtr(&pHandle->pGVM,               (PGVM)NULL);
     1070    ASMAtomicWritePtr(&pHandle->pVM,                 (PVM)NULL);
     1071    ASMAtomicWritePtr(&pHandle->pvObj,            (void *)NULL);
     1072    ASMAtomicWritePtr(&pHandle->pSession, (PSUPDRVSESSION)NULL);
     1073    ASMAtomicWriteSize(&pHandle->hEMT0,    NIL_RTNATIVETHREAD);
     1074    ASMAtomicWriteSize(&pHandle->ProcId,        NIL_RTPROCESS);
    10751075
    10761076    gvmmR0UsedUnlock(pGVMM);

  • trunk/src/VBox/VMM/VMMR0/PGMR0.cpp

    r29468 r30111  
    198198 * @param   pvFault             The fault address.
    199199 */
    200 VMMR0DECL(int) PGMR0Trap0eHandlerNestedPaging(PVM pVM, PVMCPU pVCpu, PGMMODE enmShwPagingMode, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPHYS pvFault)
     200VMMR0DECL(int) PGMR0Trap0eHandlerNestedPaging(PVM pVM, PVMCPU pVCpu, PGMMODE enmShwPagingMode, RTGCUINT uErr,
     201                                              PCPUMCTXCORE pRegFrame, RTGCPHYS pvFault)
    201202{
    202203    int rc;

  • trunk/src/VBox/VMM/VMReq.cpp

    r28800 r30111  
    480480    for (unsigned cIterations = 0;; cIterations++)
    481481    {
    482         PVMREQ pHead = (PVMREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, pList);
     482        PVMREQ pHead = ASMAtomicXchgPtrT(ppHead, pList, PVMREQ);
    483483        if (!pHead)
    484484            return;
    … …  
    486486        while (pTail->pNext)
    487487            pTail = pTail->pNext;
    488         ASMAtomicWritePtr((void * volatile *)&pTail->pNext, pList);
     488        ASMAtomicWritePtr(&pTail->pNext, pList);
    489489        ASMCompilerBarrier();
    490         if (ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (void *)pHead, pList))
     490        if (ASMAtomicCmpXchgPtr(ppHead, pHead, pList))
    491491            return;
    492         ASMAtomicWritePtr((void * volatile *)&pTail->pNext, NULL);
     492        ASMAtomicWritePtr(&pTail->pNext, NULL);
    493493        ASMCompilerBarrier();
    494         if (ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (void *)pHead, NULL))
     494        if (ASMAtomicCmpXchgPtr(ppHead, pHead, NULL))
    495495            return;
    496496        pList = pHead;
    … …  
    594594        PVMREQ pReq = *ppHead;
    595595        if (    pReq
    596             &&  !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq)
     596            &&  !ASMAtomicCmpXchgPtr(ppHead, (pNext = pReq->pNext), pReq)
    597597            &&  (pReq = *ppHead)
    598             &&  !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (pNext = pReq->pNext), pReq))
     598            &&  !ASMAtomicCmpXchgPtr(ppHead, (pNext = pReq->pNext), pReq))
    599599            pReq = NULL;
    600600        if (pReq)
    … …  
    602602            Assert(pReq->pNext == pNext); NOREF(pReq);
    603603#else
    604         PVMREQ pReq = (PVMREQ)ASMAtomicXchgPtr((void * volatile *)ppHead, NULL);
     604        PVMREQ pReq = ASMAtomicXchgPtrT(ppHead, NULL, PVMREQ);
    605605        if (pReq)
    606606        {
    607607            PVMREQ pNext = pReq->pNext;
    608608            if (    pNext
    609                 &&  !ASMAtomicCmpXchgPtr((void * volatile *)ppHead, pNext, NULL))
     609                &&  !ASMAtomicCmpXchgPtr(ppHead, pNext, NULL))
    610610            {
    611611                STAM_COUNTER_INC(&pUVM->vm.s.StatReqAllocRaces);
    … …  
    750750        do
    751751        {
    752             pNext = (PVMREQ)ASMAtomicUoReadPtr((void * volatile *)ppHead);
    753             ASMAtomicWritePtr((void * volatile *)&pReq->pNext, pNext);
     752            pNext = ASMAtomicUoReadPtrT(ppHead, PVMREQ);
     753            ASMAtomicWritePtr(&pReq->pNext, pNext);
    754754            ASMCompilerBarrier();
    755         } while (!ASMAtomicCmpXchgPtr((void * volatile *)ppHead, (void *)pReq, (void *)pNext));
     755        } while (!ASMAtomicCmpXchgPtr(ppHead, pReq, pNext));
    756756    }
    757757    else
    … …  
    857857        do
    858858        {
    859             pNext = (PVMREQ)ASMAtomicUoReadPtr((void * volatile *)&pUVCpu->vm.s.pReqs);
    860             ASMAtomicWritePtr((void * volatile *)&pReq->pNext, pNext);
     859            pNext = ASMAtomicUoReadPtrT(&pUVCpu->vm.s.pReqs, PVMREQ);
     860            ASMAtomicWritePtr(&pReq->pNext, pNext);
    861861            ASMCompilerBarrier();
    862         } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pUVCpu->vm.s.pReqs, (void *)pReq, (void *)pNext));
     862        } while (!ASMAtomicCmpXchgPtr(&pUVCpu->vm.s.pReqs, pReq, pNext));
    863863
    864864        /*
    … …  
    891891        do
    892892        {
    893             pNext = (PVMREQ)ASMAtomicUoReadPtr((void * volatile *)&pUVM->vm.s.pReqs);
    894             ASMAtomicWritePtr((void * volatile *)&pReq->pNext, pNext);
     893            pNext = ASMAtomicUoReadPtrT(&pUVM->vm.s.pReqs, PVMREQ);
     894            ASMAtomicWritePtr(&pReq->pNext, pNext);
    895895            ASMCompilerBarrier();
    896         } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pUVM->vm.s.pReqs, (void *)pReq, (void *)pNext));
     896        } while (!ASMAtomicCmpXchgPtr(&pUVM->vm.s.pReqs, pReq, pNext));
    897897
    898898        /*
    … …  
    996996 * @param   idDstCpu            VMCPUID_ANY or virtual CPU ID.
    997997 * @param   pReqList            The list of requests.
    998  * @param   ppvReqs             Pointer to the list head.
    999  */
    1000 static PVMREQ vmR3ReqProcessUTooManyHelper(PUVM pUVM, VMCPUID idDstCpu, PVMREQ pReqList, void * volatile *ppvReqs)
     998 * @param   ppReqs              Pointer to the list head.
     999 */
     1000static PVMREQ vmR3ReqProcessUTooManyHelper(PUVM pUVM, VMCPUID idDstCpu, PVMREQ pReqList, PVMREQ volatile *ppReqs)
    10011001{
    10021002    STAM_COUNTER_INC(&pUVM->vm.s.StatReqMoreThan1);
    … …  
    10091009        pReqRet = pReqRet->pNext;
    10101010    } while (pReqRet->pNext);
    1011     ASMAtomicWritePtr((void * volatile *)&pPrev->pNext, NULL);
     1011    ASMAtomicWritePtr(&pPrev->pNext, NULL);
    10121012
    10131013    /* Push the others back onto the list (end of it). */
    10141014    Log2(("VMR3ReqProcess: Pushing back %p %p...\n", pReqList, pReqList->pNext));
    1015     if (RT_UNLIKELY(!ASMAtomicCmpXchgPtr(ppvReqs, pReqList, NULL)))
     1015    if (RT_UNLIKELY(!ASMAtomicCmpXchgPtr(ppReqs, pReqList, NULL)))
    10161016    {
    10171017        STAM_COUNTER_INC(&pUVM->vm.s.StatReqPushBackRaces);
    … …  
    10191019        {
    10201020            ASMNopPause();
    1021             PVMREQ pReqList2 = (PVMREQ)ASMAtomicXchgPtr(ppvReqs, NULL);
     1021            PVMREQ pReqList2 = ASMAtomicXchgPtrT(ppReqs, NULL, PVMREQ);
    10221022            if (pReqList2)
    10231023            {
    … …  
    10251025                while (pLast->pNext)
    10261026                    pLast = pLast->pNext;
    1027                 ASMAtomicWritePtr((void * volatile *)&pLast->pNext, pReqList);
     1027                ASMAtomicWritePtr(&pLast->pNext, pReqList);
    10281028                pReqList = pReqList2;
    10291029            }
    1030         } while (!ASMAtomicCmpXchgPtr(ppvReqs, pReqList, NULL));
     1030        } while (!ASMAtomicCmpXchgPtr(ppReqs, pReqList, NULL));
    10311031    }
    10321032
    … …  
    10781078         * rest back so that we're reentrant.
    10791079         */
    1080         void * volatile *ppvReqs;
     1080        PVMREQ volatile *ppReqs;
    10811081        if (idDstCpu == VMCPUID_ANY)
    10821082        {
    1083             ppvReqs = (void * volatile *)&pUVM->vm.s.pReqs;
     1083            ppReqs = &pUVM->vm.s.pReqs;
    10841084            if (RT_LIKELY(pUVM->pVM))
    10851085                VM_FF_CLEAR(pUVM->pVM, VM_FF_REQUEST);
    … …  
    10891089            Assert(idDstCpu < pUVM->cCpus);
    10901090            Assert(pUVM->aCpus[idDstCpu].vm.s.NativeThreadEMT == RTThreadNativeSelf());
    1091             ppvReqs = (void * volatile *)&pUVM->aCpus[idDstCpu].vm.s.pReqs;
     1091            ppReqs = &pUVM->aCpus[idDstCpu].vm.s.pReqs;
    10921092            if (RT_LIKELY(pUVM->pVM))
    10931093                VMCPU_FF_CLEAR(&pUVM->pVM->aCpus[idDstCpu], VMCPU_FF_REQUEST);
    10941094        }
    10951095
    1096         PVMREQ pReq = (PVMREQ)ASMAtomicXchgPtr(ppvReqs, NULL);
     1096        PVMREQ pReq = ASMAtomicXchgPtrT(ppReqs, NULL, PVMREQ);
    10971097        if (!pReq)
    10981098            break;
    10991099        if (RT_UNLIKELY(pReq->pNext))
    1100             pReq = vmR3ReqProcessUTooManyHelper(pUVM, idDstCpu, pReq, ppvReqs);
     1100            pReq = vmR3ReqProcessUTooManyHelper(pUVM, idDstCpu, pReq, ppReqs);
    11011101
    11021102        /*
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