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