// 声明和初始等待队列头
wait_queue_head_t my_queue;
init_waitqueue_head(&my_queue);
DECLARE_WAIT_QUEUE_HEAD (name) 
// 定义等待队列元素，并绑定到指定进程
DECLARE_WAITQUEUE(name, tsk)
// 添加/移除队列元素
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
// 下列宏检查condition是否满足，阻塞并等待被唤醒，唤醒时检查condition是否满足，不满足继续阻塞
// 只需声明等待队列头，然后直接调用下列宏
wait_event(queue, condition)
wait_event_interruptible(queue, condition)
wait_event_timeout(queue, condition, timeout)
wait_event_interruptible_timeout(queue, condition, timeout)
// 唤醒指定队列中元素绑定的进程
void wake_up(wait_queue_head_t *queue);
void wake_up_interruptible(wait_queue_head_t *queue);

// app设置非阻塞flag
oflags = fcntl(FILENO, F_GETFL);
fcntl(FILENO, F_SETFL, oflags | O_NONBLOCK);

用户进程调用 select/poll/epoll系统调用
	 ↓
内核调用驱动的 poll 方法
	 ↓
驱动调用 poll_wait()注册等待队列，并判断是否有事件
	 ↓
内核将进程加入等待队列
	 ↓  
无事件时用户进程在内核中休眠等待
	 ↓
设备事件发生
	 ↓
驱动调用 wake_up_interruptible()
	 ↓
内核唤醒休眠的进程
	 ↓
内核再次调用驱动的 poll 方法，此时poll_wait不会再次注册等待队列
	 ↓  
驱动返回事件掩码 (如 POLLIN)
	 ↓
select/poll/epoll 系统调用返回，用户进程处理事件

unsigned int(*poll)(struct file * filp, struct poll_table* wait);

static unsigned int xxx_poll(struct file *filp, struct poll_table *wait)
{
	unsigned int mask = 0;
	struct xxx_dev *dev = filp->private_data; /* 获得设备结构体指针*/
	
	...
	poll_wait(filp, &dev->r_wait, wait); /* 加入读等待队列 */
	poll_wait(filp, &dev->w_wait, wait); /* 加入写等待队列 */
	
	if (...) /* 可读 */
		mask |= POLLIN | POLLRDNORM; /* 标示数据可获得（对用户可读）*/

	if (...) /* 可写 */
		mask |= POLLOUT | POLLWRNORM; /* 标示数据可写入*/
	...
	return mask;
}
static ssize_t xxx_read(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos){
	if(no_data() && filp->f_flags & O_NONBLOCK)
		return -EAGAIN;
	if((filp->f_flags & O_NONBLOCK) == 0)
		wait_event_interruptible(dev->r_wait, hava_data());
	read_size = read_data();
	return read_size;
}

void poll_wait(struct file *filp, wait_queue_heat_t *queue, poll_table * wait);

#include <fcntl.h>
#include <signal.h>
#define MAX_LEN 100
void input_handler(int num)
{
	char data[MAX_LEN];
	int len;
	
	/* 读取并输出STDIN_FILENO上的输入 */
	len = read(STDIN_FILENO, &data, MAX_LEN);
	data[len] = 0;
	printf("input available:%s\n",data);
}

main()
{
	int oflags;
	
	/* 启动SIGIO异步信号机制 */
	signal(SIGIO, input_handler);
	fcntl(FILENO, F_SETOWN, getpid());
	oflags = fcntl(FILENO, F_GETFL);
	fcntl(FILENO, F_SETFL, oflags | FASYNC);
	
	...
}

struct xxx_dev {
	struct cdev cdev; /* cdev结构体*/
	...
	struct fasync_struct *async_queue; /* 异步结构体指针 */
};
static int xxx_fasync(int fd, struct file *filp, int mode)
{
	struct xxx_dev *dev = filp->private_data;
	return fasync_helper(fd, filp, mode, &dev->async_queue);
}
// 在设备资源可以获得时，调用kill_fasync（）释放SIGIO信号。在可读时，第3个参数设置为POLL_IN，在可写时，第3个参数设置为POLL_OUT。
static ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
{
	struct xxx_dev *dev = filp->private_data;
	...
	/* 产生异步读信号 */
	if (dev->async_queue)
		kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
	...
}
static int xxx_release(struct inode *inode, struct file *filp)
{
	/* 将文件从异步通知列表中删除 */
	xxx_fasync(-1, filp, 0);
	...
	return 0;
}
static struct file_operations fops = {
	.write = xxx_write,
	.fasync = xxx_fasync,
	.release = xxx_release,
}

int io_setup(int maxevents, io_context_t *ctxp);
int io_destroy(io_context_t ctx);
int io_submit(io_context_t ctx, long nr, struct iocb *ios[]);
int io_cancel(io_context_t ctx, struct iocb *iocb, struct io_event *evt);
int io_getevents(io_context_t ctx_id, long min_nr, long nr, struct io_event *events,
struct timespec *timeout);
void io_set_callback(struct iocb *iocb, io_callback_t cb);
void io_prep_pwrite(struct iocb *iocb, int fd, void *buf, size_t count, long long offset);
void io_prep_pread(struct iocb *iocb, int fd, void *buf, size_t count, long long offset);
void io_prep_pwritev(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt,
long long offset);
void io_prep_preadv(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt,
long long offset);

// 使用 read_iter 统一处理
static ssize_t my_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
    struct file *filp = iocb->ki_filp;
    struct my_device *dev = filp->private_data;
    if (iocb->ki_flags & IOCB_DIRECT) {
        return my_direct_io(iocb, iter);  // 直接IO
    } else {
        return my_buffered_io(iocb, iter); // 缓冲IO
    }
}

// 同时处理同步和异步
static const struct file_operations my_fops = {
    .read_iter = my_read_iter,
    .write_iter = my_write_iter,
    // 不再需要单独的 .read, .write, .aio_read, .aio_write
};

// read_iter 使用更先进的 iov_iter
static ssize_t my_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
    // iov_iter 自动处理所有类型的向量
    while (iov_iter_count(iter) > 0) {
        size_t len = process_chunk(iter);
        iov_iter_advance(iter, len);
    }
    // 同样的代码处理所有情况，驱动不需要关心数据的具体来源
    copy_to_iter(device_data, data_len, iter);
    copy_from_iter(device_data, data_len, iter);
}