Ticket #4224: haiku_mlock_map_locked_and_private_area.diff

headers/os/kernel/OS.h

@@ -79 +79 @@
 /* area protection */
 #define B_READ_AREA             1
 #define B_WRITE_AREA            2
+#define B_PRIVATE_AREA          0x8000
 
 extern area_id      create_area(const char *name, void **startAddress,
                         uint32 addressSpec, size_t size, uint32 lock,

headers/posix/sys/mman.h

@@ -22 +22 @@
 #define MAP_FIXED       0x04            /* require mapping to specified addr */
 #define MAP_ANONYMOUS   0x08            /* no underlying object */
 #define MAP_ANON        MAP_ANONYMOUS
+#define MAP_LOCKED      0x2000          /* memory is locked into RAM */
 
 /* mmap() error return code */
 #define MAP_FAILED      ((void*)-1)
@@ -50 +51 @@
 
 int     posix_madvise(void* address, size_t length, int advice);
 
+int     mlock(const void *address, size_t length);
+int     munlock(const void *address, size_t length);
+
 int     shm_open(const char* name, int openMode, mode_t permissions);
 int     shm_unlink(const char* name);
 

headers/private/kernel/vm.h

@@ -131 +131 @@
             int protection);
 status_t _user_sync_memory(void *address, size_t size, int flags);
 status_t _user_memory_advice(void* address, size_t size, int advice);
+status_t _user_lock_memory(void *address, size_t size, uint32 flags);
+status_t _user_unlock_memory(void *address, size_t size, uint32 flags);
 
 area_id _user_area_for(void *address);
 area_id _user_find_area(const char *name);

headers/private/system/syscalls.h

@@ -393 +393 @@
 extern status_t     _kern_sync_memory(void *address, size_t size, int flags);
 extern status_t     _kern_memory_advice(void *address, size_t size,
                         int advice);
+extern status_t     _kern_lock_memory(void *address, size_t size, uint32 flags);
+extern status_t     _kern_unlock_memory(void *address, size_t size, uint32 flags);
 
 /* kernel port functions */
 extern port_id      _kern_create_port(int32 queue_length, const char *name);

headers/private/system/vm_defs.h

@@ -27 +27 @@
 #define B_KERNEL_STACK_AREA     0x80
 
 #define B_USER_PROTECTION \
-    (B_READ_AREA | B_WRITE_AREA | B_EXECUTE_AREA | B_STACK_AREA)
+    (B_READ_AREA | B_WRITE_AREA | B_EXECUTE_AREA | B_STACK_AREA | B_PRIVATE_AREA)
 #define B_KERNEL_PROTECTION \
     (B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA | B_KERNEL_EXECUTE_AREA \
     | B_KERNEL_STACK_AREA)

src/system/kernel/vm/vm.cpp

@@ -2264 +2264 @@
     TRACE(("_vm_map_file(fd = %d, offset = %Ld, size = %lu, mapping %ld)\n",
         fd, offset, size, mapping));
 
+    uint32 lock = (mapping & MAP_LOCKED) ? B_FULL_LOCK : B_NO_LOCK;
+    mapping &= ~MAP_LOCKED;
+
     offset = ROUNDDOWN(offset, B_PAGE_SIZE);
     size = PAGE_ALIGN(size);
 
     if (mapping == REGION_NO_PRIVATE_MAP)
         protection |= B_SHARED_AREA;
+    else if (mapping == REGION_PRIVATE_MAP)
+        protection |= B_PRIVATE_AREA;
     if (addressSpec != B_EXACT_ADDRESS)
         unmapAddressRange = false;
 
     if (fd < 0) {
         uint32 flags = unmapAddressRange ? CREATE_AREA_UNMAP_ADDRESS_RANGE : 0;
         return vm_create_anonymous_area(team, name, _address, addressSpec, size,
-            B_NO_LOCK, protection, 0, flags, kernel);
+            lock, protection, 0, flags, kernel);
     }
 
     // get the open flags of the FD
@@ -2439 +2444 @@
         if (status != B_OK)
             return status;
 
-        if (!kernel && (sourceArea->protection & B_KERNEL_AREA) != 0)
+        if (!kernel && (sourceArea->protection & (B_KERNEL_AREA | B_PRIVATE_AREA)) != 0)
             return B_NOT_ALLOWED;
 
         sourceArea->protection |= B_SHARED_AREA;
@@ -6443 +6448 @@
     // TODO: Implement!
     return B_OK;
 }
+
+status_t
+_user_lock_memory(void* _address, size_t size, uint32 flags)
+{
+    addr_t address = (addr_t)_address;
+
+    // check params
+    if (size == 0 || (addr_t)address + size < (addr_t)address || (address % B_PAGE_SIZE) != 0)
+        return B_BAD_VALUE;
+
+    if (!IS_USER_ADDRESS(address) || !IS_USER_ADDRESS((addr_t)address + size))
+        return B_BAD_ADDRESS;
+
+    // lock
+    return lock_memory(_address, size, flags);
+}
+
+status_t
+_user_unlock_memory(void* _address, size_t size, uint32 flags)
+{
+    addr_t address = (addr_t)_address;
+
+    // check params
+    if (size == 0 || (addr_t)address + size < (addr_t)address || (address % B_PAGE_SIZE) != 0)
+        return B_BAD_VALUE;
+
+    if (!IS_USER_ADDRESS(address) || !IS_USER_ADDRESS((addr_t)address + size))
+        return B_BAD_ADDRESS;
+
+    // lock
+    return unlock_memory(_address, size, flags);
+}

src/system/libroot/posix/sys/mman.cpp

@@ -110 +110 @@
     // translate mapping, address specification, and protection
     int mapping = (flags & MAP_SHARED) != 0
         ? REGION_NO_PRIVATE_MAP : REGION_PRIVATE_MAP;
+    mapping |= (flags & MAP_LOCKED);
 
     uint32 addressSpec = B_ANY_ADDRESS;
     if ((flags & MAP_FIXED) != 0)
@@ -165 +166 @@
 
 
 int
+mlock(const void *address, size_t length)
+{
+    void *_address = const_cast<void*>(address);
+    RETURN_AND_SET_ERRNO(_kern_lock_memory(_address, length, 0));
+}
+
+int
+munlock(const void *address, size_t length)
+{
+    void *_address = const_cast<void*>(address);
+    RETURN_AND_SET_ERRNO(_kern_unlock_memory(_address, length, 0));
+}
+
+
+int
 shm_open(const char* name, int openMode, mode_t permissions)
 {
     char path[PATH_MAX];