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_LOCKBREAKunsigned int break_lock;
#endif
#ifdef CONFIG_DEBUG_SPINLOCKunsigned int magic, owner_cpu;void *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOCstruct 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;
#elseu16 owner;u16 next;
#endif} tickets;};
} arch_spinlock_t;
owner表示持有这个数字的thread可以获得自旋锁，next表示如果后续再有thread请求获取这个自旋锁，就给他分配这个数字。
spinlock的实现原理：
- 刚开始owner=next=0
- 第一个thread获取spinlock，可获取成功，此时owner=0，next=0
- 第二个thread获取spinlock，如果第一个thread还没有释放spinlock，则next++，next变为1
- 第三个thread获取spinlock，如果第一个thread还没有释放spinlock，则next++，next就变为2
- 此时第一个thread释放spinlock，则执行owner++，owner=1
- 虽然此时第二个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，然后把抢占设为允许
