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的實現原理：

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，然后把搶占設為允許