Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
1: #ifndef __LINUX_RWLOCK_H 2: #define __LINUX_RWLOCK_H 3: 4: #ifndef __LINUX_SPINLOCK_H 5: # error "please don't include this file directly" 6: #endif 7: 8: /* 9: * rwlock related methods 10: * 11: * split out from spinlock.h 12: * 13: * portions Copyright 2005, Red Hat, Inc., Ingo Molnar 14: * Released under the General Public License (GPL). 15: */ 16: 17: #ifdef CONFIG_DEBUG_SPINLOCK 18: extern void __rwlock_init(rwlock_t *lock, const char *name, 19: struct lock_class_key *key); 20: # define rwlock_init(lock) \ 21: do { \ 22: static struct lock_class_key __key; \ 23: \ 24: __rwlock_init((lock), #lock, &__key); \ 25: } while (0) 26: #else 27: # define rwlock_init(lock) \ 28: do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0) 29: #endif 30: 31: #ifdef CONFIG_DEBUG_SPINLOCK 32: extern void do_raw_read_lock(rwlock_t *lock) __acquires(lock); 33: #define do_raw_read_lock_flags(lock, flags) do_raw_read_lock(lock) 34: extern int do_raw_read_trylock(rwlock_t *lock); 35: extern void do_raw_read_unlock(rwlock_t *lock) __releases(lock); 36: extern void do_raw_write_lock(rwlock_t *lock) __acquires(lock); 37: #define do_raw_write_lock_flags(lock, flags) do_raw_write_lock(lock) 38: extern int do_raw_write_trylock(rwlock_t *lock); 39: extern void do_raw_write_unlock(rwlock_t *lock) __releases(lock); 40: #else 41: # define do_raw_read_lock(rwlock) do {__acquire(lock); arch_read_lock(&(rwlock)->raw_lock); } while (0) 42: # define do_raw_read_lock_flags(lock, flags) \ 43: do {__acquire(lock); arch_read_lock_flags(&(lock)->raw_lock, *(flags)); } while (0) 44: # define do_raw_read_trylock(rwlock) arch_read_trylock(&(rwlock)->raw_lock) 45: # define do_raw_read_unlock(rwlock) do {arch_read_unlock(&(rwlock)->raw_lock); __release(lock); } while (0) 46: # define do_raw_write_lock(rwlock) do {__acquire(lock); arch_write_lock(&(rwlock)->raw_lock); } while (0) 47: # define do_raw_write_lock_flags(lock, flags) \ 48: do {__acquire(lock); arch_write_lock_flags(&(lock)->raw_lock, *(flags)); } while (0) 49: # define do_raw_write_trylock(rwlock) arch_write_trylock(&(rwlock)->raw_lock) 50: # define do_raw_write_unlock(rwlock) do {arch_write_unlock(&(rwlock)->raw_lock); __release(lock); } while (0) 51: #endif 52: 53: #define read_can_lock(rwlock) arch_read_can_lock(&(rwlock)->raw_lock) 54: #define write_can_lock(rwlock) arch_write_can_lock(&(rwlock)->raw_lock) 55: 56: /* 57: * Define the various rw_lock methods. Note we define these 58: * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various 59: * methods are defined as nops in the case they are not required. 60: */ 61: #define read_trylock(lock) __cond_lock(lock, _raw_read_trylock(lock)) 62: #define write_trylock(lock) __cond_lock(lock, _raw_write_trylock(lock)) 63: 64: #define write_lock(lock) _raw_write_lock(lock) 65: #define read_lock(lock) _raw_read_lock(lock) 66: 67: #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) 68: 69: #define read_lock_irqsave(lock, flags) \ 70: do { \ 71: typecheck(unsigned long, flags); \ 72: flags = _raw_read_lock_irqsave(lock); \ 73: } while (0) 74: #define write_lock_irqsave(lock, flags) \ 75: do { \ 76: typecheck(unsigned long, flags); \ 77: flags = _raw_write_lock_irqsave(lock); \ 78: } while (0) 79: 80: #else 81: 82: #define read_lock_irqsave(lock, flags) \ 83: do { \ 84: typecheck(unsigned long, flags); \ 85: _raw_read_lock_irqsave(lock, flags); \ 86: } while (0) 87: #define write_lock_irqsave(lock, flags) \ 88: do { \ 89: typecheck(unsigned long, flags); \ 90: _raw_write_lock_irqsave(lock, flags); \ 91: } while (0) 92: 93: #endif 94: 95: #define read_lock_irq(lock) _raw_read_lock_irq(lock) 96: #define read_lock_bh(lock) _raw_read_lock_bh(lock) 97: #define write_lock_irq(lock) _raw_write_lock_irq(lock) 98: #define write_lock_bh(lock) _raw_write_lock_bh(lock) 99: #define read_unlock(lock) _raw_read_unlock(lock) 100: #define write_unlock(lock) _raw_write_unlock(lock) 101: #define read_unlock_irq(lock) _raw_read_unlock_irq(lock) 102: #define write_unlock_irq(lock) _raw_write_unlock_irq(lock) 103: 104: #define read_unlock_irqrestore(lock, flags) \ 105: do { \ 106: typecheck(unsigned long, flags); \ 107: _raw_read_unlock_irqrestore(lock, flags); \ 108: } while (0) 109: #define read_unlock_bh(lock) _raw_read_unlock_bh(lock) 110: 111: #define write_unlock_irqrestore(lock, flags) \ 112: do { \ 113: typecheck(unsigned long, flags); \ 114: _raw_write_unlock_irqrestore(lock, flags); \ 115: } while (0) 116: #define write_unlock_bh(lock) _raw_write_unlock_bh(lock) 117: 118: #define write_trylock_irqsave(lock, flags) \ 119: ({ \ 120: local_irq_save(flags); \ 121: write_trylock(lock) ? \ 122: 1 : ({ local_irq_restore(flags); 0; }); \ 123: }) 124: 125: #endif /* __LINUX_RWLOCK_H */ 126: