lib/silcutil/unix/silcunixthread.c

   1 /*
   2
   3   silcunixthread.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2001 - 2007 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19 /* $Id$ */
  20
  21 #include "silc.h"
  22
  23 /**************************** SILC Thread API *******************************/
  24
  25 SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
  26                               SilcBool waitable)
  27 {
  28 #ifdef SILC_THREADS
  29   pthread_attr_t attr;
  30   pthread_t thread;
  31   int ret;
  32
  33   SILC_LOG_DEBUG(("Creating new thread"));
  34
  35   if (!start_func)
  36     return NULL;
  37
  38   if (pthread_attr_init(&attr)) {
  39     SILC_LOG_ERROR(("Thread error: %s", strerror(errno)));
  40     return NULL;
  41   }
  42
  43   if (pthread_attr_setdetachstate(&attr,
  44                                   waitable ? PTHREAD_CREATE_JOINABLE :
  45                                   PTHREAD_CREATE_DETACHED)) {
  46     SILC_LOG_ERROR(("Thread error: %s", strerror(errno)));
  47     pthread_attr_destroy(&attr);
  48     return NULL;
  49   }
  50
  51   ret = pthread_create(&thread, &attr, (void * (*)(void *))start_func,
  52                        context);
  53   if (ret) {
  54     SILC_LOG_ERROR(("Thread error: %s", strerror(errno)));
  55     pthread_attr_destroy(&attr);
  56     return NULL;
  57   }
  58
  59   pthread_attr_destroy(&attr);
  60
  61   SILC_LOG_DEBUG(("Created thread %p", (SilcThread)thread));
  62
  63   return (SilcThread)thread;
  64 #else
  65   /* Call thread callback immediately */
  66   (*start_func)(context);
  67   return NULL;
  68 #endif
  69 }
  70
  71 void silc_thread_exit(void *exit_value)
  72 {
  73 #ifdef SILC_THREADS
  74   pthread_exit(exit_value);
  75 #endif
  76 }
  77
  78 SilcThread silc_thread_self(void)
  79 {
  80 #ifdef SILC_THREADS
  81   pthread_t self = pthread_self();
  82   return (SilcThread)self;
  83 #else
  84   return NULL;
  85 #endif
  86 }
  87
  88 SilcBool silc_thread_wait(SilcThread thread, void **exit_value)
  89 {
  90 #ifdef SILC_THREADS
  91   SILC_LOG_DEBUG(("Waiting for thread %p", thread));
  92   if (!pthread_join(*(pthread_t *)thread, exit_value))
  93     return TRUE;
  94   return FALSE;
  95 #else
  96   return FALSE;
  97 #endif
  98 }
  99
 100 void silc_thread_yield(void)
 101 {
 102 #ifdef SILC_THREADS
 103 #ifdef HAVE_SCHED_YIELD
 104   sched_yield();
 105 #endif /* HAVE_SCHED_YIELD */
 106 #endif /* SILC_THREADS */
 107 }
 108
 109 /***************************** SILC Mutex API *******************************/
 110
 111 /* SILC Mutex structure */
 112 struct SilcMutexStruct {
 113 #ifdef SILC_THREADS
 114   pthread_mutex_t mutex;
 115 #endif /* SILC_THREADS */
 116   unsigned int locked : 1;
 117 };
 118
 119 SilcBool silc_mutex_alloc(SilcMutex *mutex)
 120 {
 121 #ifdef SILC_THREADS
 122   *mutex = silc_calloc(1, sizeof(**mutex));
 123   if (*mutex == NULL)
 124     return FALSE;
 125   pthread_mutex_init(&(*mutex)->mutex, NULL);
 126   (*mutex)->locked = FALSE;
 127   return TRUE;
 128 #else
 129   return FALSE;
 130 #endif /* SILC_THREADS */
 131 }
 132
 133 void silc_mutex_free(SilcMutex mutex)
 134 {
 135 #ifdef SILC_THREADS
 136   if (mutex) {
 137     pthread_mutex_destroy(&mutex->mutex);
 138     silc_free(mutex);
 139   }
 140 #endif /* SILC_THREADS */
 141 }
 142
 143 void silc_mutex_lock(SilcMutex mutex)
 144 {
 145 #ifdef SILC_THREADS
 146   if (mutex) {
 147     SILC_VERIFY(pthread_mutex_lock(&mutex->mutex) == 0);
 148     mutex->locked = TRUE;
 149   }
 150 #endif /* SILC_THREADS */
 151 }
 152
 153 void silc_mutex_unlock(SilcMutex mutex)
 154 {
 155 #ifdef SILC_THREADS
 156   if (mutex) {
 157     SILC_VERIFY(pthread_mutex_unlock(&mutex->mutex) == 0);
 158     mutex->locked = FALSE;
 159   }
 160 #endif /* SILC_THREADS */
 161 }
 162
 163 void silc_mutex_assert_locked(SilcMutex mutex)
 164 {
 165 #ifdef SILC_THREADS
 166   if (mutex)
 167     SILC_VERIFY(mutex->locked);
 168 #endif /* SILC_THREADS */
 169 }
 170
 171 /***************************** SILC Rwlock API ******************************/
 172
 173 /* SILC read/write lock structure */
 174 struct SilcRwLockStruct {
 175 #ifdef SILC_THREADS
 176   pthread_rwlock_t rwlock;
 177 #else
 178   void *tmp;
 179 #endif /* SILC_THREADS */
 180 };
 181
 182 SilcBool silc_rwlock_alloc(SilcRwLock *rwlock)
 183 {
 184 #ifdef SILC_THREADS
 185   *rwlock = silc_calloc(1, sizeof(**rwlock));
 186   if (*rwlock == NULL)
 187     return FALSE;
 188   pthread_rwlock_init(&(*rwlock)->rwlock, NULL);
 189   return TRUE;
 190 #else
 191   return FALSE;
 192 #endif /* SILC_THREADS */
 193 }
 194
 195 void silc_rwlock_free(SilcRwLock rwlock)
 196 {
 197 #ifdef SILC_THREADS
 198   if (rwlock) {
 199     pthread_rwlock_destroy(&rwlock->rwlock);
 200     silc_free(rwlock);
 201   }
 202 #endif /* SILC_THREADS */
 203 }
 204
 205 void silc_rwlock_rdlock(SilcRwLock rwlock)
 206 {
 207 #ifdef SILC_THREADS
 208   if (rwlock)
 209     pthread_rwlock_rdlock(&rwlock->rwlock);
 210 #endif /* SILC_THREADS */
 211 }
 212
 213 void silc_rwlock_wrlock(SilcRwLock rwlock)
 214 {
 215 #ifdef SILC_THREADS
 216   if (rwlock)
 217     SILC_VERIFY(pthread_rwlock_wrlock(&rwlock->rwlock) == 0);
 218 #endif /* SILC_THREADS */
 219 }
 220
 221 void silc_rwlock_unlock(SilcRwLock rwlock)
 222 {
 223 #ifdef SILC_THREADS
 224   if (rwlock)
 225     SILC_VERIFY(pthread_rwlock_unlock(&rwlock->rwlock) == 0);
 226 #endif /* SILC_THREADS */
 227 }
 228
 229 /****************************** SILC Cond API *******************************/
 230
 231 /* SILC Conditional Variable context */
 232 struct SilcCondStruct {
 233 #ifdef SILC_THREADS
 234   pthread_cond_t cond;
 235 #else
 236   void *tmp;
 237 #endif /* SILC_THREADS*/
 238 };
 239
 240 SilcBool silc_cond_alloc(SilcCond *cond)
 241 {
 242 #ifdef SILC_THREADS
 243   *cond = silc_calloc(1, sizeof(**cond));
 244   if (*cond == NULL)
 245     return FALSE;
 246   pthread_cond_init(&(*cond)->cond, NULL);
 247   return TRUE;
 248 #else
 249   return FALSE;
 250 #endif /* SILC_THREADS*/
 251 }
 252
 253 void silc_cond_free(SilcCond cond)
 254 {
 255 #ifdef SILC_THREADS
 256   pthread_cond_destroy(&cond->cond);
 257   silc_free(cond);
 258 #endif /* SILC_THREADS*/
 259 }
 260
 261 void silc_cond_signal(SilcCond cond)
 262 {
 263 #ifdef SILC_THREADS
 264   pthread_cond_signal(&cond->cond);
 265 #endif /* SILC_THREADS*/
 266 }
 267
 268 void silc_cond_broadcast(SilcCond cond)
 269 {
 270 #ifdef SILC_THREADS
 271   pthread_cond_broadcast(&cond->cond);
 272 #endif /* SILC_THREADS*/
 273 }
 274
 275 void silc_cond_wait(SilcCond cond, SilcMutex mutex)
 276 {
 277 #ifdef SILC_THREADS
 278   pthread_cond_wait(&cond->cond, &mutex->mutex);
 279 #endif /* SILC_THREADS*/
 280 }
 281
 282 SilcBool silc_cond_timedwait(SilcCond cond, SilcMutex mutex,
 283                              int timeout)
 284 {
 285 #ifdef SILC_THREADS
 286   struct timespec t;
 287   if (timeout) {
 288     t.tv_sec = timeout / 1000;
 289     t.tv_nsec = (timeout % 1000) * 1000;
 290     return pthread_cond_timedwait(&cond->cond, &mutex->mutex, &t) == 0;
 291   }
 292
 293   return pthread_cond_wait(&cond->cond, &mutex->mutex) == 0;
 294 #else
 295   return FALSE;
 296 #endif /* SILC_THREADS*/
 297 }