merging refactor (replacing)

slsDetectorSoftware/include/SharedMemory.h

@@ -0,0 +1,304 @@
+#pragma once
+/************************************************
+ * @file SharedMemory.h
+ * @short functions basic implemenation of
+ * shared memory
+ ***********************************************/
+/**
+ *@short functions basic implemenation of shared memory
+ */
+
+#include "ansi.h"
+#include "logger.h"
+#include "sls_detector_exceptions.h"
+
+#include "stdlib.h"
+#include <cerrno>  // errno
+#include <cstring> // strerror
+#include <fcntl.h> // O_CREAT, O_TRUNC..
+#include <iostream>
+#include <sstream>
+#include <stdio.h>    // printf
+#include <sys/mman.h> // shared memory
+#include <sys/stat.h> // fstat
+#include <unistd.h>
+
+#define SHM_MULTI_PREFIX "/slsDetectorPackage_multi_"
+#define SHM_SLS_PREFIX "_sls_"
+#define SHM_ENV_NAME "SLSDETNAME"
+
+#include <iostream>
+#include <string>
+
+namespace sls {
+
+template <typename T>
+class SharedMemory {
+
+  public:
+    /**
+	 * Constructor
+	 * creates the single/multi detector shared memory name
+	 * @param multiId multi detector id
+     * @param slsId sls detector id, -1 if a multi detector shared memory
+ 	 */
+    SharedMemory(int multiId, int slsId) {
+        name = ConstructSharedMemoryName(multiId, slsId);
+    }
+
+    /** 
+     * Delete the copy constructor and copy assignment since we don't want two 
+     * objects managing the same resource
+     */
+    SharedMemory(const SharedMemory &) = delete;
+    SharedMemory &operator=(const SharedMemory &other) = delete;
+
+    //Move constructor
+    SharedMemory(SharedMemory &&other) : name(other.name),
+                                         fd(other.fd),
+                                         shmSize(other.shmSize),
+                                         shared_struct(other.shared_struct) {
+
+        other.fd = -1;
+        other.shared_struct = nullptr;
+        other.shmSize = 0;
+    }
+
+    //Move assignment
+    SharedMemory &operator=(SharedMemory &&other) {
+        name = other.name;
+        if (fd) {
+            close(fd);
+        }
+        fd = other.fd;
+        other.fd = -1;
+
+        if (shared_struct != nullptr) {
+            UnmapSharedMemory();
+        }
+        shared_struct = other.shared_struct;
+        other.shared_struct = nullptr;
+
+        shmSize = other.shmSize;
+        other.shmSize = 0;
+        return *this;
+    }
+
+    ~SharedMemory() {
+        if (fd >= 0)
+            close(fd);
+
+        if (shared_struct) {
+            UnmapSharedMemory();
+        }
+    }
+
+    /**
+     * Verify if it exists
+     * @param name of shared memory
+     * @return true if exists, else false
+     */
+    bool IsExisting() {
+        bool ret = true;
+        int tempfd = shm_open(name.c_str(), O_RDWR, 0);
+        if ((tempfd < 0) && (errno == ENOENT)) {
+            ret = false;
+        }
+        close(tempfd);
+        return ret;
+    }
+
+    /**
+	 * Get shared memory name
+	 */
+    std::string GetName() const {
+        return name;
+    }
+
+    size_t size() const {
+        return shmSize;
+    }
+
+    /**
+     * Create Shared memory and call MapSharedMemory to map it to an address
+     * throws a SharedMemoryError exception on failure to create, ftruncate or map
+     * @param sz of shared memory
+     */
+    void CreateSharedMemory() {
+        fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            std::string msg = "Create shared memory " + name + " failed: " + strerror(errno);
+            FILE_LOG(logERROR) << msg;
+            throw SharedMemoryError(msg);
+        }
+
+        if (ftruncate(fd, sizeof(T)) < 0) {
+            std::string msg = "Create shared memory " + name + " failed at ftruncate: " + strerror(errno);
+            FILE_LOG(logERROR) << msg;
+            close(fd);
+            RemoveSharedMemory();
+            throw SharedMemoryError(msg);
+        }
+
+        shared_struct = MapSharedMemory();
+        FILE_LOG(logINFO) << "Shared memory created " << name;
+    }
+
+    /**
+     * Open existing Shared memory and call MapSharedMemory to map it to an address
+     * throws a SharedMemoryError exception on failure to open or map
+     * @param sz of shared memory
+     */
+    void OpenSharedMemory() {
+        fd = shm_open(name.c_str(), O_RDWR, 0);
+        if (fd < 0) {
+            std::string msg = "Open existing shared memory " + name + " failed: " + strerror(errno);
+            FILE_LOG(logERROR) << msg;
+            throw SharedMemoryError(msg);
+        }
+
+        shared_struct = MapSharedMemory();
+    }
+
+    /**
+     * Unmap shared memory from an address
+     * throws a SharedMemoryError exception on failure
+     */
+    void UnmapSharedMemory() {
+        if (shared_struct != nullptr) {
+            if (munmap(shared_struct, shmSize) < 0) {
+                std::string msg = "Unmapping shared memory " + name + " failed: " + strerror(errno);
+                FILE_LOG(logERROR) << msg;
+                close(fd);
+                throw SharedMemoryError(msg);
+            }
+            shared_struct = nullptr;
+        }
+    }
+
+    /**
+	 * Remove existing Shared memory
+	 */
+    void RemoveSharedMemory() {
+        UnmapSharedMemory();
+        if (shm_unlink(name.c_str()) < 0) {
+            // silent exit if shm did not exist anyway
+            if (errno == ENOENT)
+                return;
+            std::string msg = "Free Shared Memory " + name + " Failed: " + strerror(errno);
+            FILE_LOG(logERROR) << msg;
+            throw SharedMemoryError(msg);
+        }
+        FILE_LOG(logINFO) << "Shared memory deleted " << name;
+    }
+
+    /**
+     * Maximum length of name as from man pages
+     */
+    static const int NAME_MAX_LENGTH = 255;
+
+    /**
+    *Using the call operator to access the pointer
+    */
+    T *operator()() {
+        return shared_struct;
+    }
+
+    /**
+    *Using the call operator to access the pointer, const overload
+    */
+    const T *operator()() const {
+        return shared_struct;
+    }
+
+  private:
+    /**
+     * Create Shared memory name
+     * throws exception if name created is longer than required 255(manpages)
+     * @param multiId multi detector id
+     * @param slsId sls detector id, -1 if a multi detector shared memory
+     * @returns shared memory name
+     */
+    std::string ConstructSharedMemoryName(int multiId, int slsId) {
+
+        // using environment path
+        std::string sEnvPath = "";
+        char *envpath = getenv(SHM_ENV_NAME);
+        if (envpath != nullptr) {
+            sEnvPath.assign(envpath);
+            sEnvPath.insert(0, "_");
+        }
+
+        std::stringstream ss;
+        if (slsId < 0)
+            ss << SHM_MULTI_PREFIX << multiId << sEnvPath;
+        else
+            ss << SHM_MULTI_PREFIX << multiId << SHM_SLS_PREFIX << slsId << sEnvPath;
+
+        std::string temp = ss.str();
+        if (temp.length() > NAME_MAX_LENGTH) {
+            std::string msg = "Shared memory initialization failed. " + temp + " has " + std::to_string(temp.length()) + " characters. \n" + "Maximum is " + std::to_string(NAME_MAX_LENGTH) + ". Change the environment variable " + SHM_ENV_NAME;
+            FILE_LOG(logERROR) << msg;
+            throw SharedMemoryError(msg);
+        }
+        return temp;
+    }
+
+    /**
+     * Map shared memory to an address
+     * throws a SharedMemoryException exception on failure
+     * @param sz of shared memory
+     */
+
+    T *MapSharedMemory() {
+        void *addr = mmap(nullptr, sizeof(T), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (addr == MAP_FAILED) {
+            std::string msg = "Mapping shared memory " + name + " failed: " + strerror(errno);
+            FILE_LOG(logERROR) << msg;
+            close(fd);
+            throw SharedMemoryError(msg);
+        }
+        shmSize = sizeof(T);
+        close(fd);
+        return (T *)addr;
+    }
+
+    /**
+     * Verify if existing shared memory size matches expected size
+     * @param expectedSize expected size of shared memory, replaced with smaller size if size does not match
+     * @return 0 for success, 1 for fail
+     */
+    int VerifySizeMatch(size_t expectedSize) {
+        struct stat sb;
+        // could not fstat
+        if (fstat(fd, &sb) < 0) {
+            std::string msg = "Could not verify existing shared memory " + name + " size match " + "(could not fstat): " + strerror(errno);
+            FILE_LOG(logERROR) << msg;
+            close(fd);
+            throw SharedMemoryError(msg);
+        }
+
+        //size does not match
+        auto sz = static_cast<size_t>(sb.st_size);
+        if (sz != expectedSize) {
+            std::string msg = "Existing shared memory " + name + " size does not match" + "Expected " + std::to_string(expectedSize) + ", found " + std::to_string(sz);
+            FILE_LOG(logERROR) << msg;
+            throw SharedMemoryError(msg);
+            return 1;
+        }
+        return 0;
+    }
+
+    /** Shared memory name */
+    std::string name;
+
+    /** File descriptor */
+    int fd{-1};
+
+    /** shm size */
+    size_t shmSize{0};
+
+    T *shared_struct{nullptr};
+};
+
+} // namespace sls