Linux 内核编程完全指南

← 返回指南列表

Linux 内核编程完全指南

一、Linux 内核架构概述

Linux 内核是整个 Linux 操作系统的核心,负责管理硬件资源、提供系统调用接口、调度进程、管理内存和处理文件系统操作。理解内核架构是进行内核编程的基础。

1.1 宏内核与微内核

Linux 采用宏内核(Monolithic Kernel)架构。与微内核不同,宏内核将操作系统的所有核心服务——进程调度、内存管理、文件系统、设备驱动、网络协议栈等——都运行在内核空间。这使得内核内部各模块之间可以直接调用函数,效率极高,但也意味着任何一个模块的崩溃都可能导致整个系统崩溃。

微内核架构(如 Minix、QNX)仅将最基本的服务(IPC、基本调度)放在内核空间,其他服务运行在用户空间,隔离性更好但存在上下文切换开销。

1.2 内核空间与用户空间

现代 CPU 提供至少两种特权级别。Linux 使用 Ring 0(内核空间)和 Ring 3(用户空间)。在内核空间运行的代码可以访问所有硬件资源和内存地址;用户空间的程序则受到严格限制,必须通过系统调用向内核请求服务。

用户空间到内核空间的切换有以下几种方式:

  • 系统调用(System Call):用户程序主动请求内核服务
  • 中断(Interrupt):硬件设备通知 CPU
  • 异常(Exception):CPU 执行指令时的错误,如缺页异常

1.3 内核源码目录结构

Linux 内核源码组织清晰,按功能模块划分目录:

CODE
linux/
├── arch/          # 架构相关代码(x86、ARM、RISC-V 等)
├── block/         # 块设备 I/O 层
├── crypto/        # 加密算法实现
├── Documentation/ # 内核文档
├── drivers/       # 设备驱动(最大的目录)
├── fs/            # 文件系统(ext4、btrfs、xfs 等)
├── include/       # 内核头文件
├── init/          # 内核初始化代码
├── ipc/           # 进程间通信
├── kernel/        # 核心子系统(调度器、信号、时间等)
├── lib/           # 内核通用库函数
├── mm/            # 内存管理
├── net/           # 网络协议栈
├── scripts/       # 编译和配置脚本
├── security/      # 安全模块(SELinux、AppArmor)
├── sound/         # 音频子系统(ALSA)
├── tools/         # 用户空间工具
└── virt/          # 虚拟化支持(KVM)

1.4 内核版本号

Linux 内核使用 主版本.次版本.修订版本 的格式。例如 6.1.0:

  • 主版本:重大架构变更时递增
  • 次版本:奇数表示开发版,偶数表示稳定版(2.6 之后此规则已淡化)
  • 修订版本:Bug 修复和安全更新

LTS(Long Term Support)版本通常获得 2-6 年的维护支持,适合生产环境使用。


二、内核开发环境搭建

2.1 安装编译工具链

在 Debian/Ubuntu 系统上安装必要的编译工具:

BASH
sudo apt update
sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev

核心工具说明:

  • build-essential:GCC 编译器、make、libc 开发库
  • libncurses-dev:make menuconfig 图形配置界面依赖
  • bison 和 flex:语法和词法分析器生成器
  • libssl-dev:内核模块签名所需
  • libelf-dev:ELF 文件处理

2.2 获取内核源码

从 kernel.org 下载官方源码:

BASH
wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.tar.xz
tar -xf linux-6.6.tar.xz
cd linux-6.6

也可以使用 Git 克隆主线仓库:

BASH
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

2.3 内核配置

内核提供了多种配置方式:

BASH
make menuconfig    # 基于 ncurses 的图形界面(推荐)
make config        # 命令行逐项问答
make oldconfig     # 基于已有 .config 只询问新选项
make defconfig     # 使用默认配置
make localmodconfig # 仅启用当前加载的模块

关键配置项分类:

  • General setup:通用设置,如内核压缩模式、initramfs 支持
  • Processor type and features:CPU 架构相关配置
  • Memory Management options:内存管理选项
  • Networking support:网络协议栈配置
  • Device Drivers:设备驱动选择
  • File systems:文件系统支持
  • Security options:安全模块配置
  • Kernel hacking:调试相关选项

2.4 编译与安装

BASH
make -j$(nproc)          # 使用所有 CPU 核心并行编译
make modules_install     # 安装内核模块到 /lib/modules/
make install             # 安装内核镜像到 /boot/
update-grub              # 更新 GRUB 引导菜单

编译产物:

  • arch/x86/boot/bzImage:压缩后的内核镜像
  • vmlinux:未压缩的 ELF 格式内核文件
  • System.map:内核符号表
  • .ko 文件:可加载内核模块

三、内核模块(LKM)编程

内核模块允许在系统运行时动态扩展内核功能,而无需重新编译整个内核或重启系统。

3.1 最简单的 Hello World 模块

C
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Security Researcher");
MODULE_DESCRIPTION("A simple Hello World kernel module");
MODULE_VERSION("1.0");

static int __init hello_init(void)
{
    printk(KERN_INFO "Hello, Linux Kernel!\n");
    return 0;
}

static void __exit hello_exit(void)
{
    printk(KERN_INFO "Goodbye, Linux Kernel!\n");
}

module_init(hello_init);
module_exit(hello_exit);

对应的 Makefile:

MAKEFILE
obj-m += hello.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

编译和执行命令:

BASH
make                      # 编译模块
sudo insmod hello.ko      # 加载模块
dmesg | tail -5           # 查看内核日志
lsmod | grep hello        # 查看已加载模块
sudo rmmod hello          # 卸载模块

3.2 模块参数传递

C
#include <linux/moduleparam.h>

static int repeat = 1;
module_param(repeat, int, 0644);
MODULE_PARM_DESC(repeat, "Number of times to repeat the message");

static char *message = "Default Message";
module_param(message, charp, 0644);
MODULE_PARM_DESC(message, "Custom message string");

static int __init param_init(void)
{
    int i;
    for (i = 0; i < repeat; i++)
        printk(KERN_INFO "%s (iteration %d)\n", message, i + 1);
    return 0;
}

支持的参数类型:

  • bool:布尔值
  • invbool:取反布尔值
  • charp:字符串指针
  • int:整数
  • long:长整数
  • short:短整数
  • uint:无符号整数
  • ulong:无符号长整数
  • ushort:无符号短整数
  • array:数组类型参数

3.3 模块签名与安全

从 Linux 4.3 开始,内核支持模块签名验证。加载已签名的模块时,内核会验证其签名以确保没有被篡改:

BASH
# 内核配置中启用
CONFIG_MODULE_SIG=y
CONFIG_MODULE_SIG_FORCE=y   # 强制要求签名
CONFIG_MODULE_SIG_ALL=y     # 自动签名所有模块

内核维护两组密钥:内核编译时生成的密钥和 UEFI Secure Boot 证书链。

3.4 导出符号表

内核模块可以使用 EXPORT_SYMBOL 和 EXPORT_SYMBOL_GPL 宏将函数或变量导出,供其他模块使用:

C
#include <linux/export.h>

int calculate_checksum(const char *data, size_t len)
{
    int sum = 0;
    for (size_t i = 0; i < len; i++)
        sum += data[i];
    return sum;
}
EXPORT_SYMBOL(calculate_checksum);

// 仅允许 GPL 兼容模块使用
int secure_operation(void) { return 42; }
EXPORT_SYMBOL_GPL(secure_operation);

可通过 /proc/kallsyms(内核配置 CONFIG_KALLSYMS)查看导出的符号:

BASH
cat /proc/kallsyms | grep calculate_checksum

3.5 模块依赖管理

模块之间的依赖关系记录在 /lib/modules/$(uname -r)/modules.dep 文件中。modprobe 工具会自动处理依赖:

BASH
sudo modprobe mydriver        # 自动加载依赖模块
sudo modprobe -r mydriver     # 卸载模块及未被使用的依赖
depmod -a                     # 重新生成依赖数据库

modprobe 的模块搜索路径由 /etc/modprobe.d/ 和 /lib/modprobe.d/ 目录下的配置文件控制。


四、进程管理

4.1 task_struct 结构体

task_struct 是 Linux 中描述进程的核心结构体(定义在 include/linux/sched.h),每个进程在内核中都有对应的 task_struct 实例。其核心字段包括:

字段 含义
pid 进程 ID
state 进程状态(运行、睡眠、僵尸等)
mm 内存描述符(mm_struct)
files 打开的文件描述符表
signal 信号处理结构
comm 进程名称(最多 16 字符)
parent 父进程指针
children 子进程链表
real_cred 真实凭证(UID、GID)
cred 有效凭证
prio / static_prio 动态 / 静态优先级
se CFS 调度器实体
thread_info 架构相关的线程信息

可以通过 current 宏获取当前进程的 task_struct 指针:

C
#include <linux/sched.h>

static int __init process_info_init(void)
{
    printk(KERN_INFO "Current process: %s (PID: %d)\n",
           current->comm, current->pid);
    printk(KERN_INFO "UID: %d, GID: %d\n",
           from_kuid(&init_user_ns, current_uid()),
           from_kgid(&init_user_ns, current_gid()));
    return 0;
}

4.2 进程状态

Linux 进程有五种基本状态(include/linux/sched.h):

C
#define TASK_RUNNING            0x0000  // 可运行或正在运行
#define TASK_INTERRUPTIBLE      0x0001  // 可中断睡眠
#define TASK_UNINTERRUPTIBLE    0x0002  // 不可中断睡眠(D 状态)
#define TASK_STOPPED            0x0004  // 已停止(收到 SIGSTOP)
#define TASK_TRACED             0x0008  // 被调试器跟踪
#define EXIT_ZOMBIE             0x0010  // 僵尸进程
#define EXIT_DEAD               0x0020  // 已死亡

关键状态的详细说明:

  • TASK_INTERRUPTIBLE:进程在等待某个条件,可以被信号唤醒。大多数用户态睡眠都是此状态。
  • TASK_UNINTERRUPTIBLE:进程等待硬件条件,不能被信号中断。常见于直接 I/O、NFS 等场景。大量 D 状态进程可能是 I/O 瓶颈的信号。
  • EXIT_ZOMBIE:进程已终止但父进程尚未调用 wait(),资源尚未完全释放。

状态切换 API:

C
set_current_state(TASK_INTERRUPTIBLE);   // 设置当前状态
schedule();                               // 主动让出 CPU
__set_current_state(TASK_RUNNING);       // 恢复运行状态

// 便捷宏
wait_event_interruptible(wq, condition); // 等待条件满足
wake_up_interruptible(&wq);              // 唤醒等待者

4.3 进程创建:fork、vfork、clone 与内核线程

在用户空间,fork() 创建子进程,execve() 替换程序镜像。在内核层面,三者都最终调用 _do_fork() → copy_process() 流程。

copy_process() 的核心工作:

  1. 调用 dup_task_struct() 复制 task_struct 和内核栈
  2. 检查资源限制(RLIMIT_NPROC)
  3. 复制进程凭证(copy_creds())
  4. 复制文件描述符表(copy_files())
  5. 复制文件系统上下文(copy_fs())
  6. 复制信号处理(copy_sighand()、copy_signal())
  7. 复制内存描述符 mm_struct(copy_mm())
  8. 复制命名空间(copy_namespaces())
  9. 分配 PID(alloc_pid())

关键标志位控制共享行为:

标志 含义
CLONE_VM 共享地址空间(线程)
CLONE_FS 共享文件系统信息
CLONE_FILES 共享文件描述符表
CLONE_SIGHAND 共享信号处理表
CLONE_THREAD 创建线程(同线程组)
CLONE_NEWNS 新的挂载命名空间
CLONE_NEWNET 新的网络命名空间
CLONE_NEWPID 新的 PID 命名空间

内核线程是仅在内核空间运行的特殊进程,没有独立的地址空间(mm == NULL):

C
#include <linux/kthread.h>

struct task_struct *kthread_create(
    int (*threadfn)(void *data),
    void *data,
    const char namefmt[], ...);

struct task_struct *kthread_run(
    int (*threadfn)(void *data),
    void *data,
    const char namefmt[], ...);

4.4 CFS 完全公平调度器

自 Linux 2.6.23 起,CFS(Completely Fair Scheduler)取代了 O(1) 调度器。CFS 的核心思想是:为每个可运行的进程分配公平的 CPU 时间份额。

调度实体(sched_entity)的关键字段:

  • vruntime:虚拟运行时间,CFS 使用红黑树组织进程,vruntime 最小的进程优先运行
  • load.weight:nice 值映射的权重
  • run_node:红黑树节点

nice 值与权重对应关系(部分):

nice 权重
-20 88761
0 1024
5 335
19 15

实际运行时间计算公式:实际时间 = 调度周期 × (权重 / 总权重)

查看和调整进程调度策略:

BASH
chrt -p PID              # 查看调度策略和优先级
chrt -f -p 50 PID        # 设置为 SCHED_FIFO,优先级 50
nice -n 10 command       # 以 nice 10 运行命令
renice 5 -p PID          # 调整运行中进程的 nice 值

Linux 支持的调度类:

  • SCHED_NORMAL(SCHED_OTHER):CFS 默认调度类
  • SCHED_BATCH:批处理,不抢占
  • SCHED_IDLE:仅空闲时运行
  • SCHED_FIFO:实时,先入先出
  • SCHED_RR:实时,时间片轮转
  • SCHED_DEADLINE:实时,截止时间驱动

五、内存管理

5.1 虚拟地址空间布局

在 x86_64 架构上,虚拟地址空间分为用户空间和内核空间:

CODE
0x0000000000000000 ────────────────────
                   用户空间(48 位)
0x00007FFFFFFFFFFF ────────────────────
                   非规范地址(空洞)
0xFFFF800000000000 ────────────────────
                   内核空间(48 位)
0xFFFFFFFFFFFFFFFF ────────────────────

用户空间布局(典型的 64 位进程):

CODE
高地址 → 栈(Stack, 向下增长)
         ↓
         [可用空间]
         ↑
         内存映射区(mmap, 共享库)
         ↓
         堆(Heap, 向上增长, brk/sbrk)
         BSS 段(未初始化全局变量)
         数据段(.data, 已初始化全局变量)
低地址 → 代码段(.text)

5.2 伙伴系统(Buddy System)

伙伴系统是 Linux 物理内存分配的核心,负责管理物理页框。它解决了外部碎片问题。

基本原理:

  • 将空闲物理页按 2^n 个连续页组织为 11 个链表(free_area[0] ~ free_area[10],对应 1、2、4、…、1024 个页)
  • 分配时:找到满足需求的最小块,如果当前级别没有空闲块,向上一级请求并分裂
  • 释放时:检查相邻”伙伴”是否空闲,若是则合并

核心分配函数:

C
#include <linux/gfp.h>

struct page *alloc_pages(gfp_t gfp_mask, unsigned int order);
void __free_pages(struct page *page, unsigned int order);

unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
void free_pages(unsigned long addr, unsigned int order);

unsigned long get_zeroed_page(gfp_t gfp_mask);  // 零初始化单页

GFP(Get Free Pages)标志位:

标志 含义
GFP_KERNEL 内核常规分配(可能睡眠)
GFP_ATOMIC 原子分配(绝不睡眠,中断上下文使用)
GFP_USER 为用户空间分配
GFP_HIGHUSER 从高端内存为用户空间分配
GFP_DMA 从 DMA 区域分配
__GFP_ZERO 返回零初始化页
__GFP_NOWARN 分配失败不打印警告
__GFP_NORETRY 分配失败不重试

5.3 Slab 分配器

伙伴系统以页为单位分配,粒度太粗。Slab 分配器在伙伴系统之上,管理小对象的分配和释放,主要优势:

  • 缓存常用对象,减少重复初始化开销
  • 减少内部碎片
  • 硬件缓存行对齐,提高缓存命中率

三种实现:

  • SLAB:传统实现,有复杂的管理结构
  • SLUB:简化版本,当前默认实现
  • SLOB:极简实现,适合嵌入式系统

创建内核缓存:

C
#include <linux/slab.h>

struct kmem_cache *kmem_cache_create(
    const char *name,
    unsigned int size,
    unsigned int align,
    slab_flags_t flags,
    void (*ctor)(void *));

// 从缓存分配
void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);

// 释放回缓存
void kmem_cache_free(struct kmem_cache *cachep, void *objp);

// 销毁缓存
void kmem_cache_destroy(struct kmem_cache *cachep);

常用的通用分配函数(基于 kmalloc 的 SLUB 分配):

C
void *kmalloc(size_t size, gfp_t flags);    // 分配物理连续内存
void *kzalloc(size_t size, gfp_t flags);    // kmalloc + 零初始化
void kfree(const void *objp);               // 释放

void *vmalloc(unsigned long size);           // 分配虚拟连续内存
void vfree(const void *addr);               // 释放

kmalloc 与 vmalloc 的关键区别:

  • kmalloc:分配物理连续内存,直接映射,速度更快,适合 DMA
  • vmalloc:分配虚拟连续内存,物理页可以不连续,需要设置页表,性能稍差

5.4 缺页异常处理

当进程访问尚未映射到物理内存的虚拟地址时,MMU 触发缺页异常(Page Fault)。Linux 的缺页异常处理入口是 do_page_fault():

  1. 检查地址是否属于进程的虚拟地址空间(find_vma())
  2. 检查访问权限(读/写/执行)
  3. 分为三种情况处理:
    • 匿名页:分配物理页并清零
    • 文件映射页:从磁盘读取数据到物理页
    • 写时复制(COW):复制页面并断开共享
  4. 更新页表,建立虚拟到物理的映射

写时复制是 fork() 效率的关键:父子进程共享只读页面,只有当任一方尝试写入时才真正复制。

5.5 页面回收与 OOM Killer

当内存紧张时,内核启动页面回收(Page Reclaim)机制:

  1. kswapd:后台守护进程,持续监控水位线,提前回收
  2. 直接回收(Direct Reclaim):分配时发现内存不足,同步回收
  3. OOM Killer:终极手段,选择并杀死进程释放内存

OOM 评分计算在 oom_badness() 中实现,综合考虑:

  • 进程占用的内存量
  • 进程的 oom_score_adj 值(用户可调)
  • 进程运行时长和重要性
BASH
# 查看 OOM 评分
cat /proc/PID/oom_score

# 调整 OOM 调整值(-1000 到 1000,-1000 完全豁免)
echo -500 > /proc/PID/oom_score_adj

六、文件系统

6.1 VFS 虚拟文件系统

VFS(Virtual File System)是 Linux 内核的抽象层,为所有文件系统提供统一接口。它定义了四个核心对象:

对象 结构体 含义
超级块 super_block 描述已挂载的文件系统
索引节点 inode 描述文件系统中的对象(文件、目录等)
目录项 dentry 将路径名映射到 inode
文件对象 file 描述进程打开的文件的上下文

VFS 定义了操作接口集合:

C
struct file_operations {
    int (*open) (struct inode *, struct file *);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    int (*mmap) (struct file *, struct vm_area_struct *);
    int (*release) (struct inode *, struct file *);
    loff_t (*llseek) (struct file *, loff_t, int);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    // ... 更多操作
};

struct inode_operations {
    int (*create) (struct mnt_idmap *, struct inode *, struct dentry *, umode_t, bool);
    int (*mkdir) (struct mnt_idmap *, struct inode *, struct dentry *, umode_t);
    int (*rmdir) (struct inode *, struct dentry *);
    int (*symlink) (struct mnt_idmap *, struct inode *, struct dentry *, const char *);
    int (*rename) (struct mnt_idmap *, struct inode *, struct dentry *, struct inode *, struct dentry *, unsigned int);
    // ... 更多操作
};

6.2 页缓存

页缓存(Page Cache)是 Linux 性能的关键。它缓存从磁盘读取的文件数据在内存中:

  • 读操作:先在页缓存查找,命中则直接返回(免去磁盘 I/O)
  • 写操作:默认采用”写回”策略——数据先写入页缓存标记为脏,由内核周期性写回磁盘

页缓存的核心接口:

C
// 查找或创建页缓存页
struct page *find_get_page(struct address_space *mapping, pgoff_t index);
struct page *find_lock_page(struct address_space *mapping, pgoff_t index);

// 读取页(可能触发磁盘 I/O)
struct page *read_mapping_page(struct address_space *mapping, pgoff_t index, void *data);

// 标记脏页
void set_page_dirty(struct page *page);

脏页写回触发条件:

  • 脏页比例超过 dirty_background_ratio(默认 10%),后台写回
  • 脏页比例超过 dirty_ratio(默认 20%),进程阻塞等待写回
  • 脏页存在时间超过 dirty_expire_centisecs(默认 30 秒)
  • 用户调用 sync() / fsync() / fdatasync()

6.3 文件锁机制

Linux 提供两种文件锁:

建议锁(Advisory Lock):flock() 和 fcntl(F_SETLK),不强制阻止读写,依赖进程自觉检查。

强制锁(Mandatory Lock):通过设置文件 set-group-ID 位并清除 group-execute 位启用,内核强制检查。

BASH
chmod g+s,g-x file    # 启用强制锁

七、中断与异常处理

7.1 中断处理流程

中断分为上半部(Top Half)和下半部(Bottom Half):

  • 上半部(中断处理程序):响应紧急事件,关中断运行,必须尽可能快
  • 下半部:执行可延迟的非紧急工作,开中断运行

下半部机制对比:

机制 上下文 并发 适用场景
Softirq 中断上下文 同类型可在多 CPU 并行 高频率、低延迟(网络、块 I/O)
Tasklet 中断上下文 同类型串行执行 一般的非紧急延迟工作
Workqueue 进程上下文 可睡眠 需要睡眠的延迟工作

7.2 注册中断处理函数

C
#include <linux/interrupt.h>

irq_handler_t handler(unsigned int irq, void *dev_id)
{
    // 上半部处理
    return IRQ_HANDLED;  // 或 IRQ_NONE(表示不是本设备的中断)
}

// 注册
int request_irq(
    unsigned int irq,
    irq_handler_t handler,
    unsigned long flags,
    const char *name,
    void *dev_id);

// 释放
void free_irq(unsigned int irq, void *dev_id);

常用的中断标志:

  • IRQF_SHARED:允许多个设备共享中断线
  • IRQF_TRIGGER_RISING:上升沿触发
  • IRQF_TRIGGER_FALLING:下降沿触发
  • IRQF_ONESHOT:一次性中断,处理完成后保持屏蔽

7.3 软中断(Softirq)

软中断是编译时静态定义的,总数有限:

C
// 预定义类型
enum {
    HI_SOFTIRQ = 0,    // 高优先级 tasklet
    TIMER_SOFTIRQ,      // 定时器
    NET_TX_SOFTIRQ,     // 网络发送
    NET_RX_SOFTIRQ,     // 网络接收
    BLOCK_SOFTIRQ,      // 块设备
    IRQ_POLL_SOFTIRQ,   // IRQ 轮询
    TASKLET_SOFTIRQ,    // 常规 tasklet
    SCHED_SOFTIRQ,      // 调度器
    HRTIMER_SOFTIRQ,    // 高精度定时器
    RCU_SOFTIRQ,        // RCU
    NR_SOFTIRQS
};

软中断在以下时机被检查和执行:

  • 硬件中断处理程序返回时(irq_exit())
  • 内核线程 ksoftirqd 被唤醒时
  • 显式调用 local_bh_enable() 时

7.4 Tasklet 与 Workqueue

Tasklet 示例:

C
#include <linux/interrupt.h>

void tasklet_fn(unsigned long data);

DECLARE_TASKLET(my_tasklet, tasklet_fn, (unsigned long)&my_data);

// 或动态创建
struct tasklet_struct *t = kmalloc(sizeof(*t), GFP_KERNEL);
tasklet_init(t, tasklet_fn, (unsigned long)&my_data);

// 调度执行
tasklet_schedule(&my_tasklet);
tasklet_hi_schedule(&my_tasklet);  // 高优先级

Workqueue 示例:

C
#include <linux/workqueue.h>

struct work_struct my_work;

void work_handler(struct work_struct *work)
{
    // 可以睡眠!
    msleep(100);
    printk(KERN_INFO "Work done on CPU %d\n", smp_processor_id());
}

// 初始化并调度
INIT_WORK(&my_work, work_handler);
schedule_work(&my_work);  // 使用系统默认 workqueue

// 创建专用 workqueue
struct workqueue_struct *my_wq = create_workqueue("my_wq");
queue_work(my_wq, &my_work);
flush_workqueue(my_wq);
destroy_workqueue(my_wq);

八、内核同步机制

内核是抢占式的,多 CPU 可以同时在不同的核心上执行内核代码。正确的同步至关重要。

8.1 自旋锁(Spinlock)

自旋锁在获取锁时会忙等(在 CPU 上自旋),适用于持有时间极短的临界区,不能在持有自旋锁时睡眠:

C
#include <linux/spinlock.h>

DEFINE_SPINLOCK(my_lock);
// 或动态初始化
spinlock_t lock;
spin_lock_init(&lock);

unsigned long flags;

spin_lock_irqsave(&lock, flags);
// 临界区代码
spin_unlock_irqrestore(&lock, flags);

自旋锁变体:

  • spin_lock() / spin_unlock():不考虑中断
  • spin_lock_irq() / spin_unlock_irq():禁用本地中断
  • spin_lock_irqsave() / spin_unlock_irqrestore():保存并恢复中断状态(推荐)
  • spin_lock_bh() / spin_unlock_bh():禁用下半部(softirq/tasklet)

8.2 互斥锁(Mutex)

互斥锁在获取失败时会让 CPU 睡眠,适合临界区较长的场景:

C
#include <linux/mutex.h>

DEFINE_MUTEX(my_mutex);
// 或动态
struct mutex my_mutex;
mutex_init(&my_mutex);

mutex_lock(&my_mutex);
// 可睡眠的临界区代码
mutex_unlock(&my_mutex);

// 可中断的获取
if (mutex_lock_interruptible(&my_mutex))
    return -ERESTARTSYS;

// 尝试获取
if (mutex_trylock(&my_mutex)) {
    // 获取成功
    mutex_unlock(&my_mutex);
} else {
    // 获取失败
}

8.3 信号量(Semaphore)

信号量允许多个持有者同时进入临界区:

C
#include <linux/semaphore.h>

DEFINE_SEMAPHORE(my_sem);
// 或动态
struct semaphore sem;
sema_init(&sem, 1);  // 初始计数为 1(二值信号量)

down(&sem);           // 获取(不可中断)
down_interruptible(&sem);  // 获取(可中断)
down_trylock(&sem);   // 尝试获取
up(&sem);             // 释放

8.4 RCU(Read-Copy-Update)

RCU 针对读多写少的场景优化,读者完全不需要获取锁:

C
#include <linux/rcupdate.h>

// 读者
rcu_read_lock();
struct my_data *p = rcu_dereference(global_ptr);
if (p) {
    int val = p->value;
    // 使用 p 的数据
}
rcu_read_unlock();

// 写者
struct my_data *newp = kmalloc(sizeof(*newp), GFP_KERNEL);
struct my_data *oldp;
*newp = *global_ptr;
newp->value = 42;
oldp = global_ptr;
rcu_assign_pointer(global_ptr, newp);
synchronize_rcu();  // 等待所有读者离开临界区
kfree(oldp);

8.5 原子操作

对于简单的整数操作,使用原子变量避免加锁开销:

C
#include <linux/atomic.h>

atomic_t my_counter = ATOMIC_INIT(0);
atomic64_t big_counter = ATOMIC64_INIT(0);

atomic_inc(&my_counter);          // 自增
atomic_dec(&my_counter);          // 自减
atomic_add(5, &my_counter);       // 加
int old = atomic_read(&my_counter); // 读取

// 比较并交换
int old_val = 0, new_val = 1;
atomic_cmpxchg(&my_counter, old_val, new_val);

九、系统调用

9.1 系统调用实现原理

从用户空间调用到内核处理的完整流程:

  1. 用户程序调用 C 库包装函数(如 write())
  2. 参数存入寄存器(x86_64:rax=系统调用号,rdi/rsi/rdx/r10/r8/r9=参数)
  3. 执行 syscall 指令,CPU 切换到内核模式
  4. CPU 从 MSR_LSTAR 寄存器读取入口地址,跳转到 entry_SYSCALL_64
  5. 内核保存寄存器上下文,通过系统调用号查表(sys_call_table)
  6. 调用对应的内核函数(如 __x64_sys_write)
  7. 返回用户空间,恢复寄存器

9.2 添加自定义系统调用

在内核源码中添加系统调用(仅供学习和研究,生产环境请使用其他内核接口):

C
// 1. 在 kernel/sys.c 中添加实现
SYSCALL_DEFINE2(mycall, int, a, int, b)
{
    printk(KERN_INFO "mycall(%d, %d) from pid %d\n", a, b, current->pid);
    return a + b;
}

// 2. 在 include/uapi/asm-generic/unistd.h 中分配调用号
#define __NR_mycall 451
__SYSCALL(__NR_mycall, sys_mycall)

// 3. 在 arch/x86/entry/syscalls/syscall_64.tbl 中注册
451  common  mycall  sys_mycall

用户空间调用:

C
#include <unistd.h>
#include <sys/syscall.h>

#define __NR_mycall 451

int main()
{
    long result = syscall(__NR_mycall, 10, 20);
    printf("Result: %ld\n", result);
    return 0;
}

9.3 用户空间与内核空间数据传递

C
// 从用户空间拷贝数据到内核空间
unsigned long copy_from_user(void *to, const void __user *from, unsigned long n);

// 从内核空间拷贝数据到用户空间
unsigned long copy_to_user(void __user *to, const void *from, unsigned long n);

// 检查用户空间指针
int access_ok(const void __user *addr, unsigned long n);

// 单值拷贝
int get_user(x, ptr);    // 从用户空间获取一个值
int put_user(x, ptr);    // 向用户空间写入一个值

十、内核调试技术

10.1 printk 与内核日志级别

C
#define KERN_EMERG    "<0>"  // 系统崩溃
#define KERN_ALERT    "<1>"  // 立即处理
#define KERN_CRIT     "<2>"  // 严重错误
#define KERN_ERR      "<3>"  // 错误
#define KERN_WARNING  "<4>"  // 警告
#define KERN_NOTICE   "<5>"  // 正常但重要
#define KERN_INFO     "<6>"  // 信息
#define KERN_DEBUG    "<7>"  // 调试信息

查看内核日志:

BASH
dmesg                          # 查看全部内核日志
dmesg -w                       # 实时跟踪
echo 8 > /proc/sys/kernel/printk  # 调整控制台日志级别
cat /proc/kmsg                 # 读取内核环形缓冲区

/proc/sys/kernel/printk 的四个值:

  1. 控制台日志级别
  2. 默认消息日志级别
  3. 控制台最小日志级别
  4. 控制台默认日志级别

10.2 调试工具链

ftrace:内核函数跟踪器:

BASH
mount -t tracefs nodev /sys/kernel/tracing
echo function > /sys/kernel/tracing/current_tracer
echo 1 > /sys/kernel/tracing/tracing_on
cat /sys/kernel/tracing/trace

Kprobes:动态插桩:

BASH
# 在 do_sys_open 入口插入探针
echo "p:myprobe do_sys_open" > /sys/kernel/tracing/kprobe_events
echo 1 > /sys/kernel/tracing/events/kprobes/myprobe/enable
cat /sys/kernel/tracing/trace

perf:性能分析:

BASH
perf top                        # 实时热点函数
perf record -g sleep 10         # 记录 10 秒调用栈
perf report                     # 查看报告

KGDB:内核级 GDB 调试,需要串口线或虚拟机支持。

10.3 内核崩溃分析

BASH
# 配置 kdump 捕获崩溃转储
sudo apt install linux-crashdump

# 使用 crash 工具分析
sudo crash /usr/lib/debug/boot/vmlinux-$(uname -r) /var/crash/dump.xxx

# 在 crash 中常用命令
crash> bt          # 回溯栈
crash> log         # 内核日志
crash> ps          # 进程列表
crash> files PID   # 进程打开的文件
crash> vm PID      # 进程虚拟内存

10.4 内核配置中的调试选项

BASH
CONFIG_DEBUG_KERNEL=y             # 启用内核调试
CONFIG_DEBUG_INFO=y               # 编译调试信息
CONFIG_KALLSYMS=y                 # 加载所有内核符号
CONFIG_MAGIC_SYSRQ=y              # 启用 Magic SysRq
CONFIG_DEBUG_SPINLOCK=y           # 自旋锁调试
CONFIG_DEBUG_MUTEXES=y            # 互斥锁调试
CONFIG_LOCKDEP=y                  # 锁依赖检查
CONFIG_KASAN=y                    # 内核地址消毒器(内存错误检测)
CONFIG_KFENCE=y                   # 低开销内存错误检测器
CONFIG_UBSAN=y                    # 未定义行为消毒器
CONFIG_DEBUG_PAGEALLOC=y          # 释放后填充页以检测 use-after-free
CONFIG_SLUB_DEBUG=y               # SLUB 分配器调试

KASAN(Kernel Address Sanitizer) 是检测内存错误的有力工具:

  • Generic KASAN:每次内存访问都检查影子内存,开销较大
  • Software Tag-Based KASAN:使用 ARM TBI 特性,仅 arm64
  • Hardware Tag-Based KASAN:使用 MTE 硬件,仅 arm64

KASAN 能检测的 Bug 类型:

  • 堆/栈/全局变量越界访问
  • Use-after-free
  • Double-free
  • 栈溢出

10.5 常见内核 Bug 排查思路

症状 可能原因 排查工具
内核 panic 空指针解引用、栈溢出 kdump + crash
内存泄漏 kmalloc 未配 kfree kmemleak
死锁 锁序不一致 lockdep
软锁死 长时间持锁 NMI watchdog
RCU 停顿 读者未释放 RCU 读锁 rcu 调试
数据破坏 并发竞争 KCSAN

十一、内核安全机制

11.1 内核地址空间布局随机化(KASLR)

KASLR 随机化内核基址,增加攻击难度:

BASH
# 检查是否启用
cat /proc/cmdline | grep kaslr

# 查看内核基址
cat /proc/kallsyms | grep " T _stext"

11.2 SMAP 与 SMEP

  • SMEP(Supervisor Mode Execution Prevention):禁止内核模式执行用户空间代码
  • SMAP(Supervisor Mode Access Prevention):禁止内核模式访问用户空间内存

临时绕过 SMAP 的方法:

C
stac();  // 启用用户空间访问
// 访问用户空间数据
clac();  // 禁止用户空间访问

11.3 内核栈保护

  • Stack Canary:在栈帧放置金丝雀值,检测栈溢出(CONFIG_STACKPROTECTOR)
  • 影子调用栈(SCS):arm64 上的硬件支持特性
  • CFI(Control Flow Integrity):CONFIG_CFI_CLANG 防止控制流劫持

11.4 内核加固配置

BASH
CONFIG_STRICT_KERNEL_RWX=y    # 内核代码段只读,数据段不可执行
CONFIG_STRICT_MODULE_RWX=y    # 模块代码段只读
CONFIG_RANDOMIZE_BASE=y       # 启用 KASLR
CONFIG_SLUB_DEBUG=y           # SLUB 堆调试
CONFIG_HARDENED_USERCOPY=y    # 加固 user copy 检查
CONFIG_FORTIFY_SOURCE=y       # 编译时缓冲区溢出检测
CONFIG_SECURITY_DMESG_RESTRICT=y  # 限制 dmesg 访问
CONFIG_HARDENED_USERCOPY_FALLBACK=n  # 拒绝未列入白名单的 copy 操作

十二、内核编程最佳实践

12.1 错误处理模式

C
// 经典的 goto 清理模式
static int __init my_init(void)
{
    int ret;
    
    resource_a = allocate_resource_a();
    if (!resource_a) {
        ret = -ENOMEM;
        goto fail_a;
    }
    
    resource_b = allocate_resource_b();
    if (!resource_b) {
        ret = -ENOMEM;
        goto fail_b;
    }
    
    ret = register_something();
    if (ret)
        goto fail_register;
    
    return 0;

fail_register:
    free_resource_b(resource_b);
fail_b:
    free_resource_a(resource_a);
fail_a:
    return ret;
}

12.2 避免常见陷阱

  1. 不要在持有自旋锁时睡眠:这会导致死锁
  2. 不要在内核栈上分配大量内存:内核栈通常只有 16KB
  3. 复制用户空间数据前验证指针:使用 access_ok() 或让 copy_from_user 自己处理
  4. 原子上下文不能调度:中断处理程序、tasklet、timer 中不能使用 mutex_lock() 等可能睡眠的函数
  5. 注意数字溢出:内核代码中的整数溢出可能导致严重的安全漏洞
  6. 使用 RCU 保护的指针不能在宽限期前释放:使用 synchronize_rcu() 或 call_rcu()
  7. 不要在模块卸载后保留指针:使用 try_module_get() / module_put() 管理模块引用计数

12.3 内核编码风格

Linux 内核有严格的编码风格要求(Documentation/process/coding-style.rst):

  • 缩进使用 8 个空格的 Tab(不是 4 个!)
  • 每行不超过 80 列(注释和字符串可以到 100 列)
  • K&R 风格的大括号
  • 函数名、变量名使用下划线命名(snake_case)
  • 类型定义使用 _t 后缀
  • 避免在头文件中使用 typedef
BASH
# 检查代码风格
scripts/checkpatch.pl --file my_module.c

12.4 提交内核补丁

向 Linux 主线提交补丁的流程:

  1. 在 linux-next 或相应子系统的维护者树基础上开发
  2. 编写清晰的 commit message(git format-patch -1)
  3. 使用 scripts/get_maintainer.pl 找到相关维护者和邮件列表
  4. 使用 git send-email 发送补丁
  5. 在邮件列表中参与讨论,迭代修改
  6. 被维护者 Ack 后,补丁进入子系统树,最终合入主线

十三、总结

Linux 内核编程是一项复杂但有深度的技术工作。从内核模块的编写到核心子系统的深入理解,每一步都需要扎实的 C 语言功底和对操作系统原理的透彻掌握。本指南覆盖了内核编程的关键领域:

  • 内核架构与源码结构
  • 开发环境搭建与内核编译
  • LKM 内核模块编程
  • 进程管理与 CFS 调度器
  • 内存管理:伙伴系统、Slab 分配器、页缓存
  • VFS 文件系统抽象
  • 中断下半部机制(Softirq / Tasklet / Workqueue)
  • 内核同步:自旋锁、互斥锁、RCU、原子操作
  • 系统调用实现原理
  • 内核调试与安全加固

深入内核编程不仅能帮助你编写高效的驱动和内核模块,更能让你理解操作系统的底层运作机制,从而写出更优秀的用户空间程序。记住:在内核中,你是操作系统本身的一部分,你的每一个错误都可能让整个系统崩溃。 保持敬畏,持续学习。