lkn
/
pcloudcc-lneely
mirror of https://github.com/lneely/pcloudcc-lneely.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

plocks namespace

This commit is contained in:
Levi Neely 2025-03-01 20:43:26 +01:00
parent 990fde0b64
commit 7c19e8f919
3 changed files with 55 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
pclsync/plibs.c
View File

@ -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
}

32
pclsync/plocks.c
View File

@ -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;

34
pclsync/plocks.h
View File

@ -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