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