[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / lglock.h

/*
 * Specialised local-global spinlock. Can only be declared as global variables
 * to avoid overhead and keep things simple (and we don't want to start using
 * these inside dynamically allocated structures).
 *
 * "local/global locks" (lglocks) can be used to:
 *
 * - Provide fast exclusive access to per-CPU data, with exclusive access to
 *   another CPU's data allowed but possibly subject to contention, and to
 *   provide very slow exclusive access to all per-CPU data.
 * - Or to provide very fast and scalable read serialisation, and to provide
 *   very slow exclusive serialisation of data (not necessarily per-CPU data).
 *
 * Brlocks are also implemented as a short-hand notation for the latter use
 * case.
 *
 * Copyright 2009, 2010, Nick Piggin, Novell Inc.
 */
#ifndef __LINUX_LGLOCK_H
#define __LINUX_LGLOCK_H

#include <linux/spinlock.h>
#include <linux/lockdep.h>
#include <linux/percpu.h>
#include <linux/cpu.h>

/* can make br locks by using local lock for read side, global lock for write */
#define br_lock_init(name)	name##_lock_init()
#define br_read_lock(name)	name##_local_lock()
#define br_read_unlock(name)	name##_local_unlock()
#define br_write_lock(name)	name##_global_lock()
#define br_write_unlock(name)	name##_global_unlock()

#define DECLARE_BRLOCK(name)	DECLARE_LGLOCK(name)
#define DEFINE_BRLOCK(name)	DEFINE_LGLOCK(name)


#define lg_lock_init(name)	name##_lock_init()
#define lg_local_lock(name)	name##_local_lock()
#define lg_local_unlock(name)	name##_local_unlock()
#define lg_local_lock_cpu(name, cpu)	name##_local_lock_cpu(cpu)
#define lg_local_unlock_cpu(name, cpu)	name##_local_unlock_cpu(cpu)
#define lg_global_lock(name)	name##_global_lock()
#define lg_global_unlock(name)	name##_global_unlock()

#ifdef CONFIG_DEBUG_LOCK_ALLOC
#define LOCKDEP_INIT_MAP lockdep_init_map

#define DEFINE_LGLOCK_LOCKDEP(name)					\
 struct lock_class_key name##_lock_key;					\
 struct lockdep_map name##_lock_dep_map;				\
 EXPORT_SYMBOL(name##_lock_dep_map)

#else
#define LOCKDEP_INIT_MAP(a, b, c, d)

#define DEFINE_LGLOCK_LOCKDEP(name)
#endif


#define DECLARE_LGLOCK(name)						\
 extern void name##_lock_init(void);					\
 extern void name##_local_lock(void);					\
 extern void name##_local_unlock(void);					\
 extern void name##_local_lock_cpu(int cpu);				\
 extern void name##_local_unlock_cpu(int cpu);				\
 extern void name##_global_lock(void);					\
 extern void name##_global_unlock(void);				\

#define DEFINE_LGLOCK(name)						\
									\
 DEFINE_SPINLOCK(name##_cpu_lock);					\
 DEFINE_PER_CPU(arch_spinlock_t, name##_lock);				\
 DEFINE_LGLOCK_LOCKDEP(name);						\
									\
 void name##_lock_init(void) {						\
	int i;								\
	LOCKDEP_INIT_MAP(&name##_lock_dep_map, #name, &name##_lock_key, 0); \
	for_each_possible_cpu(i) {					\
		arch_spinlock_t *lock;					\
		lock = &per_cpu(name##_lock, i);			\
		*lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;	\
	}								\
 }									\
 EXPORT_SYMBOL(name##_lock_init);					\
									\
 void name##_local_lock(void) {						\
	arch_spinlock_t *lock;						\
	preempt_disable();						\
	rwlock_acquire_read(&name##_lock_dep_map, 0, 0, _THIS_IP_);	\
	lock = &__get_cpu_var(name##_lock);				\
	arch_spin_lock(lock);						\
 }									\
 EXPORT_SYMBOL(name##_local_lock);					\
									\
 void name##_local_unlock(void) {					\
	arch_spinlock_t *lock;						\
	rwlock_release(&name##_lock_dep_map, 1, _THIS_IP_);		\
	lock = &__get_cpu_var(name##_lock);				\
	arch_spin_unlock(lock);						\
	preempt_enable();						\
 }									\
 EXPORT_SYMBOL(name##_local_unlock);					\
									\
 void name##_local_lock_cpu(int cpu) {					\
	arch_spinlock_t *lock;						\
	preempt_disable();						\
	rwlock_acquire_read(&name##_lock_dep_map, 0, 0, _THIS_IP_);	\
	lock = &per_cpu(name##_lock, cpu);				\
	arch_spin_lock(lock);						\
 }									\
 EXPORT_SYMBOL(name##_local_lock_cpu);					\
									\
 void name##_local_unlock_cpu(int cpu) {				\
	arch_spinlock_t *lock;						\
	rwlock_release(&name##_lock_dep_map, 1, _THIS_IP_);		\
	lock = &per_cpu(name##_lock, cpu);				\
	arch_spin_unlock(lock);						\
	preempt_enable();						\
 }									\
 EXPORT_SYMBOL(name##_local_unlock_cpu);				\
									\
 void name##_global_lock(void) {					\
	int i;								\
	preempt_disable();						\
	rwlock_acquire(&name##_lock_dep_map, 0, 0, _RET_IP_);		\
	for_each_possible_cpu(i) {					\
		arch_spinlock_t *lock;					\
		lock = &per_cpu(name##_lock, i);			\
		arch_spin_lock(lock);					\
	}								\
 }									\
 EXPORT_SYMBOL(name##_global_lock);					\
									\
 void name##_global_unlock(void) {					\
	int i;								\
	rwlock_release(&name##_lock_dep_map, 1, _RET_IP_);		\
	for_each_possible_cpu(i) {					\
		arch_spinlock_t *lock;					\
		lock = &per_cpu(name##_lock, i);			\
		arch_spin_unlock(lock);					\
	}								\
	preempt_enable();						\
 }									\
 EXPORT_SYMBOL(name##_global_unlock);
#endif
Commit	Line	Data
2dc91abe NP	1	/*
	2	* Specialised local-global spinlock. Can only be declared as global variables
	3	* to avoid overhead and keep things simple (and we don't want to start using
	4	* these inside dynamically allocated structures).
	5	*
	6	* "local/global locks" (lglocks) can be used to:
	7	*
	8	* - Provide fast exclusive access to per-CPU data, with exclusive access to
	9	* another CPU's data allowed but possibly subject to contention, and to
	10	* provide very slow exclusive access to all per-CPU data.
	11	* - Or to provide very fast and scalable read serialisation, and to provide
	12	* very slow exclusive serialisation of data (not necessarily per-CPU data).
	13	*
	14	* Brlocks are also implemented as a short-hand notation for the latter use
	15	* case.
	16	*
	17	* Copyright 2009, 2010, Nick Piggin, Novell Inc.
	18	*/
	19	#ifndef __LINUX_LGLOCK_H
	20	#define __LINUX_LGLOCK_H
	21
	22	#include <linux/spinlock.h>
	23	#include <linux/lockdep.h>
	24	#include <linux/percpu.h>
e30e2fdf	25	#include <linux/cpu.h>
2dc91abe NP	26
	27	/* can make br locks by using local lock for read side, global lock for write */
	28	#define br_lock_init(name) name##_lock_init()
	29	#define br_read_lock(name) name##_local_lock()
	30	#define br_read_unlock(name) name##_local_unlock()
9dd6fa03 RR	31	#define br_write_lock(name) name##_global_lock()
9dd6fa03 RR	32	#define br_write_unlock(name) name##_global_unlock()
2dc91abe NP	33
	34	#define DECLARE_BRLOCK(name) DECLARE_LGLOCK(name)
	35	#define DEFINE_BRLOCK(name) DEFINE_LGLOCK(name)
	36
	37
	38	#define lg_lock_init(name) name##_lock_init()
	39	#define lg_local_lock(name) name##_local_lock()
	40	#define lg_local_unlock(name) name##_local_unlock()
	41	#define lg_local_lock_cpu(name, cpu) name##_local_lock_cpu(cpu)
	42	#define lg_local_unlock_cpu(name, cpu) name##_local_unlock_cpu(cpu)
	43	#define lg_global_lock(name) name##_global_lock()
	44	#define lg_global_unlock(name) name##_global_unlock()
2dc91abe NP	45
	46	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	47	#define LOCKDEP_INIT_MAP lockdep_init_map
	48
	49	#define DEFINE_LGLOCK_LOCKDEP(name) \
	50	struct lock_class_key name##_lock_key; \
	51	struct lockdep_map name##_lock_dep_map; \
	52	EXPORT_SYMBOL(name##_lock_dep_map)
	53
	54	#else
	55	#define LOCKDEP_INIT_MAP(a, b, c, d)
	56
	57	#define DEFINE_LGLOCK_LOCKDEP(name)
	58	#endif
	59
	60
	61	#define DECLARE_LGLOCK(name) \
	62	extern void name##_lock_init(void); \
	63	extern void name##_local_lock(void); \
	64	extern void name##_local_unlock(void); \
	65	extern void name##_local_lock_cpu(int cpu); \
	66	extern void name##_local_unlock_cpu(int cpu); \
	67	extern void name##_global_lock(void); \
	68	extern void name##_global_unlock(void); \
2dc91abe NP	69
	70	#define DEFINE_LGLOCK(name) \
	71	\
e30e2fdf	72	DEFINE_SPINLOCK(name##_cpu_lock); \
2dc91abe NP	73	DEFINE_PER_CPU(arch_spinlock_t, name##_lock); \
	74	DEFINE_LGLOCK_LOCKDEP(name); \
	75	\
	76	void name##_lock_init(void) { \
	77	int i; \
	78	LOCKDEP_INIT_MAP(&name##_lock_dep_map, #name, &name##_lock_key, 0); \
	79	for_each_possible_cpu(i) { \
	80	arch_spinlock_t *lock; \
	81	lock = &per_cpu(name##_lock, i); \
	82	*lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED; \
	83	} \
	84	} \
	85	EXPORT_SYMBOL(name##_lock_init); \
	86	\
	87	void name##_local_lock(void) { \
	88	arch_spinlock_t *lock; \
	89	preempt_disable(); \
	90	rwlock_acquire_read(&name##_lock_dep_map, 0, 0, _THIS_IP_); \
	91	lock = &__get_cpu_var(name##_lock); \
	92	arch_spin_lock(lock); \
	93	} \
	94	EXPORT_SYMBOL(name##_local_lock); \
	95	\
	96	void name##_local_unlock(void) { \
	97	arch_spinlock_t *lock; \
	98	rwlock_release(&name##_lock_dep_map, 1, _THIS_IP_); \
	99	lock = &__get_cpu_var(name##_lock); \
	100	arch_spin_unlock(lock); \
	101	preempt_enable(); \
	102	} \
	103	EXPORT_SYMBOL(name##_local_unlock); \
	104	\
	105	void name##_local_lock_cpu(int cpu) { \
	106	arch_spinlock_t *lock; \
	107	preempt_disable(); \
	108	rwlock_acquire_read(&name##_lock_dep_map, 0, 0, _THIS_IP_); \
	109	lock = &per_cpu(name##_lock, cpu); \
	110	arch_spin_lock(lock); \
	111	} \
	112	EXPORT_SYMBOL(name##_local_lock_cpu); \
	113	\
	114	void name##_local_unlock_cpu(int cpu) { \
	115	arch_spinlock_t *lock; \
	116	rwlock_release(&name##_lock_dep_map, 1, _THIS_IP_); \
	117	lock = &per_cpu(name##_lock, cpu); \
	118	arch_spin_unlock(lock); \
	119	preempt_enable(); \
	120	} \
	121	EXPORT_SYMBOL(name##_local_unlock_cpu); \
	122	\
2dc91abe NP	123	void name##_global_lock(void) { \
	124	int i; \
	125	preempt_disable(); \
	126	rwlock_acquire(&name##_lock_dep_map, 0, 0, _RET_IP_); \
a73f8844	127	for_each_possible_cpu(i) { \
2dc91abe NP	128	arch_spinlock_t *lock; \
	129	lock = &per_cpu(name##_lock, i); \
	130	arch_spin_lock(lock); \
	131	} \
	132	} \
	133	EXPORT_SYMBOL(name##_global_lock); \
	134	\
	135	void name##_global_unlock(void) { \
	136	int i; \
	137	rwlock_release(&name##_lock_dep_map, 1, _RET_IP_); \
a73f8844	138	for_each_possible_cpu(i) { \
2dc91abe NP	139	arch_spinlock_t *lock; \
	140	lock = &per_cpu(name##_lock, i); \
	141	arch_spin_unlock(lock); \
	142	} \
	143	preempt_enable(); \
	144	} \
	145	EXPORT_SYMBOL(name##_global_unlock);
	146	#endif