Iox #33 implement ipc mutex semaphore

.github/workflows/build-test.yml

@@ -108,7 +108,7 @@ jobs:
       # we have to exclude the tests explicitly until everyone is running
       - name: Run tests, excluding timing_tests
         run: |
-          build\hoofs\test\Debug\hoofs_moduletests.exe --gtest_filter="-*TimingTest*:IpcChannel*:Mutex*:UnixDomainSocket*"
+          build\hoofs\test\Debug\hoofs_moduletests.exe --gtest_filter="-*TimingTest*:UnixDomainSocket*"
           build\hoofs\test\Debug\hoofs_integrationtests.exe
           build\binding_c\test\Debug\binding_c_moduletests.exe --gtest_filter="-BindingC_Runtime*:*TimingTest*"
           build\posh\test\Debug\posh_moduletests.exe --gtest_filter="-PoshRuntime*:IceoryxRoudiApp*:IceoryxRoudiMemoryManager*:ProcessIntrospection*:ParseAllMalformedInput*:*TimingTest*"

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 OwnerShip ownerShip,
+                       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

@@ -36,12 +36,20 @@ enum class AccessMode : uint64_t
 };
 static constexpr const char* ACCESS_MODE_STRING[] = {"AccessMode::READ_ONLY", "AccessMode::READ_WRITE"};
 
-enum class OwnerShip : uint64_t
+/// @brief describes how the shared memory is opened or created
+enum class OpenMode : uint64_t
 {
-    MINE = 0U,
-    OPEN_EXISTING_SHM = 1U
+    /// @brief creates the shared memory, if it exists already the construction will fail
+    EXCLUSIVE_CREATE = 0U,
+    /// @brief creates the shared memory, if it exists it will be deleted and recreated
+    PURGE_AND_CREATE = 1U,
+    /// @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_EXISTING = 3U
 };
-static constexpr const char* OWNERSHIP_STRING[] = {"OwnerShip::MINE", "OwnerShip::OPEN_EXISTING_SHM"};
+static constexpr const char* OPEN_MODE_STRING[] = {
+    "OpenMode::EXCLUSIVE_CREATE", "OpenMode::PURGE_AND_CREATE", "OpenMode::OPEN_OR_CREATE", "OpenMode::OPEN_EXISTING"};
 
 enum class SharedMemoryError
 {
@@ -63,10 +71,15 @@ enum class SharedMemoryError
     UNKNOWN_ERROR
 };
 
+/// @brief Creates a bare metal shared memory object with the posix functions
+///        shm_open, shm_unlink etc.
+///        It must be used in combination with MemoryMap (or manual mmap calls)
+//         to gain access to the created/opened shared memory
 class SharedMemory : public DesignPattern::Creation<SharedMemory, SharedMemoryError>
 {
   public:
-    static constexpr uint64_t NAME_SIZE = 128U;
+    static constexpr uint64_t NAME_SIZE = platform::IOX_MAX_SHM_NAME_LENGTH;
+    static constexpr int INVALID_HANDLE = -1;
     using Name_t = cxx::string<NAME_SIZE>;
 
     SharedMemory(const SharedMemory&) = delete;
@@ -75,29 +88,50 @@ class SharedMemory : public DesignPattern::Creation<SharedMemory, SharedMemoryEr
     SharedMemory& operator=(SharedMemory&&) noexcept;
     ~SharedMemory() noexcept;
 
+    /// @brief returns the file handle of the shared memory
     int32_t getHandle() const noexcept;
 
+    /// @brief this class has the ownership of the shared memory when the shared
+    ///        memory was created by this class. This is the case when this class
+    ///        was successful created with EXCLUSIVE_CREATE, PURGE_AND_CREATE or OPEN_OR_CREATE
+    ///        and the shared memory was created. If an already available shared memory
+    ///        is opened then this class does not have the ownership.
+    bool hasOwnership() const noexcept;
+
+    /// @brief removes shared memory with a given name from the system
+    /// @param[in] name name of the shared memory
+    /// @return true if the shared memory was removed, false if the shared memory did not exist and
+    ///         SharedMemoryError when the underlying shm_unlink call failed.
+    static cxx::expected<bool, SharedMemoryError> unlinkIfExist(const Name_t& name) noexcept;
+
     friend class DesignPattern::Creation<SharedMemory, SharedMemoryError>;
 
   private:
+    /// @brief constructs or opens existing shared memory
+    /// @param[in] name the name of the shared memory, must start with a leading /
+    /// @param[in] accessMode defines if the shared memory is mapped read only or with read write rights
+    /// @param[in] openMode states how the shared memory is created/opened
+    /// @param[in] permissions the permissions the shared memory should have
+    /// @param[in] size the size in bytes of the shared memory
     SharedMemory(const Name_t& name,
                  const AccessMode accessMode,
-                 const OwnerShip ownerShip,
+                 const OpenMode openMode,
                  const mode_t permissions,
                  const uint64_t size) noexcept;
 
-    bool open(const int oflags, 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 OpenMode openMode) noexcept;
 
-    SharedMemoryError errnoToEnum(const int32_t errnum) const noexcept;
-
+    static SharedMemoryError errnoToEnum(const int32_t errnum) noexcept;
 
     Name_t m_name;
-    OwnerShip m_ownerShip;
-    int m_handle{-1};
+    int m_handle{INVALID_HANDLE};
+    bool m_hasOwnership{false};
 };
 } // namespace posix
 } // namespace iox

iceoryx_hoofs/include/iceoryx_hoofs/posix_wrapper/file_lock.hpp

@@ -27,10 +27,9 @@ namespace posix
 enum class FileLockError
 {
     INVALID_STATE,
-    NO_FILE_NAME_PROVIDED,
+    INVALID_FILE_NAME,
     LOCKED_BY_OTHER_PROCESS,
     ACCESS_DENIED,
-    INVALID_FILE_NAME,
     QUOTA_EXHAUSTED,
     INVALID_CHARACTERS_IN_FILE_NAME,
     SYSTEM_LIMIT,
@@ -45,14 +44,6 @@ enum class FileLockError
     INTERNAL_LOGIC_ERROR,
 };
 
-
-#if defined(QNX) || defined(QNX__) || defined(__QNX__)
-constexpr char PATH_PREFIX[] = "/var/lock/";
-#else
-constexpr char PATH_PREFIX[] = "/tmp/";
-#endif
-
-
 /// @brief Posix file lock C++ wrapping class
 ///        Following RAII, the lock is acquired on creation and released on destruction. Releasing the locks works even
 ///        if the process crashes with a segfault or using SIGKILL. 'lslocks' can be used to display all system-wide
@@ -72,8 +63,13 @@ class FileLock : public DesignPattern::Creation<FileLock, FileLockError>
   public:
     static constexpr int32_t ERROR_CODE = -1;
     static constexpr int32_t INVALID_FD = -1;
-    using FileName_t = cxx::string<250>;
-    using PathName_t = cxx::string<1024>;
+    static constexpr const char LOCK_FILE_SUFFIX[] = ".lock";
+    static constexpr uint64_t FILENAME_LENGTH = platform::IOX_MAX_FILENAME_LENGTH
+                                                - sizeof(platform::IOX_LOCK_FILE_PATH_PREFIX) / sizeof(char)
+                                                - sizeof(LOCK_FILE_SUFFIX) / sizeof(char);
+
+    using FileName_t = cxx::string<FILENAME_LENGTH>;
+    using PathName_t = cxx::string<platform::IOX_MAX_PATH_LENGTH>;
 
     FileLock(const FileLock&) = delete;
     FileLock& operator=(const FileLock&) = delete;

iceoryx_hoofs/platform/linux/include/iceoryx_hoofs/platform/mman.hpp

@@ -20,5 +20,6 @@
 #include <sys/mman.h>
 
 int iox_shm_open(const char* name, int oflag, mode_t mode);
+int iox_shm_unlink(const char* name);
 
-#endif // IOX_HOOFS_LINUX_PLATFORM_MMAN_HPP
+#endif // IOX_HOOFS_LINUX_PLATFORM_MMAN_HPP

iceoryx_hoofs/platform/linux/include/iceoryx_hoofs/platform/platform_settings.hpp

@@ -17,6 +17,7 @@
 #define IOX_HOOFS_LINUX_PLATFORM_PLATFORM_SETTINGS_HPP
 
 #include <cstdint>
+#include <linux/limits.h>
 
 namespace iox
 {
@@ -27,11 +28,16 @@ class UnixDomainSocket;
 
 namespace platform
 {
+constexpr uint64_t IOX_MAX_FILENAME_LENGTH = 255U;
+constexpr uint64_t IOX_MAX_PATH_LENGTH = 1023U;
 constexpr bool IOX_SHM_WRITE_ZEROS_ON_CREATION = true;
+constexpr uint64_t IOX_MAX_SHM_NAME_LENGTH = PATH_MAX;
 constexpr const char IOX_PATH_SEPARATORS[] = "/";
 constexpr uint64_t IOX_UDS_SOCKET_MAX_MESSAGE_SIZE = 4096;
-constexpr char IOX_UDS_SOCKET_PATH_PREFIX[] = "/tmp/";
+constexpr const char IOX_UDS_SOCKET_PATH_PREFIX[] = "/tmp/";
+constexpr const char IOX_LOCK_FILE_PATH_PREFIX[] = "/tmp/";
 using IoxIpcChannelType = iox::posix::UnixDomainSocket;
 } // namespace platform
 } // namespace iox
+
 #endif // IOX_HOOFS_LINUX_PLATFORM_PLATFORM_SETTINGS_HPP

iceoryx_hoofs/platform/linux/source/mman.cpp

@@ -20,3 +20,8 @@ int iox_shm_open(const char* name, int oflag, mode_t mode)
 {
     return shm_open(name, oflag, mode);
 }
+
+int iox_shm_unlink(const char* name)
+{
+    return shm_unlink(name);
+}

iceoryx_hoofs/platform/mac/include/iceoryx_hoofs/platform/mman.hpp

@@ -20,5 +20,6 @@
 #include <sys/mman.h>
 
 int iox_shm_open(const char* name, int oflag, mode_t mode);
+int iox_shm_unlink(const char* name);
 
-#endif // IOX_HOOFS_MAC_PLATFORM_MMAN_HPP
+#endif // IOX_HOOFS_MAC_PLATFORM_MMAN_HPP

iceoryx_hoofs/platform/mac/include/iceoryx_hoofs/platform/platform_settings.hpp

@@ -27,10 +27,16 @@ class UnixDomainSocket;
 
 namespace platform
 {
+constexpr uint64_t IOX_MAX_FILENAME_LENGTH = 255U;
+constexpr uint64_t IOX_MAX_PATH_LENGTH = 1023U;
 constexpr bool IOX_SHM_WRITE_ZEROS_ON_CREATION = true;
+// it should be SHM_NAME_MAX but it is unknown in which header this define
+// is defined
+constexpr uint64_t IOX_MAX_SHM_NAME_LENGTH = 255U;
 constexpr const char IOX_PATH_SEPARATORS[] = "/";
 constexpr uint64_t IOX_UDS_SOCKET_MAX_MESSAGE_SIZE = 2048;
-constexpr char IOX_UDS_SOCKET_PATH_PREFIX[] = "/tmp/";
+constexpr const char IOX_UDS_SOCKET_PATH_PREFIX[] = "/tmp/";
+constexpr const char IOX_LOCK_FILE_PATH_PREFIX[] = "/tmp/";
 using IoxIpcChannelType = iox::posix::UnixDomainSocket;
 } // namespace platform
 } // namespace iox

iceoryx_hoofs/platform/mac/source/mman.cpp

@@ -16,7 +16,24 @@
 
 #include "iceoryx_hoofs/platform/mman.hpp"
 
+#include <errno.h>
+#include <sys/shm.h>
+
 int iox_shm_open(const char* name, int oflag, mode_t mode)
 {
     return shm_open(name, oflag, mode);
 }
+
+int iox_shm_unlink(const char* name)
+{
+    int state = shm_unlink(name);
+    // according to mac os shm_unlink sets errno to ENOENT when the name is invalid
+    // and never EINVAL - but it is actually set when ENOENT should be set.
+    // See:
+    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/shm_unlink.2.html
+    if (errno == EINVAL)
+    {
+        errno = ENOENT;
+    }
+    return state;
+}

iceoryx_hoofs/platform/qnx/include/iceoryx_hoofs/platform/mman.hpp

@@ -20,5 +20,6 @@
 #include <sys/mman.h>
 
 int iox_shm_open(const char* name, int oflag, mode_t mode);
+int iox_shm_unlink(const char* name);
 
-#endif // IOX_HOOFS_QNX_PLATFORM_MMAN_HPP
+#endif // IOX_HOOFS_QNX_PLATFORM_MMAN_HPP

iceoryx_hoofs/platform/qnx/include/iceoryx_hoofs/platform/platform_settings.hpp

@@ -27,10 +27,14 @@ class UnixDomainSocket;
 
 namespace platform
 {
+constexpr uint64_t IOX_MAX_FILENAME_LENGTH = 255U;
+constexpr uint64_t IOX_MAX_PATH_LENGTH = 1023U;
 constexpr bool IOX_SHM_WRITE_ZEROS_ON_CREATION = true;
+constexpr uint64_t IOX_MAX_SHM_NAME_LENGTH = 1024U;
 constexpr const char IOX_PATH_SEPARATORS[] = "/";
 constexpr uint64_t IOX_UDS_SOCKET_MAX_MESSAGE_SIZE = 4096;
-constexpr char IOX_UDS_SOCKET_PATH_PREFIX[] = "/tmp/";
+constexpr const char IOX_UDS_SOCKET_PATH_PREFIX[] = "/tmp/";
+constexpr const char IOX_LOCK_FILE_PATH_PREFIX[] = "/var/lock/";
 using IoxIpcChannelType = iox::posix::UnixDomainSocket;
 } // namespace platform
 } // namespace iox

iceoryx_hoofs/platform/qnx/source/mman.cpp

@@ -20,3 +20,8 @@ int iox_shm_open(const char* name, int oflag, mode_t mode)
 {
     return shm_open(name, oflag, mode);
 }
+
+int iox_shm_unlink(const char* name)
+{
+    return shm_unlink(name);
+}

iceoryx_hoofs/platform/win/include/iceoryx_hoofs/platform/handle_translator.hpp

@@ -0,0 +1,41 @@
+// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+#ifndef IOX_HOOFS_WIN_PLATFORM_HANDLE_TRANSLATOR_HPP
+#define IOX_HOOFS_WIN_PLATFORM_HANDLE_TRANSLATOR_HPP
+
+#include "iceoryx_hoofs/platform/windows.hpp"
+#include <vector>
+
+/// @brief In windows file handles have the type HANDLE (void*) in linux it is
+///        usually an int. To establish the portability we keep track of the
+///        windows handles and assign them a unique int so that they can be used
+///        in a platform independent manner.
+///        This class translates a windows handle of type HANDLE to its linux
+///        file handle int pendant.
+class HandleTranslator
+{
+  public:
+    static HandleTranslator& getInstance() noexcept;
+    HANDLE get(const int handle) const noexcept;
+    int add(HANDLE handle) noexcept;
+    void remove(const int handle) noexcept;
+
+  private:
+    HandleTranslator() noexcept = default;
+    std::vector<HANDLE> m_handleList;
+};
+
+#endif

iceoryx_hoofs/platform/win/include/iceoryx_hoofs/platform/ipc_handle_manager.hpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+#ifndef IOX_HOOFS_WIN_PLATFORM_IPC_HANDLE_MANAGER_HPP
+#define IOX_HOOFS_WIN_PLATFORM_IPC_HANDLE_MANAGER_HPP
+
+#include "iceoryx_hoofs/platform/unique_system_id.hpp"
+#include "iceoryx_hoofs/platform/windows.hpp"
+#include <map>
+
+
+enum class OwnerShip
+{
+    OWN,
+    LOAN,
+};
+
+struct IpcHandle_t
+{
+    OwnerShip ownerShip = OwnerShip::LOAN;
+    HANDLE handle = nullptr;
+};
+
+class IpcHandleManager
+{
+  public:
+    ~IpcHandleManager() noexcept;
+
+    bool getHandle(const UniqueSystemId& id, HANDLE& handle) noexcept;
+    void addHandle(const UniqueSystemId& id, const OwnerShip ownerShip, HANDLE handle) noexcept;
+    void removeHandle(const UniqueSystemId& id) noexcept;
+
+  private:
+    std::map<UniqueSystemId, IpcHandle_t> ipcHandles;
+};
+
+#endif

iceoryx_hoofs/platform/win/include/iceoryx_hoofs/platform/mman.hpp

@@ -42,5 +42,5 @@ int munmap(void* addr, size_t length);
 
 int iox_shm_open(const char* name, int oflag, mode_t mode);
 
-int shm_unlink(const char* name);
+int iox_shm_unlink(const char* name);
 #endif // IOX_HOOFS_WIN_PLATFORM_MMAN_HPP

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