夜雨聆风学习资料网

ARTICLE · 1393097

内核源码精读 03 | suspend 与 resume:醒来的路,是睡下去的路倒着走

内核源码精读 03 | suspend 与 resume:醒来的路,是睡下去的路倒着走

系列第 03 篇。上一篇我们看 cpufreq 和 thermal 在运行时怎么互相拉扯;这一篇看一个更极端的问题——当整个系统决定睡觉时,内核里发生了什么?以及它醒来时的样子是否和睡下去时一模一样、方向相反?


一、涉及的源码路径

这一篇的主战场非常集中,只有三个文件、一处数据结构:

文件
行数级别
职责
kernel/power/main.c
~700
用户态入口:sysfs 的 /sys/power/state 接口
kernel/power/suspend.c
~650
主干
:整条休眠/唤醒链的编排
drivers/base/power/main.c
~1900
设备层:dpm_list 链表遍历与驱动回调分发
include/linux/pm.h
 等
—
pm_message_t
、PM notifier 等定义(辅助)

另外要提前认识两个"名册":

  • • dpm_list:全系统所有注册过 PM 能力的设备挂在上面,drivers/base/power/main.c 管"点名"——谁睡了、谁没睡、按什么顺序
  • • suspend_ops:平台钩子(ACPI / ARM PSCI / SoC 自家代码),内核把"怎么断 CPU 的电"留给平台,自己管流程

读代码的顺序建议:main.c 的 state_store → suspend.c 从上往下通读 → drivers/base/power/main.c 只看 dpm_suspend 和 dpm_resume 两个函数。

动手之前,先看这篇讲的 suspend/resume 在整个电源管理版图里的位置——它是"内核 PM 核心"那条线的系统级出口:

Linux 电源管理全景图

图注:suspend/resume 属于第二层 kernel/power 的核心职能;第三层的 cpufreq/cpuidle/devfreq/thermal 是"醒着时"的日常省电,suspend 是"都闲下来"的终极手段。上一篇的 cpufreq×thermal 拉扯发生在第三层,这一篇进到第二层。


二、流程骨架

先看骨架,再看血肉。整条链可以画成两列——左列睡下去,右列原路返回:

suspend 与 resume 的镜像调用链

图注:蓝色是休眠链,绿色是唤醒链。睡眠发生在左列最后一格 ops->enter() 内部——CPU 在这行断电,唤醒中断把执行流从这一行原样送回,然后右列从上往下把睡前的每一步倒放一遍。

写成文字版(方便对照源码):

【休眠链:从上往下】

用户态: echo mem > /sys/power/state
  └─ state_store()            main.c     解析目标状态,mem→pm_suspend()
      └─ pm_suspend()         suspend.c  平台入口检查 → enter_state()
          └─ enter_state()               总指挥
              ├─ suspend_prepare()       通知链 → 冻结全部用户进程
              └─ suspend_devices_and_enter()
                  ├─ dpm_suspend_start() 设备逆序逐个睡(含 cpufreq/devfreq 收尾)
                  └─ suspend_enter()
                      ├─ 关非启动CPU、关中断
                      ├─ syscore_suspend()   系统地基最后睡
                      └─ suspend_ops->enter() ★ CPU 在这一行断电

【唤醒链:严格镜像返回】

唤醒中断(已注册的 wakeup source)
  └─ 从 suspend_ops->enter() 返回
      └─ syscore_resume()            地基先醒
          └─ 非启动CPU上线、开中断
              └─ dpm_resume_end()    设备正序逐个醒(cpufreq/devfreq 复位)
                  └─ suspend_finish() 解冻进程 → 回到调度

记住一句话就抓住了全部:睡下去的每一步,醒来时都被原样倒放。


三、源码逐段通读

以下代码全部取自 torvalds/linux 主线(v6.x),逐段加读后感。

3.1 入口:state_store()——一个 sysfs 写入,两条岔路

static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
               const
 char *buf, size_t n)

{
    suspend_state_t
 state;
    int
 error;

    error = pm_autosleep_lock();
    if
 (error)
        return
 error;

    if
 (pm_autosleep_state() > PM_SUSPEND_ON) {
        error = -EBUSY;
        goto
 out;
    }

    state = decode_state(buf, n);
    if
 (state < PM_SUSPEND_MAX) {
        if
 (state == PM_SUSPEND_MEM)
            state = mem_sleep_current;

        error = pm_suspend(state);
    } else if (state == PM_SUSPEND_MAX) {
        error = hibernate();
    } else {
        error = -EINVAL;
    }

 out:
    pm_autosleep_unlock();
    return
 error ? error : n;
}

power_attr(state);

读后感:

● 这个函数是 cat /sys/power/state 能看到的接口背后的写回调(power_attr(state) 注册的)。写入 "mem" 走 pm_suspend(),写入 "disk" 走 hibernate()(休眠到盘)——suspend 和 hibernate 在第一个岔路口就分家了,本文只跟左边那条。

● state == PM_SUSPEND_MEM 时取的是 mem_sleep_current——mem 其实是个"模式指针":在 sysfs 的 /sys/power/mem_sleep 里可以在 s2idle(浅睡,现代笔记本和 Android 常用)和 deep(真 S3)之间切换,同一个 "mem",底层可能睡得完全不一样深。

● 开头的 pm_autosleep_lock 是给 Android 式自动休眠(wakeup 计数归零自动睡)留的门,桌面系统不走这条路。

3.2 总指挥:enter_state()——先把自己锁起来

static int enter_state(suspend_state_t state)
{
    int
 error;

    trace_suspend_resume(TPS("suspend_enter"), state, true);
    if
 (state == PM_SUSPEND_TO_IDLE) {
#ifdef CONFIG_PM_DEBUG

        if
 (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
            pr_warn("Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform.\n");
            return
 -EAGAIN;
        }
#endif

    } else if (!valid_state(state)) {
        return
 -EINVAL;
    }
    if
 (!mutex_trylock(&system_transition_mutex))
        return
 -EBUSY;

    if
 (state == PM_SUSPEND_TO_IDLE)
        s2idle_begin();

    if
 (sync_on_suspend_enabled) {
        trace_suspend_resume(TPS("sync_filesystems"), 0, true);

        error = pm_sleep_fs_sync();
        if
 (error)
            goto
 Unlock;

        trace_suspend_resume(TPS("sync_filesystems"), 0, false);
    }

    pm_pr_dbg("Preparing system for sleep (%s)\n", mem_sleep_labels[state]);
    pm_suspend_clear_flags();
    error = suspend_prepare(state);
    if
 (error)
        goto
 Unlock;

    if
 (suspend_test(TEST_FREEZER))
        goto
 Finish;

    trace_suspend_resume(TPS("suspend_enter"), state, false);
    pm_pr_dbg("Suspending system (%s)\n", mem_sleep_labels[state]);
    error = suspend_devices_and_enter(state);

 Finish:
    events_check_enabled = false;
    pm_pr_dbg("Finishing wakeup.\n");
    suspend_finish();
 Unlock:
    mutex_unlock(&system_transition_mutex);
    return
 error;
}

读后感:

● mutex_trylock(&system_transition_mutex) 用的是 trylock 而不是 lock:两个"睡觉请求"同时来,后到的直接返回 -EBUSY 拒绝,而不是排队等第一个醒来——睡眠是全局唯一状态,没有"睡一半再叠一层"。

● sync_on_suspend_enabled:睡之前把文件系统脏页落盘,断电前的最后保险。

● 注意结尾的对称结构:suspend_prepare() 睡前准备 → suspend_devices_and_enter() 进出睡眠 → suspend_finish() 醒后清理,三个函数的失败路径全部汇聚到同一个 Unlock 出口——这是整篇代码都在贯彻的"失败即回退"纪律的第一个样本。

3.3 睡前点名:suspend_prepare()——通知与冻结

static int suspend_prepare(suspend_state_t state)
{
    int
 error;

    if
 (!sleep_state_supported(state))
        return
 -EPERM;

    pm_prepare_console();

    error = pm_notifier_call_chain_robust(PM_SUSPEND_PREPARE, PM_POST_SUSPEND);
    if
 (error)
        goto
 Restore;

    filesystems_freeze(filesystem_freeze_enabled);
    trace_suspend_resume(TPS("freeze_processes"), 0, true);
    error = suspend_freeze_processes();
    trace_suspend_resume(TPS("freeze_processes"), 0, false);
    if
 (!error)
        return
 0;

    dpm_save_failed_step(SUSPEND_FREEZE);
    filesystems_thaw();
    pm_notifier_call_chain(PM_POST_SUSPEND);
 Restore:
    pm_restore_console();
    return
 error;
}

读后感:

● pm_notifier_call_chain_robust(PM_SUSPEND_PREPARE, PM_POST_SUSPEND)——注意是 robust 版本:任何 notifier 回调返回失败,框架自动给所有已收到 PREPARE 的回调补发 POST_SUSPEND,让它们回滚。内核把"通知了就要负责善后"做成了框架行为,不靠每个回调自己小心。

● suspend_freeze_processes() 冻结全部用户进程,这是硬门槛:任何进程停在不可中断状态(典型:等 IO 卡死),冻结失败 → dpm_save_failed_step(SUSPEND_FREEZE) 记录失败步骤 → 反向解冻 → 休眠取消。手机的"灭屏后睡不下去"问题,很多就卡在这一步——查法是看 freezer 超时日志和 /sys/power/pm_wakeup_irq。

● dpm_save_failed_step() 配合 /sys/power/pm_test 可以逐层演练休眠(先只走到 freezer、再走到 devices、再走到 core……),是功耗调试的官方脚手架。

3.4 设备阶段:suspend_devices_and_enter()——睡觉是个循环

int suspend_devices_and_enter(suspend_state_t state)
{
    int
 error;
    bool
 wakeup = false;

    if
 (!sleep_state_supported(state))
        return
 -ENOSYS;

    pm_suspend_target_state = state;

    if
 (state == PM_SUSPEND_TO_IDLE)
        pm_set_suspend_no_platform();

    error = platform_suspend_begin(state);
    if
 (error)
        goto
 Close;

    console_suspend_all();
    suspend_test_start();
    error = dpm_suspend_start(PMSG_SUSPEND);
    if
 (error) {
        pr_err("Some devices failed to suspend, or early wake event detected\n");
        goto
 Recover_platform;
    }
    suspend_test_finish("suspend devices");
    if
 (suspend_test(TEST_DEVICES))
        goto
 Recover_platform;

    do
 {
        error = suspend_enter(state, &wakeup);
    } while (!error && !wakeup && platform_suspend_again(state));

 Resume_devices:
    suspend_test_start();
    dpm_resume_end(PMSG_RESUME);
    suspend_test_finish("resume devices");
    trace_suspend_resume(TPS("console_resume_all"), state, true);
    console_resume_all();
    trace_suspend_resume(TPS("console_resume_all"), state, false);

 Close:
    platform_resume_end(state);
    pm_suspend_target_state = PM_SUSPEND_ON;
    return
 error;

 Recover_platform:
    platform_recover(state);
    goto
 Resume_devices;
}

读后感:

● dpm_suspend_start(PMSG_SUSPEND) 把整个设备世界交出去(3.6 看内部),然后才轮到 suspend_enter() 碰 CPU。

● 最有意思的是中间那个 do-while 循环:while (!error && !wakeup && platform_suspend_again(state))——醒来之后,如果平台说"条件还合适",系统可以立刻再睡一次,这就是 SoC 上"反复进出浅睡攒待机时长"的框架支持,wakeup 置位或出错才真正退出循环。

● Recover_platform 标签:设备睡挂了,先请平台抢救(platform_recover),然后仍然走完整条 resume 路径——不是崩溃重启,是把系统原样拉回来。连 printk 的输出终端都要先睡(console_suspend_all),防止睡的过程中串口驱动还在收发。

3.5 深水区:suspend_enter()——关灯前的最后检查

static int suspend_enter(suspend_state_t state, bool *wakeup)
{
    int
 error;

    error = platform_suspend_prepare(state);
    if
 (error)
        goto
 Platform_finish;

    error = dpm_suspend_late(PMSG_SUSPEND);
    if
 (error) {
        pr_err("late suspend of devices failed\n");
        goto
 Platform_finish;
    }
    error = platform_suspend_prepare_late(state);
    if
 (error)
        goto
 Devices_early_resume;

    error = dpm_suspend_noirq(PMSG_SUSPEND);
    if
 (error) {
        pr_err("noirq suspend of devices failed\n");
        goto
 Platform_early_resume;
    }
    error = platform_suspend_prepare_noirq(state);
    if
 (error)
        goto
 Platform_wake;

    if
 (suspend_test(TEST_PLATFORM))
        goto
 Platform_wake;

    if
 (state == PM_SUSPEND_TO_IDLE) {
        s2idle_loop();
        goto
 Platform_wake;
    }

    error = pm_sleep_disable_secondary_cpus();
    if
 (error || suspend_test(TEST_CPUS))
        goto
 Enable_cpus;

    arch_suspend_disable_irqs();
    BUG_ON(!irqs_disabled());

    system_state = SYSTEM_SUSPEND;

    error = syscore_suspend();
    if
 (!error) {
        *wakeup = pm_wakeup_pending();
        if
 (!(suspend_test(TEST_CORE) || *wakeup)) {
            trace_suspend_resume(TPS("machine_suspend"),
                state, true);
            error = suspend_ops->enter(state);
            trace_suspend_resume(TPS("machine_suspend"),
                state, false);
        } else if (*wakeup) {
            error = -EBUSY;
        }
        syscore_resume();
    }

    system_state = SYSTEM_RUNNING;

    arch_suspend_enable_irqs();
    BUG_ON(irqs_disabled());

 Enable_cpus:
    pm_sleep_enable_secondary_cpus();

 Platform_wake:
    platform_resume_noirq(state);
    dpm_resume_noirq(PMSG_RESUME);

 Platform_early_resume:
    platform_resume_early(state);

 Devices_early_resume:
    dpm_resume_early(PMSG_RESUME);

 Platform_finish:
    platform_resume_finish(state);
    return
 error;
}

读后感:

● 设备的睡眠其实是三段式——dpm_suspend(普通回调)→ dpm_suspend_late → dpm_suspend_noirq(关中断后还要执行的回调),把"还能睡觉中断的设备"和"必须在中断全关后才能碰的设备"分开处理;层次越多,失败路径的标签越多(看那串 goto,每个对应一段已完成工作的回滚起点)。

最精妙的两行在睡着之前:

    *wakeup = pm_wakeup_pending();
    if
 (!(suspend_test(TEST_CORE) || *wakeup)) {
        error = suspend_ops->enter(state);

● 断电前的最后一刻,再问一次"有没有唤醒事件挂着?"——有就根本不进 enter,直接返回 -EBUSY 走唤醒路径。这防的是最尴尬的场景:刚关灯就响铃,白关一次灯还多耗一次进出睡眠的动态功耗。写功耗测试用例的人应该认得这个模式:睡前检查、睡后校验,是待机功耗优化的通用骨架。

● syscore_suspend() / syscore_resume() 是地基层(timekeeping、中断控制器根域),没有设备模型身份,单独走 syscore 通道,最后睡、最先醒。ops->enter(state) 前后各一个 trace 点:perfetto trace 里那一段长长的空白,就是这行代码。

3.6 镜像的实现:dpm_suspend() vs dpm_resume()——差两个字

现在回答"为什么醒来和睡下去一模一样、方向相反"。答案在设备点名函数里,把两个函数并排放:

int dpm_suspend(pm_message_t state)
{
    ktime_t
 starttime = ktime_get();
struct device *dev;

    int
 error;

    trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
    might_sleep();

    devfreq_suspend();
    cpufreq_suspend();

    pm_transition = state;
    async_error = 0;

    mutex_lock(&dpm_list_mtx);

    /*
     * Start processing "async" leaf devices upfront so they don't need to
     * wait for the "sync" devices they don't depend on.
     */

    list_for_each_entry_reverse(dev, &dpm_prepared_list, power.entry) {
        dpm_clear_async_state(dev);
        if
 (dpm_leaf_device(dev))
            dpm_async_with_cleanup(dev, async_suspend);
    }

    while
 (!list_empty(&dpm_prepared_list)) {
        dev = to_device(dpm_prepared_list.prev);

        list_move(&dev->power.entry, &dpm_suspended_list);

        if
 (dpm_async_fn(dev, async_suspend))
            continue
;

        get_device(dev);

        mutex_unlock(&dpm_list_mtx);

        device_suspend(dev, state, false);

        put_device(dev);

        mutex_lock(&dpm_list_mtx);

        if
 (READ_ONCE(async_error)) {
            dpm_async_suspend_complete_all(&dpm_prepared_list);
            /*
             * Move all devices to the target list to resume them
             * properly.
             */

            list_splice_init(&dpm_prepared_list, &dpm_suspended_list);
            break
;
        }
    }

    mutex_unlock(&dpm_list_mtx);

    async_synchronize_full();

    error = READ_ONCE(async_error);
    if
 (error)
        dpm_save_failed_step(SUSPEND_SUSPEND);

    dpm_show_time(starttime, state, error, NULL);
    trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
    return
 error;
}
void dpm_resume(pm_message_t state)
{
struct device *dev;

    ktime_t
 starttime = ktime_get();

    trace_suspend_resume(TPS("dpm_resume"), state.event, true);

    pm_transition = state;
    async_error = 0;

    mutex_lock(&dpm_list_mtx);

    /*
     * Start processing "async" root devices upfront so they don't wait for the
     * "sync" devices they don't depend on.
     */

    list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
        dpm_clear_async_state(dev);
        if
 (dpm_root_device(dev))
            dpm_async_with_cleanup(dev, async_resume);
    }

    while
 (!list_empty(&dpm_suspended_list)) {
        dev = to_device(dpm_suspended_list.next);
        list_move_tail(&dev->power.entry, &dpm_prepared_list);

        if
 (!dpm_async_fn(dev, async_resume)) {
            get_device(dev);

            mutex_unlock(&dpm_list_mtx);

            device_resume(dev, state, false);

            put_device(dev);

            mutex_lock(&dpm_list_mtx);
        }
    }
    mutex_unlock(&dpm_list_mtx);
    async_synchronize_full();
    dpm_show_time(starttime, state, 0, NULL);
    if
 (READ_ONCE(async_error))
        dpm_save_failed_step(SUSPEND_RESUME);

    cpufreq_resume();
    devfreq_resume();
    trace_suspend_resume(TPS("dpm_resume"), state.event, false);
}

读后感(本篇的核心):

● 方向的实现只需两个字——睡是 dpm_prepared_list.prev(从链表尾部拿设备),醒是 dpm_suspended_list.next(从链表头部拿设备)。同一个链表,遍历方向相反:注册顺序天然形成依赖序(父先于子),睡的时候尾→头(叶子先睡),醒的时候头→尾(父先醒)。没有写两套顺序逻辑,一个链表的两个方向就是全部。

还有一处和上一篇的直接联动,藏在 dpm_suspend 开头:

    devfreq_suspend();
    cpufreq_suspend();

● 整个系统睡之前,governor 先停摆——运行时调频框架自己是被 suspend 流程关掉的(dpm_resume 尾部对称地有 cpufreq_resume())。这解释了一个 trace 现象:睡眠期间 schedutil 完全静默,频率切换事件消失。上一篇讲的"thermal 和 governor 的拉扯"只发生在醒着的每一毫秒;睡前 governor 立刻下岗,约束(QoS)保留、执行者停班。

● 异步优化也值得停一眼:睡之前先扫描叶子设备(dpm_leaf_device,不依赖任何其他设备)提前并发处理,醒的时候对称地先处理根设备——设备多到几千个的现代 SoC 上,这是把 suspend 时间压下来的主要手段。suspend/resume 耗时本身就是功耗优化的 KPI:进睡眠慢,动态功耗白烧。失败路径依旧贯彻"全部转正再回滚":async_error 一旦置位,把剩余设备全部移入 suspended_list,保证 resume 时一个不漏地被唤醒。

3.7 收尾:suspend_finish()——解冻,回到人间

static void suspend_finish(void)
{
    suspend_thaw_processes();
    filesystems_thaw();
    pm_notifier_call_chain(PM_POST_SUSPEND);
    pm_restore_console();
}

读后感:

● 四行对应 3.3 节的四行,严格对仗——解冻进程 ↔ 冻结进程、解冻文件系统 ↔ 冻结、PM_POST_SUSPEND ↔ PM_SUSPEND_PREPARE、恢复控制台 ↔ 准备控制台。

● 这里能看清整篇的结构美学:enter_state 三段、suspend_prepare 四行、dpm_suspend/resume 两列、suspend_finish 四行,每一层都是"原路镜像"。这不是巧合,是内核对"全局状态转换"的标准设计姿势:先建立对称,再填内容。


四、设计结论

  1. 1. 镜像式状态机:suspend/resume 共用一份设备链表、一套回调、两条遍历方向。对称性不是事后保证的,是结构自带的——"醒来的顺序"根本不存在另一份代码
  2. 2. 失败即回退,回退即复用:任何一步失败,不做专门的"恢复逻辑",直接走正常 resume 路径。代码量减半,且恢复逻辑永远和成功路径一样被测试到
  3. 3. 睡前最后一刻的检查:pm_wakeup_pending() 放在最深处、断电前一瞬。省电优化的黄金位置往往就是这种"最后半步"——不白睡一次
  4. 4. 分层收权:进程 → 文件系统 → 设备 → CPU → 中断 → 地基(syscore)→ 平台,一层层收,醒的时候一层层还。和第 01 篇 reboot 的"逐层下线"是同一套哲学:内核关机/休眠类流程,都是有序地放弃控制权

本文结构与分析由作者构思,源码与资料由 AI 辅助整理,全部内容经作者逐段核对。

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

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

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

相关学习资料