epoll字符设备驱动代码

以下是一个简单的使用 epoll 的字符设备驱动代码示例：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/uaccess.h>

#define DEVICE_NAME "mychardev"
#define BUFFER_SIZE 1024

MODULE_LICENSE("Dual BSD/GPL");

// 设备结构体
struct mychardev_dev {
    struct cdev cdev;           // 字符设备结构体
    char buffer[BUFFER_SIZE];   // 数据缓冲区
    atomic_t length;            // 缓冲区中当前数据长度
    wait_queue_head_t wq;       // 等待队列头
    struct mutex mutex;         // 互斥锁
    struct device *device;      // 设备指针
};

// 定义设备结构体变量
static struct mychardev_dev mychardev;

// 打开设备
static int mychardev_open(struct inode *inode, struct file *file) {
    file->private_data = container_of(inode->i_cdev, struct mychardev_dev, cdev);
    return 0;
}

// 释放设备
static int mychardev_release(struct inode *inode, struct file *file) {
    return 0;
}

// 读取设备
static ssize_t mychardev_read(struct file *file, char __user *buf, size_t count, loff_t *offset) {
    struct mychardev_dev *dev = file->private_data;
    ssize_t ret = 0;

    // 等待缓冲区中有数据
    if (wait_event_interruptible(dev->wq, atomic_read(&dev->length) > 0)) {
        return -ERESTARTSYS;
    }

    // 读取数据
    if (mutex_lock_interruptible(&dev->mutex)) {
        return -ERESTARTSYS;
    }

    if (count > atomic_read(&dev->length)) {
        count = atomic_read(&dev->length);
    }

    if (copy_to_user(buf, dev->buffer, count)) {
        ret = -EFAULT;
    } else {
        memmove(dev->buffer, dev->buffer + count, atomic_read(&dev->length) - count);
        atomic_sub(count, &dev->length);
        ret = count;
    }

    mutex_unlock(&dev->mutex);
    return ret;
}

// 写入设备
static ssize_t mychardev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) {
    struct mychardev_dev *dev = file->private_data;
    ssize_t ret = 0;

    // 写入数据
    if (mutex_lock_interruptible(&dev->mutex)) {
        return -ERESTARTSYS;
    }

    if (count > BUFFER_SIZE - atomic_read(&dev->length)) {
        count = BUFFER_SIZE - atomic_read(&dev->length);
    }

    if (copy_from_user(dev->buffer + atomic_read(&dev->length), buf, count)) {
        ret = -EFAULT;
    } else {
        atomic_add(count, &dev->length);
        ret = count;
    }

    mutex_unlock(&dev->mutex);

    // 唤醒等待队列中的进程
    wake_up_interruptible(&dev->wq);

    return ret;
}

// 轮询设备
static unsigned int mychardev_poll(struct file *file, poll_table *wait) {
    struct mychardev_dev *dev = file->private_data;
    unsigned int mask = 0;

    poll_wait(file, &dev->wq, wait);

    if (atomic_read(&dev->length) > 0) {
        mask |= POLLIN | POLLRDNORM;
    }

    if (atomic_read(&dev->length) < BUFFER_SIZE) {
        mask |= POLLOUT | POLLWRNORM;
    }

    return mask;
}

// 设备操作结构体
static struct file_operations mychardev_fops = {
    .owner = THIS_MODULE,
    .open = mychardev_open,
    .release = mychardev_release,
    .read = mychardev_read,
    .write = mychardev_write,
    .poll = mychardev_poll,
};

// 初始化设备
static int mychardev_init(void) {
    int ret;

    // 分配设备号
    if (register_chrdev_region(MKDEV(0, 0), 1, DEVICE_NAME)) {
        printk(KERN_ERR "mychardev: register_chrdev_region failed\n");
        return -EFAULT;
    }

    // 初始化字符设备结构体
    cdev_init(&mychardev.cdev, &mychardev_fops);
    mychardev.cdev.owner = THIS_MODULE;

    // 注册字符设备
    ret = cdev_add(&mychardev.cdev, MKDEV(0, 0), 1);
    if (ret) {
        printk(KERN_ERR "mychardev: cdev_add failed\n");
        unregister_chrdev_region(MKDEV(0, 0), 1);
        return ret;
    }

    // 初始化等待队列头
    init_waitqueue_head(&mychardev.wq);

    // 初始化互斥锁
    mutex_init(&mychardev.mutex);

    // 创建设备节点
    mychardev.device = device_create(
        class_create(THIS_MODULE, "mychardev_class"),
        NULL,
        MKDEV(0, 0),
        NULL,
        DEVICE_NAME);

    if (IS_ERR(mychardev.device)) {
        printk(KERN_ERR "mychardev: device_create failed\n");
        cdev_del(&mychardev.cdev);
        unregister_chrdev_region(MKDEV(0, 0), 1);
        return PTR_ERR(mychardev.device);
    }

    return 0;
}

// 卸载设备
static void mychardev_exit(void) {
    // 销毁设备节点
    device_destroy(class_create(THIS_MODULE, "mychardev_class"), MKDEV(0, 0));

    // 删除字符设备
    cdev_del(&mychardev.cdev);

    // 释放设备号
    unregister_chrdev_region(MKDEV(0, 0), 1);
}

module_init(mychardev_init);
module_exit(mychardev_exit);

在此示例中，我们使用了 epoll 实现了设备的轮询，当设备中有数据时，我们会将进程加入到等待队列中，当设备中有数据或者缓冲区未满时，我们会将等待队列中的进程唤醒。同时，我们也使用了互斥锁来保证数据的同步和并发访问的安全。