Linux内核字符设备驱动实现阻塞式read通过定时器解除阻塞

在Linux内核字符设备驱动中，实现阻塞式read可以通过在设备驱动程序中调用wait_event_interruptible()函数来实现。该函数会使进程进入睡眠状态，等待设备数据就绪，直到被唤醒。但是，当设备没有数据就绪时，进程会一直阻塞在该函数处，无法继续执行。

为了解决这个问题，可以通过定时器来解除阻塞。具体实现步骤如下：

在设备驱动程序中定义一个定时器结构体。
在设备驱动程序的read函数中，如果设备没有数据就绪，则启动定时器。
定时器回调函数中，检查设备数据是否就绪，如果就绪则唤醒阻塞的进程。
在设备驱动程序的release函数中，取消定时器。

下面是一个简单的实现示例：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <linux/timer.h>

#define DEVICE_NAME "mydevice"
#define DEVICE_CLASS "myclass"
#define BUF_SIZE 1024

static struct device *dev;
static struct class *cls;
static struct cdev cdev;
static int major;

static char *buf;
static int buf_len = 0;

static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
static struct timer_list read_timer;

static void read_timer_callback(unsigned long data)
{
    if (buf_len > 0) {
        wake_up_interruptible(&read_wait_queue);
    }
}

static ssize_t mydevice_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    int ret;

    if (buf_len == 0) {
        mod_timer(&read_timer, jiffies + HZ/10); //启动定时器，等待100ms
        wait_event_interruptible(read_wait_queue, buf_len > 0); //等待数据就绪
        del_timer(&read_timer); //取消定时器
    }

    if (buf_len > 0) {
        ret = copy_to_user(buf, mybuf, min(buf_len, count));
        if (ret) {
            return -EFAULT;
        }
        *f_pos += min(buf_len, count);
        buf_len -= min(buf_len, count);
        return min(buf_len, count);
    }

    return 0;
}

static int mydevice_open(struct inode *inode, struct file *filp)
{
    return 0;
}

static int mydevice_release(struct inode *inode, struct file *filp)
{
    del_timer(&read_timer); //取消定时器
    return 0;
}

static const struct file_operations mydevice_fops = {
    .owner = THIS_MODULE,
    .read = mydevice_read,
    .open = mydevice_open,
    .release = mydevice_release,
};

static int __init mydevice_init(void)
{
    int ret;

    buf = kmalloc(BUF_SIZE, GFP_KERNEL);
    if (!buf) {
        return -ENOMEM;
    }

    major = register_chrdev(0, DEVICE_NAME, &mydevice_fops);
    if (major < 0) {
        kfree(buf);
        return major;
    }

    cdev_init(&cdev, &mydevice_fops);
    cdev_add(&cdev, MKDEV(major, 0), 1);

    cls = class_create(THIS_MODULE, DEVICE_CLASS);
    if (IS_ERR(cls)) {
        cdev_del(&cdev);
        unregister_chrdev(major, DEVICE_NAME);
        kfree(buf);
        return PTR_ERR(cls);
    }

    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, DEVICE_NAME);
    if (IS_ERR(dev)) {
        class_destroy(cls);
        cdev_del(&cdev);
        unregister_chrdev(major, DEVICE_NAME);
        kfree(buf);
        return PTR_ERR(dev);
    }

    init_timer(&read_timer);
    read_timer.function = read_timer_callback;
    read_timer.data = 0;

    return 0;
}

static void __exit mydevice_exit(void)
{
    device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    cdev_del(&cdev);
    unregister_chrdev(major, DEVICE_NAME);
    kfree(buf);
}

module_init(mydevice_init);
module_exit(mydevice_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("My Device Driver");

在read函数中，如果设备没有数据就绪，则启动定时器，等待100ms。该定时器使用jiffies + HZ/10来启动，即100ms后执行回调函数。在回调函数中，检查设备数据是否就绪，如果就绪则唤醒阻塞的进程。在release函数中，取消定时器。

注意，如果设备数据在100ms内就绪了，则不会启动定时器，而是直接执行后续操作。定时器只有在数据没有在100ms内就绪时才会启动，防止过长的阻塞时间