Changeset 20525 in vbox for trunk

Timestamp:

Jun 13, 2009 8:13:33 PM (15 years ago)

Author:

vboxsync

Message:

iprt/memobj.h: Added RTR0MemObjProtect, only implemented for darwin.

Location:

trunk

Files:

• include/iprt/memobj.h (modified) (1 diff)
• src/VBox/Runtime/include/internal/memobj.h (modified) (4 diffs)
• src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp (modified) (2 diffs)
• src/VBox/Runtime/r0drv/darwin/the-darwin-kernel.h (modified) (2 diffs)
• src/VBox/Runtime/r0drv/freebsd/memobj-r0drv-freebsd.c (modified) (1 diff)
• src/VBox/Runtime/r0drv/linux/memobj-r0drv-linux.c (modified) (2 diffs)
• src/VBox/Runtime/r0drv/memobj-r0drv.cpp (modified) (4 diffs)
• src/VBox/Runtime/r0drv/nt/memobj-r0drv-nt.cpp (modified) (1 diff)
• src/VBox/Runtime/r0drv/os2/memobj-r0drv-os2.cpp (modified) (1 diff)
• src/VBox/Runtime/r0drv/solaris/memobj-r0drv-solaris.c (modified) (1 diff)
• src/VBox/Runtime/r0drv/solaris/vbi/memobj-r0drv-solaris.c (modified) (1 diff)

trunk/include/iprt/memobj.h

@@ -300 +300 @@
 RTR0DECL(int) RTR0MemObjMapUser(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process);
 
+/**
+ * Change the page level protection of one or more pages in a memory object.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_NOT_SUPPORTED if the OS doesn't provide any way to manipulate
+ *          page level protection. The caller must handle this status code
+ *          gracefully. (Note that it may also occur if the implementation is
+ *          missing, in which case just go ahead and implement it.)
+ *
+ * @param   hMemObj         Memory object handle.
+ * @param   offSub          Offset into the memory object. Must be page aligned.
+ * @param   cbSub           Number of bytes to change the protection of. Must be
+ *                          page aligned.
+ * @param   fProt           Combination of RTMEM_PROT_* flags.
+ */
+RTR0DECL(int) RTR0MemObjProtect(RTR0MEMOBJ hMemObj, size_t offSub, size_t cbSub, uint32_t fProt);
+
 #endif /* IN_RING0 */
 

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

@@ -90 +90 @@
 
 
+/** @name RTR0MEMOBJINTERNAL::fFlags
+ * @{ */
+/** Page level protection was changed. */
+#define RTR0MEMOBJ_FLAGS_PROT_CHANGED       RT_BIT_32(0)
+/** @} */
+
+
 typedef struct RTR0MEMOBJINTERNAL *PRTR0MEMOBJINTERNAL;
 typedef struct RTR0MEMOBJINTERNAL **PPRTR0MEMOBJINTERNAL;
@@ -111 +118 @@
     /** The type of allocation. */
     RTR0MEMOBJTYPE  enmType;
+    /** Flags, RTR0MEMOBJ_FLAGS_*. */
+    uint32_t        fFlags;
     /** The size of the memory allocated, pinned down, or mapped. */
     size_t          cb;
@@ -222 +231 @@
     {
         case RTR0MEMOBJTYPE_MAPPING:
+            return true;
+
+        default:
+            return false;
+    }
+}
+
+
+/**
+ * Checks page level protection can be changed on this object.
+ *
+ * @returns true / false.
+ * @param   pMem        The ring-0 memory object handle.
+ */
+DECLINLINE(bool) rtR0MemObjIsProtectable(PRTR0MEMOBJINTERNAL pMem)
+{
+    switch (pMem->enmType)
+    {
+        case RTR0MEMOBJTYPE_MAPPING:
+        case RTR0MEMOBJTYPE_PAGE:
+        case RTR0MEMOBJTYPE_LOW:
+        case RTR0MEMOBJTYPE_CONT:
             return true;
 
@@ -411 +442 @@
 
 /**
+ * Change the page level protection of one or more pages in a memory object.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_NOT_SUPPORTED see RTR0MemObjProtect.
+ *
+ * @param   pMem            The memory object.
+ * @param   offSub          Offset into the memory object. Page aligned.
+ * @param   cbSub           Number of bytes to change the protection of. Page
+ *                          aligned.
+ * @param   fProt           Combination of RTMEM_PROT_* flags.
+ */
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt);
+
+/**
  * Get the physical address of an page in the memory object.
  *

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

@@ -92 +92 @@
     }
 }
+
+
+/**
+ * Gets the virtual memory map the specified object is mapped into.
+ *
+ * @returns VM map handle on success, NULL if no map.
+ * @param   pMem                The memory object.
+ */
+DECLINLINE(vm_map_t) rtR0MemObjDarwinGetMap(PRTR0MEMOBJINTERNAL pMem)
+{
+    switch (pMem->enmType)
+    {
+        case RTR0MEMOBJTYPE_PAGE:
+        case RTR0MEMOBJTYPE_LOW:
+        case RTR0MEMOBJTYPE_CONT:
+            return kernel_map;
+
+        case RTR0MEMOBJTYPE_PHYS:
+        case RTR0MEMOBJTYPE_PHYS_NC:
+            return NULL; /* pretend these have no mapping atm. */
+
+        case RTR0MEMOBJTYPE_LOCK:
+            return pMem->u.Lock.R0Process == NIL_RTR0PROCESS
+                ? kernel_map
+                : get_task_map((task_t)pMem->u.Lock.R0Process);
+
+        case RTR0MEMOBJTYPE_RES_VIRT:
+            return pMem->u.ResVirt.R0Process == NIL_RTR0PROCESS
+                ? kernel_map
+                : get_task_map((task_t)pMem->u.ResVirt.R0Process);
+
+        case RTR0MEMOBJTYPE_MAPPING:
+            return pMem->u.Mapping.R0Process == NIL_RTR0PROCESS
+                ? kernel_map
+                : get_task_map((task_t)pMem->u.Mapping.R0Process);
+
+        default:
+            return NULL;
+    }
+}
+
+#if 0 /* not necessary after all*/
+/* My vm_map mockup. */
+struct my_vm_map
+{
+    struct { char pad[8]; } lock;
+    struct my_vm_map_header
+    {
+        struct vm_map_links
+        {
+            void            *prev;
+            void            *next;
+            vm_map_offset_t start;
+            vm_map_offset_t end;
+        }                   links;
+        int                 nentries;
+        boolean_t           entries_pageable;
+    }                       hdr;
+    pmap_t                  pmap;
+    vm_map_size_t           size;
+};
+
+
+/**
+ * Gets the minimum map address, this is similar to get_map_min.
+ *
+ * @returns The start address of the map.
+ * @param   pMap                The map.
+ */
+static vm_map_offset_t rtR0MemObjDarwinGetMapMin(vm_map_t pMap)
+{
+    /* lazy discovery of the correct offset. The apple guys is a wonderfully secretive bunch. */
+    static int32_t volatile s_offAdjust = INT32_MAX;
+    int32_t                 off         = s_offAdjust;
+    if (off == INT32_MAX)
+    {
+        for (off = 0; ; off += sizeof(pmap_t))
+        {
+            if (*(pmap_t *)((uint8_t *)kernel_map + off) == kernel_pmap)
+                break;
+            AssertReturn(off <= RT_MAX(RT_OFFSETOF(struct my_vm_map, pmap) * 4, 1024), 0x1000);
+        }
+        ASMAtomicWriteS32(&s_offAdjust, off - RT_OFFSETOF(struct my_vm_map, pmap));
+    }
+
+    /* calculate it. */
+    struct my_vm_map *pMyMap = (struct my_vm_map *)((uint8_t *)pMap + off);
+    return pMyMap->hdr.links.start;
+}
+#endif /* unused */
 
 #ifdef RT_STRICT
@@ -813 +903 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    /* Get the map for the object. */
+    vm_map_t pVmMap = rtR0MemObjDarwinGetMap(pMem);
+    if (!pVmMap)
+        return VERR_NOT_SUPPORTED;
+
+    /* Convert the protection. */
+    vm_prot_t fMachProt;
+    switch (fProt)
+    {
+        case RTMEM_PROT_NONE:
+            fMachProt = VM_PROT_NONE;
+            break;
+        case RTMEM_PROT_READ:
+            fMachProt = VM_PROT_READ;
+            break;
+        case RTMEM_PROT_READ | RTMEM_PROT_WRITE:
+            fMachProt = VM_PROT_READ | VM_PROT_WRITE;
+            break;
+        case RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC:
+            fMachProt = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
+            break;
+        case RTMEM_PROT_WRITE | RTMEM_PROT_EXEC:
+            fMachProt = VM_PROT_WRITE | VM_PROT_EXECUTE;
+            break;
+        case RTMEM_PROT_EXEC:
+            fMachProt = VM_PROT_EXECUTE;
+            break;
+        default:
+            AssertFailedReturn(VERR_INVALID_PARAMETER);
+    }
+
+    /* do the job. */
+    vm_offset_t Start = (uintptr_t)pMem->pv + offSub;
+    kern_return_t krc = vm_protect(pVmMap,
+                                   Start,
+                                   cbSub,
+                                   false,
+                                   fMachProt);
+    if (krc != KERN_SUCCESS)
+        return RTErrConvertFromDarwinKern(krc);
+    return VINF_SUCCESS;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {

trunk/src/VBox/Runtime/r0drv/darwin/the-darwin-kernel.h

@@ -88 +88 @@
 
 RT_C_DECLS_BEGIN
+
 /* mach/vm_types.h */
 typedef struct pmap *pmap_t;
@@ -116 +117 @@
 /* osfmk/i386/cpu_number.h */
 extern int cpu_number(void);
+
+/* osfmk/vm/vm_user.c */
+extern kern_return_t vm_protect(vm_map_t, vm_offset_t, vm_size_t, boolean_t, vm_prot_t);
 
 /* i386/machine_routines.h */

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

@@ -682 +682 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    NOREF(pMem);
+    NOREF(offSub);
+    NOREF(cbSub);
+    NOREF(fProt);
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {

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

@@ -39 +39 @@
 #include <iprt/assert.h>
 #include <iprt/log.h>
+#include <iprt/process.h>
 #include <iprt/string.h>
-#include <iprt/process.h>
 #include "internal/memobj.h"
 
@@ -1166 +1166 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    NOREF(pMem);
+    NOREF(offSub);
+    NOREF(cbSub);
+    NOREF(fProt);
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {

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

@@ -35 +35 @@
 #define LOG_GROUP RTLOGGROUP_DEFAULT ///@todo RTLOGGROUP_MEM
 #include <iprt/memobj.h>
+
 #include <iprt/alloc.h>
-#include <iprt/process.h>
+#include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/err.h>
 #include <iprt/log.h>
 #include <iprt/param.h>
+#include <iprt/process.h>
+
 #include "internal/memobj.h"
 
@@ -72 +75 @@
         pNew->cbSelf    = (uint32_t)cbSelf;
         pNew->enmType   = enmType;
+        pNew->fFlags    = 0;
         pNew->cb        = cb;
         pNew->pv        = pv;
@@ -90 +94 @@
     if (pMem)
     {
-        pMem->u32Magic++;
+        ASMAtomicUoWriteU32(&pMem->u32Magic, ~RTR0MEMOBJ_MAGIC);
         pMem->enmType = RTR0MEMOBJTYPE_END;
         RTMemFree(pMem);
@@ -818 +822 @@
 }
 
+
+RTR0DECL(int) RTR0MemObjProtect(RTR0MEMOBJ hMemObj, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    PRTR0MEMOBJINTERNAL pMemObj;
+    int                 rc;
+
+    /* sanity checks. */
+    pMemObj = (PRTR0MEMOBJINTERNAL)hMemObj;
+    AssertPtrReturn(pMemObj, VERR_INVALID_HANDLE);
+    AssertReturn(pMemObj->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(pMemObj->enmType > RTR0MEMOBJTYPE_INVALID && pMemObj->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
+    AssertReturn(rtR0MemObjIsProtectable(pMemObj), VERR_INVALID_PARAMETER);
+    AssertReturn(!(offSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
+    AssertReturn(offSub < pMemObj->cb, VERR_INVALID_PARAMETER);
+    AssertReturn(!(cbSub  & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
+    AssertReturn(cbSub <= pMemObj->cb, VERR_INVALID_PARAMETER);
+    AssertReturn(offSub + cbSub <= pMemObj->cb, VERR_INVALID_PARAMETER);
+    AssertReturn(!(fProt & ~(RTMEM_PROT_NONE | RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC)), VERR_INVALID_PARAMETER);
+
+    /* do the job */
+    rc = rtR0MemObjNativeProtect(pMemObj, offSub, cbSub, fProt);
+    if (RT_SUCCESS(rc))
+        pMemObj->fFlags |= RTR0MEMOBJ_FLAGS_PROT_CHANGED; /* record it */
+
+    return rc;
+}

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

@@ -761 +761 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    NOREF(pMem);
+    NOREF(offSub);
+    NOREF(cbSub);
+    NOREF(fProt);
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {

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

@@ -468 +468 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    NOREF(pMem);
+    NOREF(offSub);
+    NOREF(cbSub);
+    NOREF(fProt);
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {

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

@@ -401 +401 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    NOREF(pMem);
+    NOREF(offSub);
+    NOREF(cbSub);
+    NOREF(fProt);
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {

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

@@ -323 +323 @@
 
 
+int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
+{
+    NOREF(pMem);
+    NOREF(offSub);
+    NOREF(cbSub);
+    NOREF(fProt);
+    return VERR_NOT_SUPPORTED;
+}
+
+
 RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
 {