（二）内核那些事儿：程序启动到运行的完整过程

// 用户操作的多种形式
// 1. 图形界面双击 - 桌面环境处理
desktop_environment_click_handler(file_path) {
    // 桌面环境捕获双击事件
    check_executable_permission(file_path);  // 检查权限
    create_process_request(file_path, args, env);  // 创建进程请求
}

// 2. 命令行执行 - Shell处理
shell_command_parser("./program arg1 arg2") {
    // Shell解析命令行
    parse_command_line(command, &program, &args);
    exec_program(program, args, environment);
}

// 3. 程序化创建 - 直接系统调用
pid_t pid = fork();  // 创建子进程
if (pid == 0) {
    execve("/path/to/program", argv, envp);  // 替换进程映像
}

// 跨平台的进程创建抽象
struct process_creation_request {
    char *executable_path;      // 可执行文件路径
    char **arguments;           // 命令行参数
    char **environment;         // 环境变量
    int creation_flags;         // 创建标志
    security_context_t security; // 安全上下文
};

// Linux实现：fork + exec模式
int linux_create_process(struct process_creation_request *req) {
    pid_t pid = fork();         // 创建进程空间
    if (pid == 0) {
        // 子进程：替换程序映像
        execve(req->executable_path, req->arguments, req->environment);
    }
    return pid;  // 父进程：返回子进程PID
}

// Windows实现：直接创建模式
int windows_create_process(struct process_creation_request *req) {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    return CreateProcess(
        req->executable_path, req->arguments,
        NULL, NULL, FALSE, req->creation_flags,
        req->environment, NULL, &si, &pi
    );
}

// Linux的task_struct结构（核心字段）
struct task_struct {
    // 进程标识与关系
    pid_t pid, tgid, ppid;           // 进程ID、线程组ID、父进程ID
    struct list_head children;       // 子进程列表
    struct list_head sibling;        // 兄弟进程列表
    struct task_struct *parent;      // 父进程指针

    // 进程状态与调度
    int state;                       // 运行状态
    int prio, static_prio, normal_prio; // 优先级
    struct sched_entity se;          // 调度实体

    // 内存管理
    struct mm_struct *mm;            // 内存描述符

    // 文件系统与I/O
    struct fs_struct *fs;            // 文件系统信息
    struct files_struct *files;      // 打开的文件描述符表

    // 信号处理
    struct signal_struct *signal;    // 信号信息

    // CPU状态与时间统计
    struct thread_struct thread;     // 寄存器状态
    cputime_t utime, stime;         // 用户态和内核态时间

    int exit_code;                   // 退出码
};

// 进程创建的内核实现
struct task_struct *kernel_create_process(const char *filename,
                                        char **argv, char **envp) {
    // 1. 分配并初始化进程描述符
    struct task_struct *new_task = alloc_task_struct();

    // 2. 分配唯一进程ID
    new_task->pid = alloc_pid();

    // 3. 创建虚拟地址空间
    new_task->mm = create_address_space();

    // 4. 初始化文件描述符表
    new_task->files = create_files_struct();
    init_std_files(new_task->files);  // 设置stdin/stdout/stderr

    // 5. 建立进程关系树
    new_task->parent = current;
    add_to_process_tree(new_task);

    // 6. 注册到调度器
    sched_fork(new_task);

    // 7. 启动程序加载流程
    load_binary(new_task, filename, argv, envp);

    return new_task;
}

// 进程生命周期状态机
enum process_state {
    TASK_CREATED,      // 创建完成
    TASK_LOADING,      // 程序加载中
    TASK_READY,        // 就绪等待调度
    TASK_RUNNING,      // 正在运行
    TASK_BLOCKED,      // 阻塞等待
    TASK_ZOMBIE,       // 僵尸状态
    TASK_DEAD          // 已销毁
};

// 状态转换的触发事件
void process_state_transition(struct task_struct *task,
                            enum process_state new_state) {
    enum process_state old_state = task->state;

    switch (old_state) {
    case TASK_CREATED:
        if (new_state == TASK_LOADING) {
            start_program_loading(task);
        }
        break;
    case TASK_LOADING:
        if (new_state == TASK_READY) {
            add_to_ready_queue(task);
        }
        break;
    case TASK_READY:
        if (new_state == TASK_RUNNING) {
            context_switch_to(task);
        }
        break;
    // ...更多状态转换逻辑
    }

    task->state = new_state;
}

// 通用可执行文件结构抽象
struct executable_format {
    // 文件头：描述文件基本信息
    struct file_header {
        uint32_t magic_number;      // 文件类型标识
        uint16_t machine_type;      // 目标架构
        uint32_t entry_point;       // 程序入口地址
        uint32_t section_count;     // 段数量
    } header;

    // 段表：描述各个段的信息
    struct section_info {
        uint32_t type;              // 段类型（代码/数据/符号表）
        uint64_t file_offset;       // 文件中的偏移
        uint64_t virtual_addr;      // 加载到内存的虚拟地址
        uint64_t size;              // 段大小
        uint32_t permissions;       // 访问权限
    } sections[];

    // 实际数据：代码、数据、符号表等
    uint8_t section_data[];
};

// ELF文件的分层结构
struct elf_file_structure {
    Elf64_Ehdr header;              // ELF头部
    Elf64_Phdr program_headers[];   // 程序头表（运行时视图）
    Elf64_Shdr section_headers[];   // 节头表（链接时视图）

    // 关键段的内容
    struct {
        uint8_t *text;              // 代码段
        uint8_t *data;              // 已初始化数据段
        uint8_t *bss;               // 未初始化数据段
        Elf64_Sym *symtab;          // 符号表
        char *strtab;               // 字符串表
        Elf64_Dyn *dynamic;         // 动态链接信息
    } sections;
};

// ELF加载器的核心逻辑
int load_elf_binary(struct task_struct *task, const char *filename) {
    // 1. 读取并验证ELF头
    Elf64_Ehdr *elf_header = read_elf_header(filename);
    if (elf_header->e_ident[EI_MAG0] != ELFMAG0) {
        return -ENOEXEC;  // 非ELF文件
    }

    // 2. 创建虚拟地址空间布局
    setup_address_space(task, elf_header);

    // 3. 按程序头表映射各段
    Elf64_Phdr *phdr = read_program_headers(filename, elf_header);
    for (int i = 0; i < elf_header->e_phnum; i++) {
        if (phdr[i].p_type == PT_LOAD) {
            map_program_segment(task, &phdr[i], filename);
        }
    }

    // 4. 设置程序入口点
    task->thread.ip = elf_header->e_entry;

    // 5. 处理动态链接信息
    if (has_dynamic_linking(elf_header)) {
        setup_dynamic_linker(task, filename);
    }

    return 0;
}

// 虚拟地址空间的标准布局
struct virtual_address_space {
    // 64位Linux的典型布局
    struct memory_region {
        uint64_t start;
        uint64_t end;
        uint32_t permissions;
        char *description;
    } regions[] = {
        {0x400000,      0x600000,    PROT_READ|PROT_EXEC, "代码段"},
        {0x600000,      0x800000,    PROT_READ|PROT_WRITE, "数据段"},
        {0x800000,      0x800000,    PROT_READ|PROT_WRITE, "BSS段"},
        {0x800000,      堆顶,        PROT_READ|PROT_WRITE, "堆区"},
        {库区域开始,     库区域结束,   PROT_READ|PROT_EXEC, "共享库"},
        {0x7FFF80000000, 0x7FFFFFFFFFFF, PROT_READ|PROT_WRITE, "栈区"},
        {0x7FFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, PROT_NONE, "内核空间"}
    };
};

// 地址空间创建的详细过程
struct mm_struct *create_address_space(struct task_struct *task) {
    struct mm_struct *mm = kmalloc(sizeof(*mm), GFP_KERNEL);

    // 1. 初始化页表
    mm->pgd = allocate_page_directory();

    // 2. 设置地址空间范围
    mm->start_code = 0x400000;          // 代码段起始
    mm->end_code = 0x400000;            // 代码段结束（待加载时确定）
    mm->start_data = 0x600000;          // 数据段起始
    mm->end_data = 0x600000;            // 数据段结束（待加载时确定）
    mm->start_brk = 0x800000;           // 堆起始地址
    mm->brk = 0x800000;                 // 当前堆顶
    mm->start_stack = 0x7FFF80000000;   // 栈起始地址

    // 3. 初始化VMA链表
    INIT_LIST_HEAD(&mm->mmap);

    // 4. 设置内存统计
    mm->total_vm = 0;                   // 总虚拟内存
    mm->resident_set_size = 0;          // 物理内存使用

    task->mm = mm;
    return mm;
}

// 程序段到虚拟内存的映射
int map_program_segment(struct task_struct *task, Elf64_Phdr *phdr,
                       const char *filename) {
    struct vm_area_struct *vma;
    struct file *file;

    // 1. 打开可执行文件
    file = filp_open(filename, O_RDONLY, 0);
    if (IS_ERR(file)) {
        return PTR_ERR(file);
    }

    // 2. 创建VMA（虚拟内存区域）
    vma = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
    vma->vm_start = phdr->p_vaddr;
    vma->vm_end = phdr->p_vaddr + phdr->p_memsz;
    vma->vm_file = file;
    vma->vm_pgoff = phdr->p_offset >> PAGE_SHIFT;

    // 3. 设置访问权限
    vma->vm_flags = 0;
    if (phdr->p_flags & PF_R) vma->vm_flags |= VM_READ;
    if (phdr->p_flags & PF_W) vma->vm_flags |= VM_WRITE;
    if (phdr->p_flags & PF_X) vma->vm_flags |= VM_EXEC;

    // 4. 建立文件映射
    if (phdr->p_filesz > 0) {
        // 映射文件内容到虚拟内存
        do_mmap(vma->vm_file, vma->vm_start, phdr->p_filesz,
                vma->vm_flags, MAP_PRIVATE | MAP_FIXED, vma->vm_pgoff);
    }

    // 5. 处理BSS段（零初始化区域）
    if (phdr->p_memsz > phdr->p_filesz) {
        unsigned long bss_start = vma->vm_start + phdr->p_filesz;
        unsigned long bss_size = phdr->p_memsz - phdr->p_filesz;
        do_anonymous_mmap(bss_start, bss_size, vma->vm_flags);
    }

    // 6. 添加到进程的VMA链表
    insert_vm_struct(task->mm, vma);

    return 0;
}

// 代码段通常是只读的，可以被多个进程共享
struct code_segment {
    void *start_addr;        // 起始地址
    size_t size;            // 段大小
    int permissions;        // 权限（只读+可执行）
};

// 代码段在虚拟内存中的映射
mmap(0x400000,              // 建议的起始地址
     code_size,             // 映射大小
     PROT_READ | PROT_EXEC, // 只读可执行
     MAP_PRIVATE | MAP_FIXED, // 私有映射，固定地址
     fd,                    // 可执行文件描述符
     code_offset);          // 文件偏移

// 数据段：存储已初始化的全局变量和静态变量
struct data_segment {
    void *initialized_data;   // 已初始化数据起始地址
    size_t data_size;        // 数据段大小
    void *bss_start;         // BSS段起始地址
    size_t bss_size;         // BSS段大小
};

// BSS段在加载时被零初始化
void init_bss_segment(void *bss_start, size_t bss_size) {
    memset(bss_start, 0, bss_size);
}

// 堆空间的动态分配管理
struct heap_manager {
    void *heap_start;        // 堆起始地址
    void *heap_end;          // 堆结束地址
    void *brk;              // 当前堆顶位置
    struct free_block *free_list; // 空闲块列表
};

// malloc实现的简化版本
void *malloc(size_t size) {
    // 1. 查找足够大的空闲块
    struct free_block *block = find_free_block(size);

    if (!block) {
        // 2. 没有合适的空闲块，扩展堆
        if (extend_heap(size) < 0) {
            return NULL;
        }
        block = find_free_block(size);
    }

    // 3. 分割块并返回
    return split_block(block, size);
}

// 堆扩展系统调用
int brk(void *addr) {
    // 调整堆的结束位置
    current_process->heap_end = addr;
    return 0;
}

// 栈帧结构
struct stack_frame {
    void *return_address;    // 返回地址
    void *frame_pointer;     // 上一个栈帧指针
    // 局部变量和参数存储在这里
};

// 栈空间的特点
// - 向下增长（高地址向低地址）
// - 自动管理（函数调用时分配，返回时释放）
// - 速度快，但空间有限

// 栈溢出检测
void check_stack_overflow() {
    void *current_sp = get_stack_pointer();
    if (current_sp < stack_limit) {
        signal(SIGSEGV, stack_overflow_handler);
    }
}

// 静态链接：编译时决策
struct static_linking {
    // 优势
    char *advantages[] = {
        "程序自包含，无运行时依赖",
        "启动速度快，无加载开销",
        "部署简单，单一可执行文件"
    };

    // 劣势
    char *disadvantages[] = {
        "文件体积大，代码重复",
        "更新困难，需重新编译",
        "内存浪费，无法共享"
    };

    // 适用场景
    char *use_cases[] = {
        "嵌入式系统，资源受限",
        "系统关键程序，稳定性优先",
        "独立工具，简化部署"
    };
};

// 动态链接：运行时决策
struct dynamic_linking {
    // 优势
    char *advantages[] = {
        "代码共享，节省内存",
        "模块更新，无需重编译",
        "插件化架构，扩展性好"
    };

    // 劣势
    char *disadvantages[] = {
        "运行时依赖，部署复杂",
        "启动延迟，加载开销",
        "版本冲突，依赖地狱"
    };

    // 适用场景
    char *use_cases[] = {
        "大型应用，模块众多",
        "系统服务，资源共享",
        "开发调试，频繁更新"
    };
};

// 链接器符号解析过程
struct symbol_table {
    char *name;           // 符号名称
    void *address;        // 内存地址
    int  type;           // 符号类型（函数/变量）
    int  section;        // 所属段
};

// 静态链接过程：
// 1. 扫描所有目标文件，建立符号表
// 2. 解析未定义符号，从静态库中提取需要的模块
// 3. 重定位：调整所有符号的最终地址
// 4. 生成最终可执行文件

// PLT/GOT机制的实现原理
struct plt_got_mechanism {
    // PLT条目结构
    struct plt_entry {
        uint8_t jmp_instruction[2];     // jmp *(GOT+offset)
        uint32_t got_offset;            // GOT表偏移
        uint8_t push_instruction;       // push index
        uint32_t symbol_index;          // 符号索引
        uint8_t jmp_resolver[5];        // jmp PLT[0]
    } plt_table[];

    // GOT条目：初始指向PLT解析代码
    void **got_table;

    // 第一次调用流程
    void first_call_flow(int symbol_index) {
        // 1. 调用PLT条目
        // 2. 跳转到GOT条目（指向PLT解析代码）
        // 3. 压入符号索引，跳转到动态链接器
        // 4. 动态链接器解析符号地址
        // 5. 更新GOT条目为真实函数地址
        // 6. 跳转到真实函数
    }

    // 后续调用：直接通过GOT跳转到真实函数
};

// 动态链接器的符号解析
void *resolve_symbol(const char *symbol_name, struct loaded_library *libs) {
    // 1. 在已加载的库中搜索符号
    for (struct loaded_library *lib = libs; lib; lib = lib->next) {
        Elf64_Sym *sym = lookup_symbol_in_library(lib, symbol_name);
        if (sym && sym->st_shndx != SHN_UNDEF) {
            return (void *)(lib->base_address + sym->st_value);
        }
    }

    // 2. 符号未找到，可能需要加载新库
    char *library_path = find_library_for_symbol(symbol_name);
    if (library_path) {
        struct loaded_library *new_lib = load_dynamic_library(library_path);
        if (new_lib) {
            return resolve_symbol(symbol_name, new_lib);
        }
    }

    // 3. 符号解析失败
    fprintf(stderr, "Undefined symbol: %s\n", symbol_name);
    abort();
}

// 动态库管理系统
struct dynamic_library_manager {
    struct loaded_library *loaded_libs;    // 已加载库链表
    struct symbol_cache *symbol_cache;     // 符号缓存
    char **search_paths;                   // 搜索路径

    // 加载计数和依赖管理
    struct library_dependency {
        char *library_name;
        int reference_count;               // 引用计数
        struct loaded_library *lib;
        struct library_dependency *dependencies; // 依赖库列表
    } *dep_graph;
};

// 库加载的完整流程
struct loaded_library *load_dynamic_library(const char *lib_name) {
    // 1. 检查是否已加载
    struct loaded_library *existing = find_loaded_library(lib_name);
    if (existing) {
        existing->reference_count++;
        return existing;
    }

    // 2. 查找库文件
    char *lib_path = search_library_file(lib_name);
    if (!lib_path) {
        return NULL;
    }

    // 3. 读取并解析ELF文件
    int fd = open(lib_path, O_RDONLY);
    Elf64_Ehdr *elf_header = mmap(NULL, sizeof(*elf_header),
                                  PROT_READ, MAP_PRIVATE, fd, 0);

    // 4. 分配虚拟地址空间
    void *base_addr = allocate_library_space(elf_header);

    // 5. 映射库的各个段
    map_library_segments(fd, elf_header, base_addr);

    // 6. 处理重定位
    perform_relocations(elf_header, base_addr);

    // 7. 解析依赖库（递归加载）
    load_library_dependencies(elf_header, base_addr);

    // 8. 调用初始化函数
    call_library_init_functions(elf_header, base_addr);

    // 9. 注册到已加载库列表
    struct loaded_library *new_lib = register_loaded_library(lib_name, base_addr);

    close(fd);
    return new_lib;
}

// Windows DLL搜索顺序
HMODULE LoadLibraryEx(
    LPCSTR lpLibFileName,    // DLL名称
    HANDLE hFile,            // 保留参数
    DWORD  dwFlags          // 加载标志
);

// 搜索顺序：
// 1. 程序所在目录
// 2. 系统目录（System32）
// 3. Windows目录
// 4. 当前工作目录
// 5. PATH环境变量指定的目录

// 参数和环境变量在栈上的布局
/*
栈布局（从高地址到低地址）：
+------------------+
| 环境变量字符串    |  <- 实际的字符串内容
+------------------+
| 命令行参数字符串  |  <- 实际的字符串内容
+------------------+
| NULL             |  <- envp终止符
+------------------+
| envp[n]          |  <- 环境变量指针数组
| ...              |
| envp[0]          |
+------------------+
| NULL             |  <- argv终止符
+------------------+
| argv[n]          |  <- 参数指针数组
| ...              |
| argv[0]          |
+------------------+
| argc             |  <- 参数个数
+------------------+  <- 栈指针位置
*/

// execve系统调用的参数处理
int setup_arg_pages(struct linux_binprm *bprm) {
    unsigned long stack_top = STACK_TOP;
    unsigned long stack_base;
    int argc = bprm->argc;
    int envc = bprm->envc;

    // 计算需要的栈空间
    unsigned long arg_size = calculate_arg_size(bprm);

    // 在栈上为参数和环境变量分配空间
    stack_base = stack_top - arg_size;

    // 复制参数字符串
    copy_strings(argc, bprm->argv, stack_base);

    // 复制环境变量字符串
    copy_strings(envc, bprm->envp, stack_base);

    // 设置argc, argv, envp指针
    setup_arg_pointers(bprm, stack_base);

    return 0;
}

// 子进程继承父进程的环境变量
char **copy_environment(char **parent_env) {
    int count = 0;
    char **new_env;

    // 计算环境变量数量
    while (parent_env[count]) count++;

    // 分配新的环境变量数组
    new_env = malloc((count + 1) * sizeof(char*));

    // 复制所有环境变量
    for (int i = 0; i < count; i++) {
        new_env[i] = strdup(parent_env[i]);
    }
    new_env[count] = NULL;

    return new_env;
}

// main函数中访问参数和环境变量
int main(int argc, char *argv[], char *envp[]) {
    // argc: 命令行参数个数
    // argv: 命令行参数数组
    // envp: 环境变量数组

    printf("Program name: %s\n", argv[0]);
    printf("Number of arguments: %d\n", argc);

    // 遍历命令行参数
    for (int i = 1; i < argc; i++) {
        printf("Argument %d: %s\n", i, argv[i]);
    }

    // 遍历环境变量
    for (int i = 0; envp[i] != NULL; i++) {
        printf("Environment: %s\n", envp[i]);
    }

    // 或者使用getenv函数
    char *path = getenv("PATH");
    if (path) {
        printf("PATH: %s\n", path);
    }

    return 0;
}

// _start函数：程序启动的真正入口
void _start(void) {
    // 1. 从栈上获取参数信息
    // 获取栈上的参数
    register long *sp asm("rsp");       // 栈指针
    int argc = *sp;                     // 参数个数
    char **argv = (char **)(sp + 1);    // 参数数组
    char **envp = argv + argc + 1;      // 环境变量数组

    // 2. 调用C运行时库主函数
    __libc_start_main(
        main,                           // 用户main函数
        argc, argv,                     // 命令行参数
        __libc_csu_init,               // 初始化函数
        __libc_csu_fini,               // 清理函数
        0,                             // rtld_fini（动态链接器清理）
        sp                             // 栈结束位置
    );

    // 正常情况下不会到达这里
    __builtin_unreachable();
}

// __libc_start_main的完整实现
STATIC int LIBC_START_MAIN(int (*main)(int, char **, char **),
                          int argc, char **argv,
                          __typeof(main) init,
                          void (*fini)(void),
                          void (*rtld_fini)(void),
                          void *stack_end) {
    // 1. 设置程序环境变量
    __environ = __find_environ(argv);
    __progname = __get_program_name(argv[0]);

    // 2. 安全相关初始化
    __security_init();

    // 3. 初始化线程库
    __pthread_initialize_minimal();

    // 4. 设置栈保护
    __stack_chk_guard_setup();

    // 5. 初始化标准I/O
    __stdio_init();

    // 6. 信号处理初始化
    __signal_init();

    // 7. 设置程序退出处理
    if (rtld_fini) {
        __cxa_atexit((void (*)(void *))rtld_fini, NULL, NULL);
    }
    if (fini) {
        __cxa_atexit((void (*)(void *))fini, NULL, NULL);
    }

    // 8. 调用全局构造函数
    if (init) {
        init(argc, argv, __environ);
    }

    // 9. 调用用户main函数
    int result = main(argc, argv, __environ);

    // 10. 程序退出清理
    exit(result);
}

// 全局构造函数的管理
struct global_constructor {
    void (*constructor)(void);          // 构造函数指针
    void (*destructor)(void);           // 析构函数指针
    int priority;                       // 优先级
};

// 构造函数表（由链接器生成）
extern struct global_constructor __init_array_start[];
extern struct global_constructor __init_array_end[];

// __libc_csu_init：调用全局构造函数
void __libc_csu_init(int argc, char **argv, char **envp) {
    // 1. 调用.preinit_array中的函数
    for (init_fn *fn = __preinit_array_start; fn < __preinit_array_end; fn++) {
        (*fn)(argc, argv, envp);
    }

    // 2. 调用.init段中的函数
    _init();

    // 3. 调用.init_array中的构造函数（按优先级排序）
    for (init_fn *fn = __init_array_start; fn < __init_array_end; fn++) {
        (*fn)();
    }
}

// __libc_csu_fini：调用全局析构函数
void __libc_csu_fini(void) {
    // 按相反顺序调用析构函数
    for (fini_fn *fn = __fini_array_end - 1; fn >= __fini_array_start; fn--) {
        (*fn)();
    }

    // 调用.fini段中的函数
    _fini();
}

// 内核完成程序加载后的最后步骤
void start_user_program(struct task_struct *task) {
    struct pt_regs *regs = task_pt_regs(task);

    // 1. 设置用户态CPU状态
    regs->ip = task->mm->start_code;        // 程序入口点（_start）
    regs->sp = task->mm->start_stack;       // 栈指针
    regs->flags = X86_EFLAGS_IF;            // 开启中断

    // 2. 设置段寄存器
    regs->cs = USER_CS;                     // 用户代码段
    regs->ds = USER_DS;                     // 用户数据段
    regs->es = USER_DS;
    regs->ss = USER_DS;                     // 用户栈段

    // 3. 清除调试寄存器
    clear_debug_registers(task);

    // 4. 设置浮点状态
    fpu_init();

    // 5. 通过系统调用返回机制跳转到用户态
    // 这将导致CPU从内核态切换到用户态，并跳转到_start函数
    force_iret();
}

// 监控进程内存使用情况
struct memory_stats {
    size_t code_size;       // 代码段大小
    size_t data_size;       // 数据段大小
    size_t heap_size;       // 堆大小
    size_t stack_size;      // 栈大小
    size_t shared_lib_size; // 共享库大小
};

// 内存分配跟踪
void track_memory_allocation(void *ptr, size_t size) {
    struct allocation_record *record = malloc(sizeof(*record));
    record->ptr = ptr;
    record->size = size;
    record->timestamp = get_current_time();
    record->stack_trace = capture_stack_trace();

    // 添加到分配记录链表
    add_allocation_record(record);
}

// 检查内存泄漏
void check_memory_leaks() {
    struct allocation_record *record = allocation_list;
    while (record) {
        if (!is_freed(record->ptr)) {
            printf("Memory leak detected: %p (%zu bytes)\n",
                   record->ptr, record->size);
            print_stack_trace(record->stack_trace);
        }
        record = record->next;
    }
}

// 程序正常退出的清理过程
void program_exit(int exit_code) {
    // 1. 调用atexit注册的函数
    call_exit_handlers();

    // 2. 刷新并关闭标准I/O
    fflush(stdout);
    fflush(stderr);
    fclose(stdin);
    fclose(stdout);
    fclose(stderr);

    // 3. 调用全局析构函数
    call_global_destructors();

    // 4. 释放动态分配的内存
    cleanup_heap();

    // 5. 通知父进程
    sys_exit(exit_code);
}

// 内核清理进程资源
void do_exit(long code) {
    struct task_struct *tsk = current;

    // 1. 设置退出状态
    tsk->exit_code = code;

    // 2. 关闭所有打开的文件
    exit_files(tsk);

    // 3. 释放内存空间
    exit_mm(tsk);

    // 4. 释放IPC资源
    exit_sem(tsk);

    // 5. 通知父进程
    exit_notify(tsk);

    // 6. 切换到僵尸状态
    tsk->state = TASK_ZOMBIE;

    // 7. 调度其他进程
    schedule();
}