linux驱动编程--异步通知与异步I/O
In a general way, there are two methods for process control: synchronization and 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();
(没找到源码，且使用较少，暂时放弃分析)