From d27db01d8d427b9a3ade4e82e73dba1bb3802781 Mon Sep 17 00:00:00 2001 From: Ryo Nakamura Date: Sun, 11 Dec 2022 13:23:41 +0900 Subject: use pthread_cleanup to acquire and release lock In chunk_prepare(), if multiple threads wait for acquiring f->lock, and then pthread_cancel() is called, the waiting threads are never canceled because pthread_mutex_lock() is not a cancellation point. So, use pthread_cleanup_push/pop to release the lock. --- src/atomic.h | 13 +++++++++++++ src/file.c | 4 ++-- src/main.c | 4 ++-- 3 files changed, 17 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/atomic.h b/src/atomic.h index e0e735d..cdbd21e 100644 --- a/src/atomic.h +++ b/src/atomic.h @@ -55,4 +55,17 @@ static inline void lock_release(lock *l) } } +static inline void lock_release_via_cleanup(void *l) +{ + lock_release(l); +} + +#define LOCK_ACQUIRE_THREAD(l) \ + lock_acquire(l); \ + pthread_cleanup_push(lock_release_via_cleanup, l) + + +#define LOCK_RELEASE_THREAD(l) \ + pthread_cleanup_pop(1) + #endif /* _ATOMIC_H_ */ diff --git a/src/file.c b/src/file.c index 4edab42..55e95a5 100644 --- a/src/file.c +++ b/src/file.c @@ -554,7 +554,7 @@ int chunk_prepare(struct chunk *c, sftp_session sftp) struct file *f = c->f; int ret = 0; - lock_acquire(&f->lock); /* XXX: is always acquiring lock per-chunk heavy? */ + LOCK_ACQUIRE_THREAD(&f->lock); if (f->state == FILE_STATE_INIT) { if (file_dst_prepare(f, f->dst_is_remote ? sftp : NULL) < 0) { ret = -1; @@ -565,7 +565,7 @@ int chunk_prepare(struct chunk *c, sftp_session sftp) } out: - lock_release(&f->lock); + LOCK_RELEASE_THREAD(); return ret; } diff --git a/src/main.c b/src/main.c index 3c1038e..5fb5a05 100644 --- a/src/main.c +++ b/src/main.c @@ -507,9 +507,9 @@ void *mscp_copy_thread(void *arg) pthread_cleanup_push(mscp_copy_thread_cleanup, t); while (1) { - lock_acquire(&m.chunk_lock); + LOCK_ACQUIRE_THREAD(&m.chunk_lock); c = chunk_acquire(&m.chunk_list); - lock_release(&m.chunk_lock); + LOCK_RELEASE_THREAD(); if (!c) break; /* no more chunks */ -- cgit v1.2.3