面试题：C语言函数指针与回调机制在操作系统内核模块中的应用

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义设备驱动操作函数指针类型
typedef void (*init_func_t)();
typedef int (*read_func_t)(void *buf, int len);
typedef int (*write_func_t)(const void *buf, int len);

// 定义设备驱动结构体
typedef struct {
    const char *name;
    init_func_t init;
    read_func_t read;
    write_func_t write;
} device_driver_t;

// 全局变量，用于存储已加载的设备驱动
device_driver_t *loaded_drivers[100];
int driver_count = 0;

// 加载设备驱动模块
int load_driver(const char *name, init_func_t init, read_func_t read, write_func_t write) {
    if (driver_count >= 100) {
        printf("无法加载更多驱动，已达上限\n");
        return -1;
    }
    loaded_drivers[driver_count] = (device_driver_t *)malloc(sizeof(device_driver_t));
    if (!loaded_drivers[driver_count]) {
        printf("内存分配失败\n");
        return -1;
    }
    loaded_drivers[driver_count]->name = strdup(name);
    loaded_drivers[driver_count]->init = init;
    loaded_drivers[driver_count]->read = read;
    loaded_drivers[driver_count]->write = write;
    driver_count++;
    return 0;
}

// 卸载设备驱动模块
int unload_driver(const char *name) {
    for (int i = 0; i < driver_count; i++) {
        if (strcmp(loaded_drivers[i]->name, name) == 0) {
            free((void *)loaded_drivers[i]->name);
            free(loaded_drivers[i]);
            for (int j = i; j < driver_count - 1; j++) {
                loaded_drivers[j] = loaded_drivers[j + 1];
            }
            driver_count--;
            return 0;
        }
    }
    printf("未找到名为 %s 的驱动\n", name);
    return -1;
}

// 调用设备驱动的初始化函数
void call_init(const char *name) {
    for (int i = 0; i < driver_count; i++) {
        if (strcmp(loaded_drivers[i]->name, name) == 0) {
            if (loaded_drivers[i]->init) {
                loaded_drivers[i]->init();
            }
            return;
        }
    }
    printf("未找到名为 %s 的驱动\n", name);
}

// 调用设备驱动的读函数
int call_read(const char *name, void *buf, int len) {
    for (int i = 0; i < driver_count; i++) {
        if (strcmp(loaded_drivers[i]->name, name) == 0) {
            if (loaded_drivers[i]->read) {
                return loaded_drivers[i]->read(buf, len);
            }
            return -1;
        }
    }
    printf("未找到名为 %s 的驱动\n", name);
    return -1;
}

// 调用设备驱动的写函数
int call_write(const char *name, const void *buf, int len) {
    for (int i = 0; i < driver_count; i++) {
        if (strcmp(loaded_drivers[i]->name, name) == 0) {
            if (loaded_drivers[i]->write) {
                return loaded_drivers[i]->write(buf, len);
            }
            return -1;
        }
    }
    printf("未找到名为 %s 的驱动\n", name);
    return -1;
}

// 示例设备驱动1的操作函数
void driver1_init() {
    printf("驱动1初始化\n");
}
int driver1_read(void *buf, int len) {
    printf("驱动1读操作\n");
    return 0;
}
int driver1_write(const void *buf, int len) {
    printf("驱动1写操作\n");
    return 0;
}

// 示例设备驱动2的操作函数
void driver2_init() {
    printf("驱动2初始化\n");
}
int driver2_read(void *buf, int len) {
    printf("驱动2读操作\n");
    return 0;
}
int driver2_write(const void *buf, int len) {
    printf("驱动2写操作\n");
    return 0;
}

int main() {
    // 加载驱动1
    load_driver("driver1", driver1_init, driver1_read, driver1_write);
    // 加载驱动2
    load_driver("driver2", driver2_init, driver2_read, driver2_write);

    // 调用驱动1的初始化函数
    call_init("driver1");
    // 调用驱动2的读函数
    call_read("driver2", NULL, 0);

    // 卸载驱动1
    unload_driver("driver1");

    return 0;
}

函数指针类型定义：定义了 init_func_t、read_func_t 和 write_func_t 分别表示设备驱动的初始化、读、写操作函数指针类型。
设备驱动结构体：device_driver_t 结构体用于存储设备驱动的名称以及对应的操作函数指针。
全局变量：loaded_drivers 数组用于存储已加载的设备驱动，driver_count 记录已加载驱动的数量。
加载与卸载函数：
- load_driver 函数负责将新的设备驱动加载到系统中，分配内存并存储相关信息。
- unload_driver 函数用于卸载指定名称的设备驱动，释放相关内存并调整数组。
回调调用函数：
- call_init、call_read 和 call_write 函数根据设备驱动名称调用相应的初始化、读、写操作函数。
示例驱动函数：定义了 driver1_init、driver1_read、driver1_write 和 driver2_init、driver2_read、driver2_write 作为示例设备驱动的操作函数。
主函数：在 main 函数中演示了加载、调用和卸载设备驱动的过程。

面试题：C语言函数指针与回调机制在操作系统内核模块中的应用

知识考点

面试题答案