ARTICLE · 1376060
Linux reboot 子系统源码通读:从 sys_reboot 到硬件复位
Linux 内核源码精读 · 01
reboot 是每个 Linux 用户最先学会的操作之一,但很少有人把它对应的内核代码完整读一遍。这个子系统的妙处在于:核心代码不到一千行,却把"一个复杂系统如何体面地结束自己"的全部答案写了出来——先广播告别,再按依赖顺序逐层关断,把整个系统收敛到一个核,最后交出控制权。
这篇按三步走:先列出整个流程涉及的源码路径,再给流程骨架,然后按调用顺序逐段通读代码。读完这篇,你可以在任何一个内核版本里自己把这条链走一遍。
代码版本:torvalds/linux v6.x 主线 | 全文约 3200 字 + 7 段源码,阅读约 10 分钟
一、涉及的源码路径
先把地图摊开。整个 reboot 流程涉及 6 个核心文件:
① include/uapi/linux/reboot.h
cmd 命令字和魔力数的定义——用户空间与内核的接口约定
② kernel/reboot.c
sys_reboot 系统调用、kernel_restart/halt/power_off、通知链、migrate_to_reboot_cpu、emergency_restart——主战场,流程的调度中心
③ drivers/base/core.c
device_shutdown()——第 3 步:逐台关闭设备
④ drivers/base/syscore.c
syscore_shutdown()、register_syscore()——第 5 步:关闭无 device 结构的系统核心组件
⑤ arch/arm64/kernel/process.c
machine_restart/halt/power_off(ARM64)——第 7 步:停其它 CPU、触发复位
⑥ arch/arm/kernel/process.c
同上的 ARM32 经典版——对照阅读(arm_pm_restart 函数指针版本)
另外两处按需查看:
• kernel/notifier.c —— blocking_notifier_call_chain 的实现,通知链的通用机制 • arch/arm64/mach-*/(各家 SoC 的 BSP 目录)—— 复位回调的真正实现,写 PMIC 寄存器或触发 watchdog 的代码在这里
阅读顺序建议:② → ③ → ④ → ⑤,正好是调用顺序;①随手翻一眼;⑥用来理解钩子设计的演变。
二、流程骨架
2.1 一条系统调用,三种结局
reboot、halt、poweroff 三个命令,在内核里对应同一条系统调用 sys_reboot,只是 cmd 参数不同。
关机也算 reboot?对。内核的逻辑很直白:关机之后早晚要开机,所以关机是一种"耗时特别长的重启"。一条调用,按 cmd 分发三种结局:
• kernel_restart() —— 重启 • kernel_halt() —— 停机,控制权交给 ROM monitor(如有) • kernel_power_off() —— 真正断电
三条主线结构完全一致,差异只有两处:power_off 多一步断电前准备;最后调用的 machine 层接口不同。
2.2 七步流程图
以 kernel_restart 为例,从用户敲下命令到芯片复位:
用户空间: reboot 命令(busybox / systemd)
│ reboot() 系统调用 [kernel/reboot.c]
▼
sys_reboot: 权限 → 魔力数 → pid namespace → 断电能力检查
▼
kernel_restart:
第1步 通知链广播 SYS_RESTART [kernel/reboot.c]
(watchdog 等组件在此收尾)
第2步 system_state 切换 + usermodehelper 禁用
第3步 device_shutdown 逐台关闭设备 [drivers/base/core.c]
第4步 migrate_to_reboot_cpu 收敛到单 CPU [kernel/reboot.c]
第5步 syscore_shutdown 关中断控制器、时钟 [drivers/base/syscore.c]
第6步 printk 冲出最后的日志
第7步 machine_restart [arch/arm64/kernel/process.c]
→ smp_send_stop 停其它 CPU
→ 复位回调触发硬件复位
▼
硬件: 复位信号 → 重新 boot(复位失败则死循环)一句话概括:**先礼貌地通知,再逐层关断,把整个系统收敛到一个 CPU 上,最后一行硬件代码触发复位。**流程图右边的文件标注,就是下面通读代码的行进路线。
三、源码逐段通读
按调用顺序走,每段代码后附读后感。
3.1 命令字定义(include/uapi/linux/reboot.h)
#define LINUX_REBOOT_CMD_RESTART 0x01234567
#define LINUX_REBOOT_CMD_HALT 0xCDEF0123
#define LINUX_REBOOT_CMD_CAD_ON 0x89ABCDEF
#define LINUX_REBOOT_CMD_CAD_OFF 0x00000000
#define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC
#define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4
#define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2
#define LINUX_REBOOT_CMD_KEXEC 0x4558454C每个 cmd 都是精心挑选的"随机数"——它们和魔力数一起构成防误调用的第二道防线。CAD_ON/CAD_OFF 只控制 Ctrl-Alt-Del 组合键的行为,SW_SUSPEND 和 KEXEC 是另外两条支线(休眠、启动新内核),本文不展开。
3.2 入口:sys_reboot 的四道门(kernel/reboot.c)
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
void __user *, arg)
{
struct pid_namespace *pid_ns = task_active_pid_ns(current);
/* 门1:权限。CAP_SYS_BOOT 就是 root,否则 -EPERM */
if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
return -EPERM;
/* 门2:魔力数。magic2 有 4 个合法值,纯防误操作设计 */
if (magic1 != LINUX_REBOOT_MAGIC1 ||
(magic2 != LINUX_REBOOT_MAGIC2 &&
magic2 != LINUX_REBOOT_MAGIC2A &&
magic2 != LINUX_REBOOT_MAGIC2B &&
magic2 != LINUX_REBOOT_MAGIC2C))
return -EINVAL;
/* 门3:容器。子 pid namespace 里的 reboot 只退出该 namespace
* (内部 do_exit),不会动真机 */
ret = reboot_pid_ns(pid_ns, cmd);
if (ret)
return ret;
/* 门4:降级。平台不支持断电时,POWER_OFF 自动改成 HALT */
if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !kernel_can_power_off()) {
poweroff_fallback_to_halt = true;
cmd = LINUX_REBOOT_CMD_HALT;
}
mutex_lock(&system_transition_mutex);
switch (cmd) {
case LINUX_REBOOT_CMD_RESTART:
kernel_restart(NULL); /* 普通重启 */
break;
case LINUX_REBOOT_CMD_HALT:
kernel_halt();
do_exit(0); /* 停机后调用进程直接退出 */
case LINUX_REBOOT_CMD_POWER_OFF:
kernel_power_off();
do_exit(0);
break;
case LINUX_REBOOT_CMD_RESTART2:
/* 重启+携带字符串:如 "reboot bootloader" 进 fastboot,
* 从用户空间拷 256 字节,一路传到 machine 层 */
ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1);
...
kernel_restart(buffer);
break;
...
}
mutex_unlock(&system_transition_mutex);
}读后感:四道门全是"别误重机"的防御设计。RESTART2 的 buffer[256] 是个容易被忽略的细节——手机上"重启到 bootloader"就是这个字符串从用户空间一路传到 SoC 复位回调的。全程持 system_transition_mutex,防止 shutdown 和 suspend 并发打架。
3.3 主线:kernel_restart 和它的两个兄弟(kernel/reboot.c)
void kernel_restart(char *cmd)
{
kernel_restart_prepare(cmd); /* 第1~3步:通知、切状态、关设备 */
do_kernel_restart_prepare(); /* restart handler 预备 */
migrate_to_reboot_cpu(); /* 第4步:收敛单 CPU */
syscore_shutdown(); /* 第5步:关系统核心 */
if (!cmd)
pr_emerg("Restarting system\n");
else
pr_emerg("Restarting system with command '%s'\n", cmd);
kmsg_dump(KMSG_DUMP_SHUTDOWN); /* 第6步:临终日志落盘 */
machine_restart(cmd); /* 第7步:交给 arch 层,一去不返 */
}
EXPORT_SYMBOL_GPL(kernel_restart);void kernel_halt(void)
{
kernel_shutdown_prepare(SYSTEM_HALT);
migrate_to_reboot_cpu();
syscore_shutdown();
if (poweroff_fallback_to_halt)
pr_emerg("Power off not available: System halted instead\n");
/* 本想关机但平台不支持,降级成了 halt */
kmsg_dump(KMSG_DUMP_SHUTDOWN);
machine_halt();
}
void kernel_power_off(void)
{
kernel_shutdown_prepare(SYSTEM_POWER_OFF);
do_kernel_power_off_prepare(); /* 比 restart 多的一步:
断电前的平台收尾(如 ACPI S5) */
migrate_to_reboot_cpu();
syscore_shutdown();
pr_emerg("Power down\n");
pr_flush(1000, true); /* 等 printk 冲刷完,最多 1 秒 */
kmsg_dump(KMSG_DUMP_SHUTDOWN);
machine_power_off();
}读后感:三个函数摆在一起看,结构完全一样。前半段(收尾工作)和后半段(拉闸)之间没有任何弯路——关机流程没有重试、没有回退,每一步都默认成功,因为走到这里已经没有"失败后再试试"的余地了。
3.4 第 1~3 步:两条 prepare,差异全在通知事件(kernel/reboot.c)
void kernel_restart_prepare(char *cmd)
{
blocking_notifier_call_chain(&reboot_notifier_list,
SYS_RESTART, cmd); /* 第1步:广播 */
system_state = SYSTEM_RESTART; /* 第2步:切状态 */
usermodehelper_disable(); /* 禁止拉起用户态进程 */
device_shutdown(); /* 第3步:关设备 */
}
static void kernel_shutdown_prepare(enum system_states state)
{
blocking_notifier_call_chain(&reboot_notifier_list,
(state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL);
system_state = state;
usermodehelper_disable();
device_shutdown();
}读后感:两条 prepare 只差通知链的事件类型,后面动作一字不差。两个关键机制:
• 通知链是内核的经典解耦手段。register_reboot_notifier() 供驱动注册,典型用户是 watchdog——重启前必须先停狗,否则流程走到一半被狗超时复位,好好的重启变成随机重启; • system_state 是全局变量,很多驱动靠它判断"系统是不是正在关机"。从这一步起,系统进入"半死"状态。
3.5 第 3 步重点:device_shutdown,驱动作者最该读的一段(drivers/base/core.c)
void device_shutdown(void)
{
struct device *dev, *parent;
wait_for_device_probe(); /* 等所有未完成的 probe 结束 */
device_block_probing(); /* 再禁止新的 probe */
cpufreq_suspend(); /* 先把调频子系统挂起——
频率从此不能再动 */
spin_lock(&devices_kset->list_lock);
/*
* Walk the devices list backward, shutting down each in turn.
* 倒序遍历:后注册的先关(叶子先死,控制器后死)
*/
while (!list_empty(&devices_kset->list)) {
dev = list_entry(devices_kset->list.prev,
struct device, kobj.entry);
parent = get_device(dev->parent); /* 持 parent 引用,
防止锁 parent 时被释放 */
get_device(dev);
list_del_init(&dev->kobj.entry); /* 先摘出链表——防止
shutdown 回调里自删出乱子 */
spin_unlock(&devices_kset->list_lock);
if (parent)
device_lock(parent);
device_lock(dev); /* 持锁防与 probe/release 竞争 */
pm_runtime_get_noresume(dev); /* 冻结 Runtime PM:
不允许再有运行时挂起/恢复 */
pm_runtime_barrier(dev);
/* 关设备的三层优先级,写死在 if-else 里 */
if (dev->class && dev->class->shutdown_pre)
dev->class->shutdown_pre(dev); /* 最外层 */
if (dev->bus && dev->bus->shutdown)
dev->bus->shutdown(dev); /* 总线优先 */
else if (dev->driver && dev->driver->shutdown)
dev->driver->shutdown(dev); /* 驱动兜底 */
device_unlock(dev);
if (parent)
device_unlock(parent);
put_device(dev);
put_device(parent);
spin_lock(&devices_kset->list_lock);
}
spin_unlock(&devices_kset->list_lock);
}这段代码三个设计点,逐个说透:
① bus 优先于 driver,是双保险。 总线统一处理一类设备(比如 USB 总线统一复位挂载的设备),总线实现了就用总线的;没实现才退回驱动自己的。设备驱动作者要做的就一件事:实现 ->shutdown 回调,把设备放进安全状态。
② 倒序遍历维护的是依赖关系。 设备树是"控制器在上、叶子在下",从链表尾部倒着取,叶子先关、控制器后关——温控设备如果依赖某个时钟或总线,注册顺序决定了它死前还能不能工作。
③ 边走边删的写法。 每处理完一台就 list_del_init 摘出链表,一台设备不会被关两次;摘出后立刻放开自旋锁再调回调,因为 shutdown 回调可能睡眠,不能持自旋锁调它。开头那行 cpufreq_suspend() 是当前主线新增的——关机流程的第一批动作里就有电源管理。
3.6 第 4 步:migrate_to_reboot_cpu,多核重启的硬前提(kernel/reboot.c)
void migrate_to_reboot_cpu(void)
{
int cpu = reboot_cpu; /* 默认 boot CPU(cpu0) */
cpu_hotplug_disable(); /* 禁止热插拔捣乱 */
/* 万一 cpu0 已 offline,随便挑一个在线的 */
if (!cpu_online(cpu))
cpu = cpumask_first(cpu_online_mask);
current->flags |= PF_NO_SETAFFINITY; /* 防止别的任务把我迁走 */
set_cpus_allowed_ptr(current, cpumask_of(cpu)); /* 钉死在这个核 */
}为什么必须收敛:这次系统调用可能在任意核上触发,后面的 syscore 和硬件复位只能由一个 CPU 干。这一步执行完,全系统只剩一个 CPU 还在跑——ARM64 代码注释里写得很直白:必须保证所有 CPU 同时复位,否则复位后主 CPU 的代码还要跟"没死干净"的其它 CPU 协调内存,这基本不可能做到。
3.7 第 5 步:syscore_shutdown,没有 device 结构的组件走这条路(drivers/base/syscore.c)
void syscore_shutdown(void)
{
struct syscore *syscore;
mutex_lock(&syscore_lock);
/* 倒序遍历,和 device_shutdown 同一个原则 */
list_for_each_entry_reverse(syscore, &syscore_list, node)
if (syscore->ops->shutdown) {
if (initcall_debug)
pr_info("PM: Calling %pS\n",
syscore->ops->shutdown);
syscore->ops->shutdown(syscore->data);
}
mutex_unlock(&syscore_lock);
}中断控制器、时钟这些最底层组件没有对应的 struct device,走不了 device_shutdown,只能通过 register_syscore() 单独注册。值得注意的巧思:同一个 syscore 结构里还有 suspend/resume 回调(给休眠用)——关机、休眠、挂起,最底层那一段共用同一批注册回调。这就是这套代码叫 "Generic PM" 的原因。
3.8 第 7 步:machine_restart,arch 与 machine 解耦的范式(arch/arm64/kernel/process.c)
void machine_restart(char *cmd)
{
local_irq_disable(); /* 先关中断 */
smp_send_stop(); /* 停掉所有其它 CPU */
if (efi_enabled(EFI_RUNTIME_SERVICES))
efi_reboot(reboot_mode, NULL); /* UEFI 场景走 ResetSystem() */
do_kernel_restart(cmd); /* 通知链:各 SoC 注册的复位回调 */
/* Whoops - the architecture was unable to reboot. */
printk("Reboot failed -- System halted\n"); /* 能走到这 = 失败 */
while (1); /* 死循环等死 */
}
void machine_halt(void)
{
local_irq_disable();
smp_send_stop();
while (1); /* 最简单:关中断 + 停核 + 死循环 */
}
void machine_power_off(void)
{
local_irq_disable();
smp_send_stop();
do_kernel_power_off(); /* 同样走通知链 */
}复位回调这一层的设计很值得玩味:arch 层只留一个钩子——ARM32 时代是函数指针 arm_pm_restart(arch/arm/kernel/process.c 声明,各家 BSP 在 mach-xxx 里赋值),现在演进为 register_restart_handler() 注册的通知链(还支持优先级)。每家 SoC 自己来填:写 PMIC 寄存器也好,触发 watchdog 也好,内核不关心复位的具体方式,只关心"所有 CPU 必须同时复位"这个硬约束。钩子的形态十几年间换过,"arch 留钩子、machine 来填"的思想一厘米没动。
还有一条支线值得知道:emergency_restart()(kernel/reboot.c)——panic、SysRq-b 用的逃生通道,一步收尾工作都不做,直接 machine_emergency_restart()。对比正常流程的七步,就知道"体面"两字的成本有多高,以及系统烂到什么程度才会放弃体面。
四、几个可以带走的设计结论
通读完整条链,reboot 子系统留给读者的设计模式有四个:
1. 分层交接:用户空间 → 系统调用 → 通用收尾 → 设备层 → 核心层 → arch 层 → machine 层,每层只做自己的事,交接边界清晰 2. 倒序关断:device_shutdown 和 syscore_shutdown 都是倒序遍历——按依赖关系死亡,后注册的先死 3. 钩子解耦:arch 层留钩子、SoC 的 BSP 来填,同一套骨架支撑所有厂商的芯片 4. 单点收敛:多核系统的所有收尾,最终收敛到一个 CPU 上执行——这是硬件复位的物理约束决定的
下次再看"重启"这个动作,它不再是黑盒:哪一步发通知、哪一步关设备、哪一步只剩一个核、复位失败时代码停在哪一行,全部有出处。
reboot 的核心代码不到一千行,却是学习内核分层设计最好的入口之一:麻雀虽小,通知链、设备模型、CPU 收敛、arch/machine 解耦全在里面,而且每一段都短到可以一次读完。
这是「Linux 内核源码精读」系列的第一篇。下一篇读 cpufreq:调频 governor 和 thermal cooling 怎么在同一套框架里互相拉扯——那是功耗和性能真正短兵相接的地方。
读源码时发现什么细节、有什么不同理解,评论区见。下一篇继续。















































































