<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Linux 内核锁机制：原理与实现 on GPUers</title><link>https://gpuers.cn/columns/kernel-locks/</link><description>Recent content in Linux 内核锁机制：原理与实现 on GPUers</description><image><title>GPUers</title><url>https://gpuers.cn/assets/img/og-cover.png</url><link>https://gpuers.cn/assets/img/og-cover.png</link></image><generator>Hugo</generator><language>zh-CN</language><lastBuildDate>Wed, 18 Nov 2026 00:00:00 +0800</lastBuildDate><atom:link href="https://gpuers.cn/columns/kernel-locks/index.xml" rel="self" type="application/rss+xml"/><item><title>lockdep：死锁检测的原理</title><link>https://gpuers.cn/columns/kernel-locks/lockdep/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/lockdep/</guid><description>前十章的每一章几乎都有一节“误用与调试”，反复提到同一个名字：lockdep。它是内核运行时的死锁检测器，能在一次普通运行中——哪怕死锁并未真正发生——就报出潜在的加锁顺序问题。本章拆开它的引擎，看清它凭什么做到“未死先知”。</description><content:encoded><![CDATA[<p>前十章的每一章几乎都有一节“误用与调试”，反复提到同一个名字：lockdep。它是内核运行时的死锁检测器，能在一次普通运行中——哪怕死锁并未真正发生——就报出潜在的加锁顺序问题。本章拆开它的引擎，看清它凭什么做到“未死先知”。</p>
<p>lockdep 代码量不小，本章聚焦其核心数据结构与环检测算法，锚定 <code>kernel/locking/lockdep.c</code>。它默认由 <code>CONFIG_PROVE_LOCKING</code> 开启，是一个纯调试设施，生产内核通常关闭。</p>
<blockquote>
<p>说明：lockdep 与具体锁的实现无关，它挂在所有锁的加锁/解锁路径上做旁路记录与校验，本章不区分锁类型。</p>
</blockquote>
]]></content:encoded></item><item><title>locktorture：锁实现的压力验证</title><link>https://gpuers.cn/columns/kernel-locks/locktorture/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/locktorture/</guid><description>第 11 章的 lockdep 证明的是锁被用对了——加锁顺序无环、配对无误。但还有一个更底层的问题：锁的实现本身正确吗？一把新写的自旋锁或互斥锁，真的能在任意并发下保证互斥、不丢唤醒、不死等吗？这类保证无法靠阅读代码穷尽，只能用高强度并发去逼。</description><content:encoded><![CDATA[<p>第 11 章的 lockdep 证明的是<strong>锁被用对了</strong>——加锁顺序无环、配对无误。但还有一个更底层的问题：锁的<strong>实现本身</strong>正确吗？一把新写的自旋锁或互斥锁，真的能在任意并发下保证互斥、不丢唤醒、不死等吗？这类保证无法靠阅读代码穷尽，只能用高强度并发去逼。locktorture 就是内核为此准备的压力测试框架，也呼应了第 7 章 <code>ww_mutex</code> 用 <code>test-ww_mutex</code> 注入死锁做验证的思路。</p>
<p>本章锚定 <code>kernel/locking/locktorture.c</code>。它是一个内核模块，基于内核通用的 torture 测试框架（与 rcutorture 共用一套基础设施），加载即开跑。</p>
<blockquote>
<p>说明：locktorture 是测试设施，通过模块参数选择被测锁类型与线程数，不参与生产路径。</p>
</blockquote>
]]></content:encoded></item><item><title>mutex：乐观自旋与 handoff</title><link>https://gpuers.cn/columns/kernel-locks/mutex/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/mutex/</guid><description>前四章的锁——spinlock、qrwlock、osqlock——有一个共同的硬约束：争锁失败时只能原地自旋，绝不能睡眠。这决定了它们只适合极短的临界区。可内核里有大量临界区并不短：里面要读写文件、等 DMA、分配大块内存、甚至再去拿别的锁。这些操作动辄耗时几毫秒，若还让别的 CPU 干等着自旋，纯属浪费。</description><content:encoded><![CDATA[<p>前四章的锁——<code>spinlock</code>、<code>qrwlock</code>、<code>osq_lock</code>——有一个共同的硬约束：争锁失败时只能原地自旋，绝不能睡眠。这决定了它们只适合极短的临界区。可内核里有大量临界区并不短：里面要读写文件、等 DMA、分配大块内存、甚至再去拿别的锁。这些操作动辄耗时几毫秒，若还让别的 CPU 干等着自旋，纯属浪费。本章的 <code>mutex</code>（mutual exclusion，互斥锁）正是为此而生——它是内核中<strong>最常用的睡眠锁</strong>：争锁失败时不空转，而是把当前任务挂起、让出 CPU 去干别的，等锁释放时再被唤醒。</p>
<p>但 <code>mutex</code> 并非“一言不合就睡”。睡眠的代价不菲（上下文切换、缓存失效），所以它先借用第 4 章的 <code>osq_lock</code> 做一轮<strong>乐观自旋</strong>：如果持锁者正在别的 CPU 上跑、很可能马上放锁，就先转几圈等它，赌赢了就省下一次睡眠。本章的主线，就是看 <code>mutex</code> 如何用一个 <code>owner</code> 字段身兼数职，如何在自旋与睡眠之间权衡，以及如何用 <strong>handoff</strong> 机制防止等待者被源源不断的“偷锁者”饿死。源码集中在 <code>kernel/locking/mutex.c</code> 与 <code>kernel/locking/mutex.h</code>、<code>include/linux/mutex.h</code>。</p>
<blockquote>
<p>说明：以 x86-64、非 <code>PREEMPT_RT</code> 配置为主线。<code>PREEMPT_RT</code> 下 <code>mutex</code> 的实现会改走 <code>rtmutex</code>，不在本章范围。</p>
</blockquote>
]]></content:encoded></item><item><title>osq_lock：乐观自旋队列</title><link>https://gpuers.cn/columns/kernel-locks/osq-lock/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/osq-lock/</guid><description>前三章的锁都有一个共同点：它们是直接面向使用者的锁——你 spinlock、我 readlock，拿到就进临界区。</description><content:encoded><![CDATA[<p>前三章的锁都有一个共同点：它们是<strong>直接面向使用者</strong>的锁——你 <code>spin_lock</code>、我 <code>read_lock</code>，拿到就进临界区。本章的 <code>osq_lock</code>（optimistic spin queue lock，乐观自旋队列锁）却是个例外：它几乎从不被业务代码直接调用，而是深藏在 <code>mutex</code>（第 5 章）和 <code>rwsem</code>（第 6 章）内部，充当它们<strong>乐观自旋</strong>的公共底座。要理解后两章睡眠锁“为什么明明能睡却先自旋一会儿”，就必须先看懂这把垫在底下的队列锁。它的源码只有一个文件——<code>kernel/locking/osq_lock.c</code>——却浓缩了两个关键思想：一是第 2 章 <code>qspinlock</code> 那套 MCS 队列的“各自本地自旋”，二是本章新增的、<code>qspinlock</code> 所没有的能力——<strong>中途可取消的自旋</strong>。</p>
<blockquote>
<p>说明：以 x86-64 为主线。<code>osq_lock</code> 与第 2 章的 MCS 同源，建议对照 2.7 节阅读；它的直接用户是 <code>mutex</code>/<code>rwsem</code>，本章 4.8 节会点明衔接处。</p>
</blockquote>
]]></content:encoded></item><item><title>RCU 与 SRCU：宽限期驱动的无锁读</title><link>https://gpuers.cn/columns/kernel-locks/rcu-and-srcu/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/rcu-and-srcu/</guid><description>第 8 章的 seqcount 用序号与重试实现了无锁读，但在小结里留了一个伏笔：它只适用于读取值，一旦读侧要顺着指针访问对象，就得叠加 RCU——因为重试能保证读到的值前后一致，却无法保证指针指向的对象在读的过程中没有被释放。</description><content:encoded><![CDATA[<p>第 8 章的 <code>seqcount</code> 用序号与重试实现了无锁读，但在小结里留了一个伏笔：它只适用于<strong>读取值</strong>，一旦读侧要顺着指针访问对象，就得叠加 RCU——因为重试能保证读到的值前后一致，却无法保证指针指向的对象在读的过程中没有被释放。本章补齐这块：RCU（Read-Copy-Update）正是专门解决<strong>对象生命周期</strong>的无锁读机制，它让读者近乎零成本，把全部代价搬到更新者一侧。</p>
<p>RCU 的实现规模庞大，本章只做综述，锚定语义与关键接口，深入的宽限期推进机制在 mmu-notifier 专栏 12.3 展开。本章源码为 <code>include/linux/rcupdate.h</code>、<code>kernel/rcu/tree.c</code> 与 <code>kernel/rcu/srcutree.c</code>。</p>
<blockquote>
<p>说明：以 x86-64、非 <code>PREEMPT_RT</code> 配置为主线。RCU 在不同抢占配置下读侧开销不同，下文以经典（可抢占）语义描述。</p>
</blockquote>
]]></content:encoded></item><item><title>rwlock 与 qrwlock：读者写者的自旋权衡</title><link>https://gpuers.cn/columns/kernel-locks/rwlock-and-qrwlock/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/rwlock-and-qrwlock/</guid><description>第 2 章的 spinlock 把所有争抢者一视同仁：无论只是想读一眼、还是要动手改，都得排队独占。可现实里有一类极常见的场景——读多写少：一份数据被无数次读取，偶尔才更新一回。若读操作彼此之间本就无冲突，却仍被自旋锁串成单行道，多核的并行度就被白白浪费了。</description><content:encoded><![CDATA[<p><a href="https://gpuers.blog.csdn.net/article/details/164263475">第 2 章的 <code>spinlock</code></a> 把所有争抢者一视同仁：无论只是想读一眼、还是要动手改，都得排队独占。可现实里有一类极常见的场景——<strong>读多写少</strong>：一份数据被无数次读取，偶尔才更新一回。若读操作彼此之间本就无冲突，却仍被自旋锁串成单行道，多核的并行度就被白白浪费了。本章的主角 <code>qrwlock</code>（queued read/write lock）正是为此而生：它允许多个读者同时进入临界区共享数据，只在写者出现时才要求独占。它和 <code>spinlock</code> 一样不睡眠、可用于中断上下文，区别只在于把“互斥”细化成了“读共享、写独占”。本章的主线，是看内核如何用<strong>一个 32 位原子字</strong>同时编码读者计数与写者状态，又如何用一个“等待标志”解决读写锁与生俱来的<strong>写者饥饿</strong>难题。</p>
<blockquote>
<p>说明：以 x86-64 为主线，现代内核的 <code>rwlock_t</code> 在架构层统一落到 <code>qrwlock</code>。源码集中在 <code>kernel/locking/qrwlock.c</code> 与 <code>include/asm-generic/qrwlock.h</code>、<code>include/asm-generic/qrwlock_types.h</code>。</p>
</blockquote>
]]></content:encoded></item><item><title>rwsem：读写信号量的计数编码与偷锁</title><link>https://gpuers.cn/columns/kernel-locks/rwsem/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/rwsem/</guid><description>第 5 章的 mutex 是内核最主流的睡眠锁，但它有一个天生的局限：无论读还是写，同一时刻只允许一个任务进入临界区。可现实中有大量数据是读多写少的——进程的地址空间 mm-&amp;gt;mmaplock、文件系统的若干元数据、驱动里的配置表——这些结构大部分时间只被读取，偶尔才被修改。</description><content:encoded><![CDATA[<p><a href="https://gpuers.blog.csdn.net/article/details/164263925">第 5 章的 <code>mutex</code></a> 是内核最主流的睡眠锁，但它有一个天生的局限：无论读还是写，同一时刻只允许一个任务进入临界区。可现实中有大量数据是<strong>读多写少</strong>的——进程的地址空间 <code>mm-&gt;mmap_lock</code>、文件系统的若干元数据、驱动里的配置表——这些结构大部分时间只被读取，偶尔才被修改。若用 <code>mutex</code> 保护，多个只读任务也要一个个排队串行，白白浪费了“读与读本可并行”的机会。第 3 章的 <code>qrwlock</code> 解决了自旋场景下的读写并行，但它不睡眠、只适合极短临界区。当读写临界区较长、需要睡眠时，就轮到本章的 <code>rwsem</code>（读写信号量）出场：它允许<strong>任意多个读者同时持锁</strong>，但写者独占；争锁失败时像 <code>mutex</code> 一样睡眠让出 CPU。</p>
<p>先要澄清一个几乎所有人都被坑过的误会：<code>rwsem</code> 名字里的 “sem” 是 semaphore（信号量），很容易让人以为是计数信号量 <code>semaphore</code> 的读写版本。<strong>并非如此</strong>。现代 <code>rwsem</code> 与 <code>kernel/locking/semaphore.c</code> 毫无实现上的继承关系。真正的血缘是：<code>rwsem</code> 是第 5 章 <code>mutex</code> 的读写版兄弟。它复用了 <code>mutex</code> 的全套设计——一个原子字段做位编码、<code>owner</code> 字段配合乐观自旋、借第 4 章 <code>osq_lock</code> 做底座、用 handoff 防饥饿。</p>
<blockquote>
<p>说明：以 x86-64、64 位、非 <code>PREEMPT_RT</code> 配置为主线。<code>PREEMPT_RT</code> 下 <code>rwsem</code> 会改走 <code>rt_mutex</code> 底座，读者也不再能真正并行，不在本章范围。</p>
</blockquote>
]]></content:encoded></item><item><title>semaphore：最朴素的计数信号量</title><link>https://gpuers.cn/columns/kernel-locks/semaphore/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/semaphore/</guid><description>从这一章起进入扩展篇。核心八篇沿“地基 → 自旋 → 睡眠 → 无锁与特化”走通了主干，本篇回头补一条被刻意搁置的历史支线：semaphore（信号量）。它是 Linux 最古老的睡眠同步原语之一，比第 5 章的 mutex 更早、也更朴素。</description><content:encoded><![CDATA[<p>从这一章起进入扩展篇。核心八篇沿“地基 → 自旋 → 睡眠 → 无锁与特化”走通了主干，本篇回头补一条被刻意搁置的历史支线：<code>semaphore</code>（信号量）。它是 Linux 最古老的睡眠同步原语之一，比第 5 章的 <code>mutex</code> 更早、也更朴素。把它单独拎出来，一是看清 <code>mutex</code> 到底在它之上补了什么，二是彻底收口一个贯穿前几章的误会——<strong><code>rwsem</code> 名字里那个 “sem” 与本章的 <code>semaphore</code> 没有实现上的血缘</strong>：<code>rwsem</code> 属于 <code>mutex</code> 家族（owner 指针、乐观自旋、handoff），而 <code>semaphore</code> 是另一支，结构里连 owner 都没有。</p>
<p><code>semaphore</code> 的实现只有一个源文件，短小到可以一次读完。本章源码为 <code>kernel/locking/semaphore.c</code> 与 <code>include/linux/semaphore.h</code>。</p>
<blockquote>
<p>说明：以 x86-64、非 <code>PREEMPT_RT</code> 配置为主线。<code>semaphore</code> 不随 <code>PREEMPT_RT</code> 变身，其行为在各配置下一致。</p>
</blockquote>
]]></content:encoded></item><item><title>seqlock 与 seqcount：序号驱动的无锁读</title><link>https://gpuers.cn/columns/kernel-locks/seqlock-and-seqcount/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/seqlock-and-seqcount/</guid><description>前面七章，无论自旋还是睡眠、独占还是读写、单锁还是多锁，读者和写者之间总要靠某种“互斥”来协调——读者持锁期间写者必须等，反过来亦然。可有一大类数据，特点是极少被写、却被海量地读，而且读者只想拷走一份一致的快照。系统时钟就是典型：gettimeofday 每秒可能被调用百万次，而 xtime 一秒才更新几百次。</description><content:encoded><![CDATA[<p>前面七章，无论自旋还是睡眠、独占还是读写、单锁还是多锁，读者和写者之间总要靠某种“互斥”来协调——读者持锁期间写者必须等，反过来亦然。可有一大类数据，特点是<strong>极少被写、却被海量地读</strong>，而且读者只想拷走一份一致的快照。系统时钟就是典型：<code>gettimeofday</code> 每秒可能被调用百万次，而 <code>xtime</code> 一秒才更新几百次。若让每个读者都去抢一把读写锁，光是读者之间为了修改锁计数而反复争抢同一条 cache line，就足以拖垮多核扩展性——即便读读之间本不冲突。</p>
<p>本章的 <code>seqcount</code>/<code>seqlock</code> 给出一条与前七章相反的思路：<strong>写者从不被读者阻塞，读者也完全不修改任何共享状态</strong>。它的全部机制凝结成一个序号（sequence）——写者每进出一次临界区就把序号加一，读者在读前读后各看一眼序号：若两次相等、且期间序号为偶，说明这段读取没被写者打断，快照有效；否则重来。读者付出的仅仅是两次读和一次比较，无原子写、无 cache line 争抢，读侧几乎零开销。代价是读者可能<strong>空转重试</strong>——因此它只适合“写极少、读极多、且读取的是可整体重读的值”这一特定场景。</p>
<p><code>seqcount</code> 也印证了第 1 章“锁 = 原子操作 + 屏障 + 等待策略”的公式在这里被推到极端：它几乎不含原子操作（序号自增由写者串行化保证），<strong>核心全在内存屏障</strong>——写侧 <code>smp_wmb</code> 与读侧 <code>smp_rmb</code> 精确配对，保证读者要么看见写者动手前的完整旧态、要么发现序号变化而重试，绝不会读到写到一半的“撕裂”数据。本章源码集中在 <code>include/linux/seqlock.h</code> 与 <code>include/linux/seqlock_types.h</code>。</p>
<blockquote>
<p>说明：以 x86-64、非 <code>PREEMPT_RT</code> 配置为主线。<code>PREEMPT_RT</code> 下带关联锁的 <code>seqcount_LOCKNAME_t</code> 写侧不再关抢占，改由读者检测到写者在途时“获取再释放”关联锁来避免活锁，机理在 8.6 节点出，不展开。</p>
</blockquote>
]]></content:encoded></item><item><title>spinlock 与 qspinlock：从测试-设置到 MCS 队列</title><link>https://gpuers.cn/columns/kernel-locks/spinlock-and-qspinlock/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/spinlock-and-qspinlock/</guid><description>第 1 章把地基打好了：原子操作保证一次读-改-写不可分割，acquire/release 约束临界区不外泄。本章拆解第一把真正的锁——自旋锁。它是内核里最基础、也最常用的互斥原语：拿不到锁的 CPU 不睡眠，而是原地打转（自旋）反复重试，直到锁被释放。正因为不睡眠，它能用在中断处理、持有其它锁等无法调度的上下文里。</description><content:encoded><![CDATA[<p>第 1 章把地基打好了：原子操作保证一次读-改-写不可分割，acquire/release 约束临界区不外泄。本章拆解第一把真正的锁——自旋锁。它是内核里最基础、也最常用的互斥原语：拿不到锁的 CPU 不睡眠，而是原地打转（自旋）反复重试，直到锁被释放。正因为不睡眠，它能用在中断处理、持有其它锁等无法调度的上下文里。但“原地打转”这件事在多核上并不简单——朴素的实现会让所有争抢者挤在同一条缓存行上互相拖累。本章的主线，就是看内核如何从最朴素的 <code>test-and-set</code> 一路演进到 <code>qspinlock</code> 的 MCS 队列，把“所有 CPU 争一条缓存行”降为“每个 CPU 自旋在自己的本地节点上”。</p>
<blockquote>
<p>说明：以 x86-64 为主线，它默认选用 <code>qspinlock</code>；<code>ticket_spinlock</code> 作为“更简单但仍有缓存争用”的对照版本一并剖析。</p>
</blockquote>
]]></content:encoded></item><item><title>ww_mutex：wound/wait 死锁避免</title><link>https://gpuers.cn/columns/kernel-locks/ww-mutex/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/ww-mutex/</guid><description>前面六章讲的每一把锁，关注点都是单独一把锁如何被高效地获取与释放。可现实中有一类棘手场景：一个操作要同时持有许多把锁才能安全推进。最典型的就是 GPU 驱动的命令提交——一次提交往往引用几十上百个缓冲对象（buffer object），每个对象各有一把锁，驱动必须把它们全部锁住，才能一致地检查、迁移、映射这些显存。</description><content:encoded><![CDATA[<p>前面六章讲的每一把锁，关注点都是<strong>单独一把锁</strong>如何被高效地获取与释放。可现实中有一类棘手场景：一个操作要<strong>同时持有许多把锁</strong>才能安全推进。最典型的就是 GPU 驱动的命令提交——一次提交往往引用几十上百个缓冲对象（buffer object），每个对象各有一把锁，驱动必须把它们<strong>全部锁住</strong>，才能一致地检查、迁移、映射这些显存。文件系统的 rename、内存管理的多 VMA 操作也都有类似需求。</p>
<p>一旦要同时拿多把锁，就撞上了并发编程里最经典的幽灵——<strong>ABBA 死锁</strong>：任务甲按“先 A 后 B”的顺序加锁，任务乙按“先 B 后 A”的顺序加锁，两者各持一把、又都在等对方手里那把，于是永久僵持。教科书给出的标准解法是<strong>全局锁序</strong>：约定所有人都按同一个固定顺序（比如按锁的内存地址从小到大）加锁，ABBA 就不可能出现。但这个前提在 GPU 场景里常常不成立——要锁哪些缓冲对象、以什么顺序，取决于用户态提交上来的命令，驱动事先无从得知、也无法强行排序。当“无法预先确定加锁顺序”时，就轮到本章的 <code>ww_mutex</code>（wound/wait mutex，创伤/等待互斥锁）出场：它不强求锁序，而是引入<strong>死锁避免</strong>（deadlock avoidance）算法——给每个“加锁事务”盖一个时间戳，一旦检测到可能成环，就让<strong>较年轻的事务主动退让</strong>，从而保证系统整体永远向前推进。</p>
<p><code>ww_mutex</code> 并不是一把全新的锁，它就<strong>建立在第 5 章的 <code>mutex</code> 之上</strong>：底层的互斥、睡眠、乐观自旋、handoff 全部复用 <code>mutex</code>，<code>ww_mutex</code> 只在其外面包了一层“时间戳 + 退让”的死锁避免逻辑。本章源码主要在 <code>kernel/locking/ww_mutex.h</code>（算法核心）、<code>include/linux/ww_mutex.h</code>（数据结构与 API）、<code>kernel/locking/ww_rt_mutex.c</code> 与 <code>kernel/locking/test-ww_mutex.c</code>。</p>
<blockquote>
<p>说明：以 x86-64、非 <code>PREEMPT_RT</code> 配置为主线，此时 <code>ww_mutex</code> 的底座 <code>WW_MUTEX_BASE</code> 就是第 5 章的 <code>mutex</code>。<code>PREEMPT_RT</code> 下底座换成 <code>rt_mutex</code>，算法逻辑一致，不单独展开。</p>
</blockquote>
]]></content:encoded></item><item><title>原子操作与内存屏障：一切锁的地基</title><link>https://gpuers.cn/columns/kernel-locks/atomics-and-barriers/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0800</pubDate><guid>https://gpuers.cn/columns/kernel-locks/atomics-and-barriers/</guid><description>并发编程里，我们说得最多的词是“锁”，但锁并不是一种凭空存在的原语。把任意一把内核锁拆开，底下永远是同两块地基：原子操作保证一次“读-改-写”不可被打断，内存屏障约束多核之间的可见顺序。</description><content:encoded><![CDATA[<p>并发编程里，我们说得最多的词是“锁”，但锁并不是一种凭空存在的原语。把任意一把内核锁拆开，底下永远是同两块地基：<strong>原子操作</strong>保证一次“读-改-写”不可被打断，<strong>内存屏障</strong>约束多核之间的可见顺序。本章我们暂不讲任何一把具体的锁，而是聚焦这两块地基—因为从第 2 章的 <code>spinlock</code> 到后面的 <code>mutex</code>、<code>rwsem</code>、<code>ww_mutex</code>，每一把锁都只是“<strong>原子操作 + 内存屏障 + 等待策略</strong>”的不同组合。地基不牢，上层锁的正确性无从谈起。</p>
<h2 id="11-锁到底在防什么数据竞争的三种面孔">1.1 锁到底在防什么：数据竞争的三种面孔</h2>
<p>两个 CPU 并发执行 <code>counter++</code>，结果可能小于预期。原因是 <code>counter++</code> 并非一条指令，而是三步：</p>
<pre tabindex="0"><code>load  r, [counter];  读
add   r, 1        ;  改
store [counter], r;  写
</code></pre><p>若两个 CPU 几乎同时读到同一个旧值，各自加一后写回，两次自增只留下一次效果——这是<strong>丢失更新（lost update）</strong>。</p>
<pre class="mermaid">
sequenceDiagram
    participant A as CPU A
    participant M as counter（初值 0）
    participant B as CPU B
    A-&gt;&gt;M: load 读到 0
    B-&gt;&gt;M: load 读到 0
    A-&gt;&gt;A: 0 + 1 = 1
    B-&gt;&gt;B: 0 + 1 = 1
    A-&gt;&gt;M: store 写回 1
    B-&gt;&gt;M: store 写回 1
    Note over M: 两次自增只留下 1，丢失一次更新
</pre>
<p>它是最直观的一种数据竞争，但不是唯一一种。并发缺陷有三种面孔：</p>
<ul>
<li><strong>丢失更新</strong>：多个“读-改-写”交错，部分更新被覆盖。根因是 RMW 不是原子的。</li>
<li><strong>撕裂访问（torn access）</strong>：一次读或写被编译器/硬件拆成多次。一个 64 位变量在某些路径上可能被拆成两个 32 位写，另一个 CPU 就可能读到“写了一半”的值。</li>
<li><strong>乱序可见（reordering）</strong>：即使每个访问本身原子，不同 CPU 观察到的<strong>操作顺序</strong>也可能不同。重排来自两层——编译器在编译期调换无数据依赖的读写，CPU 在运行期通过 store buffer、乱序执行改变全局可见顺序。</li>
</ul>
<p>针对前两种，我们需要<strong>原子操作</strong>；针对第三种，我们需要<strong>内存屏障</strong>。这两件武器贯穿全章。</p>
<h2 id="12-先过编译器这一关read_oncewrite_once-与编译器屏障">1.2 先过编译器这一关：<code>READ_ONCE</code>/<code>WRITE_ONCE</code> 与编译器屏障</h2>
<p>上一节的三种竞争，病根都在多核硬件。但在麻烦真正抵达硬件之前，还站着一个更早出场的角色——编译器。它为了让代码跑得更快，会对我们写下的每一次内存访问做大胆假设，这些假设在单线程里天经地义，搬到多线程就会闯祸。所以本章第一件武器既不是原子指令、也不是硬件屏障，而是这层最轻、也最容易被忽略的防线。</p>
<p>先看一个几乎人人踩过的坑。一个线程原地打转，等另一个线程把标志置起：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="n">flag</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">	<span class="p">;</span>          <span class="cm">/* 等 flag 变成非零 */</span>
</span></span></code></pre></div><p>在编译器看来，这个循环里没有任何代码去改 <code>flag</code>，于是它把 <code>flag</code> 从内存读进寄存器一次，之后每轮都只看寄存器、不再回内存核对。结果是：哪怕另一个线程早已把 <code>flag</code> 置起，这个循环也永远看不到，活活变成一个出不来的死循环。编译器并没有算错，错在我们没有告诉它“这个变量会被别人从背后改动”。</p>
<p>C 语言标准把这种“两个线程不加同步地读写同一个变量”直接定义为<strong>未定义行为</strong>（data race is undefined behavior）。一旦踩中，编译器就有权做任何优化：缓存进寄存器、把多次读合并成一次、甚至整段删掉。要堵住它，我们得有办法对编译器下一道硬命令——“这次访问必须老老实实地、不多不少地打到内存上一次”。内核给出的答案就是 <code>READ_ONCE</code>/<code>WRITE_ONCE</code>，定义于 <code>include/asm-generic/rwonce.h</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define __READ_ONCE(x)	(*(const volatile __unqual_scalar_typeof(x) *)&amp;(x))
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#define READ_ONCE(x)							\
</span></span></span><span class="line"><span class="cl"><span class="cp">({									\
</span></span></span><span class="line"><span class="cl"><span class="cp">	compiletime_assert_rwonce_type(x);				\
</span></span></span><span class="line"><span class="cl"><span class="cp">	__READ_ONCE(x);							\
</span></span></span><span class="line"><span class="cl"><span class="cp">})
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#define __WRITE_ONCE(x, val)						\
</span></span></span><span class="line"><span class="cl"><span class="cp">do {									\
</span></span></span><span class="line"><span class="cl"><span class="cp">	*(volatile typeof(x) *)&amp;(x) = (val);				\
</span></span></span><span class="line"><span class="cl"><span class="cp">} while (0)
</span></span></span></code></pre></div><p>拨开宏的外壳，核心只有一个 <code>volatile</code> 强制转换。<code>volatile</code> 是对编译器下的一道硬命令：“这个地址随时可能被你看不见的力量改写，不许缓存、不许合并、不许省略，每次都给我实打实地去内存走一趟。”于是前面那个死循环只要改成 <code>while (!READ_ONCE(flag))</code>，编译器每一轮都会重新从内存取 <code>flag</code>，标志一置起，循环立刻退出。顺带地，它也堵住了 1.1 说的<strong>撕裂</strong>——<code>volatile</code> 保证这次访问是机器字长内一次完整的读或写，不会被拆成两半。而 <code>compiletime_assert_rwonce_type</code> 在编译期站岗：一旦你拿它去访问超过机器字长、根本无法保证“单次原子”的类型，直接编译报错，把隐患挡在上线之前。</p>
<p><code>READ_ONCE</code>/<code>WRITE_ONCE</code> 管得住“单个变量的单次访问”，却管不了“多条语句之间谁先谁后”。当我们要约束的是“先写完 A，再写 B，两者别被调换”时，就要请出另一件更粗的工具——<strong>编译器屏障</strong>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define barrier() asm volatile(&#34;&#34; ::: &#34;memory&#34;)
</span></span></span></code></pre></div><p>它是一条什么都不执行的空汇编，玄机全在末尾的 <code>&quot;memory&quot;</code>：这相当于对编译器喊一声“走到这条线，内存里的一切都可能已经变了，别把我前面拿到的旧值跨过这里接着用”。编译器于是不敢把屏障两侧的内存访问对调顺序。但一定要记住它的边界——<strong>它只拦得住编译器，拦不住 CPU</strong>。CPU 在运行期照样能乱序，那是 1.5 节硬件屏障要收拾的另一层问题；也正因为 x86 是强序模型，它的 <code>smp_rmb</code>/<code>smp_wmb</code> 才退化成了这条 <code>barrier()</code>。</p>
<p>这里要特别钉死一层认知：本节两件工具都只作用于“源码 → 汇编”的<strong>编译期</strong>，不会生成任何真实的屏障指令。</p>
<ul>
<li><code>READ_ONCE</code>/<code>WRITE_ONCE</code> 靠 <code>volatile</code> 强制转换，约束的是编译器生成访存指令的行为——必须真的发一条 load/store，不许缓存进寄存器，不许合并或删除。它不产生任何额外的 CPU 指令（如 <code>mfence</code>、<code>lock</code> 前缀），生成的仍是一条普通的 <code>mov</code>。</li>
<li><code>barrier()</code> 是空汇编 <code>asm volatile(&quot;&quot; ::: &quot;memory&quot;)</code>，不生成任何机器指令，只是命令编译器不要跨过这一点重排它安排指令的顺序。</li>
</ul>
<p>真正约束运行期 CPU 乱序、会实际生成 <code>LOCK</code> 前缀或 <code>mfence</code>/<code>lfence</code>/<code>sfence</code> 的手段，要到 1.3 节的原子指令与 1.5 节的内存屏障才登场。</p>
<p>把本节两件工具收成一句话：<code>READ_ONCE</code>/<code>WRITE_ONCE</code> 管“<strong>一个变量的这一次访问必须真实发生、且不被撕裂</strong>”，<code>barrier()</code> 管“<strong>编译器不许跨过这一点重排代码</strong>”。它俩联手挡下的，是编译器惹的麻烦；至于多核 CPU 之间的可见顺序，要留到 1.5 节硬件屏障登场才能解决。</p>
<p><strong>本节机制小结</strong>：<code>READ_ONCE</code>/<code>WRITE_ONCE</code> 与 <code>barrier()</code> 是整套原子与锁机制最底层的两块砖，后续每一层都建立在它们之上，本章及后续章节不会再重复解释，但会反复用到——<code>atomic_read</code>/<code>atomic_set</code>（1.3 节）就是 <code>READ_ONCE</code>/<code>WRITE_ONCE</code> 的直接封装；acquire/release 屏障（1.6 节）的 <code>smp_load_acquire</code>/<code>smp_store_release</code> 内部正是 <code>READ_ONCE</code>/<code>WRITE_ONCE</code> 再叠一条 <code>barrier()</code>；而 <code>spinlock</code>、<code>qspinlock</code>、<code>rwsem</code> 在自旋等待锁状态时，读的都是 <code>READ_ONCE(lock-&gt;val)</code> 这类访问，靠的正是本节保证的“每轮真实重读、绝不被优化成死循环”。记住这一点，后面看任何一把锁的源码，都能一眼认出这两块地基。</p>
<h2 id="13-原子类型与原子操作">1.3 原子类型与原子操作</h2>
<p><code>atomic_t</code> 的本体朴素得出人意料，就是一个对齐的 <code>int</code>（<code>include/linux/types.h</code>）：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="kt">int</span> <span class="nf">__aligned</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="kt">int</span><span class="p">))</span> <span class="n">counter</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span> <span class="kt">atomic_t</span><span class="p">;</span>
</span></span></code></pre></div><p>用结构体包一层，是为了<strong>类型安全</strong>：强制所有访问都走 <code>atomic_*</code> API，杜绝裸 <code>v.counter++</code>。但类型安全只是表壳，真正的原子性来自<strong>硬件</strong>。注意，本节是全章第一次跨过软硬件分界线：1.2 节的 <code>READ_ONCE</code>/<code>barrier()</code> 都只在编译期约束编译器、不生成任何额外指令；而从本节的原子 RMW 起，我们第一次真正落到 CPU 指令层——x86 上靠 <code>LOCK</code> 前缀锁定缓存行（现代实现基于缓存一致性协议而非锁总线），由硬件保证一次读-改-写不可被打断。见 <code>arch/x86/include/asm/atomic.h</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">static</span> <span class="n">__always_inline</span> <span class="kt">int</span> <span class="nf">arch_atomic_read</span><span class="p">(</span><span class="k">const</span> <span class="kt">atomic_t</span> <span class="o">*</span><span class="n">v</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="k">return</span> <span class="nf">__READ_ONCE</span><span class="p">((</span><span class="n">v</span><span class="p">)</span><span class="o">-&gt;</span><span class="n">counter</span><span class="p">);</span>      <span class="cm">/* 对齐读本身即原子，无需 LOCK */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">static</span> <span class="n">__always_inline</span> <span class="kt">void</span> <span class="nf">arch_atomic_add</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span> <span class="kt">atomic_t</span> <span class="o">*</span><span class="n">v</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="n">asm_inline</span> <span class="k">volatile</span><span class="p">(</span><span class="n">LOCK_PREFIX</span> <span class="s">&#34;addl %1, %0&#34;</span>
</span></span><span class="line"><span class="cl">		     <span class="o">:</span> <span class="s">&#34;+m&#34;</span> <span class="p">(</span><span class="n">v</span><span class="o">-&gt;</span><span class="n">counter</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">		     <span class="o">:</span> <span class="s">&#34;ir&#34;</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="o">:</span> <span class="s">&#34;memory&#34;</span><span class="p">);</span>   <span class="cm">/* RMW，必须 LOCK */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">static</span> <span class="n">__always_inline</span> <span class="kt">int</span> <span class="nf">arch_atomic_add_return</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span> <span class="kt">atomic_t</span> <span class="o">*</span><span class="n">v</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="k">return</span> <span class="n">i</span> <span class="o">+</span> <span class="nf">xadd</span><span class="p">(</span><span class="o">&amp;</span><span class="n">v</span><span class="o">-&gt;</span><span class="n">counter</span><span class="p">,</span> <span class="n">i</span><span class="p">);</span>       <span class="cm">/* 带返回：xadd 原子取回旧值 */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>注意 <code>read</code>/<code>set</code> 不需要 <code>LOCK</code>——在 x86 上，对齐的字长读写天生原子，只需 <code>READ_ONCE</code>/<code>WRITE_ONCE</code>（回到 1.2 的编译期控制）防编译器捣乱即可；真正需要 <code>LOCK</code> 的是“读-改-写”这类复合操作。</p>
<p>这里请专注代码里的 <code>LOCK_PREFIX</code>，它正是软硬件分界。它定义在 <code>arch/x86/include/asm/alternative.h</code>：在 SMP 内核下展开成真实的 <code>lock</code> 前缀（机器码 <code>0xF0</code>），拼在 <code>addl</code>/<code>cmpxchgl</code> 前面，由 CPU 保证这条指令的原子性；在单处理器（UP）内核下则展开成空串，连前缀都不生成。换句话说，<code>LOCK_PREFIX</code> 是货真价实的一条硬件指令前缀，这与 1.2 里“不生成任何指令”的 <code>barrier()</code>、<code>volatile</code> 形成鲜明对照——<strong>读到这一层，我们已经站在硬件上了</strong>。</p>
<p>据此把原子操作分为三类：</p>
<ul>
<li><strong>纯读写</strong>：<code>atomic_read</code> / <code>atomic_set</code>。</li>
<li><strong>无返回值 RMW</strong>：<code>atomic_add</code> / <code>sub</code> / <code>inc</code> / <code>dec</code>——只改不问结果。</li>
<li><strong>带返回值或带条件的 RMW</strong>：<code>atomic_add_return</code>（走 <code>xadd</code>）、<code>atomic_dec_and_test</code> / <code>inc_and_test</code>（走 <code>GEN_UNARY_RMWcc</code>，直接读 CPU 标志位判断结果是否为零）。第三类是引用计数、无锁算法的主力。</li>
</ul>
<h2 id="14-cmpxchg无锁与锁快速路径的共同基石">1.4 <code>cmpxchg</code>：无锁与锁快速路径的共同基石</h2>
<p>如果说前面的原子操作是零件，<code>cmpxchg</code>（compare-and-swap，CAS）就是把零件拼成任意无锁算法的万能接头。它的语义是：“若内存当前值等于期望的旧值，就写入新值，并返回原值。”x86 实现见 <code>arch/x86/include/asm/cmpxchg.h</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define __raw_cmpxchg(ptr, old, new, size, lock)			\
</span></span></span><span class="line"><span class="cl"><span class="cp">({									\
</span></span></span><span class="line"><span class="cl"><span class="cp">	...								\
</span></span></span><span class="line"><span class="cl"><span class="cp">	case __X86_CASE_L:						\
</span></span></span><span class="line"><span class="cl"><span class="cp">	{								\
</span></span></span><span class="line"><span class="cl"><span class="cp">		volatile u32 *__ptr = (volatile u32 *)(ptr);		\
</span></span></span><span class="line"><span class="cl"><span class="cp">		asm_inline volatile(lock &#34;cmpxchgl %2, %1&#34;		\
</span></span></span><span class="line"><span class="cl"><span class="cp">			     : &#34;=a&#34; (__ret), &#34;+m&#34; (*__ptr)		\
</span></span></span><span class="line"><span class="cl"><span class="cp">			     : &#34;r&#34; (__new), &#34;0&#34; (__old)			\
</span></span></span><span class="line"><span class="cl"><span class="cp">			     : &#34;memory&#34;);				\
</span></span></span><span class="line"><span class="cl"><span class="cp">		break;							\
</span></span></span><span class="line"><span class="cl"><span class="cp">	}								\
</span></span></span><span class="line"><span class="cl"><span class="cp">	...								\
</span></span></span><span class="line"><span class="cl"><span class="cp">})
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#define arch_cmpxchg(ptr, old, new)					\
</span></span></span><span class="line"><span class="cl"><span class="cp">	__cmpxchg(ptr, old, new, sizeof(*(ptr)))   </span><span class="cm">/* 带 LOCK_PREFIX */</span><span class="cp">
</span></span></span></code></pre></div><p>这里的 <code>lock</code> 不是新东西，正是 1.3 那个 <code>LOCK_PREFIX</code>——只不过 <code>__raw_cmpxchg</code> 把它抽成了一个宏参数，好让同一份汇编模板服务两种变体：<code>arch_cmpxchg</code> 走 <code>__cmpxchg</code> 填入 <code>LOCK_PREFIX</code>（SMP 下即真实的 <code>lock</code> 前缀），保证跨 CPU 原子；而 <code>arch_cmpxchg_local</code> 走 <code>__cmpxchg_local</code> 填入空串，只防本 CPU 中断、省掉前缀以求更快。所以 <code>cmpxchg</code> 的原子性依旧落在 1.3 划定的那条硬件线上。</p>
<p>有了 CAS，任何“读出旧值 → 算出新值 → 原子换上”的更新都能写成一个重试循环：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">old</span> <span class="o">=</span> <span class="nf">READ_ONCE</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="k">do</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="n">new</span> <span class="o">=</span> <span class="nf">f</span><span class="p">(</span><span class="n">old</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="nf">try_cmpxchg</span><span class="p">(</span><span class="o">&amp;</span><span class="n">v</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">old</span><span class="p">,</span> <span class="n">new</span><span class="p">));</span>   <span class="cm">/* 失败时 old 被刷新为最新值，重来 */</span>
</span></span></code></pre></div><p>这个范式的重要性怎么强调都不过分：<strong>后续每一把锁的“抢锁快速路径”本质都是一次 CAS</strong>——<code>mutex</code> 用 CAS 把 owner 从 NULL 换成 current，<code>qspinlock</code> 用 CAS 抢 pending 位，<code>rwsem</code> 用 CAS 改 count。理解了这个循环，就理解了所有锁快速路径的骨架。（CAS 有个经典陷阱叫 ABA 问题：值从 A 变 B 再变回 A，CAS 会误判“没变过”；它在 RCU 与无锁数据结构章节再展开。）</p>
<h2 id="15-内存屏障四种基本屏障与-cpu-侧实现">1.5 内存屏障：四种基本屏障与 CPU 侧实现</h2>
<p>原子操作解决了“单个操作不可分割”，但解决不了“多个操作之间的可见顺序”。考虑经典的消息传递：</p>
<pre tabindex="0"><code>CPU 0:  data = 42;          CPU 1:  while (!flag) ;
        flag = 1;                   r = data;
</code></pre><p>即使 <code>data</code> 和 <code>flag</code> 各自的写都是原子的，CPU 1 也可能先看到 <code>flag == 1</code> 却仍读到 <code>data</code> 的旧值——因为两个写在 CPU 0 的 store buffer 里可能乱序刷出，或 CPU 1 的两个读被乱序执行。修好它需要屏障。内核的四种基本屏障与 x86 实现见 <code>arch/x86/include/asm/barrier.h</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define __mb()	asm volatile(&#34;mfence&#34;:::&#34;memory&#34;)   </span><span class="cm">/* 全屏障：读写都不跨越 */</span><span class="cp">
</span></span></span><span class="line"><span class="cl"><span class="cp">#define __rmb()	asm volatile(&#34;lfence&#34;:::&#34;memory&#34;)   </span><span class="cm">/* 读屏障 */</span><span class="cp">
</span></span></span><span class="line"><span class="cl"><span class="cp">#define __wmb()	asm volatile(&#34;sfence&#34; ::: &#34;memory&#34;) </span><span class="cm">/* 写屏障 */</span><span class="cp">
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#define __smp_mb()	asm volatile(&#34;lock addl $0,-4(%%&#34; _ASM_SP &#34;)&#34; ::: &#34;memory&#34;, &#34;cc&#34;)
</span></span></span><span class="line"><span class="cl"><span class="cp">#define __smp_rmb()	dma_rmb()
</span></span></span><span class="line"><span class="cl"><span class="cp">#define __smp_wmb()	barrier()
</span></span></span></code></pre></div><p>几个要点：</p>
<ul>
<li><code>mb</code>/<code>rmb</code>/<code>wmb</code> 用于与设备（MMIO/DMA）交互，映射到 <code>mfence</code>/<code>lfence</code>/<code>sfence</code>。</li>
<li><code>smp_mb</code>/<code>smp_rmb</code>/<code>smp_wmb</code> 用于 CPU 之间。<strong>x86 是强序模型</strong>，普通读读、写写本就不会被 CPU 乱序，所以 <code>smp_rmb</code>/<code>smp_wmb</code> 直接退化成编译器屏障；只有“写后读”这一种重排 x86 允许，因此 <code>smp_mb</code> 必须是真屏障——这里用一条 <code>lock addl $0, -4(%rsp)</code>（对栈顶做一次带锁的空加法）充当全屏障，比 <code>mfence</code> 更快。</li>
<li>弱序架构（ARM64、PowerPC 等）上，<code>smp_rmb</code>/<code>smp_wmb</code> 都是实打实的屏障指令。<strong>正因如此，可移植代码必须显式写屏障，不能依赖 x86 的强序“运气”。</strong></li>
</ul>
<p>顺着 1.3 划下的那条软硬件分界线，这四种屏障也可以按“是否生成硬件指令”归位：</p>
<table>
	<thead>
			<tr>
					<th>屏障</th>
					<th>x86 生成</th>
					<th>是否硬件指令</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><code>mb</code> / <code>rmb</code> / <code>wmb</code></td>
					<td><code>mfence</code> / <code>lfence</code> / <code>sfence</code></td>
					<td>是</td>
			</tr>
			<tr>
					<td><code>smp_mb</code></td>
					<td><code>lock addl $0, -4(%rsp)</code></td>
					<td>是（靠 <code>lock</code> 前缀）</td>
			</tr>
			<tr>
					<td><code>smp_rmb</code> / <code>smp_wmb</code></td>
					<td>退化为 <code>barrier()</code></td>
					<td>否，纯编译期</td>
			</tr>
	</tbody>
</table>
<p>要抓住的关键是：<strong>同一行屏障是否落到硬件指令，取决于目标架构的强弱序</strong>。<code>smp_wmb()</code> 在 x86 上是空的 <code>barrier()</code>（回到 1.2 的编译期控制），换到 ARM64 就变成真实的 <code>dmb</code> 指令。这也解释了上一条要点——你在 x86 上漏写 <code>smp_wmb</code> 往往“碰巧正确”，一移植到弱序架构立刻暴雷。</p>
<h2 id="16-acquire--release锁真正依赖的顺序模型">1.6 acquire / release：锁真正依赖的顺序模型</h2>
<p>全屏障语义强但开销大。锁真正需要的是一种<strong>单向</strong>的、更廉价的顺序：临界区里的访问不许“泄漏”到临界区外。这正是 acquire/release 模型：</p>
<ul>
<li><strong>acquire</strong>（用于加锁）：其后的所有访问，不得被重排到 acquire 之前。</li>
<li><strong>release</strong>（用于解锁）：其前的所有访问，不得被重排到 release 之后。</li>
</ul>
<p>两者一夹，临界区内的读写就被牢牢关在里面。x86 实现见 <code>arch/x86/include/asm/barrier.h</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define __smp_store_release(p, v)					\
</span></span></span><span class="line"><span class="cl"><span class="cp">do {									\
</span></span></span><span class="line"><span class="cl"><span class="cp">	compiletime_assert_atomic_type(*p);				\
</span></span></span><span class="line"><span class="cl"><span class="cp">	barrier();							\
</span></span></span><span class="line"><span class="cl"><span class="cp">	WRITE_ONCE(*p, v);						\
</span></span></span><span class="line"><span class="cl"><span class="cp">} while (0)
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#define __smp_load_acquire(p)						\
</span></span></span><span class="line"><span class="cl"><span class="cp">({									\
</span></span></span><span class="line"><span class="cl"><span class="cp">	typeof(*p) ___p1 = READ_ONCE(*p);				\
</span></span></span><span class="line"><span class="cl"><span class="cp">	compiletime_assert_atomic_type(*p);				\
</span></span></span><span class="line"><span class="cl"><span class="cp">	barrier();							\
</span></span></span><span class="line"><span class="cl"><span class="cp">	___p1;								\
</span></span></span><span class="line"><span class="cl"><span class="cp">})
</span></span></span></code></pre></div><p>在强序的 x86 上，acquire/release <strong>不需要任何真屏障指令</strong>，一个编译器屏障 <code>barrier()</code> 加 <code>READ_ONCE</code>/<code>WRITE_ONCE</code> 就够了——因为硬件已经保证了除“写后读”外的顺序。这解释了 x86 上锁的解锁路径为何可以如此廉价（一次带 release 语义的普通写）。但这仍是 x86 的红利：在 ARM64 这类弱序架构上，acquire/release 会落到专门的硬件指令（如 <code>ldar</code>/<code>stlr</code>），解锁不再是一次普通写——这与 1.5 表格里 <code>smp_wmb</code> 的“x86 退化、弱序变真指令”如出一辙。同理，x86 上原子操作前后的屏障是空的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define __smp_mb__before_atomic()	do { } while (0)
</span></span></span><span class="line"><span class="cl"><span class="cp">#define __smp_mb__after_atomic()	do { } while (0)
</span></span></span></code></pre></div><p>因为带 <code>LOCK</code> 前缀的原子操作本身就是一个全屏障，无需再补。把 lock 理解为 acquire、unlock 理解为 release，是贯穿后续所有锁章节的顺序模型基础。</p>
<h2 id="17-内核原子-api-的三层结构">1.7 内核原子 API 的三层结构</h2>
<p>翻源码时会发现 <code>atomic_add</code> 有好几个名字：<code>arch_atomic_add</code>、<code>raw_atomic_add</code>、<code>atomic_add</code>。这不是重复，而是刻意的三层结构：</p>
<ol>
<li><strong><code>arch_atomic_*</code></strong>：架构相关实现，如上文 x86 的 <code>LOCK_PREFIX &quot;addl&quot;</code>。架构只需实现一个最小集。</li>
<li><strong>fallback 生成层</strong>（<code>include/linux/atomic/atomic-arch-fallback.h</code>）：脚本据最小集自动补全所有变体（如架构没实现 <code>add_return</code>，就用 <code>cmpxchg</code> 循环合成）。</li>
<li><strong><code>atomic_*</code> 插桩层</strong>（<code>include/linux/atomic/atomic-instrumented.h</code>）：对外的公开 API，包一层 KASAN/KCSAN 插桩用于并发缺陷检测。</li>
</ol>
<p>这三层几乎全部由 <code>scripts/atomic/</code> 下的脚本生成。分层的意义：架构移植者只写最小汇编，通用变体与调试插桩一次性交给公共层，既减负又统一。日常写驱动只需用最上层的 <code>atomic_*</code>，无需关心底下两层。</p>
<h2 id="18-把地基拼成一把锁">1.8 把地基拼成一把锁</h2>
<p>现在用本章的零件，手写一把最小自旋锁，验证“锁 = CAS 抢 + release 放 + 等待策略”这个公式：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">struct</span> <span class="n">minimal_lock</span> <span class="p">{</span> <span class="kt">atomic_t</span> <span class="n">locked</span><span class="p">;</span> <span class="p">};</span>   <span class="cm">/* 0=空闲 1=占用 */</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">static</span> <span class="kt">void</span> <span class="nf">minimal_lock</span><span class="p">(</span><span class="k">struct</span> <span class="n">minimal_lock</span> <span class="o">*</span><span class="n">l</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="kt">int</span> <span class="n">expected</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">	<span class="k">do</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">		<span class="n">expected</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">		<span class="cm">/* CAS 抢锁：把 0 换成 1，成功即获得锁（acquire 语义） */</span>
</span></span><span class="line"><span class="cl">	<span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="nf">atomic_try_cmpxchg_acquire</span><span class="p">(</span><span class="o">&amp;</span><span class="n">l</span><span class="o">-&gt;</span><span class="n">locked</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">expected</span><span class="p">,</span> <span class="mi">1</span><span class="p">));</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">static</span> <span class="kt">void</span> <span class="nf">minimal_unlock</span><span class="p">(</span><span class="k">struct</span> <span class="n">minimal_lock</span> <span class="o">*</span><span class="n">l</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="cm">/* release 语义写回 0，保证临界区内的写都已对他人可见 */</span>
</span></span><span class="line"><span class="cl">	<span class="nf">atomic_set_release</span><span class="p">(</span><span class="o">&amp;</span><span class="n">l</span><span class="o">-&gt;</span><span class="n">locked</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>逐项对照：<code>atomic_try_cmpxchg_acquire</code> 是 1.4 的 CAS + 1.6 的 acquire；<code>atomic_set_release</code> 是 1.6 的 release；<code>do-while</code> 里的空转就是“等待策略”。这把锁能用，但它的等待策略太原始——所有争抢者都在同一个 <code>locked</code> 上自旋写，制造大量缓存行颠簸（cache-line bouncing）。第 2 章的 <code>qspinlock</code> 会把这个“裸自旋”升级成 MCS 队列，让每个等待者自旋在自己的本地节点上。这正是从“能用的锁”到“可扩展的锁”的分水岭。</p>
<h2 id="19-误用与调试">1.9 误用与调试</h2>
<p>地基层最常见的坑：</p>
<ul>
<li><strong>把裸 <code>v++</code> 当原子</strong>：多核下必丢更新，改用 <code>atomic_inc</code> 或 <code>cmpxchg</code> 循环。</li>
<li><strong>漏 <code>READ_ONCE</code>/<code>WRITE_ONCE</code></strong>：轮询共享标志时写 <code>while (!flag)</code>，编译器可能把 <code>flag</code> 提进寄存器变成死循环；应写 <code>while (!READ_ONCE(flag))</code>。</li>
<li><strong>屏障不配对</strong>：<code>smp_store_release</code> 的写方必须有 <code>smp_load_acquire</code> 的读方与之配对，单边屏障等于没有顺序保证。消息传递两端都要设屏障。</li>
<li><strong>误信 x86 强序</strong>：在 x86 上漏写 <code>smp_rmb</code>/<code>smp_wmb</code> 往往“碰巧正确”，一移植到 ARM64 立即暴雷。写可移植代码要按弱序模型思考。</li>
</ul>
<p>调试手段：开 <code>CONFIG_KCSAN</code> 做运行时数据竞争检测，它能抓出绝大多数漏加 <code>READ_ONCE</code>/原子化的并发访问；涉及复杂顺序推理时，<code>Documentation/memory-barriers.txt</code> 是内核内部的权威参考，<code>tools/memory-model/</code> 下还有可对拍的形式化模型（LKMM）。锁序层面的死锁检测（lockdep）留到工具章。</p>
<hr>
<h2 id="本章小结">本章小结</h2>
<p>一切锁都建立在两块地基上：<strong>原子操作</strong>用 <code>LOCK</code> 前缀 / <code>cmpxchg</code> 保证“读-改-写”不可分割，解决丢失更新与撕裂；<strong>内存屏障</strong>约束多核可见顺序，其中 acquire/release 这对单向屏障恰好构成“临界区不外泄”的最小充分模型——lock 即 acquire，unlock 即 release。<code>READ_ONCE</code>/<code>WRITE_ONCE</code> 守住单次访问的原子与不可优化，<code>cmpxchg</code> 则是所有锁快速路径与无锁算法的共同接头。x86 的强序模型让许多屏障退化为空，但正确的心智模型应按弱序建立。带着“锁 = 原子 + 屏障 + 等待策略”这个公式，下一章我们拆解第一把真正的锁——从最朴素的 <code>spinlock</code> 到用 MCS 队列消除争用的 <code>qspinlock</code>。</p>
]]></content:encoded></item></channel></rss>