Added a cleanup interface for the synchronization facilities

Author: mutouyun

include/libipc/condition.h

@@ -26,6 +26,9 @@ class IPC_EXPORT condition {
     bool open(char const *name) noexcept;
     void close() noexcept;
 
+    void clear() noexcept;
+    static void clear_storage(char const * name) noexcept;
+
     bool wait(ipc::sync::mutex &mtx, std::uint64_t tm = ipc::invalid_value) noexcept;
     bool notify(ipc::sync::mutex &mtx) noexcept;
     bool broadcast(ipc::sync::mutex &mtx) noexcept;

include/libipc/mutex.h

@@ -26,6 +26,9 @@ class IPC_EXPORT mutex {
     bool open(char const *name) noexcept;
     void close() noexcept;
 
+    void clear() noexcept;
+    static void clear_storage(char const * name) noexcept;
+
     bool lock(std::uint64_t tm = ipc::invalid_value) noexcept;
     bool try_lock() noexcept(false); // std::system_error
     bool unlock() noexcept;

include/libipc/semaphore.h

@@ -25,6 +25,9 @@ class IPC_EXPORT semaphore {
     bool open(char const *name, std::uint32_t count = 0) noexcept;
     void close() noexcept;
 
+    void clear() noexcept;
+    static void clear_storage(char const * name) noexcept;
+
     bool wait(std::uint64_t tm = ipc::invalid_value) noexcept;
     bool post(std::uint32_t count = 1) noexcept;
 

src/libipc/platform/linux/mutex.h

@@ -136,7 +136,7 @@ class mutex {
     }
 
     template <typename F>
-    void release_mutex(ipc::string const &name, F &&clear) {
+    static void release_mutex(ipc::string const &name, F &&clear) {
         if (name.empty()) return;
         auto &info = curr_prog::get();
         IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
@@ -192,6 +192,23 @@ class mutex {
         ref_   = nullptr;
     }
 
+    void clear() noexcept {
+        if (mutex_ != nullptr) {
+            if (mutex_->name() != nullptr) {
+                release_mutex(mutex_->name(), [] { return true; });
+            }
+            mutex_->clear();
+        }
+        mutex_ = nullptr;
+        ref_   = nullptr;
+    }
+
+    static void clear_storage(char const *name) noexcept {
+        if (name == nullptr) return;
+        release_mutex(name, [] { return true; });
+        robust_mutex::clear_storage(name);
+    }
+
     bool lock(std::uint64_t tm) noexcept {
         if (!valid()) return false;
         return mutex_->lock(tm);

src/libipc/platform/linux/sync_obj_impl.h

@@ -62,6 +62,15 @@ class obj_impl {
         shm_.release();
         h_ = nullptr;
     }
+
+    void clear() noexcept {
+        shm_.clear(); // Make sure the storage is cleaned up.
+        h_ = nullptr;
+    }
+
+    static void clear_storage(char const *name) noexcept {
+        ipc::shm::handle::clear_storage(name);
+    }
 };
 
 } // namespace sync

src/libipc/platform/posix/condition.h

@@ -88,6 +88,21 @@ class condition {
         cond_ = nullptr;
     }
 
+    void clear() noexcept {
+        if ((shm_.ref() <= 1) && cond_ != nullptr) {
+            int eno;
+            if ((eno = ::pthread_cond_destroy(cond_)) != 0) {
+                ipc::error("fail pthread_cond_destroy[%d]\n", eno);
+            }
+        }
+        shm_.clear(); // Make sure the storage is cleaned up.
+        cond_ = nullptr;
+    }
+
+    static void clear_storage(char const *name) noexcept {
+        ipc::shm::handle::clear_storage(name);
+    }
+
     bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
         if (!valid()) return false;
         switch (tm) {

src/libipc/platform/posix/mutex.h

@@ -71,7 +71,7 @@ class mutex {
     }
 
     template <typename F>
-    void release_mutex(ipc::string const &name, F &&clear) {
+    static void release_mutex(ipc::string const &name, F &&clear) {
         if (name.empty()) return;
         auto &info = curr_prog::get();
         IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
@@ -169,6 +169,30 @@ class mutex {
         mutex_ = nullptr;
     }
 
+    void clear() noexcept {
+        if ((shm_ != nullptr) && (mutex_ != nullptr)) {
+            if (shm_->name() != nullptr) {
+                release_mutex(shm_->name(), [this] {
+                    int eno;
+                    if ((eno = ::pthread_mutex_destroy(mutex_)) != 0) {
+                        ipc::error("fail pthread_mutex_destroy[%d]\n", eno);
+                    }
+                    return true;
+                });
+            }
+            shm_->clear();
+        }
+        shm_   = nullptr;
+        ref_   = nullptr;
+        mutex_ = nullptr;
+    }
+
+    static void clear_storage(char const *name) noexcept {
+        if (name == nullptr) return;
+        release_mutex(name, [] { return true; });
+        ipc::shm::handle::clear_storage(name);
+    }
+
     bool lock(std::uint64_t tm) noexcept {
         if (!valid()) return false;
         for (;;) {

src/libipc/platform/posix/semaphore_impl.h

@@ -62,6 +62,24 @@ class semaphore {
         }
     }
 
+    void clear() noexcept {
+        if (valid()) {
+            if (::sem_close(h_) != 0) {
+                ipc::error("fail sem_close[%d]: %s\n", errno);
+            }
+            h_ = SEM_FAILED;
+        }
+        char const *name = shm_.name();
+        if (name == nullptr) return;
+        ::sem_unlink(name);
+        shm_.clear(); // Make sure the storage is cleaned up.
+    }
+
+    static void clear_storage(char const *name) noexcept {
+        ::sem_unlink(name);
+        ipc::shm::handle::clear_storage(name);
+    }
+
     bool wait(std::uint64_t tm) noexcept {
         if (!valid()) return false;
         if (tm == invalid_value) {

src/libipc/platform/posix/shm_posix.cpp

@@ -188,7 +188,7 @@ void remove(id_t id) noexcept {
     }
 }
 
-void remove(char const * name) {
+void remove(char const * name) noexcept {
     if (!is_valid_string(name)) {
         ipc::error("fail remove: name is empty\n");
         return;

src/libipc/platform/win/condition.h

@@ -67,6 +67,16 @@ class condition {
         shm_.release();
     }
 
+    void clear() noexcept {
+        close();
+    }
+
+    static void clear_storage(char const *name) noexcept {
+        ipc::shm::handle::clear_storage(name);
+        ipc::sync::mutex::clear_storage(name);
+        ipc::sync::semaphore::clear_storage(name);
+    }
+
     bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
         if (!valid()) return false;
         auto &cnt = counter();