1 krisbash 1.1 #ifndef _pal_lockposix_h
  2              #define _pal_lockposix_h
  3              
  4              #if !defined(_pal_lock_h)
  5              #error "Include pal/lock.h (Atomic version available)"
  6              #endif
  7              
  8              #include "palcommon.h"
  9              #include "thread.h"
 10              #include <pthread.h>
 11              
 12              PAL_BEGIN_EXTERNC
 13              
 14              /*
 15              **==============================================================================
 16              **
 17              ** ReadWriteLock -- read/write lock (non-recursive)
 18              **
 19              **==============================================================================
 20              */
 21              
 22 krisbash 1.1 #define READWRITELOCK_INITIALIZER PTHREAD_RWLOCK_INITIALIZER
 23              
 24              typedef struct _ReadWriteLock
 25              {
 26                  pthread_rwlock_t lock;
 27              } 
 28              ReadWriteLock;
 29              
 30              PAL_INLINE void ReadWriteLock_Init(_Out_ ReadWriteLock* self)
 31              {
 32                  pthread_rwlock_t tmp = PTHREAD_RWLOCK_INITIALIZER;
 33                  memcpy(&self->lock, &tmp, sizeof(tmp));
 34              }
 35              
 36              PAL_INLINE void ReadWriteLock_AcquireRead(
 37                  _Inout_ ReadWriteLock* self)
 38              {
 39                  pthread_rwlock_rdlock(&self->lock);
 40              }
 41              
 42              PAL_INLINE int ReadWriteLock_TryAcquireRead(
 43 krisbash 1.1     _Inout_ ReadWriteLock* self)
 44              {
 45                  return pthread_rwlock_tryrdlock(&self->lock) == 0 ? 1 : 0;
 46              }
 47              
 48              PAL_INLINE void ReadWriteLock_AcquireWrite(
 49                  _Inout_ ReadWriteLock* self)
 50              {
 51                  pthread_rwlock_wrlock(&self->lock);
 52              }
 53              
 54              PAL_INLINE int ReadWriteLock_TryAcquireWrite(
 55                  _Inout_ ReadWriteLock* self)
 56              {
 57                  return pthread_rwlock_trywrlock(&self->lock) == 0 ? 1 : 0;
 58              }
 59              
 60              PAL_INLINE void ReadWriteLock_ReleaseRead(
 61                  _Inout_ ReadWriteLock* self)
 62              {
 63                  pthread_rwlock_unlock(&self->lock);
 64 krisbash 1.1 }
 65              
 66              PAL_INLINE void ReadWriteLock_ReleaseWrite(
 67                  _Inout_ ReadWriteLock* self)
 68              {
 69                  pthread_rwlock_unlock(&self->lock);
 70              }
 71              
 72              /*
 73              **==============================================================================
 74              **
 75              ** Lock -- simple non-recursive lock
 76              **
 77              **==============================================================================
 78              */
 79              
 80              #define LOCK_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
 81              
 82              typedef struct _Lock
 83              {
 84                  pthread_mutex_t lock;
 85 krisbash 1.1 } Lock;
 86              
 87              PAL_INLINE void Lock_Init(
 88                  _Out_ Lock* self)
 89              {
 90                  pthread_mutex_t tmp = PTHREAD_MUTEX_INITIALIZER;
 91                  memcpy(&self->lock, &tmp, sizeof(tmp));
 92              }
 93              
 94              PAL_INLINE void Lock_Acquire(
 95                  _Inout_ Lock* self)
 96              {
 97                  pthread_mutex_lock(&self->lock);
 98              }
 99              
100              PAL_INLINE int Lock_TryAcquire(
101                  _Inout_ Lock* self)
102              {
103                  return pthread_mutex_trylock(&self->lock) == 0 ? 1 : 0;
104              }
105              
106 krisbash 1.1 PAL_INLINE void Lock_Release(
107                  _Inout_ Lock* self)
108              {
109                  pthread_mutex_unlock(&self->lock);
110              }
111              
112              /*
113              **==============================================================================
114              **
115              ** RecursiveLock -- recursive lock
116              **
117              **==============================================================================
118              */
119              
120              #define RECURSIVELOCK_INITIALIZER {LOCK_INITIALIZER, 0}
121              
122              typedef struct _RecursiveLock
123              {
124                  Lock lock;
125                  ptrdiff_t count;
126                  ThreadID owner;
127 krisbash 1.1 } RecursiveLock;
128              
129              PAL_INLINE void RecursiveLock_Init(
130                  _Out_ RecursiveLock* self)
131              {
132                  Lock_Init(&self->lock);
133                  self->count = 0;
134                  self->owner = Thread_ID_Null();
135              }
136              
137              void RecursiveLock_Acquire(
138                  _Inout_ RecursiveLock* self);
139              
140              PAL_INLINE void RecursiveLock_Release(
141                  _Inout_ RecursiveLock* self)
142              {
143                  if (--self->count > 0)
144                      return;
145              
146                  self->owner = Thread_ID_Null();
147                  Lock_Release(&self->lock);
148 krisbash 1.1 }
149              
150              /*
151              **==============================================================================
152              **
153              ** CachedLock -- cached lock
154              **
155              **==============================================================================
156              */
157              
158              typedef ReadWriteLock CachedLock;
159              
160              #define CACHEDLOCK_FLAG_SHARED (1 << 0)
161              
162              _Return_type_success_(return == 0) 
163              PAL_INLINE int CachedLock_Init(
164                  _Out_ CachedLock* self,
165                  unsigned long flags)
166              { 
167                  ReadWriteLock_Init(self); 
168                  return 0; 
169 krisbash 1.1 }
170              
171              #define CachedLock_Destroy(self) 
172              
173              #define CachedLock_AcquireRead(self, token) ReadWriteLock_AcquireRead(self)
174              
175              #define CachedLock_AcquireWrite(self) ReadWriteLock_AcquireWrite(self)
176              
177              #define CachedLock_ReleaseRead(self, token) ReadWriteLock_ReleaseRead(self)
178              
179              #define CachedLock_ReleaseWrite(self) ReadWriteLock_ReleaseWrite(self)
180              
181              /*
182              **==============================================================================
183              **
184              ** CondLock -- condition variable
185              **
186              **==============================================================================
187              */
188              
189              #define CONDLOCK_DEFAULT_SPINCOUNT ((size_t)-1)
190 krisbash 1.1 #define CONDLOCK_HIGH_SPINCOUNT    ((size_t)-2)
191              #define CONDLOCK_LOW_SPINCOUNT     ((size_t)-3)
192              
193              int CondLock_Wait(
194                  ptrdiff_t key,
195                  _In_ volatile const ptrdiff_t* destination,
196                  ptrdiff_t comparand,
197                  size_t spinCount);
198              
199              void CondLock_Broadcast(
200                  ptrdiff_t key);
201              
202              void CondLock_BroadcastSpinners(
203                  ptrdiff_t key);
204              
205              void CondLock_Signal(
206                  ptrdiff_t key);
207              
208              PAL_END_EXTERNC
209              
210              #endif /* _pal_lockposix_h */