多读单写导致Linux字符驱动死锁？

Question

我正在开发一个基于字符设备驱动程序的示例 Linux 模块（使用 misc 驱动程序以方便使用），我发现了一些不寻常的行为。

我有文件操作的打开、读取、写入和释放功能，我的杂项设备被命名为test_device

我的设备有一个环形缓冲区，可以存储来自写入系统调用的数据，而读取系统调用可以读取数据。如果缓冲区已满，则调用 write 系统调用的进程将休眠，如果缓冲区为空，则调用 read 系统调用的进程将休眠。

有一个信号量（计数为 1，如互斥锁）以避免多次读取，从而避免出现竞争条件。这对于单个读取和单个写入过程来说效果很好，没有任何问题

现在我使用命令将设备作为 2 个读取实例打开

cat /dev/test_device 

正如预期的那样，第二个 cat 进程休眠了。我只有一个进程要写

ls > /dev/test_device

ls 命令甚至不调用 open 系统调用。谁能解释一下 open 系统调用失败的原因。

代码如下

static int hr_open(struct inode *inode, struct file *file)
{
    pr_info("process %i (%s) enters open\n", current->pid, current->comm);
    if (file->f_mode & FMODE_READ) down_interruptible(&rd_sem);

    pr_info("process %i (%s) leaves open\n", current->pid, current->comm);

    return 0;
}

static int hr_release(struct inode *inode, struct file *file)
{
    pr_info("process %i (%s) enters release\n", current->pid, current->comm);
    if (file->f_mode & FMODE_READ) up(&rd_sem);

    pr_info("process %i (%s) leaves release\n", current->pid, current->comm);

    return 0;
}

static ssize_t hr_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
    pr_info("process %i (%s) enters read\n", current->pid, current->comm);

    if (wait_event_interruptible(wq_rd, head != tail))
        return -ERESTARTSYS;    

    if (put_user(buff[head], buffer)) 
        return -EFAULT;

    head = (head + 1) % BUFF_SIZE;

    wake_up_interruptible(&wq_wr);
    pr_info("process %i (%s) leaves read\n", current->pid, current->comm);

    return 1;
}

static ssize_t hr_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
    pr_info("process %i (%s) enters write\n", current->pid, current->comm);

    if (wait_event_interruptible(wq_wr, tail != ((head + 1) % BUFF_SIZE)))
        return -ERESTARTSYS;    

    if (get_user(buff[tail], buffer)) 
        return -EFAULT; 

    tail = (tail + 1) % BUFF_SIZE;

    wake_up_interruptible(&wq_rd);
    pr_info("process %i (%s) leaves write\n", current->pid, current->comm);

    return 1;
}

Answer 1

我在您的代码中注意到您打开信号量锁并在释放函数中释放它。我通常不建议在一个函数中持有一个锁并在另一个函数中释放它，因为这可能会导致锁定问题或死锁。

    static int hr_open(struct inode *inode, struct file *file)
    {
    ...    
        if (file->f_mode & FMODE_READ) down_interruptible(&rd_sem);
    ...
    }

    static int hr_release(struct inode *inode, struct file *file)
    {
     ...

       if (file->f_mode & FMODE_READ) up(&rd_sem);

     ...
    }

我的建议是在读写函数中移动信号量锁（向下和向上）。