typedef struct {
	int counter;
} atomic_t;

int atomic_read(atomic_t *v); //读操作
void atomic_set(atomic_t *v, int i); //设置变量
void atomic_add(int i, atomic_t *v); //增加i
void atomic_sub(int i, atomic_t *v); //减少i
void atomic_inc(atomic_t *v); //增加一
void atomic_dec(atomic_t *v); //减少一
bool atomic_inc_and_test(atomic_t *v); //加一是否为零
bool atomic_dec_and_test(atomic_t *v); //减一是否为零
bool atomic_add_negative(int i, atomic_t *v); //加i是否为负
int atomic_add_return(int i, atomic_t *v); //加i返回结果
int atomic_sub_return(int i, atomic_t *v); //减i返回结果
int atomic_inc_return(atomic_t *v); //加一返回结果
int atomic_dec_return(atomic_t *v); //减一返回结果

typedef struct {
	struct raw_spinlock rlock;
} spinlock_t;
//套娃结构体我就不写了。

spin_lock_init(); //动态初始化spin_lock
DEFINE_SPINLOCK(); //声明并初始化spin_lock

/* 普通版本 */
void spin_lock(spinlock_t *lock); //持有一个spinlock
void spin_unlock(spinlock_t *lock); //释放一个spinlock
int spin_trylock(spinlock_t *lock); //尝试获得锁，不能获得立即返回，不自旋
int spin_is_locked(spinlock_t *lock); //判断一个锁是否被持有
int spin_can_lock(spinlock_t *lock); //判断一个锁是否可以被持有

/* 保存标志关中断版本 */
void spin_lock_irqsave(spinlock_t *lock, unsigned long flags); //获得锁时，保存标志寄存器到flags变量中，关中断；释放锁反之
void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);

/* 关中断版本 */
void spin_lock_irq(spinlock_t *lock); //获得锁时，关中断；释放锁反之
void spin_unlock_irq(spinlock_t *lock);

/* 关软中断版本 */
void spin_lock_bh(spinlock_t *lock); //获得锁时，关软中断；释放反之
void spin_unlock_bh(spinlock_t *lock);

void spin_trylock_irqsave(spinlock_t *lock, unsigned long flags); //能够获得锁时，保存标志寄存器到flags，关中断；否则立即返回
void spin_trylock_irq(spinlock_t *lock); //能够获得锁时，关中断；否则立即返回
void spin_trylock_bh(spinlock_t *lock); //能够获得锁时，关软中断；否则立即返回

spin_lock > spin_lock_bh > spin_lock_irq > spin_lock_irqsave 

spin_lock_irqsave > spin_lock_irq > spin_lock_bh > spin_lock 

struct semaphore {
	raw_spinlock_t lock; //用自旋锁同步
	unsigned int count; //资源计数
	struct list_head wait_list; //等待队列
};

DEFINE_SEMAPHORE(name); //声明信号量，并初始化为1
void sema_init(struct semaphore *sem, in val); //声明信号量，并初始化为val
void down(struct semaphore *sem); //获得信号量，且task不可被中断，除非是致命信号
void down_interruptible(struct semaphore *sem); //获得信号量，task可以被中断
int down_trylock(struct semaphore *sem); //在能够获得信号量时，count--；否则立即返回，不会挂起到等待队列
int down_killable(struct semaphore *sem); //获得信号量，且task可以被kill
void up(struct semaphore *sem); //释放信号量

/* include/linux/mutex.h */
struct mutex {
	atomic_t count;
	spinlock_t wait_lock;
	struct list_head wait_list;
#if defined(CONFIG_DEBUG_MUTEX) || defined(CONFIG_MUTEX_SPIN_ON_OWNER)
	struct task_struct *owner;
#endif
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
	struct optimistic_spin_queue osq; /* Spinner MCS lock */
#endif
};

DEFINE_MUTEX(name); //静态声明互斥锁并初始化状态
void mutex_init(struct mutex *lock); //动态声明互斥锁并初始化状态
void mutex_destory(struct mutex *lock); //销毁该互斥锁
bool mutex_is_locked(struct mutex *lock); //判断互斥锁是否被持有
void mutex_lock(struct mutex *lock); //获得锁，且task不可被中断，除非致命信号
void mutex_unlock(struct mutex *lock); //释放锁
int mutex_trylock(struct mutex *lock); //尝试获得锁，不能获得立即返回
int mutex_lock_interruptible(struct mutex *lock); //获得锁，task可以被中断
int mutex_lock_killable(struct mutex *lock); //获得锁，task可以被kill

/* include/linux/rwsem.h */
struct rw_semaphore {
	long count;
	struct list_head wait_list;
	raw_spinlock_t wait_lock;
#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
	struct optimistic_spin_queue osq; /* Spinner MCS lock */
	struct task_struct *owner;
#endif
};

DECLARE_RWSEM(name); //静态声明并初始化
void init_rwsem(struct rw_semaphore *sem); //动态声明并初始化
void down_read(struct rw_semaphore *sem); //读者获得读写信号量
int down_read_trylock(struct rw_semphore *sem); //读者尝试获得读写信号量，不能获得立即返回
void down_wirte(struct rw_semaphore *sem); //写者获得读写信号量
int down_write_trylock(struct rw_semaphore *sem); //写者尝试获得读写信号量，不能获得立即返回
void up_read(struct rw_semaphore *sem); //读者释放读写信号量
void up_write(struct rw_semaphore *sem); //写者释放读写信号量
void downgrade_write(struct rw_semaphore *sem); //写者身份降为读者

typedef struct {
	arch_rwlock_t raw_lock;
} rwlock_t;
/* 套娃的结构体不写了 */

rwlock_init(lock); //静态声明并初始化

read_lock(lock); //获得读者锁
read_unlock(lock); //释放读者锁
read_trylock(lock); //尝试获得读者锁，不能获得立即返回

write_lock(lock); //获得写者锁
write_unlock(lock); //释放写者锁
write_trylock(lock); //尝试获得写者锁，不能获得立即返回

read_lock_irqsave(lock， flags); //获得读者锁，将标志寄存器内容写入flags；解锁反之
read_unlock_irqrestore(lock, flags);
read_lock_irq(lock);
read_unlock_irq(lock);
read_lock_bh(lock);
read_unlock_bh(lock);

write_lock_irqsave(lock, flags);
write_unlock_irqrestore(lock, flags);
write_lock_irq(lock);
write_unlock_irq(lock);
write_lock_bh(lock);
write_unlock_bh(lock);

write_trylock_irqsave(lock, flags); //将标志寄存器内容存入flags，并尝试获得写者锁，成功获得则关闭中断；失败则恢复标志寄存器，并立即返回

typedef struct {
	struct seqcount seqcount;
	spinlock_t lock;
} seqlock_t;

seqlock_init(x); //声明并初始化顺序锁
DEFINE_SEQLOCK(x); 

void write_seqlock(seqlock_t *sl); //写者获得顺序锁
void write_sequnlock(seqlock_t *sl); //写者释放顺序锁

unsigned read_seqbegin(const seqlock_t *sl); //读取开始前,获得seqlock的写操作次数seqcount
unsigned read_seqretry(const seqlock_t *sl, unsigned start); //读取结束后，判断当前的seqcount是否与start一致

/* 通常读者不需要获得顺序锁，但内核也提供了，实际实习就是spin_lock/unlock */
void read_seqlock_excl(seqlock_t *sl);
void read_sequnlock_excl(seqlock_t *sl);

/* 其他irqsave, irq, bh版本与其他锁类似 */

void rcu_read_lock(void); //读者在读取RCU保护的共享资源时，使用此函数标记它进入临界区
void rcu_read_unlock(void); //与上函数配对使用，表示读者离开临界区

void synchronize_rcu(void); //同步RCU，即：所有的读者已完成读端临界区，写者才可以继续下一步操作。由于该函数会阻塞写者，只能在进程上下文中使用

void call_rcu(struct rcu_head *head, rcu_callback_t func); //将回调函数注册到RCU回调函数链，然后立即返回

rcu_assign_pointer(p, v); //用于RCU指针赋值
rcu_dereference(p); //用于RCU指针取值

void list_add_rcu(struct list_head *new, struct list_head *head); //向RCU注册一个链表结构
void list_del_rcu(struct list_head *entry); //从RCU移除一个链表结构

/* driver/input/input.c为例 */

/* 1. 将共享资源加入RCU保护 */
rcu_assign_pointer(dev->grab, handle);

/* 2. 标记进入临界区 */
rcu_read_lock();

/* 3. 读出临界区，进行操作 */
handle = rcu_dereference(dev->grab);

/* 4. 退出临界区 */
rcu_read_unlock();

/* 5. 释放，然后通知所有写者 */
rcu_assign_pointer(dev->grab, NULL);
synchronize_rcu();