linux内核驱动，构造一个全局队列，用于写入和读取结构体，给出具体代码

以下是一个简单的 Linux 内核模块，构造了一个全局队列，用于写入和读取结构体：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>

MODULE_LICENSE("GPL");

#define QUEUE_LENGTH 10

struct queue_item {
    int data;
    struct list_head list;
};

static LIST_HEAD(queue);

static int queue_init(void)
{
    int i;
    struct queue_item *item;

    printk(KERN_INFO "Queue module loaded\n");

    for (i = 0; i < QUEUE_LENGTH; i++) {
        item = kmalloc(sizeof(struct queue_item), GFP_KERNEL);
        item->data = i;
        list_add_tail(&item->list, &queue);
    }

    return 0;
}

static void queue_exit(void)
{
    struct queue_item *item, *tmp;

    printk(KERN_INFO "Queue module unloaded\n");

    list_for_each_entry_safe(item, tmp, &queue, list) {
        list_del(&item->list);
        kfree(item);
    }
}

static ssize_t queue_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    struct queue_item *item;
    ssize_t len = 0;

    list_for_each_entry(item, &queue, list) {
        len += snprintf(buf + len, count - len, "%d\n", item->data);
    }

    return len;
}

static ssize_t queue_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    struct queue_item *item;

    item = kmalloc(sizeof(struct queue_item), GFP_KERNEL);
    if (!item) {
        return -ENOMEM;
    }

    if (count < 2) {
        kfree(item);
        return -EINVAL;
    }

    sscanf(buf, "%d", &item->data);

    list_add_tail(&item->list, &queue);

    return count;
}

static const struct file_operations queue_fops = {
    .owner = THIS_MODULE,
    .read = queue_read,
    .write = queue_write,
};

static int queue_major;

static int __init queue_init_module(void)
{
    queue_major = register_chrdev(0, "queue", &queue_fops);
    if (queue_major < 0) {
        printk(KERN_WARNING "Failed to register character device\n");
        return queue_major;
    }

    queue_init();

    printk(KERN_INFO "Queue module initialized\n");

    return 0;
}

static void __exit queue_cleanup_module(void)
{
    queue_exit();

    unregister_chrdev(queue_major, "queue");

    printk(KERN_INFO "Queue module cleaned up\n");
}

module_init(queue_init_module);
module_exit(queue_cleanup_module);

该模块提供了一个字符设备 `/dev/queue`，可以使用 `read()` 和 `write()` 系统调用来读取和写入队列中的结构体。

在模块初始化时，使用 `kmalloc()` 分配 QUEUE_LENGTH 个结构体，初始化它们的数据，并将它们添加到队列中。在模块清除时，释放所有结构体占用的内存。

在 `queue_read()` 函数中，遍历队列，将每个结构体的数据以字符串形式写入到用户空间的缓冲区中。在 `queue_write()` 函数中，从用户空间的缓冲区中读取一个整数，并创建一个新的结构体，将其添加到队列的末尾。

需要注意的是，该模块中的队列是全局的，因此可以被多个进程同时访问。为了避免竞态条件，需要在读取和修改队列时使用适当的同步机制，例如自旋锁。