File: /Users/paulross/dev/linux/linux-3.13/include/linux/rwlock_api_smp.h

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_API_SMP_H
       2: #define __LINUX_RWLOCK_API_SMP_H
       3: 
       4: #ifndef __LINUX_SPINLOCK_API_SMP_H
       5: # error "please don't include this file directly"
       6: #endif
       7: 
       8: /*
       9:  * include/linux/rwlock_api_smp.h
      10:  *
      11:  * spinlock API declarations on SMP (and debug)
      12:  * (implemented in kernel/spinlock.c)
      13:  *
      14:  * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
      15:  * Released under the General Public License (GPL).
      16:  */
      17: 
      18: void __lockfunc _raw_read_lock(rwlock_t *lock)        __acquires(lock);
      19: void __lockfunc _raw_write_lock(rwlock_t *lock)        __acquires(lock);
      20: void __lockfunc _raw_read_lock_bh(rwlock_t *lock)    __acquires(lock);
      21: void __lockfunc _raw_write_lock_bh(rwlock_t *lock)    __acquires(lock);
      22: void __lockfunc _raw_read_lock_irq(rwlock_t *lock)    __acquires(lock);
      23: void __lockfunc _raw_write_lock_irq(rwlock_t *lock)    __acquires(lock);
      24: unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
      25:                             __acquires(lock);
      26: unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
      27:                             __acquires(lock);
      28: int __lockfunc _raw_read_trylock(rwlock_t *lock);
      29: int __lockfunc _raw_write_trylock(rwlock_t *lock);
      30: void __lockfunc _raw_read_unlock(rwlock_t *lock)    __releases(lock);
      31: void __lockfunc _raw_write_unlock(rwlock_t *lock)    __releases(lock);
      32: void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)    __releases(lock);
      33: void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)    __releases(lock);
      34: void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)    __releases(lock);
      35: void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)    __releases(lock);
      36: void __lockfunc
      37: _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
      38:                             __releases(lock);
      39: void __lockfunc
      40: _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
      41:                             __releases(lock);
      42: 
      43: #ifdef CONFIG_INLINE_READ_LOCK
      44: #define _raw_read_lock(lock) __raw_read_lock(lock)
      45: #endif
      46: 
      47: #ifdef CONFIG_INLINE_WRITE_LOCK
      48: #define _raw_write_lock(lock) __raw_write_lock(lock)
      49: #endif
      50: 
      51: #ifdef CONFIG_INLINE_READ_LOCK_BH
      52: #define _raw_read_lock_bh(lock) __raw_read_lock_bh(lock)
      53: #endif
      54: 
      55: #ifdef CONFIG_INLINE_WRITE_LOCK_BH
      56: #define _raw_write_lock_bh(lock) __raw_write_lock_bh(lock)
      57: #endif
      58: 
      59: #ifdef CONFIG_INLINE_READ_LOCK_IRQ
      60: #define _raw_read_lock_irq(lock) __raw_read_lock_irq(lock)
      61: #endif
      62: 
      63: #ifdef CONFIG_INLINE_WRITE_LOCK_IRQ
      64: #define _raw_write_lock_irq(lock) __raw_write_lock_irq(lock)
      65: #endif
      66: 
      67: #ifdef CONFIG_INLINE_READ_LOCK_IRQSAVE
      68: #define _raw_read_lock_irqsave(lock) __raw_read_lock_irqsave(lock)
      69: #endif
      70: 
      71: #ifdef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
      72: #define _raw_write_lock_irqsave(lock) __raw_write_lock_irqsave(lock)
      73: #endif
      74: 
      75: #ifdef CONFIG_INLINE_READ_TRYLOCK
      76: #define _raw_read_trylock(lock) __raw_read_trylock(lock)
      77: #endif
      78: 
      79: #ifdef CONFIG_INLINE_WRITE_TRYLOCK
      80: #define _raw_write_trylock(lock) __raw_write_trylock(lock)
      81: #endif
      82: 
      83: #ifdef CONFIG_INLINE_READ_UNLOCK
      84: #define _raw_read_unlock(lock) __raw_read_unlock(lock)
      85: #endif
      86: 
      87: #ifdef CONFIG_INLINE_WRITE_UNLOCK
      88: #define _raw_write_unlock(lock) __raw_write_unlock(lock)
      89: #endif
      90: 
      91: #ifdef CONFIG_INLINE_READ_UNLOCK_BH
      92: #define _raw_read_unlock_bh(lock) __raw_read_unlock_bh(lock)
      93: #endif
      94: 
      95: #ifdef CONFIG_INLINE_WRITE_UNLOCK_BH
      96: #define _raw_write_unlock_bh(lock) __raw_write_unlock_bh(lock)
      97: #endif
      98: 
      99: #ifdef CONFIG_INLINE_READ_UNLOCK_IRQ
     100: #define _raw_read_unlock_irq(lock) __raw_read_unlock_irq(lock)
     101: #endif
     102: 
     103: #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQ
     104: #define _raw_write_unlock_irq(lock) __raw_write_unlock_irq(lock)
     105: #endif
     106: 
     107: #ifdef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
     108: #define _raw_read_unlock_irqrestore(lock, flags) \
     109:     __raw_read_unlock_irqrestore(lock, flags)
     110: #endif
     111: 
     112: #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
     113: #define _raw_write_unlock_irqrestore(lock, flags) \
     114:     __raw_write_unlock_irqrestore(lock, flags)
     115: #endif
     116: 
     117: static inline int __raw_read_trylock(rwlock_t *lock)
     118: {
     119:     preempt_disable();
     120:     if (do_raw_read_trylock(lock)) {
     121:         rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
     122:         return 1;
     123:     }
     124:     preempt_enable();
     125:     return 0;
     126: }
     127: 
     128: static inline int __raw_write_trylock(rwlock_t *lock)
     129: {
     130:     preempt_disable();
     131:     if (do_raw_write_trylock(lock)) {
     132:         rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
     133:         return 1;
     134:     }
     135:     preempt_enable();
     136:     return 0;
     137: }
     138: 
     139: /*
     140:  * If lockdep is enabled then we use the non-preemption spin-ops
     141:  * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
     142:  * not re-enabled during lock-acquire (which the preempt-spin-ops do):
     143:  */
     144: #if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)
     145: 
     146: static inline void __raw_read_lock(rwlock_t *lock)
     147: {
     148:     preempt_disable();
     149:     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
     150:     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
     151: }
     152: 
     153: static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
     154: {
     155:     unsigned long flags;
     156: 
     157:     local_irq_save(flags);
     158:     preempt_disable();
     159:     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
     160:     LOCK_CONTENDED_FLAGS(lock, do_raw_read_trylock, do_raw_read_lock,
     161:                  do_raw_read_lock_flags, &flags);
     162:     return flags;
     163: }
     164: 
     165: static inline void __raw_read_lock_irq(rwlock_t *lock)
     166: {
     167:     local_irq_disable();
     168:     preempt_disable();
     169:     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
     170:     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
     171: }
     172: 
     173: static inline void __raw_read_lock_bh(rwlock_t *lock)
     174: {
     175:     local_bh_disable();
     176:     preempt_disable();
     177:     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
     178:     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
     179: }
     180: 
     181: static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
     182: {
     183:     unsigned long flags;
     184: 
     185:     local_irq_save(flags);
     186:     preempt_disable();
     187:     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
     188:     LOCK_CONTENDED_FLAGS(lock, do_raw_write_trylock, do_raw_write_lock,
     189:                  do_raw_write_lock_flags, &flags);
     190:     return flags;
     191: }
     192: 
     193: static inline void __raw_write_lock_irq(rwlock_t *lock)
     194: {
     195:     local_irq_disable();
     196:     preempt_disable();
     197:     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
     198:     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
     199: }
     200: 
     201: static inline void __raw_write_lock_bh(rwlock_t *lock)
     202: {
     203:     local_bh_disable();
     204:     preempt_disable();
     205:     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
     206:     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
     207: }
     208: 
     209: static inline void __raw_write_lock(rwlock_t *lock)
     210: {
     211:     preempt_disable();
     212:     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
     213:     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
     214: }
     215: 
     216: #endif /* CONFIG_PREEMPT */
     217: 
     218: static inline void __raw_write_unlock(rwlock_t *lock)
     219: {
     220:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     221:     do_raw_write_unlock(lock);
     222:     preempt_enable();
     223: }
     224: 
     225: static inline void __raw_read_unlock(rwlock_t *lock)
     226: {
     227:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     228:     do_raw_read_unlock(lock);
     229:     preempt_enable();
     230: }
     231: 
     232: static inline void
     233: __raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
     234: {
     235:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     236:     do_raw_read_unlock(lock);
     237:     local_irq_restore(flags);
     238:     preempt_enable();
     239: }
     240: 
     241: static inline void __raw_read_unlock_irq(rwlock_t *lock)
     242: {
     243:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     244:     do_raw_read_unlock(lock);
     245:     local_irq_enable();
     246:     preempt_enable();
     247: }
     248: 
     249: static inline void __raw_read_unlock_bh(rwlock_t *lock)
     250: {
     251:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     252:     do_raw_read_unlock(lock);
     253:     preempt_enable_no_resched();
     254:     local_bh_enable_ip((unsigned long)__builtin_return_address(0));
     255: }
     256: 
     257: static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,
     258:                          unsigned long flags)
     259: {
     260:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     261:     do_raw_write_unlock(lock);
     262:     local_irq_restore(flags);
     263:     preempt_enable();
     264: }
     265: 
     266: static inline void __raw_write_unlock_irq(rwlock_t *lock)
     267: {
     268:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     269:     do_raw_write_unlock(lock);
     270:     local_irq_enable();
     271:     preempt_enable();
     272: }
     273: 
     274: static inline void __raw_write_unlock_bh(rwlock_t *lock)
     275: {
     276:     rwlock_release(&lock->dep_map, 1, _RET_IP_);
     277:     do_raw_write_unlock(lock);
     278:     preempt_enable_no_resched();
     279:     local_bh_enable_ip((unsigned long)__builtin_return_address(0));
     280: }
     281: 
     282: #endif /* __LINUX_RWLOCK_API_SMP_H */
     283: