VirtualBox

Changeset 23610 in vbox


Ignore:
Timestamp:
Oct 7, 2009 9:22:10 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
53284
Message:

IPRT,VMM,SUPDrv,VBGLR0: Added a parameter to RTR0MemObjLockUser/Kernel that indicates read/write intent so we can correctly lock readonly memory on Windows and OS/2. (Guest property strings, see #4238.)

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/memobj.h

    r20525 r23610  
    146146 * @returns IPRT status code.
    147147 * @param   pMemObj         Where to store the ring-0 memory object handle.
    148  * @param   R3Ptr           User virtual address. This is rounded down to a page boundrary.
    149  * @param   cb              Number of bytes to lock. This is rounded up to nearest page boundrary.
    150  * @param   R0Process       The process to lock pages in. NIL_R0PROCESS is an alias for the current one.
    151  *
    152  * @remarks RTR0MemGetAddressR3() and RTR0MemGetAddress() will return the rounded
     148 * @param   R3Ptr           User virtual address. This is rounded down to a page
     149 *                          boundrary.
     150 * @param   cb              Number of bytes to lock. This is rounded up to
     151 *                          nearest page boundrary.
     152 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     153 *                          and RTMEM_PROT_WRITE.
     154 * @param   R0Process       The process to lock pages in. NIL_R0PROCESS is an
     155 *                          alias for the current one.
     156 *
     157 * @remarks RTR0MemGetAddressR3() and RTR0MemGetAddress() will return therounded
    153158 *          down address.
     159 *
    154160 * @remarks Linux: This API requires that the memory begin locked is in a memory
    155161 *          mapping that is not required in any forked off child process. This
    … …  
    157163 *          lifting it.
    158164 */
    159 RTR0DECL(int) RTR0MemObjLockUser(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process);
     165RTR0DECL(int) RTR0MemObjLockUser(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process);
    160166
    161167/**
    … …  
    166172 * @param   pv              Kernel virtual address. This is rounded down to a page boundrary.
    167173 * @param   cb              Number of bytes to lock. This is rounded up to nearest page boundrary.
     174 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     175 *                          and RTMEM_PROT_WRITE.
    168176 *
    169177 * @remark  RTR0MemGetAddress() will return the rounded down address.
    170178 */
    171 RTR0DECL(int) RTR0MemObjLockKernel(PRTR0MEMOBJ pMemObj, void *pv, size_t cb);
     179RTR0DECL(int) RTR0MemObjLockKernel(PRTR0MEMOBJ pMemObj, void *pv, size_t cb, uint32_t fAccess);
    172180
    173181/**

  • trunk/src/VBox/Additions/common/VBoxGuestLib/HGCMInternal.cpp

    r21778 r23610  
    4747/** Linux needs to use bounce buffers since RTR0MemObjLockUser has unwanted
    4848 *  side effects. */
    49 # define USE_BOUNCH_BUFFERS
     49# define USE_BOUNCE_BUFFERS
    5050#endif
    5151
    … …  
    6464        uint32_t    iParm;
    6565        RTR0MEMOBJ  hObj;
    66 #ifdef USE_BOUNCH_BUFFERS
     66#ifdef USE_BOUNCE_BUFFERS
    6767        void       *pvSmallBuf;
    6868#endif
    … …  
    274274                if (cb != 0)
    275275                {
    276 #ifdef USE_BOUNCH_BUFFERS
     276#ifdef USE_BOUNCE_BUFFERS
    277277                    void       *pvSmallBuf = NULL;
    278278#endif
    … …  
    280280                    RTR0MEMOBJ  hObj;
    281281                    int         rc;
     282                    uint32_t    fAccess =    pSrcParm->type == VMMDevHGCMParmType_LinAddr_In
     283                                          || pSrcParm->type == VMMDevHGCMParmType_LinAddr_Locked_In
     284                                        ? RTMEM_PROT_READ
     285                                        : RTMEM_PROT_READ | RTMEM_PROT_WRITE;
    282286
    283287                    AssertReturn(iLockBuf < RT_ELEMENTS(pParmInfo->aLockBufs), VERR_INVALID_PARAMETER);
    … …  
    286290                        AssertMsgReturn(cb <= VBGLR0_MAX_HGCM_KERNEL_PARM, ("%#x > %#x\n", cb, VBGLR0_MAX_HGCM_KERNEL_PARM),
    287291                                        VERR_OUT_OF_RANGE);
    288                         rc = RTR0MemObjLockKernel(&hObj, (void *)pSrcParm->u.Pointer.u.linearAddr, cb);
     292                        rc = RTR0MemObjLockKernel(&hObj, (void *)pSrcParm->u.Pointer.u.linearAddr, cb, fAccess);
    289293                        if (RT_FAILURE(rc))
    290294                        {
    … …  
    306310                        }
    307311
    308 #ifndef USE_BOUNCH_BUFFERS
    309                         rc = RTR0MemObjLockUser(&hObj, (RTR3PTR)pSrcParm->u.Pointer.u.linearAddr, cb, NIL_RTR0PROCESS);
     312#ifndef USE_BOUNCE_BUFFERS
     313                        rc = RTR0MemObjLockUser(&hObj, (RTR3PTR)pSrcParm->u.Pointer.u.linearAddr, cb, fAccess, NIL_RTR0PROCESS);
    310314                        if (RT_FAILURE(rc))
    311315                        {
    … …  
    317321                              iParm, pSrcParm->type, cb, pSrcParm->u.Pointer.u.linearAddr, hObj));
    318322
    319 #else  /* USE_BOUNCH_BUFFERS */
     323#else  /* USE_BOUNCE_BUFFERS */
    320324                        /*
    321325                         * This is a bit massive, but we don't want to waste a
    … …  
    347351                                }
    348352                            }
    349                             rc = RTR0MemObjLockKernel(&hObj, pvSmallBuf, cb);
     353                            rc = RTR0MemObjLockKernel(&hObj, pvSmallBuf, cb, fAccess);
    350354                            if (RT_FAILURE(rc))
    351355                            {
    … …  
    380384                                  iParm, pSrcParm->type, cb, pSrcParm->u.Pointer.u.linearAddr, hObj));
    381385                        }
    382 #endif /* USE_BOUNCH_BUFFERS */
     386#endif /* USE_BOUNCE_BUFFERS */
    383387                    }
    384388
    385389                    pParmInfo->aLockBufs[iLockBuf].iParm      = iParm;
    386390                    pParmInfo->aLockBufs[iLockBuf].hObj       = hObj;
    387 #ifdef USE_BOUNCH_BUFFERS
     391#ifdef USE_BOUNCE_BUFFERS
    388392                    pParmInfo->aLockBufs[iLockBuf].pvSmallBuf = pvSmallBuf;
    389393#endif
    … …  
    541545                if (pSrcParm->u.Pointer.size != 0)
    542546                {
    543 #ifdef USE_BOUNCH_BUFFERS
     547#ifdef USE_BOUNCE_BUFFERS
    544548                    void      *pvSmallBuf = pParmInfo->aLockBufs[iLockBuf].pvSmallBuf;
    545549#endif
    … …  
    557561                        pDstParm->u.PageList.offset = offExtra;
    558562                        pDstPgLst->flags            = vbglR0HGCMInternalLinAddrTypeToPageListFlags(pSrcParm->type);
    559 #ifdef USE_BOUNCH_BUFFERS
     563#ifdef USE_BOUNCE_BUFFERS
    560564                        if (fIsUser)
    561565                            pDstPgLst->offFirstPage = (uintptr_t)pvSmallBuf & PAGE_OFFSET_MASK;
    … …  
    576580                        pDstParm->type = vbglR0HGCMInternalConvertLinAddrType(pSrcParm->type);
    577581                        pDstParm->u.Pointer.size = pSrcParm->u.Pointer.size;
    578 #ifdef USE_BOUNCH_BUFFERS
     582#ifdef USE_BOUNCE_BUFFERS
    579583                        if (fIsUser)
    580584                            pDstParm->u.Pointer.u.linearAddr = pvSmallBuf
    … …  
    749753    HGCMFunctionParameter       *pDstParm = VBOXGUEST_HGCM_CALL_PARMS(pCallInfo);
    750754    uint32_t    cParms   = pCallInfo->cParms;
    751 #ifdef USE_BOUNCH_BUFFERS
     755#ifdef USE_BOUNCE_BUFFERS
    752756    uint32_t    iLockBuf = 0;
    753757#endif
    … …  
    777781            case VMMDevHGCMParmType_LinAddr_Locked_In:
    778782            case VMMDevHGCMParmType_LinAddr_In:
    779 #ifdef USE_BOUNCH_BUFFERS
     783#ifdef USE_BOUNCE_BUFFERS
    780784                if (    fIsUser
    781785                    &&  iLockBuf < pParmInfo->cLockBufs
    … …  
    798802            case VMMDevHGCMParmType_LinAddr:
    799803            {
    800 #ifdef USE_BOUNCH_BUFFERS
     804#ifdef USE_BOUNCE_BUFFERS
    801805                if (fIsUser)
    802806                {
    … …  
    830834    }
    831835
    832 #ifdef USE_BOUNCH_BUFFERS
     836#ifdef USE_BOUNCE_BUFFERS
    833837    Assert(!fIsUser || pParmInfo->cLockBufs == iLockBuf);
    834838#endif
    … …  
    904908        {
    905909            RTR0MemObjFree(ParmInfo.aLockBufs[ParmInfo.cLockBufs].hObj, false /*fFreeMappings*/);
    906 #ifdef USE_BOUNCH_BUFFERS
     910#ifdef USE_BOUNCE_BUFFERS
    907911            RTMemTmpFree(ParmInfo.aLockBufs[ParmInfo.cLockBufs].pvSmallBuf);
    908912#endif

  • trunk/src/VBox/Additions/common/VBoxGuestLib/SysHlp.cpp

    r21412 r23610  
    100100     *       know they aren't pagable.
    101101     */
    102     RTR0MEMOBJ MemObj = NIL_RTR0MEMOBJ;
     102    RTR0MEMOBJ  MemObj = NIL_RTR0MEMOBJ;
     103    uint32_t    fAccess = RTMEM_PROT_READ | (fWriteAccess ? RTMEM_PROT_WRITE : 0);
    103104    if ((fFlags & VBGLR0_HGCMCALL_F_MODE_MASK) == VBGLR0_HGCMCALL_F_USER)
    104         rc = RTR0MemObjLockUser(&MemObj, (RTR3PTR)pv, u32Size, NIL_RTR0PROCESS);
     105        rc = RTR0MemObjLockUser(&MemObj, (RTR3PTR)pv, u32Size, fAccess, NIL_RTR0PROCESS);
    105106    else
    106         rc = RTR0MemObjLockKernel(&MemObj, pv, u32Size);
     107        rc = RTR0MemObjLockKernel(&MemObj, pv, u32Size, fAccess);
    107108    if (RT_SUCCESS(rc))
    108109        *ppvCtx = MemObj;

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

    r22615 r23610  
    203203DECLASM(int)    UNWIND_WRAP(RTR0MemObjAllocCont)(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable);
    204204DECLASM(int)    UNWIND_WRAP(RTR0MemObjEnterPhys)(PRTR0MEMOBJ pMemObj, RTHCPHYS Phys, size_t cb);
    205 DECLASM(int)    UNWIND_WRAP(RTR0MemObjLockUser)(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process);
     205DECLASM(int)    UNWIND_WRAP(RTR0MemObjLockUser)(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, uint32_t fFlags, RTR0PROCESS R0Process);
    206206DECLASM(int)    UNWIND_WRAP(RTR0MemObjMapKernel)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt);
    207207DECLASM(int)    UNWIND_WRAP(RTR0MemObjMapKernelEx)(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt, size_t offSub, size_t cbSub);
    … …  
    23212321     */
    23222322    Mem.eType = MEMREF_TYPE_LOCKED;
    2323     rc = RTR0MemObjLockUser(&Mem.MemObj, pvR3, cb, RTR0ProcHandleSelf());
     2323    rc = RTR0MemObjLockUser(&Mem.MemObj, pvR3, cb, RTMEM_PROT_READ | RTMEM_PROT_WRITE, RTR0ProcHandleSelf());
    23242324    if (RT_SUCCESS(rc))
    23252325    {

  • trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

    r22615 r23610  
    197197 *          - Nothing.
    198198 */
    199 #define SUPDRV_IOC_VERSION                              0x000f0000
     199#define SUPDRV_IOC_VERSION                              0x00100000
    200200
    201201/** SUP_IOCTL_COOKIE. */

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

    r22615 r23610  
    272272        strcpy(CookieReq.u.In.szMagic, SUPCOOKIE_MAGIC);
    273273        CookieReq.u.In.u32ReqVersion = SUPDRV_IOC_VERSION;
    274         const uint32_t MinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x000f0000
    275                                   ?  0x000f0000
    276                                   :  SUPDRV_IOC_VERSION & 0xffff0000;
    277         CookieReq.u.In.u32MinVersion = MinVersion;
     274        const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x00100000
     275                                   ?  0x00100000
     276                                   :  SUPDRV_IOC_VERSION & 0xffff0000;
     277        CookieReq.u.In.u32MinVersion = uMinVersion;
    278278        rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_COOKIE, &CookieReq, SUP_IOCTL_COOKIE_SIZE);
    279279        if (    RT_SUCCESS(rc)
    … …  
    281281        {
    282282            if (    (CookieReq.u.Out.u32SessionVersion & 0xffff0000) == (SUPDRV_IOC_VERSION & 0xffff0000)
    283                 &&  CookieReq.u.Out.u32SessionVersion >= MinVersion)
     283                &&  CookieReq.u.Out.u32SessionVersion >= uMinVersion)
    284284            {
    285285                /*
    … …  
    348348            {
    349349                LogRel(("Support driver version mismatch: SessionVersion=%#x DriverVersion=%#x ClientVersion=%#x MinVersion=%#x\n",
    350                         CookieReq.u.Out.u32SessionVersion, CookieReq.u.Out.u32DriverVersion, SUPDRV_IOC_VERSION, MinVersion));
     350                        CookieReq.u.Out.u32SessionVersion, CookieReq.u.Out.u32DriverVersion, SUPDRV_IOC_VERSION, uMinVersion));
    351351                rc = VERR_VM_DRIVER_VERSION_MISMATCH;
    352352            }

  • trunk/src/VBox/HostDrivers/Support/win/SUPDrvA-win.asm

    r22077 r23610  
    9999NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjAllocCont
    100100NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjEnterPhys
    101 NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTR0MemObjLockUser
     101NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, RTR0MemObjLockUser
    102102NtWrapDyn2DrvFunctionWith5Params       supdrvNtWrap, RTR0MemObjMapKernel
    103103NtWrapDyn2DrvFunctionWith7Params       supdrvNtWrap, RTR0MemObjMapKernelEx

  • trunk/src/VBox/Runtime/include/internal/memobj.h

    r20525 r23610  
    335335 * @param   R3Ptr           User virtual address, page aligned.
    336336 * @param   cb              Number of bytes to lock, page aligned.
     337 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     338 *                          and RTMEM_PROT_WRITE.
    337339 * @param   R0Process       The process to lock pages in.
    338340 */
    339 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process);
     341int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process);
    340342
    341343/**
    … …  
    346348 * @param   pv              Kernel virtual address, page aligned.
    347349 * @param   cb              Number of bytes to lock, page aligned.
    348  */
    349 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb);
     350 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     351 *                          and RTMEM_PROT_WRITE.
     352 */
     353int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess);
    350354
    351355/**

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

    r22069 r23610  
    655655 * @return IPRT status code.
    656656 *
    657  * @param ppMem     Where to store the memory object pointer.
    658  * @param pv        First page.
    659  * @param cb        Number of bytes.
    660  * @param Task      The task \a pv and \a cb refers to.
     657 * @param   ppMem           Where to store the memory object pointer.
     658 * @param   pv              First page.
     659 * @param   cb              Number of bytes.
     660 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     661 *                          and RTMEM_PROT_WRITE.
     662 * @param   Task            The task \a pv and \a cb refers to.
    661663 */
    662 static int rtR0MemObjNativeLock(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, task_t Task)
    663 {
     664static int rtR0MemObjNativeLock(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess, task_t Task)
     665{
     666    NOREF(fAccess);
    664667#ifdef USE_VM_MAP_WIRE
    665668    vm_map_t Map = get_task_map(Task);
    … …  
    729732
    730733
    731 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
    732 {
    733     return rtR0MemObjNativeLock(ppMem, (void *)R3Ptr, cb, (task_t)R0Process);
    734 }
    735 
    736 
    737 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
    738 {
    739     return rtR0MemObjNativeLock(ppMem, pv, cb, kernel_task);
     734int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
     735{
     736    return rtR0MemObjNativeLock(ppMem, (void *)R3Ptr, cb, fAccess, (task_t)R0Process);
     737}
     738
     739
     740int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
     741{
     742    return rtR0MemObjNativeLock(ppMem, pv, cb, fAccess, kernel_task);
    740743}
    741744

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

    r22574 r23610  
    378378
    379379
    380 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     380int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    381381{
    382382    int rc;
     383    NOREF(fAccess);
    383384
    384385    /* create the object. */
    … …  
    406407
    407408
    408 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
     409int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
    409410{
    410411    int rc;
     412    NOREF(fAccess);
    411413
    412414    /* create the object. */

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

    r22680 r23610  
    734734
    735735
    736 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     736int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    737737{
    738738    const int cPages = cb >> PAGE_SHIFT;
    … …  
    741741    PRTR0MEMOBJLNX pMemLnx;
    742742    int rc = VERR_NO_MEMORY;
     743    NOREF(fAccess);
    743744
    744745    /*
    … …  
    830831
    831832
    832 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
     833int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fFlags)
    833834{
    834835    void           *pvLast = (uint8_t *)pv + cb - 1;
    … …  
    839840    uint8_t        *pbPage;
    840841    size_t          iPage;
     842    NOREF(fAccess);
    841843
    842844    /*

  • trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp

    r22052 r23610  
    492492 * @returns IPRT status code.
    493493 * @param   pMemObj         Where to store the ring-0 memory object handle.
    494  * @param   R3Ptr           User virtual address. This is rounded down to a page boundrary.
    495  * @param   cb              Number of bytes to lock. This is rounded up to nearest page boundrary.
    496  * @param   R0Process       The process to lock pages in. NIL_R0PROCESS is an alias for the current one.
     494 * @param   R3Ptr           User virtual address. This is rounded down to a page
     495 *                          boundrary.
     496 * @param   cb              Number of bytes to lock. This is rounded up to
     497 *                          nearest page boundrary.
     498 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     499 *                          and RTMEM_PROT_WRITE.
     500 * @param   R0Process       The process to lock pages in. NIL_R0PROCESS is an
     501 *                          alias for the current one.
    497502 *
    498503 * @remarks RTR0MemGetAddressR3() and RTR0MemGetAddress() will return therounded
    … …  
    504509 *          lifting it.
    505510 */
    506 RTR0DECL(int) RTR0MemObjLockUser(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     511RTR0DECL(int) RTR0MemObjLockUser(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    507512{
    508513    /* sanity checks. */
    … …  
    515520    if (R0Process == NIL_RTR0PROCESS)
    516521        R0Process = RTR0ProcHandleSelf();
     522    AssertReturn(!(fAccess & ~(RTMEM_PROT_READ | RTMEM_PROT_WRITE)), VERR_INVALID_PARAMETER);
     523    AssertReturn(fAccess, VERR_INVALID_PARAMETER);
    517524    RT_ASSERT_PREEMPTIBLE();
    518525
    519526    /* do the locking. */
    520     return rtR0MemObjNativeLockUser(pMemObj, R3PtrAligned, cbAligned, R0Process);
     527    return rtR0MemObjNativeLockUser(pMemObj, R3PtrAligned, cbAligned, fAccess, R0Process);
    521528}
    522529RT_EXPORT_SYMBOL(RTR0MemObjLockUser);
    … …  
    530537 * @param   pv              Kernel virtual address. This is rounded down to a page boundrary.
    531538 * @param   cb              Number of bytes to lock. This is rounded up to nearest page boundrary.
     539 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     540 *                          and RTMEM_PROT_WRITE.
    532541 *
    533542 * @remark  RTR0MemGetAddress() will return the rounded down address.
    534543 */
    535 RTR0DECL(int) RTR0MemObjLockKernel(PRTR0MEMOBJ pMemObj, void *pv, size_t cb)
     544RTR0DECL(int) RTR0MemObjLockKernel(PRTR0MEMOBJ pMemObj, void *pv, size_t cb, uint32_t fAccess)
    536545{
    537546    /* sanity checks. */
    … …  
    543552    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    544553    AssertPtrReturn(pvAligned, VERR_INVALID_POINTER);
     554    AssertReturn(!(fAccess & ~(RTMEM_PROT_READ | RTMEM_PROT_WRITE)), VERR_INVALID_PARAMETER);
     555    AssertReturn(fAccess, VERR_INVALID_PARAMETER);
    545556    RT_ASSERT_PREEMPTIBLE();
    546557
    547558    /* do the allocation. */
    548     return rtR0MemObjNativeLockKernel(pMemObj, pvAligned, cbAligned);
     559    return rtR0MemObjNativeLockKernel(pMemObj, pvAligned, cbAligned, fAccess);
    549560}
    550561RT_EXPORT_SYMBOL(RTR0MemObjLockKernel);

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

    r23065 r23610  
    501501 * @return IPRT status code.
    502502 *
    503  * @param ppMem     Where to store the memory object pointer.
    504  * @param pv        First page.
    505  * @param cb        Number of bytes.
    506  * @param R0Process The process \a pv and \a cb refers to.
     503 * @param   ppMem           Where to store the memory object pointer.
     504 * @param   pv              First page.
     505 * @param   cb              Number of bytes.
     506 * @param   fAccess         The desired access, a combination of RTMEM_PROT_READ
     507 *                          and RTMEM_PROT_WRITE.
     508 * @param   R0Process       The process \a pv and \a cb refers to.
    507509 */
    508 static int rtR0MemObjNtLock(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, RTR0PROCESS R0Process)
     510static int rtR0MemObjNtLock(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    509511{
    510512    /*
    … …  
    549551        __try
    550552        {
    551             MmProbeAndLockPages(pMdl, R0Process == NIL_RTR0PROCESS ? KernelMode : UserMode, IoModifyAccess);
     553            MmProbeAndLockPages(pMdl,
     554                                R0Process == NIL_RTR0PROCESS ? KernelMode : UserMode,
     555                                fAccess == RTMEM_PROT_READ
     556                                ? IoReadAccess
     557                                : fAccess == RTMEM_PROT_WRITE
     558                                ? IoWriteAccess
     559                                : IoModifyAccess);
    552560
    553561            pMemNt->apMdls[iMdl] = pMdl;
    … …  
    561569        }
    562570
    563         if (R0Process != NIL_RTR0PROCESS )
     571        if (R0Process != NIL_RTR0PROCESS)
    564572        {
    565573            /* Make sure the user process can't change the allocation. */
    566             pMemNt->pvSecureMem = MmSecureVirtualMemory(pv, cb, PAGE_READWRITE);
     574            pMemNt->pvSecureMem = MmSecureVirtualMemory(pv, cb,
     575                                                        fAccess & RTMEM_PROT_WRITE
     576                                                        ? PAGE_READWRITE
     577                                                        : PAGE_READONLY);
    567578            if (!pMemNt->pvSecureMem)
    568579            {
    … …  
    604615
    605616
    606 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     617int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    607618{
    608619    AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
    609620    /* (Can use MmProbeAndLockProcessPages if we need to mess with other processes later.) */
    610     return rtR0MemObjNtLock(ppMem, (void *)R3Ptr, cb, R0Process);
    611 }
    612 
    613 
    614 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
    615 {
    616     return rtR0MemObjNtLock(ppMem, pv, cb, NIL_RTR0PROCESS);
     621    return rtR0MemObjNtLock(ppMem, (void *)R3Ptr, cb, fAccess, R0Process);
     622}
     623
     624
     625int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
     626{
     627    return rtR0MemObjNtLock(ppMem, pv, cb, fAccess, NIL_RTR0PROCESS);
    617628}
    618629

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

    r21497 r23610  
    242242
    243243
    244 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     244int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    245245{
    246246    AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
    … …  
    254254    /* lock it. */
    255255    ULONG cPagesRet = cPages;
    256     int rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE, (void *)R3Ptr, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
     256    int rc = KernVMLock(VMDHL_LONG | (fAccess & RTMEM_PROT_WRITE ? VMDHL_WRITE : 0),
     257                        (void *)R3Ptr, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
    257258    if (!rc)
    258259    {
    … …  
    269270
    270271
    271 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
     272int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
    272273{
    273274    /* create the object. */
    … …  
    279280    /* lock it. */
    280281    ULONG cPagesRet = cPages;
    281     int rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE, pv, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
     282    int rc = KernVMLock(VMDHL_LONG | (fAccess & RTMEM_PROT_WRITE ? VMDHL_WRITE : 0),
     283                        pv, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
    282284    if (!rc)
    283285    {

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

    r22073 r23610  
    272272
    273273
    274 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     274int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    275275{
    276276    AssertReturn(R0Process == RTR0ProcHandleSelf(), VERR_INVALID_PARAMETER);
     277    NOREF(fAccess);
    277278
    278279    /* Create the locking object */
    … …  
    306307
    307308
    308 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
    309 {
     309int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
     310{
     311    NOREF(fAccess);
     312
    310313    /* Create the locking object */
    311314    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_LOCK, pv, cb);

  • trunk/src/VBox/Runtime/r0drv/solaris/vbi/memobj-r0drv-solaris.c

    r22073 r23610  
    213213
    214214
    215 int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
     215int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process)
    216216{
    217217    AssertReturn(R0Process == RTR0ProcHandleSelf(), VERR_INVALID_PARAMETER);
     218    NOREF(fAccess);
    218219
    219220    /* Create the locking object */
    … …  
    239240
    240241
    241 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
    242 {
     242int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess)
     243{
     244    NOREF(fAccess);
     245
    243246    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_LOCK, pv, cb);
    244247    if (!pMemSolaris)

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

    r20900 r23610  
    31053105     */
    31063106    RTR0MEMOBJ MemObj;
    3107     rc = RTR0MemObjLockUser(&MemObj, pvR3, GMM_CHUNK_SIZE, NIL_RTR0PROCESS);
     3107    rc = RTR0MemObjLockUser(&MemObj, pvR3, GMM_CHUNK_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
    31083108    if (RT_SUCCESS(rc))
    31093109    {
Note: See TracChangeset for help on using the changeset viewer.

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