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 }
  26
  27 void fio_mutex_remove(struct fio_mutex *mutex)
  28 {
  29         __fio_mutex_remove(mutex);
  30         munmap((void *) mutex, sizeof(*mutex));
  31 }
  32
  33 int cond_init_pshared(pthread_cond_t *cond)
  34 {
  35         pthread_condattr_t cattr;
  36         int ret;
  37
  38         ret = pthread_condattr_init(&cattr);
  39         if (ret) {
  40                 log_err("pthread_condattr_init: %s\n", strerror(ret));
  41                 return ret;
  42         }
  43
  44 #ifdef FIO_HAVE_PSHARED_MUTEX
  45         ret = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
  46         if (ret) {
  47                 log_err("pthread_condattr_setpshared: %s\n", strerror(ret));
  48                 return ret;
  49         }
  50 #endif
  51         ret = pthread_cond_init(cond, &cattr);
  52         if (ret) {
  53                 log_err("pthread_cond_init: %s\n", strerror(ret));
  54                 return ret;
  55         }
  56
  57         return 0;
  58 }
  59
  60 int mutex_init_pshared(pthread_mutex_t *mutex)
  61 {
  62         pthread_mutexattr_t mattr;
  63         int ret;
  64
  65         ret = pthread_mutexattr_init(&mattr);
  66         if (ret) {
  67                 log_err("pthread_mutexattr_init: %s\n", strerror(ret));
  68                 return ret;
  69         }
  70
  71         /*
  72          * Not all platforms support process shared mutexes (FreeBSD)
  73          */
  74 #ifdef FIO_HAVE_PSHARED_MUTEX
  75         ret = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
  76         if (ret) {
  77                 log_err("pthread_mutexattr_setpshared: %s\n", strerror(ret));
  78                 return ret;
  79         }
  80 #endif
  81         ret = pthread_mutex_init(mutex, &mattr);
  82         if (ret) {
  83                 log_err("pthread_mutex_init: %s\n", strerror(ret));
  84                 return ret;
  85         }
  86
  87         return 0;
  88 }
  89
  90 int mutex_cond_init_pshared(pthread_mutex_t *mutex, pthread_cond_t *cond)
  91 {
  92         int ret;
  93
  94         ret = mutex_init_pshared(mutex);
  95         if (ret)
  96                 return ret;
  97
  98         ret = cond_init_pshared(cond);
  99         if (ret)
 100                 return ret;
 101
 102         return 0;
 103 }
 104
 105 int __fio_mutex_init(struct fio_mutex *mutex, int value)
 106 {
 107         int ret;
 108
 109         mutex->value = value;
 110         mutex->magic = FIO_MUTEX_MAGIC;
 111
 112         ret = mutex_cond_init_pshared(&mutex->lock, &mutex->cond);
 113         if (ret)
 114                 return ret;
 115
 116         return 0;
 117 }
 118
 119 struct fio_mutex *fio_mutex_init(int value)
 120 {
 121         struct fio_mutex *mutex = NULL;
 122
 123         mutex = (void *) mmap(NULL, sizeof(struct fio_mutex),
 124                                 PROT_READ | PROT_WRITE,
 125                                 OS_MAP_ANON | MAP_SHARED, -1, 0);
 126         if (mutex == MAP_FAILED) {
 127                 perror("mmap mutex");
 128                 return NULL;
 129         }
 130
 131         if (!__fio_mutex_init(mutex, value))
 132                 return mutex;
 133
 134         fio_mutex_remove(mutex);
 135         return NULL;
 136 }
 137
 138 static bool mutex_timed_out(struct timeval *t, unsigned int msecs)
 139 {
 140         struct timeval now;
 141
 142         gettimeofday(&now, NULL);
 143         return mtime_since(t, &now) >= msecs;
 144 }
 145
 146 int fio_mutex_down_timeout(struct fio_mutex *mutex, unsigned int msecs)
 147 {
 148         struct timeval tv_s;
 149         struct timespec t;
 150         int ret = 0;
 151
 152         assert(mutex->magic == FIO_MUTEX_MAGIC);
 153
 154         gettimeofday(&tv_s, NULL);
 155         t.tv_sec = tv_s.tv_sec;
 156         t.tv_nsec = tv_s.tv_usec * 1000;
 157
 158         t.tv_sec += msecs / 1000;
 159         t.tv_nsec += ((msecs * 1000000) % 1000000000);
 160         if (t.tv_nsec >= 1000000000) {
 161                 t.tv_nsec -= 1000000000;
 162                 t.tv_sec++;
 163         }
 164
 165         pthread_mutex_lock(&mutex->lock);
 166
 167         mutex->waiters++;
 168         while (!mutex->value && !ret) {
 169                 /*
 170                  * Some platforms (FreeBSD 9?) seems to return timed out
 171                  * way too early, double check.
 172                  */
 173                 ret = pthread_cond_timedwait(&mutex->cond, &mutex->lock, &t);
 174                 if (ret == ETIMEDOUT && !mutex_timed_out(&tv_s, msecs))
 175                         ret = 0;
 176         }
 177         mutex->waiters--;
 178
 179         if (!ret) {
 180                 mutex->value--;
 181                 pthread_mutex_unlock(&mutex->lock);
 182                 return 0;
 183         }
 184
 185         pthread_mutex_unlock(&mutex->lock);
 186         return ret;
 187 }
 188
 189 bool fio_mutex_down_trylock(struct fio_mutex *mutex)
 190 {
 191         bool ret = true;
 192
 193         assert(mutex->magic == FIO_MUTEX_MAGIC);
 194
 195         pthread_mutex_lock(&mutex->lock);
 196         if (mutex->value) {
 197                 mutex->value--;
 198                 ret = false;
 199         }
 200         pthread_mutex_unlock(&mutex->lock);
 201
 202         return ret;
 203 }
 204
 205 void fio_mutex_down(struct fio_mutex *mutex)
 206 {
 207         assert(mutex->magic == FIO_MUTEX_MAGIC);
 208
 209         pthread_mutex_lock(&mutex->lock);
 210
 211         while (!mutex->value) {
 212                 mutex->waiters++;
 213                 pthread_cond_wait(&mutex->cond, &mutex->lock);
 214                 mutex->waiters--;
 215         }
 216
 217         mutex->value--;
 218         pthread_mutex_unlock(&mutex->lock);
 219 }
 220
 221 void fio_mutex_up(struct fio_mutex *mutex)
 222 {
 223         int do_wake = 0;
 224
 225         assert(mutex->magic == FIO_MUTEX_MAGIC);
 226
 227         pthread_mutex_lock(&mutex->lock);
 228         read_barrier();
 229         if (!mutex->value && mutex->waiters)
 230                 do_wake = 1;
 231         mutex->value++;
 232         pthread_mutex_unlock(&mutex->lock);
 233
 234         if (do_wake)
 235                 pthread_cond_signal(&mutex->cond);
 236 }
 237
 238 void fio_rwlock_write(struct fio_rwlock *lock)
 239 {
 240         assert(lock->magic == FIO_RWLOCK_MAGIC);
 241         pthread_rwlock_wrlock(&lock->lock);
 242 }
 243
 244 void fio_rwlock_read(struct fio_rwlock *lock)
 245 {
 246         assert(lock->magic == FIO_RWLOCK_MAGIC);
 247         pthread_rwlock_rdlock(&lock->lock);
 248 }
 249
 250 void fio_rwlock_unlock(struct fio_rwlock *lock)
 251 {
 252         assert(lock->magic == FIO_RWLOCK_MAGIC);
 253         pthread_rwlock_unlock(&lock->lock);
 254 }
 255
 256 void fio_rwlock_remove(struct fio_rwlock *lock)
 257 {
 258         assert(lock->magic == FIO_RWLOCK_MAGIC);
 259         munmap((void *) lock, sizeof(*lock));
 260 }
 261
 262 struct fio_rwlock *fio_rwlock_init(void)
 263 {
 264         struct fio_rwlock *lock;
 265         pthread_rwlockattr_t attr;
 266         int ret;
 267
 268         lock = (void *) mmap(NULL, sizeof(struct fio_rwlock),
 269                                 PROT_READ | PROT_WRITE,
 270                                 OS_MAP_ANON | MAP_SHARED, -1, 0);
 271         if (lock == MAP_FAILED) {
 272                 perror("mmap rwlock");
 273                 lock = NULL;
 274                 goto err;
 275         }
 276
 277         lock->magic = FIO_RWLOCK_MAGIC;
 278
 279         ret = pthread_rwlockattr_init(&attr);
 280         if (ret) {
 281                 log_err("pthread_rwlockattr_init: %s\n", strerror(ret));
 282                 goto err;
 283         }
 284 #ifdef FIO_HAVE_PSHARED_MUTEX
 285         ret = pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
 286         if (ret) {
 287                 log_err("pthread_rwlockattr_setpshared: %s\n", strerror(ret));
 288                 goto destroy_attr;
 289         }
 290
 291         ret = pthread_rwlock_init(&lock->lock, &attr);
 292 #else
 293         ret = pthread_rwlock_init(&lock->lock, NULL);
 294 #endif
 295
 296         if (ret) {
 297                 log_err("pthread_rwlock_init: %s\n", strerror(ret));
 298                 goto destroy_attr;
 299         }
 300
 301         pthread_rwlockattr_destroy(&attr);
 302
 303         return lock;
 304 destroy_attr:
 305         pthread_rwlockattr_destroy(&attr);
 306 err:
 307         if (lock)
 308                 fio_rwlock_remove(lock);
 309         return NULL;
 310 }