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 内核源码组织清晰,按功能模块划分目录:
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 系统上安装必要的编译工具:
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 下载官方源码:
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 克隆主线仓库:
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
2.3 内核配置
内核提供了多种配置方式:
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 编译与安装
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 模块
#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:
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
编译和执行命令:
make # 编译模块
sudo insmod hello.ko # 加载模块
dmesg | tail -5 # 查看内核日志
lsmod | grep hello # 查看已加载模块
sudo rmmod hello # 卸载模块
3.2 模块参数传递
#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 开始,内核支持模块签名验证。加载已签名的模块时,内核会验证其签名以确保没有被篡改:
# 内核配置中启用
CONFIG_MODULE_SIG=y
CONFIG_MODULE_SIG_FORCE=y # 强制要求签名
CONFIG_MODULE_SIG_ALL=y # 自动签名所有模块
内核维护两组密钥:内核编译时生成的密钥和 UEFI Secure Boot 证书链。
3.4 导出符号表
内核模块可以使用 EXPORT_SYMBOL 和 EXPORT_SYMBOL_GPL 宏将函数或变量导出,供其他模块使用:
#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)查看导出的符号:
cat /proc/kallsyms | grep calculate_checksum
3.5 模块依赖管理
模块之间的依赖关系记录在 /lib/modules/$(uname -r)/modules.dep 文件中。modprobe 工具会自动处理依赖:
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 指针:
#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):
#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:
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() 的核心工作:
- 调用
dup_task_struct()复制task_struct和内核栈 - 检查资源限制(
RLIMIT_NPROC) - 复制进程凭证(
copy_creds()) - 复制文件描述符表(
copy_files()) - 复制文件系统上下文(
copy_fs()) - 复制信号处理(
copy_sighand()、copy_signal()) - 复制内存描述符
mm_struct(copy_mm()) - 复制命名空间(
copy_namespaces()) - 分配 PID(
alloc_pid())
关键标志位控制共享行为:
| 标志 | 含义 |
|---|---|
CLONE_VM |
共享地址空间(线程) |
CLONE_FS |
共享文件系统信息 |
CLONE_FILES |
共享文件描述符表 |
CLONE_SIGHAND |
共享信号处理表 |
CLONE_THREAD |
创建线程(同线程组) |
CLONE_NEWNS |
新的挂载命名空间 |
CLONE_NEWNET |
新的网络命名空间 |
CLONE_NEWPID |
新的 PID 命名空间 |
内核线程是仅在内核空间运行的特殊进程,没有独立的地址空间(mm == NULL):
#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 |
实际运行时间计算公式:实际时间 = 调度周期 × (权重 / 总权重)
查看和调整进程调度策略:
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 架构上,虚拟地址空间分为用户空间和内核空间:
0x0000000000000000 ────────────────────
用户空间(48 位)
0x00007FFFFFFFFFFF ────────────────────
非规范地址(空洞)
0xFFFF800000000000 ────────────────────
内核空间(48 位)
0xFFFFFFFFFFFFFFFF ────────────────────
用户空间布局(典型的 64 位进程):
高地址 → 栈(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 个页) - 分配时:找到满足需求的最小块,如果当前级别没有空闲块,向上一级请求并分裂
- 释放时:检查相邻”伙伴”是否空闲,若是则合并
核心分配函数:
#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:极简实现,适合嵌入式系统
创建内核缓存:
#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 分配):
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:分配物理连续内存,直接映射,速度更快,适合 DMAvmalloc:分配虚拟连续内存,物理页可以不连续,需要设置页表,性能稍差
5.4 缺页异常处理
当进程访问尚未映射到物理内存的虚拟地址时,MMU 触发缺页异常(Page Fault)。Linux 的缺页异常处理入口是 do_page_fault():
- 检查地址是否属于进程的虚拟地址空间(
find_vma()) - 检查访问权限(读/写/执行)
- 分为三种情况处理:
- 匿名页:分配物理页并清零
- 文件映射页:从磁盘读取数据到物理页
- 写时复制(COW):复制页面并断开共享
- 更新页表,建立虚拟到物理的映射
写时复制是 fork() 效率的关键:父子进程共享只读页面,只有当任一方尝试写入时才真正复制。
5.5 页面回收与 OOM Killer
当内存紧张时,内核启动页面回收(Page Reclaim)机制:
- kswapd:后台守护进程,持续监控水位线,提前回收
- 直接回收(Direct Reclaim):分配时发现内存不足,同步回收
- OOM Killer:终极手段,选择并杀死进程释放内存
OOM 评分计算在 oom_badness() 中实现,综合考虑:
- 进程占用的内存量
- 进程的
oom_score_adj值(用户可调) - 进程运行时长和重要性
# 查看 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 定义了操作接口集合:
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)
- 写操作:默认采用”写回”策略——数据先写入页缓存标记为脏,由内核周期性写回磁盘
页缓存的核心接口:
// 查找或创建页缓存页
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 位启用,内核强制检查。
chmod g+s,g-x file # 启用强制锁
七、中断与异常处理
7.1 中断处理流程
中断分为上半部(Top Half)和下半部(Bottom Half):
- 上半部(中断处理程序):响应紧急事件,关中断运行,必须尽可能快
- 下半部:执行可延迟的非紧急工作,开中断运行
下半部机制对比:
| 机制 | 上下文 | 并发 | 适用场景 |
|---|---|---|---|
| Softirq | 中断上下文 | 同类型可在多 CPU 并行 | 高频率、低延迟(网络、块 I/O) |
| Tasklet | 中断上下文 | 同类型串行执行 | 一般的非紧急延迟工作 |
| Workqueue | 进程上下文 | 可睡眠 | 需要睡眠的延迟工作 |
7.2 注册中断处理函数
#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)
软中断是编译时静态定义的,总数有限:
// 预定义类型
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 示例:
#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 示例:
#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 上自旋),适用于持有时间极短的临界区,不能在持有自旋锁时睡眠:
#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 睡眠,适合临界区较长的场景:
#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)
信号量允许多个持有者同时进入临界区:
#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 针对读多写少的场景优化,读者完全不需要获取锁:
#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 原子操作
对于简单的整数操作,使用原子变量避免加锁开销:
#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 系统调用实现原理
从用户空间调用到内核处理的完整流程:
- 用户程序调用 C 库包装函数(如
write()) - 参数存入寄存器(x86_64:
rax=系统调用号,rdi/rsi/rdx/r10/r8/r9=参数) - 执行
syscall指令,CPU 切换到内核模式 - CPU 从
MSR_LSTAR寄存器读取入口地址,跳转到entry_SYSCALL_64 - 内核保存寄存器上下文,通过系统调用号查表(
sys_call_table) - 调用对应的内核函数(如
__x64_sys_write) - 返回用户空间,恢复寄存器
9.2 添加自定义系统调用
在内核源码中添加系统调用(仅供学习和研究,生产环境请使用其他内核接口):
// 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
用户空间调用:
#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 用户空间与内核空间数据传递
// 从用户空间拷贝数据到内核空间
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 与内核日志级别
#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>" // 调试信息
查看内核日志:
dmesg # 查看全部内核日志
dmesg -w # 实时跟踪
echo 8 > /proc/sys/kernel/printk # 调整控制台日志级别
cat /proc/kmsg # 读取内核环形缓冲区
/proc/sys/kernel/printk 的四个值:
- 控制台日志级别
- 默认消息日志级别
- 控制台最小日志级别
- 控制台默认日志级别
10.2 调试工具链
ftrace:内核函数跟踪器:
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:动态插桩:
# 在 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:性能分析:
perf top # 实时热点函数
perf record -g sleep 10 # 记录 10 秒调用栈
perf report # 查看报告
KGDB:内核级 GDB 调试,需要串口线或虚拟机支持。
10.3 内核崩溃分析
# 配置 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 内核配置中的调试选项
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 随机化内核基址,增加攻击难度:
# 检查是否启用
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 的方法:
stac(); // 启用用户空间访问
// 访问用户空间数据
clac(); // 禁止用户空间访问
11.3 内核栈保护
- Stack Canary:在栈帧放置金丝雀值,检测栈溢出(
CONFIG_STACKPROTECTOR) - 影子调用栈(SCS):arm64 上的硬件支持特性
- CFI(Control Flow Integrity):
CONFIG_CFI_CLANG防止控制流劫持
11.4 内核加固配置
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 错误处理模式
// 经典的 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 避免常见陷阱
- 不要在持有自旋锁时睡眠:这会导致死锁
- 不要在内核栈上分配大量内存:内核栈通常只有 16KB
- 复制用户空间数据前验证指针:使用
access_ok()或让copy_from_user自己处理 - 原子上下文不能调度:中断处理程序、tasklet、timer 中不能使用
mutex_lock()等可能睡眠的函数 - 注意数字溢出:内核代码中的整数溢出可能导致严重的安全漏洞
- 使用 RCU 保护的指针不能在宽限期前释放:使用
synchronize_rcu()或call_rcu() - 不要在模块卸载后保留指针:使用
try_module_get()/module_put()管理模块引用计数
12.3 内核编码风格
Linux 内核有严格的编码风格要求(Documentation/process/coding-style.rst):
- 缩进使用 8 个空格的 Tab(不是 4 个!)
- 每行不超过 80 列(注释和字符串可以到 100 列)
- K&R 风格的大括号
- 函数名、变量名使用下划线命名(snake_case)
- 类型定义使用
_t后缀 - 避免在头文件中使用
typedef
# 检查代码风格
scripts/checkpatch.pl --file my_module.c
12.4 提交内核补丁
向 Linux 主线提交补丁的流程:
- 在
linux-next或相应子系统的维护者树基础上开发 - 编写清晰的 commit message(
git format-patch -1) - 使用
scripts/get_maintainer.pl找到相关维护者和邮件列表 - 使用
git send-email发送补丁 - 在邮件列表中参与讨论,迭代修改
- 被维护者 Ack 后,补丁进入子系统树,最终合入主线
十三、总结
Linux 内核编程是一项复杂但有深度的技术工作。从内核模块的编写到核心子系统的深入理解,每一步都需要扎实的 C 语言功底和对操作系统原理的透彻掌握。本指南覆盖了内核编程的关键领域:
- 内核架构与源码结构
- 开发环境搭建与内核编译
- LKM 内核模块编程
- 进程管理与 CFS 调度器
- 内存管理:伙伴系统、Slab 分配器、页缓存
- VFS 文件系统抽象
- 中断下半部机制(Softirq / Tasklet / Workqueue)
- 内核同步:自旋锁、互斥锁、RCU、原子操作
- 系统调用实现原理
- 内核调试与安全加固
深入内核编程不仅能帮助你编写高效的驱动和内核模块,更能让你理解操作系统的底层运作机制,从而写出更优秀的用户空间程序。记住:在内核中,你是操作系统本身的一部分,你的每一个错误都可能让整个系统崩溃。 保持敬畏,持续学习。