kk Blog —— 通用基础

  append=”nmi_watchdog=1”

//  使能hard lockup探测
//  调用路径：watchdog_enable->watchdog_nmi_enable
//  函数任务：
//      1.初始化hard lockup检测事件
//          2.hard lockup阈值为10s
//      2.向performance monitoring子系统注册hard lockup检测事件
//      3.使能hard lockup检测事件
//  注：
//      performance monitoring，x86中的硬件设备，当cpu clock经过了指定个周期后发出一个NMI中断。
1.1 static int watchdog_nmi_enable(unsigned int cpu)
{
	//hard lockup事件
	struct perf_event_attr *wd_attr;
	struct perf_event *event = per_cpu(watchdog_ev, cpu);
	....
	wd_attr = &wd_hw_attr;
	//hard lockup检测周期，10s
	wd_attr->sample_period = hw_nmi_get_sample_period(watchdog_thresh);
	//向performance monitoring注册hard lockup检测事件
	event = perf_event_create_kernel_counter(wd_attr, cpu, NULL, watchdog_overflow_callback, NULL);
	....
	//使能hard lockup的检测
	per_cpu(watchdog_ev, cpu) = event;
	perf_event_enable(per_cpu(watchdog_ev, cpu));
	return 0;
}
 
//  换算hard lockup检测周期到cpu频率
1.2 u64 hw_nmi_get_sample_period(int watchdog_thresh)
{
	return (u64)(cpu_khz) * 1000 * watchdog_thresh;
}
 
//  hard lockup检测事件发生时的nmi回调函数
//  函数任务：
//      1.判断是否发生了hard lockup
//          1.1 dump hard lockup信息
1.3 static void watchdog_overflow_callback(struct perf_event *event,
	 struct perf_sample_data *data,
	 struct pt_regs *regs)
{
	//判断是否发生hard lockup
	if (is_hardlockup()) {
		int this_cpu = smp_processor_id();
 
		//打印hard lockup信息
		if (hardlockup_panic)
			panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
		else
			WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
 
		return;
	}
	return;
}
 
//  判断是否发生hard lockup
//  注：
//      如果时钟中断在指定阈值范围内为运行，核心认为可屏蔽中断被屏蔽时间过长
1.4 static int is_hardlockup(void)
{
	//获取watchdog timer的运行次数
	unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
	//在一个hard lockup检测时间阈值内，如果watchdog timer未运行，说明cpu中断被屏蔽时间超过阈值
	if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
		return 1;
	//记录watchdog timer运行的次数
	__this_cpu_write(hrtimer_interrupts_saved, hrint);
	return 0;
}
 
//  关闭hard lockup检测机制
//  函数任务：
//      1.向performance monitoring子系统注销hard lockup检测控制块
//      2.清空per-cpu hard lockup检测控制块
//      3.释放hard lock检测控制块
2.1 static void watchdog_nmi_disable(unsigned int cpu)
{
	struct perf_event *event = per_cpu(watchdog_ev, cpu);
	if (event) {
		//向performance monitoring子系统注销hard lockup检测控制块
		perf_event_disable(event);
		//清空per-cpu hard lockup检测控制块
		per_cpu(watchdog_ev, cpu) = NULL;
		//释放hard lock检测控制块
		perf_event_release_kernel(event);
	}
	return;
}

local_irq_disable();
local_irq_enable();

unsigned long flags;
local_irq_save(flags);
local_irq_restore(flags);

local_bh_disable();
local_bh_enable();

#define in_interrupt() (irq_count()) // 是否处于中断状态(硬中断或软中断)
#define in_irq() (hardirq_count()) // 是否处于硬中断
#define in_softirq() (softirq_count()) // 是否处于软中断

/** 
 * irq: 要分配的中断号 
 * handler: 要注册的中断处理函数 
 * flags: 标志(一般为0) 
 * name: 设备名(dev->name) 
 * dev: 设备(struct net_device *dev)，作为中断处理函数的参数 
 * 成功返回0 
 */  
  
int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,   
	const char *name, void *dev);  

typedef irqreturn_t (*irq_handler_t) (int, void *);  
  
/** 
 * enum irqreturn 
 * @IRQ_NONE: interrupt was not from this device 
 * @IRQ_HANDLED: interrupt was handled by this device 
 * @IRQ_WAKE_THREAD: handler requests to wake the handler thread 
 */  
enum irqreturn {  
	IRQ_NONE,  
	IRQ_HANDLED,  
	IRQ_WAKE_THREAD,  
};  
typedef enum irqreturn irqreturn_t;  
#define IRQ_RETVAL(x) ((x) != IRQ_NONE)  

/** 
 * free_irq - free an interrupt allocated with request_irq 
 * @irq: Interrupt line to free 
 * @dev_id: Device identity to free 
 * 
 * Remove an interrupt handler. The handler is removed and if the 
 * interrupt line is no longer in use by any driver it is disabled. 
 * On a shared IRQ the caller must ensure the interrupt is disabled 
 * on the card it drives before calling this function. The function does 
 * not return until any executing interrupts for this IRQ have completed. 
 * This function must not be called from interrupt context. 
 */  
  
void free_irq(unsigned int irq, void *dev_id);  

struct softirq_action {  
	void (*action) (struct softirq_action *); /* 软中断的处理函数 */  
};  

static struct softirq_action softirq_vec[NR_SOFTIRQS];  
  
enum {  
	HI_SOFTIRQ = 0, /* 优先级高的tasklets */  
	TIMER_SOFTIRQ, /* 定时器的下半部 */  
	NET_TX_SOFTIRQ, /* 发送网络数据包 */  
	NET_RX_SOFTIRQ, /* 接收网络数据包 */  
	BLOCK_SOFTIRQ, /* BLOCK装置 */  
	BLOCK_IOPOLL_SOFTIRQ,  
	TASKLET_SOFTIRQ, /* 正常优先级的tasklets */  
	SCHED_SOFTIRQ, /* 调度程序 */  
	HRTIMER_SOFTIRQ, /* 高分辨率定时器 */  
	RCU_SOFTIRQ, /* RCU锁定 */  
	NR_SOFTIRQS /* 10 */  
};  

/** 
 * @nr: 软中断的索引号 
 * @action: 软中断的处理函数 
 */  
  
void open_softirq(int nr, void (*action) (struct softirq_action *))  
{  
	softirq_vec[nr].action = action;  
}  

open_softirq(NET_TX_SOFTIRQ, net_tx_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);

void raise_softirq(unsigned int nr)  
{  
	unsigned long flags;  
	local_irq_save(flags);  
	raise_softirq_irqoff(nr);  
	local_irq_restore(flags);  
}  
  
/* This function must run with irqs disabled */  
inline void rasie_softirq_irqsoff(unsigned int nr)  
{  
	__raise_softirq_irqoff(nr);  
  
	/* If we're in an interrupt or softirq, we're done 
	 * (this also catches softirq-disabled code). We will 
	 * actually run the softirq once we return from the irq 
	 * or softirq. 
	 * Otherwise we wake up ksoftirqd to make sure we 
	 * schedule the softirq soon. 
	 */  
	if (! in_interrupt()) /* 如果不处于硬中断或软中断 */  
		wakeup_softirqd(void); /* 唤醒ksoftirqd/n进程 */  
}  

static inline void __rasie_softirq_irqoff(unsigned int nr)  
{  
	trace_softirq_raise(nr);  
	or_softirq_pending(1UL << nr);  
}  
  
typedef struct {  
	unsigned int __softirq_pending;  
	unsigned int __nmi_count; /* arch dependent */  
} irq_cpustat_t;  
  
irq_cpustat_t irq_stat[];  
#define __IRQ_STAT(cpu, member) (irq_stat[cpu].member)  
#define or_softirq_pending(x) percpu_or(irq_stat.__softirq_pending, (x))  
#define local_softirq_pending() percpu_read(irq_stat.__softirq_pending)  

static void wakeup_softirqd(void)  
{  
	/* Interrupts are disabled: no need to stop preemption */  
	struct task_struct *tsk = __get_cpu_var(ksoftirqd);  
  
	if (tsk && tsk->state != TASK_RUNNING)  
		wake_up_process(tsk);  
}  

asmlinkage void do_softirq(void)  
{  
	__u32 pending;  
	unsigned long flags;  
  
	/* 如果当前已处于硬中断或软中断中，直接返回 */  
	if (in_interrupt())   
		return;  
  
	local_irq_save(flags);  
	pending = local_softirq_pending();  
	if (pending) /* 如果有激活的软中断 */  
		__do_softirq(); /* 处理函数 */  
	local_irq_restore(flags);  
}  

/* We restart softirq processing MAX_SOFTIRQ_RESTART times, 
 * and we fall back to softirqd after that. 
 * This number has been established via experimentation. 
 * The two things to balance is latency against fairness - we want 
 * to handle softirqs as soon as possible, but they should not be 
 * able to lock up the box. 
 */  
asmlinkage void __do_softirq(void)  
{  
	struct softirq_action *h;  
	__u32 pending;  
	/* 本函数能重复触发执行的次数，防止占用过多的cpu时间 */  
	int max_restart = MAX_SOFTIRQ_RESTART;  
	int cpu;  
  
	pending = local_softirq_pending(); /* 激活的软中断位图 */  
	account_system_vtime(current);  
	/* 本地禁止当前的软中断 */  
	__local_bh_disable((unsigned long)__builtin_return_address(0), SOFTIRQ_OFFSET);  
	lockdep_softirq_enter(); /* current->softirq_context++ */  
	cpu = smp_processor_id(); /* 当前cpu编号 */  
  
restart:  
	/* Reset the pending bitmask before enabling irqs */  
	set_softirq_pending(0); /* 重置位图 */  
	local_irq_enable();  
	h = softirq_vec;  
	do {  
		if (pending & 1) {  
			unsigned int vec_nr = h - softirq_vec; /* 软中断索引 */  
			int prev_count = preempt_count();  
			kstat_incr_softirqs_this_cpu(vec_nr);  
  
			trace_softirq_entry(vec_nr);  
			h->action(h); /* 调用软中断的处理函数 */  
			trace_softirq_exit(vec_nr);  
  
			if (unlikely(prev_count != preempt_count())) {  
				printk(KERN_ERR "huh, entered softirq %u %s %p" "with preempt_count %08x,"  
					"exited with %08x?\n", vec_nr, softirq_to_name[vec_nr], h->action, prev_count,  
					preempt_count());  
			}  
			rcu_bh_qs(cpu);  
		}  
		h++;  
		pending >>= 1;  
	} while(pending);  
  
	local_irq_disable();  
	pending = local_softirq_pending();  
	if (pending & --max_restart) /* 重复触发 */  
		goto restart;  
  
	/* 如果重复触发了10次了，接下来唤醒ksoftirqd/n内核线程来处理 */  
	if (pending)  
		wakeup_softirqd();   
  
	lockdep_softirq_exit();  
	account_system_vtime(current);  
	__local_bh_enable(SOFTIRQ_OFFSET);  
}  

static int run_ksoftirqd(void *__bind_cpu)  
{  
	set_current_state(TASK_INTERRUPTIBLE);  
	current->flags |= PF_KSOFTIRQD; /* I am ksoftirqd */  
  
	while(! kthread_should_stop()) {  
		preempt_disable();  
  
		if (! local_softirq_pending()) { /* 如果没有要处理的软中断 */  
			preempt_enable_no_resched();  
			schedule();  
			preempt_disable():  
		}  
  
		__set_current_state(TASK_RUNNING);  
  
		while(local_softirq_pending()) {  
			/* Preempt disable stops cpu going offline. 
			 * If already offline, we'll be on wrong CPU: don't process. 
			 */  
			 if (cpu_is_offline(long)__bind_cpu))/* 被要求释放cpu */  
				 goto wait_to_die;  
  
			do_softirq(); /* 软中断的统一处理函数 */  
  
			preempt_enable_no_resched();  
			cond_resched();  
			preempt_disable();  
			rcu_note_context_switch((long)__bind_cpu);  
		}  
  
		preempt_enable();  
		set_current_state(TASK_INTERRUPTIBLE);  
	}  
  
	__set_current_state(TASK_RUNNING);  
	return 0;  
  
wait_to_die:  
	preempt_enable();  
	/* Wait for kthread_stop */  
	set_current_state(TASK_INTERRUPTIBLE);  
	while(! kthread_should_stop()) {  
		schedule();  
		set_current_state(TASK_INTERRUPTIBLE);  
	}  
  
	__set_current_state(TASK_RUNNING);  
	return 0;  
}