在Linux内核驱动中，构建一个存放如下结构体的数组： struct msg { u16 module_id; u16 cmd_id; u16 cmd_subid; u16 complete; u8 data[128]; }; 请给出操作这个数组的函数，包括初始化，入数组，出数组，注销等。 再构建两个函数，在函数中使用操作数组的函数完成如下功能： 函数一初始化msg结构体，将msg所有成员设置为常数（其中msg的complete成员设置为0），向msg的data数组内放置两个unsigned int 类型数据a和b，之后将msg结构体放入数组中，触发函数二，使用usleep_range()函数等待函数二将msg的complete成员设置为1后，获取函数二放入的c并还原成unsigned int 类型，之后清除msg。 函数二需要从数组中取出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；使用移位的方式放置和还原unsigned int类型数据。

下面是操作数组的函数实现：

#define MSG_ARRAY_SIZE 10

struct msg msg_array[MSG_ARRAY_SIZE];
int msg_array_head = 0;
int msg_array_tail = 0;

// 初始化数组
void msg_array_init(void)
{
    memset(msg_array, 0, sizeof(msg_array));
    msg_array_head = msg_array_tail = 0;
}

// 入数组
int msg_array_push(struct msg *msg)
{
    int next_tail = (msg_array_tail + 1) % MSG_ARRAY_SIZE;
    if (next_tail == msg_array_head) {
        return -1; // 数组已满
    }
    memcpy(&msg_array[msg_array_tail], msg, sizeof(struct msg));
    msg_array_tail = next_tail;
    return 0;
}

// 出数组
int msg_array_pop(struct msg *msg)
{
    if (msg_array_head == msg_array_tail) {
        return -1; // 数组为空
    }
    memcpy(msg, &msg_array[msg_array_head], sizeof(struct msg));
    msg_array_head = (msg_array_head + 1) % MSG_ARRAY_SIZE;
    return 0;
}

// 注销数组
void msg_array_cleanup(void)
{
    memset(msg_array, 0, sizeof(msg_array));
    msg_array_head = msg_array_tail = 0;
}

下面是函数一：

void func_one(void)
{
    struct msg msg;

    // 初始化msg结构体
    memset(&msg, 0, sizeof(struct msg));
    msg.module_id = 0x1;
    msg.cmd_id = 0x2;
    msg.cmd_subid = 0x3;
    msg.complete = 0;
    *(unsigned int *)msg.data = 0x12345678;
    *(unsigned int *)(msg.data + sizeof(unsigned int)) = 0x87654321;

    // 将msg结构体放入数组中
    if (msg_array_push(&msg) != 0) {
        printk(KERN_ERR "msg array full\n");
        return;
    }

    // 等待msg结构体被处理
    while (msg.complete == 0) {
        usleep_range(1000, 2000);
    }

    // 获取函数二放入的c并还原成unsigned int类型
    unsigned int c = *(unsigned int *)(msg.data + 2 * sizeof(unsigned int));

    // 清除msg结构体
    memset(&msg, 0, sizeof(struct msg));
}

下面是函数二：

void func_two(void)
{
    struct msg msg;

    // 从数组中取出msg结构体
    if (msg_array_pop(&msg) != 0) {
        return;
    }

    // 判断module_id是否为0x1
    if (msg.module_id != 0x1) {
        printk(KERN_ERR "msg module_id error\n");
        return;
    }

    // 解析cmd_id
    switch (msg.cmd_id) {
    case 0x2:
        // 解析cmd_subid
        switch (msg.cmd_subid) {
        case 0x3:
            // 取出a和b并还原成unsigned int类型
            unsigned int a = *(unsigned int *)msg.data;
            unsigned int b = *(unsigned int *)(msg.data + sizeof(unsigned int));

            // 将c放入msg的data数组内
            *(unsigned int *)(msg.data + 2 * sizeof(unsigned int)) = 1000;

            // 将msg的complete置1
            msg.complete = 1;

            // 使用移位的方式放置和还原unsigned int类型数据
            a = a << 16 | a >> 16;
            b = b << 16 | b >> 16;
            c = c << 16 | c >> 16;
            break;
        default:
            printk(KERN_ERR "msg cmd_subid error\n");
            return;
        }
        break;
    default:
        printk(KERN_ERR "msg cmd_id error\n");
        return;
    }

    // 将处理后的msg结构体放回数组中
    if (msg_array_push(&msg) != 0) {
        printk(KERN_ERR "msg array full\n");
        return;
    }
}