kexec file load系统调用及示例

92. kexec_file_load - 通过文件描述符加载内核镜像链接到标题

1. 函数介绍链接到标题

kexec_file_load 是一个 Linux 系统调用，用于通过文件描述符直接加载内核镜像和 initrd 文件。它是 kexec_load 的现代化替代接口，提供了更简单、更安全的内核加载方式，支持数字签名验证和更严格的参数检查。

2. 函数原型链接到标题

long kexec_file_load(int kernel_fd, int initrd_fd,
                     unsigned long cmdline_len,
                     const char *cmdline_ptr,
                     unsigned long flags);

注意：这不是标准 C 库函数，需要通过 syscall() 调用。

3. 功能链接到标题

通过文件描述符加载内核镜像和 initrd 文件到内存中，为后续的 kexec 调用做准备。相比 kexec_load，这个接口更加安全和易用。

4. 参数链接到标题

int kernel_fd: 内核镜像文件的文件描述符
int initrd_fd: initrd/initramfs 文件的文件描述符（可为 -1 表示不使用）
unsigned long cmdline_len: 内核命令行参数的长度
const char *cmdline_ptr: 指向内核命令行参数的指针
unsigned long flags: 控制标志
- KEXEC_FILE_UNLOAD: 卸载当前已加载的内核
- KEXEC_FILE_ON_CRASH: 为内核崩溃转储加载内核
- KEXEC_FILE_NO_INITRAMFS: 不使用 initramfs

5. 返回值链接到标题

成功时：返回 0
失败时：返回 -1，并设置 errno

6. 常见 errno 错误码链接到标题

EBUSY: kexec 子系统正在使用中
EINVAL: 参数无效或文件格式错误
EPERM: 权限不足（需要 CAP_SYS_BOOT 能力）
ENOMEM: 内存不足
EACCES: 文件访问权限不足
ENOEXEC: 内核镜像格式无效
ENOSYS: 系统不支持此系统调用
EEXIST: 已有内核加载且未指定卸载标志

7. 相似函数，或关联函数链接到标题

kexec_load(): 传统的内核加载接口
reboot(): 系统重启函数，用于激活已加载的内核
open(), close(): 文件操作函数
syscall(): 系统调用接口
/sbin/kexec: 用户态 kexec 工具
/proc/iomem: 查看系统内存布局
/sys/kernel/kexec_loaded: 检查内核是否已加载

8. 示例代码链接到标题

示例1：基本使用 - kexec_file_load 框架链接到标题

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>

#ifndef SYS_kexec_file_load
# define SYS_kexec_file_load 320  // x86_64 架构下的系统调用号
#endif

#ifndef SYS_reboot
# define SYS_reboot 169
#endif

#define LINUX_REBOOT_MAGIC1 0xfee1dead
#define LINUX_REBOOT_MAGIC2 0x28121969
#define LINUX_REBOOT_CMD_KEXEC 0x45584543

// kexec_file_load 系统调用包装函数
long kexec_file_load_wrapper(int kernel_fd, int initrd_fd,
                            unsigned long cmdline_len,
                            const char *cmdline_ptr,
                            unsigned long flags) {
    return syscall(SYS_kexec_file_load, kernel_fd, initrd_fd,
                   cmdline_len, cmdline_ptr, flags);
}

// 检查系统支持
int check_kexec_file_load_support() {
    // 尝试调用以检查是否支持
    long result = kexec_file_load_wrapper(-1, -1, 0, NULL, 0);
    if (result == -1 && errno == ENOSYS) {
        return -1;  // 不支持
    }
    return 0;  // 支持
}

// 检查权限
int check_kexec_permissions() {
    if (geteuid() != 0) {
        printf("错误: 需要 root 权限执行 kexec\n");
        return -1;
    }
    
    // 检查 CAP_SYS_BOOT 能力
    // 这里简化处理
    
    return 0;
}

int main() {
    printf("=== kexec_file_load 基本框架演示 ===\n");
    
    // 检查系统支持
    if (check_kexec_file_load_support() == -1) {
        printf("错误: 系统不支持 kexec_file_load 系统调用\n");
        printf("提示: 需要 Linux 内核 3.17 或更高版本\n");
        return 1;
    }
    
    printf("✓ 系统支持 kexec_file_load\n");
    
    // 检查权限
    if (check_kexec_permissions() == -1) {
        return 1;
    }
    
    printf("✓ 权限检查通过\n");
    
    // 显示系统信息
    printf("\n系统信息:\n");
    printf("  内核版本: ");
    system("uname -r");
    printf("  系统架构: ");
    system("uname -m");
    
    // 检查 kexec 状态
    printf("\n当前 kexec 状态:\n");
    system("cat /sys/kernel/kexec_loaded 2>/dev/null || echo 'kexec_loaded 不可用'");
    system("cat /sys/kernel/kexec_crash_loaded 2>/dev/null || echo 'kexec_crash_loaded 不可用'");
    
    return 0;
}

示例2：完整的内核加载实现链接到标题

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/utsname.h>

#ifndef SYS_kexec_file_load
# define SYS_kexec_file_load 320
#endif

#define KEXEC_FILE_UNLOAD       0x00000001
#define KEXEC_FILE_ON_CRASH     0x00000002
#define KEXEC_FILE_NO_INITRAMFS 0x00000004

long kexec_file_load_wrapper(int kernel_fd, int initrd_fd,
                            unsigned long cmdline_len,
                            const char *cmdline_ptr,
                            unsigned long flags) {
    return syscall(SYS_kexec_file_load, kernel_fd, initrd_fd,
                   cmdline_len, cmdline_ptr, flags);
}

// 查找内核文件
int find_kernel_file(char *kernel_path, size_t path_size) {
    struct utsname uts;
    if (uname(&uts) == -1) {
        perror("uname 失败");
        return -1;
    }
    
    // 尝试常见的内核文件路径
    const char *paths[] = {
        "/boot/vmlinuz-%s",
        "/boot/vmlinux-%s",
        "/boot/Image-%s",
        "/boot/kernel-%s"
    };
    
    for (int i = 0; i < sizeof(paths)/sizeof(paths[0]); i++) {
        snprintf(kernel_path, path_size, paths[i], uts.release);
        if (access(kernel_path, R_OK) == 0) {
            printf("找到内核文件: %s\n", kernel_path);
            return 0;
        }
    }
    
    // 尝试不带版本号的文件名
    const char *simple_paths[] = {
        "/boot/vmlinuz",
        "/boot/vmlinux"
    };
    
    for (int i = 0; i < sizeof(simple_paths)/sizeof(simple_paths[0]); i++) {
        if (access(simple_paths[i], R_OK) == 0) {
            strncpy(kernel_path, simple_paths[i], path_size - 1);
            kernel_path[path_size - 1] = '\0';
            printf("找到内核文件: %s\n", kernel_path);
            return 0;
        }
    }
    
    printf("错误: 未找到合适的内核文件\n");
    return -1;
}

// 查找 initrd 文件
int find_initrd_file(char *initrd_path, size_t path_size) {
    struct utsname uts;
    if (uname(&uts) == -1) {
        perror("uname 失败");
        return -1;
    }
    
    // 尝试常见的 initrd 文件路径
    const char *paths[] = {
        "/boot/initrd.img-%s",
        "/boot/initramfs-%s.img",
        "/boot/initrd-%s.img",
        "/boot/initramfs-%s",
        "/boot/initrd",
        "/boot/initramfs"
    };
    
    for (int i = 0; i < sizeof(paths)/sizeof(paths[0]); i++) {
        snprintf(initrd_path, path_size, paths[i], uts.release);
        if (access(initrd_path, R_OK) == 0) {
            printf("找到 initrd 文件: %s\n", initrd_path);
            return 0;
        }
        
        // 尝试不带版本号的文件名
        if (i >= 4) {
            if (access(paths[i], R_OK) == 0) {
                strncpy(initrd_path, paths[i], path_size - 1);
                initrd_path[path_size - 1] = '\0';
                printf("找到 initrd 文件: %s\n", initrd_path);
                return 0;
            }
        }
    }
    
    printf("警告: 未找到 initrd 文件，将继续不使用 initrd\n");
    return 1;  // 表示未找到但不是错误
}

// 获取当前内核命令行
int get_current_cmdline(char **cmdline, size_t *cmdline_len) {
    FILE *fp = fopen("/proc/cmdline", "r");
    if (!fp) {
        perror("打开 /proc/cmdline 失败");
        return -1;
    }
    
    char *buffer = malloc(4096);
    if (!buffer) {
        fclose(fp);
        return -1;
    }
    
    size_t len = fread(buffer, 1, 4095, fp);
    fclose(fp);
    
    if (len > 0 && buffer[len - 1] == '\n') {
        buffer[len - 1] = '\0';
        len--;
    }
    
    *cmdline = buffer;
    *cmdline_len = len;
    return 0;
}

int main() {
    printf("=== kexec_file_load 完整实现演示 ===\n");
    
    // 检查权限
    if (geteuid() != 0) {
        printf("错误: 需要 root 权限\n");
        printf("提示: 请使用 sudo 运行此程序\n");
        return 1;
    }
    
    // 检查系统支持
    if (syscall(SYS_kexec_file_load, -1, -1, 0, NULL, 0) == -1 && errno == ENOSYS) {
        printf("错误: 系统不支持 kexec_file_load\n");
        return 1;
    }
    
    printf("✓ 系统支持 kexec_file_load\n");
    
    // 查找内核文件
    char kernel_path[512];
    if (find_kernel_file(kernel_path, sizeof(kernel_path)) == -1) {
        return 1;
    }
    
    // 打开内核文件
    int kernel_fd = open(kernel_path, O_RDONLY);
    if (kernel_fd == -1) {
        perror("打开内核文件失败");
        return 1;
    }
    
    printf("✓ 成功打开内核文件 (fd: %d)\n", kernel_fd);
    
    // 查找 initrd 文件
    char initrd_path[512];
    int initrd_fd = -1;
    int initrd_result = find_initrd_file(initrd_path, sizeof(initrd_path));
    
    if (initrd_result == 0) {
        initrd_fd = open(initrd_path, O_RDONLY);
        if (initrd_fd == -1) {
            printf("警告: 打开 initrd 文件失败: %s\n", strerror(errno));
        } else {
            printf("✓ 成功打开 initrd 文件 (fd: %d)\n", initrd_fd);
        }
    } else if (initrd_result == 1) {
        printf("ℹ 将不使用 initrd 文件\n");
    }
    
    // 获取当前内核命令行
    char *cmdline = NULL;
    size_t cmdline_len = 0;
    if (get_current_cmdline(&cmdline, &cmdline_len) == -1) {
        printf("警告: 无法获取当前内核命令行\n");
        cmdline = "";
        cmdline_len = 0;
    } else {
        printf("✓ 获取当前内核命令行成功\n");
        printf("  命令行: %s\n", cmdline);
    }
    
    // 显示加载信息
    printf("\n=== 加载信息 ===\n");
    printf("内核文件: %s\n", kernel_path);
    printf("initrd 文件: %s\n", initrd_result == 0 ? initrd_path : "无");
    printf("命令行长度: %zu 字节\n", cmdline_len);
    
    // 询问用户是否继续
    printf("\n是否继续加载内核? (y/N): ");
    char response;
    if (scanf(" %c", &response) != 1 || (response != 'y' && response != 'Y')) {
        printf("操作已取消\n");
        goto cleanup;
    }
    
    // 加载内核
    printf("正在加载内核...\n");
    long result = kexec_file_load_wrapper(kernel_fd, initrd_fd, 
                                         cmdline_len, cmdline, 0);
    
    if (result == -1) {
        printf("❌ 内核加载失败: %s\n", strerror(errno));
        switch (errno) {
            case EPERM:
                printf("  原因: 权限不足\n");
                break;
            case EINVAL:
                printf("  原因: 参数无效或文件格式错误\n");
                break;
            case ENOEXEC:
                printf("  原因: 内核镜像格式无效\n");
                break;
            case ENOMEM:
                printf("  原因: 内存不足\n");
                break;
            default:
                printf("  原因: 其他错误\n");
                break;
        }
    } else {
        printf("✅ 内核加载成功\n");
        printf("提示: 使用 'reboot -k' 或 'kexec -e' 来执行新内核\n");
    }
    
cleanup:
    // 清理资源
    if (kernel_fd != -1) close(kernel_fd);
    if (initrd_fd != -1) close(initrd_fd);
    if (cmdline) free(cmdline);
    
    return result == -1 ? 1 : 0;
}

示例3：错误处理和状态检查工具链接到标题

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>

#ifndef SYS_kexec_file_load
# define SYS_kexec_file_load 320
#endif

#define KEXEC_FILE_UNLOAD       0x00000001
#define KEXEC_FILE_ON_CRASH     0x00000002
#define KEXEC_FILE_NO_INITRAMFS 0x00000004

long kexec_file_load_wrapper(int kernel_fd, int initrd_fd,
                            unsigned long cmdline_len,
                            const char *cmdline_ptr,
                            unsigned long flags) {
    return syscall(SYS_kexec_file_load, kernel_fd, initrd_fd,
                   cmdline_len, cmdline_ptr, flags);
}

void check_kexec_status() {
    printf("=== kexec 状态检查 ===\n");
    
    // 检查 kexec 是否已加载
    FILE *fp = fopen("/sys/kernel/kexec_loaded", "r");
    if (fp) {
        char buf[16];
        if (fgets(buf, sizeof(buf), fp)) {
            printf("kexec 加载状态: %s", buf);
        }
        fclose(fp);
    } else {
        printf("kexec 加载状态: 无法读取\n");
    }
    
    // 检查崩溃内核状态
    fp = fopen("/sys/kernel/kexec_crash_loaded", "r");
    if (fp) {
        char buf[16];
        if (fgets(buf, sizeof(buf), fp)) {
            printf("崩溃内核状态: %s", buf);
        }
        fclose(fp);
    } else {
        printf("崩溃内核状态: 无法读取\n");
    }
    
    // 检查崩溃内存大小
    fp = fopen("/sys/kernel/kexec_crash_size", "r");
    if (fp) {
        char buf[32];
        if (fgets(buf, sizeof(buf), fp)) {
            printf("崩溃内存大小: %s", buf);
        }
        fclose(fp);
    } else {
        printf("崩溃内存大小: 无法读取\n");
    }
}

void test_error_conditions() {
    printf("\n=== 错误条件测试 ===\n");
    
    // 测试无效文件描述符
    printf("测试无效内核文件描述符 (-1):\n");
    long result = kexec_file_load_wrapper(-1, -1, 0, NULL, 0);
    if (result == -1) {
        printf("  结果: 失败 - %s\n", strerror(errno));
        switch (errno) {
            case EBADF:
                printf("    原因: 无效的文件描述符\n");
                break;
            case EINVAL:
                printf("    原因: 参数无效\n");
                break;
            default:
                printf("    原因: 其他错误\n");
                break;
        }
    } else {
        printf("  结果: 意外成功\n");
    }
    
    // 测试权限不足（非 root 用户）
    if (geteuid() != 0) {
        printf("测试权限不足情况:\n");
        printf("  当前用户不是 root，权限检查正常\n");
    }
    
    // 测试无效标志
    printf("测试无效标志位:\n");
    unsigned long invalid_flags = 0x80000000;  // 无效标志
    result = kexec_file_load_wrapper(-1, -1, 0, NULL, invalid_flags);
    if (result == -1) {
        printf("  结果: 失败 - %s\n", strerror(errno));
        if (errno == EINVAL) {
            printf("    原因: 无效的标志位\n");
        }
    }
}

void demonstrate_flags_usage() {
    printf("\n=== 标志位使用演示 ===\n");
    
    printf("支持的标志位:\n");
    printf("  KEXEC_FILE_UNLOAD (0x%08x): 卸载当前已加载的内核\n", 
           KEXEC_FILE_UNLOAD);
    printf("  KEXEC_FILE_ON_CRASH (0x%08x): 为崩溃转储加载内核\n", 
           KEXEC_FILE_ON_CRASH);
    printf("  KEXEC_FILE_NO_INITRAMFS (0x%08x): 不使用 initramfs\n", 
           KEXEC_FILE_NO_INITRAMFS);
    
    // 演示卸载标志
    printf("\n测试卸载标志:\n");
    long result = kexec_file_load_wrapper(-1, -1, 0, NULL, KEXEC_FILE_UNLOAD);
    if (result == -1) {
        if (errno == EINVAL) {
            printf("  结果: 卸载操作完成（如果没有已加载的内核）\n");
        } else {
            printf("  结果: %s\n", strerror(errno));
        }
    } else {
        printf("  结果: 成功卸载已加载的内核\n");
    }
}

void show_system_information() {
    printf("\n=== 系统信息 ===\n");
    
    // 显示内核版本
    printf("内核版本: ");
    system("uname -r");
    
    // 显示系统架构
    printf("系统架构: ");
    system("uname -m");
    
    // 显示可用内存
    printf("内存信息: ");
    system("free -h | grep Mem");
    
    // 显示 kexec 相关配置
    printf("kexec 配置:\n");
    system("sysctl -a 2>/dev/null | grep kexec | head -5 || echo '无相关配置'");
    
    // 显示启动参数
    printf("启动参数:\n");
    system("cat /proc/cmdline");
}

int main() {
    printf("=== kexec_file_load 错误处理和状态检查工具 ===\n");
    
    // 检查系统支持
    if (syscall(SYS_kexec_file_load, -1, -1, 0, NULL, 0) == -1 && errno == ENOSYS) {
        printf("错误: 系统不支持 kexec_file_load\n");
        return 1;
    }
    
    printf("✓ 系统支持 kexec_file_load\n");
    
    // 执行各种检查和测试
    check_kexec_status();
    test_error_conditions();
    demonstrate_flags_usage();
    show_system_information();
    
    // 提供使用建议
    printf("\n=== 使用建议 ===\n");
    printf("1. 始终在 root 权限下运行\n");
    printf("2. 确保内核文件和 initrd 文件存在且可读\n");
    printf("3. 验证内核命令行参数的正确性\n");
    printf("4. 检查系统是否有足够的内存\n");
    printf("5. 备份重要数据\n");
    printf("6. 测试新内核前先验证其完整性\n");
    
    return 0;
}

示例4：kexec 管理和监控工具链接到标题

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <time.h>
#include <sys/stat.h>

#ifndef SYS_kexec_file_load
# define SYS_kexec_file_load 320
#endif

#ifndef SYS_reboot
# define SYS_reboot 169
#endif

#define LINUX_REBOOT_MAGIC1 0xfee1dead
#define LINUX_REBOOT_MAGIC2 0x28121969
#define LINUX_REBOOT_CMD_KEXEC 0x45584543

#define KEXEC_FILE_UNLOAD       0x00000001
#define KEXEC_FILE_ON_CRASH     0x00000002

long kexec_file_load_wrapper(int kernel_fd, int initrd_fd,
                            unsigned long cmdline_len,
                            const char *cmdline_ptr,
                            unsigned long flags) {
    return syscall(SYS_kexec_file_load, kernel_fd, initrd_fd,
                   cmdline_len, cmdline_ptr, flags);
}

long reboot_wrapper(int magic1, int magic2, int cmd, void *arg) {
    return syscall(SYS_reboot, magic1, magic2, cmd, arg);
}

void show_kexec_statistics() {
    printf("=== kexec 统计信息 ===\n");
    
    // 显示加载历史（如果可用）
    printf("加载历史: ");
    system("dmesg | grep -i kexec | tail -10 || echo '无相关日志'");
    
    // 显示内存使用情况
    printf("\n内存使用情况:\n");
    system("cat /proc/meminfo | grep -E 'MemTotal|MemFree|MemAvailable'");
    
    // 显示 kexec 相关的 sysfs 信息
    printf("\n系统 kexec 信息:\n");
    system("ls /sys/kernel/kexec* 2>/dev/null | while read f; do "
           "echo \"$f: $(cat $f 2>/dev/null || echo '无法读取')\"; done || "
           "echo '无 kexec sysfs 信息'");
}

void interactive_kexec_manager() {
    int choice;
    
    while (1) {
        printf("\n=== kexec 管理菜单 ===\n");
        printf("1. 查看 kexec 状态\n");
        printf("2. 加载新内核\n");
        printf("3. 卸载当前内核\n");
        printf("4. 执行 kexec 重启\n");
        printf("5. 查看统计信息\n");
        printf("0. 退出\n");
        printf("请选择操作: ");
        
        if (scanf("%d", &choice) != 1) {
            printf("输入无效，请重新选择\n");
            while (getchar() != '\n');  // 清空输入缓冲区
            continue;
        }
        
        switch (choice) {
            case 1:
                system("cat /sys/kernel/kexec_loaded 2>/dev/null && "
                       "echo 'kexec 已加载' || echo 'kexec 未加载'");
                break;
                
            case 2:
                printf("加载新内核功能需要完整的文件路径和参数配置\n");
                printf("建议使用标准的 kexec 工具: kexec -l <kernel>\n");
                break;
                
            case 3:
                printf("正在卸载已加载的内核...\n");
                if (kexec_file_load_wrapper(-1, -1, 0, NULL, KEXEC_FILE_UNLOAD) == 0) {
                    printf("✅ 成功卸载内核\n");
                } else {
                    if (errno == EINVAL) {
                        printf("ℹ 没有已加载的内核需要卸载\n");
                    } else {
                        printf("❌ 卸载失败: %s\n", strerror(errno));
                    }
                }
                break;
                
            case 4:
                if (geteuid() != 0) {
                    printf("❌ 需要 root 权限执行 kexec 重启\n");
                    break;
                }
                
                printf("⚠ 警告: 这将立即重启系统到已加载的内核\n");
                printf("确认执行? (y/N): ");
                char confirm;
                if (scanf(" %c", &confirm) == 1 && (confirm == 'y' || confirm == 'Y')) {
                    printf("正在执行 kexec 重启...\n");
                    reboot_wrapper(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
                                  LINUX_REBOOT_CMD_KEXEC, NULL);
                    printf("❌ 重启失败: %s\n", strerror(errno));
                } else {
                    printf("操作已取消\n");
                }
                break;
                
            case 5:
                show_kexec_statistics();
                break;
                
            case 0:
                printf("退出 kexec 管理工具\n");
                return;
                
            default:
                printf("无效选择，请重新输入\n");
                break;
        }
    }
}

void security_analysis() {
    printf("\n=== kexec 安全分析 ===\n");
    
    // 检查 kexec 锁定状态
    FILE *fp = fopen("/proc/sys/kernel/kexec_load_disabled", "r");
    if (fp) {
        int disabled;
        if (fscanf(fp, "%d", &disabled) == 1) {
            printf("kexec 加载状态: %s\n", disabled ? "已禁用" : "已启用");
        }
        fclose(fp);
    } else {
        printf("kexec 加载状态: 无法检查\n");
    }
    
    // 检查数字签名支持
    printf("数字签名支持:\n");
    system("grep CONFIG_KEXEC_VERIFY_SIG /boot/config-$(uname -r) 2>/dev/null || "
           "echo '未找到签名配置信息'");
    
    // 检查安全启动状态
    printf("安全启动状态:\n");
    system("mokutil --sb-state 2>/dev/null || echo '安全启动信息不可用'");
    
    // 安全建议
    printf("\n安全建议:\n");
    printf("• 验证内核镜像的完整性\n");
    printf("• 使用数字签名保护的内核\n");
    printf("• 限制 kexec 权限\n");
    printf("• 启用审计日志\n");
    printf("• 定期更新内核\n");
}

void performance_analysis() {
    printf("\n=== kexec 性能分析 ===\n");
    
    printf("kexec 重启时间对比:\n");
    printf("  传统重启:     30-120 秒\n");
    printf("  kexec 重启:   2-10 秒\n");
    printf("  时间节省:     80-95%%\n");
    
    printf("\n影响因素:\n");
    printf("  • 内核镜像大小\n");
    printf("  • initrd 文件大小\n");
    printf("  • 系统内存容量\n");
    printf("  • 硬件配置\n");
    
    printf("\n最佳实践:\n");
    printf("  • 预加载常用内核\n");
    printf("  • 监控内存使用\n");
    printf("  • 定期清理旧内核\n");
    printf("  • 测试重启流程\n");
}

int main() {
    printf("=== kexec_file_load 管理和监控工具 ===\n");
    
    // 检查权限
    if (geteuid() != 0) {
        printf("警告: 某些功能需要 root 权限\n");
    }
    
    // 检查系统支持
    if (syscall(SYS_kexec_file_load, -1, -1, 0, NULL, 0) == -1 && errno == ENOSYS) {
        printf("错误: 系统不支持 kexec_file_load\n");
        printf("提示: 需要 Linux 内核 3.17 或更高版本\n");
        return 1;
    }
    
    printf("✓ 系统支持 kexec_file_load\n");
    
    // 显示基本信息
    printf("\n系统信息:\n");
    system("uname -a");
    
    // 执行安全分析
    security_analysis();
    
    // 执行性能分析
    performance_analysis();
    
    // 启动交互式管理器
    printf("\n启动交互式 kexec 管理器...\n");
    interactive_kexec_manager();
    
    return 0;
}

9. kexec_file_load 与 kexec_load 对比链接到标题

// kexec_load (传统接口)
long kexec_load(unsigned long entry, unsigned long nr_segments,
                struct kexec_segment *segments, unsigned long flags);

// kexec_file_load (现代接口)
long kexec_file_load(int kernel_fd, int initrd_fd,
                     unsigned long cmdline_len,
                     const char *cmdline_ptr,
                     unsigned long flags);

// 主要优势:
// 1. 更简单的接口
// 2. 内置安全检查
// 3. 支持数字签名验证
// 4. 更好的错误处理
// 5. 减少用户态复杂性

10. 实际应用场景链接到标题

场景1：高可用性集群链接到标题

void ha_cluster_kexec() {
    // 快速故障转移
    // 减少服务中断时间
}

场景2：内核开发测试链接到标题

void kernel_development_kexec() {
    // 快速测试新内核
    // 避免漫长重启过程
}

场景3：系统维护链接到标题

void system_maintenance_kexec() {
    // 快速内核升级
    // 最小化维护窗口
}

11. 注意事项链接到标题

使用 kexec_file_load 时需要注意：

内核版本: 需要 Linux 3.17 或更高版本
权限要求: 需要 CAP_SYS_BOOT 能力或 root 权限
文件格式: 内核和 initrd 文件必须是正确格式
内存需求: 需要足够的内存加载新内核
硬件兼容: 新内核必须与硬件兼容
安全考虑: 验证内核文件的完整性和来源
调试限制: kexec 后的调试信息可能有限

12. 系统配置检查链接到标题

# 检查 kexec 支持
grep CONFIG_KEXEC /boot/config-$(uname -r)

# 检查 kexec 状态
cat /sys/kernel/kexec_loaded

# 检查内存布局
cat /proc/iomem

# 检查系统日志
dmesg | grep -i kexec

总结链接到标题

kexec_file_load 是 Linux 系统中现代化的内核加载接口：

关键特性:

简单易用: 通过文件描述符直接加载
安全增强: 支持数字签名验证
参数完整: 支持完整的内核命令行
标志丰富: 提供多种控制选项

主要优势:

相比 kexec_load 接口更简洁
内置安全检查机制
更好的错误处理和诊断
减少用户态复杂性

使用场景:

高可用性系统快速重启
内核开发和测试
系统维护和升级
崩溃分析和调试

正确使用 kexec_file_load 可以显著提高 Linux 系统的可用性和维护效率，是企业级系统管理的重要工具。

92. kexec_file_load - 通过文件描述符加载内核镜像 链接到标题

1. 函数介绍 链接到标题

2. 函数原型 链接到标题

3. 功能 链接到标题

4. 参数 链接到标题

5. 返回值 链接到标题

6. 常见 errno 错误码 链接到标题

7. 相似函数，或关联函数 链接到标题

8. 示例代码 链接到标题

示例1：基本使用 - kexec_file_load 框架 链接到标题

示例2：完整的内核加载实现 链接到标题

示例3：错误处理和状态检查工具 链接到标题

示例4：kexec 管理和监控工具 链接到标题

9. kexec_file_load 与 kexec_load 对比 链接到标题

10. 实际应用场景 链接到标题

场景1：高可用性集群 链接到标题

场景2：内核开发测试 链接到标题

场景3：系统维护 链接到标题

11. 注意事项 链接到标题

12. 系统配置检查 链接到标题

总结 链接到标题