From 7c19e8f919ecb7a0b974a878e8c38023007e4ec6 Mon Sep 17 00:00:00 2001
From: Levi Neely <141506390+lneely@users.noreply.github.com>
Date: Sat, 1 Mar 2025 20:43:26 +0100
Subject: [PATCH] plocks namespace

---
 pclsync/plibs.c  | 46 +++++++++++++++++++++++-----------------------
 pclsync/plocks.c | 32 ++++++++++++++++----------------
 pclsync/plocks.h | 34 ++++++++++++++++------------------
 3 files changed, 55 insertions(+), 57 deletions(-)

diff --git a/pclsync/plibs.c b/pclsync/plibs.c
index ae3ceb3..93f1034 100644
--- a/pclsync/plibs.c
+++ b/pclsync/plibs.c
@@ -429,7 +429,7 @@ int psync_sql_connect(const char *db) {
   code = sqlite3_open(db, &psync_db);
   if (likely(code == SQLITE_OK)) {
     if (initmutex) {
-      psync_rwlock_init(&psync_db_lock);
+      plocks_init(&psync_db_lock);
       pthread_mutexattr_init(&mattr);
       pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
       pthread_mutex_init(&psync_db_checkpoint_mutex, &mattr);
@@ -446,7 +446,7 @@ int psync_sql_connect(const char *db) {
                  "DELETE FROM setting WHERE id='justcheckingiflocked'")) {
       debug(D_ERROR, "database is locked");
       sqlite3_close(psync_db);
-      psync_rwlock_destroy(&psync_db_lock);
+      plocks_destroy(&psync_db_lock);
       return -1;
     }
 
@@ -637,7 +637,7 @@ void psync_sql_dump_locks() {
 
 #if IS_DEBUG
 int psync_sql_do_trylock(const char *file, unsigned line) {
-  if (psync_rwlock_trywrlock(&psync_db_lock))
+  if (plocks_trywrlock(&psync_db_lock))
     return -1;
   if (++sqllockcnt == 1) {
     clock_gettime(CLOCK_REALTIME, &sqllockstart);
@@ -646,18 +646,18 @@ int psync_sql_do_trylock(const char *file, unsigned line) {
   return 0;
 }
 #else
-int psync_sql_trylock() { return psync_rwlock_trywrlock(&psync_db_lock); }
+int psync_sql_trylock() { return plocks_trywrlock(&psync_db_lock); }
 #endif
 
 #if IS_DEBUG
 void psync_sql_do_lock(const char *file, unsigned line) {
-  if (psync_rwlock_trywrlock(&psync_db_lock)) {
+  if (plocks_trywrlock(&psync_db_lock)) {
     struct timespec start, end;
     unsigned long msec;
     clock_gettime(CLOCK_REALTIME, &start);
     memcpy(&end, &start, sizeof(end));
     end.tv_sec += PSYNC_DEBUG_LOCK_TIMEOUT;
-    if (psync_rwlock_timedwrlock(&psync_db_lock, &end)) {
+    if (plocks_timedwrlock(&psync_db_lock, &end)) {
       debug(D_BUG, "sql write lock timed out called from %s:%u", file, line);
       senddebug("sql write lock timed out called from %s:%u", file, line);
       psync_sql_dump_locks();
@@ -678,7 +678,7 @@ void psync_sql_do_lock(const char *file, unsigned line) {
   }
 }
 #else
-void psync_sql_lock() { psync_rwlock_wrlock(&psync_db_lock); }
+void psync_sql_lock() { plocks_wrlock(&psync_db_lock); }
 #endif
 
 void psync_sql_unlock() {
@@ -695,23 +695,23 @@ void psync_sql_unlock() {
             "held database write lock for %lu milliseconds taken from %s:%u",
             msec, wrlockfile, wrlockline);
     record_wrunlock();
-    psync_rwlock_unlock(&psync_db_lock);
+    plocks_unlock(&psync_db_lock);
   } else
-    psync_rwlock_unlock(&psync_db_lock);
+    plocks_unlock(&psync_db_lock);
 #else
-  psync_rwlock_unlock(&psync_db_lock);
+  plocks_unlock(&psync_db_lock);
 #endif
 }
 
 #if IS_DEBUG
 void psync_sql_do_rdlock(const char *file, unsigned line) {
-  if (psync_rwlock_tryrdlock(&psync_db_lock)) {
+  if (plocks_tryrdlock(&psync_db_lock)) {
     struct timespec start, end;
     unsigned long msec;
     clock_gettime(CLOCK_REALTIME, &start);
     memcpy(&end, &start, sizeof(end));
     end.tv_sec += PSYNC_DEBUG_LOCK_TIMEOUT;
-    if (psync_rwlock_timedrdlock(&psync_db_lock, &end)) {
+    if (plocks_timedrdlock(&psync_db_lock, &end)) {
       debug(D_BUG, "sql read lock timed out, called from %s:%u", file, line);
       senddebug("sql read lock timed out, called from %s:%u", file, line);
       psync_sql_dump_locks();
@@ -731,7 +731,7 @@ void psync_sql_do_rdlock(const char *file, unsigned line) {
   }
 }
 #else
-void psync_sql_rdlock() { psync_rwlock_rdlock(&psync_db_lock); }
+void psync_sql_rdlock() { plocks_rdlock(&psync_db_lock); }
 #endif
 
 void psync_sql_rdunlock() {
@@ -744,7 +744,7 @@ void psync_sql_rdunlock() {
     struct timespec end;
     unsigned long msec;
     rd_lock_data *lock;
-    psync_rwlock_unlock(&psync_db_lock);
+    plocks_unlock(&psync_db_lock);
     clock_gettime(CLOCK_REALTIME, &end);
     lock = record_rdunlock();
     msec = (end.tv_sec - sqlrdlockstart.tv_sec) * 1000 + end.tv_nsec / 1000000 -
@@ -755,28 +755,28 @@ void psync_sql_rdunlock() {
             lock->file, lock->line);
     psync_free(lock);
   } else
-    psync_rwlock_unlock(&psync_db_lock);
+    plocks_unlock(&psync_db_lock);
 #else
-  psync_rwlock_unlock(&psync_db_lock);
+  plocks_unlock(&psync_db_lock);
 #endif
 }
 
 int psync_sql_has_waiters() {
-  return psync_rwlock_num_waiters(&psync_db_lock) > 0;
+  return plocks_num_waiters(&psync_db_lock) > 0;
 }
 
 int psync_sql_isrdlocked() {
-  return psync_rwlock_holding_rdlock(&psync_db_lock);
+  return plocks_holding_rdlock(&psync_db_lock);
 }
 
-int psync_sql_islocked() { return psync_rwlock_holding_lock(&psync_db_lock); }
+int psync_sql_islocked() { return plocks_holding_lock(&psync_db_lock); }
 
 int psync_sql_tryupgradelock() {
 #if IS_DEBUG
-  if (psync_rwlock_holding_wrlock(&psync_db_lock))
+  if (plocks_holding_wrlock(&psync_db_lock))
     return 0;
-  assert(psync_rwlock_holding_rdlock(&psync_db_lock));
-  if (psync_rwlock_towrlock(&psync_db_lock))
+  assert(plocks_holding_rdlock(&psync_db_lock));
+  if (plocks_towrlock(&psync_db_lock))
     return -1;
   else {
     rd_lock_data *lock = record_rdunlock();
@@ -789,7 +789,7 @@ int psync_sql_tryupgradelock() {
     return 0;
   }
 #else
-  return psync_rwlock_towrlock(&psync_db_lock);
+  return plocks_towrlock(&psync_db_lock);
 #endif
 }
 
diff --git a/pclsync/plocks.c b/pclsync/plocks.c
index 723d47f..4121710 100644
--- a/pclsync/plocks.c
+++ b/pclsync/plocks.c
@@ -48,7 +48,7 @@ typedef union {
   uint_halfptr_t cnt[2];
 } psync_rwlock_lockcnt_t;
 
-void psync_rwlock_init(psync_rwlock_t *rw) {
+void plocks_init(psync_rwlock_t *rw) {
   assert(sizeof(void *) == sizeof(psync_rwlock_lockcnt_t));
   rw->rcount = 0;
   rw->rwait = 0;
@@ -61,7 +61,7 @@ void psync_rwlock_init(psync_rwlock_t *rw) {
   pthread_cond_init(&rw->wcond, NULL);
 }
 
-void psync_rwlock_destroy(psync_rwlock_t *rw) {
+void plocks_destroy(psync_rwlock_t *rw) {
   pthread_key_delete(rw->cntkey);
   pthread_mutex_destroy(&rw->mutex);
   pthread_cond_destroy(&rw->rcond);
@@ -142,7 +142,7 @@ static psync_rwlock_lockcnt_t psync_rwlock_create_cnt(uint_halfptr_t rd,
   return cnt;
 }
 
-void psync_rwlock_rdlock(psync_rwlock_t *rw) {
+void plocks_rdlock(psync_rwlock_t *rw) {
   if (psync_rwlock_check_rdrecursive_in(rw))
     return;
   pthread_mutex_lock(&rw->mutex);
@@ -156,7 +156,7 @@ void psync_rwlock_rdlock(psync_rwlock_t *rw) {
   psync_rwlock_set_count(rw, psync_rwlock_create_cnt(1, 0));
 }
 
-int psync_rwlock_tryrdlock(psync_rwlock_t *rw) {
+int plocks_tryrdlock(psync_rwlock_t *rw) {
   if (psync_rwlock_check_rdrecursive_in(rw))
     return 0;
   pthread_mutex_lock(&rw->mutex);
@@ -170,7 +170,7 @@ int psync_rwlock_tryrdlock(psync_rwlock_t *rw) {
   return 0;
 }
 
-int psync_rwlock_timedrdlock(psync_rwlock_t *rw,
+int plocks_timedrdlock(psync_rwlock_t *rw,
                              const struct timespec *abstime) {
   if (psync_rwlock_check_rdrecursive_in(rw))
     return 0;
@@ -190,7 +190,7 @@ int psync_rwlock_timedrdlock(psync_rwlock_t *rw,
   return 0;
 }
 
-void psync_rwlock_rdlock_starvewr(psync_rwlock_t *rw) {
+void plocks_rdlock_starvewr(psync_rwlock_t *rw) {
   if (psync_rwlock_check_rdrecursive_in(rw))
     return;
   pthread_mutex_lock(&rw->mutex);
@@ -206,7 +206,7 @@ void psync_rwlock_rdlock_starvewr(psync_rwlock_t *rw) {
   psync_rwlock_set_count(rw, psync_rwlock_create_cnt(1, 0));
 }
 
-void psync_rwlock_wrlock(psync_rwlock_t *rw) {
+void plocks_wrlock(psync_rwlock_t *rw) {
   if (psync_rwlock_check_wrrecursive_in(rw))
     return;
   pthread_mutex_lock(&rw->mutex);
@@ -220,7 +220,7 @@ void psync_rwlock_wrlock(psync_rwlock_t *rw) {
   psync_rwlock_set_count(rw, psync_rwlock_create_cnt(0, 1));
 }
 
-int psync_rwlock_trywrlock(psync_rwlock_t *rw) {
+int plocks_trywrlock(psync_rwlock_t *rw) {
   if (psync_rwlock_check_wrrecursive_in(rw))
     return 0;
   pthread_mutex_lock(&rw->mutex);
@@ -234,7 +234,7 @@ int psync_rwlock_trywrlock(psync_rwlock_t *rw) {
   return 0;
 }
 
-int psync_rwlock_timedwrlock(psync_rwlock_t *rw,
+int plocks_timedwrlock(psync_rwlock_t *rw,
                              const struct timespec *abstime) {
   if (psync_rwlock_check_wrrecursive_in(rw))
     return 0;
@@ -255,7 +255,7 @@ int psync_rwlock_timedwrlock(psync_rwlock_t *rw,
   return 0;
 }
 
-void psync_rwlock_rslock(psync_rwlock_t *rw) {
+void plocks_rslock(psync_rwlock_t *rw) {
   psync_rwlock_lockcnt_t cnt;
   cnt = psync_rwlock_get_count(rw);
   assert(cnt.cnt[0] == 0);
@@ -283,7 +283,7 @@ void psync_rwlock_rslock(psync_rwlock_t *rw) {
   psync_rwlock_set_count(rw, cnt);
 }
 
-int psync_rwlock_towrlock(psync_rwlock_t *rw) {
+int plocks_towrlock(psync_rwlock_t *rw) {
   psync_rwlock_lockcnt_t cnt;
   cnt = psync_rwlock_get_count(rw);
   if (cnt.cnt[1] && cnt.cnt[1] != PSYNC_WR_RESERVED)
@@ -317,7 +317,7 @@ int psync_rwlock_towrlock(psync_rwlock_t *rw) {
   return 0;
 }
 
-void psync_rwlock_unlock(psync_rwlock_t *rw) {
+void plocks_unlock(psync_rwlock_t *rw) {
   if (psync_rwlock_check_recursive_out(rw))
     return;
   pthread_mutex_lock(&rw->mutex);
@@ -359,7 +359,7 @@ void psync_rwlock_unlock(psync_rwlock_t *rw) {
   pthread_mutex_unlock(&rw->mutex);
 }
 
-unsigned psync_rwlock_num_waiters(psync_rwlock_t *rw) {
+unsigned plocks_num_waiters(psync_rwlock_t *rw) {
   unsigned ret;
   pthread_mutex_lock(&rw->mutex);
   ret = rw->rwait + rw->wwait;
@@ -367,17 +367,17 @@ unsigned psync_rwlock_num_waiters(psync_rwlock_t *rw) {
   return ret;
 }
 
-int psync_rwlock_holding_rdlock(psync_rwlock_t *rw) {
+int plocks_holding_rdlock(psync_rwlock_t *rw) {
   return psync_rwlock_get_count(rw).cnt[0] != 0;
 }
 
-int psync_rwlock_holding_wrlock(psync_rwlock_t *rw) {
+int plocks_holding_wrlock(psync_rwlock_t *rw) {
   psync_rwlock_lockcnt_t cnt;
   cnt = psync_rwlock_get_count(rw);
   return cnt.cnt[1] != 0 && cnt.cnt[1] != PSYNC_WR_RESERVED;
 }
 
-int psync_rwlock_holding_lock(psync_rwlock_t *rw) {
+int plocks_holding_lock(psync_rwlock_t *rw) {
   psync_rwlock_lockcnt_t cnt;
   cnt = psync_rwlock_get_count(rw);
   return cnt.cnt[0] != 0 || cnt.cnt[1] != 0;
diff --git a/pclsync/plocks.h b/pclsync/plocks.h
index aede059..df9b126 100644
--- a/pclsync/plocks.h
+++ b/pclsync/plocks.h
@@ -46,23 +46,21 @@ typedef struct {
   pthread_cond_t wcond;
 } psync_rwlock_t;
 
-void psync_rwlock_init(psync_rwlock_t *rw);
-void psync_rwlock_destroy(psync_rwlock_t *rw);
-void psync_rwlock_rdlock(psync_rwlock_t *rw);
-int psync_rwlock_tryrdlock(psync_rwlock_t *rw);
-int psync_rwlock_timedrdlock(psync_rwlock_t *rw,
-                             const struct timespec *abstime);
-void psync_rwlock_rdlock_starvewr(psync_rwlock_t *rw);
-void psync_rwlock_wrlock(psync_rwlock_t *rw);
-int psync_rwlock_trywrlock(psync_rwlock_t *rw);
-int psync_rwlock_timedwrlock(psync_rwlock_t *rw,
-                             const struct timespec *abstime);
-void psync_rwlock_rslock(psync_rwlock_t *rw);
-int psync_rwlock_towrlock(psync_rwlock_t *rw);
-void psync_rwlock_unlock(psync_rwlock_t *rw);
-unsigned psync_rwlock_num_waiters(psync_rwlock_t *rw);
-int psync_rwlock_holding_rdlock(psync_rwlock_t *rw);
-int psync_rwlock_holding_wrlock(psync_rwlock_t *rw);
-int psync_rwlock_holding_lock(psync_rwlock_t *rw);
+void plocks_init(psync_rwlock_t *rw);
+void plocks_destroy(psync_rwlock_t *rw);
+void plocks_rdlock(psync_rwlock_t *rw);
+int plocks_tryrdlock(psync_rwlock_t *rw);
+int plocks_timedrdlock(psync_rwlock_t *rw, const struct timespec *abstime);
+void plocks_rdlock_starvewr(psync_rwlock_t *rw);
+void plocks_wrlock(psync_rwlock_t *rw);
+int plocks_trywrlock(psync_rwlock_t *rw);
+int plocks_timedwrlock(psync_rwlock_t *rw, const struct timespec *abstime);
+void plocks_rslock(psync_rwlock_t *rw);
+int plocks_towrlock(psync_rwlock_t *rw);
+void plocks_unlock(psync_rwlock_t *rw);
+unsigned plocks_num_waiters(psync_rwlock_t *rw);
+int plocks_holding_rdlock(psync_rwlock_t *rw);
+int plocks_holding_wrlock(psync_rwlock_t *rw);
+int plocks_holding_lock(psync_rwlock_t *rw);
 
 #endif