include/linux/rwlock_rt.h

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #ifndef __LINUX_RWLOCK_RT_H
   3 #define __LINUX_RWLOCK_RT_H
   4
   5 #ifndef __LINUX_SPINLOCK_RT_H
   6 #error Do not #include directly. Use <linux/spinlock.h>.
   7 #endif
   8
   9 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  10 extern void __rt_rwlock_init(rwlock_t *rwlock, const char *name,
  11                              struct lock_class_key *key);
  12 #else
  13 static inline void __rt_rwlock_init(rwlock_t *rwlock, char *name,
  14                                     struct lock_class_key *key)
  15 {
  16 }
  17 #endif
  18
  19 #define rwlock_init(rwl)                                \
  20 do {                                                    \
  21         static struct lock_class_key __key;             \
  22                                                         \
  23         init_rwbase_rt(&(rwl)->rwbase);                 \
  24         __rt_rwlock_init(rwl, #rwl, &__key);            \
  25 } while (0)
  26
  27 extern void rt_read_lock(rwlock_t *rwlock)      __acquires(rwlock);
  28 extern int rt_read_trylock(rwlock_t *rwlock);
  29 extern void rt_read_unlock(rwlock_t *rwlock)    __releases(rwlock);
  30 extern void rt_write_lock(rwlock_t *rwlock)     __acquires(rwlock);
  31 extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass)        __acquires(rwlock);
  32 extern int rt_write_trylock(rwlock_t *rwlock);
  33 extern void rt_write_unlock(rwlock_t *rwlock)   __releases(rwlock);
  34
  35 static __always_inline void read_lock(rwlock_t *rwlock)
  36 {
  37         rt_read_lock(rwlock);
  38 }
  39
  40 static __always_inline void read_lock_bh(rwlock_t *rwlock)
  41 {
  42         local_bh_disable();
  43         rt_read_lock(rwlock);
  44 }
  45
  46 static __always_inline void read_lock_irq(rwlock_t *rwlock)
  47 {
  48         rt_read_lock(rwlock);
  49 }
  50
  51 #define read_lock_irqsave(lock, flags)                  \
  52         do {                                            \
  53                 typecheck(unsigned long, flags);        \
  54                 rt_read_lock(lock);                     \
  55                 flags = 0;                              \
  56         } while (0)
  57
  58 #define read_trylock(lock)      __cond_lock(lock, rt_read_trylock(lock))
  59
  60 static __always_inline void read_unlock(rwlock_t *rwlock)
  61 {
  62         rt_read_unlock(rwlock);
  63 }
  64
  65 static __always_inline void read_unlock_bh(rwlock_t *rwlock)
  66 {
  67         rt_read_unlock(rwlock);
  68         local_bh_enable();
  69 }
  70
  71 static __always_inline void read_unlock_irq(rwlock_t *rwlock)
  72 {
  73         rt_read_unlock(rwlock);
  74 }
  75
  76 static __always_inline void read_unlock_irqrestore(rwlock_t *rwlock,
  77                                                    unsigned long flags)
  78 {
  79         rt_read_unlock(rwlock);
  80 }
  81
  82 static __always_inline void write_lock(rwlock_t *rwlock)
  83 {
  84         rt_write_lock(rwlock);
  85 }
  86
  87 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  88 static __always_inline void write_lock_nested(rwlock_t *rwlock, int subclass)
  89 {
  90         rt_write_lock_nested(rwlock, subclass);
  91 }
  92 #else
  93 #define write_lock_nested(lock, subclass)       rt_write_lock(((void)(subclass), (lock)))
  94 #endif
  95
  96 static __always_inline void write_lock_bh(rwlock_t *rwlock)
  97 {
  98         local_bh_disable();
  99         rt_write_lock(rwlock);
 100 }
 101
 102 static __always_inline void write_lock_irq(rwlock_t *rwlock)
 103 {
 104         rt_write_lock(rwlock);
 105 }
 106
 107 #define write_lock_irqsave(lock, flags)                 \
 108         do {                                            \
 109                 typecheck(unsigned long, flags);        \
 110                 rt_write_lock(lock);                    \
 111                 flags = 0;                              \
 112         } while (0)
 113
 114 #define write_trylock(lock)     __cond_lock(lock, rt_write_trylock(lock))
 115
 116 #define write_trylock_irqsave(lock, flags)              \
 117 ({                                                      \
 118         int __locked;                                   \
 119                                                         \
 120         typecheck(unsigned long, flags);                \
 121         flags = 0;                                      \
 122         __locked = write_trylock(lock);                 \
 123         __locked;                                       \
 124 })
 125
 126 static __always_inline void write_unlock(rwlock_t *rwlock)
 127 {
 128         rt_write_unlock(rwlock);
 129 }
 130
 131 static __always_inline void write_unlock_bh(rwlock_t *rwlock)
 132 {
 133         rt_write_unlock(rwlock);
 134         local_bh_enable();
 135 }
 136
 137 static __always_inline void write_unlock_irq(rwlock_t *rwlock)
 138 {
 139         rt_write_unlock(rwlock);
 140 }
 141
 142 static __always_inline void write_unlock_irqrestore(rwlock_t *rwlock,
 143                                                     unsigned long flags)
 144 {
 145         rt_write_unlock(rwlock);
 146 }
 147
 148 #define rwlock_is_contended(lock)               (((void)(lock), 0))
 149
 150 #endif /* __LINUX_RWLOCK_RT_H */