[linux-block.git] / include / linux / rwlock_rt.h

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

#ifndef __LINUX_SPINLOCK_RT_H
#error Do not #include directly. Use <linux/spinlock.h>.
#endif

#ifdef CONFIG_DEBUG_LOCK_ALLOC
extern void __rt_rwlock_init(rwlock_t *rwlock, const char *name,
			     struct lock_class_key *key);
#else
static inline void __rt_rwlock_init(rwlock_t *rwlock, char *name,
				    struct lock_class_key *key)
{
}
#endif

#define rwlock_init(rwl)				\
do {							\
	static struct lock_class_key __key;		\
							\
	init_rwbase_rt(&(rwl)->rwbase);			\
	__rt_rwlock_init(rwl, #rwl, &__key);		\
} while (0)

extern void rt_read_lock(rwlock_t *rwlock);
extern int rt_read_trylock(rwlock_t *rwlock);
extern void rt_read_unlock(rwlock_t *rwlock);
extern void rt_write_lock(rwlock_t *rwlock);
extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass);
extern int rt_write_trylock(rwlock_t *rwlock);
extern void rt_write_unlock(rwlock_t *rwlock);

static __always_inline void read_lock(rwlock_t *rwlock)
{
	rt_read_lock(rwlock);
}

static __always_inline void read_lock_bh(rwlock_t *rwlock)
{
	local_bh_disable();
	rt_read_lock(rwlock);
}

static __always_inline void read_lock_irq(rwlock_t *rwlock)
{
	rt_read_lock(rwlock);
}

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

#define read_trylock(lock)	__cond_lock(lock, rt_read_trylock(lock))

static __always_inline void read_unlock(rwlock_t *rwlock)
{
	rt_read_unlock(rwlock);
}

static __always_inline void read_unlock_bh(rwlock_t *rwlock)
{
	rt_read_unlock(rwlock);
	local_bh_enable();
}

static __always_inline void read_unlock_irq(rwlock_t *rwlock)
{
	rt_read_unlock(rwlock);
}

static __always_inline void read_unlock_irqrestore(rwlock_t *rwlock,
						   unsigned long flags)
{
	rt_read_unlock(rwlock);
}

static __always_inline void write_lock(rwlock_t *rwlock)
{
	rt_write_lock(rwlock);
}

#ifdef CONFIG_DEBUG_LOCK_ALLOC
static __always_inline void write_lock_nested(rwlock_t *rwlock, int subclass)
{
	rt_write_lock_nested(rwlock, subclass);
}
#else
#define write_lock_nested(lock, subclass)	rt_write_lock(((void)(subclass), (lock)))
#endif

static __always_inline void write_lock_bh(rwlock_t *rwlock)
{
	local_bh_disable();
	rt_write_lock(rwlock);
}

static __always_inline void write_lock_irq(rwlock_t *rwlock)
{
	rt_write_lock(rwlock);
}

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

#define write_trylock(lock)	__cond_lock(lock, rt_write_trylock(lock))

#define write_trylock_irqsave(lock, flags)		\
({							\
	int __locked;					\
							\
	typecheck(unsigned long, flags);		\
	flags = 0;					\
	__locked = write_trylock(lock);			\
	__locked;					\
})

static __always_inline void write_unlock(rwlock_t *rwlock)
{
	rt_write_unlock(rwlock);
}

static __always_inline void write_unlock_bh(rwlock_t *rwlock)
{
	rt_write_unlock(rwlock);
	local_bh_enable();
}

static __always_inline void write_unlock_irq(rwlock_t *rwlock)
{
	rt_write_unlock(rwlock);
}

static __always_inline void write_unlock_irqrestore(rwlock_t *rwlock,
						    unsigned long flags)
{
	rt_write_unlock(rwlock);
}

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

#endif /* __LINUX_RWLOCK_RT_H */
Commit	Line	Data
8282947f TG	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);
	28	extern int rt_read_trylock(rwlock_t *rwlock);
	29	extern void rt_read_unlock(rwlock_t *rwlock);
	30	extern void rt_write_lock(rwlock_t *rwlock);
4a57d6bb	31	extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass);
8282947f TG	32	extern int rt_write_trylock(rwlock_t *rwlock);
	33	extern void rt_write_unlock(rwlock_t *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
4a57d6bb MK	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
8282947f TG	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 */