内核并发原语与 RCU 机制

if (in_atomic() || irqs_disabled()) {
    /* 只能使用自旋锁，不能调用可能睡眠的函数 */
}

#include <linux/atomic.h>

static atomic_t refcount = ATOMIC_INIT(0);

atomic_inc(&refcount);
atomic_dec_and_test(&refcount);    /* 为 0 说明对象可释放 */
atomic_cmpxchg(&refcount, 0, 1);   /* CAS */

static struct config cfg = { .mode = 0, .timeout = 100 };

int mode = READ_ONCE(cfg.mode);    /* 防止读取被拆分或合并 */
WRITE_ONCE(cfg.mode, 1);           /* 防止写入被撕裂 */

data = 42;                        /* 生产者 */
smp_wmb();                        /* data 先于 flag 可见 */
WRITE_ONCE(flag, 1);

if (READ_ONCE(flag)) {            /* 消费者 */
    smp_rmb();                    /* 读到 flag 后再读 data */
    printk("data=%d\n", data);
}

static DEFINE_SPINLOCK(stat_lock);
static unsigned long packets;

unsigned long flags;
spin_lock_irqsave(&stat_lock, flags);   /* 通用选择：保存并恢复中断状态 */
packets++;
spin_unlock_irqrestore(&stat_lock, flags);

static DEFINE_MUTEX(dev_lock);

if (mutex_lock_interruptible(&dev_lock))
    return -ERESTARTSYS;      /* 被信号打断 */
do_ioctl(f, cmd, arg);
mutex_unlock(&dev_lock);

#include <linux/rtmutex.h>
static DEFINE_RT_MUTEX(rt_lock);

rt_mutex_lock(&rt_lock);     /* 期间持有者被提升到当前任务的优先级 */
rt_mutex_unlock(&rt_lock);

static DECLARE_RWSEM(cfg_sem);

down_read(&cfg_sem);         /* 读侧，可并发 */
val = cfg.value;
up_read(&cfg_sem);

down_write(&cfg_sem);        /* 写侧，独占 */
cfg.value = new_val;
up_write(&cfg_sem);

static DEFINE_WW_CLASS(buf_ww_class);
static DEFINE_WW_MUTEX(buf_a, &buf_ww_class);
static DEFINE_WW_MUTEX(buf_b, &buf_ww_class);

ww_acquire_init(ctx, &buf_ww_class);
retry:
if (ww_mutex_lock(&buf_a, ctx) || ww_mutex_lock(&buf_b, ctx)) {
    ww_mutex_unlock(&buf_a);   /* 被 wound：放弃已持锁并重试 */
    goto retry;
}
ww_acquire_done(ctx);
ww_acquire_fini(ctx);

static seqlock_t stats_seqlock = __SEQLOCK_UNLOCKED(stats_seqlock);
static struct stats snapshot;

write_seqlock(&stats_seqlock);           /* 写侧：必须串行化 */
snapshot.a = a;
snapshot.b = b;
write_sequnlock(&stats_seqlock);

void read_stats(struct stats *out)       /* 读侧：无锁重试 */
{
    unsigned int seq;

    do {
        seq = read_seqbegin(&stats_seqlock);
        out->a = snapshot.a;
        out->b = snapshot.b;
    } while (read_seqretry(&stats_seqlock, seq));
}

static seqcount_t time_seq = SEQCNT_ZERO(time_seq);
static u64 last_time;

write_seqcount_begin(&time_seq);         /* 写侧由外部锁保护 */
last_time = t;
write_seqcount_end(&time_seq);

u64 get_time(void)
{
    unsigned int seq;
    u64 t;

    do {
        seq = read_seqcount_begin(&time_seq);
        t = last_time;
    } while (read_seqcount_retry(&time_seq, seq));
    return t;
}

#include <linux/percpu.h>
static DEFINE_PER_CPU(unsigned long, pkt_count);

this_cpu_inc(pkt_count);                  /* 访问当前 CPU 副本，无需加锁 */

for_each_possible_cpu(cpu)                /* 汇总时遍历所有 CPU 副本 */
    sum += per_cpu(pkt_count, cpu);

struct local_ctx *ctx = get_cpu_var(my_ctx);   /* 关抢占，取当前 CPU 副本 */

ctx->count++;
do_something(ctx);
put_cpu_var(my_ctx);                           /* 开抢占 */

static struct percpu_ref ref;

percpu_ref_init(&ref, release_fn, 0, GFP_KERNEL);
percpu_ref_get(&ref);
percpu_ref_put(&ref);
percpu_ref_kill(&ref);   /* 切换为原子模式并等待引用消失 */

rcu_read_lock();                    /* 读侧：极轻量，非 RT 内核仅关闭/恢复抢占 */
p = rcu_dereference(gp);
use(p);
rcu_read_unlock();

synchronize_rcu();                        /* 写侧：同步等待，会阻塞 */
call_rcu(&old->rcu_head, free_callback);  /* 写侧：异步回调，不阻塞 */

struct config *global_cfg;

void update_config(struct config *new_cfg)      /* 写者 */
{
    struct config *old = rcu_dereference_protected(global_cfg, 1);

    rcu_assign_pointer(global_cfg, new_cfg);    /* 隐含释放屏障 */
    synchronize_rcu();
    kfree(old);
}

int read_mode(void)                             /* 读者 */
{
    struct config *cfg;

    rcu_read_lock();
    cfg = rcu_dereference(global_cfg);          /* 隐含获取屏障 */
    rcu_read_unlock();
    return cfg->mode;
}

#include <linux/rculist.h>
static LIST_HEAD(dev_list);
static DEFINE_SPINLOCK(dev_list_lock);

void walk_devices(void)                       /* 读者：无锁遍历 */
{
    struct device *d;

    rcu_read_lock();
    list_for_each_entry_rcu(d, &dev_list, list)
        printk("%s\n", d->name);
    rcu_read_unlock();
}

void del_device(struct device *d)             /* 写者：加锁保护 */
{
    spin_lock(&dev_list_lock);
    list_del_rcu(&d->list);
    spin_unlock(&dev_list_lock);
    synchronize_rcu();                        /* 等读者退出后再释放 */
    kfree(d);
}

static struct srcu_struct my_srcu;
int idx = srcu_read_lock(&my_srcu);

use(rcu_dereference(gp));            /* 可睡眠 */
srcu_read_unlock(&my_srcu, idx);
synchronize_srcu(&my_srcu);          /* 写侧 */

static DEFINE_SPINLOCK(lock_a);
static DEFINE_SPINLOCK(lock_b);

void path1(void)      /* 只要出现过 A→B 与 B→A 两种顺序就会报警 */
{
    spin_lock(&lock_a);
    spin_lock(&lock_b);
    spin_unlock(&lock_b);
    spin_unlock(&lock_a);
}

grep CONFIG_KCSAN /boot/config-$(uname -r)
echo on > /sys/kernel/debug/kcsan       # 运行时开启

spin_lock(&my_lock);
buf = kmalloc(1024, GFP_KERNEL);   /* BUG: sleeping function called from invalid context */
spin_unlock(&my_lock);

/* 完整可运行示例：RCU 发布-订阅 + spinlock 保护写侧
 * 保存为 rcu_demo.c，同目录放一个 Makefile 即可编译：
 *   obj-m := rcu_demo.o
 *   all:
 *       $(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
 * 运行：make && sudo insmod rcu_demo.ko && sleep 3 && dmesg | grep rcu_demo
 */
#include <linux/module.h>
#include <linux/rcupdate.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/timer.h>

MODULE_LICENSE("GPL");

struct demo_cfg { int mode; struct rcu_head rcu; };
static struct demo_cfg __rcu *global_cfg;
static DEFINE_SPINLOCK(cfg_lock);
static unsigned long updates;
static struct timer_list tick_timer;

static void cfg_free(struct rcu_head *head)
{
    struct demo_cfg *old = container_of(head, struct demo_cfg, rcu);
    pr_info("rcu_demo: freed mode=%d\n", old->mode);
    kfree(old);
}

static void publish(int mode)
{
    struct demo_cfg *new_cfg, *old;
    unsigned long flags;

    new_cfg = kzalloc(sizeof(*new_cfg), GFP_KERNEL);
    if (!new_cfg)
        return;
    new_cfg->mode = mode;

    spin_lock_irqsave(&cfg_lock, flags);
    old = rcu_dereference_protected(global_cfg, lockdep_is_held(&cfg_lock));
    rcu_assign_pointer(global_cfg, new_cfg);
    updates++;
    spin_unlock_irqrestore(&cfg_lock, flags);
    if (old)
        call_rcu(&old->rcu, cfg_free);   /* 宽限期结束后异步释放旧数据 */
}

static void tick(struct timer_list *t)
{
    struct demo_cfg *cfg;

    publish((int)(jiffies / HZ) % 10);
    rcu_read_lock();                     /* 读侧与写侧完全无锁并发 */
    cfg = rcu_dereference(global_cfg);
    pr_info("rcu_demo: read mode=%d updates=%lu\n",
            cfg ? cfg->mode : -1, updates);
    rcu_read_unlock();
    mod_timer(&tick_timer, jiffies + HZ);
}

static int __init demo_init(void)
{
    publish(1);
    timer_setup(&tick_timer, tick, 0);
    mod_timer(&tick_timer, jiffies + HZ);
    return 0;
}

static void __exit demo_exit(void)
{
    struct demo_cfg *old;

    del_timer_sync(&tick_timer);
    spin_lock_irq(&cfg_lock);
    old = rcu_dereference_protected(global_cfg, lockdep_is_held(&cfg_lock));
    rcu_assign_pointer(global_cfg, NULL);
    spin_unlock_irq(&cfg_lock);
    rcu_barrier();     /* 等所有 call_rcu 回调执行完再释放模块资源 */
    kfree(old);
    pr_info("rcu_demo: unloaded after %lu updates\n", updates);
}

module_init(demo_init);
module_exit(demo_exit);