【原創】linux spinlock/rwlock/seqlock原理剖析（基於ARM64）

背景

• Read the fucking source code! --By 魯迅
• A picture is worth a thousand words. --By 高爾基

說明：

1. Kernel版本：4.14
2. ARM64處理器，Contex-A53，雙核
3. 使用工具：Source Insight 3.5， Visio

1. 概述

吹起並發機制研究的進攻號角了！

作為第一篇文章，應該提綱挈領的介紹下並發。
什么是並發，並發就是：你有兩個兒子，同時搶一個玩具玩，你一巴掌打在你大兒子手上，小兒子拿到了玩具。
並發是指多個執行流訪問同一個資源，並發引起競態。

來張圖吧：

圖中每一種顏色代表一種競態情況，主要歸結為三類：

1. 進程與進程之間：單核上的搶占，多核上的SMP；
2. 進程與中斷之間：中斷又包含了上半部與下半部，中斷總是能打斷進程的執行流；
3. 中斷與中斷之間：外設的中斷可以路由到不同的CPU上，它們之間也可能帶來競態；

目前內核中提供了很多機制來處理並發問題，spinlock就是其中一種。

spinlock，就是大家熟知的自旋鎖，它的特點是自旋鎖保護的區域不允許睡眠，可以用在中斷上下文中。自旋鎖獲取不到時，CPU會忙等待，並循環測試等待條件。自旋鎖一般用於保護很短的臨界區。

下文將進一步揭開神秘的面紗。

2. spinlock原理分析

2.1 spin_lock/spin_unlock

先看一下函數調用流程：

• spin_lock操作中，關閉了搶占，也就是其他進程無法再來搶占當前進程了；
• spin_lock函數中，關鍵邏輯需要依賴於體系結構的實現，也就是arch_spin_lock函數；
• spin_unlock函數中，關鍵邏輯需要依賴於體系結構的實現，也就是arch_spin_unlock函數；

直接看ARM64中這個arch_spin_lock/arch_spin_unlock函數的實現吧：

static inline void arch_spin_lock(arch_spinlock_t *lock)
{
	unsigned int tmp;
	arch_spinlock_t lockval, newval;

	asm volatile(
	/* Atomically increment the next ticket. */
	ARM64_LSE_ATOMIC_INSN(
	/* LL/SC */
"	prfm	pstl1strm, %3\n"
"1:	ldaxr	%w0, %3\n"
"	add	%w1, %w0, %w5\n"
"	stxr	%w2, %w1, %3\n"
"	cbnz	%w2, 1b\n",
	/* LSE atomics */
"	mov	%w2, %w5\n"
"	ldadda	%w2, %w0, %3\n"
	__nops(3)
	)

	/* Did we get the lock? */
"	eor	%w1, %w0, %w0, ror #16\n"
"	cbz	%w1, 3f\n"
	/*
	 * No: spin on the owner. Send a local event to avoid missing an
	 * unlock before the exclusive load.
	 */
"	sevl\n"
"2:	wfe\n"
"	ldaxrh	%w2, %4\n"
"	eor	%w1, %w2, %w0, lsr #16\n"
"	cbnz	%w1, 2b\n"
	/* We got the lock. Critical section starts here. */
"3:"
	: "=&r" (lockval), "=&r" (newval), "=&r" (tmp), "+Q" (*lock)
	: "Q" (lock->owner), "I" (1 << TICKET_SHIFT)
	: "memory");
}

static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
	unsigned long tmp;

	asm volatile(ARM64_LSE_ATOMIC_INSN(
	/* LL/SC */
	"	ldrh	%w1, %0\n"
	"	add	%w1, %w1, #1\n"
	"	stlrh	%w1, %0",
	/* LSE atomics */
	"	mov	%w1, #1\n"
	"	staddlh	%w1, %0\n"
	__nops(1))
	: "=Q" (lock->owner), "=&r" (tmp)
	:
	: "memory");
}

spinlock的核心思想是基於tickets的機制：

1. 每個鎖的數據結構arch_spinlock_t中維護兩個字段：next和owner，只有當next和owner相等時才能獲取鎖；
2. 每個進程在獲取鎖的時候，next值會增加，當進程在釋放鎖的時候owner值會增加；
3. 如果有多個進程在爭搶鎖的時候，看起來就像是一個排隊系統，FIFO ticket spinlock；

上邊的代碼中，核心邏輯在於asm volatile()內聯匯編中，有點迷糊嗎？把核心邏輯翻譯成C語言，類似於下邊：

• asm volatile內聯匯編中，有很多獨占的操作指令，只有基於指令的獨占操作，才能保證軟件上的互斥，簡單介紹如下：

  1. ldaxr：Load-Acquire Exclusive Register derives an address from a base register value, loads a 32-bit word or 64-bit doubleword from memory, and writes it to a register，從內存地址中讀取值到寄存器中，獨占訪問；
  2. stxr：Store Exclusive Register stores a 32-bit or a 64-bit doubleword from a register to memory if the PE has exclusive access to the memory address，將寄存器中的值寫入到內存中，並需要返回是否獨占訪問成功；
  3. eor：Bitwise Exclusive OR，執行獨占的按位或操作；
  4. ldadda：Atomic add on word or doubleword in memory atomically loads a 32-bit word or 64-bit doubleword from memory, adds the value held in a register to it, and stores the result back to memory，原子的將內存中的數據進行加值處理，並將結果寫回到內存中；

• 此外，還需要提醒一點的是，在arch_spin_lock中，當自旋等待時，會執行WFE指令，這條指令會讓CPU處於低功耗的狀態，其他CPU可以通過SEV指令來喚醒當前CPU。

如果說了這么多，你還是沒有明白，那就再來一張圖吧：

2.2 spin_lock_irq/spin_lock_bh

自旋鎖還有另外兩種形式，那就是在持有鎖的時候，不僅僅關掉搶占，還會把本地的中斷關掉，或者把下半部關掉（本質上是把軟中斷關掉）。
這種鎖用來保護臨界資源既會被進程訪問，也會被中斷訪問的情況。

看一下調用流程圖：

• 可以看到這兩個函數中，實際鎖的機制實現跟spin_lock是一樣的；
• 額外提一句，spin_lock_irq還有一種變種形式spin_lock_irqsave，該函數會將當前處理器的硬件中斷狀態保存下來；

__local_bh_disable_ip是怎么實現的呢，貌似也沒有看到關搶占？有必要前情回顧一下了，如果看過之前的文章的朋友，應該見過下邊這張圖片：

• thread_info->preempt_count值就維護了各種狀態，針對該值的加減操作，就可以進行狀態的控制；

3. rwlock讀寫鎖

• 讀寫鎖是自旋鎖的一種變種，分為讀鎖和寫鎖，有以下特點：
  1. 可以多個讀者同時進入臨界區；
  2. 讀者與寫者互斥；
  3. 寫者與寫者互斥；

先看流程分析圖：

看一下arch_read_lock/arch_read_unlock/arch_write_lock/arch_write_unlock源代碼：

static inline void arch_read_lock(arch_rwlock_t *rw)
{
	unsigned int tmp, tmp2;

	asm volatile(
	"	sevl\n"
	ARM64_LSE_ATOMIC_INSN(
	/* LL/SC */
	"1:	wfe\n"
	"2:	ldaxr	%w0, %2\n"
	"	add	%w0, %w0, #1\n"
	"	tbnz	%w0, #31, 1b\n"
	"	stxr	%w1, %w0, %2\n"
	"	cbnz	%w1, 2b\n"
	__nops(1),
	/* LSE atomics */
	"1:	wfe\n"
	"2:	ldxr	%w0, %2\n"
	"	adds	%w1, %w0, #1\n"
	"	tbnz	%w1, #31, 1b\n"
	"	casa	%w0, %w1, %2\n"
	"	sbc	%w0, %w1, %w0\n"
	"	cbnz	%w0, 2b")
	: "=&r" (tmp), "=&r" (tmp2), "+Q" (rw->lock)
	:
	: "cc", "memory");
}

static inline void arch_read_unlock(arch_rwlock_t *rw)
{
	unsigned int tmp, tmp2;

	asm volatile(ARM64_LSE_ATOMIC_INSN(
	/* LL/SC */
	"1:	ldxr	%w0, %2\n"
	"	sub	%w0, %w0, #1\n"
	"	stlxr	%w1, %w0, %2\n"
	"	cbnz	%w1, 1b",
	/* LSE atomics */
	"	movn	%w0, #0\n"
	"	staddl	%w0, %2\n"
	__nops(2))
	: "=&r" (tmp), "=&r" (tmp2), "+Q" (rw->lock)
	:
	: "memory");
}

static inline void arch_write_lock(arch_rwlock_t *rw)
{
	unsigned int tmp;

	asm volatile(ARM64_LSE_ATOMIC_INSN(
	/* LL/SC */
	"	sevl\n"
	"1:	wfe\n"
	"2:	ldaxr	%w0, %1\n"
	"	cbnz	%w0, 1b\n"
	"	stxr	%w0, %w2, %1\n"
	"	cbnz	%w0, 2b\n"
	__nops(1),
	/* LSE atomics */
	"1:	mov	%w0, wzr\n"
	"2:	casa	%w0, %w2, %1\n"
	"	cbz	%w0, 3f\n"
	"	ldxr	%w0, %1\n"
	"	cbz	%w0, 2b\n"
	"	wfe\n"
	"	b	1b\n"
	"3:")
	: "=&r" (tmp), "+Q" (rw->lock)
	: "r" (0x80000000)
	: "memory");
}

static inline void arch_write_unlock(arch_rwlock_t *rw)
{
	asm volatile(ARM64_LSE_ATOMIC_INSN(
	"	stlr	wzr, %0",
	"	swpl	wzr, wzr, %0")
	: "=Q" (rw->lock) :: "memory");
}

知道你們不愛看匯編代碼，那么翻譯成C語言的偽代碼看看吧：

• 讀寫鎖數據結構arch_rwlock_t中只維護了一個字段：volatile unsigned int lock，其中bit[31]用於寫鎖的標記，bit[30:0]用於讀鎖的統計；
• 讀者在獲取讀鎖的時候，高位bit[31]如果為1，表明正有寫者在訪問臨界區，這時候會進入自旋的狀態，如果沒有寫者訪問，那么直接去自加rw->lock的值，從邏輯中可以看出，是支持多個讀者同時訪問的；
• 讀者在釋放鎖的時候，直接將rw->lock自減1即可；
• 寫者在獲取鎖的時候，判斷rw->lock的值是否為0，這個條件顯得更為苛刻，也就是只要有其他讀者或者寫者訪問，那么都將進入自旋，沒錯，它確實很霸道，只能自己一個人持有；
• 寫者在釋放鎖的時候，很簡單，直接將rw->lock值清零即可；
• 缺點：由於讀者的判斷條件很苛刻，假設出現了接二連三的讀者來訪問臨界區，那么rw->lock的值將一直不為0，也就是會把寫者活活的氣死，噢，是活活的餓死。

讀寫鎖當然也有類似於自旋鎖的關中斷、關底半部的形式：read_lock_irq/read_lock_bh/write_lock_irq/write_lock_bh，原理都類似，不再贅述了。

4. seqlock順序鎖

• 順序鎖也區分讀者與寫者，它的優點是不會把寫者給餓死。

來看一下流程圖：

• 順序鎖的讀鎖有三種形式：
  1. 無加鎖訪問，讀者在讀臨界區之前，先讀取序列號，退出臨界區操作后再讀取序列號進行比較，如果發現不相等，說明被寫者更新內容了，需要重新再讀取臨界區，所以這種情況下可能給讀者帶來的開銷會大一些；
  2. 加鎖訪問，實際是spin_lock/spin_unlock，僅僅是接口包裝了一下而已，因此對讀和寫都是互斥的；
  3. 在形式1和形式2中動態選擇，如果有寫者在寫臨界區，讀者化身為自旋鎖，沒有寫者在寫臨界區，則化身為順序無鎖訪問；
• 順序鎖的寫鎖，只有一種形式，本質上是用自旋鎖來保護臨界區，然后再把序號值自加處理；
• 順序鎖也有一些局限的地方，比如采用讀者的形式1的話，臨界區中存在地址（指針）操作，如果寫者把地址進行了修改，那就可能造成訪問錯誤了；
• 說明一下流程圖中的smp_rmb/smp_wmb，這兩個函數是內存屏障操作，作用是告訴編譯器內存中的值已經改變，之前對內存的緩存（緩存到寄存器）都需要拋棄，屏障之后的內存操作需要重新從內存load，而不能使用之前寄存器緩存的值，內存屏障就像是代碼中一道不可逾越的屏障，屏障之前的load/store指令不能跑到屏障的后邊，同理，后邊的也不能跑到前邊；
• 順序鎖也同樣存在關中斷和關下半部的形式，原理基本都是一致的，不再啰嗦了。

最近在項目中，遇到了RCU Stall的問題，下一個topic就先來看看RCU吧，其他的並發機制都會在路上，Just keep growing and fuck everthing else，收工！
歡迎關注公眾號，不定期發布Linux內核機制探索文檔。