夜雨聆风学习资料网

ARTICLE · 1376060

Linux reboot 子系统源码通读:从 sys_reboot 到硬件复位

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. 1. 分层交接:用户空间 → 系统调用 → 通用收尾 → 设备层 → 核心层 → arch 层 → machine 层,每层只做自己的事,交接边界清晰
  2. 2. 倒序关断:device_shutdown 和 syscore_shutdown 都是倒序遍历——按依赖关系死亡,后注册的先死
  3. 3. 钩子解耦:arch 层留钩子、SoC 的 BSP 来填,同一套骨架支撑所有厂商的芯片
  4. 4. 单点收敛:多核系统的所有收尾,最终收敛到一个 CPU 上执行——这是硬件复位的物理约束决定的

下次再看"重启"这个动作,它不再是黑盒:哪一步发通知、哪一步关设备、哪一步只剩一个核、复位失败时代码停在哪一行,全部有出处。

reboot 的核心代码不到一千行,却是学习内核分层设计最好的入口之一:麻雀虽小,通知链、设备模型、CPU 收敛、arch/machine 解耦全在里面,而且每一段都短到可以一次读完。

这是「Linux 内核源码精读」系列的第一篇。下一篇读 cpufreq:调频 governor 和 thermal cooling 怎么在同一套框架里互相拉扯——那是功耗和性能真正短兵相接的地方。

读源码时发现什么细节、有什么不同理解,评论区见。下一篇继续。

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料