内核同步

atomic_t v = ATOMIC_INIT(0);
atomic_inc(&v);
atomic_dec(&v);
atomic_add(10, &v);
atomic_sub(&v);
atomic_read(&v);
atomic_set(&v, 100);
int old = atomic_fetch_add(1, &v);
atomic_inc_and_test(&v);           // == 1?
atomic_dec_and_test(&v);           // == 0?
atomic_cmpxchg(&v, old, new);

set_bit(nr, addr);
clear_bit(nr, addr);
change_bit(nr, addr);
test_bit(nr, addr);
test_and_set_bit(nr, addr);
test_and_clear_bit(nr, addr);

atomic64_t v;
atomic64_inc(&v);
// ...

atomic_t v;                   // 或 ATOMIC_INIT
atomic_set(&v, 1);
atomic_inc(&v);
atomic_fetch_add(1, &v);

DEFINE_SPINLOCK(my_lock);
spin_lock(&my_lock);
// 临界区（必须短！）
spin_unlock(&my_lock);

spin_lock(&lock);                    // 加锁
spin_lock_irqsave(&lock, flags);     // 加锁 + 关本地中断
spin_lock_irq(&lock);                // 加锁 + 关中断（已知状态）
spin_lock_bh(&lock);                 // 加锁 + 关软中断

spin_unlock(&lock);
spin_unlock_irqrestore(&lock, flags);
spin_unlock_irq(&lock);
spin_unlock_bh(&lock);

spin_trylock(&lock);                 // 不阻塞
spin_is_locked(&lock);

echo 1 > /proc/sys/kernel/lock_stat
cat /proc/lock_stat

DEFINE_MUTEX(my_mutex);
mutex_lock(&my_mutex);
// 可睡眠、可调度
mutex_unlock(&my_mutex);

mutex_trylock(&my_mutex);
mutex_is_locked(&my_mutex);

DEFINE_RWLOCK(my_rw);
read_lock(&my_rw);
// 读
read_unlock(&my_rw);

write_lock(&my_rw);
// 写
write_unlock(&my_rw);

DEFINE_SEQLOCK(my_seq);

unsigned int seq;
seq = read_seqbegin(&my_seq);
// 读（如果冲突就重读）
read_seqretry(&my_seq, seq);

write_seqlock(&my_seq);
// 写（不能睡眠）
write_sequnlock(&my_seq);

struct my_data {
    int value;
    struct rcu_head rcu;
};

static struct my_data *g_data;

void reader(void) {
    struct my_data *p;
    rcu_read_lock();
    p = rcu_dereference(g_data);
    printk("%d\n", p->value);
    rcu_read_unlock();
}

void writer(struct my_data *new) {
    struct my_data *old = g_data;
    rcu_assign_pointer(g_data, new);
    synchronize_rcu();        // 等待所有读者
    kfree(old);
}

// 异步版本
void writer_async(struct my_data *new) {
    struct my_data *old = g_data;
    rcu_assign_pointer(g_data, new);
    call_rcu(&old->rcu, my_free);   // 延迟释放
}

DEFINE_PER_CPU(int, my_counter);

void inc_my_counter(void) {
    int *cnt = this_cpu_ptr(&my_counter);
    (*cnt)++;
}

s64 sum = 0;
for_each_possible_cpu(cpu)
    sum += per_cpu(my_counter, cpu);

mb();        // 全屏障
rmb();       // 读屏障
wmb();       // 写屏障

smp_mb();    // SMP 屏障（单 CPU 时为空）
smp_rmb();
smp_wmb();

barrier();   // 编译器屏障（不阻止 CPU）

smp_store_release(&ptr, new);
smp_load_acquire(&ptr);