VirtualBox

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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