libcfs/include/libcfs/user-lock.h

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2012, 2013, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * libcfs/include/libcfs/user-lock.h
  37  *
  38  * Author: Nikita Danilov <nikita@clusterfs.com>
  39  */
  40
  41 #ifndef __LIBCFS_USER_LOCK_H__
  42 #define __LIBCFS_USER_LOCK_H__
  43
  44 #ifndef __LIBCFS_LIBCFS_H__
  45 #error Do not #include this file directly. #include <libcfs/libcfs.h> instead
  46 #endif
  47
  48 /* Implementations of portable synchronization APIs for liblustre */
  49
  50 /*
  51  * liblustre is single-threaded, so most "synchronization" APIs are trivial.
  52  *
  53  * XXX Liang: There are several branches share lnet with b_hd_newconfig,
  54  * if we define lock APIs at here, there will be conflict with liblustre
  55  * in other branches.
  56  */
  57
  58 #ifndef __KERNEL__
  59
  60 /*
  61  * The userspace implementations of linux/spinlock.h vary; we just
  62  * include our own for all of them
  63  */
  64 #define __LINUX_SPINLOCK_H
  65
  66 /*
  67  * Optional debugging (magic stamping and checking ownership) can be added.
  68  */
  69
  70 /*
  71  * spin_lock
  72  *
  73  * - spin_lock_init(x)
  74  * - spin_lock(x)
  75  * - spin_unlock(x)
  76  * - spin_trylock(x)
  77  * - spin_lock_bh_init(x)
  78  * - spin_lock_bh(x)
  79  * - spin_unlock_bh(x)
  80  *
  81  * - assert_spin_locked(x)
  82  * - spin_lock_irqsave(x, f)
  83  * - spin_unlock_irqrestore(x, f)
  84  *
  85  * No-op implementation.
  86  */
  87 struct spin_lock { int foo; };
  88
  89 typedef struct spin_lock spinlock_t;
  90
  91 #define DEFINE_SPINLOCK(lock)           spinlock_t lock = { }
  92 #define __SPIN_LOCK_UNLOCKED(x)         ((spinlock_t) {})
  93
  94 void spin_lock_init(spinlock_t *lock);
  95 void spin_lock(spinlock_t *lock);
  96 void spin_unlock(spinlock_t *lock);
  97 int  spin_trylock(spinlock_t *lock);
  98 void spin_lock_bh_init(spinlock_t *lock);
  99 void spin_lock_bh(spinlock_t *lock);
 100 void spin_unlock_bh(spinlock_t *lock);
 101
 102 static inline void spin_lock_irqsave(spinlock_t *l, unsigned long f) {}
 103 static inline void spin_unlock_irqrestore(spinlock_t *l, unsigned long f) {}
 104
 105 #define assert_spin_locked(lock)        do { (void)(lock); } while (0)
 106
 107 /*
 108  * Semaphore
 109  *
 110  * - sema_init(x, v)
 111  * - __down(x)
 112  * - __up(x)
 113  */
 114 struct semaphore {
 115         int foo;
 116 };
 117
 118 void sema_init(struct semaphore *s, int val);
 119 void __up(struct semaphore *s);
 120 void __down(struct semaphore *s);
 121 int __down_interruptible(struct semaphore *s);
 122
 123 #define DEFINE_SEMAPHORE(name)      struct semaphore name = { 1 }
 124
 125 #define up(s)                           __up(s)
 126 #define down(s)                 __down(s)
 127 #define down_interruptible(s)           __down_interruptible(s)
 128
 129 static inline int down_trylock(struct semaphore *sem)
 130 {
 131         return 0;
 132 }
 133
 134 /*
 135  * Completion:
 136  *
 137  * - init_completion_module(c)
 138  * - call_wait_handler(t)
 139  * - init_completion(c)
 140  * - complete(c)
 141  * - wait_for_completion(c)
 142  * - wait_for_completion_interruptible(c)
 143  */
 144 #ifdef HAVE_LIBPTHREAD
 145 #include <pthread.h>
 146
 147 /*
 148  * Multi-threaded user space completion APIs
 149  */
 150
 151 struct completion {
 152         int             c_done;
 153         pthread_cond_t  c_cond;
 154         pthread_mutex_t c_mut;
 155 };
 156
 157 #else /* !HAVE_LIBPTHREAD */
 158
 159 struct completion {
 160         unsigned int    done;
 161         wait_queue_head_t       wait;
 162 };
 163 #endif /* HAVE_LIBPTHREAD */
 164
 165 typedef int (*wait_handler_t) (int timeout);
 166 void init_completion_module(wait_handler_t handler);
 167 int  call_wait_handler(int timeout);
 168 void init_completion(struct completion *c);
 169 void fini_completion(struct completion *c);
 170 void complete(struct completion *c);
 171 void wait_for_completion(struct completion *c);
 172 int wait_for_completion_interruptible(struct completion *c);
 173
 174 #define COMPLETION_INITIALIZER(work) \
 175         { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
 176
 177
 178 #define INIT_COMPLETION(x)      ((x).done = 0)
 179
 180
 181 /*
 182  * rw_semaphore:
 183  *
 184  * - init_rwsem(x)
 185  * - down_read(x)
 186  * - down_read_trylock(x)
 187  * - down_write(struct rw_semaphore *s);
 188  * - down_write_trylock(struct rw_semaphore *s);
 189  * - up_read(x)
 190  * - up_write(x)
 191  * - fini_rwsem(x)
 192  */
 193 struct rw_semaphore {
 194         int foo;
 195 };
 196
 197 void init_rwsem(struct rw_semaphore *s);
 198 void down_read(struct rw_semaphore *s);
 199 int down_read_trylock(struct rw_semaphore *s);
 200 void down_write(struct rw_semaphore *s);
 201 void downgrade_write(struct rw_semaphore *s);
 202 int down_write_trylock(struct rw_semaphore *s);
 203 void up_read(struct rw_semaphore *s);
 204 void up_write(struct rw_semaphore *s);
 205 void fini_rwsem(struct rw_semaphore *s);
 206 #define DECLARE_RWSEM(name)  struct rw_semaphore name = { }
 207
 208 /*
 209  * read-write lock : Need to be investigated more!!
 210  * XXX nikita: for now, let rwlock_t to be identical to rw_semaphore
 211  *
 212  * - rwlock_init(x)
 213  * - read_lock(x)
 214  * - read_unlock(x)
 215  * - write_lock(x)
 216  * - write_unlock(x)
 217  * - write_lock_irqsave(x)
 218  * - write_unlock_irqrestore(x)
 219  * - read_lock_irqsave(x)
 220  * - read_unlock_irqrestore(x)
 221  */
 222 #define rwlock_t                struct rw_semaphore
 223 #define DEFINE_RWLOCK(lock)     rwlock_t lock = { }
 224
 225 #define rwlock_init(pl)         init_rwsem(pl)
 226
 227 #define read_lock(l)            down_read(l)
 228 #define read_unlock(l)          up_read(l)
 229 #define write_lock(l)           down_write(l)
 230 #define write_unlock(l)         up_write(l)
 231
 232 static inline void write_lock_irqsave(rwlock_t *l, unsigned long f)
 233 {
 234         write_lock(l);
 235 }
 236
 237 static inline void write_unlock_irqrestore(rwlock_t *l, unsigned long f)
 238 {
 239         write_unlock(l);
 240 }
 241
 242 static inline void read_lock_irqsave(rwlock_t *l, unsigned long f)
 243 {
 244         read_lock(l);
 245 }
 246
 247 static inline void read_unlock_irqrestore(rwlock_t *l, unsigned long f)
 248 {
 249         read_unlock(l);
 250 }
 251
 252 /*
 253  * Atomic for single-threaded user-space
 254  */
 255 typedef struct { volatile int counter; } atomic_t;
 256
 257 #define ATOMIC_INIT(i) { (i) }
 258
 259 #define atomic_read(a) ((a)->counter)
 260 #define atomic_set(a,b) do {(a)->counter = b; } while (0)
 261 #define atomic_dec_and_test(a) ((--((a)->counter)) == 0)
 262 #define atomic_dec_and_lock(a,b) ((--((a)->counter)) == 0)
 263 #define atomic_inc(a)  (((a)->counter)++)
 264 #define atomic_dec(a)  do { (a)->counter--; } while (0)
 265 #define atomic_add(b,a)  do {(a)->counter += b;} while (0)
 266 #define atomic_add_return(n,a) ((a)->counter += n)
 267 #define atomic_inc_return(a) atomic_add_return(1,a)
 268 #define atomic_sub(b,a)  do {(a)->counter -= b;} while (0)
 269 #define atomic_sub_return(n,a) ((a)->counter -= n)
 270 #define atomic_dec_return(a)  atomic_sub_return(1,a)
 271 #define atomic_add_unless(v, a, u) \
 272         ((v)->counter != u ? (v)->counter += a : 0)
 273 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
 274 #define atomic_cmpxchg(v, ov, nv) \
 275         ((v)->counter == ov ? ((v)->counter = nv, ov) : (v)->counter)
 276
 277 typedef struct { volatile long counter; } atomic_long_t;
 278
 279 #define ATOMIC_LONG_INIT(i) { (i) }
 280
 281 #define atomic_long_read(a) ((a)->counter)
 282 #define atomic_long_set(a, b) do {(a)->counter = b; } while (0)
 283 #define atomic_long_dec_and_test(a) ((--((a)->counter)) == 0)
 284 #define atomic_long_dec_and_lock(a, b) ((--((a)->counter)) == 0)
 285 #define atomic_long_inc(a)  (((a)->counter)++)
 286 #define atomic_long_dec(a)  do { (a)->counter--; } while (0)
 287 #define atomic_long_add(b, a)  do {(a)->counter += b; } while (0)
 288 #define atomic_long_add_return(n, a) ((a)->counter += n)
 289 #define atomic_long_inc_return(a) atomic_long_add_return(1, a)
 290 #define atomic_long_sub(b, a)  do {(a)->counter -= b; } while (0)
 291 #define atomic_long_sub_return(n, a) ((a)->counter -= n)
 292 #define atomic_long_dec_return(a)  atomic_long_sub_return(1, a)
 293 #define atomic_long_add_unless(v, a, u) \
 294         ((v)->counter != u ? (v)->counter += a : 0)
 295 #define atomic_long_inc_not_zero(v) atomic_long_add_unless((v), 1, 0)
 296 #define atomic_long_cmpxchg(v, ov, nv) \
 297         ((v)->counter == ov ? ((v)->counter = nv, ov) : (v)->counter)
 298
 299 #ifdef HAVE_LIBPTHREAD
 300 #include <pthread.h>
 301
 302 /*
 303  * Multi-threaded user space atomic APIs
 304  */
 305
 306 typedef struct { volatile int counter; } mt_atomic_t;
 307
 308 int mt_atomic_read(mt_atomic_t *a);
 309 void mt_atomic_set(mt_atomic_t *a, int b);
 310 int mt_atomic_dec_and_test(mt_atomic_t *a);
 311 void mt_atomic_inc(mt_atomic_t *a);
 312 void mt_atomic_dec(mt_atomic_t *a);
 313 void mt_atomic_add(int b, mt_atomic_t *a);
 314 void mt_atomic_sub(int b, mt_atomic_t *a);
 315
 316 #endif /* HAVE_LIBPTHREAD */
 317
 318 /**************************************************************************
 319  *
 320  * Mutex interface.
 321  *
 322  **************************************************************************/
 323 #define mutex semaphore
 324
 325 #define DEFINE_MUTEX(m) DEFINE_SEMAPHORE(m)
 326
 327 static inline void mutex_init(struct mutex *mutex)
 328 {
 329         sema_init(mutex, 1);
 330 }
 331
 332 static inline void mutex_lock(struct mutex *mutex)
 333 {
 334         down(mutex);
 335 }
 336
 337 static inline void mutex_unlock(struct mutex *mutex)
 338 {
 339         up(mutex);
 340 }
 341
 342 static inline int mutex_lock_interruptible(struct mutex *mutex)
 343 {
 344         return down_interruptible(mutex);
 345 }
 346
 347 /**
 348  * Try-lock this mutex.
 349  *
 350  * Note, return values are negation of what is expected from down_trylock() or
 351  * pthread_mutex_trylock().
 352  *
 353  * \retval 1 try-lock succeeded (lock acquired).
 354  * \retval 0 indicates lock contention.
 355  */
 356 static inline int mutex_trylock(struct mutex *mutex)
 357 {
 358         return !down_trylock(mutex);
 359 }
 360
 361 static inline void mutex_destroy(struct mutex *lock)
 362 {
 363 }
 364
 365 /*
 366  * This is for use in assertions _only_, i.e., this function should always
 367  * return 1.
 368  *
 369  * \retval 1 mutex is locked.
 370  *
 371  * \retval 0 mutex is not locked. This should never happen.
 372  */
 373 static inline int mutex_is_locked(struct mutex *lock)
 374 {
 375         return 1;
 376 }
 377
 378
 379 /**************************************************************************
 380  *
 381  * Lockdep "implementation". Also see lustre_compat25.h
 382  *
 383  **************************************************************************/
 384
 385 struct lock_class_key {
 386         int foo;
 387 };
 388
 389 static inline void lockdep_set_class(void *lock, struct lock_class_key *key)
 390 {
 391 }
 392
 393 static inline void lockdep_off(void)
 394 {
 395 }
 396
 397 static inline void lockdep_on(void)
 398 {
 399 }
 400
 401 #define mutex_lock_nested(mutex, subclass) mutex_lock(mutex)
 402 #define spin_lock_nested(lock, subclass) spin_lock(lock)
 403 #define down_read_nested(lock, subclass) down_read(lock)
 404 #define down_write_nested(lock, subclass) down_write(lock)
 405
 406
 407 /* !__KERNEL__ */
 408 #endif
 409
 410 /* __LIBCFS_USER_LOCK_H__ */
 411 #endif
 412 /*
 413  * Local variables:
 414  * c-indentation-style: "K&R"
 415  * c-basic-offset: 8
 416  * tab-width: 8
 417  * fill-column: 80
 418  * scroll-step: 1
 419  * End:
 420  */