• 浅析linux 内核 高精度定时器（hrtimer）实现机制（一）

    1 hrtimer 概述

    在Linux内核中已经存在了一个管理定时器的通用框架。不过它也有很多不足，最大的问题是其精度不是很高。哪怕底层的定时事件设备精度再高，定时器层的分辨率只能达到Tick级别，按照内核配置选项的不同，在100Hz到1000Hz之间。但是，原有的定时器层由于实现教早，应用广泛，如果完全替换掉会引入大量代码改动。因此，Linux内核又独立设计出了一个叫高精度定时器层（High Resolution Timer）的框架，可以为我们提供纳秒级的定时精度，以满足对精确时间有迫切需求的应用程序或内核驱动程序。

    高分辨率定时器是建立在每CPU私有独占的本地时钟事件设备上的，对于一个多处理器系统，如果只有全局的时钟事件设备，高分辨率定时器是无法工作的。因为如果没有每CPU私有独占的时钟事件设备，当到期中断发生时系统必须产生夸处理器中断来通知其它CPU完成相应的工作，而过多的夸处理器中断会带来很大的系统开销，这样会令使用高分辨率定时器的代价大大增加，还不如不用。为了让内核支持高分辨率定时器，必须要在编译的时候打开编译选项CONFIG_HIGH_RES_TIMERS。

    高分辨率定时器层有两种工作模式：低精度模式与高精度模式。虽然高分辨率定时器子系统是为高精度定时器准备的，但是系统可能在运行过程中动态切换到不同精度和模式的定时事件设备，因此高精度定时器层必须能够在低精度模式与高精度模式下自由切换。

    高分辨率定时器层使用红黑树来组织各个高分辨率定时器。随着系统的运行，高分辨率定时器不停地被创建和销毁，新的高分辨率定时器按顺序被插入到红黑树中，树的最左边的节点就是最快到期的定时器。

    2 相关数据结构

    2.1 hrtimer

    高分辨率定时器由hrtimer结构体表示（代码位于include/linux/hrtimer.h中）：

    1. struct hrtimer {
    2. 	struct timerqueue_node		node;
    3. 	ktime_t				_softexpires;
    4. 	enum hrtimer_restart		(*function)(struct hrtimer *);
    5. 	struct hrtimer_clock_base	*base;
    6. 	u8				state;
    7. 	u8				is_rel;
    8. 	u8				is_soft;
    9. 	u8				is_hard;
    10. };

    node：是一个timerqueue_node结构体变量。这个结构体中有两个成员，node是红黑树的节点，expires：表示该定时器的硬超时时间：

    1. struct timerqueue_node {
    2.     struct rb_node node;
    3.     ktime_t expires;
    4. };

    _softexpires：表示该定时器的软超时时间。高精度定时器一般都有一个到期的时间范围，而不像（低精度）定时器那样就是一个时间点。这个时间范围的前时间点就是软超时时间，而后一个时间点就是硬超时时间。达到软超时时间后，还可以再拖一会再调用超时回调函数，而到达硬超时时间后就不能再拖了。

    function：定时器到期后的回调函数。

    base：指向包含该高分辨率定时器的的hrtimer_clock_base结构体。

    state：用来表示该高分辨率定时器当前所处的状态，目前共有两种状态：

    1. /* 表示定时器还未激活 */
    2. #define HRTIMER_STATE_INACTIVE	0x00
    3. /* 表示定时器已激活（入列） */
    4. #define HRTIMER_STATE_ENQUEUED	0x01

    is_rel：表示该定时器的到期时间是否是相对时间。is_soft：表示该定时器是否是“软”定时器。
    is_hard：表示该定时器是否是“硬”定时器。

    2.2 hrtimer_clock_base

    1. struct hrtimer_clock_base {
    2. 	struct hrtimer_cpu_base	*cpu_base;
    3. 	unsigned int		index;
    4. 	clockid_t		clockid;
    5. 	seqcount_t		seq;
    6. 	struct hrtimer		*running;
    7. 	struct timerqueue_head	active;
    8. 	ktime_t			(*get_time)(void);
    9. 	ktime_t			offset;
    10. } __hrtimer_clock_base_align;

    cpu_base：指向所属CPU的hrtimer_cpu_base结构体。
    index：表示该结构体在当前CPU的hrtimer_cpu_base结构体中clock_base数组中所处的下标。
    clockid：表示当前时钟类型的ID值。
    seq：顺序锁，在处理到期定时器的函数__run_hrtimer中会用到。
    running：指向当前正在处理的那个定时器。
    active：红黑树，包含了所有使用该时间类型的定时器。
    get_time：是一个函数指针，指定了如何获取该时间类型的当前时间的函数。由于不同类型的时间在Linux中都是由时间维护层来统一管理的，因此这些函数都是在时间维护层里面定义好的。
    offset：表示当前时间类型和单调时间之间的差值。

    2.3 hrtimer_cpu_base

    每个CPU单独管理属于自己的高分辨率定时器，为了方便管理，专门定义了一个结构体hrtimer_cpu_base：

    1. struct hrtimer_cpu_base {
    2. 	raw_spinlock_t			lock;
    3. 	unsigned int			cpu;
    4. 	unsigned int			active_bases;
    5. 	unsigned int			clock_was_set_seq;
    6. 	unsigned int			hres_active		: 1,
    7. 					in_hrtirq		: 1,
    8. 					hang_detected		: 1,
    9. 					softirq_activated       : 1;
    10. #ifdef CONFIG_HIGH_RES_TIMERS
    11. 	unsigned int			nr_events;
    12. 	unsigned short			nr_retries;
    13. 	unsigned short			nr_hangs;
    14. 	unsigned int			max_hang_time;
    15. #endif
    16. #ifdef CONFIG_PREEMPT_RT
    17. 	......
    18. #endif
    19. 	ktime_t				expires_next;
    20. 	struct hrtimer			*next_timer;
    21. 	ktime_t				softirq_expires_next;
    22. 	struct hrtimer			*softirq_next_timer;
    23. 	struct hrtimer_clock_base	clock_base[HRTIMER_MAX_CLOCK_BASES];
    24. } ____cacheline_aligned;

    lock：用来保护该结构体的自旋锁。

    cpu：绑定到的CPU编号。

    active_bases：表示clock_base数组中哪些元素下的红黑树中含有定时器。

    clock_was_set_seq：表示时钟被设置的序数。

    hres_active：表示是否已经处在了高精度模式下。

    in_hrtirq：是否正在执行hrtimer_interrupt中断处理程序中。

    hang_detected：表明在前一次执行hrtimer_interrupt中断处理程序的时候发生了错误。

    softirq_activated：是否正在执行hrtimer_run_softirq软中断处理程序。

    nr_events：表明一共执行了多少次hrtimer_interrupt中断处理程序。

    nr_retries：表明在执行hrtimer_interrupt中断处理程序的时候对定时事件设备编程错误后重试的次数。

    nr_hangs：表明在执行hrtimer_interrupt中断处理程序的时候发生错误的次数。

    max_hang_time：表明在碰到错误后，在hrtimer_interrupt中断处理程序中停留的最长时间。

    expires_next：该CPU上即将要到期定时器的到期时间。

    next_timer：该CPU上即将要到期的定时器。

    softirq_expires_next：该CPU上即将要到期的“软”定时器的到期时间。

    softirq_next_timer：该CPU上即将要到期的“软”定时器。

    clock_base：高分辨率定时器的到期时间可以基于以下几种时间类型，clock_base数组为每种时间基准系统都定义了一个hrtimer_clock_base结构体：

    1. enum  hrtimer_base_type {
    2. 	HRTIMER_BASE_MONOTONIC,
    3. 	HRTIMER_BASE_REALTIME,
    4. 	HRTIMER_BASE_BOOTTIME,
    5. 	HRTIMER_BASE_TAI,
    6. 	HRTIMER_BASE_MONOTONIC_SOFT,
    7. 	HRTIMER_BASE_REALTIME_SOFT,
    8. 	HRTIMER_BASE_BOOTTIME_SOFT,
    9. 	HRTIMER_BASE_TAI_SOFT,
    10. 	HRTIMER_MAX_CLOCK_BASES,
    11. };

    没有加 SOFT 后缀的，表示是“硬”定时器，将直接在中断处理程序中处理；而加了SOFT后缀的，表示是“软”定时器，将在软中断（HRTIMER_SOFTIRQ）中处理。而且前面的一半都定义成“硬”定时器类型，后面一半都定义成“软”定时器类型，硬的一半和软的一半申明的次序也是对应的。这样设计就方便根据“硬”“软”特性和时间类型很快查出对应 hrtimer_clock_base 结构体的下标。

     【文章福利】小编推荐自己的Linux内核技术交流群： 【977878001】整理一些个人觉得比较好得学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100进群领取，额外赠送一份 价值699的内核资料包（含视频教程、电子书、实战项目及代码）

    内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

    学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

    所以，综上所述，高分辨率定时器层的组织相对来说还是比较简单的，甚至比（低分辨率）定时器层还要简单。每个CPU对应有一个 hrtimer_cpu_base 的 Per CPU 结构体变量，其定义如下：

    1. DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases) =
    2. {
    3. 	.lock = __RAW_SPIN_LOCK_UNLOCKED(hrtimer_bases.lock),
    4. 	.clock_base =
    5. 	{
    6. 		{
    7. 			.index = HRTIMER_BASE_MONOTONIC,
    8. 			.clockid = CLOCK_MONOTONIC,
    9. 			.get_time = &ktime_get,
    10. 		},
    11. 		{
    12. 			.index = HRTIMER_BASE_REALTIME,
    13. 			.clockid = CLOCK_REALTIME,
    14. 			.get_time = &ktime_get_real,
    15. 		},
    16. 		{
    17. 			.index = HRTIMER_BASE_BOOTTIME,
    18. 			.clockid = CLOCK_BOOTTIME,
    19. 			.get_time = &ktime_get_boottime,
    20. 		},
    21. 		{
    22. 			.index = HRTIMER_BASE_TAI,
    23. 			.clockid = CLOCK_TAI,
    24. 			.get_time = &ktime_get_clocktai,
    25. 		},
    26. 		{
    27. 			.index = HRTIMER_BASE_MONOTONIC_SOFT,
    28. 			.clockid = CLOCK_MONOTONIC,
    29. 			.get_time = &ktime_get,
    30. 		},
    31. 		{
    32. 			.index = HRTIMER_BASE_REALTIME_SOFT,
    33. 			.clockid = CLOCK_REALTIME,
    34. 			.get_time = &ktime_get_real,
    35. 		},
    36. 		{
    37. 			.index = HRTIMER_BASE_BOOTTIME_SOFT,
    38. 			.clockid = CLOCK_BOOTTIME,
    39. 			.get_time = &ktime_get_boottime,
    40. 		},
    41. 		{
    42. 			.index = HRTIMER_BASE_TAI_SOFT,
    43. 			.clockid = CLOCK_TAI,
    44. 			.get_time = &ktime_get_clocktai,
    45. 		},
    46. 	}
    47. };

    每个 hrtimer_cpu_base 结构体中有一个 hrtimer_clock_base 类型的数组变量 clock_base，目前数组元素是8个，分别用来存放8种到期时间类型的高分辨率定时器。而每种到期时间类型下，又是以红黑数来组织所有的高分辨率定时器。因此，高分辨率定时器层的数据结构如下图所示：

    3 高精度定时器相关API

    3.1 高精度定时器层初始化 hrtimers_init

    在linux内核启动初始化阶段，start_kernel 会调用 hrtimers_init 函数对高精度定时器层初始化：

    1. void __init hrtimers_init(void)
    2. {
    3.         /* 初始化属于当前CPU的hrtimer_cpu_base结构体 */
    4. 	hrtimers_prepare_cpu(smp_processor_id());
    5.         /* 打开HRTIMER_SOFTIRQ软中断 */
    6. 	open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq);
    7. }

    该函数主要功能就是初始化属于当前 CPU 的 hrtimer_cpu_base 结构体，然后打开HRTIMER_SOFTIRQ软中断。

    1. int hrtimers_prepare_cpu(unsigned int cpu)
    2. {
    3.         /* 获得属于当前CPU的hrtimer_cpu_base结构体 */
    4. 	struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);
    5. 	int i;
    6.  
    7.         /* 初始化所有的hrtimer_clock_base结构体 */
    8. 	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
    9.                 /* 初始化cpu_base */
    10. 		cpu_base->clock_base[i].cpu_base = cpu_base;
    11.                 /* 初始化红黑树 */
    12. 		timerqueue_init_head(&cpu_base->clock_base[i].active);
    13. 	}
    14.  
    15. 	cpu_base->cpu = cpu;
    16. 	cpu_base->active_bases = 0;
    17. 	cpu_base->hres_active = 0;
    18. 	cpu_base->hang_detected = 0;
    19. 	cpu_base->next_timer = NULL;
    20. 	cpu_base->softirq_next_timer = NULL;
    21. 	cpu_base->expires_next = KTIME_MAX;
    22. 	cpu_base->softirq_expires_next = KTIME_MAX;
    23. 	hrtimer_cpu_base_init_expiry_lock(cpu_base);
    24. 	return 0;
    25. }

    3.2 定时器初始化 hrtimer_init

    在将一个高分辨率定时器插入并激活之前，首先需要调用hrtimer_init函数对其进行初始化：

    1. void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
    2. 		  enum hrtimer_mode mode)
    3. {
    4. 	debug_init(timer, clock_id, mode);
    5. 	__hrtimer_init(timer, clock_id, mode);
    6. }
    7. EXPORT_SYMBOL_GPL(hrtimer_init);

    其直接调用了__hrtimer_init函数：

    1. static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
    2. 			   enum hrtimer_mode mode)
    3. {
    4. 	bool softtimer = !!(mode & HRTIMER_MODE_SOFT);
    5. 	struct hrtimer_cpu_base *cpu_base;
    6. 	int base;
    7.  
    8. 	if (IS_ENABLED(CONFIG_PREEMPT_RT) && !(mode & HRTIMER_MODE_HARD))
    9. 		softtimer = true;
    10.  
    11.         /* 将hrtimer结构体清0 */
    12. 	memset(timer, 0, sizeof(struct hrtimer));
    13.  
    14.         /* 获得当前CPU的hrtimer_cpu_base结构体变量 */
    15. 	cpu_base = raw_cpu_ptr(&hrtimer_bases);
    16.  
    17. 	/* 相对的实时时间调整为单调时间 */
    18. 	if (clock_id == CLOCK_REALTIME && mode & HRTIMER_MODE_REL)
    19. 		clock_id = CLOCK_MONOTONIC;
    20.  
    21.         /* 根据定时器是不是“软”的找到hrtimer_clock_base的起始下标 */
    22. 	base = softtimer ? HRTIMER_MAX_CLOCK_BASES / 2 : 0;
    23.         /* 通过clock_id找hrtimer_clock_base的偏移下标 */
    24. 	base += hrtimer_clockid_to_base(clock_id);
    25. 	timer->is_soft = softtimer;
    26. 	timer->is_hard = !softtimer;
    27. 	timer->base = &cpu_base->clock_base[base];
    28.         /* 初始化定时器的红黑树节点结构体 */
    29. 	timerqueue_init(&timer->node);
    30. }

    所以，可以看出任何一个高分辨率定时器在初始化的时候都是默认被分配到当前处理器上的。

    对于 clock_base 下标的计算，由于“硬”定时器模式和“软”定时器模式各占一半，上下对称。所以，如果是“软”的，那起始下标就是最大值的一半，否则就是0。然后，在根据 clock_id 找到对应模式的偏移下标，两者相加就可以了。

    1. static inline int hrtimer_clockid_to_base(clockid_t clock_id)
    2. {
    3. 	if (likely(clock_id < MAX_CLOCKS)) {
    4.                 /* 将clock_id转换成下标 */
    5. 		int base = hrtimer_clock_to_base_table[clock_id];
    6.  
    7. 		if (likely(base != HRTIMER_MAX_CLOCK_BASES))
    8. 			return base;
    9. 	}
    10. 	WARN(1, "Invalid clockid %d. Using MONOTONIC\n", clock_id);
    11.         /* 如果出错默认选择单调时间 */
    12. 	return HRTIMER_BASE_MONOTONIC;
    13. }

    1. static const int hrtimer_clock_to_base_table[MAX_CLOCKS] = {
    2. 	[0 ... MAX_CLOCKS - 1]	= HRTIMER_MAX_CLOCK_BASES,
    3.  
    4. 	[CLOCK_REALTIME]	= HRTIMER_BASE_REALTIME,
    5. 	[CLOCK_MONOTONIC]	= HRTIMER_BASE_MONOTONIC,
    6. 	[CLOCK_BOOTTIME]	= HRTIMER_BASE_BOOTTIME,
    7. 	[CLOCK_TAI]		= HRTIMER_BASE_TAI,
    8. };

    数组下标是 clock_id，而数组的值是要返回的高分辨率定时器的时间类型。由于实际有意义的只有4项，因此多出来的项全部填上 HRTIMER_MAX_CLOCK_BASES，表示出错了。

    高分辨率定时器共有以下几种模式：

    1. enum hrtimer_mode {
    2. 	HRTIMER_MODE_ABS	= 0x00,
    3. 	HRTIMER_MODE_REL	= 0x01,
    4. 	HRTIMER_MODE_PINNED	= 0x02,
    5. 	HRTIMER_MODE_SOFT	= 0x04,
    6. 	HRTIMER_MODE_HARD	= 0x08,
    7.  
    8. 	HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
    9. 	HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
    10.  
    11. 	HRTIMER_MODE_ABS_SOFT	= HRTIMER_MODE_ABS | HRTIMER_MODE_SOFT,
    12. 	HRTIMER_MODE_REL_SOFT	= HRTIMER_MODE_REL | HRTIMER_MODE_SOFT,
    13.  
    14. 	HRTIMER_MODE_ABS_PINNED_SOFT = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT,
    15. 	HRTIMER_MODE_REL_PINNED_SOFT = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_SOFT,
    16.  
    17. 	HRTIMER_MODE_ABS_HARD	= HRTIMER_MODE_ABS | HRTIMER_MODE_HARD,
    18. 	HRTIMER_MODE_REL_HARD	= HRTIMER_MODE_REL | HRTIMER_MODE_HARD,
    19.  
    20. 	HRTIMER_MODE_ABS_PINNED_HARD = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_HARD,
    21. 	HRTIMER_MODE_REL_PINNED_HARD = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_HARD,
    22. };

    共有五种基本模式，其它模式都是由这五种组合而成：

    • HRTIMER_MODE_ABS：表示定时器到期时间是一个绝对值。
    • HRTIMER_MODE_REL：表示定时器到期时间是一个相对于当前时间之后的值。
    • HRTIMER_MODE_PINNED：表示定时器是否需要绑定到某个CPU上。
    • HRTIMER_MODE_SOFT：表示该定时器是否是“软”的，也就是定时器到期回调函数是在软中断下被执行的。
    • HRTIMER_MODE_HARD：表示该定时器是否是“硬”的，也就是定时器到期回调函数是在中断处理程序中被执行的。

    3.3 定时器移除 remove_hrtimer

    将一个高分辨率定时器从系统中移除是通过 remove_hrtimer 函数实现的：

    1. static inline int
    2. remove_hrtimer(struct hrtimer *timer, struct hrtimer_clock_base *base, bool restart)
    3. {
    4. 	u8 state = timer->state;
    5.  
    6.         /* 如果定时器没有激活则直接返回 */
    7. 	if (state & HRTIMER_STATE_ENQUEUED) {
    8. 		int reprogram;
    9. 		
    10. 		debug_deactivate(timer);
    11.                 /* 只有要删除的定时器激活在当前处理器上时才需要重编程 */
    12. 		reprogram = base->cpu_base == this_cpu_ptr(&hrtimer_bases);
    13.  
    14.                 /* 如果要删除的定时器不需要重新再激活则将其状态改为HRTIMER_STATE_INACTIVE */
    15. 		if (!restart)
    16. 			state = HRTIMER_STATE_INACTIVE;
    17.  
    18. 		__remove_hrtimer(timer, base, state, reprogram);
    19. 		return 1;
    20. 	}
    21. 	return 0;
    22. }

    参数 base 指向的就是那个包含要删除定时器的 hrtimer_clock_base 结构体。参数 restart 表示该定时器删除后是不是还会马上被激活，如果是的话就没必要修改状态为HRTIMER_STATE_INACTIVE（未激活）了。该函数判断一些状态后，主要是调用__remove_hrtimer函数进行删除：

    1. static void __remove_hrtimer(struct hrtimer *timer,
    2. 			     struct hrtimer_clock_base *base,
    3. 			     u8 newstate, int reprogram)
    4. {
    5. 	struct hrtimer_cpu_base *cpu_base = base->cpu_base;
    6. 	u8 state = timer->state;
    7.  
    8. 	/* 修改当前定时器的状态为参数指定的状态 */
    9. 	WRITE_ONCE(timer->state, newstate);
    10.         /* 如果该定时器还没有被添加到任何红黑树中则直接返回 */
    11. 	if (!(state & HRTIMER_STATE_ENQUEUED))
    12. 		return;
    13.  
    14.         /* 将要删除的定时器从红黑树中移除 */
    15. 	if (!timerqueue_del(&base->active, &timer->node))
    16.                 /* 如果删除后红黑树为空则清除active_bases中对应的位 */
    17. 		cpu_base->active_bases &= ~(1 << base->index);
    18.  
    19. 	/* 如果需要重编程并且要删除的定时器是其激活CPU上马上就要到期的定时器则重编程 */
    20. 	if (reprogram && timer == cpu_base->next_timer)
    21. 		hrtimer_force_reprogram(cpu_base, 1);
    22. }

    如果要删除的高分辨率定时器是其激活CPU上马上就要到期的那个定时器，则需要对底层的定时事件设备进行重新编程，让其在下一个定时器的到期时间上到期。关于重编程的部分，后面会介绍。

    3.4 定时器激活 hrtimer_start_range_ns

    要激活一个高分辨率定时器需要调用 hrtimer_start_range_ns 函数：

    1. void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
    2.                 u64 delta_ns, const enum hrtimer_mode mode)
    3. {
    4.     struct hrtimer_clock_base *base;
    5.     unsigned long flags;
    6.  
    7.     if (!IS_ENABLED(CONFIG_PREEMPT_RT))
    8.         WARN_ON_ONCE(!(mode & HRTIMER_MODE_SOFT) ^ !timer->is_soft);
    9.     else
    10.         WARN_ON_ONCE(!(mode & HRTIMER_MODE_HARD) ^ !timer->is_hard);
    11.  
    12.         /* 获得定时器对应CPU的hrtimer_cpu_base结构体内的自旋锁 */
    13.     base = lock_hrtimer_base(timer, &flags);
    14.  
    15.         /* 激活定时器 */
    16.     if (__hrtimer_start_range_ns(timer, tim, delta_ns, mode, base))
    17.                 /* 如果成功则尝试对定时事件设备重编程 */
    18.         hrtimer_reprogram(timer, true);
    19.  
    20.         /* 释放自旋锁 */
    21.     unlock_hrtimer_base(timer, &flags);
    22. }
    23. EXPORT_SYMBOL_GPL(hrtimer_start_range_ns);

    参数 tim 保存了定时器的“软”到期时间。参数 delta_ns 是到期时间的范围，所以硬到期时间就是tim+delta_ns。参数 mode 指定了到期时间的类型。在获得了定时器对应 CPU 的hrtimer_cpu_base 结构体内的自旋锁后，其接着调用了 __hrtimer_start_range_ns 函数：

    1. static int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
    2.                     u64 delta_ns, const enum hrtimer_mode mode,
    3.                     struct hrtimer_clock_base *base)
    4. {
    5.     struct hrtimer_clock_base *new_base;
    6.  
    7.     /* 先将该定时器从现有红黑树中移除 */
    8.     remove_hrtimer(timer, base, true);
    9.  
    10.         /* 如果是相对时间则获得当前时间并累加得到绝对时间 */
    11.     if (mode & HRTIMER_MODE_REL)
    12.         tim = ktime_add_safe(tim, base->get_time());
    13.  
    14.     tim = hrtimer_update_lowres(timer, tim, mode);
    15.  
    16.         /* 设置定时器的“软”“硬”到期时间 */
    17.     hrtimer_set_expires_range_ns(timer, tim, delta_ns);
    18.  
    19.     /* 尝试迁移该高分辨率定时器 */
    20.     new_base = switch_hrtimer_base(timer, base, mode & HRTIMER_MODE_PINNED);
    21.  
    22.         /* 将定时器插入红黑树 */
    23.     return enqueue_hrtimer(timer, new_base, mode);
    24. }

    该函数首先调用 remove_hrtimer 函数，如果要激活的定时器已经被激活过了的话，会将其先删除掉。由于后面还会再激活，所以对应的 restart 参数传的是 true。接着调用了hrtimer_set_expires_range_ns 函数，根据参数设置定时器的“软”“硬”到期时间：

    1. static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, u64 delta)
    2. {
    3. 	timer->_softexpires = time;
    4. 	timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta));
    5. }

    所以，“硬”到期时间就是“软”到期时间加上delta。

    switch_hrtimer_base 函数会尝试迁移该要激活的高分辨率定时器，这个后面会分析。如果不需要迁移，则返回的 hrtimer_clock_base 结构体和调用参数是一样的，否则会返回一个新的要迁移到的 hrtimer_clock_base 结构体。

    最后，函数调用 enqueue_hrtimer 函数，将定时器插入红黑树中，从而完成定时器的激活：

    1. static int enqueue_hrtimer(struct hrtimer *timer,
    2. 			   struct hrtimer_clock_base *base,
    3. 			   enum hrtimer_mode mode)
    4. {
    5. 	debug_activate(timer, mode);
    6.  
    7.         /* 设置active_bases中对应的位 */
    8. 	base->cpu_base->active_bases |= 1 << base->index;
    9.  
    10. 	/* 更新定时器的状态为HRTIMER_STATE_ENQUEUED */
    11. 	WRITE_ONCE(timer->state, HRTIMER_STATE_ENQUEUED);
    12.  
    13.         /* 将该定时器加入对应hrtimer_clock_base结构体内的红黑树中 */
    14. 	return timerqueue_add(&base->active, &timer->node);
    15. }
  • 相关阅读:
    Q-Vision+Kvaser CAN/CAN FD/LIN总线解决方案
    DBCO-PEG3-Maleimide，Mal-PEG3-DBCO，二苯并环辛炔-三聚乙二醇-马来酰亚胺
    C#去掉字符串最后一个字符
    机器学习：过拟合、欠拟合、正则化之间的纸短情长～
    阿里云e实例服务器3M固定带宽40G ESSD entry系统盘99元/年
    GeoScene Pro 2.1下载地址与安装基本要求
    AUTOCAD——文字显示方式、CAD怎么直接打开天正图纸
    分层测试（三）：接口测试
    2023年【煤气】报名考试及煤气免费试题
    Unity中实现溶解(Dissolve)特效及其原理解析
  • 原文地址：https://blog.csdn.net/m0_74282605/article/details/127936139