#include <daemon.h>
#include <processing/processor.h>
#include <processing/jobs/callback_job.h>
+#include <utils/mutex.h>
typedef struct event_t event_t;
/**
* Exclusive access to list
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* Condvar to wait for next job.
*/
- pthread_cond_t condvar;
-
- bool cancelled;
+ condvar_t *condvar;
};
/**
*/
static job_requeue_t schedule(private_scheduler_t * this)
{
- timespec_t timeout;
timeval_t now;
event_t *event;
long difference;
bool timed = FALSE;
DBG2(DBG_JOB, "waiting for next event...");
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
gettimeofday(&now, NULL);
difference = time_difference(&now, &event->time);
if (difference > 0)
{
- DBG2(DBG_JOB, "got event, queueing job for execution");
this->list->remove_first(this->list, (void **)&event);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
+ DBG2(DBG_JOB, "got event, queueing job for execution");
charon->processor->queue_job(charon->processor, event->job);
free(event);
return JOB_REQUEUE_DIRECT;
}
- timeout.tv_sec = event->time.tv_sec;
- timeout.tv_nsec = event->time.tv_usec * 1000;
timed = TRUE;
}
- pthread_cleanup_push((void*)pthread_mutex_unlock, &this->mutex);
+ pthread_cleanup_push((void*)this->mutex->unlock, this->mutex);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
if (timed)
{
- pthread_cond_timedwait(&this->condvar, &this->mutex, &timeout);
+ this->condvar->timed_wait_abs(this->condvar, this->mutex, event->time);
}
else
{
- pthread_cond_wait(&this->condvar, &this->mutex);
+ this->condvar->wait(this->condvar, this->mutex);
}
pthread_setcancelstate(oldstate, NULL);
pthread_cleanup_pop(TRUE);
static u_int get_job_load(private_scheduler_t *this)
{
int count;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
count = this->list->get_count(this->list);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return count;
}
event->time.tv_usec = (now.tv_usec + us) % 1000000;
event->time.tv_sec = now.tv_sec + (now.tv_usec + us)/1000000 + s;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
while(TRUE)
{
if (this->list->get_count(this->list) == 0)
iterator->destroy(iterator);
break;
}
- pthread_cond_signal(&this->condvar);
- pthread_mutex_unlock(&this->mutex);
+ this->condvar->signal(this->condvar);
+ this->mutex->unlock(this->mutex);
}
/**
*/
static void destroy(private_scheduler_t *this)
{
- this->cancelled = TRUE;
this->job->cancel(this->job);
+ this->condvar->destroy(this->condvar);
+ this->mutex->destroy(this->mutex);
this->list->destroy_function(this->list, (void*)event_destroy);
free(this);
}
this->public.destroy = (void(*)(scheduler_t*)) destroy;
this->list = linked_list_create();
- this->cancelled = FALSE;
- pthread_mutex_init(&this->mutex, NULL);
- pthread_cond_init(&this->condvar, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
+ this->condvar = condvar_create(CONDVAR_DEFAULT);
this->job = callback_job_create((callback_job_cb_t)schedule, this, NULL, NULL);
charon->processor->queue_job(charon->processor, (job_t*)this->job);
/*
+ * Copyright (C) 2008 Tobias Brunner
* Copyright (C) 2008 Martin Willi
* Hochschule fuer Technik Rapperswil
*
}
/**
- * Implementation of condvar_t.timed_wait.
+ * Implementation of condvar_t.timed_wait_abs.
*/
-static bool timed_wait(private_condvar_t *this, private_mutex_t *mutex,
- u_int timeout)
+static bool timed_wait_abs(private_condvar_t *this, private_mutex_t *mutex,
+ timeval_t time)
{
struct timespec ts;
- struct timeval tv;
- u_int s, ms;
bool timed_out;
- gettimeofday(&tv, NULL);
-
- s = timeout / 1000;
- ms = timeout % 1000;
+ ts.tv_sec = time.tv_sec;
+ ts.tv_nsec = time.tv_usec * 1000;
- ts.tv_sec = tv.tv_sec + s;
- ts.tv_nsec = tv.tv_usec * 1000 + ms * 1000000;
- if (ts.tv_nsec > 1000000000 /* 1s */)
- {
- ts.tv_nsec -= 1000000000;
- ts.tv_sec++;
- }
if (mutex->recursive)
{
private_r_mutex_t* recursive = (private_r_mutex_t*)mutex;
return timed_out;
}
+/**
+ * Implementation of condvar_t.timed_wait.
+ */
+static bool timed_wait(private_condvar_t *this, private_mutex_t *mutex,
+ u_int timeout)
+{
+ timeval_t tv;
+ u_int s, ms;
+
+ gettimeofday(&tv, NULL);
+
+ s = timeout / 1000;
+ ms = timeout % 1000;
+
+ tv.tv_sec += s;
+ tv.tv_usec += ms * 1000;
+
+ if (tv.tv_usec > 1000000 /* 1s */)
+ {
+ tv.tv_usec -= 1000000;
+ tv.tv_sec++;
+ }
+ return timed_wait_abs(this, mutex, tv);
+}
+
/**
* Implementation of condvar_t.signal.
*/
this->public.wait = (void(*)(condvar_t*, mutex_t *mutex))wait;
this->public.timed_wait = (bool(*)(condvar_t*, mutex_t *mutex, u_int timeout))timed_wait;
+ this->public.timed_wait_abs = (bool(*)(condvar_t*, mutex_t *mutex, timeval_t time))timed_wait_abs;
this->public.signal = (void(*)(condvar_t*))signal;
this->public.broadcast = (void(*)(condvar_t*))broadcast;
this->public.destroy = (void(*)(condvar_t*))condvar_destroy;
/*
+ * Copyright (C) 2008 Tobias Brunner
* Copyright (C) 2008 Martin Willi
* Hochschule fuer Technik Rapperswil
*
* 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.
+ *
+ * $Id$
*/
/**
*/
bool (*timed_wait)(condvar_t *this, mutex_t *mutex, u_int timeout);
+ /**
+ * Wait on a condvar until it gets signalized, or times out.
+ *
+ * @param mutex mutex to release while waiting
+ * @param time absolute time until timeout
+ * @return TRUE if timed out, FALSE otherwise
+ */
+ bool (*timed_wait_abs)(condvar_t *this, mutex_t *mutex, timeval_t timeout);
+
/**
* Wake up a single thread in a condvar.
*/
projects / thirdparty / strongswan.git / commitdiff
