阅读数:187 评论数:0

一、概述

在 Linux 内核中，preempt_count 是一个用于跟踪抢占和中断深度的计数器。它是一个 per-CPU 变量，意味着每个处理器核心有自己的 preempt_count。这个计数器的作用是防止在不合适的时候发生抢占，确保内核的关键代码段可以安全地执行，而不会被其他任务或中断打断。

preempt_count 包含了几个不同的计数器，每个都有不同的目的：

• 抢占计数：当内核代码正在执行一个不应该被抢占的关键部分时，抢占计数会增加。这通常发生在关键代码段，比如内核锁定期间。

• 中断计数：当处理器正在处理中断时，中断计数会增加。这防止了嵌套中断的发生，即一个中断处理程序被另一个中断打断。

• 软中断（或软IRQ）计数：软中断处理程序也会增加 preempt_count，以防止它们被其他软中断或某些类型的中断打断。

二、查看preempt_count

在内核开发中，可以通过查看当前 CPU 的 preempt_count 值来确定当前是否处于抢占不可中断的代码段。这个值可以通过读取当前任务的 thread_info 结构体中的 preempt_count 成员来获取，或者在某些内核调试工具中直接查看。

三、使用场景

以下是一些使用 preempt_count 的场景：

• 内核调度器：在内核调度器中，preempt_count 用于确定是否可以安全地进行任务切换。
• 锁定机制：在获取和释放内核锁时，preempt_count 用于确保锁的持有者不会被抢占。
• 中断和软中断处理：在中断和软中断（softirq）处理中，preempt_count 确保处理程序可以在没有干扰的情况下运行。

四、内核配置

内核的抢占模型可以在编译内核时通过配置选项来选择。例如：

• CONFIG_PREEMPT_NONE：无抢占模型，适用于需要最大吞吐量的服务器环境。
• CONFIG_PREEMPT_VOLUNTARY：自愿抢占模型，适用于需要良好响应性但不需要极端低延迟的系统。
• CONFIG_PREEMPT：完全抢占模型，适用于需要极低延迟的实时应用。

五、源码相关部分

/*
* low level task data that entry.S needs immediate access to.
* __switch_to() assumes cpu_context follows immediately after cpu_domain.
*/
struct thread_info {
unsigned long flags; /* low level flags */
mm_segment_t addr_limit; /* address limit */
struct task_struct *task; /* main task structure */
struct exec_domain *exec_domain; /* execution domain */
struct restart_block restart_block;
int preempt_count; /* 0 => preemptable, <0 => bug */
int cpu; /* cpu */
};

在支持可抢占的系统中，一个进程的thread_info信息定义如上。其中preempt_count代表的是该进程是否可以被抢占，根据注释的说明当peermpt_count等于0的时候当前进程可以被抢占，当小于0存在bug，当大于0说明当前进程不可以被抢占。比如当前进程在中断上下文中或者使用了锁。

<linux/include/preempt_mask.h>
------------------------------------------
/*
* We put the hardirq and softirq counter into the preemption
* counter. The bitmask has the following meaning:
*
* - bits 0-7 are the preemption count (max preemption depth: 256)
* - bits 8-15 are the softirq count (max # of softirqs: 256)
*
* The hardirq count could in theory be the same as the number of
* interrupts in the system, but we run all interrupt handlers with
* interrupts disabled, so we cannot have nesting interrupts. Though
* there are a few palaeontologic drivers which reenable interrupts in
* the handler, so we need more than one bit here.
*
* PREEMPT_MASK: 0x000000ff
* SOFTIRQ_MASK: 0x0000ff00
* HARDIRQ_MASK: 0x000f0000
* NMI_MASK: 0x00100000
* PREEMPT_ACTIVE: 0x00200000
*/
#define PREEMPT_BITS 8
#define SOFTIRQ_BITS 8
#define HARDIRQ_BITS 4
#define NMI_BITS 1

结合上述的示图和代码的定义可知，bit0-7代表的是抢占的次数，最大抢占深度为256次，bit8-15代表的是软中断的次数，最大也是256次，bit16-19表示中断的次数，注释的大概意思是避免中断嵌套，但是也不能防止某些驱动中断嵌套使用中断，所以嵌套16层也是最大次数了。bit20代表的NMI中断，bit21代表当前抢占是否active。

Linux系统为了方便得出各个字段的值，提供了一系列宏定义如下：

#define PREEMPT_SHIFT 0
#define SOFTIRQ_SHIFT (PREEMPT_SHIFT + PREEMPT_BITS) //0+8=8
#define HARDIRQ_SHIFT (SOFTIRQ_SHIFT + SOFTIRQ_BITS) //8+8=16
#define NMI_SHIFT (HARDIRQ_SHIFT + HARDIRQ_BITS) //16+4=20

#define __IRQ_MASK(x) ((1UL << (x))-1)

#define PREEMPT_MASK (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
#define SOFTIRQ_MASK (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
#define HARDIRQ_MASK (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
#define NMI_MASK (__IRQ_MASK(NMI_BITS) << NMI_SHIFT)

#define PREEMPT_OFFSET (1UL << PREEMPT_SHIFT) //1<<0
#define SOFTIRQ_OFFSET (1UL << SOFTIRQ_SHIFT) //1<<8
#define HARDIRQ_OFFSET (1UL << HARDIRQ_SHIFT) //1<<16
#define NMI_OFFSET (1UL << NMI_SHIFT) //1<<20

#define SOFTIRQ_DISABLE_OFFSET (2 * SOFTIRQ_OFFSET) //16

#define PREEMPT_ACTIVE_BITS 1
#define PREEMPT_ACTIVE_SHIFT (NMI_SHIFT + NMI_BITS)
#define PREEMPT_ACTIVE (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)

#define hardirq_count() (preempt_count() & HARDIRQ_MASK) //硬中断count
#define softirq_count() (preempt_count() & SOFTIRQ_MASK) //软中断count
#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
| NMI_MASK)) //所有中断=硬+软+NMI

从上述的定义可以得出，如果想知道硬中断的次数就使用hardirq_count，如果想知道中断次数就使用softirq_count，如果想知道所有中断的次数就使用irq_count。

/*
* Are we doing bottom half or hardware interrupt processing?
* Are we in a softirq context? Interrupt context?
* in_softirq - Are we currently processing softirq or have bh disabled?
* in_serving_softirq - Are we currently processing softirq?
*/
#define in_irq() (hardirq_count())
#define in_softirq() (softirq_count())
#define in_interrupt() (irq_count())
#define in_serving_softirq() (softirq_count() & SOFTIRQ_OFFSET)

其中in_irq用于判断当前进程是否在硬中断中，in_softirq用于判断是否当前进程在软件中断或者有别的进程disable了软中断，in_interrupt用于判断当前进程是否在中断中，而in_serving_softirq用于判断当前进程是否在软件中断中，通过bit8这一位来判断。

#define in_atomic() ((preempt_count() & ~PREEMPT_ACTIVE) != 0)

这个宏可以判断当前进程是否处于原子操作中。