rwlock.h 4.3 KB

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