softlockup detector-编程知识

softlockup detector

news/2024/7/7 20:42:46/文章来源:https://www.cnblogs.com/robert-hu-453416372/p/18283173

1 简介

从内核稳定性问题的角度来看内核安全，是基础，也是必备技能。很多时候，一个内核稳定性问题，就是造成系统安全的罪魁祸首。

当出现异常死锁、Hang up、死机等问题时，watchdog的作用就很好的体现出来。Watchdog主要用于监测系统运行情况，一旦出现以上异常情况，就会重启系统，并收集crash dump（程序崩溃时保存的运行数据）。

watchdog包括硬件watchdog和软件实现的watchdog，前者是硬件模块，触发时直接硬件复位CPU重启，无法收集crash dump。而软件实现的watchdog可触发panic，收集crashdump等，软件watchdog在Linux内核中有softlockup detector和hardlockup detector，安卓framework也有watchdog。

本文介绍softlockup detector

2 工作原理

假定某一变量的状态能表征系统运行状态，比如中断次数（如果高优先级中断没有发生，就认为CPU卡死），比如/dev/watchdog时间戳（如果超时时间到了仍没有向watchdog节点写数据，就认为用户空间卡死）。
启动一个watchdog程序，定期观测该变量，来判定系统是否正常，并采取相应动作。
内核态watchdog主要用于检测内核Lockup。所谓的Lockup，是指某段内核代码一直占着CPU不放，此时内核调度器无法进行调度工作。进一步严重情况下，会导致整个系统卡死。
Lockup涉及到内核线程、时钟中断。它们有不一样的优先级：内核线程 < 时钟中断。其中，内核线程可以被调度或被中断打断。

3 Lockup分类

只有内核代码才能引起lockup，因为用户代码是可以被抢占的，只有一种情况例外，就是SCHED_FIFO（一直运行，直到进程运行完毕才会释放CPU）优先级为99的实时进程。当它被阻塞或被更高优先级进程抢占时，也可能使[watchdog/x]内核线程抢不到CPU而形成soft lockup。
内核代码必须处于禁止内核抢占的状态(preemption disabled)，Linux是可抢占的，只在某些特定的代码区才禁止抢占（例如spinlock），才可能形成lockup。

Lockup 分为两种：soft lockup 和 hard lockup

Soft lockup在CPU无法正常调度其他线程时发生，即某段代码一直占用某个CPU，导致watchdog/x内核线程得不到调度，此时中断仍可响应；
Hard lockup在中断无法正常响应时发生，即关中断时间过长或中断处理程序执行时间过长。

4 softlockup detector 详解

在驱动中加入以下代码可触发soft lockup，通过spinlock()实现关抢占，使得该CPU上的[watchdog/x]线程无法被调度。

static spinlock_t spinlock;
spin_lock_init(&spinlock);
spin_lock(&spinlock);
while(1);

soft lockup detector机制通过smp_hotplug_thread机制为每个CPU核创建一个内核线程[watchdog/X] （其中N为CPU ID，该内核线程为FIFI 99最高优先级，此类线程设置了 p->flags |= PF_NO_SETAFFINITY属性，不允许用户空间设置CPU亲和性）。该线程定时（每隔4s执行一次）对变量watchdog_touch_ts加加操作，即喂狗。
然后给每个CPU分配一个高精度hrtimer（[watchdog/X] 首次执行时就被创建），该定时器的中断服务程序会每隔4s（sample_period seconds (4 seconds by default)）检测一下变量watchdog_touch_ts是否被更新过，如果20s内该变量仍未更新，就说明CPU卡住，导致watchdog线程无法调度。

hrtimer的中断处理函数是：kernel/watchdog.c/watchdog_timer_fn()。

中断处理函数主要做了以下事情：

对变量hrtimer_interrupts加加操作，该变量同时供hard lockup detector用于判断CPU是否响应中断。
唤醒[watchdog/x]内核线程喂狗（执行soft_lockup_hrtimer_cnt=hrtimer_interrupts赋值即将hrtimer_interrupts更新到soft_lockup_hrtimer_cnt，同时更新watchdog_touch_ts到当时系统时间截，下图有误，并非++）。
检测变量watchdog_touch_ts是否被更新，如果超过20s未更新，说明[watchdog/x]未得到运行，发生了soft lockup，CPU被霸占。

注意：这里的内核线程[watchdog/x]的目的是操作变量watchdog_touch_ts，该变量是被watch的对象。而真正的看门狗，则是由hrtimer中断触发的，即 watchdog_timer_fn()函数，该函数会唤醒喂狗线程。[watchdog/x]是被scheduler调度执行的，而watchdog_timer_fn()则是被中断触发的。

5 源码分析

5.1 全局变量与数据结构

/* Global variables, exported for sysctl */
unsigned int __read_mostly softlockup_panic =CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;static bool softlockup_threads_initialized __read_mostly;
static u64 __read_mostly sample_period; //定时器时间周期，默认4秒//以下per cpu变量，每个CPU有一个
static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts); //[watchdog/x]线程更新的时间截
static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog);//[watchdog/x]线程的 task_struct结构指针
static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer);//[watchdog/x]线程对应的hrtimer中断定时器控制结构
static DEFINE_PER_CPU(bool, softlockup_touch_sync);
static DEFINE_PER_CPU(bool, soft_watchdog_warn);//发生softlockup当标记为true，否则false
static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts);//hrtimer定时器watchdog_timer_fn自增
static DEFINE_PER_CPU(unsigned long, soft_lockup_hrtimer_cnt);//[watchdog/x]线程更新soft_lockup_hrtimer_cnt=hrtimer_interrupts
static DEFINE_PER_CPU(struct task_struct *, softlockup_task_ptr_saved);//定时器回调watchdog_timer_fn保存发生softlockup时current，它不是[watchdog/x]线程的 task_struct结构指针
static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved);//用在hardlockup dectector中
static unsigned long soft_lockup_nmi_warn;static struct smp_hotplug_thread watchdog_threads = {.store			= &softlockup_watchdog,//[watchdog/x]线程的 task_struct结构指针，上面定义的per cpu变量.thread_should_run	= watchdog_should_run,//return (hrtimer_interrupts) !=soft_lockup_hrtimer_cnt)，两者不等则返回true.thread_fn		= watchdog,//[watchdog/x]线程的喂狗回调，先会调用thread_should_run返回true则执行，否则不执行。.thread_comm		= "watchdog/%u",.setup			= watchdog_enable,//[watchdog/x]线程激活时被执行，比thread_fn（即喂狗）回调执行早，它会创建hrtimer，同时设置[watchdog/x]为FIFO 99.cleanup		= watchdog_cleanup,//内部调用下面的watchdog_disable，当有人对此kthread调用了 kthread_stop() 时被执行，一般是module_exit，softlockup的模块一般不会被调用.park			= watchdog_disable,//执行与[watchdog/x]相反的操作，取消定时器，[watchdog/x]线程设为CFS 优先级0.unpark			= watchdog_enable,
};

5.2 创建[watchdog/x]线程（per cpu thread）

softlockup detector通过smp_hotplug_thread机制创建per cpu thread。关于smp_hotplug_thread机制详细见《Linux内核机制smp_hotplug_thread》

kernel_init_freeablelockup_detector_init  //比do_basic_setup调用的早，因此比 early_initcall 调用的还早lockup_detector_setup:ret = smpboot_register_percpu_thread_cpumask(&watchdog_threads, &watchdog_allowed_mask);softlockup_threads_initialized = true;lockup_detector_reconfigure();//detector的配置初始化，包括定时器的周期参数等。/**  smpboot.c* smpboot_register_percpu_thread_cpumask - Register a per_cpu thread related to hotplug* @plug_thread:	Hotplug thread descriptor* @cpumask:		The cpumask where threads run** Creates and starts the threads on all online cpus.*/
int smpboot_register_percpu_thread_cpumask(struct smp_hotplug_thread *plug_thread, const struct cpumask *cpumask)
{unsigned int cpu;int ret = 0;
.................for_each_online_cpu(cpu) {__smpboot_create_thread(plug_thread, cpu);//创建per_cpu thread 即[watchdog/x]smpboot_unpark_thread(plug_thread, cpu);//unpark per_cpu thread}list_add(&plug_thread->list, &hotplug_threads);//挂到hotplug_threads中，以便core管理
............
}static int __smpboot_create_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
{struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);struct smpboot_thread_data *td;td = kzalloc_node(sizeof(*td), GFP_KERNEL, cpu_to_node(cpu));td->cpu = cpu;td->ht = ht;tsk = kthread_create_on_cpu(smpboot_thread_fn, td, cpu,  ht->thread_comm);//创建per_cpu thread 即[watchdog/x]kthread_park(tsk);get_task_struct(tsk);*per_cpu_ptr(ht->store, cpu) = tsk;//内核线程的task_struct指针保存到上面定义的per cpu变量中return 0;
}static int smpboot_thread_fn(void *data)
{struct smpboot_thread_data *td = data;struct smp_hotplug_thread *ht = td->ht;while (1) {set_current_state(TASK_INTERRUPTIBLE);preempt_disable(); //关抢占............................/* Check for state change setup */switch (td->status) {case HP_THREAD_NONE:__set_current_state(TASK_RUNNING);preempt_enable();if (ht->setup) //调用setup即上面的watchdog_enable,，它会创建hrtimer，同时设置[watchdog/x]为FIFO 99ht->setup(td->cpu);td->status = HP_THREAD_ACTIVE;continue;case HP_THREAD_PARKED:__set_current_state(TASK_RUNNING);preempt_enable();if (ht->unpark)ht->unpark(td->cpu);td->status = HP_THREAD_ACTIVE;continue;}if (!ht->thread_should_run(td->cpu)) {//return (hrtimer_interrupts) !=soft_lockup_hrtimer_cnt)，两者不等则返回truepreempt_enable_no_resched();schedule();} else {__set_current_state(TASK_RUNNING);preempt_enable();ht->thread_fn(td->cpu);//上面的(hrtimer_interrupts) !=soft_lockup_hrtimer_cnt)，则执行thread_fn即喂狗函数watchdog()}}
}

5.3 创建hrtimer定时器

由上面的smp_hotplug_thread机制的smpboot_thread_fn处理可知，内核线程第一次执行smp_hotplug_thread::setup()回调时被调用，即watchdog_enable：

static void watchdog_enable(unsigned int cpu)
{struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer);/** Start the timer first to prevent the NMI watchdog triggering* before the timer has a chance to fire.*/hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);hrtimer->function = watchdog_timer_fn;hrtimer_start(hrtimer, ns_to_ktime(sample_period), HRTIMER_MODE_REL_PINNED);/* Initialize timestamp */__touch_watchdog();//喂一次狗，初始化watchdog_touch_ts值，因为上面定义时没初始化，它是0//smp_hotplug_thread机制创建的内核线程是CFS 120，此处设置为FIFO 99watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1);
}

以上5.2, 5.3节流程处理完后，系统为每个CPU核创建了一个内核线程，优先级为FIFO 99：

sh-3.2# ps | grep watchdog12 root         0 SW   [watchdog/0]15 root         0 SW   [watchdog/1]21 root         0 SW   [watchdog/2]27 root         0 SW   [watchdog/3]
sh-3.2# chrt -p 12
pid 12's current scheduling policy: SCHED_FIFO
pid 12's current scheduling priority: 99

5.4 定时喂狗

5.4.1 hrtimer时间周期

在detector init中（5.2节也提到），配置了定时器的周期参数sample_period（全局变量），它的值由watchdog_thresh乘2除5，转化为纳秒计算得来，watchdog_thresh默认10秒（可通过/proc/sys/kernel/watchdog_thresh修改），即定时器一次调用周期4秒，即每4秒喂一狗，详见如下代码：

lockup_detector_initlockup_detector_setup:ret = smpboot_register_percpu_thread_cpumask(&watchdog_threads, &watchdog_allowed_mask);softlockup_threads_initialized = true;lockup_detector_reconfigure()://detector的配置初始化，包括定时器的周期参数等。set_sample_periodstatic int get_softlockup_thresh(void)
{return watchdog_thresh * 2;//watchdog_thresh默认是10秒， 可通过/proc/sys/kernel/watchdog_thresh修改
}
static void set_sample_period(void)
{sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5);//20除5==4秒，转化为纳秒作为hrtimer采样周期。watchdog_update_hrtimer_threshold(sample_period);//hardlockup detector用的，不关心。
}

5.4.2 hrtimer定时器喂狗

主要做了两件事：

soft_lockup_hrtimer_cnt == hrtimer_interrupts
watchdog_touch_ts == get_timestamp(); //喂狗

//watchdog_timer_fn是5.3节创建hrtimer定时器时绑定的回调函数，每隔4秒执行一次：
static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
{unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);/* kick the softlockup detector *///唤醒内核线程[watchdog/x]，它会通过thread_should_run判断是否应该调用thread_fn即喂狗函数watchdog，详见见smpboot_thread_fn//thread_should_run是return (hrtimer_interrupts) !=soft_lockup_hrtimer_cnt)，两者不等则返回truewake_up_process(__this_cpu_read(softlockup_watchdog)); //唤醒[watchdog/X]线程喂狗/* .. and repeat */hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));//更新定时器，4秒后再触发。.....
}/*下面两个都是[watchdog/X]线程的上下文，正在喂狗的地方，上面是hrtimer定时器的上下文（主要用于唤醒唤醒[watchdog/X]线程及检测是否发生softlockup），发生softlockup时dumpstack栈空间是hrtimer的上下文，即发生softlockup时在CPU上running的线程。*/
static void __touch_watchdog(void)
{__this_cpu_write(watchdog_touch_ts, get_timestamp());//喂狗
}
static void watchdog(unsigned int cpu)
{__this_cpu_write(soft_lockup_hrtimer_cnt,  __this_cpu_read(hrtimer_interrupts));__touch_watchdog();//喂狗
}

5.5 hrtimer定时器detect softlockup

hrtimer每隔4秒检测是否发生softlockup，检测逻辑为：
如果20s内都没更新watchdog_touch_ts ，就认为出现了soft lockup，详细原理见2节和4节。

/* Global variables, exported for sysctl */
unsigned int __read_mostly softlockup_panic = CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;/* watchdog_timer_fn是5.3节创建hrtimer定时器时绑定的回调函数，每隔4秒执行一次： */
static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
{unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);watchdog_interrupt_count();  /* 对hrtimer_interrupts加1操作*/wake_up_process(__this_cpu_read(softlockup_watchdog)); /* 唤醒喂狗线程[watchdog/X] 见5.4.2节*//* ..  and repeat  更新定时器，4秒后再触发。 */hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));/* check for a softlockup* This is done by making sure a high priority task is* being scheduled.  The task touches the watchdog to* indicate it is getting cpu time.  If it hasn't then* this is a good indication some task is hogging the cpu* 英文判断softlockup很详细，如果某个CPU卡死，该CPU的watchdog线程不会被调度，即watchdog_touch_ts* 不会被更新。如果20s内都没更新watchdog_touch_ts ，就认为出现了soft lockup* is_softlockup内部实现是：* 如果watchdog_touch_ts 20秒更新，返回duration = 当时时间截 - watchdog_touch_ts 否则返回0* duration > 0表示发生了softlockup*/duration = is_softlockup(touch_ts);if (unlikely(duration)) {pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",smp_processor_id(), duration,current->comm, task_pid_nr(current));__this_cpu_write(softlockup_task_ptr_saved, current);print_modules();print_irqtrace_events(current);dump_stack();add_taint(TAINT_SOFTLOCKUP, LOCKDEP_STILL_OK);if (softlockup_panic) //CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE配置为1时触发softlockup panicpanic("softlockup: hung tasks");__this_cpu_write(soft_watchdog_warn, true);} else__this_cpu_write(soft_watchdog_warn, false);return HRTIMER_RESTART;
}static int is_softlockup(unsigned long touch_ts)
{unsigned long now = get_timestamp();/* 如果某个CPU卡死，该CPU的watchdog线程不会被调度，即watchdog_touch_ts *//* 不会被更新。如果20s内都没更新watchdog_touch_ts ，就认为出现了soft lockup *//* get_softlockup_thresh()函数返回20 */if (time_after(now, touch_ts + get_softlockup_thresh()))return now - touch_ts;return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/737991.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！