mutex.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <unistd.h>
   4 #include <stdlib.h>
   5 #include <fcntl.h>
   6 #include <time.h>
   7 #include <errno.h>
   8 #include <pthread.h>
   9 #include <sys/mman.h>
  10 #include <assert.h>
  11
  12 #include "fio.h"
  13 #include "log.h"
  14 #include "mutex.h"
  15 #include "arch/arch.h"
  16 #include "os/os.h"
  17 #include "helpers.h"
  18 #include "fio_time.h"
  19 #include "gettime.h"
  20
  21 void fio_mutex_remove(struct fio_mutex *mutex)
  22 {
  23         assert(mutex->magic == FIO_MUTEX_MAGIC);
  24         pthread_cond_destroy(&mutex->cond);
  25         munmap((void *) mutex, sizeof(*mutex));
  26 }
  27
  28 int __fio_mutex_init(struct fio_mutex *mutex, int value)
  29 {
  30         pthread_mutexattr_t attr;
  31         pthread_condattr_t cond;
  32         int ret;
  33
  34         mutex->value = value;
  35         mutex->magic = FIO_MUTEX_MAGIC;
  36
  37         ret = pthread_mutexattr_init(&attr);
  38         if (ret) {
  39                 log_err("pthread_mutexattr_init: %s\n", strerror(ret));
  40                 return ret;
  41         }
  42
  43         /*
  44          * Not all platforms support process shared mutexes (FreeBSD)
  45          */
  46 #ifdef FIO_HAVE_PSHARED_MUTEX
  47         ret = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
  48         if (ret) {
  49                 log_err("pthread_mutexattr_setpshared: %s\n", strerror(ret));
  50                 return ret;
  51         }
  52 #endif
  53
  54         pthread_condattr_init(&cond);
  55 #ifdef FIO_HAVE_PSHARED_MUTEX
  56         pthread_condattr_setpshared(&cond, PTHREAD_PROCESS_SHARED);
  57 #endif
  58         pthread_cond_init(&mutex->cond, &cond);
  59
  60         ret = pthread_mutex_init(&mutex->lock, &attr);
  61         if (ret) {
  62                 log_err("pthread_mutex_init: %s\n", strerror(ret));
  63                 return ret;
  64         }
  65
  66         pthread_condattr_destroy(&cond);
  67         pthread_mutexattr_destroy(&attr);
  68         return 0;
  69 }
  70
  71 struct fio_mutex *fio_mutex_init(int value)
  72 {
  73         struct fio_mutex *mutex = NULL;
  74
  75         mutex = (void *) mmap(NULL, sizeof(struct fio_mutex),
  76                                 PROT_READ | PROT_WRITE,
  77                                 OS_MAP_ANON | MAP_SHARED, -1, 0);
  78         if (mutex == MAP_FAILED) {
  79                 perror("mmap mutex");
  80                 return NULL;
  81         }
  82
  83         if (!__fio_mutex_init(mutex, value))
  84                 return mutex;
  85
  86         fio_mutex_remove(mutex);
  87         return NULL;
  88 }
  89
  90 static int mutex_timed_out(struct timeval *t, unsigned int seconds)
  91 {
  92         return mtime_since_now(t) >= seconds * 1000;
  93 }
  94
  95 int fio_mutex_down_timeout(struct fio_mutex *mutex, unsigned int seconds)
  96 {
  97         struct timeval tv_s;
  98         struct timespec t;
  99         int ret = 0;
 100
 101         assert(mutex->magic == FIO_MUTEX_MAGIC);
 102
 103         gettimeofday(&tv_s, NULL);
 104         t.tv_sec = tv_s.tv_sec + seconds;
 105         t.tv_nsec = tv_s.tv_usec * 1000;
 106
 107         pthread_mutex_lock(&mutex->lock);
 108
 109         while (!mutex->value && !ret) {
 110                 mutex->waiters++;
 111
 112                 /*
 113                  * Some platforms (FreeBSD 9?) seems to return timed out
 114                  * way too early, double check.
 115                  */
 116                 ret = pthread_cond_timedwait(&mutex->cond, &mutex->lock, &t);
 117                 if (ret == ETIMEDOUT && !mutex_timed_out(&tv_s, seconds))
 118                         ret = 0;
 119
 120                 mutex->waiters--;
 121         }
 122
 123         if (!ret) {
 124                 mutex->value--;
 125                 pthread_mutex_unlock(&mutex->lock);
 126         }
 127
 128         return ret;
 129 }
 130
 131 int fio_mutex_down_trylock(struct fio_mutex *mutex)
 132 {
 133         int ret = 1;
 134
 135         assert(mutex->magic == FIO_MUTEX_MAGIC);
 136
 137         pthread_mutex_lock(&mutex->lock);
 138         if (mutex->value) {
 139                 mutex->value--;
 140                 ret = 0;
 141         }
 142         pthread_mutex_unlock(&mutex->lock);
 143
 144         return ret;
 145 }
 146
 147 void fio_mutex_down(struct fio_mutex *mutex)
 148 {
 149         assert(mutex->magic == FIO_MUTEX_MAGIC);
 150
 151         pthread_mutex_lock(&mutex->lock);
 152
 153         while (!mutex->value) {
 154                 mutex->waiters++;
 155                 pthread_cond_wait(&mutex->cond, &mutex->lock);
 156                 mutex->waiters--;
 157         }
 158
 159         mutex->value--;
 160         pthread_mutex_unlock(&mutex->lock);
 161 }
 162
 163 void fio_mutex_up(struct fio_mutex *mutex)
 164 {
 165         assert(mutex->magic == FIO_MUTEX_MAGIC);
 166
 167         pthread_mutex_lock(&mutex->lock);
 168         read_barrier();
 169         if (!mutex->value && mutex->waiters)
 170                 pthread_cond_signal(&mutex->cond);
 171         mutex->value++;
 172         pthread_mutex_unlock(&mutex->lock);
 173 }
 174
 175 void fio_rwlock_write(struct fio_rwlock *lock)
 176 {
 177         assert(lock->magic == FIO_RWLOCK_MAGIC);
 178         pthread_rwlock_wrlock(&lock->lock);
 179 }
 180
 181 void fio_rwlock_read(struct fio_rwlock *lock)
 182 {
 183         assert(lock->magic == FIO_RWLOCK_MAGIC);
 184         pthread_rwlock_rdlock(&lock->lock);
 185 }
 186
 187 void fio_rwlock_unlock(struct fio_rwlock *lock)
 188 {
 189         assert(lock->magic == FIO_RWLOCK_MAGIC);
 190         pthread_rwlock_unlock(&lock->lock);
 191 }
 192
 193 void fio_rwlock_remove(struct fio_rwlock *lock)
 194 {
 195         assert(lock->magic == FIO_RWLOCK_MAGIC);
 196         munmap((void *) lock, sizeof(*lock));
 197 }
 198
 199 struct fio_rwlock *fio_rwlock_init(void)
 200 {
 201         struct fio_rwlock *lock;
 202         pthread_rwlockattr_t attr;
 203         int ret;
 204
 205         lock = (void *) mmap(NULL, sizeof(struct fio_rwlock),
 206                                 PROT_READ | PROT_WRITE,
 207                                 OS_MAP_ANON | MAP_SHARED, -1, 0);
 208         if (lock == MAP_FAILED) {
 209                 perror("mmap rwlock");
 210                 lock = NULL;
 211                 goto err;
 212         }
 213
 214         lock->magic = FIO_RWLOCK_MAGIC;
 215
 216         ret = pthread_rwlockattr_init(&attr);
 217         if (ret) {
 218                 log_err("pthread_rwlockattr_init: %s\n", strerror(ret));
 219                 goto err;
 220         }
 221 #ifdef FIO_HAVE_PSHARED_MUTEX
 222         ret = pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
 223         if (ret) {
 224                 log_err("pthread_rwlockattr_setpshared: %s\n", strerror(ret));
 225                 goto destroy_attr;
 226         }
 227
 228         ret = pthread_rwlock_init(&lock->lock, &attr);
 229 #else
 230         ret = pthread_rwlock_init(&lock->lock, NULL);
 231 #endif
 232
 233         if (ret) {
 234                 log_err("pthread_rwlock_init: %s\n", strerror(ret));
 235                 goto destroy_attr;
 236         }
 237
 238         pthread_rwlockattr_destroy(&attr);
 239
 240         return lock;
 241 destroy_attr:
 242         pthread_rwlockattr_destroy(&attr);
 243 err:
 244         if (lock)
 245                 fio_rwlock_remove(lock);
 246         return NULL;
 247 }