Adding an object-oriented wrapper for threads.
This commit is contained in:
Tobias Brunner
@@ -0,0 +1,405 @@
|
||||
/*
|
||||
* Copyright (C) 2009 Tobias Brunner
|
||||
* Hochschule fuer Technik Rapperswil
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License as published by the
|
||||
* Free Software Foundation; either version 2 of the License, or (at your
|
||||
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* for more details.
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <semaphore.h>
|
||||
|
||||
#include <library.h>
|
||||
#include <debug.h>
|
||||
|
||||
#include <threading/thread_value.h>
|
||||
#include <threading/mutex.h>
|
||||
#include <utils/linked_list.h>
|
||||
|
||||
#include "thread.h"
|
||||
|
||||
typedef struct private_thread_t private_thread_t;
|
||||
|
||||
struct private_thread_t {
|
||||
/**
|
||||
* Public interface.
|
||||
*/
|
||||
thread_t public;
|
||||
|
||||
/**
|
||||
* Human-readable ID of this thread.
|
||||
*/
|
||||
u_int id;
|
||||
|
||||
/**
|
||||
* ID of the underlying thread.
|
||||
*/
|
||||
pthread_t thread_id;
|
||||
|
||||
/**
|
||||
* Main function of this thread (NULL for the main thread).
|
||||
*/
|
||||
thread_main_t main;
|
||||
|
||||
/**
|
||||
* Argument for the main function.
|
||||
*/
|
||||
void *arg;
|
||||
|
||||
/**
|
||||
* Stack of cleanup handlers.
|
||||
*/
|
||||
linked_list_t *cleanup_handlers;
|
||||
|
||||
/**
|
||||
* Mutex to make modifying thread properties safe.
|
||||
*/
|
||||
mutex_t *mutex;
|
||||
|
||||
/**
|
||||
* Semaphore used to sync the creation/start of the thread.
|
||||
*/
|
||||
sem_t created;
|
||||
|
||||
/**
|
||||
* TRUE if this thread has been detached or joined, i.e. can be cleaned
|
||||
* up after terminating.
|
||||
*/
|
||||
bool detached_or_joined;
|
||||
|
||||
/**
|
||||
* TRUE if the threads has terminated (cancelled, via thread_exit or
|
||||
* returned from the main function)
|
||||
*/
|
||||
bool terminated;
|
||||
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
/**
|
||||
* Cleanup callback function.
|
||||
*/
|
||||
thread_cleanup_t cleanup;
|
||||
|
||||
/**
|
||||
* Argument provided to the cleanup function.
|
||||
*/
|
||||
void *arg;
|
||||
|
||||
} cleanup_handler_t;
|
||||
|
||||
|
||||
/**
|
||||
* Next thread ID.
|
||||
*/
|
||||
static u_int next_id = 1;
|
||||
|
||||
/**
|
||||
* Mutex to safely access the next thread ID.
|
||||
*/
|
||||
static mutex_t *id_mutex;
|
||||
|
||||
/**
|
||||
* Store the thread object in a thread-specific value.
|
||||
*/
|
||||
static thread_value_t *current_thread;
|
||||
|
||||
|
||||
/**
|
||||
* Destroy an internal thread object.
|
||||
*
|
||||
* @note The mutex of this thread object has to be locked, it gets unlocked
|
||||
* automatically.
|
||||
*/
|
||||
static void thread_destroy(private_thread_t *this)
|
||||
{
|
||||
if (!this->terminated || !this->detached_or_joined)
|
||||
{
|
||||
this->mutex->unlock(this->mutex);
|
||||
return;
|
||||
}
|
||||
this->cleanup_handlers->destroy(this->cleanup_handlers);
|
||||
this->mutex->unlock(this->mutex);
|
||||
this->mutex->destroy(this->mutex);
|
||||
sem_destroy(&this->created);
|
||||
free(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of thread_t.cancel.
|
||||
*/
|
||||
static void cancel(private_thread_t *this)
|
||||
{
|
||||
this->mutex->lock(this->mutex);
|
||||
if (pthread_equal(this->thread_id, pthread_self()))
|
||||
{
|
||||
this->mutex->unlock(this->mutex);
|
||||
DBG1("!!! CANNOT CANCEL CURRENT THREAD !!!");
|
||||
return;
|
||||
}
|
||||
pthread_cancel(this->thread_id);
|
||||
this->mutex->unlock(this->mutex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of thread_t.kill.
|
||||
*/
|
||||
static void _kill(private_thread_t *this, int sig)
|
||||
{
|
||||
this->mutex->lock(this->mutex);
|
||||
if (pthread_equal(this->thread_id, pthread_self()))
|
||||
{
|
||||
/* it might actually be possible to send a signal to pthread_self (there
|
||||
* is an example in raise(3) describing that), the problem is though,
|
||||
* that the thread only returns here after the signal handler has
|
||||
* returned, so depending on the signal, the lock might not get
|
||||
* unlocked. */
|
||||
this->mutex->unlock(this->mutex);
|
||||
DBG1("!!! CANNOT SEND SIGNAL TO CURRENT THREAD !!!");
|
||||
return;
|
||||
}
|
||||
pthread_kill(this->thread_id, sig);
|
||||
this->mutex->unlock(this->mutex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of thread_t.cancel.
|
||||
*/
|
||||
static void detach(private_thread_t *this)
|
||||
{
|
||||
this->mutex->lock(this->mutex);
|
||||
pthread_detach(this->thread_id);
|
||||
this->detached_or_joined = TRUE;
|
||||
thread_destroy(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of thread_t.cancel.
|
||||
*/
|
||||
static void *join(private_thread_t *this)
|
||||
{
|
||||
pthread_t thread_id;
|
||||
void *val;
|
||||
this->mutex->lock(this->mutex);
|
||||
if (pthread_equal(this->thread_id, pthread_self()))
|
||||
{
|
||||
this->mutex->unlock(this->mutex);
|
||||
DBG1("!!! CANNOT JOIN CURRENT THREAD !!!");
|
||||
return NULL;
|
||||
}
|
||||
if (this->detached_or_joined)
|
||||
{
|
||||
this->mutex->unlock(this->mutex);
|
||||
DBG1("!!! CANNOT JOIN DETACHED THREAD !!!");
|
||||
return NULL;
|
||||
}
|
||||
thread_id = this->thread_id;
|
||||
this->detached_or_joined = TRUE;
|
||||
if (this->terminated)
|
||||
{
|
||||
/* thread has terminated before the call to join */
|
||||
thread_destroy(this);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* thread_destroy is called when the thread terminates normally */
|
||||
this->mutex->unlock(this->mutex);
|
||||
}
|
||||
pthread_join(thread_id, &val);
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an internal thread object.
|
||||
*/
|
||||
static private_thread_t *thread_create_internal()
|
||||
{
|
||||
private_thread_t *this = malloc_thing(private_thread_t);
|
||||
this->public.cancel = (void(*)(thread_t*))cancel;
|
||||
this->public.kill = (void(*)(thread_t*,int))_kill;
|
||||
this->public.detach = (void(*)(thread_t*))detach;
|
||||
this->public.join = (void*(*)(thread_t*))join;
|
||||
|
||||
this->id = 0;
|
||||
this->thread_id = 0;
|
||||
this->main = NULL;
|
||||
this->arg = NULL;
|
||||
this->cleanup_handlers = linked_list_create();
|
||||
this->mutex = mutex_create(MUTEX_TYPE_DEFAULT);
|
||||
sem_init(&this->created, FALSE, 0);
|
||||
this->detached_or_joined = FALSE;
|
||||
this->terminated = FALSE;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main cleanup function for threads.
|
||||
*/
|
||||
static void thread_cleanup(private_thread_t *this)
|
||||
{
|
||||
cleanup_handler_t *handler;
|
||||
this->mutex->lock(this->mutex);
|
||||
while (this->cleanup_handlers->remove_last(this->cleanup_handlers,
|
||||
(void**)&handler) == SUCCESS)
|
||||
{
|
||||
handler->cleanup(handler->arg);
|
||||
free(handler);
|
||||
}
|
||||
this->terminated = TRUE;
|
||||
thread_destroy(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Main function wrapper for threads.
|
||||
*/
|
||||
static void *thread_main(private_thread_t *this)
|
||||
{
|
||||
void *res;
|
||||
sem_wait(&this->created);
|
||||
current_thread->set(current_thread, this);
|
||||
pthread_cleanup_push((thread_cleanup_t)thread_cleanup, this);
|
||||
res = this->main(this->arg);
|
||||
pthread_cleanup_pop(TRUE);
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
thread_t *thread_create(thread_main_t main, void *arg)
|
||||
{
|
||||
private_thread_t *this = thread_create_internal();
|
||||
this->main = main;
|
||||
this->arg = arg;
|
||||
if (pthread_create(&this->thread_id, NULL, (void*)thread_main, this) != 0)
|
||||
{
|
||||
DBG1("failed to create thread!");
|
||||
thread_destroy(this);
|
||||
return NULL;
|
||||
}
|
||||
id_mutex->lock(id_mutex);
|
||||
this->id = next_id++;
|
||||
id_mutex->unlock(id_mutex);
|
||||
sem_post(&this->created);
|
||||
return &this->public;
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
thread_t *thread_current()
|
||||
{
|
||||
return current_thread->get(current_thread);
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
u_int thread_current_id()
|
||||
{
|
||||
private_thread_t *this = (private_thread_t*)thread_current();
|
||||
return this->id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
void thread_cleanup_push(thread_cleanup_t cleanup, void *arg)
|
||||
{
|
||||
private_thread_t *this = (private_thread_t*)thread_current();
|
||||
cleanup_handler_t *handler;
|
||||
this->mutex->lock(this->mutex);
|
||||
handler = malloc_thing(cleanup_handler_t);
|
||||
handler->cleanup = cleanup;
|
||||
handler->arg = arg;
|
||||
this->cleanup_handlers->insert_last(this->cleanup_handlers, handler);
|
||||
this->mutex->unlock(this->mutex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
void thread_cleanup_pop(bool execute)
|
||||
{
|
||||
private_thread_t *this = (private_thread_t*)thread_current();
|
||||
cleanup_handler_t *handler;
|
||||
this->mutex->lock(this->mutex);
|
||||
if (this->cleanup_handlers->remove_last(this->cleanup_handlers,
|
||||
(void**)&handler) != SUCCESS)
|
||||
{
|
||||
this->mutex->unlock(this->mutex);
|
||||
DBG1("!!! THREAD CLEANUP ERROR !!!");
|
||||
return;
|
||||
}
|
||||
this->mutex->unlock(this->mutex);
|
||||
|
||||
if (execute)
|
||||
{
|
||||
handler->cleanup(handler->arg);
|
||||
}
|
||||
free(handler);
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
bool thread_cancelability(bool enable)
|
||||
{
|
||||
int old;
|
||||
pthread_setcancelstate(enable ? PTHREAD_CANCEL_ENABLE
|
||||
: PTHREAD_CANCEL_DISABLE, &old);
|
||||
return old == PTHREAD_CANCEL_ENABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
void thread_cancellation_point()
|
||||
{
|
||||
bool old = thread_cancelability(TRUE);
|
||||
pthread_testcancel();
|
||||
thread_cancelability(old);
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
void thread_exit(void *val)
|
||||
{
|
||||
pthread_exit(val);
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
void threads_init()
|
||||
{
|
||||
private_thread_t *main_thread = thread_create_internal();
|
||||
main_thread->id = 0;
|
||||
main_thread->thread_id = pthread_self();
|
||||
current_thread = thread_value_create(NULL);
|
||||
current_thread->set(current_thread, (void*)main_thread);
|
||||
id_mutex = mutex_create(MUTEX_TYPE_DEFAULT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Described in header.
|
||||
*/
|
||||
void threads_deinit()
|
||||
{
|
||||
private_thread_t *main_thread = (private_thread_t*)thread_current();
|
||||
thread_destroy(main_thread);
|
||||
current_thread->destroy(current_thread);
|
||||
id_mutex->destroy(id_mutex);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user