Ticket #2657: draft-shm-002.patch

new file headers/posix/sys/shm.h

@@ +1 @@
+/*
+ * Copyright 2011 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>
+
+
+/* Message Flags */
+#define SHM_RDONLY  01000   /* attach read-only (else read-write) */
+#define SHM_RND     02000   /* rounds attach address to SHMLBA */
+
+#define SHMLBA      1024
+
+/* shmat() error return code */
+#define SHM_FAILED  ((void*)-1)
+
+
+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 id, const void* address, int flags);
+int shmctl(int id, int command, struct shmid_ds* mds);
+int shmdt(const void* address);
+int shmget(key_t key, size_t size, int flags);
+
+__END_DECLS
+
+#endif  /* _SYS_SHM_H */

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

@@ +1 @@
+/*
+ * Copyright 2011, 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 id, const void* address, int, void** rAddress);
+int     _user_xsi_shmctl(int id, int command, struct shmid_ds* mds);
+int     _user_xsi_shmdt(const void* address);
+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 <kernel/heap.h>
+
+#include <vm/vm.h>
+#include <vm/VMAddressSpace.h>
+#include <vm/VMArea.h>
+#include <vm/VMCache.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 POSIX XSI Shared Memory Lock");
+static int sSharedMemoryCount = 0;
+static uint32 sGlobalSequenceNumber = 1;
+
+
+class SharedMemoryEntry {
+public:
+    SharedMemoryEntry(key_t key, size_t size, int flags)
+        :
+        fKey(key),
+        fSize(size)
+    {
+        fIdDataStructure.shm_segsz = fSize;
+
+        fIdDataStructure.shm_cpid = getpid();
+        fIdDataStructure.shm_lpid = fIdDataStructure.shm_nattch = 0;
+        fIdDataStructure.shm_atime = fIdDataStructure.shm_dtime = 0;
+        fIdDataStructure.shm_ctime = real_time_clock();
+
+        fIdDataStructure.shm_perm.uid = fIdDataStructure.shm_perm.cuid = geteuid();
+        fIdDataStructure.shm_perm.gid = fIdDataStructure.shm_perm.cgid = getegid();
+        fIdDataStructure.shm_perm.mode = flags & 0x1ff;
+    }
+
+    status_t Init()
+    {
+        status_t status = VMCacheFactory::CreateAnonymousCache(fCache, 1, 0, 0, true,
+                    VM_PRIORITY_SYSTEM);
+        if (status != B_OK)
+            return ENOMEM;
+
+        fCache->temporary = 1;
+        fCache->virtual_end = PAGE_ALIGN(fSize);
+        fCache->committed_size = 0;
+
+        snprintf(fAreaName, B_OS_NAME_LENGTH, "xsi_shared_memory%ld", sGlobalSequenceNumber);
+
+        SetId();
+
+        atomic_add(&sGlobalSequenceNumber, 1);
+        atomic_add(&sSharedMemoryCount, 1);
+
+        return B_OK;
+    }
+
+    ~SharedMemoryEntry()
+    {
+        status_t status;
+
+        for (VMArea* area = fCache->areas; area != NULL; area = area->cache_next) {
+            status = vm_delete_area(VMAddressSpace::CurrentID(), area->id, true);
+                if (status != B_OK) {
+                    return;
+                }
+        }
+
+        fCache->Delete();
+
+        atomic_add(&sSharedMemoryCount, -1);
+    }
+
+    void SetId();
+
+    bool HasPermission() const
+    {
+        uid_t uid = geteuid();
+        if (uid == 0
+            || uid == fIdDataStructure.shm_perm.uid
+            || uid == fIdDataStructure.shm_perm.cuid)
+            return true;
+
+        return false;
+    }
+
+    bool HasReadPermission() const
+    {
+        if (fIdDataStructure.shm_perm.mode & S_IROTH)
+            return true;
+
+        uid_t uid = geteuid();
+        if (uid == 0 || (uid == fIdDataStructure.shm_perm.uid
+            && (fIdDataStructure.shm_perm.mode & S_IRUSR) != 0))
+            return true;
+
+        gid_t gid = getegid();
+        if (uid == 0 || (gid == fIdDataStructure.shm_perm.gid
+            && (fIdDataStructure.shm_perm.mode & S_IRGRP) != 0))
+            return true;
+
+        return false;
+    }
+
+    int Id() const
+    {
+        return fId;
+    }
+
+    key_t Key() const
+    {
+        return fKey;
+    }
+
+    VMCache* Cache() const
+    {
+        return fCache;
+    }
+
+    char* AreaName()
+    {
+        return fAreaName;
+    }
+
+    size_t Size() const
+    {
+        return fSize;
+    }
+
+    struct shmid_ds* IdDataStructure()
+    {
+        return &fIdDataStructure;
+    }
+
+    SharedMemoryEntry*& Link()
+    {
+        return fLink;
+    }
+
+private:
+    int         fId;
+    key_t           fKey;
+    VMCache*        fCache;
+    char            fAreaName[B_OS_NAME_LENGTH];
+    size_t          fSize;
+    struct shmid_ds     fIdDataStructure;
+    SharedMemoryEntry*  fLink;
+};
+
+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();
+    }
+};
+
+typedef BOpenHashTable<XsiSharedMemoryEntryHashTableDefinition> SharedMemoryEntryTable;
+static SharedMemoryEntryTable sSharedMemoryEntryTable;
+
+
+class Ipc {
+public:
+    Ipc(key_t key, size_t size)
+        :
+        fKey(key),
+        fSize(size),
+        fSharedMemoryId(-1)
+    {
+    }
+
+    key_t Key() const
+    {
+        return fKey;
+    }
+
+    size_t Size() const
+    {
+        return fSize;
+    }
+
+    int SharedMemoryId() const
+    {
+        return fSharedMemoryId;
+    }
+
+    void SetSharedMemoryId(int id)
+    {
+        fSharedMemoryId = id;
+    }
+
+    Ipc*& Link()
+    {
+        return fLink;
+    }
+
+private:
+    key_t   fKey;
+    size_t  fSize;
+    int fSharedMemoryId;
+    Ipc*    fLink;
+};
+
+struct IpcHashTableDefinition {
+    typedef key_t   KeyType;
+    typedef Ipc ValueType;
+
+    size_t HashKey (const key_t key) const
+    {
+        return (size_t)(key);
+    }
+
+    size_t Hash(Ipc* variable) const
+    {
+        return (size_t)HashKey(variable->Key());
+    }
+
+    bool Compare(const key_t key, Ipc* variable) const
+    {
+        return (key_t)key == (key_t)variable->Key();
+    }
+
+    Ipc*& GetLink(Ipc* variable) const
+    {
+        return variable->Link();
+    }
+};
+
+static BOpenHashTable<IpcHashTableDefinition> sIpcTable;
+
+
+void
+SharedMemoryEntry::SetId()
+{
+        fId = real_time_clock();
+
+        while (true) {
+                if (sSharedMemoryEntryTable.Lookup(fId) == NULL)
+                        break;
+                fId = (fId + 1) % INT_MAX;
+        }
+}
+
+
+//      #pragma mark - Kernel exported API
+
+
+void
+xsi_shm_init()
+{
+    status_t status = sSharedMemoryEntryTable.Init();
+    if (status != B_OK)
+        panic("xsi_shm_init(): Failed to initialize shared memory hash table!\n");
+
+    status = sIpcTable.Init();
+    if (status != B_OK)
+        panic("xsi_shm_init(): Failed to initialize ipc key hash table!\n");
+}
+
+
+status_t
+_user_xsi_shmat(int id, const void* address, int flags, void** _returnAddress)
+{
+    TRACE(("shmat: id = %d, address = %p, flags = %d\n",
+        id, address, flags));
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    SharedMemoryEntry* entry = sSharedMemoryEntryTable.Lookup(id);
+    if (entry == NULL)
+        return EINVAL;
+
+    struct shmid_ds* idDataStructure = entry->IdDataStructure();
+    if (idDataStructure->shm_nattch >= MAX_XSI_SHARED_MEMORY_ATTACH)
+        return EMFILE;
+
+    int protection = B_READ_AREA | B_WRITE_AREA | B_SHARED_AREA;
+    if ((flags & SHM_RDONLY) != 0)
+        protection &= ~B_WRITE_AREA;
+
+    uint32 addressSpec = B_ANY_ADDRESS;
+    if (address != NULL) {
+        if ((flags & SHM_RND) != 0) {
+            // TODO address = (void *) (addr - ((uintptr_t) addr % SHMLBA));
+            return EINVAL;
+        } else {
+            address = (void *)address;
+            addressSpec = B_EXACT_ADDRESS;
+        }
+
+        if (!IS_USER_ADDRESS(address))
+            return B_BAD_ADDRESS;
+    }
+
+    VMAddressSpace* targetAddressSpace = VMAddressSpace::GetCurrent();
+    if (targetAddressSpace == NULL)
+        return EINVAL;
+
+    size_t size = PAGE_ALIGN(entry->Size());
+
+    virtual_address_restrictions addressRestrictions = {};
+    addressRestrictions.address = NULL;
+    addressRestrictions.address_specification = addressSpec;
+    const uint32 allocationFlags = HEAP_DONT_WAIT_FOR_MEMORY | HEAP_DONT_LOCK_KERNEL_SPACE; 
+
+    VMArea* newArea = targetAddressSpace->CreateArea(entry->AreaName(), B_NO_LOCK,
+                protection, allocationFlags);
+    if (newArea == NULL)
+        return ENOMEM;
+
+    void* virtualAddress;
+    status_t status = targetAddressSpace->InsertArea(newArea, size, &addressRestrictions,
+                allocationFlags, &virtualAddress);
+    if (status != B_OK)
+        return EINVAL;
+
+    VMCache* cache = entry->Cache();
+    cache->Lock();
+    newArea->cache = cache;
+    newArea->cache_offset = 0;
+    newArea->cache_type = CACHE_TYPE_RAM;
+
+    cache->InsertAreaLocked(newArea);
+    VMAreaHash::Insert(newArea);
+
+    targetAddressSpace->Get();
+
+    cache->AcquireRefLocked();
+    cache->Unlock();
+
+    idDataStructure->shm_atime = real_time_clock();
+    idDataStructure->shm_nattch++;
+
+    *_returnAddress = virtualAddress;
+
+    return B_OK;
+}
+
+
+int
+_user_xsi_shmctl(int id, int command, struct shmid_ds* _buffer)
+{
+    status_t status;
+
+    TRACE(("shmctl: id = %d, command = %d, buffer = %p\n", id,
+        command, _buffer));
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    SharedMemoryEntry* entry = sSharedMemoryEntryTable.Lookup(id);
+    if (entry == NULL)
+        return EINVAL;
+
+    switch (command) {
+        case IPC_STAT: {
+            if (!entry->HasReadPermission())
+                return EACCES;
+
+            if (!IS_USER_ADDRESS(_buffer))
+                return B_BAD_ADDRESS;
+
+            // TODO: EOVERFLOW
+            struct shmid_ds* idDataStructure = entry->IdDataStructure();
+            status = user_memcpy(_buffer, (const void*)idDataStructure, 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;
+
+            struct shmid_ds* idDataStructure = entry->IdDataStructure();
+            status = user_memcpy(idDataStructure, _buffer, sizeof(struct shmid_ds));
+            if (status != B_OK)
+                return B_BAD_ADDRESS;
+            break;
+        }
+
+        case IPC_RMID: {
+            if (!entry->HasPermission())
+                return EPERM;
+
+            if (entry->Key() != IPC_PRIVATE) {
+                Ipc* ipcKey = sIpcTable.Lookup(entry->Key());
+                sIpcTable.Remove(ipcKey);
+                delete ipcKey;
+            }
+
+            sSharedMemoryEntryTable.Remove(entry);
+            atomic_add(&sSharedMemoryCount, -1);
+
+            delete entry;
+            break;
+        }
+
+        default:
+            return EINVAL;
+    }
+
+    return B_OK;
+}
+
+
+int
+_user_xsi_shmdt(const void* address)
+{
+    TRACE(("xsi_shmdt: detach address = %p\n", address));
+
+    area_id areaId = area_for((void*)address);
+    VMArea* area = VMAreaHash::Lookup(areaId);
+
+    if (area < 0 || area == NULL)
+        return EINVAL;
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    SharedMemoryEntry* entry;
+    SharedMemoryEntryTable::Iterator iterator = sSharedMemoryEntryTable.GetIterator();
+    while (iterator.HasNext()) {
+        entry = iterator.Next();
+        if (entry->Cache() == area->cache)
+            break;
+    }
+
+    status_t status = vm_delete_area(VMAddressSpace::CurrentID(), areaId, true);
+    if (status != B_OK)
+        return EINVAL;
+
+    struct shmid_ds* idDataStructure = entry->IdDataStructure();
+    idDataStructure->shm_dtime = real_time_clock();
+    idDataStructure->shm_nattch--;
+
+    return B_OK;
+}
+
+
+int
+_user_xsi_shmget(key_t key, size_t size, int flags)
+{
+    Ipc* ipcKey;
+
+    TRACE(("shmget: key = %d, size = %d, flags = %d\n",
+        (int)key, (int)size, flags));
+
+    MutexLocker _(sXsiSharedMemoryLock);
+
+    if (key != IPC_PRIVATE) {
+        ipcKey = sIpcTable.Lookup(key);
+        if (ipcKey == NULL) {
+            if (!(flags & IPC_CREAT))
+                return ENOENT;
+
+            ipcKey = new(std::nothrow) Ipc(key, size);
+            if (ipcKey == NULL)
+                return ENOMEM;
+
+            sIpcTable.Insert(ipcKey);
+        } else {
+            if ((flags & IPC_CREAT) && (flags & IPC_EXCL) != 0)
+                return EEXIST;
+
+            if ((ipcKey->Size() < size) && (size != 0))
+                return EINVAL;
+
+            return ipcKey->SharedMemoryId();
+        }
+    }
+
+    if (size < MIN_XSI_SHARED_MEMORY_SIZE
+        || size > MAX_XSI_SHARED_MEMORY_SIZE)
+        return EINVAL;
+
+    if (sSharedMemoryCount > MAX_XSI_SHARED_MEMORY_COUNT)
+        return ENOSPC;
+
+    SharedMemoryEntry* entry = new(std::nothrow) SharedMemoryEntry(key, size, flags);
+    if (entry == NULL)
+        return ENOMEM;
+
+    status_t status = entry->Init();
+    if (status != B_OK) {
+        delete entry;
+        return status;
+    }
+
+    if (key != IPC_PRIVATE)
+        ipcKey->SetSharedMemoryId(entry->Id());
+
+    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 2011, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      David Höppner <0xffea@gmail.com>
+ */
+
+
+#include <sys/shm.h>
+
+#include <errno.h>
+
+#include <syscall_utils.h>
+#include <syscalls.h>
+
+
+void*
+shmat(int key, const void *address, int flags)
+{
+    void* returnAddress;
+
+    status_t status = _kern_xsi_shmat(key, address, flags, &returnAddress);
+    if (status != B_OK) {
+        errno = status;
+        return SHM_FAILED;
+    }
+
+    return returnAddress;
+}
+
+
+int
+shmctl(int id, int command, struct shmid_ds *buffer)
+{
+    RETURN_AND_SET_ERRNO(_kern_xsi_shmctl(id, command, 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

@@ -34 +34 @@
 # 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");
+}
+
+
+static void
+test_shmctl()
+{
+        TEST_SET("shmctl({IPC_STAT, IPC_SET, IPC_RMID})");
+
+        const char* currentTest = NULL;
+
+    // Read shmid data structure for existing id
+        TEST("shmctl(ID, IPC_STAT) read shmid data structure for existing id");
+    int shmID = shmget(IPC_PRIVATE, SHM_SIZE, S_IRUSR | S_IWUSR);
+    assert_posix_bool_success(shmID != -1);
+    struct shmid_ds mds;
+    status_t status = shmctl(shmID, IPC_STAT, &mds);
+    assert_posix_bool_success(shmID != -1);
+    assert_equals(mds.shm_cpid, getpid());
+
+    // Cache has still areas
+    TEST("shmctl(ID, IPC_RMID) remove attached id");
+    shmat(shmID, NULL, 0);
+    shmctl(shmID, IPC_RMID, 0);
+
+    TEST("done");
+}
+
+
+static void
+test_shmdt()
+{
+    TEST_SET("shmdt(NULL, ID)");
+
+    const char* currentTest = NULL;
+
+    TEST("shmctl(NULL) detach NULL pointer");
+    status_t status = shmdt(NULL);
+    assert_posix_bool_success(errno == EINVAL);
+
+    TEST("shmctl(ID) detach existing ID");
+    int shmID = shmget(IPC_PRIVATE, SHM_SIZE, S_IRUSR);
+    void* address = shmat(shmID, NULL, 0);
+    status = shmdt(address);
+    assert_posix_bool_success(status != -1);
+
+    TEST("done");
+}
+
+
+int
+main()
+{
+    test_shmget();
+    test_shmdt();
+    test_shmctl();
+
+    printf("\nAll tests OK\n");
+}