一、异步通知机制简介
异步通知机制的意思：一旦设备准备就绪，可以主动的通知应用程序进行相应的操作，从而使得应用程序不必去查询设备的状态。
异步通知比较准确的称谓是"信号驱动的异步IO"，因此其实现也是通过发送、接收信号的方式。
1.1 信号接收：
// 信号接收函数原型
void (*signal(int signum,void (*handler)(int)))(int); // 函数名：signal
// 函数参数：int signum
// void (*handler)(int)
typedef void(*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler);
第一个参数指定信号的值， 第二个参数指定信号的处理函数。若第二个参数为SIG_IGN，表示对该信号忽略（有两个信号不能被忽略SIGSTOP和SIGKILL）
若第二个参数为SIG_DEF，表示进程接收到该信号后执行默认的处理函数、
在信号接收端即应用程序中需要完成的工作：
（1）设置设备文件的拥有者为本进程，这样从设备发出的信号才能被本进程接收到
（2）设置设备文件支持fasync，即异步通知模式
（3）通过signal函数连接信号和信号处理函数
1.2 信号发送：
在设备驱动与应用程序的异步通知交互中，由设备驱动释放信号，因此需要在设备驱动中需要明确：将信号发给哪一个进程，如何发送信号到应用程序。
因此在驱动程序中涉及到3项工作：
（1）设置filp->f_owner为对应进程ID ，以支持应用程序中的工作1
（2）调用驱动程序中的fasync()函数，以支持应用程序中的工作2
（3）当设备资源可以获得的时候，调用kill_fasync()函数发出相应的信号
二、应用程序
int fd;
void my_fun(int signum) // 信号处理函数
{
int press_cnt[];
int i;
printf("my_fun\n");
read(fd, press_cnt, sizeof(press_cnt));
for (i = ; i < sizeof(press_cnt)/sizeof(press_cnt[]); i++)
{
if (press_cnt[i])
printf("K%d has been pressed %d times!\n", i+, press_cnt[i]);
}
}
int main(int argc, char **argv)
{
int flags;
signal(SIGIO, my_fun); // 注册信号处理函数
fd = open("/dev/tiny6410_button", O_RDWR);
if (fd < )
{
printf("Can't open /dev/buttons\n");
return -;
}
else
printf("tiny6410_button open successfully!\n"); fcntl(fd, F_SETOWN, getpid()); // 设置设备文件的拥有者为本进程
flags = fcntl(fd, F_GETFL); // 读取设备文件的标志符
fcntl(fd, F_SETFL, flags|FASYNC); // 设置设备文件的标志符使设备文件支持异步通知模式 while () {
sleep();
}
close(fd);
return ;
}
三、驱动程序
static struct fasync_struct* button_async; // 定义异步驱动结构体 static irqreturn_t buttons_interrupt(int irq, void *dev_id)
{
......
kill_fasync(&button_async, SIGIO, POLL_IN); // 当有中断发生的时候会发送SIGIO信号到应用程序
......
} int tiny6410_button_fasync (int fd, struct file *file, int on)
{
return fasync_helper(fd, file, on, &button_async); //
} static struct file_operations tiny6410_button_fops = {
......
.fasync = tiny6410_button_fasync,
......
};
四、fcntl(...)函数的系统调用过程
SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
do_fcntl(fd, cmd, arg, filp);
static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
struct file *filp)
{
long err = -EINVAL; switch (cmd) {
......
case F_GETFL: // 得到设置的文件标志flag
err = filp->f_flags; // flags = fcntl(fd, F_GETFL）
break;
case F_SETFL: // 设置文件标志flag
err = setfl(fd, filp, arg); // fcntl(fd, F_SETFL, flags|FASYNC);--->setfl(fd, filp, flags|FASYNC)
break;
case F_SETOWN: // 设置将接收SIGIO和SIGURG信号的进程id或者进程组ID，进程组ID通过提供提供一个负值的arg来说明arg的绝对值是一个进程组id,负责arg被认为是进程id
err = f_setown(filp, arg, ); // fcntl(fd, F_SETOWN, getpid());--->f-setown(filp, pid, 1)
break;
......
default:
break;
}
return err;
}
4.1 f_setown函数
int f_setown(struct file *filp, unsigned long arg, int force)
{
enum pid_type type;
struct pid *pid;
int who = arg;
int result;
type = PIDTYPE_PID;
if (who < ) { // arg < 0 说明传来的 |arg|为组ID
type = PIDTYPE_PGID; // arg > 0 说明传来的arg为进程ID
who = -who;
}
rcu_read_lock();
pid = find_vpid(who); //根据传来的arg(pid),找到pid结构体
result = __f_setown(filp, pid, type, force); // 根据应用程序的pid结构体、pid的类型、force 的值（force=1），来设置该文件所属的pid
rcu_read_unlock();
return result;
}
在f_setown函数中，先根据传入的pid的值找到pid结构体。这里边区分了进程ID还是进程组ID，如过传来的是进程ID，那么arg>0 ，进程ID为arg， pid类型为 PIDTYPE_PID
如果传来的是进程组ID，那么arg<0，进程组ID为|arg|，pid类型为 PIDTYPE_PGID
其次，执行__f_setown，来设置filp->f_owner下边有关pid的参数
4.2 setfl(...)函数
static int setfl(int fd, struct file * filp, unsigned long arg)
{
struct inode * inode = filp->f_path.dentry->d_inode;
int error = ;
......
if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&
filp->f_op->fasync) {
error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != ); //当FASYNC位有变化时会执行到这里，并且当filp->f_op->fasync为真时，会调用到驱动程序的fasync函数
if (error < ) // 在本例程中就会调用到 tiny6410_button_fasync(...)函数调用fasync_helper(...) 函数
goto out; // --->tiny6410_button_fasync(fd, filp, 1) 开启fasync
if (error > ) // --->fasync_helper(fd, filp, 1, &button_async)
error = ;
}
spin_lock(&filp->f_lock);
filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
spin_unlock(&filp->f_lock);
out:
return error;
}
可以看到用户程序调用fcntl(fd, F_SETFL, flags|FASYNC)，当fasync位有变化时，会调用驱动程序的fasync函数，从而调用fasync_helper(...)函数
五、fasync_helper(...)函数
int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
{
if (!on)
return fasync_remove_entry(filp, fapp);
return fasync_add_entry(fd, filp, fapp);// fasync_add_entry(fd, filp, &button_async
} static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
{
struct fasync_struct *new;
new = fasync_alloc();
if (!new)
return -ENOMEM; if (fasync_insert_entry(fd, filp, fapp, new)) {
fasync_free(new);
return ;
} return ;
} // fd文件描述符 filp文件描述结构体指针 fapp:fasync机构体的二级指针 new：新分配的fasync结构体的指针
struct fasync_struct *fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp, struct fasync_struct *new)
{
struct fasync_struct *fa, **fp;
spin_lock(&filp->f_lock);
spin_lock(&fasync_lock);
for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) { //这里fp = fapp fa = *fp = null 因为定义的struct fasync_struct * button_fasync = NULL
if (fa->fa_file != filp) //故for循环中的内容是不会执行的
continue; spin_lock_irq(&fa->fa_lock);
fa->fa_fd = fd;
spin_unlock_irq(&fa->fa_lock);
goto out;
} spin_lock_init(&new->fa_lock);
new->magic = FASYNC_MAGIC; // 这里给新分配的fasync_struct 结构体赋值
new->fa_file = filp;
new->fa_fd = fd;
new->fa_next = *fapp;
rcu_assign_pointer(*fapp, new);
filp->f_flags |= FASYNC; out:
spin_unlock(&fasync_lock);
spin_unlock(&filp->f_lock);
return fa;
}