linux-stable-mirror/include/linux/spinlock_rt.h

// SPDX-License-Identifier: GPL-2.0-only
#ifndef __LINUX_SPINLOCK_RT_H
#define __LINUX_SPINLOCK_RT_H

#ifndef __LINUX_INSIDE_SPINLOCK_H
#error Do not include directly. Use spinlock.h
#endif

#ifdef CONFIG_DEBUG_LOCK_ALLOC
extern void __rt_spin_lock_init(spinlock_t *lock, const char *name,
				struct lock_class_key *key, bool percpu);
#else
static inline void __rt_spin_lock_init(spinlock_t *lock, const char *name,
				struct lock_class_key *key, bool percpu)
{
}
#endif

#define __spin_lock_init(slock, name, key, percpu)		\
do {								\
	rt_mutex_base_init(&(slock)->lock);			\
	__rt_spin_lock_init(slock, name, key, percpu);		\
} while (0)

#define _spin_lock_init(slock, percpu)				\
do {								\
	static struct lock_class_key __key;			\
	__spin_lock_init(slock, #slock, &__key, percpu);	\
} while (0)

#define spin_lock_init(slock)		_spin_lock_init(slock, false)
#define local_spin_lock_init(slock)	_spin_lock_init(slock, true)

extern void rt_spin_lock(spinlock_t *lock) __acquires(lock);
extern void rt_spin_lock_nested(spinlock_t *lock, int subclass)	__acquires(lock);
extern void rt_spin_lock_nest_lock(spinlock_t *lock, struct lockdep_map *nest_lock) __acquires(lock);
extern void rt_spin_unlock(spinlock_t *lock)	__releases(lock);
extern void rt_spin_lock_unlock(spinlock_t *lock);
extern int rt_spin_trylock_bh(spinlock_t *lock) __cond_acquires(true, lock);
extern int rt_spin_trylock(spinlock_t *lock) __cond_acquires(true, lock);

static __always_inline void spin_lock(spinlock_t *lock)
	__acquires(lock)
{
	rt_spin_lock(lock);
}

#ifdef CONFIG_LOCKDEP
# define __spin_lock_nested(lock, subclass)				\
	rt_spin_lock_nested(lock, subclass)

# define __spin_lock_nest_lock(lock, nest_lock)				\
	do {								\
		typecheck(struct lockdep_map *, &(nest_lock)->dep_map);	\
		rt_spin_lock_nest_lock(lock, &(nest_lock)->dep_map);	\
	} while (0)
# define __spin_lock_irqsave_nested(lock, flags, subclass)	\
	do {							\
		typecheck(unsigned long, flags);		\
		flags = 0;					\
		__spin_lock_nested(lock, subclass);		\
	} while (0)

#else
 /*
  * Always evaluate the 'subclass' argument to avoid that the compiler
  * warns about set-but-not-used variables when building with
  * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1.
  */
# define __spin_lock_nested(lock, subclass)	spin_lock(((void)(subclass), (lock)))
# define __spin_lock_nest_lock(lock, subclass)	spin_lock(((void)(subclass), (lock)))
# define __spin_lock_irqsave_nested(lock, flags, subclass)	\
	spin_lock_irqsave(((void)(subclass), (lock)), flags)
#endif

#define spin_lock_nested(lock, subclass)		\
	__spin_lock_nested(lock, subclass)

#define spin_lock_nest_lock(lock, nest_lock)		\
	__spin_lock_nest_lock(lock, nest_lock)

#define spin_lock_irqsave_nested(lock, flags, subclass)	\
	__spin_lock_irqsave_nested(lock, flags, subclass)

static __always_inline void spin_lock_bh(spinlock_t *lock)
	__acquires(lock)
{
	/* Investigate: Drop bh when blocking ? */
	local_bh_disable();
	rt_spin_lock(lock);
}

static __always_inline void spin_lock_irq(spinlock_t *lock)
	__acquires(lock)
{
	rt_spin_lock(lock);
}

static __always_inline void spin_lock_irq_disable(spinlock_t *lock)
	__acquires(lock)
{
	rt_spin_lock(lock);
}

#define spin_lock_irqsave(lock, flags)			 \
	do {						 \
		typecheck(unsigned long, flags);	 \
		flags = 0;				 \
		spin_lock(lock);			 \
	} while (0)

static __always_inline void spin_unlock(spinlock_t *lock)
	__releases(lock)
{
	rt_spin_unlock(lock);
}

static __always_inline void spin_unlock_bh(spinlock_t *lock)
	__releases(lock)
{
	rt_spin_unlock(lock);
	local_bh_enable();
}

static __always_inline void spin_unlock_irq(spinlock_t *lock)
	__releases(lock)
{
	rt_spin_unlock(lock);
}

static __always_inline void spin_unlock_irq_enable(spinlock_t *lock)
	__releases(lock)
{
	rt_spin_unlock(lock);
}

static __always_inline void spin_unlock_irqrestore(spinlock_t *lock,
						   unsigned long flags)
	__releases(lock)
{
	rt_spin_unlock(lock);
}

#define spin_trylock(lock)	rt_spin_trylock(lock)

static __always_inline int spin_trylock_irq_disable(spinlock_t *lock)
	__cond_acquires(true, lock)
{
	return rt_spin_trylock(lock);
}

#define spin_trylock_bh(lock)	rt_spin_trylock_bh(lock)

#define spin_trylock_irq(lock)	rt_spin_trylock(lock)

static __always_inline bool _spin_trylock_irqsave(spinlock_t *lock, unsigned long *flags)
	__cond_acquires(true, lock)
{
	*flags = 0;
	return rt_spin_trylock(lock);
}
#define spin_trylock_irqsave(lock, flags) _spin_trylock_irqsave(lock, &(flags))

#define spin_is_contended(lock)		(((void)(lock), 0))

static inline int spin_is_locked(spinlock_t *lock)
{
	return rt_mutex_base_is_locked(&lock->lock);
}

#define assert_spin_locked(lock) BUG_ON(!spin_is_locked(lock))

#include <linux/rwlock_rt.h>

#endif