linux设备驱动阻塞IO应用

1. 驱动中阻塞相关函数的基础

1.1 wait_queue_head_t

定义等待队列头

#include <linux/wait.h>
/*
 * lock：自旋锁，用于保护队列操作（如添加/删除等待项）的并发安全
 * head：链表头，指向等待队列项的链表
 */
typedef struct wait_queue_head {
    spinlock_t      lock;
    struct list_head    head;
} wait_queue_head_t;

1.2 init_waitqueue_head

初始化一个已经分配了内存的等待队列头，设置其自旋锁和链表为空

void init_waitqueue_head(wait_queue_head_t *q);

1.3 DECLARE_WAITQUEUE

静态声明并初始化一个等待队列项（wait queue entry） 。该宏创建一个 wait_queue_entry 类型的变量，并将指定的进程描述符 tsk （当前进程为 current ）与该队列项关联，同时设置默认的唤醒函数

DECLARE_WAITQUEUE(name, tsk);

// 使用方式
DECLARE_WAITQUEUE(wait, current);
// 展开后为
wait_queue_entry_t wait = {
    .private    = current,                 // 指向等待的进程 task_struct
    .func       = default_wake_function,   // 唤醒时调用的函数
    .task_list  = { NULL, NULL }           // 链表节点，用于挂入等待队列头
};

1.4 add_wait_queue

将一个已经初始化好的等待队列项 wait 添加到等待队列头 queue 所管理的队列中。添加后，该队列项就成为了等待队列的一部分

在进程准备睡眠之前，先将自己添加到等待队列，这样其他唤醒者才能找到它

void add_wait_queue(wait_queue_head_t *queue, wait_queue_t *wait);

1.5 set_current_state

设置当前进程的状态 ，将 current->state 赋值为 new_state ，进程状态定义在 <linux/sched.h> 中，常见的有：

• TASK_RUNNING：可运行状态（正在运行或就绪）。

• TASK_INTERRUPTIBLE：可中断的睡眠状态，可以被信号唤醒。

• TASK_UNINTERRUPTIBLE：不可中断的睡眠状态，只能由显式唤醒解除。

void set_current_state(int new_state);        // 有内存屏障，保证顺序
void __set_current_state(int new_state);      // 没有内存屏障    

1.6 remove_wait_queue

将之前通过 add_wait_queue 添加的等待队列项从等待队列中移除；当进程被唤醒并重新获得 CPU 后，通常需要调用此函数将自己从等待队列中删除，表示不再等待该条件；如果忘记移除，队列项仍留在等待队列中，可能导致后续不必要的唤醒或资源泄漏

void remove_wait_queue(wait_queue_head_t *queue, wait_queue_t *wait);

1.7 wake_up

唤醒队列中所有进程（包括 TASK_UNINTERRUPTIBLE和 TASK_INTERRUPTIBLE ）

void wake_up(wait_queue_head_t *queue);

唤醒等待队列 queue 中所有状态为 TASK_INTERRUPTIBLE 的进程。这些进程将被设置为 TASK_RUNNING 并移入运行队列，等待调度器选择它们运行

void wake_up_interruptible(wait_queue_head_t *queue);

2. 阻塞驱动使用例子

#include <linux/init.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/ioctl.h>
#include <linux/io.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/wait.h>

#define GLOBALFIFO_SIZE    1024
#define GLOBALMEM_MAGIC    'M'
#define MEM_CLEAR        _IO(GLOBALMEM_MAGIC, 0)

struct globalfifo_dev {
    struct cdev m_cdev;            /* 字符设备 */
    unsigned int current_len;        /* fifo有效数据长度 */
    unsigned char mem[GLOBALFIFO_SIZE];    /* 全局内存 */
    struct semaphore sem;            /* 并发控制信号量 */
    wait_queue_head_t r_wait;        /* 阻塞读等待队列头 */
    wait_queue_head_t w_wait;        /* 阻塞写等待队列头 */
};


static int globalfifo_major = 266;

// 存放字符设备私有数据
struct globalfifo_dev* globalfifo_devp;


/* user open fd */
static int globalfifo_open(struct inode* inode, struct file* filp) {
    
    struct globalfifo_dev* dev;
    dev = container_of(inode->i_cdev, struct globalfifo_dev, m_cdev);
    filp->private_data = dev;
    return 0;
}


/* user release fd*/
static int globalfifo_release(struct inode* inode, struct file* filp) {
    return 0;
}



/* user read fd */
static ssize_t globalfifo_read(struct file* filp, char __user* buf, size_t count, loff_t* ppos) {
    int ret;    
    struct globalfifo_dev* dev = filp->private_data;    
    
    // 定义等待队列
    DECLARE_WAITQUEUE(wait, current);    

    down(&dev->sem);

    // 1.将等待队列加入到等待队列头
    add_wait_queue(&dev->r_wait, &wait);

    // 2.循环检查等待条件（防止假唤醒，如果唤醒后不满足条件会再次睡眠）
    while (dev->current_len == 0) {
        // 3. 检查非阻塞模式直接返回
        if (filp->f_flags & O_NONBLOCK) {
            ret = -EAGAIN;
            up(&dev->sem);
            remove_wait_queue(&dev->w_wait, &wait);
            set_current_state(TASK_RUNNING);
            return ret;
        }
        // 4.改变进程状态为可中断睡眠
        __set_current_state(TASK_INTERRUPTIBLE);

        up(&dev->sem);

        // 5.调度其他进程执行（真正睡眠）        
        schedule();

        // 6.检查如果有信号到达返回上层处理错误（自己的唤醒只将状态转换为TASK_RUNNING，但信号到来也会做这个处理）
        if (signal_pending(current)) {
            ret = -ERESTARTSYS;
            remove_wait_queue(&dev->w_wait, &wait);
            set_current_state(TASK_RUNNING);
            return ret;
        }
        
        // 被唤醒后的处理
        down(&dev->sem);
    }

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

    if(copy_to_user(buf, dev->mem, count)) {
        ret = -EFAULT;
        up(&dev->sem);
        remove_wait_queue(&dev->w_wait, &wait);
           set_current_state(TASK_RUNNING);
        return ret;
    } else {
        memcpy(dev->mem, dev->mem + count, dev->current_len - count);
        dev->current_len -= count;
            
        wake_up_interruptible(&dev->w_wait);    // 读出数据后唤醒写进程
        ret = count;
    }
    
    up(&dev->sem);
    remove_wait_queue(&dev->w_wait, &wait);
    set_current_state(TASK_RUNNING);

    return ret;
}


/* user write fd */ 
static ssize_t globalfifo_write(struct file* filp, const char __user* buf, size_t count, loff_t* ppos) {
    int ret;    
    struct globalfifo_dev* dev = filp->private_data;    

    // 定义等待队列
    DECLARE_WAITQUEUE(wait, current);
    down(&dev->sem);
    // 1.将等待队列插入写等待队列头
    add_wait_queue(&dev->w_wait, &wait);

    // 2.循环等待 若FIFO满则应该挂起
    while (dev->current_len == GLOBALFIFO_SIZE) {
        // 3. 若非阻塞则直接返回
        if (filp->f_flags & O_NONBLOCK) {
            up(&dev->sem);
            ret = -EAGAIN;
            remove_wait_queue(&dev->w_wait, &wait);
            set_current_state(TASK_RUNNING);
            return ret;
        }
        // 4.将进程状态改为可打断睡眠
        __set_current_state(TASK_INTERRUPTIBLE);
        up(&dev->sem);
        // 5.调度其他进程（真正睡眠）
        schedule();

        // 6.若因为信号唤醒，则返回让上层完成错误处理
        if (signal_pending(current)) {
            ret = -ERESTARTSYS;
            remove_wait_queue(&dev->w_wait, &wait);
            set_current_state(TASK_RUNNING);
            return ret;
        }
        down(&dev->sem);
    }

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

    if (copy_from_user(dev->mem, buf, count)) {
        ret = -EFAULT;
        up(&dev->sem);
        remove_wait_queue(&dev->w_wait, &wait);
        set_current_state(TASK_RUNNING);
        return ret;
    } else {
        dev->current_len += count;
        // 唤醒等待队列
        wake_up_interruptible(&dev->r_wait);
        ret = count;    
    }

    up(&dev->sem);
    remove_wait_queue(&dev->w_wait, &wait);
    set_current_state(TASK_RUNNING);

    return count;
}


/* user lseek fd */
static loff_t globalfifo_llseek(struct file* filp, loff_t offset, int orig) {
    loff_t ret;
    switch(orig) {
    // 从起始位置开始移动指针
    case 0:
        if(offset < 0) {
            ret = -EINVAL;
            break;
        }
        if((unsigned int)offset > GLOBALFIFO_SIZE) {
            ret = -EINVAL;
            break;
        }
        filp->f_pos = (unsigned int)offset;
        ret = filp->f_pos;
        break;
    // 从当前位置开始移动指针
    case 1:
        if((filp->f_pos + offset) > GLOBALFIFO_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;
    }
    return ret;
}


/* user ioctl fd */
static long globalfifo_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){
    // 获取设备结构体指针    
    struct globalfifo_dev* dev = filp->private_data;    
    
    switch(cmd) {
    case MEM_CLEAR:
        down(&dev->sem);
        dev->current_len = 0;
        memset(dev->mem, 0, GLOBALFIFO_SIZE);
        up(&dev->sem);
        break;
    default:
        return -EINVAL;
    }
    return 0;
}



static const struct file_operations globalfifo_fops = {
    .owner = THIS_MODULE,
    .open = globalfifo_open,
    .release = globalfifo_release,
    .llseek = globalfifo_llseek,
    .read = globalfifo_read,
    .write = globalfifo_write,
    .unlocked_ioctl = globalfifo_unlocked_ioctl
};


/* 设备驱动模块insmod加载函数 */
static int globalfifo_init(void) {
    // 向 Linux 内核中注册字符设备编号范围
    register_chrdev_region(MKDEV(globalfifo_major, 0), 1, "globalfifo");

    // 为设备以及共享内存分配内存
    globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
    memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));
    
    // 初始化字符设备0的基本字段
    cdev_init(&globalfifo_devp->m_cdev, &globalfifo_fops);
    globalfifo_devp->m_cdev.owner = THIS_MODULE;
    // 将主设备号globalfifo_major次设备号0，与字符设备驱动的关联
    cdev_add(&globalfifo_devp->m_cdev, MKDEV(globalfifo_major, 0), 1);

    // 初始化信号量
    sema_init(&globalfifo_devp->sem, 1);

    // 初始化读写等待队列头
    init_waitqueue_head(&globalfifo_devp->r_wait);
    init_waitqueue_head(&globalfifo_devp->w_wait);
    return 0;
}


static void globalfifo_exit(void) {
    dev_t devno;
    // 注销cdev
    cdev_del(&globalfifo_devp->m_cdev);
    // 释放设备结构体内存
    kfree(globalfifo_devp);    
    // 释放设备号
    devno = MKDEV(globalfifo_major, 0);
    unregister_chrdev_region(devno, 1);
}


MODULE_AUTHOR("cear");
MODULE_LICENSE("GPL");

module_param(globalfifo_major, int, S_IRUGO);
module_init(globalfifo_init);
module_exit(globalfifo_exit);