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.

3 files changed, 17 insertions, 4 deletions

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 */