VirtualBox

Changeset 57276 in vbox for trunk/src/VBox/Runtime


Ignore:
Timestamp:
Aug 11, 2015 2:39:19 PM (10 years ago)
Author:
vboxsync
Message:

iprt/r0drv/linux: Preserve EFLAGS/AC where ever it may possibly be thought to change when calling kernel code.

Location:
trunk/src/VBox/Runtime/r0drv/linux
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    r56290 r57276  
    3636RTDECL(void) RTLogWriteDebugger(const char *pch, size_t cb)
    3737{
     38    IPRT_LINUX_SAVE_EFL_AC();
    3839    printk("%.*s", (int)cb, pch);
     40    IPRT_LINUX_RESTORE_EFL_AC();
    3941}
    4042RT_EXPORT_SYMBOL(RTLogWriteDebugger);

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

    r56290 r57276  
    235235{
    236236    PRTMEMHDR pHdr;
     237    IPRT_LINUX_SAVE_EFL_AC();
    237238
    238239    /*
    … …  
    298299    }
    299300    if (RT_UNLIKELY(!pHdr))
     301    {
     302        IPRT_LINUX_RESTORE_EFL_AC();
    300303        return VERR_NO_MEMORY;
     304    }
    301305
    302306    /*
    … …  
    309313
    310314    *ppHdr = pHdr;
     315    IPRT_LINUX_RESTORE_EFL_AC();
    311316    return VINF_SUCCESS;
    312317}
    … …  
    318323DECLHIDDEN(void) rtR0MemFree(PRTMEMHDR pHdr)
    319324{
     325    IPRT_LINUX_SAVE_EFL_AC();
     326
    320327    pHdr->u32Magic += 1;
    321328    if (pHdr->fFlags & RTMEMHDR_FLAG_KMALLOC)
    … …  
    346353    else
    347354        vfree(pHdr);
     355
     356    IPRT_LINUX_RESTORE_EFL_AC();
    348357}
    349358
    … …  
    384393    unsigned        cPages;
    385394    struct page    *paPages;
     395    void           *pvRet;
     396    IPRT_LINUX_SAVE_EFL_AC();
    386397
    387398    /*
    … …  
    435446        }
    436447        *pPhys = page_to_phys(paPages);
    437         return phys_to_virt(page_to_phys(paPages));
    438     }
    439 
     448        pvRet = phys_to_virt(page_to_phys(paPages));
     449    }
     450    else
     451        pvRet = NULL;
     452
     453    IPRT_LINUX_RESTORE_EFL_AC();
    440454    return NULL;
    441455}
    … …  
    457471        unsigned        iPage;
    458472        struct page    *paPages;
     473        IPRT_LINUX_SAVE_EFL_AC();
    459474
    460475        /* validate */
    … …  
    479494        }
    480495        __free_pages(paPages, cOrder);
     496        IPRT_LINUX_RESTORE_EFL_AC();
    481497    }
    482498}

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

    r56290 r57276  
    4343DECLHIDDEN(void) rtR0AssertNativeMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)
    4444{
     45    IPRT_LINUX_SAVE_EFL_AC();
    4546    printk(KERN_EMERG
    4647           "\r\n!!Assertion Failed!!\r\n"
    … …  
    4849           "Location  : %s(%d) %s\r\n",
    4950           pszExpr, pszFile, uLine, pszFunction);
     51    IPRT_LINUX_RESTORE_EFL_AC();
    5052}
    5153
    … …  
    5456{
    5557    char szMsg[256];
     58    IPRT_LINUX_SAVE_EFL_AC();
    5659
    5760    RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
    … …  
    6063
    6164    NOREF(fInitial);
     65    IPRT_LINUX_RESTORE_EFL_AC();
    6266}
    6367

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

    r56290 r57276  
    6363DECLHIDDEN(void) rtR0LnxWorkqueuePush(RTR0LNXWORKQUEUEITEM *pWork, void (*pfnWorker)(RTR0LNXWORKQUEUEITEM *))
    6464{
     65    IPRT_LINUX_SAVE_EFL_AC();
     66
    6567#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
    6668# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
    … …  
    7476    queue_task(pWork, &g_rtR0LnxWorkQueue);
    7577#endif
     78
     79    IPRT_LINUX_RESTORE_EFL_AC();
    7680}
    7781
    … …  
    8589DECLHIDDEN(void) rtR0LnxWorkqueueFlush(void)
    8690{
     91    IPRT_LINUX_SAVE_EFL_AC();
     92
    8793#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
    8894    flush_workqueue(g_prtR0LnxWorkQueue);
    … …  
    9096    run_task_queue(&g_rtR0LnxWorkQueue);
    9197#endif
     98
     99    IPRT_LINUX_RESTORE_EFL_AC();
    92100}
    93101
    … …  
    95103DECLHIDDEN(int) rtR0InitNative(void)
    96104{
     105    int rc = VINF_SUCCESS;
     106    IPRT_LINUX_SAVE_EFL_AC();
     107
    97108#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
    98109 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
    … …  
    102113 #endif
    103114    if (!g_prtR0LnxWorkQueue)
    104         return VERR_NO_MEMORY;
     115        rc = VERR_NO_MEMORY;
    105116#endif
    106117
    107     return VINF_SUCCESS;
     118    IPRT_LINUX_RESTORE_EFL_AC();
     119    return rc;
    108120}
    109121
    … …  
    111123DECLHIDDEN(void) rtR0TermNative(void)
    112124{
     125    IPRT_LINUX_SAVE_EFL_AC();
     126
    113127    rtR0LnxWorkqueueFlush();
    114128#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
    … …  
    118132
    119133    rtR0MemExecCleanup();
     134
     135    IPRT_LINUX_RESTORE_EFL_AC();
    120136}
    121137

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

    r56290 r57276  
    548548DECLHIDDEN(int) rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
    549549{
     550    IPRT_LINUX_SAVE_EFL_AC();
    550551    PRTR0MEMOBJLNX pMemLnx = (PRTR0MEMOBJLNX)pMem;
    551552
    … …  
    626627            return VERR_INTERNAL_ERROR;
    627628    }
     629    IPRT_LINUX_RESTORE_EFL_ONLY_AC();
    628630    return VINF_SUCCESS;
    629631}
    … …  
    632634DECLHIDDEN(int) rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
    633635{
     636    IPRT_LINUX_SAVE_EFL_AC();
    634637    PRTR0MEMOBJLNX pMemLnx;
    635638    int rc;
    … …  
    648651        {
    649652            *ppMem = &pMemLnx->Core;
     653            IPRT_LINUX_RESTORE_EFL_AC();
    650654            return rc;
    651655        }
    … …  
    655659    }
    656660
     661    IPRT_LINUX_RESTORE_EFL_AC();
    657662    return rc;
    658663}
    … …  
    661666DECLHIDDEN(int) rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
    662667{
     668    IPRT_LINUX_SAVE_EFL_AC();
    663669    PRTR0MEMOBJLNX pMemLnx;
    664670    int rc;
    … …  
    688694        {
    689695            *ppMem = &pMemLnx->Core;
     696            IPRT_LINUX_RESTORE_EFL_AC();
    690697            return rc;
    691698        }
    … …  
    695702    }
    696703
     704    IPRT_LINUX_RESTORE_EFL_AC();
    697705    return rc;
    698706}
    … …  
    701709DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
    702710{
     711    IPRT_LINUX_SAVE_EFL_AC();
    703712    PRTR0MEMOBJLNX pMemLnx;
    704713    int rc;
    … …  
    731740            pMemLnx->Core.u.Cont.Phys = page_to_phys(pMemLnx->apPages[0]);
    732741            *ppMem = &pMemLnx->Core;
     742            IPRT_LINUX_RESTORE_EFL_AC();
    733743            return rc;
    734744        }
    … …  
    738748    }
    739749
     750    IPRT_LINUX_RESTORE_EFL_AC();
    740751    return rc;
    741752}
    … …  
    809820{
    810821    int rc;
     822    IPRT_LINUX_SAVE_EFL_AC();
    811823
    812824    /*
    … …  
    844856            rc = rtR0MemObjLinuxAllocPhysSub2(ppMem, enmType, cb, uAlignment, PhysHighest, GFP_DMA);
    845857    }
     858    IPRT_LINUX_RESTORE_EFL_AC();
    846859    return rc;
    847860}
    … …  
    954967DECLHIDDEN(int) rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb, uint32_t uCachePolicy)
    955968{
     969    IPRT_LINUX_SAVE_EFL_AC();
     970
    956971    /*
    957972     * All we need to do here is to validate that we can use
    … …  
    964979    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_PHYS, NULL, cb);
    965980    if (!pMemLnx)
     981    {
     982        IPRT_LINUX_RESTORE_EFL_AC();
    966983        return VERR_NO_MEMORY;
     984    }
    967985
    968986    pMemLnx->Core.u.Phys.PhysBase = PhysAddr;
    … …  
    971989    Assert(!pMemLnx->cPages);
    972990    *ppMem = &pMemLnx->Core;
     991    IPRT_LINUX_RESTORE_EFL_AC();
    973992    return VINF_SUCCESS;
    974993}
    … …  
    977996DECLHIDDEN(int) rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    978997{
     998    IPRT_LINUX_SAVE_EFL_AC();
    979999    const int cPages = cb >> PAGE_SHIFT;
    9801000    struct task_struct *pTask = rtR0ProcessToLinuxTask(R0Process);
    … …  
    9971017    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
    9981018    if (!pMemLnx)
     1019    {
     1020        IPRT_LINUX_RESTORE_EFL_AC();
    9991021        return VERR_NO_MEMORY;
     1022    }
    10001023
    10011024    papVMAs = (struct vm_area_struct **)RTMemAlloc(sizeof(*papVMAs) * cPages);
    … …  
    10481071            *ppMem = &pMemLnx->Core;
    10491072
     1073            IPRT_LINUX_RESTORE_EFL_AC();
    10501074            return VINF_SUCCESS;
    10511075        }
    … …  
    10681092
    10691093    rtR0MemObjDelete(&pMemLnx->Core);
     1094    IPRT_LINUX_RESTORE_EFL_AC();
    10701095    return rc;
    10711096}
    … …  
    10741099DECLHIDDEN(int) rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
    10751100{
     1101    IPRT_LINUX_SAVE_EFL_AC();
    10761102    void           *pvLast = (uint8_t *)pv + cb - 1;
    10771103    size_t const    cPages = cb >> PAGE_SHIFT;
    … …  
    11061132    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, pv, cb);
    11071133    if (!pMemLnx)
     1134    {
     1135        IPRT_LINUX_RESTORE_EFL_AC();
    11081136        return VERR_NO_MEMORY;
     1137    }
    11091138
    11101139    /*
    … …  
    11471176        *ppMem = &pMemLnx->Core;
    11481177
     1178        IPRT_LINUX_RESTORE_EFL_AC();
    11491179        return VINF_SUCCESS;
    11501180    }
    11511181
    11521182    rtR0MemObjDelete(&pMemLnx->Core);
     1183    IPRT_LINUX_RESTORE_EFL_AC();
    11531184    return rc;
    11541185}
    … …  
    11581189{
    11591190#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
     1191    IPRT_LINUX_SAVE_EFL_AC();
    11601192    const size_t cPages = cb >> PAGE_SHIFT;
    11611193    struct page *pDummyPage;
    … …  
    11721204     */
    11731205    pDummyPage = alloc_page(GFP_HIGHUSER | __GFP_NOWARN);
    1174     if (!pDummyPage)
    1175         return VERR_NO_MEMORY;
    1176     papPages = RTMemAlloc(sizeof(*papPages) * cPages);
    1177     if (papPages)
    1178     {
    1179         void *pv;
    1180         size_t iPage = cPages;
    1181         while (iPage-- > 0)
    1182             papPages[iPage] = pDummyPage;
     1206    if (pDummyPage)
     1207    {
     1208        papPages = RTMemAlloc(sizeof(*papPages) * cPages);
     1209        if (papPages)
     1210        {
     1211            void *pv;
     1212            size_t iPage = cPages;
     1213            while (iPage-- > 0)
     1214                papPages[iPage] = pDummyPage;
    11831215# ifdef VM_MAP
    1184         pv = vmap(papPages, cPages, VM_MAP, PAGE_KERNEL_RO);
     1216            pv = vmap(papPages, cPages, VM_MAP, PAGE_KERNEL_RO);
    11851217# else
    1186         pv = vmap(papPages, cPages, VM_ALLOC, PAGE_KERNEL_RO);
     1218            pv = vmap(papPages, cPages, VM_ALLOC, PAGE_KERNEL_RO);
    11871219# endif
    1188         RTMemFree(papPages);
    1189         if (pv)
    1190         {
    1191             PRTR0MEMOBJLNX pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_RES_VIRT, pv, cb);
    1192             if (pMemLnx)
    1193             {
    1194                 pMemLnx->Core.u.ResVirt.R0Process = NIL_RTR0PROCESS;
    1195                 pMemLnx->cPages = 1;
    1196                 pMemLnx->apPages[0] = pDummyPage;
    1197                 *ppMem = &pMemLnx->Core;
    1198                 return VINF_SUCCESS;
    1199             }
    1200             vunmap(pv);
    1201         }
    1202     }
    1203     __free_page(pDummyPage);
     1220            RTMemFree(papPages);
     1221            if (pv)
     1222            {
     1223                PRTR0MEMOBJLNX pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_RES_VIRT, pv, cb);
     1224                if (pMemLnx)
     1225                {
     1226                    pMemLnx->Core.u.ResVirt.R0Process = NIL_RTR0PROCESS;
     1227                    pMemLnx->cPages = 1;
     1228                    pMemLnx->apPages[0] = pDummyPage;
     1229                    *ppMem = &pMemLnx->Core;
     1230                    IPRT_LINUX_RESTORE_EFL_AC();
     1231                    return VINF_SUCCESS;
     1232                }
     1233                vunmap(pv);
     1234            }
     1235        }
     1236        __free_page(pDummyPage);
     1237    }
     1238    IPRT_LINUX_RESTORE_EFL_AC();
    12041239    return VERR_NO_MEMORY;
    12051240
    … …  
    12161251DECLHIDDEN(int) rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, RTR0PROCESS R0Process)
    12171252{
     1253    IPRT_LINUX_SAVE_EFL_AC();
    12181254    PRTR0MEMOBJLNX      pMemLnx;
    12191255    void               *pv;
    … …  
    12331269    pv = rtR0MemObjLinuxDoMmap(R3PtrFixed, cb, uAlignment, pTask, RTMEM_PROT_NONE);
    12341270    if (pv == (void *)-1)
     1271    {
     1272        IPRT_LINUX_RESTORE_EFL_AC();
    12351273        return VERR_NO_MEMORY;
     1274    }
    12361275
    12371276    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_RES_VIRT, pv, cb);
    … …  
    12391278    {
    12401279        rtR0MemObjLinuxDoMunmap(pv, cb, pTask);
     1280        IPRT_LINUX_RESTORE_EFL_AC();
    12411281        return VERR_NO_MEMORY;
    12421282    }
    … …  
    12441284    pMemLnx->Core.u.ResVirt.R0Process = R0Process;
    12451285    *ppMem = &pMemLnx->Core;
     1286    IPRT_LINUX_RESTORE_EFL_AC();
    12461287    return VINF_SUCCESS;
    12471288}
    … …  
    12551296    PRTR0MEMOBJLNX pMemLnxToMap = (PRTR0MEMOBJLNX)pMemToMap;
    12561297    PRTR0MEMOBJLNX pMemLnx;
     1298    IPRT_LINUX_SAVE_EFL_AC();
    12571299
    12581300    /* Fail if requested to do something we can't. */
    … …  
    13261368            pMemLnx->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
    13271369            *ppMem = &pMemLnx->Core;
     1370            IPRT_LINUX_RESTORE_EFL_AC();
    13281371            return VINF_SUCCESS;
    13291372        }
    … …  
    13311374    }
    13321375
     1376    IPRT_LINUX_RESTORE_EFL_AC();
    13331377    return rc;
    13341378}
    … …  
    13951439    RTHCPHYS            DummyPhys;
    13961440#endif
     1441    IPRT_LINUX_SAVE_EFL_AC();
    13971442
    13981443    /*
    … …  
    14101455    pDummyPage = alloc_page(GFP_USER | __GFP_NOWARN);
    14111456    if (!pDummyPage)
     1457    {
     1458        IPRT_LINUX_RESTORE_EFL_AC();
    14121459        return VERR_NO_MEMORY;
     1460    }
    14131461    SetPageReserved(pDummyPage);
    14141462    DummyPhys = page_to_phys(pDummyPage);
    … …  
    15641612                pMemLnx->Core.u.Mapping.R0Process = R0Process;
    15651613                *ppMem = &pMemLnx->Core;
     1614                IPRT_LINUX_RESTORE_EFL_AC();
    15661615                return VINF_SUCCESS;
    15671616            }
    … …  
    15781627#endif
    15791628
     1629    IPRT_LINUX_RESTORE_EFL_AC();
    15801630    return rc;
    15811631}

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

    r56290 r57276  
    3838RTR0DECL(int) RTR0MemUserCopyFrom(void *pvDst, RTR3PTR R3PtrSrc, size_t cb)
    3939{
     40    IPRT_LINUX_SAVE_EFL_AC();
    4041    if (RT_LIKELY(copy_from_user(pvDst, (void *)R3PtrSrc, cb) == 0))
     42    {
     43        IPRT_LINUX_RESTORE_EFL_AC();
    4144        return VINF_SUCCESS;
     45    }
     46    IPRT_LINUX_RESTORE_EFL_AC();
    4247    return VERR_ACCESS_DENIED;
    4348}
    … …  
    4752RTR0DECL(int) RTR0MemUserCopyTo(RTR3PTR R3PtrDst, void const *pvSrc, size_t cb)
    4853{
     54    IPRT_LINUX_SAVE_EFL_AC();
    4955    if (RT_LIKELY(copy_to_user((void *)R3PtrDst, pvSrc, cb) == 0))
     56    {
     57        IPRT_LINUX_RESTORE_EFL_AC();
    5058        return VINF_SUCCESS;
     59    }
     60    IPRT_LINUX_RESTORE_EFL_AC();
    5161    return VERR_ACCESS_DENIED;
    5262}
    … …  
    5666RTR0DECL(bool) RTR0MemUserIsValidAddr(RTR3PTR R3Ptr)
    5767{
    58     return access_ok(VERIFY_READ, (void *)R3Ptr, 1);
     68    IPRT_LINUX_SAVE_EFL_AC();
     69    bool fRc = access_ok(VERIFY_READ, (void *)R3Ptr, 1);
     70    IPRT_LINUX_RESTORE_EFL_AC();
     71    return fRc;
    5972}
    6073RT_EXPORT_SYMBOL(RTR0MemUserIsValidAddr);
    … …  
    114127# endif /* !_ASM_EXTABLE */
    115128    int rc;
     129    IPRT_LINUX_SAVE_EFL_AC(); /* paranoia */
    116130    if (!cb)
    117131        return VINF_SUCCESS;
    … …  
    136150                            "3" (cb)
    137151                          : "memory");
     152    IPRT_LINUX_RESTORE_EFL_AC();
    138153    return rc;
    139154#else

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

    r56290 r57276  
    249249RTDECL(int) RTMpOnAll(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
    250250{
     251    IPRT_LINUX_SAVE_EFL_AC();
    251252    int rc;
    252253    RTMPARGS Args;
    … …  
    301302
    302303    RTThreadPreemptRestore(&PreemptState);
     304    IPRT_LINUX_RESTORE_EFL_AC();
    303305    return VINF_SUCCESS;
    304306}
    … …  
    308310RTDECL(int) RTMpOnOthers(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
    309311{
     312    IPRT_LINUX_SAVE_EFL_AC();
    310313    int rc;
    311314    RTMPARGS Args;
    … …  
    327330
    328331    Assert(rc == 0); NOREF(rc);
     332    IPRT_LINUX_RESTORE_EFL_AC();
    329333    return VINF_SUCCESS;
    330334}
    … …  
    356360RTDECL(int) RTMpOnPair(RTCPUID idCpu1, RTCPUID idCpu2, uint32_t fFlags, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
    357361{
     362    IPRT_LINUX_SAVE_EFL_AC();
    358363    int rc;
    359364    RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
    … …  
    443448        rc = VERR_CPU_NOT_FOUND;
    444449    RTThreadPreemptRestore(&PreemptState);;
     450    IPRT_LINUX_RESTORE_EFL_AC();
    445451    return rc;
    446452}
    … …  
    478484RTDECL(int) RTMpOnSpecific(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
    479485{
     486    IPRT_LINUX_SAVE_EFL_AC();
    480487    int rc;
    481488    RTMPARGS Args;
    … …  
    517524
    518525    NOREF(rc);
     526    IPRT_LINUX_RESTORE_EFL_AC();
    519527    return rc;
    520528}
    … …  
    539547#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
    540548    int rc;
     549    IPRT_LINUX_SAVE_EFL_AC();
    541550
    542551    if (!RTMpIsCpuPossible(idCpu))
    … …  
    554563    NOREF(rc);
    555564    Assert(rc == 0);
     565    IPRT_LINUX_RESTORE_EFL_AC();
    556566    return VINF_SUCCESS;
    557567

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

    r54808 r57276  
    174174{
    175175    int rc;
     176    IPRT_LINUX_SAVE_EFL_AC();
    176177
    177178# ifdef CPU_DOWN_FAILED
    … …  
    180181
    181182    rc = register_cpu_notifier(&g_NotifierBlock);
     183    IPRT_LINUX_RESTORE_EFL_AC();
    182184    AssertMsgReturn(!rc, ("%d\n", rc), RTErrConvertFromErrno(rc));
    183185    return VINF_SUCCESS;
    … …  
    187189DECLHIDDEN(void) rtR0MpNotificationNativeTerm(void)
    188190{
     191    IPRT_LINUX_SAVE_EFL_AC();
    189192    unregister_cpu_notifier(&g_NotifierBlock);
     193    IPRT_LINUX_RESTORE_EFL_AC();
    190194}
    191195

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

    r56290 r57276  
    7373{
    7474    PRTSEMEVENTINTERNAL pThis;
     75    IPRT_LINUX_SAVE_EFL_AC();
    7576
    7677    AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
    … …  
    8788
    8889    *phEventSem = pThis;
     90    IPRT_LINUX_RESTORE_EFL_AC();
    8991    return VINF_SUCCESS;
    9092}
    … …  
    118120RTDECL(int)  RTSemEventDestroy(RTSEMEVENT hEventSem)
    119121{
     122    IPRT_LINUX_SAVE_EFL_AC();
     123
    120124    /*
    121125     * Validate input.
    … …  
    135139    wake_up_all(&pThis->Head);
    136140    rtR0SemEventLnxRelease(pThis);
     141
     142    IPRT_LINUX_RESTORE_EFL_AC();
    137143    return VINF_SUCCESS;
    138144}
    … …  
    142148RTDECL(int)  RTSemEventSignal(RTSEMEVENT hEventSem)
    143149{
     150    IPRT_LINUX_SAVE_EFL_AC();
     151
    144152    /*
    145153     * Validate input.
    … …  
    157165
    158166    rtR0SemEventLnxRelease(pThis);
     167    IPRT_LINUX_RESTORE_EFL_AC();
    159168    return VINF_SUCCESS;
    160169}
    … …  
    195204         * We have to wait.
    196205         */
     206        IPRT_LINUX_SAVE_EFL_AC();
    197207        RTR0SEMLNXWAIT Wait;
    198208        rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
    … …  
    231241            IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
    232242        }
     243        IPRT_LINUX_RESTORE_EFL_AC();
    233244    }
    234245

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

    r56290 r57276  
    9696{
    9797    PRTSEMEVENTMULTIINTERNAL pThis;
     98    IPRT_LINUX_SAVE_EFL_AC();
    9899
    99100    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
    … …  
    107108
    108109        *phEventMultiSem = pThis;
     110        IPRT_LINUX_RESTORE_EFL_AC();
    109111        return VINF_SUCCESS;
    110112    }
     113    IPRT_LINUX_RESTORE_EFL_AC();
    111114    return VERR_NO_MEMORY;
    112115}
    … …  
    144147RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
    145148{
     149    IPRT_LINUX_SAVE_EFL_AC();
     150
    146151    /*
    147152     * Validate input.
    … …  
    162167    wake_up_all(&pThis->Head);
    163168    rtR0SemEventMultiLnxRelease(pThis);
     169
     170    IPRT_LINUX_RESTORE_EFL_AC();
    164171    return VINF_SUCCESS;
    165172}
    … …  
    169176RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
    170177{
     178    IPRT_LINUX_SAVE_EFL_AC();
    171179    uint32_t fNew;
    172180    uint32_t fOld;
    … …  
    198206
    199207    rtR0SemEventMultiLnxRelease(pThis);
     208    IPRT_LINUX_RESTORE_EFL_AC();
    200209    return VINF_SUCCESS;
    201210}
    … …  
    261270         */
    262271        RTR0SEMLNXWAIT Wait;
     272        IPRT_LINUX_SAVE_EFL_AC();
    263273        rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
    264274        if (RT_SUCCESS(rc))
    … …  
    296306            IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
    297307        }
     308        IPRT_LINUX_RESTORE_EFL_AC();
    298309    }
    299310

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

    r56290 r57276  
    6464RTDECL(int)  RTSemFastMutexCreate(PRTSEMFASTMUTEX phFastMtx)
    6565{
     66    IPRT_LINUX_SAVE_EFL_AC();
     67
    6668    /*
    6769     * Allocate.
    … …  
    8284
    8385    *phFastMtx = pThis;
     86    IPRT_LINUX_RESTORE_EFL_AC();
    8487    return VINF_SUCCESS;
    8588}
    … …  
    107110RTDECL(int)  RTSemFastMutexRequest(RTSEMFASTMUTEX hFastMtx)
    108111{
     112    IPRT_LINUX_SAVE_EFL_AC();
     113
    109114    /*
    110115     * Validate.
    … …  
    121126    ASMAtomicUoWriteSize(&pThis->Owner, RTThreadNativeSelf());
    122127#endif
     128
     129    IPRT_LINUX_RESTORE_EFL_ONLY_AC();
    123130    return VINF_SUCCESS;
    124131}
    … …  
    128135RTDECL(int)  RTSemFastMutexRelease(RTSEMFASTMUTEX hFastMtx)
    129136{
     137    IPRT_LINUX_SAVE_EFL_AC();
     138
    130139    /*
    131140     * Validate.
    … …  
    141150    up(&pThis->Semaphore);
    142151    IPRT_DEBUG_SEMS_STATE(pThis, 'u');
     152
     153    IPRT_LINUX_RESTORE_EFL_ONLY_AC();
    143154    return VINF_SUCCESS;
    144155}

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

    r56290 r57276  
    8787RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX phMtx)
    8888{
     89    IPRT_LINUX_SAVE_EFL_AC();
     90
    8991    /*
    9092     * Allocate.
    … …  
    116118    PRTSEMMUTEXLNXWAITER    pCur;
    117119    unsigned long           fSavedIrq;
     120    IPRT_LINUX_SAVE_EFL_AC();
    118121
    119122    /*
    … …  
    251254    unsigned long       fSavedIrq;
    252255    int                 rc;
     256    IPRT_LINUX_SAVE_EFL_AC();
    253257
    254258    /*
    … …  
    290294     */
    291295    else
    292         return rtSemMutexLinuxRequestSleep(pThis, cMillies, fInterruptible, fSavedIrq);
     296    {
     297        rc = rtSemMutexLinuxRequestSleep(pThis, cMillies, fInterruptible, fSavedIrq);
     298        IPRT_LINUX_RESTORE_EFL_ONLY_AC();
     299        return rc;
     300    }
    293301
    294302    IPRT_DEBUG_SEMS_STATE_RC(pThis, 'M', rc);
    295303    spin_unlock_irqrestore(&pThis->Spinlock, fSavedIrq);
     304    IPRT_LINUX_RESTORE_EFL_ONLY_AC();
    296305    return rc;
    297306}
    … …  
    332341    unsigned long       fSavedIrq;
    333342    int                 rc;
     343    IPRT_LINUX_SAVE_EFL_AC();
    334344
    335345    /*
    … …  
    367377
    368378    AssertRC(rc);
     379    IPRT_LINUX_RESTORE_EFL_AC();
    369380    return rc;
    370381}
    … …  
    377388    unsigned long       fSavedIrq;
    378389    bool                fOwned;
     390    IPRT_LINUX_SAVE_EFL_AC();
    379391
    380392    /*
    … …  
    392404    spin_unlock_irqrestore(&pThis->Spinlock, fSavedIrq);
    393405
     406    IPRT_LINUX_RESTORE_EFL_AC();
    394407    return fOwned;
    395408

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

    r56290 r57276  
    7474RTDECL(int)  RTSpinlockCreate(PRTSPINLOCK pSpinlock, uint32_t fFlags, const char *pszName)
    7575{
     76    IPRT_LINUX_SAVE_EFL_AC();
    7677    PRTSPINLOCKINTERNAL pThis;
    7778    AssertReturn(fFlags == RTSPINLOCK_FLAGS_INTERRUPT_SAFE || fFlags == RTSPINLOCK_FLAGS_INTERRUPT_UNSAFE, VERR_INVALID_PARAMETER);
    … …  
    9899
    99100    *pSpinlock = pThis;
     101    IPRT_LINUX_RESTORE_EFL_AC();
    100102    return VINF_SUCCESS;
    101103}
    … …  
    141143    }
    142144    else
     145    {
     146        IPRT_LINUX_SAVE_EFL_AC();
    143147        spin_lock(&pThis->Spinlock);
     148        IPRT_LINUX_RESTORE_EFL_ONLY_AC();
     149    }
    144150#ifdef CONFIG_PROVE_LOCKING
    145151    lockdep_on();
    … …  
    169175    }
    170176    else
     177    {
     178        IPRT_LINUX_SAVE_EFL_AC();
    171179        spin_unlock(&pThis->Spinlock);
     180        IPRT_LINUX_RESTORE_EFL_ONLY_AC();
     181    }
    172182#ifdef CONFIG_PROVE_LOCKING
    173183    lockdep_on();

  • trunk/src/VBox/Runtime/r0drv/linux/the-linux-kernel.h

    r56290 r57276  
    386386# include <iprt/asm-amd64-x86.h>
    387387# define IPRT_X86_EFL_AC                    RT_BIT(18)
    388 # define IPRT_LINUX_SAVE_EFL_AC()           RTCCUINTREG fSavedEfl = ASMGetFlags();
     388# define IPRT_LINUX_SAVE_EFL_AC()           RTCCUINTREG fSavedEfl = ASMGetFlags()
    389389# define IPRT_LINUX_RESTORE_EFL_AC()        ASMSetFlags(fSavedEfl)
    390390# define IPRT_LINUX_RESTORE_EFL_ONLY_AC()   ASMSetFlags((ASMGetFlags() & ~IPRT_X86_EFL_AC) | (fSavedEfl & IPRT_X86_EFL_AC))

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

    r55861 r57276  
    6060static int rtR0ThreadLnxSleepCommon(RTMSINTERVAL cMillies)
    6161{
     62    IPRT_LINUX_SAVE_EFL_AC();
    6263    long cJiffies = msecs_to_jiffies(cMillies);
    6364    set_current_state(TASK_INTERRUPTIBLE);
    6465    cJiffies = schedule_timeout(cJiffies);
     66    IPRT_LINUX_RESTORE_EFL_AC();
    6567    if (!cJiffies)
    6668        return VINF_SUCCESS;
    … …  
    8587RTDECL(bool) RTThreadYield(void)
    8688{
     89    IPRT_LINUX_SAVE_EFL_AC();
    8790#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 20)
    8891    yield();
    … …  
    9396    schedule();
    9497#endif
     98    IPRT_LINUX_RESTORE_EFL_AC();
    9599    return true;
    96100}

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

    r56290 r57276  
    138138#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 4)
    139139    struct task_struct *NativeThread;
     140    IPRT_LINUX_SAVE_EFL_AC();
    140141
    141142    RT_ASSERT_PREEMPTIBLE();
    … …  
    143144    NativeThread = kthread_run(rtThreadNativeMain, pThreadInt, "iprt-%s", pThreadInt->szName);
    144145
    145     if (IS_ERR(NativeThread))
    146         return VERR_GENERAL_FAILURE;
    147 
    148     *pNativeThread = (RTNATIVETHREAD)NativeThread;
    149     return VINF_SUCCESS;
     146    if (!IS_ERR(NativeThread))
     147    {
     148        *pNativeThread = (RTNATIVETHREAD)NativeThread;
     149        IPRT_LINUX_RESTORE_EFL_AC();
     150        return VINF_SUCCESS;
     151    }
     152    IPRT_LINUX_RESTORE_EFL_AC();
     153    return VERR_GENERAL_FAILURE;
    150154#else
    151155    return VERR_NOT_IMPLEMENTED;

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

    r56955 r57276  
    167167RTDECL(int) RTThreadCtxHookCreate(PRTTHREADCTXHOOK phCtxHook, uint32_t fFlags, PFNRTTHREADCTXHOOK pfnCallback, void *pvUser)
    168168{
     169    IPRT_LINUX_SAVE_EFL_AC();
     170
    169171    /*
    170172     * Validate input.
    … …  
    181183    pThis = (PRTTHREADCTXHOOKINT)RTMemAllocZ(sizeof(*pThis));
    182184    if (RT_UNLIKELY(!pThis))
     185    {
     186        IPRT_LINUX_RESTORE_EFL_AC();
    183187        return VERR_NO_MEMORY;
     188    }
    184189    pThis->u32Magic     = RTTHREADCTXHOOKINT_MAGIC;
    185190    pThis->hOwner       = RTThreadNativeSelf();
    … …  
    196201
    197202    *phCtxHook = pThis;
     203    IPRT_LINUX_RESTORE_EFL_AC();
    198204    return VINF_SUCCESS;
    199205}
    … …  
    203209RTDECL(int ) RTThreadCtxHookDestroy(RTTHREADCTXHOOK hCtxHook)
    204210{
     211    IPRT_LINUX_SAVE_EFL_AC();
     212
    205213    /*
    206214     * Validate input.
    … …  
    232240    RTMemFree(pThis);
    233241
     242    IPRT_LINUX_RESTORE_EFL_AC();
    234243    return VINF_SUCCESS;
    235244}
    … …  
    250259    if (!pThis->fEnabled)
    251260    {
     261        IPRT_LINUX_SAVE_EFL_AC();
    252262        Assert(pThis->PreemptOps.sched_out == rtThreadCtxHooksLnxSchedOut);
    253263        Assert(pThis->PreemptOps.sched_in == rtThreadCtxHooksLnxSchedIn);
    … …  
    260270        preempt_notifier_register(&pThis->LnxPreemptNotifier);
    261271        preempt_enable();
     272
     273        IPRT_LINUX_RESTORE_EFL_AC();
    262274    }
    263275
    … …  
    284296         */
    285297        if (pThis->fEnabled)
     298        {
     299            IPRT_LINUX_SAVE_EFL_AC();
    286300            rtThreadCtxHookDisable(pThis);
     301            IPRT_LINUX_RESTORE_EFL_AC();
     302        }
    287303    }
    288304    return VINF_SUCCESS;

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

    r56290 r57276  
    170170RTDECL(PRTTIMESPEC) RTTimeNow(PRTTIMESPEC pTime)
    171171{
     172    IPRT_LINUX_SAVE_EFL_AC();
    172173#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 16)
    173174    struct timespec Ts;
    174175    ktime_get_real_ts(&Ts);
     176    IPRT_LINUX_RESTORE_EFL_AC();
    175177    return RTTimeSpecSetTimespec(pTime, &Ts);
    176178
    … …  
    178180    struct timeval Tv;
    179181    do_gettimeofday(&Tv);
     182    IPRT_LINUX_RESTORE_EFL_AC();
    180183    return RTTimeSpecSetTimeval(pTime, &Tv);
    181184#endif

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

    r56290 r57276  
    11861186    RTTIMERLINUXSTARTONCPUARGS Args;
    11871187    int rc2;
     1188    IPRT_LINUX_SAVE_EFL_AC();
    11881189
    11891190    /*
    … …  
    12031204     */
    12041205    if (pTimer->fAllCpus)
    1205         return rtTimerLnxOmniStart(pTimer, &Args);
     1206    {
     1207        rc2 = rtTimerLnxOmniStart(pTimer, &Args);
     1208        IPRT_LINUX_RESTORE_EFL_AC();
     1209        return rc2;
     1210    }
    12061211#endif
    12071212
    … …  
    12341239                        }
    12351240                    }
     1241                    IPRT_LINUX_RESTORE_EFL_AC();
    12361242                    return VINF_SUCCESS;
    12371243                }
    … …  
    12431249                {
    12441250                    ASMAtomicWriteBool(&pTimer->fSuspended, false);
     1251                    IPRT_LINUX_RESTORE_EFL_AC();
    12451252                    return VINF_SUCCESS;
    12461253                }
    … …  
    12491256            default:
    12501257                AssertMsgFailed(("%d\n", enmState));
     1258                IPRT_LINUX_RESTORE_EFL_AC();
    12511259                return VERR_INTERNAL_ERROR_4;
    12521260        }
    … …  
    13291337     * Validate.
    13301338     */
     1339    IPRT_LINUX_SAVE_EFL_AC();
    13311340    AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
    13321341    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
    … …  
    13371346
    13381347    rtTimerLnxStop(pTimer, false /*fForDestroy*/);
     1348
     1349    IPRT_LINUX_RESTORE_EFL_AC();
    13391350    return VINF_SUCCESS;
    13401351}
    … …  
    13461357    unsigned long cJiffies;
    13471358    unsigned long flFlags;
     1359    IPRT_LINUX_SAVE_EFL_AC();
    13481360
    13491361    /*
    … …  
    13651377    {
    13661378        ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
     1379        IPRT_LINUX_RESTORE_EFL_AC();
    13671380        return VINF_SUCCESS;
    13681381    }
    … …  
    13851398    ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
    13861399    spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
     1400    IPRT_LINUX_RESTORE_EFL_AC();
    13871401    return VINF_SUCCESS;
    13881402}
    … …  
    13931407{
    13941408    bool fCanDestroy;
     1409    IPRT_LINUX_SAVE_EFL_AC();
    13951410
    13961411    /*
    … …  
    14601475    }
    14611476
     1477    IPRT_LINUX_RESTORE_EFL_AC();
    14621478    return VINF_SUCCESS;
    14631479}
    … …  
    14711487    unsigned    cCpus;
    14721488    int         rc;
     1489    IPRT_LINUX_SAVE_EFL_AC();
    14731490
    14741491    rtR0LnxWorkqueueFlush();                /* for 2.4 */
    … …  
    14791496     */
    14801497    if (!RTTIMER_FLAGS_ARE_VALID(fFlags))
     1498    {
     1499        IPRT_LINUX_RESTORE_EFL_AC();
    14811500        return VERR_INVALID_PARAMETER;
     1501    }
    14821502    if (    (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
    14831503        &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
    14841504        &&  !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
     1505    {
     1506        IPRT_LINUX_RESTORE_EFL_AC();
    14851507        return VERR_CPU_NOT_FOUND;
     1508    }
    14861509
    14871510    /*
    … …  
    14941517        cCpus = RTMpGetMaxCpuId() + 1;
    14951518        Assert(cCpus <= RTCPUSET_MAX_CPUS); /* On linux we have a 1:1 relationship between cpuid and set index. */
    1496         AssertReturn(u64NanoInterval, VERR_NOT_IMPLEMENTED); /* We don't implement single shot on all cpus, sorry. */
     1519        AssertReturnStmt(u64NanoInterval, IPRT_LINUX_RESTORE_EFL_AC(), VERR_NOT_IMPLEMENTED); /* We don't implement single shot on all cpus, sorry. */
    14971520    }
    14981521#endif
    … …  
    15011524                      RTMEMALLOCEX_FLAGS_ZEROED | RTMEMALLOCEX_FLAGS_ANY_CTX_FREE, (void **)&pTimer);
    15021525    if (RT_FAILURE(rc))
     1526    {
     1527        IPRT_LINUX_RESTORE_EFL_AC();
    15031528        return rc;
     1529    }
    15041530
    15051531    /*
    … …  
    15681594        {
    15691595            RTTimerDestroy(pTimer);
     1596            IPRT_LINUX_RESTORE_EFL_AC();
    15701597            return rc;
    15711598        }
    … …  
    15751602    RTTIMERLNX_LOG(("create %p hires=%d fFlags=%#x cCpus=%u\n", pTimer, pTimer->fHighRes, fFlags, cCpus));
    15761603    *ppTimer = pTimer;
     1604    IPRT_LINUX_RESTORE_EFL_AC();
    15771605    return VINF_SUCCESS;
    15781606}
    … …  
    15851613       *        querying the resolution of the high res timers? */
    15861614    struct timespec Ts;
    1587     int rc = hrtimer_get_res(CLOCK_MONOTONIC, &Ts);
     1615    int rc;
     1616    IPRT_LINUX_SAVE_EFL_AC();
     1617    rc = hrtimer_get_res(CLOCK_MONOTONIC, &Ts);
     1618    IPRT_LINUX_RESTORE_EFL_AC();
    15881619    if (!rc)
    15891620    {
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