不懂 内核延迟机制,别说你懂 Linux 驱动开发

在 Linux 驱动开发中，多数开发者深耕硬件适配、寄存器配置与设备注册等基础功能，却常常忽视内核延迟机制这一核心底层能力。事实上，延迟与延时调度是驱动衔接硬件与系统内核的关键桥梁，无论是硬件初始化等待、数据传输同步、设备状态巡检，还是中断上下文的任务处理，都离不开各类延迟机制的支撑。它并非简单的延时工具，而是保障设备时序精准、系统运行稳定的核心机制，是进阶驱动开发的必备技能。

很多新手开发常陷入误区，盲目使用忙等待、通用休眠函数，忽略上下文适配、CPU 资源占用与延时精度问题，最终引发驱动卡顿、系统崩溃、数据异常等顽固 bug。不同场景下的微秒短延时、毫秒休眠、延后工作队列、定时器调度等机制各有适配规则，一旦用错便会埋下隐患。吃透内核延迟的底层原理、适用场景与优劣差异，才能跳出基础编码局限，写出高效、稳定、适配工业级场景的高质量驱动代码。

一、初识 Linux 内核延时

面试题写作模版

1.1 延时的定义与作用

在 Linux 内核中，延时是指让程序执行流暂停一段时间的操作 。从宏观角度看，它就像是给程序执行按下了 “暂停键”，在指定的时间内，程序不会继续执行后续的代码，而是处于等待状态。

延时在 Linux 内核中有着多方面的重要作用。在硬件操作方面，许多硬件设备的操作速度相对较慢，如磁盘读写、I/O 设备通信等。当内核需要与这些硬件交互时，往往需要等待硬件操作完成。以磁盘读写为例，在向磁盘写入数据后，需要等待磁盘控制器完成数据的物理写入操作，此时就可以使用延时来确保在数据真正写入完成后再进行后续操作，避免数据丢失或读写错误。

从软件同步角度来说，在多线程或多进程的环境下，不同的执行单元可能需要按照特定的顺序或时间间隔来访问共享资源。延时可以用于协调这些访问，避免竞态条件和数据不一致的问题。比如，在两个线程同时访问一个共享变量时，可以通过延时让其中一个线程稍作等待，确保另一个线程完成对变量的操作后再进行访问。

此外，在调试内核代码时，延时也能发挥关键作用。通过在关键代码段前后添加延时，可以控制程序执行的节奏，便于观察程序的运行状态和变量的值，从而更方便地定位和解决问题。例如，在调试一个复杂的驱动程序时，可以在驱动的关键函数中添加延时，以便逐步观察硬件设备的响应和数据的处理过程。

1.2 内核延时的分类

Linux 内核中的延时主要分为两类：忙延时（Busy Delay）和休眠延时（Sleep Delay）。

忙延时，简单来说，就是 CPU 在延时期间会一直执行空操作指令，不做任何有实际意义的工作，就像一个人在原地踏步等待时间过去 。这种延时方式的特点是实现简单，不需要进行进程上下文切换，延时的精度相对较高，适合短时间的延时需求，比如微秒级或纳秒级的延时。以 udelay 函数为例，它就是典型的忙延时函数，常用于等待硬件设备的短时间响应，如在 I2C 通信中，发送一个字节数据后，使用 udelay 函数等待几微秒，确保设备有足够的时间接收和处理数据。

然而，忙延时也存在明显的缺点。由于 CPU 在延时期间一直处于忙碌状态，会占用大量的 CPU 资源，导致 CPU 利用率升高，系统整体性能下降。如果在一个对实时性要求较高的系统中，长时间使用忙延时，可能会导致其他重要任务无法及时得到 CPU 资源，从而影响系统的正常运行。比如，在一个实时控制系统中，如果在主循环中使用大量的忙延时来等待传感器数据，可能会导致控制信号的输出延迟，影响系统的控制精度和稳定性。

休眠延时则不同，当执行休眠延时操作时，当前进程会进入睡眠状态，将 CPU 资源释放给其他进程使用 。这种延时方式适用于较长时间的延时需求，比如毫秒级或秒级的延时。例如，msleep 函数就是用于休眠延时的函数，常用于在进程中等待一段时间，如在一个网络服务器程序中，当没有新的连接请求时，服务器进程可以使用 msleep 函数进入休眠状态，释放 CPU 资源，直到有新的连接请求到来时再被唤醒。

休眠延时的优点是不会占用 CPU 资源，能够提高系统的整体性能和资源利用率 。但它也有一些局限性，由于涉及到进程上下文的切换，休眠延时的开销相对较大，延时的精度不如忙延时高，并且在中断上下文中不能使用，因为中断处理函数需要快速执行，不能长时间占用 CPU 资源。

二、udelay 函数详解

面试题写作模版

2.1 什么是 udelay？

在 Linux 内核的延迟函数家族中，udelay 就像是一位爆发力十足的短跑健将，专注于微秒级别的延迟任务。它的定义位于<linux/delay.h>头文件中，是内核提供给开发者实现精确微秒延迟的有力工具 。

从原理上来说，udelay 采用了忙等待（busy - wait）的机制。简单来讲，就是通过执行一个空循环，让 CPU 在这段时间内不断地做无用功，从而达到延迟的目的。这种方式虽然简单直接，但也意味着在延迟期间，CPU 会被紧紧占用，无法去处理其他任务。为了实现精确的微秒级延迟，udelay 会根据系统启动时计算出

loops_per_jiffy 值（与 BogoMIPS 相关，BogoMIPS 表征处理器每秒执行百万指令数，是一个 CPU 性能测试数）来计算循环的次数。例如，在 ARM 架构的系统中，udelay 的实现会通过一系列复杂的移位和乘法运算，将微秒数转换为对应的循环次数，以确保延迟时间的准确性。

2.2 udelay 使用方法

使用 udelay 非常简单，只需要包含<linux/delay.h>头文件，然后调用 udelay 函数并传入需要延迟的微秒数即可。以下是一个简单的示例代码：

#include <linux/module.h>#include <linux/delay.h>staticint __init my_module_init(void){    printk(KERN_INFO "Module starting...\n");// 延迟 500 微秒    udelay(500);    printk(KERN_INFO "500 microseconds delay finished.\n");return0;}staticvoid __exit my_module_exit(void){    printk(KERN_INFO "Module exiting...\n");}module_init(my_module_init);module_exit(my_module_exit);MODULE_LICENSE("GPL");

在这个示例中，当模块加载时，会先打印 "Module starting..."，然后执行 udelay(500)，延迟 500 微秒后，再打印 "500 microseconds delay finished."。需要注意的是，udelay 只能在内核空间中使用，用户空间程序无法直接调用它。而且由于它是忙等待方式，会一直占用 CPU，所以不适用于长时间的延迟，一般建议用于 1 毫秒（1000 微秒）以内的短延迟场景。

2.3 udelay 使用场景与注意事项

udelay 在一些对时间精度要求较高的内核驱动开发场景中发挥着重要作用。比如，在硬件设备初始化过程中，常常需要精确控制时序。假设我们要向某个硬件寄存器写入数据，然后等待一段时间让硬件完成相应的操作，这个时候 udelay 就派上用场了。又或者在 I2C、SPI 等通信协议的实现中，为了保证数据传输的准确性，需要在发送或接收数据的过程中插入精确的微秒级延迟，udelay 也能很好地胜任 。

不过，在使用 udelay 时，有几个方面需要特别注意。首先，由于它会占用 CPU 资源，所以要避免使用过长的延迟时间，否则会导致系统性能下降，其他任务得不到及时处理。其次，在支持抢占的内核中，过长的 udelay 可能会被中断，从而影响延迟的准确性。因此，如果需要的延迟时间超过 1 毫秒，最好使用 mdelay 等其他更合适的函数，或者采用调度器友好的方式来实现延迟。此外，不同的硬件平台和内核版本，udelay 的最大延迟时间和精度可能会有所差异，在实际使用时需要查阅相关文档进行确认。

三、mdelay 函数详解

面试题写作模版

3.1 什么是 mdelay ？

mdelay 作为 Linux 内核延迟体系中的一员，是 udelay 的 “进阶版”，专注于毫秒级别的延迟控制 。它同样位于<linux/delay.h>头文件中，为开发者提供了一种简单有效的方式来实现较长时间的延迟，不过其本质和 udelay 一样，也是基于忙等待机制。

mdelay 与 udelay 有着紧密的联系，它实际上是通过多次调用 udelay 来实现毫秒级延迟的。因为 udelay 主要用于微秒级延迟，对于大于 1 毫秒（1000 微秒）的延迟需求，使用 udelay 会显得繁琐且效率低下，这时 mdelay 就派上用场了。例如，要实现 5 毫秒的延迟，mdelay 会将 5 毫秒转换为 5000 微秒，然后通过多次调用 udelay 来累计达到 5000 微秒的延迟时间 。

3.2 mdelay 使用方法

使用 mdelay 与 udelay 类似，先包含<linux/delay.h>头文件，然后调用 mdelay 函数并传入需要延迟的毫秒数。下面是一个示例代码：

#include <linux/module.h>#include <linux/delay.h>staticint __init my_module_init(void){    printk(KERN_INFO "Module starting...\n");// 延迟 2 毫秒    mdelay(2);    printk(KERN_INFO "2 milliseconds delay finished.\n");return0;}staticvoid __exit my_module_exit(void){    printk(KERN_INFO "Module exiting...\n");}module_init(my_module_init);module_exit(my_module_exit);MODULE_LICENSE("GPL");

在这个模块加载时，会先打印 "Module starting..."，接着执行 mdelay(2)，延迟 2 毫秒后，再打印 "2 milliseconds delay finished."。需要注意，mdelay 和 udelay 一样，只能用于内核空间，并且由于忙等待特性，长时间使用会占用大量 CPU 资源，导致系统性能下降，所以不适合长时间延迟场景，一般建议用于较短的毫秒级延迟。

3.3 mdelay 与 msleep 对比

在 Linux 内核开发中，mdelay 和 msleep 都能实现延迟功能，但它们在多个方面存在明显差异。

从占用资源角度看，mdelay 采用忙等待机制，在延迟期间 CPU 会一直处于忙碌状态，持续执行空循环，这会占用大量 CPU 资源，导致其他任务无法及时得到 CPU 的处理。而 msleep 是让调用它的进程进入睡眠状态，在睡眠期间，CPU 会被释放，其他进程可以使用 CPU 资源，因此不会占用 CPU 。

在时间准确性方面，mdelay 的延迟时间较为精确，只要系统时钟稳定，它就能按照设定的毫秒数准确延迟。而 msleep 由于涉及进程的睡眠和唤醒，受到系统调度和其他任务的影响，实际延迟时间往往会比设定的时间略长，且这个额外的时间是不确定的 。在应用场景上，mdelay 适用于对延迟时间精度要求较高、延迟时间较短的场景，比如硬件设备初始化过程中的时序控制，或者一些对时间敏感的简单任务。而 msleep 则适用于那些对延迟时间精度要求不高，但需要释放 CPU 资源的场景，例如一些长时间的等待操作，或者在进程中需要进行长时间的延迟而又不想占用 CPU 资源时 。

mdelay 的优点是使用简单，只需要传入需要延时的毫秒数即可实现相应的延时操作，并且延时相对准确，对于一些对时间精度要求在毫秒级别的场景能够很好地满足 。然而，和 udelay 一样，mdelay 在延时期间 CPU 处于忙碌状态，会占用 CPU 资源，这在一定程度上会影响系统的整体性能。如果需要长时间的延时，不建议使用 mdelay，因为长时间占用 CPU 会导致其他任务无法及时执行，可能会引发系统响应迟缓等问题 。所以在使用 mdelay 时，需要根据实际需求谨慎评估延时时间和对系统性能的影响。

四、hrtimer 高精度定时

面试题写作模版

4.1 什么是 hrtimer?

在 Linux 内核的延时与定时场景中，传统的 udelay 和 mdelay 虽能满足基础的微秒、毫秒级阻塞延时，但在音频 / 视频处理、实时控制系统等对时间精度要求极高的场景下，其精度和灵活性都显得力不从心。这时，专为高精度定时设计的 hrtimer（高精度定时器） 便成为最优解决方案，它能实现纳秒级定时精度，为时间严苛型场景提供强大支撑。

hrtimer 的超高精度，核心源于它直接依托硬件级高精度时钟源 —— 如时间戳计数器（TSC）、高精度事件定时器（HPET），这类时钟源可提供纳秒级的精细时间刻度，完全区别于依赖系统时钟节拍（jiffies）的低精度定时器，从根源上规避了 jiffies 固有精度限制带来的延时误差。同时，hrtimer 采用红黑树（Red-Black Tree） 管理所有活动定时器，将定时器按到期时间有序组织在红黑树中；作为自平衡二叉搜索树，红黑树让定时器的插入、删除操作，以及查找最早到期定时器的时间复杂度均稳定在 O (log N)，即便定时器数量庞大（如上千个），也能保持高效运行。

工作时，hrtimer 会依据设定的到期时间等待硬件定时器中断触发；中断产生后，内核会检索红黑树，将已到期的定时器从树中移除，并执行其绑定的回调函数，整套流程高效且精准，完美弥补了 udelay/mdelay 在高精度、非阻塞定时场景下的短板。

4.2 hrtimer 使用方法

在使用 hrtimer 时，首先需要包含<linux/hrtimer.h>头文件。hrtimer 相关的数据结构主要是 struct hrtimer，它包含了定时器的各种信息，如到期时间、回调函数等 。初始化 hrtimer 使用 hrtimer_init 函数，其原型为：

voidhrtimer_init(struct hrtimer *timer, clockid_t which_clock, enum hrtimer_mode mode);

其中，timer 是指向 hrtimer 结构体的指针，which_clock 指定时钟源类型，如 CLOCK_MONOTONIC（单调时钟，不受系统时间调整影响）或 CLOCK_REALTIME（实时时钟，会随系统时间调整而改变），mode 指定定时器模式，包括绝对时间模式（HRTIMER_MODE_ABS）、相对时间模式（HRTIMER_MODE_REL）等 。例如：

#include <linux/hrtimer.h>#include <linux/ktime.h>struct hrtimer my_hrtimer;ktime_t delay = ktime_set(2, 0); // 2 秒的延迟，ktime_set 用于设置时间，第一个参数为秒，第二个参数为纳秒// 初始化 hrtimerhrtimer_init(&my_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

设置回调函数时，需要定义一个返回值为 enum hrtimer_restart 类型的函数，当定时器到期时，该函数会被调用。例如：

enum hrtimer_restart my_hrtimer_callback(struct hrtimer *timer){// 在这里执行定时任务    printk(KERN_INFO "hrtimer callback executed\n");return HRTIMER_NORESTART; // 表示不重启定时器，如果需要周期性触发，返回 HRTIMER_RESTART 并调整到期时间}my_hrtimer.function = my_hrtimer_callback;

启动 hrtimer 使用 hrtimer_start 函数，其原型为：

voidhrtimer_start(struct hrtimer *timer, ktime_t tim, constenum hrtimer_mode mode);

例如，启动前面初始化的 hrtimer：

hrtimer_start(&my_hrtimer, delay, HRTIMER_MODE_REL);

在实际的 Linux 内核驱动开发中，hrtimer 通常以内核模块的形式使用，将初始化、启动、回调、周期定时、注销等流程组合在一起。为了让你更清晰地掌握 hrtimer 的完整使用方法，下面通过一个可直接编译运行的示例代码，完整演示定时器从初始化到注销的全过程：

//hrtimer 使用示例#include <linux/module.h>#include <linux/kernel.h>#include <linux/hrtimer.h>#include <linux/ktime.h>// 定义结构体管理定时器相关数据struct hrtimer_demo {    struct hrtimer timer;    ktime_t period;int count;};static struct hrtimer_demo demo_data;// 定时器回调函数staticenum hrtimer_restart hrtimer_callback(struct hrtimer *timer){    struct hrtimer_demo *demo = container_of(timer, struct hrtimer_demo, timer);    demo->count++;    pr_info("hrtimer callback: count=%d\n", demo->count);// 重新设置下次触发时间    hrtimer_forward_now(timer, demo->period);// 返回 HRTIMER_RESTART 继续定时return HRTIMER_RESTART;}staticint __init hrtimer_demo_init(void){    pr_info("hrtimer demo init\n");// 设置定时周期为 100 毫秒    demo_data.period = ktime_set(0, 100 * NSEC_PER_MSEC);    demo_data.count = 0;// 初始化定时器    hrtimer_init(&demo_data.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);    demo_data.timer.function = hrtimer_callback;// 启动定时器    hrtimer_start(&demo_data.timer, demo_data.period, HRTIMER_MODE_REL);return0;}staticvoid __exit hrtimer_demo_exit(void){    hrtimer_cancel(&demo_data.timer);    pr_info("hrtimer demo exit, total count=%d\n", demo_data.count);}module_init(hrtimer_demo_init);module_exit(hrtimer_demo_exit);MODULE_LICENSE("GPL");MODULE_DESCRIPTION("hrtimer demo driver");

在这个示例中，首先定义了一个 hrtimer_demo 结构体，包含一个 hrtimer 定时器、定时周期 period 和计数器 count。hrtimer_callback 是定时器到期时的回调函数，在函数中，先增加计数器 count，打印当前计数，然后使用 hrtimer_forward_now 重新设置下次触发时间，返回 HRTIMER_RESTART 表示继续定时。

在模块初始化函数 hrtimer_demo_init 中，设置定时周期为 100 毫秒，初始化定时器并设置回调函数，最后启动定时器。模块退出函数 hrtimer_demo_exit 则负责取消定时器，并打印总的计数。通过这个示例，我们可以清晰地看到 hrtimer 从初始化、启动到回调处理以及取消的完整流程。

4.3 回调函数模式与定时器类型

hrtimer 的回调函数有两种模式：软中断模式（HRTIMER_MODE_SOFT）和硬中断模式（HRTIMER_MODE_HARD） 。

软中断模式是默认且最常用的模式 。在这种模式下，回调函数在软中断上下文中执行。软中断的特点是可以被硬件中断打断，但不能被其他软中断打断，这使得回调函数的执行相对稳定。不过，在软中断模式下，由于软中断上下文的限制，不能执行可能引起睡眠的操作，如互斥锁的获取、内存分配（使用 GFP_KERNEL 标志）等，因为这些操作可能会导致内核调度，从而破坏软中断的执行环境。在网络设备驱动中，当使用 hrtimer 来检测网络数据包的接收超时，并且在超时回调函数中只需要进行一些简单的状态更新和错误处理，而不需要进行可能引起睡眠的操作时，就可以使用软中断模式。

硬中断模式下，回调函数在硬中断上下文中执行 。硬中断是最高优先级的中断，能够立即得到处理，延迟最低。但这种模式对回调函数的限制更严格，执行时间必须极短，因为硬中断会打断其他所有的中断处理，包括软中断，如果回调函数执行时间过长，会影响系统的实时性和响应能力。在一些对时间要求极高的场景，如实时控制系统中，当需要在定时器到期时立即执行一个非常简短的关键操作，如紧急制动信号的发送，就可以考虑使用硬中断模式，但要确保回调函数的代码简洁高效，执行时间极短。

从定时器类型来看，hrtimer 分为单次定时器（One-shot）和周期性定时器（Periodic） 。单次定时器在到期后只执行一次回调函数，常用于一些一次性的定时任务，如设备的初始化过程中，设置一个定时器来等待设备完成初始化操作，一旦定时器到期，执行相应的初始化完成处理函数，之后定时器就不再起作用；周期性定时器则会在回调函数中，通过 hrtimer_forward()函数将定时器的到期时间向前推进一个周期，并返回

HRTIMER_RESTART，这样定时器就会周期性地触发 。在传感器数据采集任务中，可能需要每隔一定时间就采集一次传感器数据，这时就可以使用周期性定时器，每次定时器到期时，执行数据采集和处理的回调函数，然后通过 hrtimer_forward()函数重新设置下一次到期时间，使定时器不断循环触发，实现持续的数据采集。

五、实践指南：正确使用内核延迟机制

面试题写作模版

在实际的 Linux 驱动开发中，正确使用 udelay、mdelay 和 hrtimer 是至关重要的。下面我们通过具体的代码示例来深入了解它们的使用方法和关键代码的作用。

（1）udelay 代码示例

#include <linux/module.h>#include <linux/delay.h>staticint __init udelay_example_init(void){// 延迟 100 微秒    udelay(100);    printk(KERN_INFO "udelay example: 100 microseconds delay completed\n");return0;}staticvoid __exit udelay_example_exit(void){    printk(KERN_INFO "udelay example: module exiting\n");}module_init(udelay_example_init);module_exit(udelay_example_exit);MODULE_LICENSE("GPL");

在上述代码中，udelay(100)函数调用实现了 100 微秒的延迟。__builtin_constant_p 函数用于判断传入 udelay 的参数是否为编译时常数，如果是常数且小于等于 MAX_UDELAY_MS * 1000（在某些架构中，MAX_UDELAY_MS 可能定义为 2 或 5 等），则会调用__const_udelay 函数进行延迟计算。__const_udelay 会根据处理器的 loops_per_jiffy（表示处理器在一个 jiffy 中执行的循环数）和其他相关参数，通过一系列的乘法和移位运算，计算出需要执行的循环次数，从而实现精确的微秒级延迟 。

（2）mdelay 代码示例

#include <linux/module.h>#include <linux/delay.h>staticint __init mdelay_example_init(void){// 延迟 500 毫秒    mdelay(500);    printk(KERN_INFO "mdelay example: 500 milliseconds delay completed\n");return0;}staticvoid __exit mdelay_example_exit(void){    printk(KERN_INFO "mdelay example: module exiting\n");}module_init(mdelay_example_init);module_exit(mdelay_example_exit);MODULE_LICENSE("GPL");

这里的 mdelay(500)实现了 500 毫秒的延迟。当传入 mdelay 的参数不是编译时常数或者大于 MAX_UDELAY_MS 时，mdelay 会通过一个循环，每次循环调用 udelay(1000)来实现毫秒级延迟。例如，上述代码中，会循环 500 次，每次延迟 1 毫秒，从而达到 500 毫秒的延迟效果 。

（3）hrtimer 代码示例

#include <linux/module.h>#include <linux/kernel.h>#include <linux/hrtimer.h>#include <linux/ktime.h>// 定义一个 hrtimer 结构体struct hrtimer my_hrtimer;// 定义回调函数enum hrtimer_restart my_callback(struct hrtimer *timer){    printk(KERN_INFO "hrtimer callback: timer expired\n");// 重新设置下次触发时间为 1 秒后    hrtimer_forward_now(timer, ktime_set(1, 0));return HRTIMER_RESTART;}staticint __init hrtimer_example_init(void){// 初始化定时器    hrtimer_init(&my_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);    my_hrtimer.function = my_callback;// 启动定时器，初始延迟为 1 秒    hrtimer_start(&my_hrtimer, ktime_set(1, 0), HRTIMER_MODE_REL);return0;}staticvoid __exit hrtimer_example_exit(void){    hrtimer_cancel(&my_hrtimer);}module_init(hrtimer_example_init);module_exit(hrtimer_example_exit);MODULE_LICENSE("GPL");

在这个示例中，首先定义了一个 hrtimer 结构体 my_hrtimer 和一个回调函数 my_callback。在 my_callback 函数中，当定时器到期时，会打印一条消息，并使用 hrtimer_forward_now 函数重新设置下次触发时间为当前时间再过 1 秒。hrtimer_init 函数用于初始化 my_hrtimer 定时器，设置其使用单调时钟 CLOCK_MONOTONIC 和相对定时模式 HRTIMER_MODE_REL。hrtimer_start 函数则启动定时器，初始延迟为 1 秒。

在使用内核延迟机制时，有一些注意事项和调试技巧可以帮助我们避免常见问题，提高开发效率。

• 在使用 udelay 和 mdelay 时，由于它们是忙等待方式，长时间的延迟会占用大量 CPU 资源，可能导致系统性能下降。因此，应尽量避免在关键路径上使用长时间的 udelay 和 mdelay。如果确实需要较长时间的延迟，且对延迟精度要求不是特别严格，可以考虑使用 msleep 等非忙等待的延时函数 。
• 在使用 hrtimer 时，要注意回调函数的执行时间。如果回调函数执行时间过长，可能会影响定时器的精度和系统的响应性能。因此，回调函数应尽量简洁高效，避免进行复杂的计算或长时间的阻塞操作。

在调试延迟相关的问题时，可以使用内核的打印函数（如 printk）来输出关键时间点和变量值，以便观察延迟的实际效果。例如，在 udelay 和 mdelay 的代码中，可以在延迟前后打印时间戳，通过对比时间戳来验证延迟是否达到预期。对于 hrtimer，可以在回调函数中打印当前时间和定时器的到期时间，检查定时器是否按时触发。还可以使用内核调试工具（如 kgdb、ftrace 等）来深入分析延迟函数的执行过程和系统状态。kgdb 可以用于调试内核代码，设置断点、查看变量值等；ftrace 则可以跟踪内核函数的调用关系和执行时间，帮助我们定位性能瓶颈和延迟相关的问题 。