linux异步IO通知

Linux 应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备，通过阻塞方式访问的话应用程序会处于休眠态，等待驱动设备可以使用，非阻塞方式的话会通过 poll 函数来不断的轮询，查看驱动设备文件是否可以使用。这两种方式都需要应用程序主动的去查询设备的使用情况。“信号”却可以使内核主动通知应用程序，信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉给应用程序的。
阻塞、非阻塞、异步通知，这三种是针对不同的场合提出来的不同的解决方法，可以根据自己的实际需求选择合适的处理方法。
异步通知的核心就是信号，在 arch/xtensa/include/uapi/asm/signal.h 文件中定义了 Linux 所支持的所有信号，这些信号如下所示：

#define SIGHUP 1 /* 终端挂起或控制进程终止 */
#define SIGINT 2 /* 终端中断(Ctrl+C 组合键) */
#define SIGQUIT 3 /* 终端退出(Ctrl+\组合键) */
#define SIGILL 4 /* 非法指令 */
#define SIGTRAP 5 /* debug 使用，有断点指令产生 */
#define SIGABRT 6 /* 由 abort(3)发出的退出指令 */
#define SIGIOT 6 /* IOT 指令 */
#define SIGBUS 7 /* 总线错误 */
#define SIGFPE 8 /* 浮点运算错误 */
#define SIGKILL 9 /* 杀死、终止进程 */
#define SIGUSR1 10 /* 用户自定义信号 1 */
#define SIGSEGV 11 /* 段违例(无效的内存段) */
#define SIGUSR2 12 /* 用户自定义信号 2 */
#define SIGPIPE 13 /* 向非读管道写入数据 */
#define SIGALRM 14 /* 闹钟 */
#define SIGTERM 15 /* 软件终止 */
#define SIGSTKFLT 16 /* 栈异常 */
#define SIGCHLD 17 /* 子进程结束 */
#define SIGCONT 18 /* 进程继续 */
#define SIGSTOP 19 /* 停止进程的执行，只是暂停 */
#define SIGTSTP 20 /* 停止进程的运行(Ctrl+Z 组合键) */
#define SIGTTIN 21 /* 后台进程需要从终端读取数据 */
#define SIGTTOU 22 /* 后台进程需要向终端写数据 */
#define SIGURG 23 /* 有"紧急"数据 */
#define SIGXCPU 24 /* 超过 CPU 资源限制 */
#define SIGXFSZ 25 /* 文件大小超额 */
#define SIGVTALRM 26 /* 虚拟时钟信号 */
#define SIGPROF 27 /* 时钟信号描述 */
#define SIGWINCH 28 /* 窗口大小改变 */
#define SIGIO 29 /* 可以进行输入/输出操作 */
#define SIGPOLL SIGIO /* #define SIGLOS 29 */
#define SIGPWR 30 /* 断点重启 */
#define SIGSYS 31 /* 非法的系统调用 */
#define SIGUNUSED 31 /* 未使用信号 */

在这些信号中，除了 SIGKILL(9)和 SIGSTOP(19)这两个信号不能被忽略外，其他的信号都可以忽略。这些信号就相当于中断号，不同的中断号代表了不同的中断，不同的中断所做的处理不同，因此，驱动程序可以通过向应用程序发送不同的信号来实现不同的功能。

一、应用层

1.1、使用异步 I/O步骤

异步 I/O 通常也称为信号驱动 I/O。要使用异步 I/O，程序需要按照如下步骤来执行：
（1）、通过指定 O_NONBLOCK 标志使能非阻塞 I/O。
（2）、通过指定 O_ASYNC 标志使能异步 I/O。
（3）、设置异步 I/O 事件的接收进程。也就是当文件描述符上可执行 I/O 操作时会发送信号通知该进程，通常将调用进程设置为异步 I/O 事件的接收进程。
（4）、为内核发送的通知信号注册一个信号处理函数。默认情况下，异步 I/O 的通知信号是 SIGIO，所以内核会给进程发送信号 SIGIO。
（5）、以上步骤完成之后，进程就可以执行其它任务了，当 I/O 操作就绪时，内核会向进程发送一个 SIGIO信号，当进程接收到信号时，会执行预先注册好的信号处理函数，我们就可以在信号处理函数中进行 I/O 操作。

1.1.1、O_ASYNC 标志

O_ASYNC 标志可用于使能文件描述符的异步 I/O 事件，当文件描述符可执行 I/O 操作时，内核会向异步 I/O 事件的接收进程发送 SIGIO 信号（默认情况下）。
需要注意的是：在调用 open()时无法通过指定 O_ASYNC 标志来使能异步 I/O，但可以使用 fcntl()函数添加 O_ASYNC 标志使能异步 I/O，譬如：

int flag;
flag = fcntl(0, F_GETFL); //先获取原来的 flag
flag |= O_ASYNC; //将 O_ASYNC 标志添加到 flag
fcntl(fd, F_SETFL, flag); //重新设置 flag

1.1.2、设置异步 I/O 事件的接收进程

为文件描述符设置异步 I/O 事件的接收进程，也就是设置异步 I/O 的所有者。同样也是通过 fcntl()函数进行设置，操作命令 cmd 设置为 F_SETOWN，第三个参数传入接收进程的进程 ID（PID），通常将调用进程的 PID 传入，譬如：

fcntl(fd, F_SETOWN, getpid());

1.1.3、注册 SIGIO 信号的处理函数

通过 signal()或 sigaction()函数为 SIGIO 信号注册一个信号处理函数，当进程接收到内核发送过来的SIGIO 信号时，会执行该处理函数，所以我们应该在处理函数当中执行相应的 I/O 操作。

1.1.4、示例

以异步 I/O 方式读取鼠标，当进程接收到 SIGIO 信号时，执行信号处理函数sigio_handler()，在该函数中调用 read()读取鼠标数据。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#define MOUSE "/dev/input/event3"
static int fd;
static void sigio_handler(int sig)
{static int loops = 5;char buf[100] = {0};int ret;if(SIGIO != sig)return;ret = read(fd, buf, sizeof(buf));if (0 < ret)printf("鼠标: 成功读取<%d>个字节数据\n", ret);loops--;if (0 >= loops) {close(fd);exit(0);}
}
int main(void)
{int flag;/* 打开鼠标设备文件<使能非阻塞 I/O> */fd = open(MOUSE, O_RDONLY | O_NONBLOCK);if (-1 == fd) {perror("open error");exit(-1);}/* 使能异步 I/O */flag = fcntl(fd, F_GETFL);flag |= O_ASYNC;fcntl(fd, F_SETFL, flag);/* 设置异步 I/O 的所有者 */fcntl(fd, F_SETOWN, getpid());/* 为 SIGIO 信号注册信号处理函数 */signal(SIGIO, sigio_handler);for ( ; ; )sleep(1);
}

1.2、异步 I/O的优化

上一小节所讲述的异步 I/O 存在着一些缺陷，如下所示：
1、默认的异步 I/O 通知信号 SIGIO 是非排队信号。SIGIO 信号是标准信号（非实时信号、不可靠信号），所以它不支持信号排队机制，譬如当前正在执行 SIGIO 信号的处理函数，此时内核又发送多次 SIGIO 信号给进程，这些信号将会被阻塞，只有当信号处理函数执行完毕之后才会传递给进程，并且只能传递一次，而其它后续的信号都会丢失。
2、无法得知文件描述符发生了什么事件。
所以，可以针对以上两个缺陷进行优化。

1.2.1、使用实时信号替换默认信号 SIGIO

SIGIO 作为异步 I/O 通知的默认信号，是一个非实时信号，我们可以设置不使用默认信号，指定一个实时信号作为异步 I/O 通知信号，如何指定呢？同样也是使用 fcntl()函数进行设置，调用函数时将操作命令cmd 参数设置为 F_SETSIG，第三个参数 arg 指定一个实时信号编号即可，表示将该信号作为异步 I/O 通知信号，譬如：

fcntl(fd, F_SETSIG, SIGRTMIN);

上述代码指定了 SIGRTMIN 实时信号作为文件描述符 fd 的异步 I/O 通知信号，而不再使用默认的 SIGIO信号。当文件描述符 fd 可执行 I/O 操作时，内核会发送实时信号 SIGRTMIN 给调用进程。如果第三个参数 arg 设置为 0，则表示指定 SIGIO 信号作为异步 I/O 通知信号，也就是回到了默认状态。

1.2.2、使用 sigaction()函数注册信号处理函数

在应用程序当中需要为实时信号注册信号处理函数，使用 sigaction 函数进行注册，并为 sa_flags 参数指定 SA_SIGINFO，表示使用 sa_sigaction 指向的函数作为信号处理函数，而不使用 sa_handler 指向的函数。因为 sa_sigaction 指向的函数作为信号处理函数提供了更多的参数，可以获取到更多信息

二、驱动层

2.1、驱动中的信号处理

2.1.1、fasync_struct 结构体

首先我们需要在驱动程序中定义一个 fasync_struct 结构体指针变量，fasync_struct 结构体内容如下：

struct fasync_struct {spinlock_t fa_lock;int magic;int fa_fd;struct fasync_struct *fa_next;struct file *fa_file;struct rcu_head fa_rcu;
};

一般将 fasync_struct 结构体指针变量定义到设备结构体中，

2.1.2、fasync 函数

如果要使用异步通知，需要在设备驱动中实现 file_operations 操作集中的 fasync 函数，此函数格式如下所示：

int (*fasync) (int fd, struct file *filp, int on)

fasync 函数里面一般通过调用 fasync_helper 函数来初始化前面定义的 fasync_struct 结构体指针，fasync_helper 函数原型如下：

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)

fasync_helper 函数的前三个参数就是 fasync 函数的那三个参数，第四个参数就是要初始化的 fasync_struct 结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync 标记的时候，驱动程序 file_operations 操作集中的 fasync 函数就会执行。
驱动程序中的 fasync 函数参考示例如下：

struct xxx_dev
{struct fasync_struct *async_queue; /* 异步相关结构体 */
};static int xxx_fasync(int fd, struct file *filp, int on)
{struct xxx_dev *dev = (xxx_dev)filp->private_data;if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)return -EIO;return 0;
}static struct file_operations xxx_ops = {.......fasync = xxx_fasync,......
};

在关闭驱动文件的时候需要在 file_operations 操作集中的 release 函数中释放 fasync_struct，fasync_struct 的释放函数同样为 fasync_helper，release 函数参数参考实例如下：

static int xxx_release(struct inode *inode, struct file *filp)
{return xxx_fasync(-1, filp, 0); /* 删除异步通知 */
}
static struct file_operations xxx_ops ={.......release = xxx_release,
};

第 3 行通过调用上面代码中的 xxx_fasync 函数来完成 fasync_struct 的释放工作，
但是，其最终还是通过 fasync_helper 函数完成释放工作。

2.1.3、kill_fasync 函数

当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断”。kill_fasync函数负责发送指定的信号，kill_fasync 函数原型如下所示：

void kill_fasync(struct fasync_struct **fp, int sig, int band)

函数参数和返回值含义如下：
fp：要操作的 fasync_struct。
sig：要发送的信号。
band：可读时设置为 POLL_IN，可写时设置为 POLL_OUT。
返回值：无。

2.1.4、应用程序对异步通知的处理

应用程序对异步通知的处理包括以下三步：
1、注册信号处理函数
应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用 signal 函数来设置信号的处理函数。
2、将本应用程序的进程号告诉给内核
使用 fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核。
3、开启异步通知
使用如下两行程序开启异步通知：

flags = fcntl(fd, F_GETFL); /* 获取当前的进程状态 */
fcntl(fd, F_SETFL, flags | FASYNC); /* 开启当前进程异步通知功能 */

重点就是通过 fcntl 函数设置进程状态为 FASYNC，经过这一步，驱动程序中的 fasync 函数就会执行。

2.2、示例

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <linux/fcntl.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>#define IMX6UIRQ_CNT       1           /* 设备号个数    */
#define IMX6UIRQ_NAME       "asyncnoti"   /* 名字       */
#define KEY0VALUE           0X01        /* KEY0按键值  */
#define INVAKEY             0XFF        /* 无效的按键值 */
#define KEY_NUM             1           /* 按键数量     *//* 中断IO描述结构体 */
struct irq_keydesc {int gpio;                               /* gpio */int irqnum;                               /* 中断号     */unsigned char value;                   /* 按键对应的键值 */char name[10];                         /* 名字 */irqreturn_t (*handler)(int, void *);    /* 中断服务函数 */
};/* imx6uirq设备结构体 */
struct imx6uirq_dev{dev_t devid;            /* 设备号   */ struct cdev cdev;       /* cdev     */                 struct class *class; /* 类        */struct device *device;    /* 设备    */int major;               /* 主设备号   */int minor;              /* 次设备号   */struct device_node  *nd; /* 设备节点 */ atomic_t keyvalue;      /* 有效的按键键值 */atomic_t releasekey;   /* 标记是否完成一次完成的按键，包括按下和释放 */struct timer_list timer;/* 定义一个定时器*/struct irq_keydesc irqkeydesc[KEY_NUM];   /* 按键init述数组 */unsigned char curkeynum;             /* 当前init按键号 */wait_queue_head_t r_wait;                /* 读等待队列头 */struct fasync_struct *async_queue;      /* 异步相关结构体 */
};struct imx6uirq_dev imx6uirq; /* irq设备 *//* @description     : 中断服务函数，开启定时器       *                     定时器用于按键消抖。* @param - irq     : 中断号 * @param - dev_id    : 设备结构。* @return           : 中断执行结果*/
static irqreturn_t key0_handler(int irq, void *dev_id)
{struct imx6uirq_dev *dev = (struct imx6uirq_dev*)dev_id;dev->curkeynum = 0;dev->timer.data = (volatile long)dev_id;mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));    /* 10ms定时 */return IRQ_RETVAL(IRQ_HANDLED);
}/* @description   : 定时器服务函数，用于按键消抖，定时器到了以后*               再次读取按键值，如果按键还是处于按下状态就表示按键有效。* @param - arg    : 设备结构变量* @return      : 无*/
void timer_function(unsigned long arg)
{unsigned char value;unsigned char num;struct irq_keydesc *keydesc;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;num = dev->curkeynum;keydesc = &dev->irqkeydesc[num];value = gpio_get_value(keydesc->gpio);   /* 读取IO值 */if(value == 0){                        /* 按下按键 */atomic_set(&dev->keyvalue, keydesc->value);}else{                                   /* 按键松开 */atomic_set(&dev->keyvalue, 0x80 | keydesc->value);atomic_set(&dev->releasekey, 1);   /* 标记松开按键，即完成一次完整的按键过程 */}               if(atomic_read(&dev->releasekey)) {      /* 一次完整的按键过程 */if(dev->async_queue)kill_fasync(&dev->async_queue, SIGIO, POLL_IN);    /* 释放SIGIO信号 */}#if 0/* 唤醒进程 */if(atomic_read(&dev->releasekey)) {   /* 完成一次按键过程 *//* wake_up(&dev->r_wait); */wake_up_interruptible(&dev->r_wait);}
#endif
}/** @description  : 按键IO初始化* @param      : 无* @return       : 无*/
static int keyio_init(void)
{unsigned char i = 0;char name[10];int ret = 0;imx6uirq.nd = of_find_node_by_path("/key");if (imx6uirq.nd== NULL){printk("key node not find!\r\n");return -EINVAL;} /* 提取GPIO */for (i = 0; i < KEY_NUM; i++) {imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd ,"key-gpio", i);if (imx6uirq.irqkeydesc[i].gpio < 0) {printk("can't get key%d\r\n", i);}}/* 初始化key所使用的IO，并且设置成中断模式 */for (i = 0; i < KEY_NUM; i++) {memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(name));   /* 缓冲区清零 */sprintf(imx6uirq.irqkeydesc[i].name, "KEY%d", i);      /* 组合名字 */gpio_request(imx6uirq.irqkeydesc[i].gpio, name);gpio_direction_input(imx6uirq.irqkeydesc[i].gpio);    imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd, i);
#if 0imx6uirq.irqkeydesc[i].irqnum = gpio_to_irq(imx6uirq.irqkeydesc[i].gpio);
#endif}/* 申请中断 */imx6uirq.irqkeydesc[0].handler = key0_handler;imx6uirq.irqkeydesc[0].value = KEY0VALUE;for (i = 0; i < KEY_NUM; i++) {ret = request_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq.irqkeydesc[i].handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, imx6uirq.irqkeydesc[i].name, &imx6uirq);if(ret < 0){printk("irq %d request failed!\r\n", imx6uirq.irqkeydesc[i].irqnum);return -EFAULT;}}/* 创建定时器 */init_timer(&imx6uirq.timer);imx6uirq.timer.function = timer_function;/* 初始化等待队列头 */init_waitqueue_head(&imx6uirq.r_wait);return 0;
}/** @description      : 打开设备* @param - inode     : 传递给驱动的inode* @param - filp   : 设备文件，file结构体有个叫做private_data的成员变量*                       一般在open的时候将private_data指向设备结构体。* @return             : 0 成功;其他 失败*/
static int imx6uirq_open(struct inode *inode, struct file *filp)
{filp->private_data = &imx6uirq;    /* 设置私有数据 */return 0;
}/** @description     : 从设备读取数据 * @param - filp    : 要打开的设备文件(文件描述符)* @param - buf     : 返回给用户空间的数据缓冲区* @param - cnt     : 要读取的数据长度* @param - offt    : 相对于文件首地址的偏移* @return          : 读取的字节数，如果为负值，表示读取失败*/
static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{int ret = 0;unsigned char keyvalue = 0;unsigned char releasekey = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;if (filp->f_flags & O_NONBLOCK) { /* 非阻塞访问 */if(atomic_read(&dev->releasekey) == 0)    /* 没有按键按下，返回-EAGAIN */return -EAGAIN;} else {                            /* 阻塞访问 *//* 加入等待队列，等待被唤醒,也就是有按键按下 */ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); if (ret) {goto wait_error;}}keyvalue = atomic_read(&dev->keyvalue);releasekey = atomic_read(&dev->releasekey);if (releasekey) { /* 有按键按下 */  if (keyvalue & 0x80) {keyvalue &= ~0x80;ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));} else {goto data_error;}atomic_set(&dev->releasekey, 0);/* 按下标志清零 */} else {goto data_error;}return 0;wait_error:return ret;
data_error:return -EINVAL;
}/** @description     : poll函数，用于处理非阻塞访问* @param - filp    : 要打开的设备文件(文件描述符)* @param - wait    : 等待列表(poll_table)* @return          : 设备或者资源状态，*/
unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct *wait)
{unsigned int mask = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;poll_wait(filp, &dev->r_wait, wait);    /* 将等待队列头添加到poll_table中 */if(atomic_read(&dev->releasekey)) {        /* 按键按下 */mask = POLLIN | POLLRDNORM;          /* 返回PLLIN */}return mask;
}/** @description     : fasync函数，用于处理异步通知* @param - fd     : 文件描述符* @param - filp    : 要打开的设备文件(文件描述符)* @param - on      : 模式* @return          : 负数表示函数执行失败*/
static int imx6uirq_fasync(int fd, struct file *filp, int on)
{struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;return fasync_helper(fd, filp, on, &dev->async_queue);
}/** @description     : release函数，应用程序调用close关闭驱动文件的时候会执行* @param - inode  : inode节点* @param - filp    : 要打开的设备文件(文件描述符)* @return          : 负数表示函数执行失败*/
static int imx6uirq_release(struct inode *inode, struct file *filp)
{return imx6uirq_fasync(-1, filp, 0);
}/* 设备操作函数 */
static struct file_operations imx6uirq_fops = {.owner = THIS_MODULE,.open = imx6uirq_open,.read = imx6uirq_read,.poll = imx6uirq_poll,.fasync = imx6uirq_fasync,.release = imx6uirq_release,
};/** @description : 驱动入口函数* @param       : 无* @return       : 无*/
static int __init imx6uirq_init(void)
{/* 1、构建设备号 */if (imx6uirq.major) {imx6uirq.devid = MKDEV(imx6uirq.major, 0);register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);} else {alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);imx6uirq.major = MAJOR(imx6uirq.devid);imx6uirq.minor = MINOR(imx6uirq.devid);}/* 2、注册字符设备 */cdev_init(&imx6uirq.cdev, &imx6uirq_fops);cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);/* 3、创建类 */imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.class)) {  return PTR_ERR(imx6uirq.class);}/* 4、创建设备 */imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.device)) {return PTR_ERR(imx6uirq.device);}/* 5、始化按键 */atomic_set(&imx6uirq.keyvalue, INVAKEY);atomic_set(&imx6uirq.releasekey, 0);keyio_init();return 0;
}/** @description  : 驱动出口函数* @param       : 无* @return       : 无*/
static void __exit imx6uirq_exit(void)
{unsigned i = 0;/* 删除定时器 */del_timer_sync(&imx6uirq.timer);    /* 删除定时器 *//* 释放中断 */   for (i = 0; i < KEY_NUM; i++) {free_irq(imx6uirq.irqkeydesc[i].irqnum, &imx6uirq);}cdev_del(&imx6uirq.cdev);unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);device_destroy(imx6uirq.class, imx6uirq.devid);class_destroy(imx6uirq.class);
}   module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");