libcfs/include/libcfs/user-lock.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  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  *
  78  * - spin_lock_irqsave(x, f)
  79  * - spin_unlock_irqrestore(x, f)
  80  *
  81  * No-op implementation.
  82  */
  83 struct spin_lock {int foo;};
  84
  85 typedef struct spin_lock spinlock_t;
  86
  87 #define SPIN_LOCK_UNLOCKED (spinlock_t) { }
  88 #define LASSERT_SPIN_LOCKED(lock) do {(void)sizeof(lock);} while(0)
  89 #define LINVRNT_SPIN_LOCKED(lock) do {(void)sizeof(lock);} while(0)
  90 #define LASSERT_SEM_LOCKED(sem) do {(void)sizeof(sem);} while(0)
  91
  92 void spin_lock_init(spinlock_t *lock);
  93 void spin_lock(spinlock_t *lock);
  94 void spin_unlock(spinlock_t *lock);
  95 int spin_trylock(spinlock_t *lock);
  96 void spin_lock_bh_init(spinlock_t *lock);
  97 void spin_lock_bh(spinlock_t *lock);
  98 void spin_unlock_bh(spinlock_t *lock);
  99
 100 static inline int spin_is_locked(spinlock_t *l) {return 1;}
 101 static inline void spin_lock_irqsave(spinlock_t *l, unsigned long f){}
 102 static inline void spin_unlock_irqrestore(spinlock_t *l, unsigned long f){}
 103
 104 /*
 105  * Semaphore
 106  *
 107  * - sema_init(x, v)
 108  * - __down(x)
 109  * - __up(x)
 110  */
 111 typedef struct semaphore {
 112     int foo;
 113 } mutex_t;
 114
 115 void sema_init(struct semaphore *s, int val);
 116 void __down(struct semaphore *s);
 117 void __up(struct semaphore *s);
 118
 119 /*
 120  * Mutex:
 121  *
 122  * - init_mutex(x)
 123  * - init_mutex_locked(x)
 124  * - mutex_up(x)
 125  * - mutex_down(x)
 126  */
 127 #define DECLARE_MUTEX(name)     \
 128         struct semaphore name = { 1 }
 129
 130 #define mutex_up(s)                     __up(s)
 131 #define up(s)                           mutex_up(s)
 132 #define mutex_down(s)                   __down(s)
 133 #define down(s)                         mutex_down(s)
 134
 135 #define init_MUTEX(x)                   sema_init(x, 1)
 136 #define init_MUTEX_LOCKED(x)            sema_init(x, 0)
 137 #define init_mutex(s)                   init_MUTEX(s)
 138
 139 /*
 140  * Completion:
 141  *
 142  * - init_completion(c)
 143  * - complete(c)
 144  * - wait_for_completion(c)
 145  */
 146 struct completion {
 147         unsigned int done;
 148         cfs_waitq_t wait;
 149 };
 150 typedef int (*cfs_wait_handler_t) (int timeout);
 151 void init_completion_module(cfs_wait_handler_t handler);
 152 void init_completion(struct completion *c);
 153 void init_completion_module(cfs_wait_handler_t handler);
 154 void complete(struct completion *c);
 155 void wait_for_completion(struct completion *c);
 156 int wait_for_completion_interruptible(struct completion *c);
 157
 158 #define COMPLETION_INITIALIZER(work) \
 159         { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
 160
 161 #define DECLARE_COMPLETION(work) \
 162         struct completion work = COMPLETION_INITIALIZER(work)
 163
 164 #define INIT_COMPLETION(x)      ((x).done = 0)
 165
 166
 167 /*
 168  * rw_semaphore:
 169  *
 170  * - init_rwsem(x)
 171  * - down_read(x)
 172  * - up_read(x)
 173  * - down_write(x)
 174  * - up_write(x)
 175  */
 176 struct rw_semaphore {
 177         int foo;
 178 };
 179
 180 void init_rwsem(struct rw_semaphore *s);
 181 void down_read(struct rw_semaphore *s);
 182 int down_read_trylock(struct rw_semaphore *s);
 183 void down_write(struct rw_semaphore *s);
 184 int down_write_trylock(struct rw_semaphore *s);
 185 void up_read(struct rw_semaphore *s);
 186 void up_write(struct rw_semaphore *s);
 187 void fini_rwsem(struct rw_semaphore *s);
 188
 189 /*
 190  * read-write lock : Need to be investigated more!!
 191  * XXX nikita: for now, let rwlock_t to be identical to rw_semaphore
 192  *
 193  * - DECLARE_RWLOCK(l)
 194  * - rwlock_init(x)
 195  * - read_lock(x)
 196  * - read_unlock(x)
 197  * - write_lock(x)
 198  * - write_unlock(x)
 199  */
 200 typedef struct rw_semaphore rwlock_t;
 201 #define RW_LOCK_UNLOCKED        (rwlock_t) { }
 202
 203 #define rwlock_init(pl)         init_rwsem(pl)
 204
 205 #define read_lock(l)            down_read(l)
 206 #define read_unlock(l)          up_read(l)
 207 #define write_lock(l)           down_write(l)
 208 #define write_unlock(l)         up_write(l)
 209
 210 static inline void
 211 write_lock_irqsave(rwlock_t *l, unsigned long f) { write_lock(l); }
 212 static inline void
 213 write_unlock_irqrestore(rwlock_t *l, unsigned long f) { write_unlock(l); }
 214
 215 static inline void
 216 read_lock_irqsave(rwlock_t *l, unsigned long f) { read_lock(l); }
 217 static inline void
 218 read_unlock_irqrestore(rwlock_t *l, unsigned long f) { read_unlock(l); }
 219
 220 /*
 221  * Atomic for user-space
 222  * Copied from liblustre
 223  */
 224 typedef struct { volatile int counter; } atomic_t;
 225
 226 #define ATOMIC_INIT(i) { (i) }
 227
 228 #define atomic_read(a) ((a)->counter)
 229 #define atomic_set(a,b) do {(a)->counter = b; } while (0)
 230 #define atomic_dec_and_test(a) ((--((a)->counter)) == 0)
 231 #define atomic_dec_and_lock(a,b) ((--((a)->counter)) == 0)
 232 #define atomic_inc(a)  (((a)->counter)++)
 233 #define atomic_dec(a)  do { (a)->counter--; } while (0)
 234 #define atomic_add(b,a)  do {(a)->counter += b;} while (0)
 235 #define atomic_add_return(n,a) ((a)->counter += n)
 236 #define atomic_inc_return(a) atomic_add_return(1,a)
 237 #define atomic_sub(b,a)  do {(a)->counter -= b;} while (0)
 238 #define atomic_sub_return(n,a) ((a)->counter -= n)
 239 #define atomic_dec_return(a)  atomic_sub_return(1,a)
 240
 241
 242 #ifdef HAVE_LIBPTHREAD
 243 #include <pthread.h>
 244
 245 /*
 246  * Completion
 247  */
 248
 249 struct cfs_completion {
 250         int c_done;
 251         pthread_cond_t c_cond;
 252         pthread_mutex_t c_mut;
 253 };
 254
 255 void cfs_init_completion(struct cfs_completion *c);
 256 void cfs_fini_completion(struct cfs_completion *c);
 257 void cfs_complete(struct cfs_completion *c);
 258 void cfs_wait_for_completion(struct cfs_completion *c);
 259
 260 /*
 261  * atomic.h
 262  */
 263
 264 typedef struct { volatile int counter; } cfs_atomic_t;
 265
 266 int cfs_atomic_read(cfs_atomic_t *a);
 267 void cfs_atomic_set(cfs_atomic_t *a, int b);
 268 int cfs_atomic_dec_and_test(cfs_atomic_t *a);
 269 void cfs_atomic_inc(cfs_atomic_t *a);
 270 void cfs_atomic_dec(cfs_atomic_t *a);
 271 void cfs_atomic_add(int b, cfs_atomic_t *a);
 272 void cfs_atomic_sub(int b, cfs_atomic_t *a);
 273
 274 #endif /* HAVE_LIBPTHREAD */
 275
 276 /**************************************************************************
 277  *
 278  * Mutex interface.
 279  *
 280  **************************************************************************/
 281
 282 struct mutex {
 283         struct semaphore m_sem;
 284 };
 285
 286 #define DEFINE_MUTEX(m) struct mutex m
 287
 288 static inline void mutex_init(struct mutex *mutex)
 289 {
 290         init_mutex(&mutex->m_sem);
 291 }
 292
 293 static inline void mutex_lock(struct mutex *mutex)
 294 {
 295         mutex_down(&mutex->m_sem);
 296 }
 297
 298 static inline void mutex_unlock(struct mutex *mutex)
 299 {
 300         mutex_up(&mutex->m_sem);
 301 }
 302
 303 /**
 304  * Try-lock this mutex.
 305  *
 306  *
 307  * \retval 0 try-lock succeeded (lock acquired).
 308  * \retval errno indicates lock contention.
 309  */
 310 static inline int mutex_down_trylock(struct mutex *mutex)
 311 {
 312         return 0;
 313 }
 314
 315 /**
 316  * Try-lock this mutex.
 317  *
 318  * Note, return values are negation of what is expected from down_trylock() or
 319  * pthread_mutex_trylock().
 320  *
 321  * \retval 1 try-lock succeeded (lock acquired).
 322  * \retval 0 indicates lock contention.
 323  */
 324 static inline int mutex_trylock(struct mutex *mutex)
 325 {
 326         return !mutex_down_trylock(mutex);
 327 }
 328
 329 static inline void mutex_destroy(struct mutex *lock)
 330 {
 331 }
 332
 333 /*
 334  * This is for use in assertions _only_, i.e., this function should always
 335  * return 1.
 336  *
 337  * \retval 1 mutex is locked.
 338  *
 339  * \retval 0 mutex is not locked. This should never happen.
 340  */
 341 static inline int mutex_is_locked(struct mutex *lock)
 342 {
 343         return 1;
 344 }
 345
 346
 347 /**************************************************************************
 348  *
 349  * Lockdep "implementation". Also see lustre_compat25.h
 350  *
 351  **************************************************************************/
 352
 353 struct lock_class_key {
 354         int foo;
 355 };
 356
 357 static inline void lockdep_set_class(void *lock, struct lock_class_key *key)
 358 {
 359 }
 360
 361 static inline void lockdep_off(void)
 362 {
 363 }
 364
 365 static inline void lockdep_on(void)
 366 {
 367 }
 368
 369 /* This has to be a macro, so that can be undefined in kernels that do not
 370  * support lockdep. */
 371 #define mutex_lock_nested(mutex, subclass) mutex_lock(mutex)
 372 #define spin_lock_nested(lock, subclass) spin_lock(lock)
 373 #define down_read_nested(lock, subclass) down_read(lock)
 374 #define down_write_nested(lock, subclass) down_write(lock)
 375
 376
 377 /* !__KERNEL__ */
 378 #endif
 379
 380 /* __LIBCFS_USER_LOCK_H__ */
 381 #endif
 382 /*
 383  * Local variables:
 384  * c-indentation-style: "K&R"
 385  * c-basic-offset: 8
 386  * tab-width: 8
 387  * fill-column: 80
 388  * scroll-step: 1
 389  * End:
 390  */