linux 中断 下半部 处理时间过长 怎么办

一、中断处理为什么要下半部？

Linux在中断处理中间中断处理分了上半部和下半部，目的就是提高系统的响应能力和并发能力。通俗一点来讲：当一个中断产生，调用该中断对应的处理程序(上半部)然后告诉系统，对应的后半部可以执行了。然后中断处理程序就返回，下半部会在合适的时机有系统调用。这样一来就大大的减少了中断处理所需要的时间。

二、那些工作应该放在上半部，那些应该放在下半部？

没有严格的规则，只有一些提示：

1、对时间非常敏感，放在上半部。

2、与硬件相关的，放在上半部。

3、不能被其他中断打断的工作，放在上半部。

以上三点之外的，考虑放在下半部。

三、下半部机制在Linux中是怎么实现的？

下半部在Linux中有以下实现机制：

1、BH(在2.5中删除)

2、任务队列(task queue，在2.5删除)

3、软中断(softirq，2.3开始。本文重点)

4、tasklet(2.3开始)

5、工作队列(work queue，2.5开始)

四、软中断是怎么实现的(以下代码出自2.6.32)？

软中断不会抢占另外一个软中断，唯一可以抢占软中断的是中断处理程序。

软中断可以在不同CPU上并发执行(哪怕是同一个软中断)

1、软中断是编译期间静态分配的，定义如下：

struct softirq_action { void (*action)(struct softirq_action *)}

/*

* PLEASE, avoid to allocate new softirqs, if you need not _really_ high

* frequency threaded job scheduling. For almost all the purposes

* tasklets are more than enough. F.e. all serial device BHs et

* al. should be converted to tasklets, not to softirqs.

*/

enum {

HI_SOFTIRQ=0,

TIMER_SOFTIRQ,

NET_TX_SOFTIRQ,

NET_RX_SOFTIRQ,

BLOCK_SOFTIRQ,

BLOCK_IOPOLL_SOFTIRQ,

TASKLET_SOFTIRQ,

SCHED_SOFTIRQ,

HRTIMER_SOFTIRQ,

RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */

NR_SOFTIRQS

}

/*

* map softirq index to softirq name. update 'softirq_to_name' in * kernel/softirq.c when adding a new softirq.

*/

extern char *softirq_to_name[NR_SOFTIRQS]

static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp

说明：

(1)、软中断的个数书上说是32，看来到这个版本已经发生变化了。

(2)、void (*action)(struct softirq_action *)传递整个结构体指针在于当结构体成员发生变化是，接口不变。

2、系统执行软中断一个注册的软中断必须被标记后才会执行(触发软中断)，通常中断处理程序会在返回前标记它的软中断。在下列地方，待处理的软中断会被执行：

(1)、从一个硬件中断代码处返回。

(2)、在ksoftirqd内核线程。

(3)、在那些显示检查和执行待处理的软中断代码中。

ksoftirqd说明：

每个处理器都有一个这样的线程。所有线程的名字都叫做ksoftirq/n，区别在于n，它对应的是处理器的编号。在一个双CPU的机器上就有两个这样的线程，分别叫做ksoftirqd/0和ksoftirqd/1。为了保证只要有空闲的处理器，它们就会处理软中断，所以给每个处理器都分配一个这样的线程。

执行软中断的代码如下：

asmlinkage void __do_softirq(void)

{

struct softirq_action *h

__u32 pending

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))

lockdep_softirq_enter()

cpu = smp_processor_id()

restart:

/* Reset the pending bitmask before enabling irqs */

set_softirq_pending(0)

local_irq_enable()

h = softirq_vec

do {

if (pending &1) {

int prev_count = preempt_count()

kstat_incr_softirqs_this_cpu(h - softirq_vec)

trace_softirq_entry(h, softirq_vec)

h->action(h)

trace_softirq_exit(h, softirq_vec)

if (unlikely(prev_count != preempt_count())) {

printk(KERN_ERR "huh, entered softirq %td %s %p"

"with preempt_count %08x,"

" exited with %08x?\n", h - softirq_vec,

softirq_to_name[h - softirq_vec],

h->action, prev_count, preempt_count())

preempt_count() = prev_count

}

rcu_bh_qs(cpu)

}

h++

pending >>= 1

} while (pending)

local_irq_disable()

pending = local_softirq_pending()

if (pending &&--max_restart)

goto restart

if (pending)

wakeup_softirqd()

lockdep_softirq_exit()

account_system_vtime(current)

_local_bh_enable()

}

3、编写自己的软中断

(1)、分配索引，在HI_SOFTIRQ与NR_SOFTIRQS中间添加自己的索引号。

(2)、注册处理程序，处理程序：open_softirq(索引号，处理函数)。

(3)、触发你的软中断：raise_softirq(索引号)。

4、软中断处理程序注意

(1)、软中断处理程序执行的时候，允许响应中断，但自己不能休眠。

(2)、如果软中断在执行的时候再次触发，则别的处理器可以同时执行，所以加锁很关键。

我也是初学者，这里抄一段《Linux设备驱动程序》书上的给你：

Linux的中断宏观分为两种：软中断和硬中断。声明一下，这里的软和硬的意思是指和软件相关以及和硬件相关，而不是软件实现的中断或硬件实现的中断。软中断就是“信号机制”。软中断不是软件中断。Linux通过信号来产生对进程的各种中断 *** 作，我们现在知道的信号共有31个，其具体内容这里略过。

一般来说，软中断是由内核机制的触发事件引起的（例如进程运行超时），但是不可忽视有大量的软中断也是由于和硬件有关的中断引起的，例如当打印机端口产生一个硬件中断时，会通知和硬件相关的硬中断，硬中断就会产生一个软中断并送到 *** 作系统内核里，这样内核就会根据这个软中断唤醒睡眠在打印机任务队列中的处理进程。

硬中断就是通常意义上的“中断处理程序”，它是直接处理由硬件发过来的中断信号的。当硬中断收到它应当处理的中断信号以后，就回去自己驱动的设备上去看看设备的状态寄存器以了解发生了什么事情，并进行相应的 *** 作。

对于软中断，我们不做讨论，那是进程调度里要考虑的事情。由于我们讨论的是设备驱动程序的中断问题，所以焦点集中在硬中断里。我们这里讨论的是硬中断，即和硬件相关的中断。

要中断，是因为外设需要通知 *** 作系统她那里发生了一些事情，但是中断的功能仅仅是一个设备报警灯，当灯亮的时候中断处理程序只知道有事情发生了，但发生了什么事情还要亲自到设备那里去看才行。也就是说，当中断处理程序得知设备发生了一个中断的时候，它并不知道设备发生了什么事情，只有当它访问了设备上的一些状态寄存器以后，才能知道具体发生了什么，要怎么去处理。

设备通过中断线向中断控制器发送高电平告诉 *** 作系统它产生了一个中断，而 *** 作系统会从中断控制器的状态位知道是哪条中断线上产生了中断。PC机上使用的中断控制器是8259，这种控制器每一个可以管理8条中断线，当两个8259级联的时候共可以控制15条中断线。这里的中断线是实实在在的电路，他们通过硬件接口连接到CPU外的设备控制器上。

并不是每个设备都可以向中断线上发中断信号的，只有对某一条确定的中断线勇有了控制权，才可以向这条中断线上发送信号。由于计算机的外部设备越来越多，所以15条中断线已经不够用了，中断线是非常宝贵的资源。要使用中断线，就得进行中断线的申请，就是IRQ(Interrupt Requirement)，我们也常把申请一条中断线成为申请一个IRQ或者是申请一个中断号。

IRQ是非常宝贵的，所以我们建议只有当设备需要中断的时候才申请占用一个IRQ，或者是在申请IRQ时采用共享中断的方式，这样可以让更多的设备使用中断。无论对IRQ的使用方式是独占还是共享，申请IRQ的过程都是一样的，分为3步：

1．将所有的中断线探测一遍，看看哪些中断还没有被占用。从这些还没有被占用的中断中选一个作为该设备的IRQ。

2．通过中断申请函数申请选定的IRQ，这是要指定申请的方式是独占还是共享。

3．根据中断申请函数的返回值决定怎么做：如果成功了万事大吉，如果没成功则或者重新申请或者放弃申请并返回错误。

Linux中的中断处理程序很有特色，它的一个中断处理程序分为两个部分：上半部（top half）和下半部(bottom half)。之所以会有上半部和下半部之分，完全是考虑到中断处理的效率。

上半部的功能是“登记中断”。当一个中断发生时，他就把设备驱动程序中中断例程的下半部挂到该设备的下半部执行队列中去，然后就没事情了--等待新的中断的到来。这样一来，上半部执行的速度就会很快，他就可以接受更多她负责的设备产生的中断了。上半部之所以要快，是因为它是完全屏蔽中断的，如果她不执行完，其它的中断就不能被及时的处理，只能等到这个中断处理程序执行完毕以后。所以，要尽可能多得对设备产生的中断进行服务和处理，中断处理程序就一定要快。

但是，有些中断事件的处理是比较复杂的，所以中断处理程序必须多花一点时间才能够把事情做完。可怎么样化解在短时间内完成复杂处理的矛盾呢，这时候 Linux引入了下半部的概念。下半部和上半部最大的不同是下半部是可中断的，而上半部是不可中断的。下半部几乎做了中断处理程序所有的事情，因为上半部只是将下半部排到了他们所负责的设备的中断处理队列中去，然后就什么都不管了。下半部一般所负责的工作是察看设备以获得产生中断的事件信息，并根据这些信息（一般通过读设备上的寄存器得来）进行相应的处理。如果有些时间下半部不知道怎么去做，他就使用著名的鸵鸟算法来解决问题--说白了就是忽略这个事件。

由于下半部是可中断的，所以在它运行期间，如果其它的设备产生了中断，这个下半部可以暂时的中断掉，等到那个设备的上半部运行完了，再回头来运行它。但是有一点一定要注意，那就是如果一个设备中断处理程序正在运行，无论她是运行上半部还是运行下半部，只要中断处理程序还没有处理完毕，在这期间设备产生的新的中断都将被忽略掉。因为中断处理程序是不可重入的，同一个中断处理程序是不能并行的。

在Linux Kernel 2.0以前，中断分为快中断和慢中断（伪中断我们这里不谈），其中快中断的下半部也是不可中断的，这样可以保证它执行的快一点。但是由于现在硬件水平不断上升，快中断和慢中断的运行速度已经没有什么差别了，所以为了提高中断例程事务处理的效率，从Linux kernel 2.0以后，中断处理程序全部都是慢中断的形式了--他们的下半部是可以被中断的。

但是，在下半部中，你也可以进行中断屏蔽--如果某一段代码不能被中断的话。你可以使用cti、sti或者是save_flag、restore_flag来实现你的想法。

在处理中断的时候，中断控制器会屏蔽掉原先发送中断的那个设备，直到她发送的上一个中断被处理完了为止。因此如果发送中断的那个设备载中断处理期间又发送了一个中断，那么这个中断就被永远的丢失了。

之所以发生这种事情，是因为中断控制器并不能缓冲中断信息，所以当前一个中断没有处理完以前又有新的中断到达，他肯定会丢掉新的中断的。但是这种缺陷可以通过设置主处理器(CPU)上的“置中断标志位”（sti）来解决，因为主处理器具有缓冲中断的功能。如果使用了“置中断标志位”，那么在处理完中断以后使用sti函数就可以使先前被屏蔽的中断得到服务。

有时候需要屏蔽中断，可是为什么要将这个中断屏蔽掉呢？这并不是因为技术上实现不了同一中断例程的并行，而是出于管理上的考虑。之所以在中断处理的过程中要屏蔽同一IRQ来的新中断，是因为中断处理程序是不可重入的，所以不能并行执行同一个中断处理程序。在这里我们举一个例子，从这里子例中可以看出如果一个中断处理程序是可以并行的话，那么很有可能会发生驱动程序锁死的情况。当驱动程序锁死的时候，你的 *** 作系统并不一定会崩溃，但是锁死的驱动程序所支持的那个设备是不能再使用了--设备驱动程序死了，设备也就死了。

A是一段代码，B是 *** 作设备寄存器R1的代码，C是 *** 作设备寄存器R2的代码。其中激发PS1的事件会使A1产生一个中断，然后B1去读R1中已有的数据，然后代码C1向R2中写数据。而激发PS2的事件会使A2产生一个中断，然后B2删除R1中的数据，然后C2读去R2中的数据。

如果PS1先产生，且当他执行到A1和B1之间的时候，如果PS2产生了，这是A2会产生一个中断，将PS2中断掉（挂到任务队列的尾部），然后删除了 R1的内容。当PS2运行到C2时，由于C1还没有向R2中写数据，所以C2将会在这里被挂起，PS2就睡眠在代码C2上，直到有数据可读的时候被信号唤醒。这是由于PS1中的B2原先要读的R1中的数据被PS2中的B2删除了，所以PS1页会睡眠在B1上，直到有数据可读的时候被信号唤醒。这样一来，唤醒PS1和PS2的事件就永远不会发生了，因此PS1和PS2之间就锁死了。

由于设备驱动程序要和设备的寄存器打交道，所以很难写出可以重入的代码来，因为设备寄存器就是全局变量。因此，最简洁的办法就是禁止同一设备的中断处理程序并行，即设备的中断处理程序是不可重入的。

有一点一定要清楚：在2.0版本以后的Linux kernel中，所有的上半部都是不可中断的（上半部的 *** 作是原子性的）；不同设备的下半部可以互相中断，但一个特定的下半部不能被它自己所中断（即同一个下半部不能并）。

由于中断处理程序要求不可重入，所以程序员也不必为编写可重入的代码而头痛了。编写可重入的设备驱动程序是可以的，编写可重入的中断处理程序是非常难得，几乎不可能。

我们都知道，一旦竞争条件出现了，就有可能会发生死锁的情况，严重时可能会将整个系统锁死。所以一定要避免竞争条件的出现。只要注意一点：绝大多数由于中断产生的竞争条件，都是在带有中断的

内核进程被睡眠造成的。所以在实现中断的时候，一定要相信谨慎的让进程睡眠，必要的时候可以使用cli、sti或者save_flag、restore_flag。

---