include/linux/spinlock_rt.h

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #ifndef __LINUX_SPINLOCK_RT_H
   3 #define __LINUX_SPINLOCK_RT_H
   4
   5 #ifndef __LINUX_INSIDE_SPINLOCK_H
   6 #error Do not include directly. Use spinlock.h
   7 #endif
   8
   9 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  10 extern void __rt_spin_lock_init(spinlock_t *lock, const char *name,
  11                                 struct lock_class_key *key, bool percpu);
  12 #else
  13 static inline void __rt_spin_lock_init(spinlock_t *lock, const char *name,
  14                                 struct lock_class_key *key, bool percpu)
  15 {
  16 }
  17 #endif
  18
  19 #define __spin_lock_init(slock, name, key, percpu)              \
  20 do {                                                            \
  21         rt_mutex_base_init(&(slock)->lock);                     \
  22         __rt_spin_lock_init(slock, name, key, percpu);          \
  23 } while (0)
  24
  25 #define _spin_lock_init(slock, percpu)                          \
  26 do {                                                            \
  27         static struct lock_class_key __key;                     \
  28         __spin_lock_init(slock, #slock, &__key, percpu);        \
  29 } while (0)
  30
  31 #define spin_lock_init(slock)           _spin_lock_init(slock, false)
  32 #define local_spin_lock_init(slock)     _spin_lock_init(slock, true)
  33
  34 extern void rt_spin_lock(spinlock_t *lock) __acquires(lock);
  35 extern void rt_spin_lock_nested(spinlock_t *lock, int subclass) __acquires(lock);
  36 extern void rt_spin_lock_nest_lock(spinlock_t *lock, struct lockdep_map *nest_lock) __acquires(lock);
  37 extern void rt_spin_unlock(spinlock_t *lock)    __releases(lock);
  38 extern void rt_spin_lock_unlock(spinlock_t *lock);
  39 extern int rt_spin_trylock_bh(spinlock_t *lock);
  40 extern int rt_spin_trylock(spinlock_t *lock);
  41
  42 static __always_inline void spin_lock(spinlock_t *lock)
  43 {
  44         rt_spin_lock(lock);
  45 }
  46
  47 #ifdef CONFIG_LOCKDEP
  48 # define __spin_lock_nested(lock, subclass)                             \
  49         rt_spin_lock_nested(lock, subclass)
  50
  51 # define __spin_lock_nest_lock(lock, nest_lock)                         \
  52         do {                                                            \
  53                 typecheck(struct lockdep_map *, &(nest_lock)->dep_map); \
  54                 rt_spin_lock_nest_lock(lock, &(nest_lock)->dep_map);    \
  55         } while (0)
  56 # define __spin_lock_irqsave_nested(lock, flags, subclass)      \
  57         do {                                                    \
  58                 typecheck(unsigned long, flags);                \
  59                 flags = 0;                                      \
  60                 __spin_lock_nested(lock, subclass);             \
  61         } while (0)
  62
  63 #else
  64  /*
  65   * Always evaluate the 'subclass' argument to avoid that the compiler
  66   * warns about set-but-not-used variables when building with
  67   * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1.
  68   */
  69 # define __spin_lock_nested(lock, subclass)     spin_lock(((void)(subclass), (lock)))
  70 # define __spin_lock_nest_lock(lock, subclass)  spin_lock(((void)(subclass), (lock)))
  71 # define __spin_lock_irqsave_nested(lock, flags, subclass)      \
  72         spin_lock_irqsave(((void)(subclass), (lock)), flags)
  73 #endif
  74
  75 #define spin_lock_nested(lock, subclass)                \
  76         __spin_lock_nested(lock, subclass)
  77
  78 #define spin_lock_nest_lock(lock, nest_lock)            \
  79         __spin_lock_nest_lock(lock, nest_lock)
  80
  81 #define spin_lock_irqsave_nested(lock, flags, subclass) \
  82         __spin_lock_irqsave_nested(lock, flags, subclass)
  83
  84 static __always_inline void spin_lock_bh(spinlock_t *lock)
  85 {
  86         /* Investigate: Drop bh when blocking ? */
  87         local_bh_disable();
  88         rt_spin_lock(lock);
  89 }
  90
  91 static __always_inline void spin_lock_irq(spinlock_t *lock)
  92 {
  93         rt_spin_lock(lock);
  94 }
  95
  96 #define spin_lock_irqsave(lock, flags)                   \
  97         do {                                             \
  98                 typecheck(unsigned long, flags);         \
  99                 flags = 0;                               \
 100                 spin_lock(lock);                         \
 101         } while (0)
 102
 103 static __always_inline void spin_unlock(spinlock_t *lock)
 104 {
 105         rt_spin_unlock(lock);
 106 }
 107
 108 static __always_inline void spin_unlock_bh(spinlock_t *lock)
 109 {
 110         rt_spin_unlock(lock);
 111         local_bh_enable();
 112 }
 113
 114 static __always_inline void spin_unlock_irq(spinlock_t *lock)
 115 {
 116         rt_spin_unlock(lock);
 117 }
 118
 119 static __always_inline void spin_unlock_irqrestore(spinlock_t *lock,
 120                                                    unsigned long flags)
 121 {
 122         rt_spin_unlock(lock);
 123 }
 124
 125 #define spin_trylock(lock)                              \
 126         __cond_lock(lock, rt_spin_trylock(lock))
 127
 128 #define spin_trylock_bh(lock)                           \
 129         __cond_lock(lock, rt_spin_trylock_bh(lock))
 130
 131 #define spin_trylock_irq(lock)                          \
 132         __cond_lock(lock, rt_spin_trylock(lock))
 133
 134 #define spin_trylock_irqsave(lock, flags)               \
 135 ({                                                      \
 136         int __locked;                                   \
 137                                                         \
 138         typecheck(unsigned long, flags);                \
 139         flags = 0;                                      \
 140         __locked = spin_trylock(lock);                  \
 141         __locked;                                       \
 142 })
 143
 144 #define spin_is_contended(lock)         (((void)(lock), 0))
 145
 146 static inline int spin_is_locked(spinlock_t *lock)
 147 {
 148         return rt_mutex_base_is_locked(&lock->lock);
 149 }
 150
 151 #define assert_spin_locked(lock) BUG_ON(!spin_is_locked(lock))
 152
 153 #include <linux/rwlock_rt.h>
 154
 155 #endif