Replace SharedBuffer::Semaphore with Core::SharedSemaphore

Source/core/Portability.h

@@ -359,6 +359,20 @@ typedef std::string string;
 //const std::basic_string<char>::size_type std::basic_string<char>::npos = (std::basic_string<char>::size_type) - 1;
 //#endif
 
+// NTQuerySemaphore (undocumented) is used to retrieve current count of a semaphore
+using NTSTATUS = LONG;
+using _NTQuerySemaphore = NTSTATUS(NTAPI*)(
+    HANDLE SemaphoreHandle, 
+    DWORD SemaphoreInformationClass, 
+    PVOID SemaphoreInformation, 
+    ULONG SemaphoreInformationLength,
+    PULONG ReturnLength OPTIONAL
+);
+struct SEMAPHORE_BASIC_INFORMATION {
+    ULONG CurrentCount;
+    ULONG MaximumCount;
+};
+
 #define LITTLE_ENDIAN_PLATFORM 1
 #undef ERROR
 #define __WINDOWS__
@@ -385,6 +399,7 @@ typedef std::string string;
 #include <typeinfo>
 #include <cmath>
 #include <thread>
+#include <limits.h>
 
 #include <string.h>
 #include <termios.h>
@@ -412,9 +427,24 @@ typedef std::string string;
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/mman.h> // memfd_create in Messaging/ConsoleRedirect.h
+#include <sys/inotify.h>
 
 #include <arpa/inet.h>
 
+#ifndef _GNU_SOURCE
+    #define _GNU_SOURCE
+    #include <features.h>
+    #ifndef __USE_GNU
+        #define __MUSL__
+    #endif
+    #undef _GNU_SOURCE /* don't contaminate other includes unnecessarily */
+#else
+    #include <features.h>
+    #ifndef __USE_GNU
+        #define __MUSL__
+    #endif
+#endif
+
 #ifdef __APPLE__
 #include <pthread_impl.h>
 #define SCHED_BATCH 99

Source/core/Proxy.h

@@ -539,11 +539,11 @@ POP_WARNING()
             {
                 return (!operator==(a_RHS));
             }
-            inline bool operator==(const nullptr_t&) const
+            inline bool operator==(const std::nullptr_t&) const
             {
                 return (_refCount == nullptr);
             }
-            inline bool operator!=(const nullptr_t&) const
+            inline bool operator!=(const std::nullptr_t&) const
             {
                 return (_refCount != nullptr);
             }

Source/core/SharedBuffer.cpp

@@ -26,148 +26,38 @@ namespace Thunder {
 
 namespace Core {
 
-#ifdef __WINDOWS__
-    SharedBuffer::Semaphore::Semaphore(const TCHAR sourceName[])
-        : _semaphore(::CreateSemaphore(nullptr, 1, 1, sourceName))
-    {
-    }
-#else
-    SharedBuffer::Semaphore::Semaphore(sem_t* storage)
-        : _semaphore(storage)
-    {
-        ASSERT(storage != nullptr);
-    }
-#endif
-    SharedBuffer::Semaphore::~Semaphore()
-    {
-#ifdef __WINDOWS__
-        if (_semaphore != nullptr) {
-            ::CloseHandle(_semaphore);
-        }
-#else
-        sem_destroy(_semaphore);
-#endif
-    }
-
-    uint32_t SharedBuffer::Semaphore::Unlock()
-    {
-#ifdef __WINDOWS__
-        if (_semaphore != nullptr) {
-            BOOL result = ::ReleaseSemaphore(_semaphore, 1, nullptr);
-
-            ASSERT(result != FALSE);
-        }
-#else
-        VARIABLE_IS_NOT_USED int result = sem_post(_semaphore);
-
-        ASSERT((result == 0) || (errno == EOVERFLOW));
-#endif
-        return ERROR_NONE;
-    }
-
-    bool SharedBuffer::Semaphore::IsLocked()
-    {
-#ifdef __WINDOWS__
-        bool locked = (::WaitForSingleObjectEx(_semaphore, 0, FALSE) != WAIT_OBJECT_0);
-
-        if (locked == false) {
-            ::ReleaseSemaphore(_semaphore, 1, nullptr);
-        }
-
-        return (locked);
-#else
-        int semValue = 0;
-        sem_getvalue(_semaphore, &semValue);
-        return (semValue == 0);
-#endif
-    }
-
-    uint32_t SharedBuffer::Semaphore::Lock(const uint32_t waitTime)
-    {
-        uint32_t result = Core::ERROR_GENERAL;
-#ifdef __WINDOWS__
-        if (_semaphore != nullptr) {
-            return (::WaitForSingleObjectEx(_semaphore, waitTime, FALSE) == WAIT_OBJECT_0 ? Core::ERROR_NONE : Core::ERROR_TIMEDOUT);
-        }
-#elif defined(__APPLE__)
-
-        uint32_t timeLeft = waitTime;
-        int semResult;
-        while (((semResult = sem_trywait(_semaphore)) != 0) && timeLeft > 0) {
-            ::SleepMs(100);
-            if (timeLeft != Core::infinite) {
-                timeLeft -= (timeLeft > 100 ? 100 : timeLeft);
-            }
-        }
-        result = semResult == 0 ? Core::ERROR_NONE : Core::ERROR_TIMEDOUT;
-#else
-
-        struct timespec structTime = {0,0};
-
-        clock_gettime(CLOCK_MONOTONIC, &structTime);
-        structTime.tv_nsec += ((waitTime % 1000) * 1000 * 1000); /* remainder, milliseconds to nanoseconds */
-        structTime.tv_sec += (waitTime / 1000) + (structTime.tv_nsec / 1000000000); /* milliseconds to seconds */
-        structTime.tv_nsec = structTime.tv_nsec % 1000000000;
-
-        do {
-            if (sem_clockwait(_semaphore, CLOCK_MONOTONIC, &structTime) == 0) {
-                result = Core::ERROR_NONE;
-            }
-            else if ( errno == EINTR ) {
-                continue;
-            }
-            else if ( errno == ETIMEDOUT ) {
-                result = Core::ERROR_TIMEDOUT;
-            }
-            else {
-                ASSERT(false);
-            }
-            break;
-        } while (true);
-#endif
-        return (result);
-    }
-
     SharedBuffer::SharedBuffer(const TCHAR name[])
         : DataElementFile(name, File::USER_READ | File::USER_WRITE | File::SHAREABLE, 0)
         , _administrationBuffer((string(name) + ".admin"), File::USER_READ | File::USER_WRITE | File::SHAREABLE, 0)
         , _administration(reinterpret_cast<Administration*>(PointerAlign(_administrationBuffer.Buffer())))
-#ifdef __WINDOWS__
+    #ifdef __WINDOWS__
         , _producer((string(name) + ".producer").c_str())
         , _consumer((string(name) + ".consumer").c_str())
-#else
-        , _producer(&(_administration->_producer))
-        , _consumer(&(_administration->_consumer))
-#endif
-        , _customerAdministration(PointerAlign(&(reinterpret_cast<uint8_t*>(_administration)[sizeof(Administration)])))
+    #else
+        , _producer(reinterpret_cast<uint8_t*>(_administration) + sizeof(Administration))
+        , _consumer(reinterpret_cast<uint8_t*>(_administration) + sizeof(Administration) + SharedSemaphore::Size())
+    #endif
+        , _customerAdministration(PointerAlign(&(reinterpret_cast<uint8_t*>(_administration)[sizeof(Administration) + (SharedSemaphore::Size() * 2)])))
     {
         Align<uint64_t>();
     }
     SharedBuffer::SharedBuffer(const TCHAR name[], const uint32_t mode, const uint32_t bufferSize, const uint16_t administratorSize)
         : DataElementFile(name, mode | File::SHAREABLE | File::CREATE, bufferSize)
-        , _administrationBuffer((string(name) + ".admin"), mode | File::SHAREABLE | File::CREATE, administratorSize + sizeof(Administration) + (2 * sizeof(void*)) + 8 /* Align buffer on 64 bits boundary */)
+        , _administrationBuffer((string(name) + ".admin"), mode | File::SHAREABLE | File::CREATE, sizeof(Administration) + (SharedSemaphore::Size() * 2) + administratorSize 
+            + (sizeof(void*) * 2) + ((sizeof(Administration) + (SharedSemaphore::Size() * 2) + administratorSize) % sizeof(void*) == 0 ?
+            0 : (sizeof(void*) - ((sizeof(Administration) + (SharedSemaphore::Size() * 2) + administratorSize) % sizeof(void*)))) /* Align buffer on 32/64 bits boundary */)
         , _administration(reinterpret_cast<Administration*>(PointerAlign(_administrationBuffer.Buffer())))
-#ifdef __WINDOWS__
-        , _producer((string(name) + ".producer").c_str())
-        , _consumer((string(name) + ".consumer").c_str())
-#else
-        , _producer(&(_administration->_producer))
-        , _consumer(&(_administration->_consumer))
-#endif
-        , _customerAdministration(PointerAlign(&(reinterpret_cast<uint8_t*>(_administration)[sizeof(Administration)])))
-    {
-
-#ifndef __WINDOWS__
-        memset(_administration, 0, sizeof(Administration));
-
-        sem_init(&(_administration->_producer), 1, 1); /* Initial value is 1. */
-        sem_init(&(_administration->_consumer), 1, 0); /* Initial value is 0. */
-#endif
+    #ifdef __WINDOWS__
+        , _producer((string(name) + ".producer").c_str(), 1, 1)
+        , _consumer((string(name) + ".consumer").c_str(), 0, 1)
+    #else
+        , _producer(reinterpret_cast<uint8_t*>(_administration) + sizeof(Administration), 1, 1)
+        , _consumer(reinterpret_cast<uint8_t*>(_administration) + sizeof(Administration) + SharedSemaphore::Size(), 0, 1)
+#   endif
+        , _customerAdministration(PointerAlign(&(reinterpret_cast<uint8_t*>(_administration)[sizeof(Administration) + (SharedSemaphore::Size() * 2)])))
+    {
+        _administration->_bytesWritten = 0;
         Align<uint64_t>();
     }
-
-    SharedBuffer::~SharedBuffer()
-    {
-    }
-}
 }
+}

Source/core/SharedBuffer.h

@@ -65,46 +65,12 @@ namespace Core {
         SharedBuffer& operator=(const SharedBuffer&) = delete;
 
     private:
-        class Semaphore {
-        private:
-            Semaphore() = delete;
-            Semaphore(const Semaphore&) = delete;
-            Semaphore& operator=(const Semaphore&) = delete;
-
-        public:
-#ifdef __WINDOWS__
-            Semaphore(const TCHAR name[]);
-#else
-            Semaphore(sem_t* storage);
-            //Semaphore(sem_t* storage, bool initialize) {
-            //}
-#endif
-            ~Semaphore();
-
-        public:
-            uint32_t Lock(const uint32_t waitTime);
-            uint32_t Unlock();
-            bool IsLocked();
-
-        private:
-#ifdef __WINDOWS__
-            HANDLE _semaphore;
-#else
-            sem_t* _semaphore;
-#endif
-        };
         struct Administration {
-
             uint32_t _bytesWritten;
-
-#ifndef __WINDOWS__
-            sem_t _producer;
-            sem_t _consumer;
-#endif
         };
 
     public:
-        virtual ~SharedBuffer();
+        ~SharedBuffer() override = default;
 
         // This is the consumer constructor. It should always take place, after, the producer
         // construct. The producer will create the Administration area, and the shared buffer,
@@ -215,8 +181,8 @@ namespace Core {
     private:
         DataElementFile _administrationBuffer;
         Administration* _administration;
-        Semaphore _producer;
-        Semaphore _consumer;
+        Core::SharedSemaphore _producer;
+        Core::SharedSemaphore _consumer;
         uint8_t* _customerAdministration;
     };
 }