在Linux内核驱动中，构建一个存放如下结构体指针的队列： struct msg { u16 module_id; u16 cmd_id; u16 cmd_subid; u16 complete; u8 data[128]; }; 这个队列需要包含头尾指针tail和head。 请给出操作这个队列的函数，包括初始化，入队，出队，注销等。 再构建两个函数，在函数中使用操作队列的函数完成如下功能： 函数一初始化msg结构体，将msg所有成员设置为常数（其中msg的complete成员设置为0），向msg的data数组内放置两个unsigned int 类型数据a和b，之后将msg结构体放入队列中，触发函数二，使用usleep_range()函数等待函数二将msg的complete成员设置为1后，获取函数二放入的c并还原成unsigned int 类型。 函数二需要从队列中取出msg，并进行解析：判断msg的module_id是否为0x1，如果不是，报错，如果是0x1,使用switch函数解析msg的cmd_id，再根据不同的cmd_id解析cmd_subid，具体解析内容为，取出在函数一向msg的data数组中放入的a和b，还原成unsigned int 类型数据，再将一个unsigned int 类型数据c=1000，放到msg的data数组内，之后，再将msg中的complete置1；请在驱动的probe函数中注册这个队列，在remove函数中注销队列，使用移位的方式放置和还原unsigned int类型数据

以下是操作这个队列的函数代码：

// 初始化队列
void queue_init(struct msg_queue *queue)
{
    queue->tail = queue->head = 0;
    spin_lock_init(&queue->lock);
    INIT_LIST_HEAD(&queue->list);
}

// 入队
void queue_put(struct msg_queue *queue, struct msg *msg)
{
    spin_lock(&queue->lock);
    list_add_tail(&msg->list, &queue->list);
    queue->tail++;
    spin_unlock(&queue->lock);
}

// 出队
struct msg *queue_get(struct msg_queue *queue)
{
    struct msg *msg = NULL;
    spin_lock(&queue->lock);
    if (!list_empty(&queue->list)) {
        msg = list_first_entry(&queue->list, struct msg, list);
        list_del(&msg->list);
        queue->head++;
    }
    spin_unlock(&queue->lock);
    return msg;
}

// 注销队列
void queue_exit(struct msg_queue *queue)
{
    struct msg *msg;
    while ((msg = queue_get(queue))) {
        kfree(msg);
    }
}

// 函数一：初始化msg结构体并入队
void init_msg_and_enqueue(struct msg_queue *queue)
{
    struct msg *msg = kmalloc(sizeof(struct msg), GFP_KERNEL);
    msg->module_id = 0x1234;
    msg->cmd_id = 0x5678;
    msg->cmd_subid = 0x9ABC;
    msg->complete = 0;
    unsigned int a = 0x12345678, b = 0x9ABCDEF0;
    msg->data[0] = (char)(a >> 24);
    msg->data[1] = (char)(0xff & (a >> 16));
    msg->data[2] = (char)(0xff & (a >> 8));
    msg->data[3] = (char)(0xff & a);
    msg->data[4] = (char)(b >> 24);
    msg->data[5] = (char)(0xff & (b >> 16));
    msg->data[6] = (char)(0xff & (b >> 8));
    msg->data[7] = (char)(0xff & b);
    queue_put(queue, msg);
}

// 函数二：从队列中取出msg并解析
void parse_msg(struct msg_queue *queue)
{
    struct msg *msg = queue_get(queue);
    if (msg && msg->module_id == 0x1) {
        switch (msg->cmd_id) {
        case 0x1:
            switch (msg->cmd_subid) {
            case 0x1:
                unsigned int a = (msg->data[0] << 24) | (msg->data[1] << 16) |
                                  (msg->data[2] << 8) | msg->data[3];
                unsigned int b = (msg->data[4] << 24) | (msg->data[5] << 16) |
                                  (msg->data[6] << 8) | msg->data[7];
                unsigned int c = 1000;
                msg->data[8] = (char)(c >> 24);
                msg->data[9] = (char)(0xff & (c >> 16));
                msg->data[10] = (char)(0xff & (c >> 8));
                msg->data[11] = (char)(0xff & c);
                msg->complete = 1;
                break;
            default:
                printk(KERN_ERR "Unknown cmd_subid: 0x%x\n", msg->cmd_subid);
                break;
            }
            break;
        default:
            printk(KERN_ERR "Unknown cmd_id: 0x%x\n", msg->cmd_id);
            break;
        }
    } else {
        printk(KERN_ERR "Unknown module_id: 0x%x\n", msg->module_id);
    }
    kfree(msg);
}

在驱动的probe函数中，可以使用如下代码注册这个队列：

struct msg_queue my_queue;
queue_init(&my_queue);

在remove函数中，可以使用如下代码注销队列：

queue_exit(&my_queue);

使用移位的方式放置和还原unsigned int类型数据的代码已经在上面的示例函数中给出。