Ticket #2657: draft-shm-001.patch

new file headers/posix/sys/shm.h

@@ +1 @@
+/*
+ * Copyright 2010 Haiku Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _SYS_SHM_H
+#define _SYS_SHM_H
+
+
+#include <sys/ipc.h>
+#include <sys/types.h>
+
+#define SHMLBA      1024
+
+/* Message Flags */
+#define SHM_RDONLY  01000   /* attach read-only (else read-write) */
+#define SHM_RND     02000   /* rounds attach address to SHMLBA */
+
+typedef unsigned long shmatt_t;
+
+struct shmid_ds {
+    struct ipc_perm shm_perm;
+    size_t      shm_segsz;
+    pid_t       shm_lpid;
+    pid_t       shm_cpid;
+    shmatt_t    shm_nattch;
+    time_t      shm_atime;
+    time_t      shm_dtime;
+    time_t      shm_ctime;
+};
+
+
+__BEGIN_DECLS
+
+void*   shmat(int, const void *, int);
+int shmctl(int, int, struct shmid_ds *);
+int shmdt(const void *);
+int shmget(key_t, size_t, int);
+
+__END_DECLS
+
+#endif  /* _SYS_SHM_H */

new file headers/private/kernel/posix/xsi_shared_memory.h

@@ +1 @@
+/*
+ * Copyright 2010, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef KERNEL_XSI_SHARED_MEMORY_H
+#define KERNEL_XSI_SHARED_MEMORY_H
+
+#include <sys/shm.h>
+#include <sys/cdefs.h>
+
+#include <OS.h>
+
+#include <kernel.h>
+
+
+__BEGIN_DECLS
+
+extern void xsi_shm_init();
+
+/* user calls */
+status_t    _user_xsi_shmat(int, const void*, int, void**);
+int _user_xsi_shmctl(int, int, struct shmid_ds *);
+int _user_xsi_shmdt(const void *);
+int _user_xsi_shmget(key_t key, size_t size, int flags);
+
+__END_DECLS
+
+#endif  /* KERNEL_XSI_SHARED_MEMORY_H */

headers/private/system/syscalls.h

@@ -35 +35 @@
 struct sembuf;
 union semun;
 struct sigaction;
+struct shmid_ds;
 struct stat;
 struct system_profiler_parameters;
 
@@ -125 +126 @@
                         const void *messagePointer, size_t messageSize,
                         int messageFlags);
 
+/* POSIX XSI shared memory syscalls */
+extern status_t     _kern_xsi_shmat(int a, const void* memoryPointer, int b, void **addr);
+extern int      _kern_xsi_shmctl(int a, int b, struct shmid_ds *memoryDs);
+extern int      _kern_xsi_shmdt(const void *memoryPointer);
+extern int      _kern_xsi_shmget(key_t key, size_t size, int flags);
+
 /* team & thread syscalls */
 extern thread_id    _kern_load_image(const char* const* flatArgs,
                         size_t flatArgsSize, int32 argCount, int32 envCount,

src/system/kernel/main.cpp

@@ -42 +42 @@
 #include <posix/realtime_sem.h>
 #include <posix/xsi_message_queue.h>
 #include <posix/xsi_semaphore.h>
+#include <posix/xsi_shared_memory.h>
 #include <real_time_clock.h>
 #include <sem.h>
 #include <smp.h>
@@ -190 +191 @@
         realtime_sem_init();
         xsi_sem_init();
         xsi_msg_init();
+        xsi_shm_init();
 
         // Start a thread to finish initializing the rest of the system. Note,
         // it won't be scheduled before calling scheduler_start() (on any CPU).

src/system/kernel/posix/Jamfile

@@ -6 +6 @@
     realtime_sem.cpp
     xsi_message_queue.cpp
     xsi_semaphore.cpp
+    xsi_shared_memory.cpp
 
     : $(TARGET_KERNEL_PIC_CCFLAGS)
 ;

new file src/system/kernel/posix/xsi_shared_memory.cpp

@@ +1 @@
+/*
+ * Copyright 2011, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      David Höppner <0xffea@gmail.com>
+ */
+
+#include <posix/xsi_shared_memory.h>
+
+#include <stdio.h>
+
+#include <sys/ipc.h>
+#include <sys/types.h>
+
+#include <kernel/lock.h>
+#include <kernel/debug.h>
+#include <kernel/team.h>
+#include <kernel/thread.h>
+
+#include <vm/vm.h>
+#include <vm/VMAddressSpace.h>
+#include <vm/VMArea.h>
+
+#include <util/AutoLock.h>
+#include <util/DoublyLinkedList.h>
+#include <util/OpenHashTable.h>
+
+
+#define TRACE_XSI_SHM
+#ifdef TRACE_XSI_SHM
+#   define TRACE(x)     dprintf x
+#else
+#   define TRACE(x)     /* nothing */
+#endif
+
+#define MAX_XSI_SHARED_MEMORY_COUNT 64
+#define MIN_XSI_SHARED_MEMORY_SIZE  1
+#define MAX_XSI_SHARED_MEMORY_SIZE  256*1024*1024
+#define MAX_XSI_SHARED_MEMORY_ATTACH    128
+
+static mutex sXsiSharedMemoryLock = MUTEX_INITIALIZER("Global Shared Memory Lock");
+static int sSharedMemoryCount = 0;
+static int sNextEntryID = 0;
+
+struct SharedMemoryKey : DoublyLinkedListLinkImpl<SharedMemoryKey> {
+    SharedMemoryKey(key_t key, int id, size_t size)
+        :
+        key(key),
+        id(id),
+        size(size)
+    {
+    }
+
+    key_t   key;
+    int id;
+    size_t  size;
+};
+
+typedef DoublyLinkedList<SharedMemoryKey> SharedMemoryKeyList;
+static SharedMemoryKeyList sSharedMemoryKeys;
+
+
+class SharedMemoryEntry {
+public:
+    SharedMemoryEntry(key_t key, size_t size, int flags)
+        :
+        fKey(key),
+        fSize(size),
+        fKeyLink(NULL)
+    {
+        fDs.shm_segsz = fSize;
+
+        fDs.shm_cpid = getpid();
+        fDs.shm_lpid = fDs.shm_nattch = 0;
+        fDs.shm_atime = fDs.shm_dtime = 0;
+        fDs.shm_ctime = real_time_clock();
+
+        fDs.shm_perm.uid = fDs.shm_perm.cuid = geteuid();
+        fDs.shm_perm.gid = fDs.shm_perm.cgid = getegid();
+        fDs.shm_perm.mode = (flags & 0x01ff);
+    }
+
+    status_t Init()
+    {
+        char    areaName[B_OS_NAME_LENGTH];
+        addr_t  dummy;
+
+        fId = sNextEntryID;
+
+        snprintf(areaName, B_OS_NAME_LENGTH, "xsi_shared_memory%d", (int) fId);
+
+        virtual_address_restrictions virtualRestrictions = {};
+        virtualRestrictions.address_specification = B_ANY_KERNEL_ADDRESS;
+        physical_address_restrictions physicalRestrictions = {};
+        fArea = vm_create_anonymous_area(B_SYSTEM_TEAM, areaName, fSize, B_FULL_LOCK,
+            B_KERNEL_AREA_FLAGS, 0, &virtualRestrictions, &physicalRestrictions,
+            true, (void **) &dummy);
+
+        if (fArea < B_OK) {
+            TRACE(("xsi_shmget: create area failed!\n"));
+            return B_NO_MEMORY;
+        }
+
+        memset((void*)dummy, 0, fSize);
+
+        atomic_add(&sNextEntryID, 1);
+        atomic_add(&sSharedMemoryCount, 1);
+
+        return B_OK;
+    }
+
+    ~SharedMemoryEntry()
+    {
+        status_t status;
+
+        status = vm_delete_area(B_SYSTEM_TEAM, fArea, true);
+        if (status < B_OK)
+            TRACE(("shmctl: failed to delete area %d\n", (int) fArea));
+
+        atomic_add(&sSharedMemoryCount, -1);
+    }
+
+    void SetKey()
+    {
+        fKey = sNextEntryID;
+    }
+
+    void SetKeyLink(SharedMemoryKey* key)
+    {
+        fKeyLink = key;
+    }
+
+    bool HasPermission() const
+    {
+
+        uid_t uid = geteuid();
+        if (uid == 0 ||
+            uid == fDs.shm_perm.uid ||
+            uid == fDs.shm_perm.cuid)
+            return true;
+
+        return false;
+    }
+
+    bool HasReadPermission() const
+    {
+        if (fDs.shm_perm.mode & S_IROTH)
+            return true;
+
+        uid_t uid = geteuid();
+        if (uid == 0 || (uid == fDs.shm_perm.uid
+            && (fDs.shm_perm.mode & S_IRUSR) != 0))
+            return true;
+
+                gid_t gid = getegid();
+                if (uid == 0 || (gid == fDs.shm_perm.gid
+                        && (fDs.shm_perm.mode & S_IRGRP) != 0))
+                        return true;
+
+        return false;
+    }
+
+    int Id() const
+    {
+        return fId;
+    }
+
+    key_t Key() const
+    {
+        return fKey;
+    }
+
+    area_id Area() const
+    {
+        return fArea;
+    }
+
+    size_t Size() const
+    {
+        return fSize;
+    }
+
+    SharedMemoryKey* KeyLink() const
+    {
+        return fKeyLink;
+    }
+
+    struct shmid_ds* GetDs()
+    {
+        return &fDs;
+    }    
+
+    SharedMemoryEntry*& Link()
+    {
+        return fLink;
+    }
+
+private:
+    int         fId;
+    key_t           fKey;
+    area_id         fArea;
+    size_t          fSize;
+    SharedMemoryKey*    fKeyLink;
+    SharedMemoryEntry*  fLink;
+    struct shmid_ds     fDs;
+};
+
+struct XsiSharedMemoryEntryHashTableDefinition {
+    typedef int         KeyType;
+    typedef SharedMemoryEntry   ValueType;
+
+    size_t HashKey (const int id) const
+    {
+        return (size_t)(id);
+    }
+
+    size_t Hash(SharedMemoryEntry* variable) const
+    {
+        return (size_t) HashKey(variable->Id());
+    }
+
+    bool Compare(const int id, SharedMemoryEntry* variable) const
+    {
+        return (int) id == (int) variable->Id();
+    }
+
+    SharedMemoryEntry*& GetLink(SharedMemoryEntry* variable) const
+    {
+        return variable->Link();
+    }
+};
+
+static BOpenHashTable<XsiSharedMemoryEntryHashTableDefinition> sSharedMemoryEntryTable;
+
+
+void
+xsi_shm_init()
+{
+    status_t status;
+
+    status = sSharedMemoryEntryTable.Init();
+    if (status != B_OK) {
+        panic("xsi_shm_init(): Failed to initialize shared memory hash table!\n");
+    }
+
+    new(&sSharedMemoryKeys) SharedMemoryKeyList;
+}
+
+status_t
+_user_xsi_shmat(int id, const void *addr, int flags, void **raddr)
+{
+    SharedMemoryEntry* entry;
+    struct shmid_ds* mds;
+    struct area_info info;
+    void* address;
+    uint32 addressSpec = B_ANY_ADDRESS;
+    area_id area;
+    int protection = B_READ_AREA | B_WRITE_AREA;
+
+    TRACE(("shmat: id = %d, addr = %p, flags = %d\n",
+        id, addr, flags));
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    entry = sSharedMemoryEntryTable.Lookup(id);
+    if (entry == NULL)
+        return EINVAL;
+
+
+    mds = entry->GetDs();
+    if (mds->shm_nattch >= MAX_XSI_SHARED_MEMORY_ATTACH)
+        return EMFILE;
+
+    if (flags & SHM_RDONLY)
+        protection &= ~B_WRITE_AREA;
+
+    if (addr != NULL) {
+        if (flags & SHM_RND) {
+            // TODO address = (void *) (addr - ((uintptr_t) addr % SHMLBA));
+            return EINVAL;
+        } else {
+            if (!IS_USER_ADDRESS(addr))
+                return B_BAD_ADDRESS;
+
+            address = (void *) addr;
+            addressSpec = B_EXACT_ADDRESS;
+        }
+
+        if (!IS_USER_ADDRESS(address))
+            return B_BAD_ADDRESS;
+    }
+
+    get_area_info(entry->Area(), &info);
+    area = vm_clone_area(VMAddressSpace::CurrentID(), info.name, &address, addressSpec,
+            protection, REGION_NO_PRIVATE_MAP, entry->Area(), false);
+
+    if (area < B_OK)
+        return area;
+
+    mds->shm_atime = real_time_clock();
+    mds->shm_nattch++;
+
+    *raddr = address;
+
+    return B_OK;
+}
+
+int
+_user_xsi_shmctl(int id, int cmd, struct shmid_ds* buffer)
+{
+    SharedMemoryEntry *entry;
+    struct shmid_ds* mds;
+    status_t status;
+
+    TRACE(("shmctl: id = %d, cmd = %d\n", id, cmd));
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    entry = sSharedMemoryEntryTable.Lookup(id);
+    if (entry == NULL)
+        return EINVAL;
+
+    switch(cmd) {
+        case IPC_STAT:
+            if (!entry->HasReadPermission())
+                return EACCES;
+
+            if (!IS_USER_ADDRESS(buffer))
+                return B_BAD_ADDRESS;
+
+            // TODO: EOVERFLOW
+            mds = (struct shmid_ds*)entry->GetDs();
+            status = user_memcpy(buffer, (const void*) mds, sizeof(struct shmid_ds));
+            if (status < B_OK) {
+                return B_BAD_ADDRESS;
+            }
+            break;
+        case IPC_SET:
+            if (!entry->HasPermission())
+                return EPERM;
+
+            if (!IS_USER_ADDRESS(buffer))
+                return B_BAD_ADDRESS;
+
+            mds = entry->GetDs();
+            status = user_memcpy(mds, buffer, sizeof(struct shmid_ds));
+            if (status < B_OK)
+                return B_BAD_ADDRESS;
+
+            break;
+        case IPC_RMID:
+            if (!entry->HasPermission())
+                return EPERM;
+
+            sSharedMemoryKeys.Remove(entry->KeyLink());
+            sSharedMemoryEntryTable.Remove(entry);
+            delete entry;
+
+            break;
+        default:
+            return EINVAL;
+    }
+
+    return B_OK;
+}
+
+int
+_user_xsi_shmdt(const void *address)
+{
+    area_id     area;
+    status_t    status;
+
+    TRACE(("xsi_shmdt: %p\n", address));
+
+    area = area_for((void*)address);
+    if (area == B_ERROR)
+        return EINVAL;
+
+    status = vm_delete_area(VMAddressSpace::CurrentID(), area, true);
+    if (status < B_OK) {
+        return EINVAL;
+    }
+
+    MutexLocker _(sXsiSharedMemoryLock);
+    // TODO nattch
+    
+    return B_OK;
+}
+
+int
+_user_xsi_shmget(key_t key, size_t size, int flags)
+{
+    SharedMemoryEntry* entry;
+    SharedMemoryKey* keyEntry = NULL;
+    status_t status;
+
+    TRACE(("shmget: key = %d, size = %d, flags = %d\n",
+        (int) key, (int) size, flags));
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    if (key != IPC_PRIVATE) {
+        SharedMemoryKeyList::Iterator it = sSharedMemoryKeys.GetIterator();
+
+        while (it.HasNext()) {
+            keyEntry = it.Next();
+
+            if (keyEntry->key == key) {
+                if ((flags & IPC_CREAT) && (flags & IPC_EXCL))
+                    return EEXIST;
+
+                if (keyEntry->size < size && size != 0)
+                    return EINVAL;
+
+                return keyEntry->id;
+            }
+        }
+
+        if (!(flags & IPC_CREAT))
+            return ENOENT;
+    }
+
+        if (size < MIN_XSI_SHARED_MEMORY_SIZE ||
+                size > MAX_XSI_SHARED_MEMORY_SIZE)
+                return EINVAL;
+
+    if (sSharedMemoryCount > MAX_XSI_SHARED_MEMORY_COUNT)
+        return ENOSPC;
+
+    entry = new (std::nothrow) SharedMemoryEntry(key, size, flags);
+    if (entry == NULL)
+        return ENOMEM;
+
+
+    status = entry->Init();
+    if (status < B_OK) {
+        delete entry;
+        return status;
+    }
+
+    if (key != IPC_PRIVATE) {
+        keyEntry = new(std::nothrow) SharedMemoryKey(key, entry->Id(), size);
+        if (keyEntry == NULL) {
+            delete entry;
+            return ENOMEM;
+        }
+
+        sSharedMemoryKeys.Add(keyEntry);
+        entry->SetKeyLink(keyEntry);
+    }
+
+    sSharedMemoryEntryTable.Insert(entry);
+
+    return entry->Id();
+}

src/system/kernel/syscalls.cpp

@@ -38 +38 @@
 #include <posix/realtime_sem.h>
 #include <posix/xsi_message_queue.h>
 #include <posix/xsi_semaphore.h>
+#include <posix/xsi_shared_memory.h>
 #include <real_time_clock.h>
 #include <safemode.h>
 #include <sem.h>

src/system/libroot/posix/sys/Jamfile

@@ -26 +26 @@
     wait.c
     xsi_msg_queue.cpp
     xsi_sem.cpp
+    xsi_shm.cpp
 ;

new file src/system/libroot/posix/sys/xsi_shm.cpp

@@ +1 @@
+/*
+ * Copyright 2010, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      David Höppner <0xffea@gmail.com>
+ */
+
+#include <errno.h>
+
+#include <sys/shm.h>
+
+#include <syscall_utils.h>
+#include <syscalls.h>
+
+
+void *
+shmat(int key, const void *address, int flags)
+{
+    status_t status;
+    void *addr;
+
+    status = _kern_xsi_shmat(key, address, flags, &addr);
+    if (status < 0) {
+        errno = status;
+        return (void *) -1;
+    }
+
+    return (void *) addr;
+}
+
+int
+shmctl(int id, int cmd, struct shmid_ds *buffer)
+{
+    RETURN_AND_SET_ERRNO(_kern_xsi_shmctl(id, cmd, buffer));
+}
+
+int
+shmdt(const void *address)
+{
+    RETURN_AND_SET_ERRNO(_kern_xsi_shmdt(address));
+}
+
+int
+shmget(key_t key, size_t size, int flags)
+{
+    RETURN_AND_SET_ERRNO(_kern_xsi_shmget(key, size, flags));
+}

src/tests/system/libroot/posix/Jamfile

@@ -33 +33 @@
 # XSI tests
 SimpleTest xsi_msg_queue_test1 : xsi_msg_queue_test1.cpp ;
 SimpleTest xsi_sem_test1 : xsi_sem_test1.cpp ;
+SimpleTest xsi_shm_test1 : xsi_shm_test1.cpp ;
 
 # wide character tests
 SimpleTest mbtest : mbtest.c ;

new file src/tests/system/libroot/posix/xsi_shm_test1.cpp

@@ +1 @@
+/*
+ * Copyright 2008-2011, Haiku Inc. All rights reserved. 
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Salvatore Benedetto <salvatore.benedetto@gmail.com>
+ *      David Höppner <0xffea@gmail.com>
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/shm.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <time.h>
+
+#include <OS.h>
+
+#include "TestUnitUtils.h"
+
+#define KEY     ((key_t)12345)
+#define SHM_SIZE    16*1024*1024
+
+static void
+test_shmget()
+{
+    TEST_SET("shmget({IPC_PRIVATE, key})");
+
+    const char* currentTest = NULL;
+
+    // Open private set with IPC_PRIVATE
+    TEST("shmget(IPC_PRIVATE) - private");
+    int shmID = shmget(IPC_PRIVATE, SHM_SIZE, S_IRUSR | S_IWUSR);
+    assert_posix_bool_success(shmID != -1);
+
+    // Destroy private memory entry
+    TEST("shmctl(IPC_RMID) - private");
+    status_t status = shmctl(shmID, IPC_RMID, NULL);
+    assert_posix_bool_success(status != -1);
+
+    // Open non-private non-existing set with IPC_CREAT
+    TEST("shmget(KEY, IPC_CREAT) non-existing");
+    shmID = shmget(KEY, SHM_SIZE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
+        | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    assert_posix_bool_success(status != -1);
+
+    // Re-open non-private existing with greater size 
+    TEST("shmget(KEY) re-open existing without IPC_CREAT");
+    int returnID = shmget(KEY, SHM_SIZE+1, 0);
+    assert_posix_bool_success(errno == EINVAL);
+
+    // Re-open non-private existing without IPC_CREAT
+    TEST("shmget(KEY) re-open existing without IPC_CREAT");
+    returnID = shmget(KEY, SHM_SIZE, 0);
+    assert_equals(shmID, returnID);
+
+    // Re-open non-private existing with IPC_CREAT
+    TEST("shmget(IPC_CREATE) re-open existing with IPC_CREAT");
+    returnID = shmget(KEY, SHM_SIZE, IPC_CREAT | IPC_EXCL);
+    assert_posix_bool_success(errno == EEXIST);
+
+    // Destroy non-private 
+    TEST("shmctl(IPC_RMID)");
+    status = shmctl(shmID, IPC_RMID, NULL);
+    assert_posix_bool_success(status != -1);
+
+    // Open non-private non-existing without IPC_CREAT
+    TEST("shmget(IPC_CREATE) non-existing without IPC_CREAT");
+    shmID = shmget(KEY, SHM_SIZE, IPC_EXCL | S_IRUSR | S_IWUSR
+        | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    assert_posix_bool_success(errno == ENOENT);
+
+    // Destroy non-existing
+    TEST("shmctl()");
+    status = shmctl(shmID, IPC_RMID, NULL);
+    assert_posix_bool_success(errno == EINVAL);
+
+    TEST("done");
+}
+
+
+int
+main()
+{
+    test_shmget();
+
+    printf("\nAll tests OK\n");
+}