1
// 无保护的链表插入——存在竞态条件
2
void list_add_unsafe(struct list_head *new, struct list_head *head) {
3
    new->next = head->next;       // 步骤 1
4
    head->next->prev = new;       // 步骤 2
5
    head->next = new;             // 步骤 3
6
    new->prev = head;             // 步骤 4
7
}

1
// 自旋锁获取的简化实现
2
static __always_inline int ticket_lock_acquire(arch_spinlock_t *lock)
3
{
4
    // 原子地获取并递增 ticket
5
    unsigned int ticket = atomic_inc_return(&lock->tickets.tail);
6
    // 忙等直到轮到自己
7
    while (atomic_read(&lock->tickets.head) != ticket)
8
        cpu_relax();
9
}

1
int data = 0;
2
bool ready = false;
3

4
// 生产者（CPU 0）
5
void producer(void) {
6
    data = 42;             // 写入数据
7
    smp_store_release(&ready, true);  // Release 写：保证 data 的写入在 ready 之前可见
8
}
9

10
// 消费者（CPU 1）
11
void consumer(void) {
12
    if (smp_load_acquire(&ready)) {   // Acquire 读：保证读取 data 在 ready 之后
13
        assert(data == 42);           // 保证成立
14
    }
15
}

1
// 进程上下文与中断共享数据的正确用法
2
spinlock_t my_lock;
3
int shared_counter;
4

5
// 进程上下文
6
void process_side(void) {
7
    unsigned long flags;
8
    spin_lock_irqsave(&my_lock, flags);  // 保存中断状态并禁用中断
9
    shared_counter++;
10
    spin_unlock_irqrestore(&my_lock, flags);  // 恢复中断状态
11
}
12

13
// 中断上下文
14
irqreturn_t my_interrupt(int irq, void *dev_id) {
15
    spin_lock(&my_lock);  // 中断中中断已自动禁用，无需再禁
16
    shared_counter++;
17
    spin_unlock(&my_lock);
18
    return IRQ_HANDLED;
19
}

1
// include/linux/mcs_spinlock.h（简化）
2
struct mcs_spinlock {
3
    struct mcs_spinlock *next;  // 指向下一个等待者
4
    int locked;                 // 本地自旋变量：1=需要等待，0=获得锁
5
};

1
// kernel/locking/mutex.c（简化）
2
static bool __mutex_optimistic_spin(struct mutex *lock,
3
                                    struct mutex_waiter *waiter)
4
{
5
    // 当持锁者正在当前 CPU 上执行时，自旋等待
6
    while (true) {
7
        // 尝试获取锁
8
        if (atomic_long_try_cmpxchg_acquire(&lock->owner, owner, current))
9
            return true;
10

11
        // 持锁者不在运行？停止自旋，去睡眠
12
        if (!owner_on_cpu(owner))
13
            return false;
14

15
        cpu_relax();
16
    }
17
}

1
// 定义与使用
2
rwlock_t my_rwlock;
3

4
// 读端
5
read_lock(&my_rwlock);
6
    // 读取共享数据——多个读者可并行
7
read_unlock(&my_rwlock);
8

9
// 写端
10
write_lock(&my_rwlock);
11
    // 修改共享数据——排他访问
12
write_unlock(&my_rwlock);

1
// 读者——完全无锁、无屏障
2
rcu_read_lock();          // 仅标记进入读端临界区（preempt_disable）
3
p = rcu_dereference(gp);  // 读取指针（带数据依赖屏障）
4
// 使用 p 指向的数据...
5
rcu_read_unlock();        // 标记退出（preempt_enable）
6

7
// 写者——创建副本，修改副本，替换指针
8
new = kmalloc(sizeof(*old), GFP_KERNEL);
9
*new = *old;              // 复制旧数据
10
new->field = new_value;   // 修改副本
11
rcu_assign_pointer(gp, new);  // 原子替换指针
12
synchronize_rcu();        // 等待所有读者退出
13
kfree(old);               // 安全释放旧数据

1
时间轴：
2
|----读者A进入----读者A退出----|
3
     |----读者B进入----读者B退出----|
4
          |----读者C进入---------读者C退出----|
5
               ^写者替换指针
6
               |<---------- 宽限期 ---------->|
7
                                          ^所有旧读者已退出
8
                                          ^可安全释放旧数据

1
// kernel/rcu/tree.c（简化）
2
void synchronize_rcu(void)
3
{
4
    RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map),
5
                     "Illegal synchronize_rcu() in RCU read-side critical section");
6

7
    if (rcu_blocking_is_gp())
8
        return;  // UP 系统，直接返回
9

10
    // 等待宽限期
11
    wait_rcu_gp(call_rcu);
12
}

1
// 注册回调，宽限期结束后自动调用
2
struct foo {
3
    int a;
4
    struct rcu_head rcu;  // RCU 回调头——必须作为结构体成员
5
};
6

7
static void foo_reclaim(struct rcu_head *rh)
8
{
9
    struct foo *p = container_of(rh, struct foo, rcu);
10
    kfree(p);  // 宽限期结束后安全释放
11
}
12

13
// 写者
14
void foo_update(struct foo **global_ptr, int new_a)
15
{
16
    struct foo *new = kmalloc(sizeof(*new), GFP_KERNEL);
17
    struct foo *old = *global_ptr;
18
    *new = *old;
19
    new->a = new_a;
20
    rcu_assign_pointer(*global_ptr, new);
21
    call_rcu(&old->rcu, foo_reclaim);  // 异步释放
22
}

1
// 用户态 pthread_mutex_lock 的简化实现
2
void futex_lock(atomic_t *futex) {
3
    // 快速路径：无争用，纯用户态
4
    if (atomic_cmpxchg(futex, 0, 1) == 0)
5
        return;  // 获取成功，零系统调用
6

7
    // 慢速路径：有争用，进入内核等待
8
    while (atomic_xchg(futex, 2) != 0)
9
        futex_wait(futex, 2);  // 系统调用：在内核等待
10
}
11

12
void futex_unlock(atomic_t *futex) {
13
    int old = atomic_xchg(futex, 0);
14
    if (old == 2)
15
        futex_wake(futex, 1);  // 系统调用：唤醒一个等待者
16
}

1
kernel/futex/
2
├── core.c          # ：哈希表、等待队列
3
├── pi.c            # 优先级继承（Priority Inheritance）
4
├── requeue.c       # futex_requeue 操作
5
├── waitwake.c      # futex_wait / futex_wake 实现
6
└── futex.h         # 内部头文件

1
// kernel/futex/core.c（简化）
2
static struct futex_hash_bucket *futex_hash(union futex_key *key)
3
{
4
    u32 hash = hash_futex(key);
5
    return &futex_queues[hash & (futex_hashsize - 1)];
6
}
7

8
// futex_wait 的核心逻辑
9
int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,
10
               ktime_t *abs_time, u32 bitset)
11
{
12
    // 1. 验证 *uaddr == val（防止丢失唤醒）
13
    // 2. 将当前任务加入哈希桶等待队列
14
    // 3. 设置 TASK_INTERRUPTIBLE 并调度
15
    // 4. 被唤醒后从等待队列移除
16
}

1
// 使用 PI futex
2
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);

1
// 声明与初始化
2
struct completion my_comp;
3
init_completion(&my_comp);
4

5
// 等待方
6
wait_for_completion(&my_comp);          // 不可中断等待
7
wait_for_completion_interruptible(&my_comp);  // 可中断等待
8
wait_for_completion_timeout(&my_comp, timeout);  // 超时等待
9

10
// 完成方
11
complete(&my_comp);       // 唤醒一个等待者
12
complete_all(&my_comp);   // 唤醒所有等待者

1
// 定义与初始化
2
struct semaphore my_sem;
3
sema_init(&my_sem, 5);  // 初始计数为 5，允许 5 个并发持有者
4

5
// 获取
6
down(&my_sem);                    // 不可中断
7
down_interruptible(&my_sem);      // 可中断
8
down_trylock(&my_sem);            // 非阻塞
9

10
// 释放
11
up(&my_sem);

1
// kernel/locking/lockdep.c（简化逻辑）
2
// 每次加锁时：
3
void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
4
                  int trylock, int read, int check,
5
                  struct lockdep_map *nest_lock, unsigned long ip)
6
{
7
    // 1. 检查当前任务已持有的锁链中是否已包含此锁（AA 死锁）
8
    // 2. 检查新的锁序是否与已有锁序形成环（ABBA 死锁）
9
    // 3. 检查中断上下文使用是否合规
10
    // 4. 将新的锁序关系加入锁序图
11
}

1
# 启用 lockdep
2
echo 1 > /proc/sys/kernel/lockdep
3

4
# 查看锁统计
5
cat /proc/lockdep_stats
6

7
# 查看锁依赖链
8
cat /proc/lockdep_chains
9

10
# 查看最常争用的锁
11
cat /proc/lockdep_stats | grep contentions

1
======================================================
2
WARNING: possible circular locking dependency detected
3
------------------------------------------------------
4
task/1234 is trying to acquire lock:
5
 (&my_lock#2){+.+.}, at: my_function+0x42/0x100
6

7
but task is already holding lock:
8
 (&other_lock){+.+.}, at: other_function+0x1a/0x80
9

10
which lock already depends on the new lock.

1
// 定义 percpu 变量
2
DEFINE_PER_CPU(int, my_counter);
3

4
// 静态定义
5
static DEFINE_PER_CPU(struct my_struct, my_data);
6

7
// 动态分配
8
int __percpu *ptr = alloc_percpu(int);
9

10
// 访问（需禁用抢占）
11
void increment_counter(void) {
12
    preempt_disable();                    // 禁用抢占，防止访问期间被迁移到其他 CPU
13
    this_cpu_inc(my_counter);             // 原子地递增当前 CPU 的副本
14
    preempt_enable();
15
}
16

17
// 安全访问宏（内置抢占保护）
18
this_cpu_inc(my_counter);       // 等价于 preempt_disable + inc + preempt_enable
19
this_cpu_add(my_counter, val);  // 加值
20
this_cpu_read(my_counter);      // 读取

1
percpu 内存布局（SMP 系统）：
2
┌──────────────────────────────────────────────────────┐
3
│ CPU 0 区域    │ CPU 1 区域    │ CPU 2 区域    │ ... │
4
├───────────────┼───────────────┼───────────────┼─────┤
5
│ my_counter    │ my_counter    │ my_counter    │     │
6
│ my_data       │ my_data       │ my_data       │     │
7
│ ...           │ ...           │ ...           │     │
8
└───────────────┴───────────────┴───────────────┴─────┘

1
// 统计所有 CPU 的计数器总和
2
int total = 0;
3
int cpu;
4
for_each_possible_cpu(cpu)
5
    total += per_cpu(my_counter, cpu);

1
# 1. 使用 perf 统计锁争用
2
sudo perf lock record sleep 10
3
sudo perf lock report
4

5
# 2. 查看特定锁的争用情况
6
sudo perf lock record -g -- sleep 5
7
sudo perf lock report -n
8

9
# 3. 使用 BPF 追踪 mutex 锁持锁时间
10
sudo bpftrace -e '
11
kprobe:mutex_lock { @start[tid] = nsecs; }
12
kretprobe:mutex_lock /@start[tid]/ {
13
    @ns[func] = hist(nsecs - @start[tid]);
14
    delete(@start[tid]);
15
}'

1
// race_test.c — 演示竞态条件
2
#include <linux/module.h>
3
#include <linux/kernel.h>
4
#include <linux/kthread.h>
5
#include <linux/atomic.h>
6

7
static int unsafe_counter = 0;
8
static atomic_t safe_counter = ATOMIC_INIT(0);
9

10
static int thread_fn(void *data)
11
{
12
    int i;
13
    for (i = 0; i < 1000000; i++) {
14
        unsafe_counter++;              // 不安全！
15
        atomic_inc(&safe_counter);     // 安全
16
    }
17
    return 0;
18
}
19

20
static int __init race_init(void)
21
{
22
    struct task_struct *t1, *t2;
23

24
    t1 = kthread_run(thread_fn, NULL, "race_thread1");
25
    t2 = kthread_run(thread_fn, NULL, "race_thread2");
26

27
    msleep(3000);  // 等待线程完成
28

29
    pr_info("unsafe_counter = %d (expected 2000000)\n", unsafe_counter);
30
    pr_info("safe_counter = %d (expected 2000000)\n", atomic_read(&safe_counter));
31

32
    return 0;
33
}
34

35
module_init(race_init);
36
MODULE_LICENSE("GPL");

1
# 1. 启用 lockdep
2
echo 1 > /proc/sys/kernel/lockdep
3

4
# 2. 查看锁依赖统计
5
cat /proc/lockdep_stats
6

7
# 3. 查看最常争用的前 20 把锁
8
cat /proc/lockdep_stats | head -20
9

10
# 4. 在 dmesg 中查看 lockdep 警告
11
dmesg | grep "lockdep"

1
# 1. 查看 RCU 统计信息
2
cat /proc/rcu/rcuexp
3
cat /proc/rcu/rcugp
4

5
# 2. 追踪 synchronize_rcu 调用
6
sudo bpftrace -e '
7
kprobe:synchronize_rcu {
8
    printf("synchronize_rcu called from %s\n", kstack);
9
}'
10

11
# 3. 查看 RCU 回调队列长度
12
cat /proc/rcu/rcucb

1
# 1. 查看 percpu 统计信息
2
cat /proc/zoneinfo | grep "percpu"
3

4
# 2. 使用 BPF 观察每个 CPU 的中断计数
5
sudo bpftrace -e '
6
kprobe:handle_irq {
7
    @irq_count[cpu] = count();
8
}'