Original pthread_once code has memory leak if pthread_once_t is used in

a shared library or any other dyanmic allocated data block, once
pthread_once_t is initialized, a mutex is allocated, if we unload the
shared library or free those data block, then there is no way to deallocate
the mutex, result is memory leak.
To fix this problem, we don't use mutex field in pthread_once_t, instead,
we use its state field and an internal mutex and conditional variable in
libkse to do any synchronization, we introduce a third state IN_PROGRESS to
wait if another thread is already in invoking init_routine().
Also while I am here, make pthread_once() conformed to pthread cancellation
point specification.

Reviewed by: deischen

1 files changed, 50 insertions, 9 deletions

diff --git a/lib/libkse/thread/thr_once.c b/lib/libkse/thread/thr_once.c
index 152fdec..ad158d1 100644
--- a/lib/libkse/thread/thr_once.c
+++ b/lib/libkse/thread/thr_once.c
@@ -38,18 +38,59 @@
 
 __weak_reference(_pthread_once, pthread_once);
 
+#define ONCE_NEVER_DONE		PTHREAD_NEEDS_INIT
+#define ONCE_DONE		PTHREAD_DONE_INIT
+#define	ONCE_IN_PROGRESS	0x02
+#define	ONCE_MASK		0x03
+
+static pthread_mutex_t		once_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t		once_cv = PTHREAD_COND_INITIALIZER;
+
+/*
+ * POSIX:
+ * The pthread_once() function is not a cancellation point. However,
+ * if init_routine is a cancellation point and is canceled, the effect
+ * on once_control shall be as if pthread_once() was never called.
+ */
+ 
+static void
+once_cancel_handler(void *arg)
+{
+	pthread_once_t *once_control = arg;
+
+	_pthread_mutex_lock(&once_lock);
+	once_control->state = ONCE_NEVER_DONE;
+	_pthread_mutex_unlock(&once_lock);
+	_pthread_cond_broadcast(&once_cv);
+}
+
 int
 _pthread_once(pthread_once_t *once_control, void (*init_routine) (void))
 {
-	if (once_control->state == PTHREAD_NEEDS_INIT) {
-		if (_thr_initial == NULL)
-			_libpthread_init(NULL);
-		_pthread_mutex_lock(&(once_control->mutex));
-		if (once_control->state == PTHREAD_NEEDS_INIT) {
-			init_routine();
-			once_control->state = PTHREAD_DONE_INIT;
-		}
-		_pthread_mutex_unlock(&(once_control->mutex));
+	int wakeup = 0;
+
+	if (once_control->state == ONCE_DONE)
+		return (0);
+	_pthread_mutex_lock(&once_lock);
+	while (*(volatile int *)&(once_control->state) == ONCE_IN_PROGRESS)
+		_pthread_cond_wait(&once_cv, &once_lock);
+	/*
+	 * If previous thread was canceled, then the state still
+	 * could be ONCE_NEVER_DONE, we need to check it again.
+	 */
+	if (*(volatile int *)&(once_control->state) == ONCE_NEVER_DONE) {
+		once_control->state = ONCE_IN_PROGRESS;
+		_pthread_mutex_unlock(&once_lock);
+		_pthread_cleanup_push(once_cancel_handler, once_control);
+		init_routine();
+		_pthread_cleanup_pop(0);
+		_pthread_mutex_lock(&once_lock);
+		once_control->state = ONCE_DONE;
+		wakeup = 1;
 	}
+	_pthread_mutex_unlock(&once_lock);
+	if (wakeup)
+		_pthread_cond_broadcast(&once_cv);
 	return (0);
 }
+