OpenVelinux内核开发：深入理解内核锁机制

2025-06-19 03:05:21作者：贡沫苏Truman

前言

在多核处理器和抢占式调度成为主流的今天，内核开发者必须深入理解并发控制和锁机制。本文将系统性地介绍OpenVelinux内核中的各种锁机制及其适用场景，帮助开发者编写安全高效的内核代码。

并发问题基础

竞态条件(Race Condition)

竞态条件是指多个执行路径（线程、中断等）同时访问共享数据时，由于执行顺序的不确定性导致的结果不一致问题。

典型示例：

very_important_count++;

看似简单的自增操作，在多线程环境下可能出现问题：

预期执行流程	可能出现的错误流程
线程1读取(值为5)	线程1读取(值为5)
线程1增加(值为6)	线程2读取(值为5)
线程1写入(值为6)	线程1增加(值为6)
线程2读取(值为6)	线程2增加(值为6)
线程2增加(值为7)	线程1写入(值为6)
线程2写入(值为7)	线程2写入(值为6)

临界区(Critical Region)

包含竞态条件的代码段称为临界区。解决竞态问题的关键是确保临界区在任何时候只能被一个执行路径进入。

内核锁机制概览

基本原则

保持简单：锁机制越简单越好
谨慎引入新锁：不要过度设计锁机制
全面测试：即使在单处理器上也要测试SMP和抢占配置

两种主要锁类型

1. 自旋锁(Spinlock)

特点：忙等待，不睡眠
适用场景：中断上下文、短临界区
头文件：include/asm/spinlock.h
变种：
- spin_lock()：基本自旋锁
- spin_lock_bh()：禁用软中断
- spin_lock_irq()：禁用硬件中断
- spin_lock_irqsave()：保存中断状态并禁用

2. 互斥锁(Mutex)

特点：可睡眠，阻塞等待
适用场景：进程上下文、可能阻塞的操作
头文件：include/linux/mutex.h
变种：
- mutex_lock()：不可中断的等待
- mutex_lock_interruptible()：可被信号中断

锁的使用场景

1. 仅用户上下文

当数据只在进程上下文被访问时，使用互斥锁是最简单的选择。

示例模式：

static DEFINE_MUTEX(my_mutex);

mutex_lock_interruptible(&my_mutex);
/* 临界区 */
mutex_unlock(&my_mutex);

2. 用户上下文与软中断共享

需要使用spin_lock_bh()，它会：

禁用本地CPU的软中断
获取自旋锁

对应的解锁函数是spin_unlock_bh()。

3. 用户上下文与硬件中断共享

使用spin_lock_irq()或spin_lock_irqsave()：

spin_lock_irq()：简单禁用中断
spin_lock_irqsave()：保存当前中断状态并禁用

4. 软中断之间共享

相同软中断在不同CPU上可能同时运行，需要使用spin_lock()保护共享数据。

5. 硬件中断处理程序之间共享

使用spin_lock_irqsave()，因为不同架构对中断处理程序中的中断状态有不同规定。

锁的选择速查表

上下文A \ 上下文B	IRQ Handler	Softirq	Tasklet	Timer	User Context
IRQ Handler	SLIS	SLI	SLI	SLI	SLI
Softirq	SLI	SL	SL	SL	SLBH
Tasklet	SLI	SL	None	SL	SLBH
Timer	SLI	SL	SL	None	SLBH
User Context	SLI	SLBH	SLBH	SLBH	MLI

缩写说明：

SLIS: spin_lock_irqsave
SLI: spin_lock_irq
SL: spin_lock
SLBH: spin_lock_bh
MLI: mutex_lock_interruptible

实际案例：缓存实现

纯用户上下文实现

#include <linux/list.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/mutex.h>
#include <asm/errno.h>

struct object {
    struct list_head list;
    int id;
    char name[32];
    int popularity;
};

static DEFINE_MUTEX(cache_lock);
static LIST_HEAD(cache);
static unsigned int cache_num = 0;
#define MAX_CACHE_SIZE 10

/* 必须在持有cache_lock时调用 */
static struct object *__cache_find(int id)
{
    struct object *i;
    list_for_each_entry(i, &cache, list)
        if (i->id == id) {
            i->popularity++;
            return i;
        }
    return NULL;
}

/* 必须在持有cache_lock时调用 */
static void __cache_delete(struct object *obj)
{
    BUG_ON(!obj);
    list_del(&obj->list);
    kfree(obj);
    cache_num--;
}

/* 必须在持有cache_lock时调用 */
static void __cache_add(struct object *obj)
{
    list_add(&obj->list, &cache);
    if (++cache_num > MAX_CACHE_SIZE) {
        struct object *i, *outcast = NULL;
        list_for_each_entry(i, &cache, list) {
            if (!outcast || i->popularity < outcast->popularity)
                outcast = i;
        }
        __cache_delete(outcast);
    }
}

int cache_add(int id, const char *name)
{
    struct object *obj;
    if ((obj = kmalloc(sizeof(*obj), GFP_KERNEL)) == NULL)
        return -ENOMEM;
    
    strscpy(obj->name, name, sizeof(obj->name));
    obj->id = id;
    obj->popularity = 0;
    
    mutex_lock(&cache_lock);
    __cache_add(obj);
    mutex_unlock(&cache_lock);
    return 0;
}

void cache_delete(int id)
{
    mutex_lock(&cache_lock);
    __cache_delete(__cache_find(id));
    mutex_unlock(&cache_lock);
}