linux驱动异步通知,linux驱动编程--异步通知与异步I/O

In a general way, there are two methods for process control: synchronizationand asynchronization.

synchronization  is involves block(阻塞) , no-block(轮询) ( poll ). it just like anti-asynchronization.

asynchronization is include signal(信号) and asynchronization I/O( 异步I/O). the kernel is do as they arrived.(随到随做). 信号和异步通知的有一些实现上的不同。

信号的逻辑模型是：进程做自己的事->信号来了，跳过去执行信号处理函数->跳回来继续执行；

异步I/O的逻辑模型是：进程做自己的事->抛出一个I/O请求->继续做自己的事->要用到数据了，再去查询别人是不是已经把I/O请求->继续做事

Asynchronous  notification (异步通知)

@signal for software is equal to @interrupt for hardware.(信号是软件上对于中断的模拟)

service mode is based on the fellowing theory: one signal is corressponds to a slot-function. just like the interrupt do.(相当于中断)

//应用层

fcntl( STDIN_FILENO, F_SETOWN, getpid()); //设置文件的拥有者。在驱动发送的信号会传输给拥有者

oflag = fcntl( STDIN_FILENO, FGETFL);

fcntl( STDIN_FILENO, FSETFL, oflag|FASYNC); //设置异步通知

signal( SIGIO, handler); //设置信号处理函数，一个萝卜一个坑

//驱动层

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

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

the most important thing is what @fasync_helper()and @kill_saync()do. @fasync_helper()will add those information, from upper layer, to a list. @kill_fasync()will check the list and send signal. The fellowing is the reason that i suppose.

/*

* fasync_helper() is used by almost all character device drivers

* to set up the fasync queue. It returns negative on error, 0 if it did

* no changes and positive if it added/deleted the entry.

*/

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

{

struct fasync_struct *fa, **fp;

struct fasync_struct *new = NULL;

int result = 0;

if (on) {

new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);

if (!new)

return -ENOMEM;

}

/*

* We need to take f_lock first since it's not an IRQ-safe

* lock.

*/

spin_lock(&filp->f_lock);

write_lock_irq(&fasync_lock);

for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {//检查异步链表是否该文件对应的信息已经存在

if (fa->fa_file == filp) {//假如该file已经被添加过了

if(on) {

fa->fa_fd = fd;

kmem_cache_free(fasync_cache, new);

} else {

*fp = fa->fa_next;

kmem_cache_free(fasync_cache, fa);

result = 1;

}

goto out;

}

}

//假如不存在就添加进去

if (on) {

new->magic = FASYNC_MAGIC;

new->fa_file = filp;

new->fa_fd = fd;

new->fa_next = *fapp;

*fapp = new;

result = 1;

}out:

if (on)

filp->f_flags |= FASYNC;

else

filp->f_flags &= ~FASYNC;

write_unlock_irq(&fasync_lock);

spin_unlock(&filp->f_lock);

return result;

}

the blue code is try to add information to the list. the next one is @kill_fasync().

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

/*

fp--异步对象链表

sig--通知的信号类型

band--POLL_IN, POLL_OUT

*/

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

{

/* First a quick test without locking: usually

* the list is empty.

*/

if (*fp) {

read_lock(&fasync_lock);

/* reread *fp after obtaining the lock */

__kill_fasync(*fp, sig, band);

read_unlock(&fasync_lock);

}

}

void __kill_fasync(struct fasync_struct *fa, int sig, int band)

{

while (fa) {//会通知所有的注册进程

struct fown_struct * fown;

if (fa->magic != FASYNC_MAGIC) {

printk(KERN_ERR "kill_fasync: bad magic number in "

"fasync_struct!\n");

return;

}

fown = &fa->fa_file->f_owner;//找到文件拥有者的进程ID

/* Don't send SIGURG to processes which have not set a

queued signum: SIGURG has its own default signalling

mechanism. */

if (!(sig == SIGURG && fown->signum == 0))

send_sigio(fown, fa->fa_fd, band);//fa_fd为文件描述符

fa = fa->fa_next;

}}

check those blue code, it is sending signal to some process.

Asynchronous I/O (异步I/O)

//添加I/O请求

aio_read();

aio_write();         //I/O请求执行结果

aio_error(); //查询

aio_return(); //获取

aio_suspend();//阻塞直到请求完成

aio_cancel();         //批量管理I/O请求

lio_listio();

(没找到源码，且使用较少，暂时放弃分析)