《从零手写操作系统 (30)：环境变量与进程上下文——export/unset与继承语义》

前言：从"裸执行体"到"携带上下文的计算单元"

在前面的章节中，我们的Shell已经能解析复杂命令、管理作业、构建I/O拓扑。但如果你尝试运行ls /usr/bin，它会报错"command not found"；运行vim，它不知道你的HOME目录在哪；编译程序时，gcc找不到头文件路径。这是因为我们的进程是"失忆"的------它们没有环境块（Environment Block）。

环境变量不是简单的"全局变量"，而是进程创建时继承、运行时可修改、跨exec传递的键值对上下文。它是Unix进程间隐式通信的核心协议：PATH决定了命令搜索范围，HOME定义了用户空间锚点，LD_LIBRARY_PATH控制动态链接行为，LANG影响本地化输出。没有环境变量，每个程序都必须硬编码所有配置路径，Unix的组合哲学将彻底崩塌。

本章里程碑：

• ✅ 内核execve支持envp参数传递与环境块拷贝
• ✅ 用户态environ全局指针与getenv/setenv/putenv实现
• ✅ Shell export/unset/env命令与变量展开（ VAR/VAR/ {VAR}）
• ✅ fork时环境块深拷贝 vs exec时替换语义
• ✅ PATH搜索算法：冒号分隔路径列表遍历
• ✅ 验证：脚本中export的变量在子进程中可见，unset后消失

---

核心概念：环境变量不是"配置"，而是"进程身份的一部分"

环境块的内存布局与ABI约定

许多初学者以为环境变量是内核维护的全局表。实际上，环境块是用户态内存中的一段连续字符串数组，位于进程栈顶之上（或单独mmap区域）。其布局为：

[ "KEY1=VAL1\0" ][ "KEY2=VAL2\0" ] ... [ NULL ]
      ↑               ↑                  ↑
   envp[0]         envp[1]            envp[n]=NULL

execve(path, argv, envp)系统调用将这段内存完整拷贝到新进程的地址空间。内核不解释内容，只做字节级复制。这意味着环境变量的语法（KEY=VALUE）、编码（UTF-8）、排序完全由用户态约定。如果你的内核试图解析或验证环境变量，就破坏了"内核无关性"原则，也失去了对非标准环境的兼容性。

⚠️ 关键洞察 ：环境变量是进程创建时的快照，而非实时共享状态。父进程修改自己的环境不会影响已fork的子进程；子进程的export也不会回传父进程。这种单向继承语义是Unix安全模型的基石：防止子进程污染父进程上下文，也避免并发修改导致的数据竞争。如果你的实现让父子共享环境块指针，就会引入难以调试的竞态条件和安全漏洞。

export vs 普通变量：Shell层与进程层的边界

Shell内部维护两套变量：shell变量 （仅当前Shell可见）和环境变量 （export后对子进程可见）。VAR=value只设置shell变量；export VAR将其标记为"需传递给子进程"；export VAR=value一步完成两者。这个区分至关重要：如果所有shell变量都自动进入envp，子进程的环境块会被大量临时变量（如循环计数器i）污染，浪费内存且可能意外覆盖关键变量。

unset的语义同样分层 ：unset VAR同时移除shell变量和环境标记；但如果VAR是通过envp继承而来且未被export过，unset只影响当前Shell，不影响后续从同一父进程fork的其他兄弟进程（因为它们各自持有独立副本）。

PATH搜索：安全与便利的永恒博弈

当用户输入ls而非/bin/ls时，Shell必须按PATH顺序搜索可执行文件。但PATH搜索有严格的安全约束：

1. 空路径分量视为当前目录（POSIX规定），但这是重大安全隐患
2. 相对路径分量应被忽略或警告（现代Shell默认行为）
3. 搜索到的文件必须有执行权限（X bit检查）
4. SUID/SGID程序不应使用用户提供的PATH（防提权攻击）

教学实现中至少要做到1和3；生产级实现还需处理2和4。永远不要信任用户控制的PATH来查找特权程序。

---

实战代码

内核execve环境块传递

// kernel/exec.c
int do_execve(const char *path, char **argv, char **envp) {
    // ... 原有ELF加载逻辑 ...
    
    // ★ 计算环境块总大小（含所有字符串+指针数组+NULL终止符）
    size_t env_size = 0;
    int envc = 0;
    if (envp) {
        for (; envp[envc]; envc++) {
            env_size += strlen(envp[envc]) + 1; // 字符串长度+\0
        }
        env_size += (envc + 1) * sizeof(char *); // 指针数组+NULL
    }
    
    // ★ 在新进程用户栈上分配环境块空间
    uint32_t new_esp = frame->esp;
    new_esp -= env_size;
    new_esp &= ~0xF; // 16字节对齐
    
    char **new_envp = NULL;
    if (envc > 0) {
        new_envp = (char **)new_esp;
        char *str_area = (char *)(new_envp + envc + 1);
        
        // ★ 逐字符串拷贝并重建指针数组
        for (int i = 0; i < envc; i++) {
            size_t len = strlen(envp[i]) + 1;
            memcpy(str_area, envp[i], len);
            new_envp[i] = str_area;
            str_area += len;
        }
        new_envp[envc] = NULL;
    }
    
    // 更新栈帧ESP，使新进程启动时能看到envp
    frame->esp = new_esp;
    
    // ★ 将new_envp作为第三个参数传递给_start
    // （x86 cdecl: push envp; push argv; push argc; call _start）
    // 简化：假设CRT startup code从栈上正确提取
    
    return 0;
}

用户态环境操作库

// user/libc/environ.c
#include <string.h>
#include <stdlib.h>

extern char **environ; // CRT启动时由内核传入

char *getenv(const char *name) {
    size_t len = strlen(name);
    for (char **e = environ; *e; e++) {
        if (strncmp(*e, name, len) == 0 && (*e)[len] == '=')
            return *e + len + 1;
    }
    return NULL;
}

// ★ setenv: 设置或添加环境变量
int setenv(const char *name, const char *value, int overwrite) {
    if (!overwrite && getenv(name)) return 0;
    
    size_t name_len = strlen(name);
    size_t val_len = strlen(value);
    char *new_entry = malloc(name_len + val_len + 2);
    sprintf(new_entry, "%s=%s", name, value);
    
    // 查找现有条目并替换
    for (char **e = environ; *e; e++) {
        if (strncmp(*e, name, name_len) == 0 && (*e)[name_len] == '=') {
            free(*e);
            *e = new_entry;
            return 0;
        }
    }
    
    // 未找到，扩展environ数组
    int count = 0;
    while (environ[count]) count++;
    
    char **new_environ = realloc(environ, (count + 2) * sizeof(char *));
    if (!new_environ) { free(new_entry); return -1; }
    
    new_environ[count] = new_entry;
    new_environ[count + 1] = NULL;
    environ = new_environ;
    return 0;
}

// ★ unsetenv: 移除环境变量
void unsetenv(const char *name) {
    size_t len = strlen(name);
    char **dst = environ;
    for (char **src = environ; *src; src++) {
        if (!(strncmp(*src, name, len) == 0 && (*src)[len] == '=')) {
            *dst++ = *src;
        } else {
            free(*src);
        }
    }
    *dst = NULL;
}

Shell变量管理与展开

// user/shell/variables.c
#include "shell.h"

#define MAX_VARS 256

typedef struct {
    char *name;
    char *value;
    int exported; // ★ 是否标记为export
} shell_var_t;

static shell_var_t vars[MAX_VARS];
static int num_vars = 0;

// ★ export命令实现
int cmd_export(const char *arg) {
    char name[256], value[1024];
    
    if (strchr(arg, '=')) {
        // export KEY=VALUE
        parse_assignment(arg, name, value);
        set_shell_var(name, value, 1);
    } else {
        // export KEY (标记已有变量)
        shell_var_t *v = find_var(arg);
        if (v) v->exported = 1;
    }
    return 0;
}

// ★ unset命令实现
int cmd_unset(const char *name) {
    for (int i = 0; i < num_vars; i++) {
        if (strcmp(vars[i].name, name) == 0) {
            free(vars[i].name);
            free(vars[i].value);
            memmove(&vars[i], &vars[i+1], 
                    (num_vars - i - 1) * sizeof(shell_var_t));
            num_vars--;
            return 0;
        }
    }
    return 0;
}

// ★ 构造envp数组供exec使用
char **build_envp(void) {
    int count = 0;
    for (int i = 0; i < num_vars; i++)
        if (vars[i].exported) count++;
    
    char **envp = malloc((count + 1) * sizeof(char *));
    int idx = 0;
    for (int i = 0; i < num_vars; i++) {
        if (vars[i].exported) {
            size_t len = strlen(vars[i].name) + strlen(vars[i].value) + 2;
            envp[idx] = malloc(len);
            sprintf(envp[idx], "%s=%s", vars[i].name, vars[i].value);
            idx++;
        }
    }
    envp[idx] = NULL;
    return envp;
}

// ★ 变量展开：$VAR 和 ${VAR}
char *expand_variables(const char *input) {
    char result[4096];
    int rpos = 0;
    
    for (int i = 0; input[i]; ) {
        if (input[i] == '$') {
            i++;
            char varname[256];
            int vlen = 0;
            
            if (input[i] == '{') {
                // ${VAR}形式
                i++;
                while (input[i] && input[i] != '}' && vlen < 255)
                    varname[vlen++] = input[i++];
                if (input[i] == '}') i++;
            } else {
                // $VAR形式（字母数字下划线）
                while ((isalnum(input[i]) || input[i] == '_') && vlen < 255)
                    varname[vlen++] = input[i++];
            }
            varname[vlen] = '\0';
            
            // 查找并替换
            const char *val = get_shell_var(varname);
            if (val) {
                int vlen2 = strlen(val);
                memcpy(result + rpos, val, vlen2);
                rpos += vlen2;
            }
        } else {
            result[rpos++] = input[i++];
        }
    }
    result[rpos] = '\0';
    return strdup(result);
}

PATH搜索实现

// user/shell/path.c
#include <sys/stat.h>

// ★ 按PATH搜索可执行文件
char *find_in_path(const char *cmd) {
    // 绝对/相对路径直接检查
    if (strchr(cmd, '/')) {
        if (access(cmd, X_OK) == 0) return strdup(cmd);
        return NULL;
    }
    
    const char *path = getenv("PATH");
    if (!path) path = "/bin:/usr/bin"; // 默认安全PATH
    
    char buf[1024];
    const char *p = path;
    
    while (*p) {
        const char *colon = strchr(p, ':');
        int dir_len = colon ? (colon - p) : strlen(p);
        
        // ★ 跳过空分量和相对路径（安全加固）
        if (dir_len == 0 || (p[0] != '/' && p[0] != '.')) {
            p = colon ? colon + 1 : p + dir_len;
            continue;
        }
        
        snprintf(buf, sizeof(buf), "%.*s/%s", dir_len, p, cmd);
        
        struct stat st;
        if (stat(buf, &st) == 0 && 
            (st.st_mode & S_IXUSR) && // 检查执行权限
            S_ISREG(st.st_mode)) {     // 必须是普通文件
            return strdup(buf);
        }
        
        p = colon ? colon + 1 : p + dir_len;
    }
    return NULL;
}

---

关键细节解析

1. 为什么execve要深拷贝环境块而非共享指针？

因为新进程拥有独立的虚拟地址空间，旧进程的指针在新空间中无效。即使使用共享内存，也会引入并发修改风险：父进程在子进程exec期间修改环境变量，可能导致子进程读到半更新的损坏数据。深拷贝保证了环境块的原子性和隔离性。这也是为什么setenv/putenv在多线程程序中不安全------它们修改的是进程全局状态，而execve的拷贝发生在fork之后、exec之前的单线程窗口内。

2. 为什么Shell变量和导出变量要分开存储？

因为两者的生命周期和作用域完全不同。Shell变量可以是任意字符串（包括含空格、特殊字符的值），而环境变量受限于KEY=VALUE格式且不能包含NUL。更重要的是，并非所有Shell变量都应该泄露到子进程环境中。例如PS1提示符、HISTFILE历史文件路径等纯Shell配置，对子进程毫无意义且可能造成干扰。分离存储使得Shell可以精确控制哪些变量参与继承，也避免了每次变量赋值都触发environ数组realloc的性能开销。

3. 为什么变量展开要在词法分析之后、单词分割之前？

考虑echo $FILES，若FILES="a b c.txt"，展开后应成为三个独立参数还是单个含空格的参数？POSIX规定：变量展开的结果仍要经历单词分割（IFS拆分）和通配符展开 。这意味着"$FILES"（加引号）抑制分割，得到单参数；$FILES（无引号）则拆分为三参数。如果展开在词法分析阶段过早执行，就无法区分引号上下文，导致行为错误。正确的pipeline是：词法分析→引号处理→变量展开→单词分割→通配符展开→exec。

---

调试Checklist：环境变量排查

症状	可能原因	排查方法
子进程getenv返回NULL	export未标记/envp未传递给execve/环境变量名拼写错	dump build_envp()输出确认变量存在；kprintf execve中envc和env_size；验证set_shell_var时exported标志置1
unset后变量仍存在	unsetenv未释放内存/environ数组未压缩/Shell变量表未同步	hexdump environ数组确认条目已移除；验证unset同时操作vars\[\]和environ；测试连续unset多个变量
$ VAR展开为空	变量名提取逻辑错/未处理 $ {}语法/展开时机过早	dump expand_variables输入输出；测试 $ {VAR_WITH_UNDERSCORE}；确认展开在引号处理后执行
PATH搜索找到错误程序	未检查X权限/相对路径未过滤/搜索顺序错误	kprintf find_in_path每步候选路径；验证stat+S_IXUSR检查；测试PATH="/tmp:/bin"时/tmp下的同名文件优先级
execve后栈崩溃	envp拷贝大小计算错/栈未对齐/new_envp指针偏移	dump新进程ESP和envp0地址；验证env_size包含所有\0和NULL指针；确认16字节对齐掩码正确
多线程setenv后crash	environ realloc非原子/其他线程正遍历environ	确认单线程初始化阶段完成所有setenv；或使用锁保护environ访问；测试pthread_create前预设环境

🔧 黄金法则 ：环境变量调试的终极武器是环境块完整性校验函数 。实现validate_environ()，遍历整个environ数组：①每个条目必须包含'='；②KEY部分非空且不含'='；③无重复KEY（除非允许覆盖）；④数组以NULL终止；⑤所有指针在合法用户空间范围内。环境变量bug几乎总是"内存布局损坏"：realloc后旧指针悬垂、拷贝时遗漏\0导致字符串粘连、栈对齐错误使CRT startup读越界。只有结构化的完整性检查才能发现这些底层内存问题。不要只看getenv返回值------那是冰山一角，水面下的内存布局才是真相。

---

本章小结与下一步

今天我们让进程从"裸执行体"进化为"携带上下文的计算单元"：

• ✅ 内核execve完整支持envp传递与环境块深拷贝
• ✅ 用户态实现了符合POSIX的getenv/setenv/unsetenv
• ✅ Shell支持export/unset命令与 VAR/VAR/ {VAR}变量展开
• ✅ PATH搜索算法兼顾功能与安全约束
• ✅ 验证了变量继承、修改、删除的正确语义链

从此，你的操作系统拥有了完整的进程上下文传递机制。当你第一次看到export的变量在子脚本中生效、PATH自动定位命令、unset干净移除变量时，你见证的是OS从"能执行程序"到"能运行真实Unix软件生态"的最后壁垒被攻破。

下一章预告：《信号进阶：sigaction/sigprocmask与可靠信号处理》

当前的信号处理仅支持简单handler注册，无法阻塞信号、无法获取信号元信息、无法原子地修改信号掩码。下一章将实现完整的POSIX信号API，让你的OS支持可靠的异步事件处理和进程间通信。

---

参考资料

• POSIX.1-2017: Environment Variables, execve(), getenv()
• Linux Kernel: fs/exec.c (copy_strings, create_elf_tables)
• GNU Bash Manual: Shell Parameters, Environment
• musl libc: src/env/getenv.c, src/env/setenv.c
• 本系列完整代码：你的GitHub仓库链接（Commit: e1n2v3p）

---

📝 作者注 ：这是《从零手写操作系统》系列的第30篇。环境变量看似基础，实则是连接内核、C运行时、Shell三层的隐形纽带 。任何一层对环境块布局的理解偏差，都会导致"程序能跑但行为诡异"的幽灵bug。强烈建议先用最简单的单变量传递验证execve-envp通路，再逐步增加多变量、长值、特殊字符等边界情况。把"内核拷贝"、"libc操作"、"Shell管理"分成三个独立验证层，并用hexdump反复检查每一步的内存布局，是避免在三层接口缝隙中坠落的关键纪律。 下一章，我们让信号从"粗暴中断"走向"可靠异步通信"！