cups/thread.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   Threading primitives for CUPS.
   5  *
   6  *   Copyright 2009-2010 by Apple Inc.
   7  *
   8  *   These coded instructions, statements, and computer programs are the
   9  *   property of Apple Inc. and are protected by Federal copyright
  10  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  11  *   which should have been included with this file.  If this file is
  12  *   file is missing or damaged, see the license at "http://www.cups.org/".
  13  *
  14  * Contents:
  15  *
  16  *   _cupsMutexInit()    - Initialize a mutex.
  17  *   _cupsMutexLock()    - Lock a mutex.
  18  *   _cupsMutexUnlock()  - Unlock a mutex.
  19  *   _cupsRWInit()       - Initialize a reader/writer lock.
  20  *   _cupsRWLockRead()   - Acquire a reader/writer lock for reading.
  21  *   _cupsRWLockWrite()  - Acquire a reader/writer lock for writing.
  22  *   _cupsRWUnlock()     - Release a reader/writer lock.
  23  *   _cupsThreadCreate() - Create a thread.
  24  */
  25
  26 /*
  27  * Include necessary headers...
  28  */
  29
  30 #include "cups-private.h"
  31 #include "thread-private.h"
  32
  33
  34 #if defined(HAVE_PTHREAD_H)
  35 /*
  36  * '_cupsMutexInit()' - Initialize a mutex.
  37  */
  38
  39 void
  40 _cupsMutexInit(_cups_mutex_t *mutex)    /* I - Mutex */
  41 {
  42   pthread_mutex_init(mutex, NULL);
  43 }
  44
  45
  46 /*
  47  * '_cupsMutexLock()' - Lock a mutex.
  48  */
  49
  50 void
  51 _cupsMutexLock(_cups_mutex_t *mutex)    /* I - Mutex */
  52 {
  53   pthread_mutex_lock(mutex);
  54 }
  55
  56
  57 /*
  58  * '_cupsMutexUnlock()' - Unlock a mutex.
  59  */
  60
  61 void
  62 _cupsMutexUnlock(_cups_mutex_t *mutex)  /* I - Mutex */
  63 {
  64   pthread_mutex_unlock(mutex);
  65 }
  66
  67
  68 /*
  69  * '_cupsRWInit()' - Initialize a reader/writer lock.
  70  */
  71
  72 void
  73 _cupsRWInit(_cups_rwlock_t *rwlock)     /* I - Reader/writer lock */
  74 {
  75   pthread_rwlock_init(rwlock, NULL);
  76 }
  77
  78
  79 /*
  80  * '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
  81  */
  82
  83 void
  84 _cupsRWLockRead(_cups_rwlock_t *rwlock) /* I - Reader/writer lock */
  85 {
  86   pthread_rwlock_rdlock(rwlock);
  87 }
  88
  89
  90 /*
  91  * '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
  92  */
  93
  94 void
  95 _cupsRWLockWrite(_cups_rwlock_t *rwlock)/* I - Reader/writer lock */
  96 {
  97   pthread_rwlock_wrlock(rwlock);
  98 }
  99
 100
 101 /*
 102  * '_cupsRWUnlock()' - Release a reader/writer lock.
 103  */
 104
 105 void
 106 _cupsRWUnlock(_cups_rwlock_t *rwlock)   /* I - Reader/writer lock */
 107 {
 108   pthread_rwlock_unlock(rwlock);
 109 }
 110
 111
 112 /*
 113  * '_cupsThreadCreate()' - Create a thread.
 114  */
 115
 116 int                                     /* O - 0 on failure, 1 on success */
 117 _cupsThreadCreate(
 118     _cups_thread_func_t func,           /* I - Entry point */
 119     void                *arg)           /* I - Entry point context */
 120 {
 121   pthread_t thread;
 122
 123   return (pthread_create(&thread, NULL, (void *(*)(void *))func, arg) == 0);
 124 }
 125
 126
 127 #elif defined(WIN32)
 128 #  include <process.h>
 129
 130
 131 /*
 132  * '_cupsMutexInit()' - Initialize a mutex.
 133  */
 134
 135 void
 136 _cupsMutexInit(_cups_mutex_t *mutex)    /* I - Mutex */
 137 {
 138   InitializeCriticalSection(&mutex->m_criticalSection);
 139   mutex->m_init = 1;
 140 }
 141
 142
 143 /*
 144  * '_cupsMutexLock()' - Lock a mutex.
 145  */
 146
 147 void
 148 _cupsMutexLock(_cups_mutex_t *mutex)    /* I - Mutex */
 149 {
 150   if (!mutex->m_init)
 151   {
 152     _cupsGlobalLock();
 153
 154     if (!mutex->m_init)
 155     {
 156       InitializeCriticalSection(&mutex->m_criticalSection);
 157       mutex->m_init = 1;
 158     }
 159
 160     _cupsGlobalUnlock();
 161   }
 162
 163   EnterCriticalSection(&mutex->m_criticalSection);
 164 }
 165
 166
 167 /*
 168  * '_cupsMutexUnlock()' - Unlock a mutex.
 169  */
 170
 171 void
 172 _cupsMutexUnlock(_cups_mutex_t *mutex)  /* I - Mutex */
 173 {
 174   LeaveCriticalSection(&mutex->m_criticalSection);
 175 }
 176
 177
 178 /*
 179  * '_cupsRWInit()' - Initialize a reader/writer lock.
 180  */
 181
 182 void
 183 _cupsRWInit(_cups_rwlock_t *rwlock)     /* I - Reader/writer lock */
 184 {
 185   _cupsMutexInit((_cups_mutex_t *)rwlock);
 186 }
 187
 188
 189 /*
 190  * '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
 191  */
 192
 193 void
 194 _cupsRWLockRead(_cups_rwlock_t *rwlock) /* I - Reader/writer lock */
 195 {
 196   _cupsMutexLock((_cups_mutex_t *)rwlock);
 197 }
 198
 199
 200 /*
 201  * '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
 202  */
 203
 204 void
 205 _cupsRWLockWrite(_cups_rwlock_t *rwlock)/* I - Reader/writer lock */
 206 {
 207   _cupsMutexLock((_cups_mutex_t *)rwlock);
 208 }
 209
 210
 211 /*
 212  * '_cupsRWUnlock()' - Release a reader/writer lock.
 213  */
 214
 215 void
 216 _cupsRWUnlock(_cups_rwlock_t *rwlock)   /* I - Reader/writer lock */
 217 {
 218   _cupsMutexUnlock((_cups_mutex_t *)rwlock);
 219 }
 220
 221
 222 /*
 223  * '_cupsThreadCreate()' - Create a thread.
 224  */
 225
 226 int                                     /* O - 0 on failure, 1 on success */
 227 _cupsThreadCreate(
 228     _cups_thread_func_t func,           /* I - Entry point */
 229     void                *arg)           /* I - Entry point context */
 230 {
 231   return (_beginthreadex(NULL, 0, (LPTHREAD_START_ROUTINE) func, arg, 0, NULL)
 232               != 0);
 233 }
 234
 235
 236 #else
 237 /*
 238  * '_cupsMutexInit()' - Initialize a mutex.
 239  */
 240
 241 void
 242 _cupsMutexInit(_cups_mutex_t *mutex)    /* I - Mutex */
 243 {
 244   (void)mutex;
 245 }
 246
 247
 248 /*
 249  * '_cupsMutexLock()' - Lock a mutex.
 250  */
 251
 252 void
 253 _cupsMutexLock(_cups_mutex_t *mutex)    /* I - Mutex */
 254 {
 255   (void)mutex;
 256 }
 257
 258
 259 /*
 260  * '_cupsMutexUnlock()' - Unlock a mutex.
 261  */
 262
 263 void
 264 _cupsMutexUnlock(_cups_mutex_t *mutex)  /* I - Mutex */
 265 {
 266   (void)mutex;
 267 }
 268
 269
 270 /*
 271  * '_cupsRWInit()' - Initialize a reader/writer lock.
 272  */
 273
 274 void
 275 _cupsRWInit(_cups_rwlock_t *rwlock)     /* I - Reader/writer lock */
 276 {
 277   (void)rwlock;
 278 }
 279
 280
 281 /*
 282  * '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
 283  */
 284
 285 void
 286 _cupsRWLockRead(_cups_rwlock_t *rwlock) /* I - Reader/writer lock */
 287 {
 288   (void)rwlock;
 289 }
 290
 291
 292 /*
 293  * '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
 294  */
 295
 296 void
 297 _cupsRWLockWrite(_cups_rwlock_t *rwlock)/* I - Reader/writer lock */
 298 {
 299   (void)rwlock;
 300 }
 301
 302
 303 /*
 304  * '_cupsRWUnlock()' - Release a reader/writer lock.
 305  */
 306
 307 void
 308 _cupsRWUnlock(_cups_rwlock_t *rwlock)   /* I - Reader/writer lock */
 309 {
 310   (void)rwlock;
 311 }
 312 #endif /* HAVE_PTHREAD_H */
 313
 314
 315 /*
 316  * End of "$Id$".
 317  */