Return to semaphore.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / threading

Strongswan

    1: /*
    2:  * Copyright (C) 2011 Tobias Brunner
    3:  * HSR Hochschule fuer Technik Rapperswil
    4:  *
    5:  * This program is free software; you can redistribute it and/or modify it
    6:  * under the terms of the GNU General Public License as published by the
    7:  * Free Software Foundation; either version 2 of the License, or (at your
    8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
    9:  *
   10:  * This program is distributed in the hope that it will be useful, but
   11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13:  * for more details.
   14:  */
   15: 
   16: #include <library.h>
   17: 
   18: #if defined(HAVE_CLOCK_GETTIME) && \
   19: 	(defined(HAVE_CONDATTR_CLOCK_MONOTONIC) || \
   20: 	 defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC))
   21: /* if we use MONOTONIC times, we can't use POSIX_SEMAPHORES since they use
   22:  * times based on CLOCK_REALTIME */
   23: #undef HAVE_SEM_TIMEDWAIT
   24: #endif /* HAVE_CLOCK_GETTIME && ... */
   25: 
   26: #ifdef HAVE_SEM_TIMEDWAIT
   27: #include <semaphore.h>
   28: #else /* !HAVE_SEM_TIMEDWAIT */
   29: #include <threading/thread.h>
   30: #include <threading/condvar.h>
   31: #endif /* HAVE_SEM_TIMEDWAIT */
   32: 
   33: #include "semaphore.h"
   34: 
   35: typedef struct private_semaphore_t private_semaphore_t;
   36: 
   37: /**
   38:  * private data of a semaphore
   39:  */
   40: struct private_semaphore_t {
   41: 	/**
   42: 	 * public interface
   43: 	 */
   44: 	semaphore_t public;
   45: 
   46: #ifdef HAVE_SEM_TIMEDWAIT
   47: 	/**
   48: 	 * wrapped POSIX semaphore object
   49: 	 */
   50: 	sem_t sem;
   51: #else /* !HAVE_SEM_TIMEDWAIT */
   52: 
   53: 	/**
   54: 	 * Mutex to lock count variable
   55: 	 */
   56: 	mutex_t *mutex;
   57: 
   58: 	/**
   59: 	 * Condvar to signal count increase
   60: 	 */
   61: 	condvar_t *cond;
   62: 
   63: 	/**
   64: 	 * Semaphore count value
   65: 	 */
   66: 	u_int count;
   67: #endif /* HAVE_SEM_TIMEDWAIT */
   68: };
   69: 
   70: METHOD(semaphore_t, wait_, void,
   71: 	private_semaphore_t *this)
   72: {
   73: #ifdef HAVE_SEM_TIMEDWAIT
   74: 	sem_wait(&this->sem);
   75: #else /* !HAVE_SEM_TIMEDWAIT */
   76: 	this->mutex->lock(this->mutex);
   77: 	thread_cleanup_push((void*)this->mutex->unlock, this->mutex);
   78: 	while (this->count == 0)
   79: 	{
   80: 		this->cond->wait(this->cond, this->mutex);
   81: 	}
   82: 	this->count--;
   83: 	thread_cleanup_pop(TRUE);
   84: #endif /* HAVE_SEM_TIMEDWAIT */
   85: }
   86: 
   87: METHOD(semaphore_t, timed_wait_abs, bool,
   88: 	private_semaphore_t *this, timeval_t tv)
   89: {
   90: #ifdef HAVE_SEM_TIMEDWAIT
   91: 	timespec_t ts;
   92: 
   93: 	ts.tv_sec = tv.tv_sec;
   94: 	ts.tv_nsec = tv.tv_usec * 1000;
   95: 
   96: 	/* there are errors other than ETIMEDOUT possible, but we consider them
   97: 	 * all as timeout */
   98: 	return sem_timedwait(&this->sem, &ts) == -1;
   99: #else /* !HAVE_SEM_TIMEDWAIT */
  100: 	this->mutex->lock(this->mutex);
  101: 	thread_cleanup_push((void*)this->mutex->unlock, this->mutex);
  102: 	while (this->count == 0)
  103: 	{
  104: 		if (this->cond->timed_wait_abs(this->cond, this->mutex, tv))
  105: 		{
  106: 			thread_cleanup_pop(TRUE);
  107: 			return TRUE;
  108: 		}
  109: 	}
  110: 	this->count--;
  111: 	thread_cleanup_pop(TRUE);
  112: 	return FALSE;
  113: #endif /* HAVE_SEM_TIMEDWAIT */
  114: }
  115: 
  116: METHOD(semaphore_t, timed_wait, bool,
  117: 	private_semaphore_t *this, u_int timeout)
  118: {
  119: 	timeval_t tv, add;
  120: 
  121: 	add.tv_sec = timeout / 1000;
  122: 	add.tv_usec = (timeout % 1000) * 1000;
  123: 
  124: 	time_monotonic(&tv);
  125: 	timeradd(&tv, &add, &tv);
  126: 
  127: 	return timed_wait_abs(this, tv);
  128: }
  129: 
  130: METHOD(semaphore_t, post, void,
  131: 	private_semaphore_t *this)
  132: {
  133: #ifdef HAVE_SEM_TIMEDWAIT
  134: 	sem_post(&this->sem);
  135: #else /* !HAVE_SEM_TIMEDWAIT */
  136: 	this->mutex->lock(this->mutex);
  137: 	this->count++;
  138: 	this->mutex->unlock(this->mutex);
  139: 	this->cond->signal(this->cond);
  140: #endif /* HAVE_SEM_TIMEDWAIT */
  141: }
  142: 
  143: METHOD(semaphore_t, destroy, void,
  144: 	private_semaphore_t *this)
  145: {
  146: #ifdef HAVE_SEM_TIMEDWAIT
  147: 	sem_destroy(&this->sem);
  148: #else /* !HAVE_SEM_TIMEDWAIT */
  149: 	this->cond->destroy(this->cond);
  150: 	this->mutex->destroy(this->mutex);
  151: #endif /* HAVE_SEM_TIMEDWAIT */
  152: 	free(this);
  153: }
  154: 
  155: /*
  156:  * Described in header
  157:  */
  158: semaphore_t *semaphore_create(u_int value)
  159: {
  160: 	private_semaphore_t *this;
  161: 
  162: 	INIT(this,
  163: 		.public = {
  164: 			.wait = _wait_,
  165: 			.timed_wait = _timed_wait,
  166: 			.timed_wait_abs = _timed_wait_abs,
  167: 			.post = _post,
  168: 			.destroy = _destroy,
  169: 		},
  170: 	);
  171: 
  172: #ifdef HAVE_SEM_TIMEDWAIT
  173: 	sem_init(&this->sem, 0, value);
  174: #else /* !HAVE_SEM_TIMEDWAIT */
  175: 	this->mutex = mutex_create(MUTEX_TYPE_DEFAULT);
  176: 	this->cond = condvar_create(CONDVAR_TYPE_DEFAULT);
  177: 	this->count = value;
  178: #endif /* HAVE_SEM_TIMEDWAIT */
  179: 
  180: 	return &this->public;
  181: }