d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Original pthread_once code has memory leak if pthread_once_t is used in

Browse Source 
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
This commit is contained in:
David Xu 2003-09-09 22:38:12 +00:00
parent 3c0f0ccce7
commit 639b4ccf7d
4 changed files with 104 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
lib/libkse/thread/thr_once.c
View File

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

2
lib/libkse/thread/thr_private.h
View File

@ -1099,6 +1099,8 @@ int _pthread_rwlock_destroy (pthread_rwlock_t *);
struct pthread *_pthread_self(void);
int _pthread_setspecific(pthread_key_t, const void *);
void _pthread_yield(void);
void _pthread_cleanup_push(void (*routine) (void *), void *routine_arg);
void _pthread_cleanup_pop(int execute);
struct pthread *_thr_alloc(struct pthread *);
void _thr_exit(char *, int, char *);
void _thr_exit_cleanup(void);

59
lib/libpthread/thread/thr_once.c
View File

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

2
lib/libpthread/thread/thr_private.h
View File

@ -1099,6 +1099,8 @@ int _pthread_rwlock_destroy (pthread_rwlock_t *);
struct pthread *_pthread_self(void);
int _pthread_setspecific(pthread_key_t, const void *);
void _pthread_yield(void);
void _pthread_cleanup_push(void (*routine) (void *), void *routine_arg);
void _pthread_cleanup_pop(int execute);
struct pthread *_thr_alloc(struct pthread *);
void _thr_exit(char *, int, char *);
void _thr_exit_cleanup(void);