bugfixes of TSharedMemory on macos.

Author: treefrogframework

src/test/sharedmemory/sharedmemory

@@ -37,6 +37,7 @@ static QByteArray randomString(int length)
 
 void TestSharedMemory::initTestCase()
 {
+    sharedMomory.unlink();
     sharedMomory.create(100 * 1024 * 1024);
 }
 
@@ -104,6 +105,14 @@ void TestSharedMemory::test2()
     sharedMomory.unlock();
     res = sharedMomory.detach();
     Q_ASSERT(res);
+
+    res = sharedMomory.attach();
+    Q_ASSERT(res);
+    res = sharedMomory.lockForRead();
+    Q_ASSERT(res);
+    int cmp = strncmp((char *)sharedMomory.data(), string.data(), string.length());
+    Q_ASSERT(cmp == 0);
+    sharedMomory.unlock();
 }
 
 TF_TEST_MAIN(TestSharedMemory)

src/test/sharedmemory/sharedmemory.cpp

@@ -34,11 +34,13 @@ class T_CORE_EXPORT TSharedMemory
     struct header_t {
 #ifdef Q_OS_LINUX
         pthread_rwlock_t rwlock;
-        uint lockcounter {0};
 #endif
+        uint lockcounter {0};
     };
 
-    void initRwlock(header_t *header) const;
+    bool initRwlock(header_t *header) const;
+    void releaseRwlock(header_t *header) const;
+
 
 #ifndef Q_OS_WIN
     QString _name;

src/tsharedmemory.h

@@ -22,6 +22,14 @@ void TSharedMemory::initRwlock(header_t *header) const
 }
 
 
+void TSharedMemory::releaseRwlock(header_t *header) const
+{
+    if (header) {
+        pthread_rwlock_destroy(&header->rwlock);
+    }
+}
+
+
 bool TSharedMemory::lockForRead()
 {
     struct timespec timeout;
@@ -65,6 +73,7 @@ bool TSharedMemory::lockForWrite()
         } else {
             if (res == ETIMEDOUT && header->lockcounter == cnt) {
                 // resets rwlock object
+                releaseRwlock(header);
                 initRwlock(header);
             }
         }

src/tsharedmemory_linux.cpp

@@ -6,22 +6,29 @@
  */
 
 #include "tsharedmemory.h"
+#include <TSystemGlobal>
 #include <semaphore.h>
 #include <fcntl.h>      // O_CREAT, O_EXCL
-#include <sys/stat.h>   // mode constants
+#include <sys/stat.h>
+#include <time.h>
 #include <errno.h>
 
 
-void TSharedMemory::initRwlock(header_t *) const
+static inline QByteArray semaphoreName(const QString &name)
 {
-    const QByteArray SEM_NAME = _name + "_global_lock";
+    return (name.startsWith("/") ? "" : "/") + name.toLatin1() + "_global_lock";
+}
+
 
-    sem_t* sem = sem_open(SEM_NAME.data(), O_CREAT | O_EXCL, 0644, 1);
+bool TSharedMemory::initRwlock(header_t *) const
+{
+    sem_t *sem = sem_open(semaphoreName(_name).data(), O_CREAT | O_EXCL, 0644, 1);
     if (sem == SEM_FAILED) {
         if (errno == EEXIST) {
+            tSystemError("sem_open semaphore already exists: {}", semaphoreName(_name));
             return true;
         } else {
-            tSystemError("sem_open (init) failed: {}", strerror(errno));
+            tSystemError("sem_open (init) failed: {}", (const char*)strerror(errno));
             return false;
         }
     }
@@ -32,24 +39,58 @@ void TSharedMemory::initRwlock(header_t *) const
 }
 
 
+void TSharedMemory::releaseRwlock(header_t *) const
+{
+    sem_unlink(semaphoreName(_name).data());
+}
+
+
 bool TSharedMemory::lockForRead()
 {
-    const QByteArray SEM_NAME = _name + "_global_lock";
+    // Use semaphore as a lock mechanism between processes.
+    // PTHREAD_PROCESS_SHARED attribute is not supported on macos.
+
+    sem_t *sem = SEM_FAILED;
+    header_t *header = (header_t *)_ptr;
+    uint cnt = header->lockcounter;
+
+    auto sem_timedwait = [&](int msecs) {
+        sem = sem_open(semaphoreName(_name).data(), 0);
+        if (sem == SEM_FAILED) {
+            tSystemError("sem_open (lock) failed: {}", (const char*)strerror(errno));
+            return -1;
+        }
 
-    sem_t* sem = sem_open(SEM_NAME.data(), 0);
-    if (sem == SEM_FAILED) {
-        tSystemError("sem_open (lock) failed: {}", strerror(errno));
-        return false;
+        auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(msecs);
+        while (std::chrono::steady_clock::now() < deadline) {
+            if (sem_trywait(sem) < 0) {
+                if (errno == EAGAIN) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+                    continue;
+                } else {
+                    return -1;  // error
+                }
+            } else {
+                header->lockcounter++;
+                return 0;  // lock success
+            }
+        }
+        tSystemError("sem_wait (lock) timed out: {}", semaphoreName(_name));
+        return 1;  // timeout
+    };
+
+    int res;
+    while ((res = sem_timedwait(1000)) == 1) {
+        if (header->lockcounter == cnt) {  // timeout and same counter
+            releaseRwlock(header);
+            initRwlock(header);
+        }
     }
 
-    if (sem_wait(sem) < 0) {
-        tSystemError("sem_wait failed: {}", strerror(errno));
+    if (sem != SEM_FAILED) {
         sem_close(sem);
-        return false;
     }
-
-    sem_close(sem);
-    return true;
+    return !res;
 }
 
 
@@ -62,16 +103,14 @@ bool TSharedMemory::lockForWrite()
 
 bool TSharedMemory::unlock()
 {
-    const QByteArray SEM_NAME = _name + "_global_lock";
-
-    sem_t* sem = sem_open(SEM_NAME.data(), 0);  // 既存を開く
+    sem_t *sem = sem_open(semaphoreName(_name).data(), 0);
     if (sem == SEM_FAILED) {
-        tSystemError("sem_open (unlock) failed: {}", strerror(errno));
+        tSystemError("sem_open (unlock) failed: {}", (const char*)strerror(errno));
         return false;
     }
 
     if (sem_post(sem) < 0) {
-        tSystemError("sem_post failed: {}", strerror(errno));
+        tSystemError("sem_post failed: {}", (const char*)strerror(errno));
         sem_close(sem);
         return false;
     }

src/tsharedmemory_macx.cpp

@@ -105,5 +105,11 @@ bool TSharedMemory::unlock()
 }
 
 
-void TSharedMemory::initRwlock(header_t *) const
+bool TSharedMemory::initRwlock(header_t *) const
+{
+    return true;
+}
+
+
+void TSharedMemory::releaseRwlock(header_t *) const
 {}

src/tsharedmemory_qt.cpp

@@ -89,6 +89,7 @@ bool TSharedMemory::create(size_t size)
 
 void TSharedMemory::unlink()
 {
+    releaseRwlock((header_t *)_ptr);
     shm_unlink(qUtf8Printable(_name));
     tSystemDebug("SharedMemory unlinked.  name:{}", qUtf8Printable(_name));
 }
@@ -154,6 +155,7 @@ bool TSharedMemory::detach()
 
     _ptr = nullptr;
     _size = 0;
+    tSystemDebug("SharedMemory detached.  name:{}", qUtf8Printable(_name));
     return true;
 }