0
中断：指cpu在执行过程中，出现了某些突发事件时CPU必须暂停执行当前的程序，转去处理突发事件，处理完毕后CPU有返回原程序被中断的位置并继续执行。
中断的分法不懂，分类就不同，向什么内外部中断，可/不可屏蔽中断…等等乱七八糟一大堆，我这里要说明的一点是按照中断入口跳转方法的不同，可分为向量中断和非向量中断。采用向量中断的CPU通常为不同的中断分配不同的中断号，当检测到某中断号的中断到来后，就自动跳转到与该中断号对应的地址执行。不同的中断号有不同的中断地址（即入口）。而非向量中断的多个中断共享一个入口地址。进入后根据软件判断中断标志来识别具体是哪个中断。也就是说，向量中断是由硬件提供中断服务程序入口地址，非向量中断由软件提供中断服务程序入口地址。
Linux中断处理架构
设备的中断会打断内核中进程的正常调度和运行，会影响系统的性能。为了在中断执行时间尽可能短和中断处理需完成大量工作之间找到一个平衡点，Linux将中断处理程序分解成两个半部：顶半部和底半部。其中顶半部尽可能完成尽可能少的比较紧急的功能。而底半部几乎做了中断处理程序所有的事情，而且可以被新的中断打断。
1）设备申请中断
int request_irq(unsigned int irq, //irq是要申请的中断号
void (*handler)(int irq, void *dev_id, struct pt_regs * *regs),//回调函数，中断发生时，系统会调用该函数，
unsigned long irqflags,
const char *devname,
void *dev_id);
其中irqflags是中断处理的属性，若设置为SA_INTERRUPT,则表示中断处理程序是快速处理程序，它被调用时屏蔽所有中断。若设置为SA_SHIRQ,则表示多个设备共享中断，dev_id在中断共享时会用到，一般设置为这个设备的设备结构体或者NULL.
该函数返回0表示成功，返回-INVAL表示中断号无效或处理函数指针为NULL,返回EBUSY表示中断已经被占用且不能共享。
2）释放中断
free_irq(unsigned int irq, void *dev_id);
3)使能和屏蔽中断
void disable_irq(int irq); //这个会立即返回
void disable_irq_nosync(int irq);//等待目前的中断处理完成再返回。
void enable_irq(int irq);
上述三个函数作用于可编程中断处理器，因此对系统内所有的CPU都生效。
void local_irq_save(unsigned long flags);//会将目前的中断状态保留在flags中
void local_irq_disable(void);//直接中断
这两个将屏蔽本CPU内的所有中断。对应的上边两个中断的方法如下
void local_irq_restore(unsigned long flags);
void local_irq_enable(void);
我们两边说了Linux系统中中断是分为顶半部和底半部的，那么在系统实现方面是具体怎样实现的呢，这主要有tasklet，工作队列，软中断：
1)tasklet：使用比较简单，如下：
void my_tasklet_function(unsigned long); //定义一个处理函数
DECLARE_TASKLET(my_tasklet, my_tasklet_function, data); //定义了一个名叫my_tasklet的tasklet并将其与处理函数绑定，而传入参数为data
在需要调度tasklet的时候引用一个tasklet_schedule()函数就能使系统在适当的时候进行调度运行：tasklet_schedule(&my_tasklet);
2)工作队列：使用方法和tasklet相似，如下：
struct work_struct my_wq; //定义一个工作队列
void my_wq_func(unsigned long); //定义一个处理函数
通过INIT_WORK()可以初始化这个工作队列并将工作队列与处理函数绑定，如下：
INIT_WORK(&my_wq, (void (*)(void *))my_wq_func, NULL); //初始化工作队列并将其与处理函数绑定
同样，使用schedule_work(&my_irq)；来在系统在适当的时候需要调度时使用运行。
3)软中断：使用软件方式模拟硬件中断的概念，实现宏观上的异步执行效果，tasklet也是基于软中断实现的。
在Linux内核中，用softirq_action结构体表征一个软中断，这个结构体中包含软中断处理函数指针和传递给函数的参数，使用open_softirq()可以注册软中断对应的处理函数，而raise_softirq()函数可以触发一个中断。
软中断和tasklet仍然运行与中断上下文，而工作队列则运行于进程上下文。因此，软中断和tasklet的处理函数不能休眠，但工作队列是可以的。
local_bh_disable()和local_bh_enable()是内核用于禁止和使能软中断和tasklet底半部机制的函数。
下边咱们再来说说有关中断共享的相关点：中断共享即是多个设备共享一根硬件中断线的情况。Linux2.6内核支持中断共享，使用方法如下：
*共享中断的多个设备在申请中断时都应该使用SA_SHIRQ标志，而且一个设备以SA_SHIRQ申请某中断成功的前提是之前该中断的所有设备也都以SA_SHIRQ标志申请该终端
*尽管内核模块可访问的全局地址都可以作为request_irq(….,void *dev_id)的最后一个参数dev_id,但是设备结构体指针是可传入的最佳参数。
*在中断带来时，所有共享此中断的中断处理程序都会被执行，在中断处理程序顶半部中，应迅速根据硬件寄存器中的信息比照传入的dev_id参数判断是否是被设备的中断，如果不是，应迅速返回。
中断的使用典型模版
1)在中断分类中，我们说到了有关向量中断和非向量中断，向量中断就是入口地址不同，进不同的地址做不同的事。那非向量中断则是进同一地址，至于区分就放在了进去后用条件判断,请看下边的模板：
irq_handler()
{
...
int int_src = read_int_status(); //读硬件的中断相关寄存器
switch(int_src) //判断中断源
｛
case DEV_A:
dev_a_handler();
break;
case DEV_B:
dev_b_handler();
break;
....
default:
break;
｝
}
2)在底半部机制中，我们讲了tasklet，工作队列和软中断先来看tasklet
tasklet使用模版：
void xxx_do_tasklet(unsigned long);
DECLARE_TASKLET(XXX_tasklet, xxx_do_tasklet, 0);
void xxx_do_tasklet(unsigned long) //中断处理底半部
{
.....
}
irqreturn_t xxx_interrupt(int irq, void *dev_id, struct pt_regs *regs) //中断处理顶半部
{
...
tasklet_schedule(&xxx_tasklet);
}
int __init xxx_init(void) //设备驱动模块加载函数
{
..
result= request_irq(xxx_irq, xxx_interrupt, SA_INTERRUPT, "XXX",NULL); //申请中断
...
}
void __exit xxx_exit(void) //设备驱动卸载模块
{
..
free_irq(xxx_irq, xxx_interrupt); //释放中断
..
}
工作队列模版：
struct work_struct xxx_wq;
void xxx_do_work(unsigned long);
void xxx_do_work(unsigned long) //中断处理底半部
{
.....
}
irqreturn_t xxx_interrupt(int irq, void *dev_id, struct pt_regs *regs) //中断处理顶半部
{
...
schedule_work(&xxx_wq);
}
int xxx_init(void) //设备驱动模块加载函数
{
..
result= request_irq(xxx_irq, xxx_interrupt, SA_INTERRUPT, "XXX",NULL); //申请中断
...
INIT_WORK(&xxx_wq, (void (*)(void *))xxx_do_work, NULL);
...
}
void __exit xxx_exit(void) //设备驱动卸载模块
{
..
free_irq(xxx_irq, xxx_interrupt); //释放中断
..
}
3)在上节最后我还给你讲了有关中断共享的东西吧，也把模版给你：
irqreturn_t xxx_interrupt(int irq, void *dev_id, struct pt_regs *regs) //中断处理顶半部
{
...
int status = read_int_status(); //获取终端源
if(!is_myint(dev_id, status)) //判断是否是本设备的中断
{
return IRQ_NONE://立即返回
}
..
return IRQ_HANDLED;
}
int __init xxx_init(void) //设备驱动模块加载函数
{
..
result= request_irq(xxx_irq, xxx_interrupt, SA_SHIRQ, "XXX",xxx_dev); //申请共享中断
...
}
void __exit xxx_exit(void) //设备驱动卸载模块
{
..
free_irq(xxx_irq, xxx_interrupt); //释放中断
..
}
共享中断中，我们仔细看一下其实也没什么，不是。就是在和前边中断中要修改一下中断标志，在中断处理中判断一下是否是自己本地的中断。
定时器：
定时器分为硬件和软件定时器，软件定时器最终还是要依靠硬件定时器来完成。内核在时钟中断发生后检测各定时器是否到期，到期后的定时器处理函数将作为软中断在底半部执行。实质上，时钟中断处理程序执行update_process_timers函数，该函数调用run_local_timers函数，这个函数处理TIMER_SOFTIRQ软中断，运行当前处理上到期的所有定时器。
Linux内核中定义提供了一些用于操作定时器的数据结构和函数如下：
1)timer_list:说定时器，当然要来个定时器的结构体
struct timer_list{
struct list_head entry; //定时器列表
unsigned long expires; //定时器到期时间
void (*function)(unsigned long) ;//定时器处理函数
unsigned long data; //作为参数被传入定时器处理函数
struct timer_base_s *base;
}
2)初始化定时器：void init_timer(struct timer_list *timer);经过这个初始化后，entry的next为NULL,并给base赋值
3)增加定时器：void add_timer(struct timer_list *timer); 该函数用于注册内核定时器，并将定时器加入到内核动态定时器链表中。
4)删除定时器：int del_timer(struct timer_list *timer);
说明：del_timer_sync是del_timer的同步版，主要在多处理器系统中使用，如果编译内核时不支持SMP,del_timer_sync和del_timer等价.
5)修改定时器：int mod_timer(struct timer_list *timer, unsigned long expires);
下边是一个使用定时器的模版：
struct xxx_dev /*second设备结构体*/
{
struct cdev cdev; /*cdev结构体*/
...
struct timer_list xxx_timer; /*设备要使用的定时器*/
};
int xxx_func1(...) //xxx驱动中某函数
{
struct xxx_dev *dev = filp->private_data;
...
/*初始化定时器*/
init_timer(&dev->xxx_timer);
dev->xxx_timer.function = &xxx_do_handle;
dev->xxx_timer.data = (unsigned long)dev;
dev->xxx_timer.expires = jiffies + delay;
add_timer(&dev->xxx_timer); /*添加（注册）定时器*/
...
return 0;
}
int xxx_func2(...) //驱动中某函数
{
...
del_timer(&second_devp->s_timer);
...
}
static void xxx_do_timer(unsigned long arg) //定时器处理函数
{
struct xxx_device *dev = (struct xxx_device *)(arg);
...
//调度定时器再执行
dev->xxx_timer.expires = jiffies + delay;
add_timer(&dev->xxx_timer);
}
在定时器函数中往往会在做完具体工作后，延迟expires并将定时器再次添加到内核定时器链表中，以便定时器能被再次触发(这句话我也是从别处抄来的，别告诉小王哈)。
在内核定时器中，常常少不了要说下内核延迟的事，请接着往下看：
1）短延迟：在linux内核中提供了三个函数来分别实现纳秒，微秒，毫秒延迟,原理上是忙等待，它根据CPU频率进行一定次数的循环
void ndelay(unsigned long nsecs); void udelay(unsigned long usecs); void mdelay(unsigned long msecs);
毫秒延迟已经相当大了，当然更秒延迟当然要小一些，在内核中，为了性能，最好不要用mdelay，这会耗费大量cpu资源，那么咋办呢，凉拌…
void msleep(unsigned int millisecs); unsigned long msleep_interruptible(unsigned int millisecs); void ssleep(unsigned int seconds);
这三个是内核专门提供该我们用来处理毫秒以上的延迟。上述函数将使得调用它的进程睡眠参数指定的秒数，其中第二个是可以被打断的，其余的两个是不可以的。
2）长延迟:内核中进行延迟最常用的方法就是比较当前的jiffies和目标jiffies(当前的加上时间间隔的jiffies)，直到未来的jiffies达到目标jiffies。比如：
unsigned long delay = jiffies + 100; //延迟100个jiffies
while(time_before(jiffies, delay));
与time_before对应的还有一个time_after().其实就是#define time_before(a,b) time_after(b,a);
另外两个是time_after_eq(a,b)和time_before_eq(a,b)
3)睡着延迟：这显然是比忙等待好的方法，因为在未到来之前，进程会处于睡眠状态，把CPU空出来，让CPU可以做别的事情，等时间到了，调用schedule_timeout()就可以唤醒它并重新调度执行。msleep和msleep_interruptible本质上都是依靠包含了schedule_timeout的schedule_timeout_uninterruptible()和schedule_
timeout_interruptible()实现。就像下边这样：
void msleep(unsigned int msecs)
{
unsigned long timeout = msecs_to_jiffies(msecs) + 1;
while(timeout)
timeout = schedule_timeout_uninterruptible(timeout);
}
unsigned long msleep_interruptible(unsigned int msecs)
{
unsigned long timeout = msecs_to_jiffies(msecs) + 1;
while(timeout && !signal_pending(current))
timeout = schedule_timeout_interruptible(timeout);
return jiffies_to_msecs(timeout);
}
signed long __sched schedule_timeout_interruptible()signed long timeout)
{
__set_current_state(TASK_INTERRUPTIBLE);
return schedule_timeout(timeout);
}
signed long __sched schedule_timeout_uninterruptible()signed long timeout)
{
__set_current_state(TASK_UNINTERRUPTIBLE);
return schedule_timeout(timeout);
}
另外还有如下：
time_on_timeout(wait_queue_head_t *q, unsigned long timeout);
interruptible_sleep_on_timeout(wait_queue_head_t *q, unsigned long timeout);
这两个将当前进程添加到等待队列，从而在等待队列上睡眠，当超时发生时，进程将被唤醒。
侵删
转载参考：https://www.cnblogs.com/hanyan225/archive/2010/10/24/1859796.html