From e9a7dbaa74458797ce490ef0f4f95d4920944f51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9C=A8=E5=A4=B4=E4=BA=91?= <372449116@qq.com>
Date: Mon, 15 Dec 2025 09:37:50 +0000
Subject: [PATCH] refactor(log): replace utility/log with imp/log in all
 platform and sync files

- Replace include "libipc/utility/log.h" with "libipc/imp/log.h" in all files
- Add LIBIPC_LOG() to functions that use logging
- Replace ipc::error() and ipc::log() calls with log.error() and log.debug()
- Use type-safe streaming interface instead of printf-style formatting
- Remove manual newline characters from log messages

Modified files:
- Linux platform: condition.h, get_wait_time.h, mutex.h, sync_obj_impl.h
- POSIX platform: condition.h, get_wait_time.h, mutex.h, semaphore_impl.h, shm_posix.cpp
- Windows platform: condition.h, get_sa.h, mutex.h, semaphore.h, shm_win.cpp
- Sync layer: condition.cpp, mutex.cpp, semaphore.cpp

Total: 17 files updated with comprehensive log interface migration
---
 src/libipc/platform/linux/condition.h      |  14 +-
 src/libipc/platform/linux/get_wait_time.h  |  13 +-
 src/libipc/platform/linux/mutex.h          |  19 +-
 src/libipc/platform/linux/sync_obj_impl.h  |   5 +-
 src/libipc/platform/posix/condition.h      |  24 +-
 src/libipc/platform/posix/get_wait_time.h  |   4 +-
 src/libipc/platform/posix/mutex.h          |  24 +-
 src/libipc/platform/posix/semaphore_impl.h |  16 +-
 src/libipc/platform/posix/shm_posix.cpp    |  37 +-
 src/libipc/platform/win/condition.h        |   2 +-
 src/libipc/platform/win/get_sa.h           |   4 +-
 src/libipc/platform/win/mutex.h            |   4 +-
 src/libipc/platform/win/semaphore.h        |   4 +-
 src/libipc/platform/win/shm_win.cpp        | 372 ++++++++++-----------
 src/libipc/sync/condition.cpp              |   4 +-
 src/libipc/sync/mutex.cpp                  |   4 +-
 src/libipc/sync/semaphore.cpp              |   4 +-
 17 files changed, 282 insertions(+), 272 deletions(-)

diff --git a/src/libipc/platform/linux/condition.h b/src/libipc/platform/linux/condition.h
index b13920f..88b280b 100644
--- a/src/libipc/platform/linux/condition.h
+++ b/src/libipc/platform/linux/condition.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/mutex.h"
 
 #include "get_wait_time.h"
@@ -19,11 +19,12 @@ public:
     ~condition() = default;
 
     bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
+        LIBIPC_LOG();
         if (!valid()) return false;
         if (tm == invalid_value) {
             int eno = A0_SYSERR(a0_cnd_wait(native(), static_cast<a0_mtx_t *>(mtx.native())));
             if (eno != 0) {
-                ipc::error("fail condition wait[%d]\n", eno);
+                log.error("fail condition wait[", eno, "]");
                 return false;
             }
         } else {
@@ -31,8 +32,7 @@ public:
             int eno = A0_SYSERR(a0_cnd_timedwait(native(), static_cast<a0_mtx_t *>(mtx.native()), {ts}));
             if (eno != 0) {
                 if (eno != ETIMEDOUT) {
-                    ipc::error("fail condition timedwait[%d]: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                                eno, tm, ts.tv_sec, ts.tv_nsec);
+                    log.error("fail condition timedwait[", eno, "]: tm = ", tm, ", tv_sec = ", ts.tv_sec, ", tv_nsec = ", ts.tv_nsec);
                 }
                 return false;
             }
@@ -41,20 +41,22 @@ public:
     }
 
     bool notify(ipc::sync::mutex &mtx) noexcept {
+        LIBIPC_LOG();
         if (!valid()) return false;
         int eno = A0_SYSERR(a0_cnd_signal(native(), static_cast<a0_mtx_t *>(mtx.native())));
         if (eno != 0) {
-            ipc::error("fail condition notify[%d]\n", eno);
+            log.error("fail condition notify[", eno, "]");
             return false;
         }
         return true;
     }
 
     bool broadcast(ipc::sync::mutex &mtx) noexcept {
+        LIBIPC_LOG();
         if (!valid()) return false;
         int eno = A0_SYSERR(a0_cnd_broadcast(native(), static_cast<a0_mtx_t *>(mtx.native())));
         if (eno != 0) {
-            ipc::error("fail condition broadcast[%d]\n", eno);
+            log.error("fail condition broadcast[", eno, "]");
             return false;
         }
         return true;
diff --git a/src/libipc/platform/linux/get_wait_time.h b/src/libipc/platform/linux/get_wait_time.h
index 3600d8d..8af32f7 100644
--- a/src/libipc/platform/linux/get_wait_time.h
+++ b/src/libipc/platform/linux/get_wait_time.h
@@ -4,7 +4,7 @@
 #include <cinttypes>
 #include <system_error>
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 
 #include "a0/time.h"
 #include "a0/err_macro.h"
@@ -14,30 +14,31 @@ namespace linux_ {
 namespace detail {
 
 inline bool calc_wait_time(timespec &ts, std::uint64_t tm /*ms*/) noexcept {
+    LIBIPC_LOG();
     std::int64_t add_ns = static_cast<std::int64_t>(tm * 1000000ull);
     if (add_ns < 0) {
-        ipc::error("invalid time = " PRIu64 "\n", tm);
+        log.error("invalid time = ", tm);
         return false;
     }
     a0_time_mono_t now;
     int eno = A0_SYSERR(a0_time_mono_now(&now));
     if (eno != 0) {
-        ipc::error("fail get time[%d]\n", eno);
+        log.error("fail get time[", eno, "]");
         return false;
     }
     a0_time_mono_t *target = reinterpret_cast<a0_time_mono_t *>(&ts);
     if ((eno = A0_SYSERR(a0_time_mono_add(now, add_ns, target))) != 0) {
-        ipc::error("fail get time[%d]\n", eno);
+        log.error("fail get time[", eno, "]");
         return false;
     }
     return true;
 }
 
 inline timespec make_timespec(std::uint64_t tm /*ms*/) noexcept(false) {
+    LIBIPC_LOG();
     timespec ts {};
     if (!calc_wait_time(ts, tm)) {
-        ipc::error("fail calc_wait_time: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                    tm, ts.tv_sec, ts.tv_nsec);
+        log.error("fail calc_wait_time: tm = ", tm, ", tv_sec = ", ts.tv_sec, ", tv_nsec = ", ts.tv_nsec);
         throw std::system_error{static_cast<int>(errno), std::system_category()};
     }
     return ts;
diff --git a/src/libipc/platform/linux/mutex.h b/src/libipc/platform/linux/mutex.h
index 021e006..296530b 100644
--- a/src/libipc/platform/linux/mutex.h
+++ b/src/libipc/platform/linux/mutex.h
@@ -6,7 +6,7 @@
 #include <atomic>
 
 #include "libipc/platform/detail.h"
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/mem/resource.h"
 #include "libipc/shm.h"
 
@@ -23,6 +23,7 @@ namespace sync {
 class robust_mutex : public sync::obj_impl<a0_mtx_t> {
 public:
     bool lock(std::uint64_t tm) noexcept {
+        LIBIPC_LOG();
         if (!valid()) return false;
         for (;;) {
             auto ts = linux_::detail::make_timespec(tm);
@@ -37,24 +38,25 @@ public:
             case EOWNERDEAD: {
                     int eno2 = A0_SYSERR(a0_mtx_consistent(native()));
                     if (eno2 != 0) {
-                        ipc::error("fail mutex lock[%d] -> consistent[%d]\n", eno, eno2);
+                        log.error("fail mutex lock[", eno, "] -> consistent[", eno2, "]");
                         return false;
                     }
                     int eno3 = A0_SYSERR(a0_mtx_unlock(native()));
                     if (eno3 != 0) {
-                        ipc::error("fail mutex lock[%d] -> unlock[%d]\n", eno, eno3);
+                        log.error("fail mutex lock[", eno, "] -> unlock[", eno3, "]");
                         return false;
                     }
                 }
                 break; // loop again
             default:
-                ipc::error("fail mutex lock[%d]\n", eno);
+                log.error("fail mutex lock[", eno, "]");
                 return false;
             }
         }
     }
 
     bool try_lock() noexcept(false) {
+        LIBIPC_LOG();
         if (!valid()) return false;
         int eno = A0_SYSERR(a0_mtx_timedlock(native(), {linux_::detail::make_timespec(0)}));
         switch (eno) {
@@ -65,28 +67,29 @@ public:
         case EOWNERDEAD: {
                 int eno2 = A0_SYSERR(a0_mtx_consistent(native()));
                 if (eno2 != 0) {
-                    ipc::error("fail mutex try_lock[%d] -> consistent[%d]\n", eno, eno2);
+                    log.error("fail mutex try_lock[", eno, "] -> consistent[", eno2, "]");
                     break;
                 }
                 int eno3 = A0_SYSERR(a0_mtx_unlock(native()));
                 if (eno3 != 0) {
-                    ipc::error("fail mutex try_lock[%d] -> unlock[%d]\n", eno, eno3);
+                    log.error("fail mutex try_lock[", eno, "] -> unlock[", eno3, "]");
                     break;
                 }
             }
             break;
         default:
-            ipc::error("fail mutex try_lock[%d]\n", eno);
+            log.error("fail mutex try_lock[", eno, "]");
             break;
         }
         throw std::system_error{eno, std::system_category()};
     }
 
     bool unlock() noexcept {
+        LIBIPC_LOG();
         if (!valid()) return false;
         int eno = A0_SYSERR(a0_mtx_unlock(native()));
         if (eno != 0) {
-            ipc::error("fail mutex unlock[%d]\n", eno);
+            log.error("fail mutex unlock[", eno, "]");
             return false;
         }
         return true;
diff --git a/src/libipc/platform/linux/sync_obj_impl.h b/src/libipc/platform/linux/sync_obj_impl.h
index f7cb018..4a94c14 100644
--- a/src/libipc/platform/linux/sync_obj_impl.h
+++ b/src/libipc/platform/linux/sync_obj_impl.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/shm.h"
 
 #include "a0/empty.h"
@@ -19,8 +19,9 @@ protected:
     sync_t *h_ = nullptr;
 
     sync_t *acquire_handle(char const *name) {
+        LIBIPC_LOG();
         if (!shm_.acquire(name, sizeof(sync_t))) {
-            ipc::error("[acquire_handle] fail shm.acquire: %s\n", name);
+            log.error("[acquire_handle] fail shm.acquire: ", name);
             return nullptr;
         }
         return static_cast<sync_t *>(shm_.get());
diff --git a/src/libipc/platform/posix/condition.h b/src/libipc/platform/posix/condition.h
index 2b543a2..e53980d 100644
--- a/src/libipc/platform/posix/condition.h
+++ b/src/libipc/platform/posix/condition.h
@@ -5,7 +5,7 @@
 
 #include <pthread.h>
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/utility/scope_guard.h"
 #include "libipc/mutex.h"
 #include "libipc/shm.h"
@@ -21,8 +21,9 @@ class condition {
     pthread_cond_t *cond_ = nullptr;
 
     pthread_cond_t *acquire_cond(char const *name) {
+        LIBIPC_LOG();
         if (!shm_.acquire(name, sizeof(pthread_cond_t))) {
-            ipc::error("[acquire_cond] fail shm.acquire: %s\n", name);
+            log.error("[acquire_cond] fail shm.acquire: %s", name);
             return nullptr;
         }
         return static_cast<pthread_cond_t *>(shm_.get());
@@ -47,6 +48,7 @@ public:
     }
 
     bool open(char const *name) noexcept {
+        LIBIPC_LOG();
         close();
         if ((cond_ = acquire_cond(name)) == nullptr) {
             return false;
@@ -60,17 +62,17 @@ public:
         int eno;
         pthread_condattr_t cond_attr;
         if ((eno = ::pthread_condattr_init(&cond_attr)) != 0) {
-            ipc::error("fail pthread_condattr_init[%d]\n", eno);
+            log.error("fail pthread_condattr_init[%d]", eno);
             return false;
         }
         LIBIPC_UNUSED auto guard_cond_attr = guard([&cond_attr] { ::pthread_condattr_destroy(&cond_attr); });
         if ((eno = ::pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED)) != 0) {
-            ipc::error("fail pthread_condattr_setpshared[%d]\n", eno);
+            log.error("fail pthread_condattr_setpshared[%d]", eno);
             return false;
         }
         *cond_ = PTHREAD_COND_INITIALIZER;
         if ((eno = ::pthread_cond_init(cond_, &cond_attr)) != 0) {
-            ipc::error("fail pthread_cond_init[%d]\n", eno);
+            log.error("fail pthread_cond_init[%d]", eno);
             return false;
         }
         finally.dismiss();
@@ -78,10 +80,11 @@ public:
     }
 
     void close() noexcept {
+        LIBIPC_LOG();
         if ((shm_.ref() <= 1) && cond_ != nullptr) {
             int eno;
             if ((eno = ::pthread_cond_destroy(cond_)) != 0) {
-                ipc::error("fail pthread_cond_destroy[%d]\n", eno);
+                log.error("fail pthread_cond_destroy[%d]", eno);
             }
         }
         shm_.release();
@@ -92,7 +95,7 @@ public:
         if ((shm_.ref() <= 1) && cond_ != nullptr) {
             int eno;
             if ((eno = ::pthread_cond_destroy(cond_)) != 0) {
-                ipc::error("fail pthread_cond_destroy[%d]\n", eno);
+                log.error("fail pthread_cond_destroy[%d]", eno);
             }
         }
         shm_.clear(); // Make sure the storage is cleaned up.
@@ -104,12 +107,13 @@ public:
     }
 
     bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
+        LIBIPC_LOG();
         if (!valid()) return false;
         switch (tm) {
         case invalid_value: {
                 int eno;
                 if ((eno = ::pthread_cond_wait(cond_, static_cast<pthread_mutex_t *>(mtx.native()))) != 0) {
-                    ipc::error("fail pthread_cond_wait[%d]\n", eno);
+                    log.error("fail pthread_cond_wait[%d]", eno);
                     return false;
                 }
             }
@@ -134,7 +138,7 @@ public:
         if (!valid()) return false;
         int eno;
         if ((eno = ::pthread_cond_signal(cond_)) != 0) {
-            ipc::error("fail pthread_cond_signal[%d]\n", eno);
+            log.error("fail pthread_cond_signal[%d]", eno);
             return false;
         }
         return true;
@@ -144,7 +148,7 @@ public:
         if (!valid()) return false;
         int eno;
         if ((eno = ::pthread_cond_broadcast(cond_)) != 0) {
-            ipc::error("fail pthread_cond_broadcast[%d]\n", eno);
+            log.error("fail pthread_cond_broadcast[%d]", eno);
             return false;
         }
         return true;
diff --git a/src/libipc/platform/posix/get_wait_time.h b/src/libipc/platform/posix/get_wait_time.h
index 44faf7d..09dcacf 100644
--- a/src/libipc/platform/posix/get_wait_time.h
+++ b/src/libipc/platform/posix/get_wait_time.h
@@ -7,7 +7,7 @@
 #include <time.h>
 #include <errno.h>
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 
 namespace ipc {
 namespace posix_ {
@@ -17,7 +17,7 @@ inline bool calc_wait_time(timespec &ts, std::uint64_t tm /*ms*/) noexcept {
     timeval now;
     int eno = ::gettimeofday(&now, NULL);
     if (eno != 0) {
-        ipc::error("fail gettimeofday [%d]\n", eno);
+        log.error("fail gettimeofday [", eno, "]");
         return false;
     }
     ts.tv_nsec = (now.tv_usec + (tm % 1000) * 1000) * 1000;
diff --git a/src/libipc/platform/posix/mutex.h b/src/libipc/platform/posix/mutex.h
index 050dfc6..b699ed8 100644
--- a/src/libipc/platform/posix/mutex.h
+++ b/src/libipc/platform/posix/mutex.h
@@ -10,7 +10,7 @@
 #include <pthread.h>
 
 #include "libipc/platform/detail.h"
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/utility/scope_guard.h"
 #include "libipc/mem/resource.h"
 #include "libipc/shm.h"
@@ -127,21 +127,21 @@ public:
         int eno;
         pthread_mutexattr_t mutex_attr;
         if ((eno = ::pthread_mutexattr_init(&mutex_attr)) != 0) {
-            ipc::error("fail pthread_mutexattr_init[%d]\n", eno);
+            log.error("fail pthread_mutexattr_init[", eno, "]");
             return false;
         }
         LIBIPC_UNUSED auto guard_mutex_attr = guard([&mutex_attr] { ::pthread_mutexattr_destroy(&mutex_attr); });
         if ((eno = ::pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED)) != 0) {
-            ipc::error("fail pthread_mutexattr_setpshared[%d]\n", eno);
+            log.error("fail pthread_mutexattr_setpshared[", eno, "]");
             return false;
         }
         if ((eno = ::pthread_mutexattr_setrobust(&mutex_attr, PTHREAD_MUTEX_ROBUST)) != 0) {
-            ipc::error("fail pthread_mutexattr_setrobust[%d]\n", eno);
+            log.error("fail pthread_mutexattr_setrobust[", eno, "]");
             return false;
         }
         *mutex_ = PTHREAD_MUTEX_INITIALIZER;
         if ((eno = ::pthread_mutex_init(mutex_, &mutex_attr)) != 0) {
-            ipc::error("fail pthread_mutex_init[%d]\n", eno);
+            log.error("fail pthread_mutex_init[", eno, "]");
             return false;
         }
         finally.dismiss();
@@ -165,7 +165,7 @@ public:
                         
                         int eno;
                         if ((eno = ::pthread_mutex_destroy(mutex_)) != 0) {
-                            ipc::error("fail pthread_mutex_destroy[%d]\n", eno);
+                            log.error("fail pthread_mutex_destroy[", eno, "]");
                         }
                         return true;
                     }
@@ -187,7 +187,7 @@ public:
                     
                     int eno;
                     if ((eno = ::pthread_mutex_destroy(mutex_)) != 0) {
-                        ipc::error("fail pthread_mutex_destroy[%d]\n", eno);
+                        log.error("fail pthread_mutex_destroy[", eno, "]");
                     }
                     shm_->clear();
                     return true;
@@ -222,7 +222,7 @@ public:
                     // but the previous owner died. We need to make it consistent.
                     int eno2 = ::pthread_mutex_consistent(mutex_);
                     if (eno2 != 0) {
-                        ipc::error("fail pthread_mutex_lock[%d], pthread_mutex_consistent[%d]\n", eno, eno2);
+                        log.error("fail pthread_mutex_lock[", eno, "], pthread_mutex_consistent[", eno2, "]");
                         return false;
                     }
                     // After calling pthread_mutex_consistent(), the mutex is now in a
@@ -230,7 +230,7 @@ public:
                     return true;
                 }
             default:
-                ipc::error("fail pthread_mutex_lock[%d]\n", eno);
+                log.error("fail pthread_mutex_lock[", eno, "]");
                 return false;
             }
         }
@@ -250,7 +250,7 @@ public:
                 // but the previous owner died. We need to make it consistent.
                 int eno2 = ::pthread_mutex_consistent(mutex_);
                 if (eno2 != 0) {
-                    ipc::error("fail pthread_mutex_timedlock[%d], pthread_mutex_consistent[%d]\n", eno, eno2);
+                    log.error("fail pthread_mutex_timedlock[", eno, "], pthread_mutex_consistent[", eno2, "]");
                     throw std::system_error{eno2, std::system_category()};
                 }
                 // After calling pthread_mutex_consistent(), the mutex is now in a
@@ -258,7 +258,7 @@ public:
                 return true;
             }
         default:
-            ipc::error("fail pthread_mutex_timedlock[%d]\n", eno);
+            log.error("fail pthread_mutex_timedlock[", eno, "]");
             break;
         }
         throw std::system_error{eno, std::system_category()};
@@ -268,7 +268,7 @@ public:
         if (!valid()) return false;
         int eno;
         if ((eno = ::pthread_mutex_unlock(mutex_)) != 0) {
-            ipc::error("fail pthread_mutex_unlock[%d]\n", eno);
+            log.error("fail pthread_mutex_unlock[", eno, "]");
             return false;
         }
         return true;
diff --git a/src/libipc/platform/posix/semaphore_impl.h b/src/libipc/platform/posix/semaphore_impl.h
index 8d5a1e8..a61f73c 100644
--- a/src/libipc/platform/posix/semaphore_impl.h
+++ b/src/libipc/platform/posix/semaphore_impl.h
@@ -7,7 +7,7 @@
 #include <semaphore.h>
 #include <errno.h>
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/shm.h"
 
 #include "get_wait_time.h"
@@ -36,7 +36,7 @@ public:
     bool open(char const *name, std::uint32_t count) noexcept {
         close();
         if (!shm_.acquire(name, 1)) {
-            ipc::error("[open_semaphore] fail shm.acquire: %s\n", name);
+            log.error("[open_semaphore] fail shm.acquire: ", name, "");
             return false;
         }
         // POSIX semaphore names must start with "/" on some platforms (e.g., FreeBSD)
@@ -48,7 +48,7 @@ public:
         }
         h_ = ::sem_open(sem_name_.c_str(), O_CREAT, 0666, static_cast<unsigned>(count));
         if (h_ == SEM_FAILED) {
-            ipc::error("fail sem_open[%d]: %s\n", errno, sem_name_.c_str());
+            log.error("fail sem_open[%d]: ", errno, sem_name_.c_str(, ""));
             return false;
         }
         return true;
@@ -57,13 +57,13 @@ public:
     void close() noexcept {
         if (!valid()) return;
         if (::sem_close(h_) != 0) {
-            ipc::error("fail sem_close[%d]: %s\n", errno);
+            log.error("fail sem_close[%d]: ", errno, "");
         }
         h_ = SEM_FAILED;
         if (!sem_name_.empty() && shm_.name() != nullptr) {
             if (shm_.release() <= 1) {
                 if (::sem_unlink(sem_name_.c_str()) != 0) {
-                    ipc::error("fail sem_unlink[%d]: %s, name: %s\n", errno, sem_name_.c_str());
+                    log.error("fail sem_unlink[%d]: ", errno, sem_name_.c_str(, ", name: %s"));
                 }
             }
         }
@@ -73,7 +73,7 @@ public:
     void clear() noexcept {
         if (valid()) {
             if (::sem_close(h_) != 0) {
-                ipc::error("fail sem_close[%d]: %s\n", errno);
+                log.error("fail sem_close[%d]: ", errno, "");
             }
             h_ = SEM_FAILED;
         }
@@ -100,7 +100,7 @@ public:
         if (!valid()) return false;
         if (tm == invalid_value) {
             if (::sem_wait(h_) != 0) {
-                ipc::error("fail sem_wait[%d]: %s\n", errno);
+                log.error("fail sem_wait[%d]: ", errno, "");
                 return false;
             }
         } else {
@@ -120,7 +120,7 @@ public:
         if (!valid()) return false;
         for (std::uint32_t i = 0; i < count; ++i) {
             if (::sem_post(h_) != 0) {
-                ipc::error("fail sem_post[%d]: %s\n", errno);
+                log.error("fail sem_post[%d]: ", errno, "");
                 return false;
             }
         }
diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
index bd03bf2..440692b 100644
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ b/src/libipc/platform/posix/shm_posix.cpp
@@ -14,7 +14,7 @@
 #include "libipc/shm.h"
 #include "libipc/def.h"
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/mem/resource.h"
 #include "libipc/mem/new.h"
 
@@ -46,7 +46,7 @@ namespace shm {
 
 id_t acquire(char const * name, std::size_t size, unsigned mode) {
     if (!is_valid_string(name)) {
-        ipc::error("fail acquire: name is empty\n");
+        log.error("fail acquire: name is empty");
         return nullptr;
     }
     // For portable use, a shared memory object should be identified by name of the form /somename.
@@ -79,7 +79,7 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
     if (fd == -1) {
         // only open shm not log error when file not exist
         if (open != mode || ENOENT != errno) {
-            ipc::error("fail shm_open[%d]: %s\n", errno, op_name.c_str());
+            log.error("fail shm_open[%d]: ", errno, op_name.c_str(, ""));
         }
         return nullptr;
     }
@@ -106,12 +106,12 @@ std::int32_t get_ref(id_t id) {
 
 void sub_ref(id_t id) {
     if (id == nullptr) {
-        ipc::error("fail sub_ref: invalid id (null)\n");
+        log.error("fail sub_ref: invalid id (null)");
         return;
     }
     auto ii = static_cast<id_info_t*>(id);
     if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail sub_ref: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
+        log.error("fail sub_ref: invalid id (mem = ", ii->mem_, ", size = ", ii->size_, ")");
         return;
     }
     acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel);
@@ -119,7 +119,7 @@ void sub_ref(id_t id) {
 
 void * get_mem(id_t id, std::size_t * size) {
     if (id == nullptr) {
-        ipc::error("fail get_mem: invalid id (null)\n");
+        log.error("fail get_mem: invalid id (null)");
         return nullptr;
     }
     auto ii = static_cast<id_info_t*>(id);
@@ -129,31 +129,31 @@ void * get_mem(id_t id, std::size_t * size) {
     }
     int fd = ii->fd_;
     if (fd == -1) {
-        ipc::error("fail get_mem: invalid id (fd = -1)\n");
+        log.error("fail get_mem: invalid id (fd = -1)");
         return nullptr;
     }
     if (ii->size_ == 0) {
         struct stat st;
         if (::fstat(fd, &st) != 0) {
-            ipc::error("fail fstat[%d]: %s, size = %zd\n", errno, ii->name_.c_str(), ii->size_);
+            log.error("fail fstat[%d]: ", errno, ii->name_.c_str(, ", size = %zd"), ii->size_);
             return nullptr;
         }
         ii->size_ = static_cast<std::size_t>(st.st_size);
         if ((ii->size_ <= sizeof(info_t)) || (ii->size_ % sizeof(info_t))) {
-            ipc::error("fail get_mem: %s, invalid size = %zd\n", ii->name_.c_str(), ii->size_);
+            log.error("fail get_mem: ", ii->name_.c_str(, ", invalid size = %zd"), ii->size_);
             return nullptr;
         }
     }
     else {
         ii->size_ = calc_size(ii->size_);
         if (::ftruncate(fd, static_cast<off_t>(ii->size_)) != 0) {
-            ipc::error("fail ftruncate[%d]: %s, size = %zd\n", errno, ii->name_.c_str(), ii->size_);
+            log.error("fail ftruncate[%d]: ", errno, ii->name_.c_str(, ", size = %zd"), ii->size_);
             return nullptr;
         }
     }
     void* mem = ::mmap(nullptr, ii->size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED) {
-        ipc::error("fail mmap[%d]: %s, size = %zd\n", errno, ii->name_.c_str(), ii->size_);
+        log.error("fail mmap[%d]: ", errno, ii->name_.c_str(, ", size = %zd"), ii->size_);
         return nullptr;
     }
     ::close(fd);
@@ -166,21 +166,20 @@ void * get_mem(id_t id, std::size_t * size) {
 
 std::int32_t release(id_t id) noexcept {
     if (id == nullptr) {
-        ipc::error("fail release: invalid id (null)\n");
+        log.error("fail release: invalid id (null)");
         return -1;
     }
     std::int32_t ret = -1;
     auto ii = static_cast<id_info_t*>(id);
     if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail release: invalid id (mem = %p, size = %zd), name = %s\n", 
-                    ii->mem_, ii->size_, ii->name_.c_str());
+        log.error("fail release: invalid id (mem = %p, size = %zd), name = ", ii->mem_, ii->size_, ii->name_.c_str(, ""));
     }
     else if ((ret = acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel)) <= 1) {
         ::munmap(ii->mem_, ii->size_);
         if (!ii->name_.empty()) {
             int unlink_ret = ::shm_unlink(ii->name_.c_str());
             if (unlink_ret == -1) {
-                ipc::error("fail shm_unlink[%d]: %s\n", errno, ii->name_.c_str());
+                log.error("fail shm_unlink[%d]: ", errno, ii->name_.c_str(, ""));
             }
         }
     }
@@ -191,7 +190,7 @@ std::int32_t release(id_t id) noexcept {
 
 void remove(id_t id) noexcept {
     if (id == nullptr) {
-        ipc::error("fail remove: invalid id (null)\n");
+        log.error("fail remove: invalid id (null)");
         return;
     }
     auto ii = static_cast<id_info_t*>(id);
@@ -200,14 +199,14 @@ void remove(id_t id) noexcept {
     if (!name.empty()) {
         int unlink_ret = ::shm_unlink(name.c_str());
         if (unlink_ret == -1) {
-            ipc::error("fail shm_unlink[%d]: %s\n", errno, name.c_str());
+            log.error("fail shm_unlink[%d]: ", errno, name.c_str(, ""));
         }
     }
 }
 
 void remove(char const * name) noexcept {
     if (!is_valid_string(name)) {
-        ipc::error("fail remove: name is empty\n");
+        log.error("fail remove: name is empty");
         return;
     }
     // For portable use, a shared memory object should be identified by name of the form /somename.
@@ -219,7 +218,7 @@ void remove(char const * name) noexcept {
     }
     int unlink_ret = ::shm_unlink(op_name.c_str());
     if (unlink_ret == -1) {
-        ipc::error("fail shm_unlink[%d]: %s\n", errno, op_name.c_str());
+        log.error("fail shm_unlink[%d]: ", errno, op_name.c_str(, ""));
     }
 }
 
diff --git a/src/libipc/platform/win/condition.h b/src/libipc/platform/win/condition.h
index 1bc3851..5b2da27 100644
--- a/src/libipc/platform/win/condition.h
+++ b/src/libipc/platform/win/condition.h
@@ -10,7 +10,7 @@
 #include <Windows.h>
 #endif
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/utility/scope_guard.h"
 #include "libipc/platform/detail.h"
 #include "libipc/mutex.h"
diff --git a/src/libipc/platform/win/get_sa.h b/src/libipc/platform/win/get_sa.h
index 74b68d4..f0980b1 100644
--- a/src/libipc/platform/win/get_sa.h
+++ b/src/libipc/platform/win/get_sa.h
@@ -15,11 +15,11 @@ inline LPSECURITY_ATTRIBUTES get_sa() {
 
         initiator() {
             if (!::InitializeSecurityDescriptor(&sd_, SECURITY_DESCRIPTOR_REVISION)) {
-                ipc::error("fail InitializeSecurityDescriptor[%d]\n", static_cast<int>(::GetLastError()));
+                log.error("fail InitializeSecurityDescriptor[", static_cast<int>(::GetLastError(, "]")));
                 return;
             }
             if (!::SetSecurityDescriptorDacl(&sd_, TRUE, NULL, FALSE)) {
-                ipc::error("fail SetSecurityDescriptorDacl[%d]\n", static_cast<int>(::GetLastError()));
+                log.error("fail SetSecurityDescriptorDacl[", static_cast<int>(::GetLastError(, "]")));
                 return;
             }
             sa_.nLength = sizeof(SECURITY_ATTRIBUTES);
diff --git a/src/libipc/platform/win/mutex.h b/src/libipc/platform/win/mutex.h
index e80c96b..8d5e9c1 100644
--- a/src/libipc/platform/win/mutex.h
+++ b/src/libipc/platform/win/mutex.h
@@ -9,7 +9,7 @@
 #include <Windows.h>
 #endif
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 
 #include "to_tchar.h"
 #include "get_sa.h"
@@ -39,7 +39,7 @@ public:
         close();
         h_ = ::CreateMutex(detail::get_sa(), FALSE, detail::to_tchar(name).c_str());
         if (h_ == NULL) {
-            ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
+            log.error("fail CreateMutex[%lu]: ", ::GetLastError(, ""), name);
             return false;
         }
         return true;
diff --git a/src/libipc/platform/win/semaphore.h b/src/libipc/platform/win/semaphore.h
index 8185369..29f5427 100644
--- a/src/libipc/platform/win/semaphore.h
+++ b/src/libipc/platform/win/semaphore.h
@@ -8,7 +8,7 @@
 #include <Windows.h>
 #endif
 
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 
 #include "to_tchar.h"
 #include "get_sa.h"
@@ -38,7 +38,7 @@ public:
                                static_cast<LONG>(count), LONG_MAX, 
                                detail::to_tchar(name).c_str());
         if (h_ == NULL) {
-            ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
+            log.error("fail CreateSemaphore[%lu]: ", ::GetLastError(, ""), name);
             return false;
         }
         return true;
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index a8a0ce5..76c5813 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -1,186 +1,186 @@
-
-#if defined(__MINGW32__)
-#include <windows.h>
-#else
-#include <Windows.h>
-#endif
-
-#include <atomic>
-#include <string>
-#include <utility>
-
-#include "libipc/shm.h"
-#include "libipc/def.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/mem/resource.h"
-#include "libipc/mem/new.h"
-
-#include "to_tchar.h"
-#include "get_sa.h"
-
-namespace {
-
-struct info_t {
-    std::atomic<std::int32_t> acc_;
-};
-
-struct id_info_t {
-    HANDLE      h_    = NULL;
-    void*       mem_  = nullptr;
-    std::size_t size_ = 0;
-};
-
-constexpr std::size_t calc_size(std::size_t size) {
-    return ((((size - 1) / alignof(info_t)) + 1) * alignof(info_t)) + sizeof(info_t);
-}
-
-inline auto& acc_of(void* mem, std::size_t size) {
-    return reinterpret_cast<info_t*>(static_cast<ipc::byte_t*>(mem) + size - sizeof(info_t))->acc_;
-}
-
-} // internal-linkage
-
-namespace ipc {
-namespace shm {
-
-id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (!is_valid_string(name)) {
-        ipc::error("fail acquire: name is empty\n");
-        return nullptr;
-    }
-    HANDLE h;
-    auto fmt_name = ipc::detail::to_tchar(name);
-    // Opens a named file mapping object.
-    if (mode == open) {
-        h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
-        if (h == NULL) {
-          ipc::error("fail OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
-          return nullptr;
-        }
-    }
-    // Creates or opens a named file mapping object for a specified file.
-    else {
-        std::size_t alloc_size = calc_size(size);
-        h = ::CreateFileMapping(INVALID_HANDLE_VALUE, detail::get_sa(), PAGE_READWRITE | SEC_COMMIT,
-                                0, static_cast<DWORD>(alloc_size), fmt_name.c_str());
-        DWORD err = ::GetLastError();
-        // If the object exists before the function call, the function returns a handle to the existing object 
-        // (with its current size, not the specified size), and GetLastError returns ERROR_ALREADY_EXISTS.
-        if ((mode == create) && (err == ERROR_ALREADY_EXISTS)) {
-            if (h != NULL) ::CloseHandle(h);
-            h = NULL;
-        }
-        if (h == NULL) {
-          ipc::error("fail CreateFileMapping[%d]: %s\n", static_cast<int>(err), name);
-          return nullptr;
-        }
-    }
-    auto ii = mem::$new<id_info_t>();
-    ii->h_    = h;
-    ii->size_ = size;
-    return ii;
-}
-
-std::int32_t get_ref(id_t id) {
-    if (id == nullptr) {
-        return 0;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        return 0;
-    }
-    return acc_of(ii->mem_, calc_size(ii->size_)).load(std::memory_order_acquire);
-}
-
-void sub_ref(id_t id) {
-    if (id == nullptr) {
-        ipc::error("fail sub_ref: invalid id (null)\n");
-        return;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail sub_ref: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
-        return;
-    }
-    acc_of(ii->mem_, calc_size(ii->size_)).fetch_sub(1, std::memory_order_acq_rel);
-}
-
-void * get_mem(id_t id, std::size_t * size) {
-    if (id == nullptr) {
-        ipc::error("fail get_mem: invalid id (null)\n");
-        return nullptr;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ != nullptr) {
-        if (size != nullptr) *size = ii->size_;
-        return ii->mem_;
-    }
-    if (ii->h_ == NULL) {
-        ipc::error("fail to_mem: invalid id (h = null)\n");
-        return nullptr;
-    }
-    LPVOID mem = ::MapViewOfFile(ii->h_, FILE_MAP_ALL_ACCESS, 0, 0, 0);
-    if (mem == NULL) {
-        ipc::error("fail MapViewOfFile[%d]\n", static_cast<int>(::GetLastError()));
-        return nullptr;
-    }
-    MEMORY_BASIC_INFORMATION mem_info;
-    if (::VirtualQuery(mem, &mem_info, sizeof(mem_info)) == 0) {
-        ipc::error("fail VirtualQuery[%d]\n", static_cast<int>(::GetLastError()));
-        return nullptr;
-    }
-    std::size_t actual_size = static_cast<std::size_t>(mem_info.RegionSize);
-    if (ii->size_ == 0) {
-        // Opening existing shared memory
-        ii->size_ = actual_size - sizeof(info_t);
-    }
-    // else: Keep user-requested size (already set in acquire)
-    ii->mem_ = mem;
-    if (size != nullptr) *size = ii->size_;
-    // Initialize or increment reference counter
-    acc_of(mem, calc_size(ii->size_)).fetch_add(1, std::memory_order_release);
-    return static_cast<void *>(mem);
-}
-
-std::int32_t release(id_t id) noexcept {
-    if (id == nullptr) {
-        ipc::error("fail release: invalid id (null)\n");
-        return -1;
-    }
-    std::int32_t ret = -1;
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
-    }
-    else {
-        ret = acc_of(ii->mem_, calc_size(ii->size_)).fetch_sub(1, std::memory_order_acq_rel);
-        ::UnmapViewOfFile(static_cast<LPCVOID>(ii->mem_));
-    }
-    if (ii->h_ == NULL) {
-        ipc::error("fail release: invalid id (h = null)\n");
-    }
-    else ::CloseHandle(ii->h_);
-    mem::$delete(ii);
-    return ret;
-}
-
-void remove(id_t id) noexcept {
-    if (id == nullptr) {
-        ipc::error("fail release: invalid id (null)\n");
-        return;
-    }
-    release(id);
-}
-
-void remove(char const * name) noexcept {
-    if (!is_valid_string(name)) {
-        ipc::error("fail remove: name is empty\n");
-        return;
-    }
-    // Do Nothing.
-}
-
-} // namespace shm
-} // namespace ipc
-
+
+#if defined(__MINGW32__)
+#include <windows.h>
+#else
+#include <Windows.h>
+#endif
+
+#include <atomic>
+#include <string>
+#include <utility>
+
+#include "libipc/shm.h"
+#include "libipc/def.h"
+
+#include "libipc/imp/log.h"
+#include "libipc/mem/resource.h"
+#include "libipc/mem/new.h"
+
+#include "to_tchar.h"
+#include "get_sa.h"
+
+namespace {
+
+struct info_t {
+    std::atomic<std::int32_t> acc_;
+};
+
+struct id_info_t {
+    HANDLE      h_    = NULL;
+    void*       mem_  = nullptr;
+    std::size_t size_ = 0;
+};
+
+constexpr std::size_t calc_size(std::size_t size) {
+    return ((((size - 1) / alignof(info_t)) + 1) * alignof(info_t)) + sizeof(info_t);
+}
+
+inline auto& acc_of(void* mem, std::size_t size) {
+    return reinterpret_cast<info_t*>(static_cast<ipc::byte_t*>(mem) + size - sizeof(info_t))->acc_;
+}
+
+} // internal-linkage
+
+namespace ipc {
+namespace shm {
+
+id_t acquire(char const * name, std::size_t size, unsigned mode) {
+    if (!is_valid_string(name)) {
+        log.error("fail acquire: name is empty");
+        return nullptr;
+    }
+    HANDLE h;
+    auto fmt_name = ipc::detail::to_tchar(name);
+    // Opens a named file mapping object.
+    if (mode == open) {
+        h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
+        if (h == NULL) {
+          log.error("fail OpenFileMapping[%d]: ", static_cast<int>(::GetLastError(, "")), name);
+          return nullptr;
+        }
+    }
+    // Creates or opens a named file mapping object for a specified file.
+    else {
+        std::size_t alloc_size = calc_size(size);
+        h = ::CreateFileMapping(INVALID_HANDLE_VALUE, detail::get_sa(), PAGE_READWRITE | SEC_COMMIT,
+                                0, static_cast<DWORD>(alloc_size), fmt_name.c_str());
+        DWORD err = ::GetLastError();
+        // If the object exists before the function call, the function returns a handle to the existing object 
+        // (with its current size, not the specified size), and GetLastError returns ERROR_ALREADY_EXISTS.
+        if ((mode == create) && (err == ERROR_ALREADY_EXISTS)) {
+            if (h != NULL) ::CloseHandle(h);
+            h = NULL;
+        }
+        if (h == NULL) {
+          log.error("fail CreateFileMapping[%d]: ", static_cast<int>(err, ""), name);
+          return nullptr;
+        }
+    }
+    auto ii = mem::$new<id_info_t>();
+    ii->h_    = h;
+    ii->size_ = size;
+    return ii;
+}
+
+std::int32_t get_ref(id_t id) {
+    if (id == nullptr) {
+        return 0;
+    }
+    auto ii = static_cast<id_info_t*>(id);
+    if (ii->mem_ == nullptr || ii->size_ == 0) {
+        return 0;
+    }
+    return acc_of(ii->mem_, calc_size(ii->size_)).load(std::memory_order_acquire);
+}
+
+void sub_ref(id_t id) {
+    if (id == nullptr) {
+        log.error("fail sub_ref: invalid id (null)");
+        return;
+    }
+    auto ii = static_cast<id_info_t*>(id);
+    if (ii->mem_ == nullptr || ii->size_ == 0) {
+        log.error("fail sub_ref: invalid id (mem = ", ii->mem_, ", size = ", ii->size_, ")");
+        return;
+    }
+    acc_of(ii->mem_, calc_size(ii->size_)).fetch_sub(1, std::memory_order_acq_rel);
+}
+
+void * get_mem(id_t id, std::size_t * size) {
+    if (id == nullptr) {
+        log.error("fail get_mem: invalid id (null)");
+        return nullptr;
+    }
+    auto ii = static_cast<id_info_t*>(id);
+    if (ii->mem_ != nullptr) {
+        if (size != nullptr) *size = ii->size_;
+        return ii->mem_;
+    }
+    if (ii->h_ == NULL) {
+        log.error("fail to_mem: invalid id (h = null)");
+        return nullptr;
+    }
+    LPVOID mem = ::MapViewOfFile(ii->h_, FILE_MAP_ALL_ACCESS, 0, 0, 0);
+    if (mem == NULL) {
+        log.error("fail MapViewOfFile[", static_cast<int>(::GetLastError(, "]")));
+        return nullptr;
+    }
+    MEMORY_BASIC_INFORMATION mem_info;
+    if (::VirtualQuery(mem, &mem_info, sizeof(mem_info)) == 0) {
+        log.error("fail VirtualQuery[", static_cast<int>(::GetLastError(, "]")));
+        return nullptr;
+    }
+    std::size_t actual_size = static_cast<std::size_t>(mem_info.RegionSize);
+    if (ii->size_ == 0) {
+        // Opening existing shared memory
+        ii->size_ = actual_size - sizeof(info_t);
+    }
+    // else: Keep user-requested size (already set in acquire)
+    ii->mem_ = mem;
+    if (size != nullptr) *size = ii->size_;
+    // Initialize or increment reference counter
+    acc_of(mem, calc_size(ii->size_)).fetch_add(1, std::memory_order_release);
+    return static_cast<void *>(mem);
+}
+
+std::int32_t release(id_t id) noexcept {
+    if (id == nullptr) {
+        log.error("fail release: invalid id (null)");
+        return -1;
+    }
+    std::int32_t ret = -1;
+    auto ii = static_cast<id_info_t*>(id);
+    if (ii->mem_ == nullptr || ii->size_ == 0) {
+        log.error("fail release: invalid id (mem = ", ii->mem_, ", size = ", ii->size_, ")");
+    }
+    else {
+        ret = acc_of(ii->mem_, calc_size(ii->size_)).fetch_sub(1, std::memory_order_acq_rel);
+        ::UnmapViewOfFile(static_cast<LPCVOID>(ii->mem_));
+    }
+    if (ii->h_ == NULL) {
+        log.error("fail release: invalid id (h = null)");
+    }
+    else ::CloseHandle(ii->h_);
+    mem::$delete(ii);
+    return ret;
+}
+
+void remove(id_t id) noexcept {
+    if (id == nullptr) {
+        log.error("fail release: invalid id (null)");
+        return;
+    }
+    release(id);
+}
+
+void remove(char const * name) noexcept {
+    if (!is_valid_string(name)) {
+        log.error("fail remove: name is empty");
+        return;
+    }
+    // Do Nothing.
+}
+
+} // namespace shm
+} // namespace ipc
+
diff --git a/src/libipc/sync/condition.cpp b/src/libipc/sync/condition.cpp
index ed75c2c..ca7c705 100644
--- a/src/libipc/sync/condition.cpp
+++ b/src/libipc/sync/condition.cpp
@@ -2,7 +2,7 @@
 #include "libipc/condition.h"
 
 #include "libipc/utility/pimpl.h"
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/mem/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(LIBIPC_OS_WIN)
@@ -51,7 +51,7 @@ bool condition::valid() const noexcept {
 
 bool condition::open(char const *name) noexcept {
     if (!is_valid_string(name)) {
-        ipc::error("fail condition open: name is empty\n");
+        log.error("fail condition open: name is empty");
         return false;
     }
     return impl(p_)->cond_.open(name);
diff --git a/src/libipc/sync/mutex.cpp b/src/libipc/sync/mutex.cpp
index ce75edd..4080d4f 100644
--- a/src/libipc/sync/mutex.cpp
+++ b/src/libipc/sync/mutex.cpp
@@ -2,7 +2,7 @@
 #include "libipc/mutex.h"
 
 #include "libipc/utility/pimpl.h"
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/mem/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(LIBIPC_OS_WIN)
@@ -51,7 +51,7 @@ bool mutex::valid() const noexcept {
 
 bool mutex::open(char const *name) noexcept {
     if (!is_valid_string(name)) {
-        ipc::error("fail mutex open: name is empty\n");
+        log.error("fail mutex open: name is empty");
         return false;
     }
     return impl(p_)->lock_.open(name);
diff --git a/src/libipc/sync/semaphore.cpp b/src/libipc/sync/semaphore.cpp
index e252ed0..5e7ff7d 100644
--- a/src/libipc/sync/semaphore.cpp
+++ b/src/libipc/sync/semaphore.cpp
@@ -2,7 +2,7 @@
 #include "libipc/semaphore.h"
 
 #include "libipc/utility/pimpl.h"
-#include "libipc/utility/log.h"
+#include "libipc/imp/log.h"
 #include "libipc/mem/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(LIBIPC_OS_WIN)
@@ -50,7 +50,7 @@ bool semaphore::valid() const noexcept {
 
 bool semaphore::open(char const *name, std::uint32_t count) noexcept {
     if (!is_valid_string(name)) {
-        ipc::error("fail semaphore open: name is empty\n");
+        log.error("fail semaphore open: name is empty");
         return false;
     }
     return impl(p_)->sem_.open(name, count);