1
#include <linux/cdev.h>
2
#include <linux/device.h>
3
#include <linux/fs.h>
4
#include <linux/init.h>
5
#include <linux/kernel.h>
6
#include <linux/kfifo.h>
7
#include <linux/module.h>
8
#include <linux/poll.h>
9
#include <linux/sched.h>
10
#include <linux/slab.h>
11
#include <linux/spinlock.h>
12
#include <linux/uaccess.h>
13
#include <linux/version.h>
14
#include <linux/wait.h>
15

16
#define MAX_DEV    2
17
#define MAX_EVENTS 16          // 最大事件队列长度
18
#define EVENT_SIZE sizeof(int) // 每个事件的大小（int）
19

20
static int dev_major = 0;
21
static struct class* lx_class = NULL;
22

23
static ssize_t lx_read(struct file*, char __user*, size_t, loff_t*);
24
static ssize_t lx_write(struct file*, const char __user*, size_t, loff_t*);
25
static unsigned int lx_poll(struct file*, poll_table*);
26

27
static struct file_operations fops = {
28
    .owner = THIS_MODULE,
29
    .read = lx_read,
30
    .write = lx_write,
31
    .poll = lx_poll,
32
};
33

34
// 设备私有数据结构
35
struct pipe_dev {
36
    struct cdev cdev;                          // 字符设备
37
    wait_queue_head_t read_queue;              // 读等待队列
38
    spinlock_t lock;                           // 保护FIFO的自旋锁
39
    struct kfifo fifo;                         // 事件队列
40
    char fifo_buffer[MAX_EVENTS * EVENT_SIZE]; // FIFO存储空间
41
};
42

43
static struct pipe_dev devs[MAX_DEV]; // 设备数组
44

45
static int __init lx_init(void) {
46
    dev_t dev;
47
    int i, err;
48
    // 动态分配设备号范围
49
    err = alloc_chrdev_region(&dev, 0, MAX_DEV, "pipe");
50
    if (err < 0) {
51
        printk(KERN_ERR "Failed to allocate char device region\n");
52
        return err;
53
    }
54

55
    // 获取主设备号
56
    dev_major = MAJOR(dev);
57
    // 创建设备类
58
#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 4, 0)
59
    lx_class = class_create("pipe");
60
#else
61
    lx_class = class_create(THIS_MODULE, "pipe");
62
#endif
63
    if (IS_ERR(lx_class)) {
64
        unregister_chrdev_region(dev, MAX_DEV);
65
        return PTR_ERR(lx_class);
66
    }
67

68
    // 初始化每个设备
69
    for (i = 0; i < MAX_DEV; ++i) {
70
        struct pipe_dev* dev_ptr = &devs[i];
71
        // 初始化kfifo
72
        if (kfifo_initialized(&dev_ptr->fifo)) {
73
            printk(KERN_WARNING "FIFO already initialized for device %d\n", i);
74
        } else {
75
            kfifo_init(&dev_ptr->fifo, dev_ptr->fifo_buffer, sizeof(dev_ptr->fifo_buffer));
76
        }
77
        // 初始化自旋锁
78
        spin_lock_init(&dev_ptr->lock);
79
        // 初始化等待队列
80
        init_waitqueue_head(&dev_ptr->read_queue);
81
        // 初始化字符设备
82
        cdev_init(&dev_ptr->cdev, &fops);
83
        dev_ptr->cdev.owner = THIS_MODULE;
84
        // 添加字符设备
85
        err = cdev_add(&dev_ptr->cdev, MKDEV(dev_major, i), 1);
86
        if (err) {
87
            printk(KERN_ERR "Error %d adding device %d\n", err, i);
88
            continue;
89
        }
90
        // 创建设备节点 /dev/pipeX
91
        device_create(lx_class, NULL, MKDEV(dev_major, i), NULL, "pipe%d", i);
92
    }
93
    printk(KERN_INFO "pipe event notifier driver loaded with major %d\n", dev_major);
94
    return 0;
95
}
96

97
static void __exit lx_exit(void) {
98
    int i;
99
    for (i = 0; i < MAX_DEV; ++i) {
100
        device_destroy(lx_class, MKDEV(dev_major, i));
101
        cdev_del(&devs[i].cdev);
102
    }
103
    class_destroy(lx_class);
104
    unregister_chrdev_region(MKDEV(dev_major, 0), MAX_DEV);
105
    printk(KERN_INFO "pipe event notifier driver unloaded\n");
106
}
107

108
static unsigned int lx_poll(struct file* file, poll_table* wait) {
109
    struct pipe_dev* dev = container_of(file->f_inode->i_cdev, struct pipe_dev, cdev);
110
    unsigned int mask = 0;
111
    // 注册等待队列
112
    poll_wait(file, &dev->read_queue, wait);
113

114
    spin_lock(&dev->lock);
115
    if (!kfifo_is_empty(&dev->fifo)) {
116
        mask |= POLLIN | POLLRDNORM; // 返回可读标志
117
    }
118
    spin_unlock(&dev->lock);
119
    return mask;
120
}
121

122
static ssize_t lx_read(struct file* file, char __user* buf, size_t count, loff_t* offset) {
123
    struct pipe_dev* dev = container_of(file->f_inode->i_cdev, struct pipe_dev, cdev);
124
    int event;
125
    DEFINE_WAIT(wait);
126
    if (count < EVENT_SIZE) {
127
        return -EINVAL; // 缓冲区太小
128
    }
129

130
    // 等待直到有事件可用
131
    while (kfifo_is_empty(&dev->fifo)) {
132
        if (file->f_flags & O_NONBLOCK) {
133
            return -EAGAIN; // 非阻塞模式，立即返回
134
        }
135

136
        prepare_to_wait(&dev->read_queue, &wait, TASK_INTERRUPTIBLE);
137
        spin_unlock(&dev->lock); // 解锁后休眠
138
        // 检查是否有信号中断
139
        if (signal_pending(current)) {
140
            finish_wait(&dev->read_queue, &wait);
141
            return -ERESTARTSYS;
142
        }
143
        // 让出CPU直到被唤醒
144
        schedule();
145
        finish_wait(&dev->read_queue, &wait);
146
    }
147

148
    spin_lock(&dev->lock); // 唤醒后重新加锁
149
    if (kfifo_out(&dev->fifo, &event, EVENT_SIZE) != EVENT_SIZE) {
150
        spin_unlock(&dev->lock);
151
        return -EIO; // 读取失败
152
    }
153
    spin_unlock(&dev->lock);
154

155
    // 将事件复制到用户空间
156
    if (copy_to_user(buf, &event, EVENT_SIZE)) {
157
        return -EFAULT;
158
    }
159
    return EVENT_SIZE;
160
}
161

162
static ssize_t lx_write(struct file* file, const char __user* buf, size_t count, loff_t* offset) {
163
    struct pipe_dev* dev = container_of(file->f_inode->i_cdev, struct pipe_dev, cdev);
164
    int event;
165
    unsigned int pushed;
166
    if (count < EVENT_SIZE) {
167
        return -EINVAL; // 数据太小
168
    }
169
    // 从用户空间复制事件
170
    if (copy_from_user(&event, buf, EVENT_SIZE)) {
171
        return -EFAULT;
172
    }
173

174
    spin_lock(&dev->lock);
175
    // 尝试将事件推入队列
176
    if (kfifo_avail(&dev->fifo) < EVENT_SIZE) {
177
        spin_unlock(&dev->lock);
178
        return -ENOSPC; // 队列已满
179
    }
180
    pushed = kfifo_in(&dev->fifo, &event, EVENT_SIZE);
181
    spin_unlock(&dev->lock);
182

183
    if (pushed != EVENT_SIZE) {
184
        return -EIO; // 写入失败
185
    }
186
    // 唤醒等待的读进程
187
    wake_up_interruptible(&dev->read_queue);
188
    return EVENT_SIZE;
189
}
190

191
module_init(lx_init);
192
module_exit(lx_exit);
193
MODULE_LICENSE("GPL");
194
MODULE_AUTHOR("aLinChe");
195
MODULE_DESCRIPTION("Kernel Event Notifier Pipe Driver");