Linux之異步通知機制分析

1.概念:

異步通知機制：一旦設備就緒，則主動通知應用程序，這樣應用程序根本就不需要查詢設備狀態，是一種“信號驅動的異步I/O”。信號是在軟件層次上對中斷機制的一種模擬，在原理上，一個進程收到一個信號與處理器收到一個中斷請求可以說是一樣的。信號是異步的，一個進程不必通過任何操作來等待信號的到達，事實上，進程也不知道信號到底什么時候會到達。

2.我們試圖通過兩個方面來分析異步通知機制：

從用戶程序的角度考慮：為了啟動文件的異步通知機制，用戶程序必須執行兩個步驟。首先，他們指定一個進程作為文件的“屬主（owner）”。當進程使用fcntl系統調用執行

F_SETOWN命令時，屬主進程的進程ID號就被保存在filp->f_owner中。這一步是必需的，目的是為了讓內核知道應該通知哪個進程。 然后為了真正啟動異步通知機制，用戶程序還必須

在設備中設置FASYNC標志，這通過fcntl的F_SETFL命令完成的。 執行完這兩個步驟之后，輸入文件就可以在新數據到達時請求發送一個SIGIO信號。該信號被發送到存放在filp-

>f_owner中的進程（如果是負值就是進程組）。

在用戶程序中，為了捕獲信號，可以使用signal()函數來設置對應信號的處理函數：

void (*signal(int signum, void (*handler))(int)))(int);

該函數原型較難理解， 它可以分解為：

typedef void (*sighandler_t)(int);                        //消息處理函數
sighandler_t signal(int signum, sighandler_t handler));   //連接信號與消息處理函數

第一個參數指定信號的值，第二個參數指定針對前面信號值的處理函數，若為SIG_IGN，表示忽略該信號；若為SIG_DFL，表示采用系統默認方式處理信號；若為用戶自定義的函

數，則信號被捕獲到后，該函數將被執行。如果signal()調用成功，它返回最后一次為信號signum綁定的處理函數的handler值，失敗則返回SIG_ERR。

fcntl(STDIN_FILENO, F_SETOWN, getpid()); //設置本進程為STDIN_FILENO文件的擁有者，沒有這一步，內核不會知道應該將信號發給哪個進程
oflags = fcntl(STDIN_FILENO, F_GETFL);   //獲取設備文件的f_flags
fcntl(STDIN_FILENO, F_SETFL, oflags | FASYNC); //為了啟用異步通知機制，還需對設備設置FASYNC標志

我們先通過內核源碼，剖析上面的實現原理。

app:fcntl()
kernel:sys_fcntl()
            do_fcntl()
                 switch (cmd) {
                 ……
                 case F_GETFL:
                     err = filp->f_flags;　　　　　　//返回文件標志
                     break;　　
                 case F_SETFL:
                     err = setfl(fd, filp, arg);　　 //轉調用setfl函數
                     break;
                 ……
                 case F_SETOWN:
                     err = f_setown(filp, arg, 1);　 //轉調用f_setown函數
                     break;
                 ……
                 default:
                     break;
                 }
                 return err;

//來看看f_setown函數的內部實現：設置文件的屬主進程

int f_setown(struct file *filp, unsigned long arg, int force)
{
...
    pid = find_pid(who);                           //獲取當前進程的pid
    result = __f_setown(filp, pid, type, force);   //內部主要調用f_modown函數
...
}
static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,uid_t uid, uid_t euid, int force)
{
...
    if (force || !filp->f_owner.pid) { //設置對應的pid，uid，euid
        put_pid(filp->f_owner.pid);
        filp->f_owner.pid = get_pid(pid);
        filp->f_owner.pid_type = type;
        filp->f_owner.uid = uid;
        filp->f_owner.euid = euid;
    }
...
}

//再來看看setfl函數的內部實現：

static int setfl(int fd, struct file * filp, unsigned long arg)
{
...
    if ((arg ^ filp->f_flags) & FASYNC) {   //也就是說FASYNC標志從0變為1的時候，才為真。
        if (filp->f_op && filp->f_op->fasync) {
            error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0); //調用的就是驅動程序的fasync()函數
            if (error < 0)
                goto out;
        }
    }
...
}

從驅動程序角度考慮：

應用程序在執行F_SETFL啟用FASYNC時，調用驅動程序的fasync方法。只要filp->f_flags中的FASYNC標識發生了變化，就會調用該方法，以便把這個變化通知驅動程序，使其能

正確響應。文件打開時，FASYNC標志被默認為是清除的。當數據到達時，所有注冊為異步通知的進程都會被發送一個SIGIO信號。

Linux的這種通用方法基於一個數據結構和兩個函數：

extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
//當一個打開的文件的FASYNC標志被修改時，調用驅動程序的fasync方法間接調用fasync_helper函數以便將當前進程加入到驅動程序的異步通知等待隊列中。
extern void kill_fasync(struct fasync_struct **, int, int);
//當設備可訪問時，可使用kill_fasync函數發信號所有的相關進程。進程進而調用綁定的消息處理函數。

//分析fasync_helper的內部實現

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, SLAB_KERNEL);//創建對象，slab分配器
        if (!new)
            return -ENOMEM;
    }
    write_lock_irq(&fasync_lock);
    //遍歷整個異步通知隊列，看是否存在對應的文件指針
    for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
        if (fa->fa_file == filp) {//已存在
            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;//找到了
        }
    }
//看到下面可以得知，所謂的把進程添加到異步通知隊列中
//實則是將文件指針關聯到異步結構體對象，然后將該對象掛載在異步通知隊列中（等待隊列也是這個原理）
//那么最后發送信號又是怎么知道是哪個進程的呢？我們看后面的kill_fasync函數。
    if (on) {//不存在
        new->magic = FASYNC_MAGIC;
        new->fa_file = filp;//指定文件指針
        new->fa_fd = fd;//指定文件描述符
        new->fa_next = *fapp;//掛載在異步通知隊列中
        *fapp = new;//掛載
        result = 1;
    }
out:
    write_unlock_irq(&fasync_lock);
    return result;
}

//看看kill_fasync函數是怎么將信號通知指定進程的：

void __kill_fasync(struct fasync_struct *fa, int sig, int band)
{
    while (fa) {
        ...
        fown = &fa->fa_file->f_owner;//這里便是回答上面的問題，如果知道是哪個進程的，通過異步對象的文件指針知道其屬主進程
        /* Don't send SIGURG to processes which have not set a queued signum: SIGURG has its own default signallingmechanism. */
        if (!(sig == SIGURG && fown->signum == 0))
            send_sigio(fown, fa->fa_fd, band);//發送信號
        fa = fa->fa_next;
        ...
    }
}

總結：應用程序使用fcntl()設置當前進程的pid和FASYNC標志。進而調用驅動程序的fasync()，即fasync_helper()。然后申請和設置fasync_struct結構，將此結構掛載到驅動程序

的fasync_struct結構鏈表中。當設備可用時，驅動程序會使用kill_fasync()，從fasync_struct鏈表中，查找所有的等待進程，然后調用send_sigio發送相應的消息給進程。進程接收到

消息，就會跳轉到與消息綁定的消息處理函數中。

 

實例：基於<<Linux設備驅動開發詳解：基於最新的Linux4.0內核.pdf>>第9.3章節

驅動程序源碼.

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/poll.h>

#define GLOBALMEM_SIZE 0x1000
//#define GLOBALMEM_SIZE 0x10
#define GLOBALMEM_MAJOR 230
#define GLOBALMEM_MAGIC 'g'
//#define MEM_CLEAR _IO(GLOBALMEM_MAGIC,0)
#define MEM_CLEAR (0x01)
static int globalfifo_major = GLOBALMEM_MAJOR;
module_param(globalfifo_major, int, S_IRUGO);

struct globalfifo_dev {
 struct cdev cdev;
 unsigned int current_len;
 unsigned char mem[GLOBALMEM_SIZE];
 struct mutex mutex;
 wait_queue_head_t r_wait;
 wait_queue_head_t w_wait;
 struct fasync_struct *queue;
};

struct globalfifo_dev *globalfifo_devp;

static int globalfifo_open(struct inode *inode, struct file *filp)
{
    filp->private_data = globalfifo_devp;
    return 0;
}

static ssize_t globalfifo_read(struct file *filp, char __user * buf, size_t size,
 loff_t * ppos)
{
    unsigned int count = size;
    int ret = 0;
    struct globalfifo_dev *dev = filp->private_data;
    DECLARE_WAITQUEUE(wait, current);

    mutex_lock(&dev->mutex);
    add_wait_queue(&dev->r_wait, &wait);

    while(dev->current_len ==0){
        if(filp->f_flags & O_NONBLOCK){
            ret = -EAGAIN;
            goto out;
        }

        set_current_state(TASK_INTERRUPTIBLE);
        mutex_unlock(&dev->mutex);

        schedule();
        if(signal_pending(current)){
            ret = -ERESTARTSYS;
            goto out2;
        }
        mutex_lock(&dev->mutex);

    }

    if (count > dev->current_len)
        count = dev->current_len;

    if (copy_to_user(buf, dev->mem, count)) {
        ret = -EFAULT;
        goto out;
    } else {
        memcpy(dev->mem, dev->mem+count, dev->current_len - count);
        dev->current_len -=count;
        printk(KERN_INFO "read %d bytes(s) current_len %d\n", count, dev->current_len);
        wake_up_interruptible(&dev->w_wait);

        if(dev->queue){
            kill_fasync(&dev->queue, SIGIO, POLL_OUT);
            printk(KERN_DEBUG "%s kill SIGIO\n", __func__);
        }
        ret = count;
    }
out:
    mutex_unlock(&dev->mutex);
out2:
    remove_wait_queue(&dev->r_wait, &wait);
    set_current_state(TASK_RUNNING);

 return ret;
}

static ssize_t globalfifo_write(struct file *filp, const char __user * buf,
 size_t size, loff_t * ppos)
{
    unsigned int count = size;
    int ret = 0;
    struct globalfifo_dev *dev = filp->private_data;
    DECLARE_WAITQUEUE(wait, current);

    mutex_lock(&dev->mutex);
    add_wait_queue(&dev->w_wait, &wait);

    while(dev->current_len == GLOBALMEM_SIZE){
        if(filp->f_flags & O_NONBLOCK){
            ret = -EAGAIN;
            goto out;
        }

        set_current_state(TASK_INTERRUPTIBLE);
        mutex_unlock(&dev->mutex);
        schedule();
        if(signal_pending(current)){
            ret = -ERESTARTSYS;
            goto out2;
        }
        mutex_lock(&dev->mutex);

    }

    if (count > (GLOBALMEM_SIZE - dev->current_len))
        count = (GLOBALMEM_SIZE - dev->current_len);

    if (copy_from_user(dev->mem + dev->current_len, buf, count)){
        ret = -EFAULT;
        goto out;
    }
    else {
        dev->current_len += count;
        wake_up_interruptible(&dev->r_wait);
        ret = count;
        printk(KERN_INFO "written %d bytes(s) current_len %d\n", count, dev->current_len);

        if(dev->queue){
            kill_fasync(&dev->queue, SIGIO, POLL_IN);
            printk(KERN_DEBUG "%s kill SIGIO\n", __func__);
        }
    }
out:
    mutex_unlock(&dev->mutex);
out2:
    remove_wait_queue(&dev->w_wait, &wait);
    set_current_state(TASK_RUNNING);
 return ret;
}
static loff_t globalfifo_llseek(struct file *filp, loff_t offset, int orig)
{
    loff_t ret = 0;
    switch (orig) {
    case 0: /* ´ÓÎļþ¿ªÍ·Î»ÖÃseek */
    if (offset< 0) {
        ret = -EINVAL;
        break;
    }
    if ((unsigned int)offset > GLOBALMEM_SIZE) {
        ret = -EINVAL;
        break;
    }
    filp->f_pos = (unsigned int)offset;
    ret = filp->f_pos;
    break;
    case 1: /* ´ÓÎļþµ±Ç°Î»ÖÿªÊ¼seek */
    if ((filp->f_pos + offset) > GLOBALMEM_SIZE) {
        ret = -EINVAL;
        break;
    }
    if ((filp->f_pos + offset) < 0) {
        ret = -EINVAL;
        break;
    }
    filp->f_pos += offset;
    ret = filp->f_pos;
    break;
    default:
    ret = -EINVAL;
    break;
    }
    return ret;
}
static long globalfifo_ioctl(struct file *filp, unsigned int cmd,
 unsigned long arg)
{
    struct globalfifo_dev *dev = filp->private_data;
    switch (cmd) {
    case MEM_CLEAR:
        mutex_lock(&dev->mutex);
        memset(dev->mem, 0, GLOBALMEM_SIZE);
    dev->current_len =0;
        printk(KERN_INFO "globalfifo is set to zero\n");
        mutex_unlock(&dev->mutex);
        break;
    default:
    return -EINVAL;
 }

 return 0;
}
static unsigned int globalfifo_poll(struct file * filp, poll_table * wait)
{
    unsigned int mask =0;
    struct globalfifo_dev *dev = filp->private_data;

    mutex_lock(&dev->mutex);

    poll_wait(filp, &dev->w_wait, wait);
    poll_wait(filp, &dev->r_wait, wait);

    if(dev->current_len != 0)
        mask |=POLLIN | POLLRDNORM;
    if(dev->current_len != GLOBALMEM_SIZE)
        mask |=POLLOUT | POLLWRNORM;

    mutex_unlock(&dev->mutex);
    return mask;
}

static int globalfifo_fasync(int fd, struct file *filp, int on)
{
    struct globalfifo_dev *dev = filp->private_data;

    return fasync_helper(fd, filp, on, &dev->queue);
}

static int globalfifo_release(struct inode *inode, struct file *filp)
{
    globalfifo_fasync(-1, filp, 0);
    return 0;
}
static const struct file_operations globalfifo_fops = {
    .owner          = THIS_MODULE,
    .llseek         = globalfifo_llseek,
    .read           = globalfifo_read,
    .write          = globalfifo_write,
    .unlocked_ioctl = globalfifo_ioctl,
    .open           = globalfifo_open,
    .poll           = globalfifo_poll,
    .release        = globalfifo_release,
    .fasync         = globalfifo_fasync,
};
static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index)
{
    int err, devno = MKDEV(globalfifo_major, index);
    cdev_init(&dev->cdev, &globalfifo_fops);
    dev->cdev.owner = THIS_MODULE;
    err = cdev_add(&dev->cdev, devno, 1);
    if (err)
    printk(KERN_NOTICE "Error %d adding globalfifo%d", err, index);
}
static int __init globalfifo_init(void)
{
    int ret;
    dev_t devno = MKDEV(globalfifo_major, 0);

    if (globalfifo_major)
    ret = register_chrdev_region(devno, 1, "globalfifo");
    else {
    ret = alloc_chrdev_region(&devno, 0, 1, "globalfifo");
    globalfifo_major = MAJOR(devno);
    }
    if (ret < 0)
    return ret;

    globalfifo_devp = kzalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
    if (!globalfifo_devp) {
    ret = -ENOMEM;
    goto fail_malloc;
    }
    globalfifo_setup_cdev(globalfifo_devp, 0);

    mutex_init(&globalfifo_devp->mutex);
    init_waitqueue_head(&globalfifo_devp->r_wait);
    init_waitqueue_head(&globalfifo_devp->w_wait);
    return 0;

fail_malloc:
    unregister_chrdev_region(devno, 1);
    return ret;
}

static void __exit globalfifo_exit(void)
{
    cdev_del(&globalfifo_devp->cdev);
    kfree(globalfifo_devp);
    unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1);
}
module_init(globalfifo_init);
module_exit(globalfifo_exit);

MODULE_LICENSE("GPL v2");

應用程序源碼.

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>


void signal_handler(int signalNum)
{
    printf("signalNum:0x%x\n",signalNum);
}

int main(int argc, char **argv)
{
    int fd;
    int err;

    fd = open("/dev/globalfifo", O_RDONLY);
    if(fd == -1)
        printf("open fail\n");
    else{
        signal(SIGIO, signal_handler);
        fcntl(fd, F_SETOWN, getpid());
        int oflags = fcntl(fd, F_GETFL);
        fcntl(fd, F_SETFL, oflags | FASYNC);
        while(1)
            sleep(100);
    }
    return 0;
}

結果：

當echo 1 >/dev/globalfifo時

 

此文源碼基於內核源碼版本為linux-2.6.22.6

參考：https://www.cnblogs.com/tureno/articles/6059711.html