同步---自旋锁

1 自旋锁的基本概念

自旋锁最多只能被一个可执行线程持有，如果一个执行线程试图获得一个已经被使用的自旋锁，那么该线程就会一直进行自旋，等待锁重新可用。在任何时刻，自旋锁都可以防止多余一个的执行线程同时进入临界区。

Linux内核实现的自旋锁是不可递归的，如果你请求一个你已经持有的自旋锁，那么你将会自旋，等待释放这个锁，由于自旋，释放这个锁的操作不会被执行，所以会一直处于自旋忙等待中，于是就被锁死了。

自旋锁可以在中断处理程序中使用。在中断处理程序中使用自旋锁时，一定要在获取锁之前，首先禁止本地中断（当前处理器上的中断请求），否则，中断处理程序就会打断正持有锁的内核代码，有可能试图去争用这个已经被持有的自旋锁，这样一来，中断处理程序就会自旋，但是锁的持有者在这个中断处理程序执行完毕前不可能运行，会造成死锁。注意，需要关闭的只是当前处理器上的中断，如果中断发生在不同的处理器上，即使中断处理程序在同一锁上自旋，也不会妨碍锁的持有者最终释放锁。

自旋锁的实现和体系结构体密切相关，代码往往通过汇编实现，这些与体系结构相关的代码定义在文件asm/spinlock.h中，实际需要用到的接口定义在文件linux/spinlock.h中，内核提供了对自旋锁的操作接口：

2 自旋锁在内核的实现

spinlock_t

自旋锁用spinlock_t的实例表示，spinlock_t定义在include/linux/spinlock_types.h

typedef struct spinlock {
	union {
		struct raw_spinlock rlock;

#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
		struct {
			u8 __padding[LOCK_PADSIZE];
			struct lockdep_map dep_map;
		};
#endif
	};
} spinlock_t;

spinlock_t由raw_spinlock表示，该类型和spinlock_t定义在同一个文件中：

typedef struct raw_spinlock {
	arch_spinlock_t raw_lock;
#ifdef CONFIG_GENERIC_LOCKBREAK
	unsigned int break_lock;
#endif
#ifdef CONFIG_DEBUG_SPINLOCK
	unsigned int magic, owner_cpu;
	void *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map dep_map;
#endif
} raw_spinlock_t;

raw_spinlock由arch_spinlock_t 表示，arch_spinlock_t的实现与体系结构相关，所以spinlock_t的实现与体系结构相关，我们看arm实现的代码，在文件arch/arm/include/asm/spinlock_types.h中：

typedef struct {
	union {
		u32 slock;
		struct __raw_tickets {
#ifdef __ARMEB__
			u16 next;
			u16 owner;
#else
			u16 owner;
			u16 next;
#endif
		} tickets;
	};
} arch_spinlock_t;

owner表示持有这个数字的thread可以获得自旋锁，next表示如果后续再有thread请求获取这个自旋锁，就给他分配这个数字。

spinlock的实现原理：

1. 刚开始owner=next=0
2. 第一个thread获取spinlock，可获取成功，此时owner=0，next=0
3. 第二个thread获取spinlock，如果第一个thread还没有释放spinlock，则next++，next变为1
4. 第三个thread获取spinlock，如果第一个thread还没有释放spinlock，则next++，next就变为2
5. 此时第一个thread释放spinlock，则执行owner++，owner=1
6. 虽然此时第二个thread和第三个thread都在等待spinlock，但是因为第二个thread的next=owner，所以第二个thread可以获取spinlock，第三个spinlock继续等待

这样保证了spinlock的唤醒机制是先到先唤醒，后到后唤醒，保证了公平性。

spin_lock_init

spin_lock_init的定义在include/linux/spinlock.h中

#define spin_lock_init(_lock)				\
do {							\
	spinlock_check(_lock);				\
	raw_spin_lock_init(&(_lock)->rlock);		\
} while (0)

spin_lock_init只是对_lock做了一些检查，我们看raw_spin_lock_init的具体实现，只对spinlock_t中的rlock的初始化。raw_spin_lock_init的实现如下，lock是struct raw_spinlock类型

# define raw_spin_lock_init(lock)				\
	do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0)
#endif

#define __RAW_SPIN_LOCK_UNLOCKED(lockname)	\
	(raw_spinlock_t) __RAW_SPIN_LOCK_INITIALIZER(lockname)

#define __RAW_SPIN_LOCK_INITIALIZER(lockname)	\
	{					\
	.raw_lock = __ARCH_SPIN_LOCK_UNLOCKED,	\
	SPIN_DEBUG_INIT(lockname)		\
	SPIN_DEP_MAP_INIT(lockname) }

__ARCH_SPIN_LOCK_UNLOCKED的值与体系架构有关，在arm架构上:

#define __ARCH_SPIN_LOCK_UNLOCKED	{ { 0 } }

SPIN_DEBUG_INIT(lockname)、SPIN_DEP_MAP_INIT(lockname)是为了调试的，如果不调试什么都不做，所以spin_lock_init只是将互斥锁设置为没有被锁住的状态，即raw_lock的值设为__ARCH_SPIN_LOCK_UNLOCKED

spin_lock

spin_lock的实现在include/linux/spinlock.h中

static __always_inline void spin_lock(spinlock_t *lock)
{
	raw_spin_lock(&lock->rlock);
}

#define raw_spin_lock(lock)	_raw_spin_lock(lock)

spin_lock在单核（up）和多核（smp）的实现不同。

up

在一个处理器下，在文件include/linux/spinlock_api_up.h中定义

#define _raw_spin_lock(lock)			__LOCK(lock)
#define __LOCK(lock) \
  do { preempt_disable(); ___LOCK(lock); } while (0)

只是关闭了抢占功能

smp

在多处理器下，在文件include/linux/spinlock_api_smp.h中定义

#define _raw_spin_lock(lock) __raw_spin_lock(lock)

static inline void __raw_spin_lock(raw_spinlock_t *lock)
{
	preempt_disable();
	spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
	LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

__raw_spin_lock的实现靠do_raw_spin_lock

void do_raw_spin_lock(raw_spinlock_t *lock)
{
	debug_spin_lock_before(lock);
	arch_spin_lock(&lock->raw_lock);
	debug_spin_lock_after(lock);
}

可以看到do_raw_spin_lock的实现与体系结构有关，因为调用了arch_spin_lock，arch_spin_lock中会将next值加1，然后一直判断next和onwer是否相同，如果相同，则获取锁，进入临界区执行，否则会一直判断

所以spin_lock首先会禁止抢占，接着看能不能获得锁，如果能够获得锁，则进入临界区，不能获得，则一直判断，直到可以进去临界区。

spin_unlock

spin_unlock定义在include/linux/spinlock.h中

static __always_inline void spin_unlock(spinlock_t *lock)
{
	raw_spin_unlock(&lock->rlock);
}
#define raw_spin_unlock(lock)		_raw_spin_unlock(lock)

_raw_spin_unlock在多处理器(SMP)和单处理器（UP）的实现不同

up

在include/linux/spinlock_api_up.h中

#define _raw_spin_unlock(lock)			__UNLOCK(lock)

#define __UNLOCK(lock) \
  do { preempt_enable(); ___UNLOCK(lock); } while (0)

仅仅允许抢占

smp

#define _raw_spin_unlock(lock) __raw_spin_unlock(lock)
static inline void __raw_spin_unlock(raw_spinlock_t *lock)
{
	spin_release(&lock->dep_map, 1, _RET_IP_);
	do_raw_spin_unlock(lock);
	preempt_enable();
}

spin_unlock在单处理器下，把抢占设为允许，在多处理器下，先将owner增加1，然后把抢占设为允许