Iox #33 implement ipc mutex semaphore

iceoryx_hoofs/include/iceoryx_hoofs/internal/posix_wrapper/shared_memory_object.hpp

@@ -64,7 +64,7 @@ class SharedMemoryObject : public DesignPattern::Creation<SharedMemoryObject, Sh
     SharedMemoryObject(const SharedMemory::Name_t& name,
                        const uint64_t memorySizeInBytes,
                        const AccessMode accessMode,
-                       const Policy policy,
+                       const OpenMode openMode,
                        const void* baseAddressHint,
                        const mode_t permissions = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 

iceoryx_hoofs/include/iceoryx_hoofs/internal/posix_wrapper/shared_memory_object/shared_memory.hpp

@@ -37,7 +37,7 @@ enum class AccessMode : uint64_t
 static constexpr const char* ACCESS_MODE_STRING[] = {"AccessMode::READ_ONLY", "AccessMode::READ_WRITE"};
 
 /// @brief describes how the shared memory is opened or created
-enum class Policy : uint64_t
+enum class OpenMode : uint64_t
 {
     /// @brief creates the shared memory, if it exists already the construction will fail
     EXCLUSIVE_CREATE = 0U,
@@ -46,10 +46,10 @@ enum class Policy : uint64_t
     /// @brief creates the shared memory, if it does not exist otherwise it opens it
     OPEN_OR_CREATE = 2U,
     /// @brief opens the shared memory, if it does not exist it will fail
-    OPEN = 3U
+    OPEN_EXISTING = 3U
 };
-static constexpr const char* POLICY_STRING[] = {
-    "Policy::EXCLUSIVE_CREATE", "Policy::PURGE_AND_CREATE", "Policy::CREATE_OR_OPEN", "Policy::OPEN"};
+static constexpr const char* OPEN_MODE_STRING[] = {
+    "OpenMode::EXCLUSIVE_CREATE", "OpenMode::PURGE_AND_CREATE", "OpenMode::CREATE_OR_OPEN", "OpenMode::OPEN_EXISTING"};
 
 enum class SharedMemoryError
 {
@@ -87,25 +87,26 @@ class SharedMemory : public DesignPattern::Creation<SharedMemory, SharedMemoryEr
     int32_t getHandle() const noexcept;
     bool hasOwnership() const noexcept;
 
-    static bool unlinkIfExist(const Name_t& name) noexcept;
+    static cxx::expected<bool, SharedMemoryError> unlinkIfExist(const Name_t& name) noexcept;
 
     friend class DesignPattern::Creation<SharedMemory, SharedMemoryError>;
 
   private:
     SharedMemory(const Name_t& name,
                  const AccessMode accessMode,
-                 const Policy policy,
+                 const OpenMode openMode,
                  const mode_t permissions,
                  const uint64_t size) noexcept;
 
-    bool open(const AccessMode accessMode, const Policy policy, const mode_t permissions, const uint64_t size) noexcept;
+    bool
+    open(const AccessMode accessMode, const OpenMode openMode, const mode_t permissions, const uint64_t size) noexcept;
     bool unlink() noexcept;
     bool close() noexcept;
     void destroy() noexcept;
     void reset() noexcept;
-    static int getOflagsFor(const AccessMode accessMode, const Policy policy) noexcept;
+    static int getOflagsFor(const AccessMode accessMode, const OpenMode openMode) noexcept;
 
-    SharedMemoryError errnoToEnum(const int32_t errnum) const noexcept;
+    static SharedMemoryError errnoToEnum(const int32_t errnum) noexcept;
 
     Name_t m_name;
     int m_handle{INVALID_HANDLE};

iceoryx_hoofs/platform/win/include/iceoryx_hoofs/platform/platform_correction.hpp

@@ -35,3 +35,4 @@
 #undef interface
 #undef CreateSemaphore
 #undef NO_ERROR
+#undef OPEN_EXISTING

iceoryx_hoofs/source/posix_wrapper/named_pipe.cpp

@@ -89,7 +89,7 @@ NamedPipe::NamedPipe(const IpcChannelName_t& name,
         // m_messages. when we add the alignment it is guaranteed that enough memory should be available.
         sizeof(MessageQueue_t) + alignof(MessageQueue_t),
         AccessMode::READ_WRITE,
-        (channelSide == IpcChannelSide::SERVER) ? Policy::OPEN_OR_CREATE : Policy::OPEN,
+        (channelSide == IpcChannelSide::SERVER) ? OpenMode::OPEN_OR_CREATE : OpenMode::OPEN_EXISTING,
         iox::posix::SharedMemoryObject::NO_ADDRESS_HINT);
 
     if (sharedMemory.has_error())

iceoryx_hoofs/source/posix_wrapper/shared_memory_object.cpp

@@ -47,14 +47,14 @@ static void memsetSigbusHandler(int)
 SharedMemoryObject::SharedMemoryObject(const SharedMemory::Name_t& name,
                                        const uint64_t memorySizeInBytes,
                                        const AccessMode accessMode,
-                                       const Policy policy,
+                                       const OpenMode openMode,
                                        const void* baseAddressHint,
                                        const mode_t permissions)
     : m_memorySizeInBytes(cxx::align(memorySizeInBytes, Allocator::MEMORY_ALIGNMENT))
 {
     m_isInitialized = true;
 
-    SharedMemory::create(name, accessMode, policy, permissions, m_memorySizeInBytes)
+    SharedMemory::create(name, accessMode, openMode, permissions, m_memorySizeInBytes)
         .and_then([this](auto& sharedMemory) { m_sharedMemory.emplace(std::move(sharedMemory)); })
         .or_else([this](auto&) {
             std::cerr << "Unable to create SharedMemoryObject since we could not acquire a SharedMemory resource"
@@ -79,9 +79,9 @@ SharedMemoryObject::SharedMemoryObject(const SharedMemory::Name_t& name,
         std::cerr << "Unable to create a shared memory object with the following properties [ name = " << name
                   << ", sizeInBytes = " << memorySizeInBytes
                   << ", access mode = " << ACCESS_MODE_STRING[static_cast<uint64_t>(accessMode)]
-                  << ", policy = " << POLICY_STRING[static_cast<uint64_t>(policy)] << ", baseAddressHint = " << std::hex
-                  << baseAddressHint << ", permissions = " << std::bitset<sizeof(mode_t)>(permissions) << " ]"
-                  << std::endl;
+                  << ", open mode = " << OPEN_MODE_STRING[static_cast<uint64_t>(openMode)]
+                  << ", baseAddressHint = " << std::hex << baseAddressHint
+                  << ", permissions = " << std::bitset<sizeof(mode_t)>(permissions) << " ]" << std::endl;
         return;
     }
 
@@ -102,12 +102,12 @@ SharedMemoryObject::SharedMemoryObject(const SharedMemory::Name_t& name,
                 SIGBUS_ERROR_MESSAGE_LENGTH,
                 "While setting the acquired shared memory to zero a fatal SIGBUS signal appeared caused by memset. The "
                 "shared memory object with the following properties [ name = %s, sizeInBytes = %llu, access mode = %s, "
-                "policy = %s, baseAddressHint = %p, permissions = %lu ] maybe requires more memory than it is "
+                "open mode = %s, baseAddressHint = %p, permissions = %lu ] maybe requires more memory than it is "
                 "currently available in the system.\n",
                 name.c_str(),
                 static_cast<unsigned long long>(memorySizeInBytes),
                 ACCESS_MODE_STRING[static_cast<uint64_t>(accessMode)],
-                POLICY_STRING[static_cast<uint64_t>(policy)],
+                OPEN_MODE_STRING[static_cast<uint64_t>(openMode)],
                 baseAddressHint,
                 std::bitset<sizeof(mode_t)>(permissions).to_ulong());
 

iceoryx_hoofs/source/posix_wrapper/shared_memory_object/shared_memory.cpp

@@ -35,7 +35,7 @@ namespace posix
 {
 SharedMemory::SharedMemory(const Name_t& name,
                            const AccessMode accessMode,
-                           const Policy policy,
+                           const OpenMode openMode,
                            const mode_t permissions,
                            const uint64_t size) noexcept
 {
@@ -57,14 +57,14 @@ SharedMemory::SharedMemory(const Name_t& name,
     if (m_isInitialized)
     {
         m_name = name;
-        m_isInitialized = open(accessMode, policy, permissions, size);
+        m_isInitialized = open(accessMode, openMode, permissions, size);
     }
 
     if (!m_isInitialized)
     {
         std::cerr << "Unable to create shared memory with the following properties [ name = " << name
                   << ", access mode = " << ACCESS_MODE_STRING[static_cast<uint64_t>(accessMode)]
-                  << ", policy = " << POLICY_STRING[static_cast<uint64_t>(policy)]
+                  << ", open mode = " << OPEN_MODE_STRING[static_cast<uint64_t>(openMode)]
                   << ", mode = " << std::bitset<sizeof(mode_t)>(permissions) << ", sizeInBytes = " << size << " ]"
                   << std::endl;
         return;
@@ -76,11 +76,11 @@ SharedMemory::~SharedMemory() noexcept
     destroy();
 }
 
-int SharedMemory::getOflagsFor(const AccessMode accessMode, const Policy policy) noexcept
+int SharedMemory::getOflagsFor(const AccessMode accessMode, const OpenMode openMode) noexcept
 {
     int oflags = 0;
     oflags |= (accessMode == AccessMode::READ_ONLY) ? O_RDONLY : O_RDWR;
-    oflags |= (policy != Policy::OPEN) ? O_CREAT | O_EXCL : 0;
+    oflags |= (openMode != OpenMode::OPEN_EXISTING) ? O_CREAT | O_EXCL : 0;
     return oflags;
 }
 
@@ -134,40 +134,41 @@ bool SharedMemory::hasOwnership() const noexcept
 }
 
 bool SharedMemory::open(const AccessMode accessMode,
-                        const Policy policy,
+                        const OpenMode openMode,
                         const mode_t permissions,
                         const uint64_t size) noexcept
 {
     cxx::Expects(size <= static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
 
-    m_hasOwnership =
-        (policy == Policy::EXCLUSIVE_CREATE || policy == Policy::PURGE_AND_CREATE || policy == Policy::OPEN_OR_CREATE);
+    m_hasOwnership = (openMode == OpenMode::EXCLUSIVE_CREATE || openMode == OpenMode::PURGE_AND_CREATE
+                      || openMode == OpenMode::OPEN_OR_CREATE);
 
     // the mask will be applied to the permissions, therefore we need to set it to 0
     mode_t umaskSaved = umask(0U);
     {
         cxx::GenericRAII umaskGuard([&] { umask(umaskSaved); });
 
-        if (policy == Policy::PURGE_AND_CREATE)
+        if (openMode == OpenMode::PURGE_AND_CREATE)
         {
             IOX_DISCARD_RESULT(posixCall(shm_unlink)(m_name.c_str())
                                    .failureReturnValue(INVALID_HANDLE)
                                    .ignoreErrnos(ENOENT)
                                    .evaluate());
         }
 
-        auto result = posixCall(iox_shm_open)(m_name.c_str(), getOflagsFor(accessMode, policy), permissions)
+        auto result = posixCall(iox_shm_open)(m_name.c_str(), getOflagsFor(accessMode, openMode), permissions)
                           .failureReturnValue(INVALID_HANDLE)
-                          .suppressErrorMessagesForErrnos((policy == Policy::OPEN_OR_CREATE) ? EEXIST : 0)
+                          .suppressErrorMessagesForErrnos((openMode == OpenMode::OPEN_OR_CREATE) ? EEXIST : 0)
                           .evaluate();
         if (result.has_error())
         {
             // if it was not possible to create the shm exclusively someone else has the
             // ownership and we just try to open it
-            if (policy == Policy::OPEN_OR_CREATE && result.get_error().errnum == EEXIST)
+            if (openMode == OpenMode::OPEN_OR_CREATE && result.get_error().errnum == EEXIST)
             {
                 m_hasOwnership = false;
-                result = posixCall(iox_shm_open)(m_name.c_str(), getOflagsFor(accessMode, Policy::OPEN), permissions)
+                result = posixCall(iox_shm_open)(
+                             m_name.c_str(), getOflagsFor(accessMode, OpenMode::OPEN_EXISTING), permissions)
                              .failureReturnValue(INVALID_HANDLE)
                              .evaluate();
                 if (!result.has_error())
@@ -177,7 +178,7 @@ bool SharedMemory::open(const AccessMode accessMode,
                 }
             }
 
-            m_errorValue = this->errnoToEnum(result.get_error().errnum);
+            m_errorValue = errnoToEnum(result.get_error().errnum);
             return false;
         }
         m_handle = result->value;
@@ -188,7 +189,7 @@ bool SharedMemory::open(const AccessMode accessMode,
         if (posixCall(ftruncate)(m_handle, static_cast<int64_t>(size))
                 .failureReturnValue(INVALID_HANDLE)
                 .evaluate()
-                .or_else([this](auto& r) { m_errorValue = this->errnoToEnum(r.errnum); })
+                .or_else([this](auto& r) { m_errorValue = errnoToEnum(r.errnum); })
                 .has_error())
         {
             return false;
@@ -198,13 +199,25 @@ bool SharedMemory::open(const AccessMode accessMode,
     return true;
 }
 
-bool SharedMemory::unlinkIfExist(const Name_t& name) noexcept
+cxx::expected<bool, SharedMemoryError> SharedMemory::unlinkIfExist(const Name_t& name) noexcept
 {
-    return !posixCall(shm_unlink)(name.c_str())
-                .failureReturnValue(INVALID_HANDLE)
-                .suppressErrorMessagesForErrnos(ENOENT)
-                .evaluate()
-                .has_error();
+    auto result = posixCall(shm_unlink)(name.c_str())
+                      .failureReturnValue(INVALID_HANDLE)
+                      .suppressErrorMessagesForErrnos(ENOENT)
+                      .evaluate();
+
+    if (result.has_error())
+    {
+        auto& error = result.get_error();
+        if (error.errnum == ENOENT)
+        {
+            return cxx::success<bool>(false);
+        }
+
+        return cxx::error<SharedMemoryError>(errnoToEnum(error.errnum));
+    }
+
+    return cxx::success<bool>(true);
 }
 
 bool SharedMemory::unlink() noexcept
@@ -235,12 +248,12 @@ bool SharedMemory::close() noexcept
     return true;
 }
 
-SharedMemoryError SharedMemory::errnoToEnum(const int32_t errnum) const noexcept
+SharedMemoryError SharedMemory::errnoToEnum(const int32_t errnum) noexcept
 {
     switch (errnum)
     {
     case EACCES:
-        std::cerr << "No permission to modify, truncate or to access the shared memory!" << std::endl;
+        std::cerr << "No permission to modify, truncate or access the shared memory!" << std::endl;
         return SharedMemoryError::INSUFFICIENT_PERMISSIONS;
     case EPERM:
         std::cerr << "Resizing a file beyond its current size is not supported by the filesystem!" << std::endl;