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