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 t;
 160         int ret = 0;
 161
 162         assert(mutex->magic == FIO_MUTEX_MAGIC);
 163
 164         gettimeofday(&tv_s, NULL);
 165         t.tv_sec = tv_s.tv_sec;
 166         t.tv_nsec = tv_s.tv_usec * 1000;
 167
 168         t.tv_sec += msecs / 1000;
 169         t.tv_nsec += ((msecs * 1000000ULL) % 1000000000);
 170         if (t.tv_nsec >= 1000000000) {
 171                 t.tv_nsec -= 1000000000;
 172                 t.tv_sec++;
 173         }
 174
 175         pthread_mutex_lock(&mutex->lock);
 176
 177         mutex->waiters++;
 178         while (!mutex->value && !ret) {
 179                 /*
 180                  * Some platforms (FreeBSD 9?) seems to return timed out
 181                  * way too early, double check.
 182                  */
 183                 ret = pthread_cond_timedwait(&mutex->cond, &mutex->lock, &t);
 184                 if (ret == ETIMEDOUT && !mutex_timed_out(&t, msecs))
 185                         ret = 0;
 186         }
 187         mutex->waiters--;
 188
 189         if (!ret) {
 190                 mutex->value--;
 191                 pthread_mutex_unlock(&mutex->lock);
 192                 return 0;
 193         }
 194
 195         pthread_mutex_unlock(&mutex->lock);
 196         return ret;
 197 }
 198
 199 bool fio_mutex_down_trylock(struct fio_mutex *mutex)
 200 {
 201         bool ret = true;
 202
 203         assert(mutex->magic == FIO_MUTEX_MAGIC);
 204
 205         pthread_mutex_lock(&mutex->lock);
 206         if (mutex->value) {
 207                 mutex->value--;
 208                 ret = false;
 209         }
 210         pthread_mutex_unlock(&mutex->lock);
 211
 212         return ret;
 213 }
 214
 215 void fio_mutex_down(struct fio_mutex *mutex)
 216 {
 217         assert(mutex->magic == FIO_MUTEX_MAGIC);
 218
 219         pthread_mutex_lock(&mutex->lock);
 220
 221         while (!mutex->value) {
 222                 mutex->waiters++;
 223                 pthread_cond_wait(&mutex->cond, &mutex->lock);
 224                 mutex->waiters--;
 225         }
 226
 227         mutex->value--;
 228         pthread_mutex_unlock(&mutex->lock);
 229 }
 230
 231 void fio_mutex_up(struct fio_mutex *mutex)
 232 {
 233         int do_wake = 0;
 234
 235         assert(mutex->magic == FIO_MUTEX_MAGIC);
 236
 237         pthread_mutex_lock(&mutex->lock);
 238         read_barrier();
 239         if (!mutex->value && mutex->waiters)
 240                 do_wake = 1;
 241         mutex->value++;
 242         pthread_mutex_unlock(&mutex->lock);
 243
 244         if (do_wake)
 245                 pthread_cond_signal(&mutex->cond);
 246 }
 247
 248 void fio_rwlock_write(struct fio_rwlock *lock)
 249 {
 250         assert(lock->magic == FIO_RWLOCK_MAGIC);
 251         pthread_rwlock_wrlock(&lock->lock);
 252 }
 253
 254 void fio_rwlock_read(struct fio_rwlock *lock)
 255 {
 256         assert(lock->magic == FIO_RWLOCK_MAGIC);
 257         pthread_rwlock_rdlock(&lock->lock);
 258 }
 259
 260 void fio_rwlock_unlock(struct fio_rwlock *lock)
 261 {
 262         assert(lock->magic == FIO_RWLOCK_MAGIC);
 263         pthread_rwlock_unlock(&lock->lock);
 264 }
 265
 266 void fio_rwlock_remove(struct fio_rwlock *lock)
 267 {
 268         assert(lock->magic == FIO_RWLOCK_MAGIC);
 269         munmap((void *) lock, sizeof(*lock));
 270 }
 271
 272 struct fio_rwlock *fio_rwlock_init(void)
 273 {
 274         struct fio_rwlock *lock;
 275         pthread_rwlockattr_t attr;
 276         int ret;
 277
 278         lock = (void *) mmap(NULL, sizeof(struct fio_rwlock),
 279                                 PROT_READ | PROT_WRITE,
 280                                 OS_MAP_ANON | MAP_SHARED, -1, 0);
 281         if (lock == MAP_FAILED) {
 282                 perror("mmap rwlock");
 283                 lock = NULL;
 284                 goto err;
 285         }
 286
 287         lock->magic = FIO_RWLOCK_MAGIC;
 288
 289         ret = pthread_rwlockattr_init(&attr);
 290         if (ret) {
 291                 log_err("pthread_rwlockattr_init: %s\n", strerror(ret));
 292                 goto err;
 293         }
 294 #ifdef CONFIG_PSHARED
 295         ret = pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
 296         if (ret) {
 297                 log_err("pthread_rwlockattr_setpshared: %s\n", strerror(ret));
 298                 goto destroy_attr;
 299         }
 300
 301         ret = pthread_rwlock_init(&lock->lock, &attr);
 302 #else
 303         ret = pthread_rwlock_init(&lock->lock, NULL);
 304 #endif
 305
 306         if (ret) {
 307                 log_err("pthread_rwlock_init: %s\n", strerror(ret));
 308                 goto destroy_attr;
 309         }
 310
 311         pthread_rwlockattr_destroy(&attr);
 312
 313         return lock;
 314 destroy_attr:
 315         pthread_rwlockattr_destroy(&attr);
 316 err:
 317         if (lock)
 318                 fio_rwlock_remove(lock);
 319         return NULL;
 320 }