Rename generic `error` function (#15296)

1 files changed, 21 insertions, 18 deletions

diff --git a/libnetdata/locks/locks.c b/libnetdata/locks/locks.c
index 0c02152f79..7c806688d9 100644
--- a/libnetdata/locks/locks.c
+++ b/libnetdata/locks/locks.c
@@ -33,7 +33,7 @@ inline void netdata_thread_disable_cancelability(void) {
         int ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old);
 
         if(ret != 0)
-            error("THREAD_CANCELABILITY: pthread_setcancelstate() on thread %s returned error %d",
+            netdata_log_error("THREAD_CANCELABILITY: pthread_setcancelstate() on thread %s returned error %d",
                   netdata_thread_tag(), ret);
 
         netdata_thread_first_cancelability = old;
@@ -46,9 +46,9 @@ inline void netdata_thread_enable_cancelability(void) {
     if(unlikely(netdata_thread_nested_disables < 1)) {
         internal_fatal(true, "THREAD_CANCELABILITY: trying to enable cancelability, but it was not not disabled");
 
-        error("THREAD_CANCELABILITY: netdata_thread_enable_cancelability(): invalid thread cancelability count %d "
-              "on thread %s - results will be undefined - please report this!",
-            netdata_thread_nested_disables, netdata_thread_tag());
+        netdata_log_error("THREAD_CANCELABILITY: netdata_thread_enable_cancelability(): invalid thread cancelability count %d "
+                          "on thread %s - results will be undefined - please report this!",
+                          netdata_thread_nested_disables, netdata_thread_tag());
 
         netdata_thread_nested_disables = 1;
     }
@@ -57,15 +57,18 @@ inline void netdata_thread_enable_cancelability(void) {
         int old = 1;
         int ret = pthread_setcancelstate(netdata_thread_first_cancelability, &old);
         if(ret != 0)
-            error("THREAD_CANCELABILITY: pthread_setcancelstate() on thread %s returned error %d", netdata_thread_tag(), ret);
+            netdata_log_error("THREAD_CANCELABILITY: pthread_setcancelstate() on thread %s returned error %d",
+                              netdata_thread_tag(),
+                              ret);
         else {
             if(old != PTHREAD_CANCEL_DISABLE) {
                 internal_fatal(true, "THREAD_CANCELABILITY: invalid old state cancelability");
 
-                error("THREAD_CANCELABILITY: netdata_thread_enable_cancelability(): old thread cancelability "
-                      "on thread %s was changed, expected DISABLED (%d), found %s (%d) - please report this!",
-                      netdata_thread_tag(), PTHREAD_CANCEL_DISABLE,
-                      (old == PTHREAD_CANCEL_ENABLE) ? "ENABLED" : "UNKNOWN", old);
+                netdata_log_error("THREAD_CANCELABILITY: netdata_thread_enable_cancelability(): old thread cancelability "
+                                  "on thread %s was changed, expected DISABLED (%d), found %s (%d) - please report this!",
+                                  netdata_thread_tag(), PTHREAD_CANCEL_DISABLE,
+                                  (old == PTHREAD_CANCEL_ENABLE) ? "ENABLED" : "UNKNOWN",
+                                  old);
             }
         }
     }
@@ -79,14 +82,14 @@ inline void netdata_thread_enable_cancelability(void) {
 int __netdata_mutex_init(netdata_mutex_t *mutex) {
     int ret = pthread_mutex_init(mutex, NULL);
     if(unlikely(ret != 0))
-        error("MUTEX_LOCK: failed to initialize (code %d).", ret);
+        netdata_log_error("MUTEX_LOCK: failed to initialize (code %d).", ret);
     return ret;
 }
 
 int __netdata_mutex_destroy(netdata_mutex_t *mutex) {
     int ret = pthread_mutex_destroy(mutex);
     if(unlikely(ret != 0))
-        error("MUTEX_LOCK: failed to destroy (code %d).", ret);
+        netdata_log_error("MUTEX_LOCK: failed to destroy (code %d).", ret);
     return ret;
 }
 
@@ -96,7 +99,7 @@ int __netdata_mutex_lock(netdata_mutex_t *mutex) {
     int ret = pthread_mutex_lock(mutex);
     if(unlikely(ret != 0)) {
         netdata_thread_enable_cancelability();
-        error("MUTEX_LOCK: failed to get lock (code %d)", ret);
+        netdata_log_error("MUTEX_LOCK: failed to get lock (code %d)", ret);
     }
     else
         netdata_locks_acquired_mutexes++;
@@ -119,7 +122,7 @@ int __netdata_mutex_trylock(netdata_mutex_t *mutex) {
 int __netdata_mutex_unlock(netdata_mutex_t *mutex) {
     int ret = pthread_mutex_unlock(mutex);
     if(unlikely(ret != 0))
-        error("MUTEX_LOCK: failed to unlock (code %d).", ret);
+        netdata_log_error("MUTEX_LOCK: failed to unlock (code %d).", ret);
     else {
         netdata_locks_acquired_mutexes--;
         netdata_thread_enable_cancelability();
@@ -211,14 +214,14 @@ int netdata_mutex_unlock_debug(const char *file __maybe_unused, const char *func
 int __netdata_rwlock_destroy(netdata_rwlock_t *rwlock) {
     int ret = pthread_rwlock_destroy(&rwlock->rwlock_t);
     if(unlikely(ret != 0))
-        error("RW_LOCK: failed to destroy lock (code %d)", ret);
+        netdata_log_error("RW_LOCK: failed to destroy lock (code %d)", ret);
     return ret;
 }
 
 int __netdata_rwlock_init(netdata_rwlock_t *rwlock) {
     int ret = pthread_rwlock_init(&rwlock->rwlock_t, NULL);
     if(unlikely(ret != 0))
-        error("RW_LOCK: failed to initialize lock (code %d)", ret);
+        netdata_log_error("RW_LOCK: failed to initialize lock (code %d)", ret);
     return ret;
 }
 
@@ -228,7 +231,7 @@ int __netdata_rwlock_rdlock(netdata_rwlock_t *rwlock) {
     int ret = pthread_rwlock_rdlock(&rwlock->rwlock_t);
     if(unlikely(ret != 0)) {
         netdata_thread_enable_cancelability();
-        error("RW_LOCK: failed to obtain read lock (code %d)", ret);
+        netdata_log_error("RW_LOCK: failed to obtain read lock (code %d)", ret);
     }
     else
         netdata_locks_acquired_rwlocks++;
@@ -241,7 +244,7 @@ int __netdata_rwlock_wrlock(netdata_rwlock_t *rwlock) {
 
     int ret = pthread_rwlock_wrlock(&rwlock->rwlock_t);
     if(unlikely(ret != 0)) {
-        error("RW_LOCK: failed to obtain write lock (code %d)", ret);
+        netdata_log_error("RW_LOCK: failed to obtain write lock (code %d)", ret);
         netdata_thread_enable_cancelability();
     }
     else
@@ -253,7 +256,7 @@ int __netdata_rwlock_wrlock(netdata_rwlock_t *rwlock) {
 int __netdata_rwlock_unlock(netdata_rwlock_t *rwlock) {
     int ret = pthread_rwlock_unlock(&rwlock->rwlock_t);
     if(unlikely(ret != 0))
-        error("RW_LOCK: failed to release lock (code %d)", ret);
+        netdata_log_error("RW_LOCK: failed to release lock (code %d)", ret);
     else {
         netdata_thread_enable_cancelability();
         netdata_locks_acquired_rwlocks--;