简介

Linux 内核版本：4.19.90
处理器架构：x86_64
操作系统：Kylin Linux Advanced Server V10

一、cond_resched

桌面版内核抢占配置：

# CONFIG_PREEMPT_NONE is not set
CONFIG_PREEMPT_VOLUNTARY=y
# CONFIG_PREEMPT is not set

桌面版内核抢占配置一般是CONFIG_PREEMPT_VOLUNTARY。

服务器内核抢占配置：

CONFIG_PREEMPT_NONE=y
# CONFIG_PREEMPT_VOLUNTARY is not set
# CONFIG_PREEMPT is not set

服务器内核抢占配置一般是CONFIG_PREEMPT_NONE，表示用户态抢占，内核态不可抢占。

通常服务器系统都是配置内核不可抢占的，比如常见的 centos 用于服务器系统，非抢占式内核主要用于服务器等需要处理大量的并发请求，对吞吐量要求较高的场景。

该操作系统没有配置CONFIG_PREEMPT，配置CONFIG_PREEMPT_NONE，表示该系统在内核态是不可抢占的。

/*
 * cond_resched() and cond_resched_lock(): latency reduction via
 * explicit rescheduling in places that are safe. The return
 * value indicates whether a reschedule was done in fact.
 * cond_resched_lock() will drop the spinlock before scheduling,
 */
#ifndef CONFIG_PREEMPT
extern int _cond_resched(void);
#else
static inline int _cond_resched(void) { return 0; }
#endif

#define cond_resched() ({			\
	___might_sleep(__FILE__, __LINE__, 0);	\
	_cond_resched();			\
})

cond_resched() 的目的是显式请求当前任务进行调度。它在可以安全地主动让出处理器给其他任务的位置使用。函数 _cond_resched() 在 cond_resched() 内部调用，以执行实际的调度操作。

由于配置了内核态是不可抢占的，在内核态运行的程序可调用cond_resched主动让出cpu，是为了在不可抢占内核的一些耗时的内核处理路径中增加主动抢占点，防止其在内核态执行时间过长导致可能发生的soft lockup或者造成较大的调度延迟。

比如：对于非抢占式内核来说，在内核的很多地方，特别是文件系统（fs子系统）操作和内存管理（mm子系统）相关的一些耗时路径中，都已经被内核开发者识别出来，并使用cond_resched来减小延迟。

1.1 _cond_resched

#ifndef CONFIG_PREEMPT
int __sched _cond_resched(void)
{
	if (should_resched(0)) {
		preempt_schedule_common();
		return 1;
	}
	rcu_all_qs();
	return 0;
}
EXPORT_SYMBOL(_cond_resched);
#endif

数 _cond_resched() 是一个具有 int 返回类型的函数，其参数列表为空。它的作用是进行条件调度，即根据一定的条件决定是否进行调度操作。

函数内部首先调用 should_resched(0) 来检查是否应该进行调度。should_resched() 是一个用于检查是否应该进行调度的函数，它的参数是一个整数（在此处传入了0）。如果 should_resched() 返回真值（非零），则表示应该进行调度。

如果应该进行调度，函数 _cond_resched() 调用 preempt_schedule_common() 来执行实际的调度操作。preempt_schedule_common() 是一个用于进行抢占式调度的函数，它会切换到其他可运行的任务。

如果不需要进行调度，函数 _cond_resched() 调用 rcu_all_qs() 函数。rcu_all_qs() 是一个用于处理 RCU（Read-Copy-Update）的函数，它用于等待所有的 RCU 队列完成。

最后，根据是否进行了调度操作，函数返回相应的值。如果进行了调度，返回值为1，否则返回0。

1.2 should_resched

// linux-4.19.90/arch/x86/include/asm/preempt.h

DECLARE_PER_CPU(int, __preempt_count);

/*
 * Returns true when we need to resched and can (barring IRQ state).
 */
static __always_inline bool should_resched(int preempt_offset)
{
	return unlikely(raw_cpu_read_4(__preempt_count) == preempt_offset);
}

1.2.1 __preempt_count：

在内核中只要没有持有锁，就可以就行内核抢占，锁是内核态是否抢占的标志，因此引入了一个preempt_count值，preempt_count初始值为0，每当使用锁时，该值就加1，释放锁时，该值就减1。preempt_count等于0代表内核可抢占。

因此对于内核态抢占来说，除了要判断是否设置了_TIF_NEED_RESCHED标志位，还需要判断preempt_count值是否等于0，内核中使用preempt_count来控制内核抢占。只有设置了_TIF_NEED_RESCHED标志位和preempt_count值等于0才能发起内核态抢占。

1.2.2 函数说明

该函数的目的是检查是否需要进行调度，并且在没有 IRQ（中断）发生的情况下可以进行调度。

函数内部使用 raw_cpu_read_4(__preempt_count) 来读取一个名为 __preempt_count 的全局变量的值。__preempt_count 是一个表示抢占计数的变量，用于跟踪当前任务的抢占状态。

unlikely() 宏用于提示编译器这个条件的结果通常是不成立的（即返回值为假）。这有助于编译器进行优化，以提高代码的执行效率。

函数比较 raw_cpu_read_4(__preempt_count) 的返回值与 preempt_offset（在这里也就是0，也就是判断__preempt_count的值是否为0） 参数是否相等。如果这两个值相等，意味着当前任务的抢占计数等于0，即需要进行调度。

如果相等，函数返回真值（非零），表示需要进行调度。否则，返回假值（零），表示不需要进行调度或者 IRQ 发生导致无法进行调度。

这个函数使用了 __always_inline 修饰符，表示建议编译器对该函数进行内联展开，以减少函数调用的开销。

在上面_cond_resched函数中调用should_resched函数时传入的参数是0，如果__preempt_count等于0，那么就发生调度（抢占式调度）。

1.3 preempt_schedule_common

static void __sched notrace preempt_schedule_common(void)
{
	do {
		/*
		 * Because the function tracer can trace preempt_count_sub()
		 * and it also uses preempt_enable/disable_notrace(), if
		 * NEED_RESCHED is set, the preempt_enable_notrace() called
		 * by the function tracer will call this function again and
		 * cause infinite recursion.
		 *
		 * Preemption must be disabled here before the function
		 * tracer can trace. Break up preempt_disable() into two
		 * calls. One to disable preemption without fear of being
		 * traced. The other to still record the preemption latency,
		 * which can also be traced by the function tracer.
		 */
		preempt_disable_notrace();
		preempt_latency_start(1);
		__schedule(true);
		preempt_latency_stop(1);
		preempt_enable_no_resched_notrace();

		/*
		 * Check again in case we missed a preemption opportunity
		 * between schedule and now.
		 */
	} while (need_resched());
}

1.3.1 preempt_schedule_common

__schedule的参数preempt等于1表示是抢占调度，有处于运行态的任务发起的抢占调度。

preempt_schedule_common表示是抢占式调度。

函数内部使用一个循环，不断执行以下步骤：
（1）调用 preempt_disable_notrace()，禁用抢占，但不允许函数跟踪器（function tracer）对其进行跟踪。这是为了避免函数跟踪器在调用 preempt_enable_notrace() 时再次调用该函数，导致无限递归。
（2）调用 preempt_latency_start(1)，开始记录抢占延迟时间，这也可以被函数跟踪器跟踪。
（3）调用 __schedule(true)，进行实际的调度操作，切换到其他可运行的任务。
（4）调用 preempt_latency_stop(1)，停止记录抢占延迟时间。
（5）调用 preempt_enable_no_resched_notrace()，启用抢占，但不允许函数跟踪器进行跟踪，并且不触发重新调度。

最后，在循环的末尾，通过调用 need_resched() 检查是否需要进行重新调度。如果需要重新调度，循环会继续执行上述步骤，直到不再需要重新调度为止。

这个函数的目的是在禁用抢占、记录抢占延迟、执行调度操作以及启用抢占的过程中，确保函数跟踪器的正常工作，并且避免出现无限递归的情况。同时，通过循环检查是否需要重新调度，确保不会错过可能的抢占机会。

1.3.2 preempt_latency_start/stop

preempt_latency_start() 和 preempt_latency_stop() 是用于记录抢占延迟时间的函数：

在多任务操作系统中，任务之间的切换是通过抢占机制实现的。当一个任务被抢占时，需要记录抢占的延迟时间，即从抢占开始到抢占结束的时间间隔。这个延迟时间对于性能分析和系统调优非常重要。

preempt_latency_start() 函数用于开始记录抢占延迟时间。它可能会调用系统计时器或其他相关机制来获取当前时间戳，并将其保存在某个数据结构中。通常，它会接收一个参数，用于标识抢占的类型或事件。

preempt_latency_stop() 函数用于停止记录抢占延迟时间。它也可能会使用系统计时器或其他机制获取当前时间戳，并将其与开始记录时的时间戳进行比较，以计算抢占的实际延迟时间。通常，它也会接收一个参数，用于标识抢占的类型或事件。

通过调用这两个函数，系统可以在抢占开始和结束时记录相关的时间戳，并计算抢占的延迟时间。这些延迟时间可以用于性能分析和诊断，以确定是否存在延迟问题，找出潜在的性能瓶颈，并进行系统调优。

1.3.3 preempt_disable_notrace

当需要禁用抢占且不被函数跟踪器追踪时，使用preempt_disable_notrace()函数。它用于禁用抢占，即当前任务不会被其他任务抢占。这个函数通常在代码的关键部分使用，确保当前任务能够无干扰地执行。

当需要重新启用抢占但不触发立即重新调度时，使用preempt_enable_no_resched_notrace()函数。它用于在禁用抢占后重新启用抢占。函数名中的no_resched表示不会立即重新调度。这意味着即使有更高优先级的任务可用，调度器也不会立即切换到其他任务。这在某些情况下非常有用，可以更加精确地控制调度行为。

总结一下，preempt_disable_notrace()用于禁用抢占且不被函数跟踪器追踪，确保当前任务不会被抢占。而preempt_enable_no_resched_notrace()用于重新启用抢占但不触发立即重新调度，从而更加精确地控制调度行为。这两个函数都用于关键代码区域，需要仔细管理抢占，同时避免受到函数跟踪器的干扰。

#define preempt_disable_notrace()		barrier()
#define preempt_enable_no_resched_notrace()	barrier()

barrier() 是一个预处理宏，用于插入一个内存屏障（memory barrier）。内存屏障是一种同步机制，用于确保在屏障之前和之后的操作按照特定的顺序执行，防止编译器或处理器对指令进行重排序。

在这种情况下，preempt_disable_notrace() 和 preempt_enable_no_resched_notrace() 宏被定义为 barrier()，是为了在禁用抢占和重新启用抢占之间插入内存屏障，以确保相关操作的顺序性。这可能是为了保证在禁用抢占和重新启用抢占之间的任何指令都不会被编译器或处理器进行重排序，从而确保这些操作的原子性和可预测性。

关于内存屏障用途（这段话的来自https://blog.csdn.net/orangeboyye 这个博主）：
内存屏障有两种用途，一是设备内存，设备内存需要顺序执行，不能重排序。
二是多CPU，CPU乱序执行能保证单核逻辑的正确性，但是它不可能替你考虑多核逻辑的正确性，如果你的代码里有多核逻辑(多线程在多核并行运行)，就需要考虑乱序执行带来的影响，就需要内存屏障了。为什么大部分情况你都没用过内存屏障，因为一般情况的多核逻辑你都会用锁，锁里面用的有内存屏障。

参考资料

Linux 4.19.90

Linux内核之内核抢占
Linux 调度器之抢占式调度
cond_resched的使用
深入理解Linux内核之主调度器（上）