Linux阻塞、非阻塞与异步通知

阻塞IO

阻塞状态下应用程序从驱动读取函数时，若kernel回报设备不可用，应用程序对应的线程将会进入睡眠，等待设备可用后由设备通知应用程序并将其唤醒以继续执行。

Linux依靠等待队列(wait queue)来进行进程同步，其允许进程在某个条件满足前进入睡眠，并在条件满足时由驱动进行唤醒，避免CPU忙等。

等待队列

基本的等待队列包括：

事件(event)：通常是硬件中断、数据可用或资源释放等
等待队列头（wait_queue_head_t）：每个等待队列都有一个队列头，用于管理在此等待的进程
等待队列项（wait_queue_t）：表示等待队列中的一个进程，它包含进程的状态信息

等待队列头结构体：

typedef struct __wait_queue_head {
    spinlock_t lock;         // 保护等待队列的自旋锁
    struct list_head task_list; 
} wait_queue_head_t;

显然这是一个链表结构，task_list为所有等待某事件发生的进程链表。等待队列头维护等待该事件的所有进程，通过自旋锁来保护对task_list的访问以防止竞争条件。

等待队列项：

typedef struct wait_queue_entry {
    unsigned int flags;
    struct task_struct *task;  // 进程的task_struct
    struct list_head entry;    // 连接到等待队列
} wait_queue_entry_t;

等待队列项代表正在等待事件的进程，进程会被挂载至task_list，进入睡眠。

这里结构体中的task_struct是Linux的进程描述符，该结构体会管理所有的进程，这是一个非常长而且很复杂的结构体。其中有一个重要的量volatile long state，用于表示进程当前的状态，包括：

TASK_RUNNING：正在运行或准备运行
TASK_INTERRUPTIBLE：处于可被中断的睡眠状态，等待某个事件发生。此过程下进程可被信号唤醒
TASK_UNINTERRUPTIBLE：处于不可被中断的睡眠状态，等待某个事件发生。此过程下进程不可被信号唤醒，只能等待事件发生
TASK_STOPPED：进程停止执行
TASK_TRACED：进程正在被调试器追踪
TASK_DEAD：进程已终止，等待被释放
TASK_WAKEKILL：进程处于可被杀死的睡眠状态，即使在不可中断的睡眠中，也能被特定信号唤醒或终止
TASK_WAKING：进程正在从睡眠状态中被唤醒，尚未进入可运行队列
TASK_NOLOAD：进程不应影响负载计算，通常用于内核线程

对于等待队列，前三种状态比较常见。

等待队列的使用方式

定义和初始化等待队列头

struct xxx_dev {
    .......
    wait_queue_head_t r_wait;
}

设定等待条件和事件（以按键为例）

DECLARE_WAITQUEUE(wait, current);   /* 创建等待队列 */
if (atomic_read(&dev->releasekey) == 0){    /* 如果按键未按下 */
    add_wait_queue(&dev->r_wait, &wait);    /* 添加当前线程至等待队列 */
    __set_current_state(TASK_INTERRUPTIBLE);    /* 切换进程模式至可中断睡眠状态 */
    schedule(); /* 让出CPU，等待被唤醒 */
    if (signal_pending(current)){   /* 如果有信号打断睡眠，退出 */
        ret = -ERESTARTSYS;
        goto wait_error;
    }
    __set_current_state(TASK_RUNNING);  /* 进程恢复运行 */
    remove_wait_queue(&dev->r_wait, &wait); /* 从等待队列中移除当前线程 */
}

其中：

DECLARE_WAITQUEUE(name, tsk)：用于创建等待队列，name为队列名称，tsk为队列所对应的进程，一般使用current，表示当前线程
add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)：q为等待队列要加入的等待队列头，wait为要加入的等待队列项

设定唤醒条件（以按键为例）

/* 唤醒进程 */
if(atomic_read(&dev->releasekey)){  /* 完成一次按键过程 */
    wake_up_interruptible(&dev->r_wait);
}

此处可选wake_up()和wake_up_interruptible()：

wake_up()会唤醒所有在r_wait所属队列中等待的进程
wake_up_interruptible仅唤醒一个处于TASK_INTERRUPTIBLE状态的进程

唤醒后，进程将在被调度器选择后从schedule()位置开始继续执行。

“信号”

上节提到在wake_up_interruptible()下睡眠中的进程会被信号唤醒。信号是Linux的异步进程间通信机制，用于通知进程发生了某种事件，比如用户按下 Ctrl + C 终止进程，或者进程试图访问非法内存地址导致段错误（SIGSEGV）。

信号编号	信号名称	描述	默认处理方式
`1`	`SIGHUP`	终端挂起（用户退出 shell）	终止
`2`	`SIGINT`	用户终止进程（Ctrl + C）	终止
`9`	`SIGKILL`	立即终止进程（不能被捕获或忽略）	终止
`11`	`SIGSEGV`	段错误（非法访问内存）	终止
`15`	`SIGTERM`	终止进程（默认 `kill` 发送）	终止
`17`	`SIGCHLD`	子进程结束	忽略

如果处于TASK_INTERRUPTIBLE状态下的进程接收到信号，其会提前返回并唤醒睡眠中的进程。在睡眠状态被信号中断的进程通常会检查是否有信号需要处理，如果有，则提前返回，避免无限等待。

非阻塞IO

非阻塞模式下若设备不可用或数据未准备好时，设备会向kernel返回错误码。应用程序会重新读取数据（或执行其他操作），如此循环，直到数据读取成功。

非阻塞模式下读取数据时，需要修改打开文件的方式：

1	`fd = open("/dev/xxx_dev", O_RDWR \| O_NONBLOCK);`

O_NONBLOCK表示使用非阻塞模式。

轮询

Select

int select(int nfds, 
           fd_set *readfds, 
           fd_set *writefds,
           fd_set *exceptfds, 
           struct timeval *timeout)

nfds：监视的文件描述符的数量。它是所有文件描述符中最大值加 1。即，nfds = max(fd1, fd2, …, fdN) + 1。
readfds：待检测是否可读的文件描述符集合。用 FD_SET() 宏添加文件描述符，FD_ZERO() 初始化为空。
writefds：待检测是否可写的文件描述符集合
exceptfds：待检测是否发生异常的文件描述符集合
timeout：指定等待时间的结构体。如果为 NULL，则会一直等待直到有事件发生；如果为零（timeout = {0, 0}），则非阻塞地返回
返回值：可操作文件描述符个数

readfds、writefds和exceptfds都为fd_set类型，指向描述符集合，用于指明关心哪些描述符，以及描述符需要满足的条件。readfds负责监视指定描述符集的读变化，即监视这些文件是否可读取，只要这些集合中有一个文件可以被读取，select就会返回大于0的值表示文件可读取。若没有文件可读取，则根据timeout判断是否超时。readfds可以设置为NULL，表示不关心文件的可读性变化。writefds和exceptfds的用法也类似。

如果要从一个设备文件中读取数据，可以定义一个fd_set变量，用于传递给readfds。fd_set可以通过这几个宏进行操作：

void FD_ZERO(fd_set *set)           /* 清零fd_set的所有位 */
void FD_SET(int fd, fd_set *set)    /* 将fd_set某个位置1 */
void FD_CLR(int fd, fd_set *set)    /* 将fd_set某个位置0（删除某个文件描述符） */
int FD_ISSET(int fd, fd_set *set)   /* 测试一个文件是否属于某个集合 */

使用select对某个设备驱动文件进行非阻塞访问的示例：

void main(void)
{
    int ret, fd;            //要监视的文件描述符
    fd_set readfds;         //读操作文件描述符集
    struct timeval timeout; //超时结构体

    fd = open("dev_xxx", O_RDWR | O_NONBLOCK);  //非阻塞访问

    FD_ZERO(&readfds);      //清除readfs
    FD_SET(fd, &readfds);   //将fd添加至readfds

    timeout.tv_sec = 0
    timeout.tv_usec = 500000;

    ret = select(fd + 1, &readfds, NULL, NULL, &timeout);   //仅监测文件是否可读
    switch (ret)
    {
        case 0:                     //超时
            printf("timeout\r\n");
            break;
        case -1:                    //错误
            printf("error\r\n");
            break;
        default:                    //可读取数据
            if (FD_ISSET(fd, &readfds)){    //判断是否为fd文件描述符
                //用read函数读取数据
            }
            break;
    }
}

poll

1
2
3

int poll(struct pollfd *fds, 
         nfds_t nfds, 
         int timeout)

fds：待监视的文件描述符集合以及要监视的事件，数组元素为pollfd类型：

struct pollfd {
    int     fd;         //文件描述符
    short   events;     //请求的事件
    short   revents;    //返回的事件
}

events为待监视事件，包含：

POLLIN 有数据可以读取。
POLLPRI 有紧急的数据需要读取。
POLLOUT 可以写数据。
POLLERR 指定的文件描述符发生错误。
POLLHUP 指定的文件描述符挂起。
POLLNVAL 无效的请求。
POLLRDNORM 等同于 POLLIN

nfds：poll函数要监视的文件描述符数量
timeout：超时时间

poll函数使用示例:

void main(void)
{
    int ret, fd;            //要监视的文件描述符
    struct pollfd fds;

    fd = open("dev_xxx", O_RDWR | O_NONBLOCK);  //非阻塞访问

    fds.fd = fd;
    fds.event = POLLIN;     //监视文件是否可以读取

    ret = poll(&fds, 1, 500);   //轮询文件是否可操作，超时时间500ms
    if (ret){               //可读取
        ...
    }else if (ret == 0){    //超时
        ...
    }else if (ret < 0){     //错误
        ...
    }
}

驱动程序：

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);    //挂载驱动至等待队列

    if (atomic_read(&dev->releasekey)){
        mask = POLLIN | POLLRDNORM;         //返回，告知有数据可读
    }

    return mask;
}

static struct file_operations imx6uirq_fops = {
    .owner = THIS_MODULE,
    .open = imx6uirq_open,
    .read = imx6uirq_read,
    .poll = imx6uirq_poll,      //绑定poll至fops
};

epoll

epoll主要解决大并发问题，用于解决传统的select和poll会随着监听fd数量增加而出现效率低下的问题。

使用epoll前应用程序要先用epoll_create创建一个epoll句柄：

int epoll_create(int size)

return:
epoll句柄，-1表示创建失败

句柄创建完成后，用epoll_ctl向其中要监视的文件描述符以及监视的事件：

int epoll_ctl(int   epfd,
              int   op,
              int   fd,
              struct epoll_event *event)

epfd：要操作的 epoll 句柄

op：表示要对 epfd(epoll 句柄)进行的操作，可以设置为：
EPOLL_CTL_ADD 向 epfd 添加文件参数 fd 表示的描述符。
EPOLL_CTL_MOD 修改参数 fd 的 event 事件。
EPOLL_CTL_DEL 从 epfd 中删除 fd 描述符。

fd：要监视的文件描述符。

event：要监视的事件类型，为 epoll_event 结构体类型指针：

struct epoll_event {
        uint32_t events;   /* epoll 事件 */
        epoll_data_t data; /* 用户数据 */
};

events表示要监视的事件，可选：
EPOLLIN 有数据可以读取。
EPOLLOUT 可以写数据。
EPOLLPRI 有紧急的数据需要读取。
EPOLLERR 指定的文件描述符发生错误。
EPOLLHUP 指定的文件描述符挂起。
EPOLLET 设置 epoll 为边沿触发，默认触发模式为水平触发。
EPOLLONESHOT 一次性的监视，当监视完成以后还需要再次监视某个 fd，那么就需要将
fd 重新添加到 epoll 里面。

设置完成后，调用epoll_wait()等待事件发生：

int epoll_wait(int epfd,                    //要等待的poll
               struct epoll_event *events,  //指向epoll_event结构体的数组
               int maxevents,               //events数组大小
               int timeout)                 //超时时间，ms

异步通知

异步通知通过信号用类似于软中断的方式，由驱动程序自行通知应用程序令其响应。Linux的信号类型在arch/xtebsa/include/uapi/asm/signal/h中定义。

信号同样有回调函数（接收到信号后要执行的内容）：

1	`sighandler_t signal(int signum, sighandler_t handler)`

signum：信号类别
handler：信号处理函数

驱动处理信号

定义一个fasync_struct类型的结构体指针：

struct fasync_struct {
    dev_t devid;
    ......
    struct fasync_struct *async_queue;  /* 异步结构体 */
}

初始化结构体指针：

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

新建xxx_fasync回调函数以处理FASYNC标志，并绑定至fops
满足信号发送条件时，调用kill_fasync向应用程序发送信号：

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

sig：待发送信号类型
band：可读时为POLL_IN，可写时为POLL_OUT

驱动文件关闭时释放fasync_struct：

1	`xxx_fasync(-1 ,filp, 0);`

xxx_fasync参考示例：

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

    if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)
        return -EIO;
    return 0;
}

/* 满足条件时 */
void xxx()
{
    ....
    kill_fasync(&dev->async_queue, SIGIO, POLL_IN); /* 向应用程序发送SIGIO（表示文件描述符准备就绪, 可以开始进行输入/输出操作）信号 */
}

应用程序处理信号

应用程序首先绑定处理函数至某个特定的信号量，然后调用fcntl(操作文件描述符的属性)进行初始化：

1	`int fcntl (int __fd, int __cmd, ...);`

1	`fcntl(fd, F_SETOWN, getpid()); /* 通知kernel当前进程的进程号 */`

-F_SETOWN：设置fd的所有者，此处为当前进程(getpid()返回当前进程的ID)

1 2	`flags = fcntl(fd, F_GETFD); /* 获取进程状态 / fcntl(fd, F_SETFL, flags \| FASYNC); / 为进程启用异步通知功能 */`

F_GETFD：获取当前fd的标志位，返回整型值，描述fd属性信息（如文件描述符是否关闭，是否是异步 I/O 等）
F_SETFL：设置fd的文件状态标志
flags | FASYNC：将FASYNC标志添加进入现有的文件描述符标志，启用文件描述符的异步IO功能。

完整过程：

static int fd = 0;  /* 文件描述符 */

/* 信号处理函数 */
static void sigio_signal_func(int signum)
{
    int err = 0;
    unsigned int keyvalue = 0;

    err = read(fd, &keyvalue, sizeof(keyvalue));
    if (err < 0){
        printf("sigio error\r\n");
    }else{
        printf("sigio signal, key value = %d\r\n", keyvalue);
    }
}

int main(int argc, char *argv[])
{  
    .......

    /* 绑定信号处理函数至SIGIO信号 */
    signal(SIGIO, sigio_signal_func);   

    fcntl(fd, F_SETOWN, getpid());  /* 通知kernel当前进程的进程号 */
    flags = fcntl(fd, F_GETFD);     /* 获取进程状态 */
    fcntl(fd, F_SETFL, flags | FASYNC); /* 为进程启用异步通知功能 */

    while (1){
        sleep(2);
    }

    close(fd);
    return 0;
}

嵌入式(Linux开发)

Linux阻塞、非阻塞与异步通知

http://akichen891.github.io/2025/03/26/Linux阻塞、非阻塞与异步通知/

作者

Aki

发布于

2025年3月26日

更新于

2025年4月1日

许可协议

Linux文件描述符上一篇

Linux中断机制下一篇