硬中斷和軟中斷【轉】
轉自：https://blog.csdn.net/zhangskd/article/details/21992933
版權聲明：本文為博主原創文章，轉載請註明出處。 https://blog.csdn.net/zhangskd/article/details/21992933
本文主要內容：硬中斷 / 軟中斷的原理和實現
內核版本：2.6.37
Author：zhangskd @ csdn blog
概述
從本質上來講，中斷是一種電信號，當設備有某種事件發生時，它就會產生中斷，通過總線把電信號發送給中斷控制器。
如果中斷的線是激活的，中斷控制器就把電信號發送給處理器的某個特定引腳。處理器於是立即停止自己正在做的事，
跳到中斷處理程序的入口點，進行中斷處理。
(1) 硬中斷
由與系統相連的外設(比如網卡、硬盤)自動產生的。主要是用來通知操作系統系統外設狀態的變化。比如當網卡收到數據包
的時候，就會發出一個中斷。我們通常所說的中斷指的是硬中斷(hardirq)。
(2) 軟中斷
為了滿足實時系統的要求，中斷處理應該是越快越好。linux為了實現這個特點，當中斷發生的時候，硬中斷處理那些短時間
就可以完成的工作，而將那些處理事件比較長的工作，放到中斷之後來完成，也就是軟中斷(softirq)來完成。
(3) 中斷嵌套
Linux下硬中斷是可以嵌套的，但是沒有優先級的概念，也就是說任何一個新的中斷都可以打斷正在執行的中斷，但同種中斷
除外。軟中斷不能嵌套，但相同類型的軟中斷可以在不同CPU上並行執行。
(4) 軟中斷指令
int是軟中斷指令。
中斷向量表是中斷號和中斷處理函數地址的對應表。
int n - 觸發軟中斷n。相應的中斷處理函數的地址為：中斷向量表地址 + 4 * n。
(5)硬中斷和軟中斷的區別
軟中斷是執行中斷指令產生的，而硬中斷是由外設引發的。
硬中斷的中斷號是由中斷控制器提供的，軟中斷的中斷號由指令直接指出，無需使用中斷控制器。
硬中斷是可屏蔽的，軟中斷不可屏蔽。
硬中斷處理程序要確保它能快速地完成任務，這樣程序執行時才不會等待較長時間，稱為上半部。
軟中斷處理硬中斷未完成的工作，是一種推後執行的機制，屬於下半部。
開關
(1) 硬中斷的開關
簡單禁止和激活當前處理器上的本地中斷：
local_irq_disable();
local_irq_enable();
保存本地中斷系統狀態下的禁止和激活：
unsigned long flags;
local_irq_save(flags);
local_irq_restore(flags);
(2) 軟中斷的開關
禁止下半部，如softirq、tasklet和workqueue等：
local_bh_disable();
local_bh_enable();
需要註意的是，禁止下半部時仍然可以被硬中斷搶占。
(3) 判斷中斷狀態
#define in_interrupt() (irq_count()) // 是否處於中斷狀態(硬中斷或軟中斷)
#define in_irq() (hardirq_count()) // 是否處於硬中斷
#define in_softirq() (softirq_count()) // 是否處於軟中斷
硬中斷
(1) 註冊中斷處理函數
註冊中斷處理函數：
/**
* 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)
(2) 註銷中斷處理函數
/**
* 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);
軟中斷
(1) 定義
軟中斷是一組靜態定義的下半部接口，可以在所有處理器上同時執行，即使兩個類型相同也可以。
但一個軟中斷不會搶占另一個軟中斷，唯一可以搶占軟中斷的是硬中斷。
軟中斷由softirq_action結構體表示：
struct softirq_action {
void (*action) (struct softirq_action *); /* 軟中斷的處理函數 */
};
目前已註冊的軟中斷有10種，定義為一個全局數組：
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 */
};
(2) 註冊軟中斷處理函數
/**
* @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);
(3) 觸發軟中斷
調用raise_softirq()來觸發軟中斷。
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進程 */
}
Percpu變量irq_cpustat_t中的__softirq_pending是等待處理的軟中斷的位圖，通過設置此變量
即可告訴內核該執行哪些軟中斷。
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)
喚醒ksoftirqd內核線程處理軟中斷。
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);
}
在下列地方，待處理的軟中斷會被檢查和執行：
1. 從一個硬件中斷代碼處返回時
2. 在ksoftirqd內核線程中
3. 在那些顯示檢查和執行待處理的軟中斷的代碼中，如網絡子系統中
而不管是用什麽方法喚起，軟中斷都要在do_softirq()中執行。如果有待處理的軟中斷，
do_softirq()會循環遍歷每一個，調用它們的相應的處理程序。
在中斷處理程序中觸發軟中斷是最常見的形式。中斷處理程序執行硬件設備的相關操作，
然後觸發相應的軟中斷，最後退出。內核在執行完中斷處理程序以後，馬上就會調用
do_softirq()，於是軟中斷開始執行中斷處理程序完成剩余的任務。
下面來看下do_softirq()的具體實現。
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);
}
(4) ksoftirqd內核線程
內核不會立即處理重新觸發的軟中斷。
當大量軟中斷出現的時候，內核會喚醒一組內核線程來處理。
這些線程的優先級最低(nice值為19)，這能避免它們跟其它重要的任務搶奪資源。
但它們最終肯定會被執行，所以這個折中的方案能夠保證在軟中斷很多時用戶程序不會
因為得不到處理時間而處於饑餓狀態，同時也保證過量的軟中斷最終會得到處理。
每個處理器都有一個這樣的線程，名字為ksoftirqd/n，n為處理器的編號。
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;
}
---------------------
作者：zhangskd
來源：CSDN
原文：https://blog.csdn.net/zhangskd/article/details/21992933
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！
硬中斷和軟中斷【轉】