第7章：进程环境（Process Environment）

一、导读

1.1 本章学习目标

第7章讲解进程的运行环境，包括main函数的参数、进程的终止方式、命令行参数处理、环境变量管理、以及进程的内存布局。这些是理解进程生命周期的基础。从C程序进入main函数的那一刻起，到进程最终终止，中间经历了哪些步骤？进程可以使用哪些资源？这些问题都将在本章得到解答。

本章的核心学习目标包括：

理解main函数的参数：argc、argv、environ分别代表什么？如何正确处理命令行参数？
掌握进程的终止方式：正常退出（return/exit）和异常退出（abort/信号）的区别
学会注册终止处理函数：atexit如何注册清理函数？多个清理函数的执行顺序是什么？
掌握环境变量操作：getenv、setenv、unsetenv的使用方法
理解进程的内存布局：文本段、数据段、BSS段、堆、栈各自存储什么内容？
了解C程序的启动和终止过程：从内核加载可执行文件到调用main函数，中间发生了什么？

1.2 为什么本章如此重要

进程环境是理解UNIX进程模型的基础。每个C程序都从main函数开始，到某种方式终止，但很多程序员对main函数前后的过程知之甚少。理解这些内容有助于：

编写更健壮的程序（正确处理命令行参数、环境变量）
实现优雅的程序退出（注册清理函数、释放资源）
调试内存相关问题（理解内存布局、定位内存泄漏）
编写可移植的程序（遵循POSIX标准的环境变量规范）

此外，进程的内存布局是理解后续章节（如动态内存分配、栈溢出、缓冲区溢出攻击）的基础。

1.3 核心问题引导

在阅读本章时，请带着以下问题思考：

main函数之前发生了什么？C运行时启动代码做了什么？

exit和_exit有什么区别？为什么exit会刷新标准I/O缓冲区而_exit不会？

atexit注册的多个清理函数按什么顺序执行？为什么是LIFO（后进先出）？

环境变量是如何在进程间传递的？setenv修改的环境变量对子进程有影响吗？

进程的堆和栈分别向哪个方向增长？它们之间有什么关系？

为什么malloc分配的内存不会在free后立即归还给操作系统？

二、核心概念详解

2.1 main函数的参数

C程序的main函数可以接收三个参数：

int main(int argc, char *argv[], char *envp[]);

argc：命令行参数的个数（包括程序名本身）
argv：命令行参数数组，以NULL结尾
envp：环境变量数组，以NULL结尾（也可以使用全局变量environ）

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Program name: %s\n", argv[0]);
    printf("Number of arguments: %d\n", argc);
    
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

bash

$ ./myprogram hello world
Program name: ./myprogram
Number of arguments: 3
argv[0] = ./myprogram
argv[1] = hello
argv[2] = world

2.1.1 命令行参数解析

getopt函数用于解析命令行选项：

#include <unistd.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
    int opt;
    int verbose = 0;
    char *output = NULL;
    
    while ((opt = getopt(argc, argv, "vo:h")) != -1) {
        switch (opt) {
        case 'v':
            verbose = 1;
            break;
        case 'o':
            output = optarg;
            break;
        case 'h':
            printf("Usage: %s [-v] [-o output] [files...]\n", argv[0]);
            return 0;
        default:
            fprintf(stderr, "Usage: %s [-v] [-o output] [files...]\n", argv[0]);
            return 1;
        }
    }
    
    if (verbose) {
        printf("Verbose mode enabled\n");
    }
    if (output) {
        printf("Output file: %s\n", output);
    }
    
    // 处理剩余的非选项参数
    for (int i = optind; i < argc; i++) {
        printf("File: %s\n", argv[i]);
    }
    
    return 0;
}

bash

$ ./myprogram -v -o result.txt file1.txt file2.txt
Verbose mode enabled
Output file: result.txt
File: file1.txt
File: file2.txt

2.2 进程的终止

C程序有5种正常终止方式和3种异常终止方式：

2.2.1 正常终止

方式	描述
从`main`返回	`return`语句
调用`exit`	执行清理操作后终止
调用`_exit`/`_Exit`	直接终止，不执行清理

#include <stdlib.h>
#include <unistd.h>

int main() {
    // 方式1：从main返回
    return 0;
    
    // 方式2：调用exit
    exit(0);  // 执行清理：atexit函数、刷新缓冲区
    
    // 方式3：调用_exit
    _exit(0);  // 直接终止，不执行清理
}

exit与_exit的区别：

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

int main() {
    printf("Hello");  // 没有\n，数据在缓冲区中
    
    // 使用exit：缓冲区被刷新，"Hello"被输出
    exit(0);
    
    // 使用_exit：缓冲区不被刷新，"Hello"不会输出
    // _exit(0);
}

exit的清理步骤：

调用所有由atexit注册的清理函数（LIFO顺序）

关闭所有打开的流（刷新缓冲区）

删除由tmpfile创建的临时文件

调用_exit终止进程

2.2.2 异常终止

方式	描述
调用`abort`	发送SIGABRT信号
被信号杀死	接收到终止信号（如SIGKILL、SIGSEGV）
最后一个线程取消	线程取消导致进程终止

#include <stdlib.h>

int main() {
    // abort发送SIGABRT信号，默认产生core dump
    abort();
}

2.3 atexit注册终止处理函数

#include <stdlib.h>

int atexit(void (*func)(void));

atexit注册在exit时调用的清理函数。POSIX要求至少支持注册32个清理函数。清理函数按注册的逆序（LIFO）调用。

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

void cleanup1(void) {
    printf("Cleanup 1: closing database\n");
}

void cleanup2(void) {
    printf("Cleanup 2: releasing resources\n");
}

void cleanup3(void) {
    printf("Cleanup 3: saving state\n");
}

int main() {
    atexit(cleanup1);
    atexit(cleanup2);
    atexit(cleanup3);
    
    printf("Main program done\n");
    return 0;
    
    // 输出顺序：
    // Main program done
    // Cleanup 3: saving state
    // Cleanup 2: releasing resources
    // Cleanup 1: closing database
}

注意事项：

atexit函数中不能调用exit，否则会导致无限递归
_exit和abort不会调用atexit注册的函数
同一个函数可以被注册多次，每次都会被调用

2.4 环境变量

2.4.1 访问环境变量

环境变量通过environ全局变量或getenv函数访问：

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

extern char **environ;

int main() {
    // 方法1：使用getenv
    char *home = getenv("HOME");
    printf("HOME = %s\n", home);
    
    // 方法2：遍历environ
    printf("\nAll environment variables:\n");
    for (char **env = environ; *env != NULL; env++) {
        printf("%s\n", *env);
    }
    
    return 0;
}

2.4.2 修改环境变量

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

int main() {
    // 设置环境变量（第三个参数为1表示覆盖已有值）
    setenv("MY_VAR", "hello", 1);
    printf("MY_VAR = %s\n", getenv("MY_VAR"));
    
    // 覆盖已有值
    setenv("MY_VAR", "world", 1);
    printf("MY_VAR = %s\n", getenv("MY_VAR"));
    
    // 不覆盖（第三个参数为0）
    setenv("MY_VAR", "new_value", 0);
    printf("MY_VAR = %s\n", getenv("MY_VAR"));  // 仍然是"world"
    
    // 删除环境变量
    unsetenv("MY_VAR");
    printf("MY_VAR = %s\n", getenv("MY_VAR"));  // (null)
    
    return 0;
}

注意：setenv和unsetenv修改的环境变量只影响当前进程及其未来的子进程，不会影响父进程或其他进程。

2.4.3 putenv（不推荐）

#include <stdlib.h>

int putenv(char *string);  // string格式为"NAME=VALUE"

putenv直接将传入的字符串指针放入环境表，因此字符串必须是可修改的且生命周期要足够长：

// 错误：使用字符串常量
putenv("MY_VAR=hello");  // 危险！字符串常量可能被修改

// 正确：使用malloc分配的内存
char *env = malloc(64);
snprintf(env, 64, "MY_VAR=%s", "hello");
putenv(env);
// 注意：env不能被free，因为环境表持有它的指针

建议：优先使用setenv/unsetenv而不是putenv，因为前者更安全。

2.5 进程的内存布局

C程序的内存布局从低地址到高地址依次为：

高地址
┌─────────────────────┐
│   命令行参数和环境变量  │  ← 栈顶
├─────────────────────┤
│        栈 (stack)    │  ← 向下增长
│          ↓          │
│                     │
│          ↑          │
│        堆 (heap)     │  ← 向上增长
├─────────────────────┤
│      BSS段 (未初始化)  │  ← 未初始化的全局/静态变量
├─────────────────────┤
│     数据段 (data)     │  ← 已初始化的全局/静态变量
├─────────────────────┤
│     文本段 (text)     │  ← 程序代码（只读）
├─────────────────────┤
│   保留区域（不可访问）   │
└─────────────────────┘
低地址

各段的内容：

段	内容	特点
文本段	机器指令	只读，可共享
数据段	已初始化的全局/静态变量	可读写
BSS段	未初始化的全局/静态变量	自动初始化为0
堆	动态分配的内存（malloc）	向上增长
栈	局部变量、函数参数、返回地址	向下增长

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

int global_init = 42;      // 数据段
int global_uninit;          // BSS段
static int static_init = 0; // 数据段
static int static_uninit;   // BSS段

int main() {
    int local = 100;        // 栈
    static int static_local = 200;  // 数据段
    
    int *heap = malloc(sizeof(int));  // 堆
    *heap = 300;
    
    printf("Text (code):    %p\n", main);
    printf("Data (init):    %p (global_init=%d)\n", &global_init, global_init);
    printf("BSS (uninit):   %p (global_uninit=%d)\n", &global_uninit, global_uninit);
    printf("Stack (local):  %p (local=%d)\n", &local, local);
    printf("Heap (malloc):  %p (*heap=%d)\n", heap, *heap);
    
    free(heap);
    return 0;
}

2.6 C程序的启动过程

C程序从内核加载到执行main函数，经历了以下步骤：

内核exec：内核加载可执行文件，创建进程

启动代码：内核调用C运行时启动代码（_start）

初始化：启动代码初始化C运行时环境（设置堆、栈、标准I/O等）

调用main：启动代码调用main函数

asm

; 简化的启动代码（汇编）
_start:
    ; 设置栈
    ; 初始化C运行时
    call __libc_csu_init    ; 初始化库
    call main               ; 调用main
    mov %eax, %edi          ; main的返回值作为exit的参数
    call exit               ; 调用exit（不是_exit）

main函数返回后，启动代码调用exit（不是_exit），确保执行atexit注册的清理函数和刷新标准I/O缓冲区。

2.7 内存分配

2.7.1 malloc系列函数

#include <stdlib.h>

void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);
void free(void *ptr);

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

int main() {
    // malloc：分配未初始化的内存
    int *p1 = malloc(10 * sizeof(int));
    // 内存内容未定义
    
    // calloc：分配并初始化为0
    int *p2 = calloc(10, sizeof(int));
    // 所有元素为0
    
    // realloc：调整已分配内存的大小
    p1 = realloc(p1, 20 * sizeof(int));
    // 前10个元素保持不变，后10个未定义
    
    // 使用字符串
    char *str = malloc(100);
    strcpy(str, "Hello, World!");
    
    free(p1);
    free(p2);
    free(str);
    
    return 0;
}

常见错误：

// 1. 内存泄漏
void leak() {
    int *p = malloc(sizeof(int));
    return;  // 忘记free(p)
}

// 2. 重复释放
int *p = malloc(sizeof(int));
free(p);
free(p);  // 未定义行为

// 3. 使用已释放的内存
free(p);
*p = 42;  // 未定义行为

// 4. 释放非malloc分配的内存
int x;
free(&x);  // 错误！只能释放malloc/calloc/realloc分配的内存

// 5. 分配大小错误
int *arr = malloc(10);  // 只分配了10字节，不是10个int
arr[5] = 42;  // 可能越界

2.7.2 alloca（栈上分配）

#include <alloca.h>

void *alloca(size_t size);

alloca在栈上分配内存，函数返回时自动释放：

#include <stdio.h>
#include <alloca.h>

void func(int n) {
    int *arr = alloca(n * sizeof(int));  // 栈上分配
    for (int i = 0; i < n; i++) {
        arr[i] = i;
    }
    // 函数返回时自动释放，不需要free
}

注意：alloca不可移植，且大量使用可能导致栈溢出。建议使用malloc或C99的变长数组。

三、实战案例

3.1 命令行参数解析工具

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

typedef struct {
    int verbose;
    int recursive;
    char *output;
    char *input;
    int count;
} Config;

void print_usage(const char *prog) {
    printf("Usage: %s [options] <input>\n", prog);
    printf("Options:\n");
    printf("  -v          Verbose mode\n");
    printf("  -r          Recursive\n");
    printf("  -o <file>   Output file\n");
    printf("  -n <num>    Count (default: 1)\n");
    printf("  -h          Show help\n");
}

int parse_args(int argc, char *argv[], Config *cfg) {
    memset(cfg, 0, sizeof(Config));
    cfg->count = 1;
    
    int opt;
    while ((opt = getopt(argc, argv, "vro:n:h")) != -1) {
        switch (opt) {
        case 'v': cfg->verbose = 1; break;
        case 'r': cfg->recursive = 1; break;
        case 'o': cfg->output = optarg; break;
        case 'n': cfg->count = atoi(optarg); break;
        case 'h': print_usage(argv[0]); exit(0);
        default:  print_usage(argv[0]); return -1;
        }
    }
    
    if (optind >= argc) {
        fprintf(stderr, "Error: input file required\n");
        print_usage(argv[0]);
        return -1;
    }
    cfg->input = argv[optind];
    
    return 0;
}

int main(int argc, char *argv[]) {
    Config cfg;
    if (parse_args(argc, argv, &cfg) != 0) {
        return 1;
    }
    
    printf("Input: %s\n", cfg.input);
    printf("Output: %s\n", cfg.output ? cfg.output : "(stdout)");
    printf("Verbose: %s\n", cfg.verbose ? "yes" : "no");
    printf("Recursive: %s\n", cfg.recursive ? "yes" : "no");
    printf("Count: %d\n", cfg.count);
    
    return 0;
}

3.2 环境变量管理器

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

void list_env(const char *prefix) {
    extern char **environ;
    for (char **env = environ; *env; env++) {
        if (prefix == NULL || strncmp(*env, prefix, strlen(prefix)) == 0) {
            printf("%s\n", *env);
        }
    }
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Usage: %s <command> [args...]\n", argv[0]);
        printf("Commands:\n");
        printf("  get <name>         Get environment variable\n");
        printf("  set <name> <value> Set environment variable\n");
        printf("  unset <name>       Unset environment variable\n");
        printf("  list [prefix]      List all variables\n");
        return 1;
    }
    
    if (strcmp(argv[1], "get") == 0 && argc >= 3) {
        char *val = getenv(argv[2]);
        if (val) printf("%s\n", val);
        else printf("(not set)\n");
    }
    else if (strcmp(argv[1], "set") == 0 && argc >= 4) {
        if (setenv(argv[2], argv[3], 1) == 0) {
            printf("Set %s=%s\n", argv[2], argv[3]);
        }
    }
    else if (strcmp(argv[1], "unset") == 0 && argc >= 3) {
        unsetenv(argv[2]);
        printf("Unset %s\n", argv[2]);
    }
    else if (strcmp(argv[1], "list") == 0) {
        list_env(argc >= 3 ? argv[2] : NULL);
    }
    
    return 0;
}

3.3 内存使用分析

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

// 全局变量
int global_data = 42;
int global_bss;

void check_memory_layout() {
    static int static_data = 100;
    static int static_bss;
    int local_var = 200;
    
    printf("=== Memory Layout ===\n");
    printf("Code segment:\n");
    printf("  main:          %p\n", (void *)main);
    printf("  check_memory:  %p\n", (void *)check_memory_layout);
    
    printf("\nData segment (initialized):\n");
    printf("  global_data:   %p (value: %d)\n", (void *)&global_data, global_data);
    printf("  static_data:   %p (value: %d)\n", (void *)&static_data, static_data);
    
    printf("\nBSS segment (uninitialized):\n");
    printf("  global_bss:    %p (value: %d)\n", (void *)&global_bss, global_bss);
    printf("  static_bss:    %p (value: %d)\n", (void *)&static_bss, static_bss);
    
    printf("\nStack:\n");
    printf("  local_var:     %p (value: %d)\n", (void *)&local_var, local_var);
    
    int *heap_var = malloc(sizeof(int));
    *heap_var = 300;
    printf("\nHeap:\n");
    printf("  heap_var:      %p (value: %d)\n", (void *)heap_var, *heap_var);
    
    free(heap_var);
}

int main() {
    check_memory_layout();
    return 0;
}

四、本章小结

第7章讲解了进程的运行环境。核心知识点包括：

main函数参数：argc/argv处理命令行参数，environ/envp访问环境变量。使用getopt解析选项。

进程终止：5种正常终止（return、exit、_exit/_Exit）和3种异常终止（abort、信号、线程取消）。exit执行清理操作，_exit直接终止。

atexit：注册exit时调用的清理函数，LIFO顺序执行。_exit和abort不调用atexit函数。

环境变量：getenv读取，setenv设置，unsetenv删除。优先使用setenv而非putenv。

内存布局：文本段（代码）、数据段（已初始化全局变量）、BSS段（未初始化全局变量）、堆（动态分配）、栈（局部变量）。

C程序启动：内核exec → 启动代码 → C运行时初始化 → 调用main → exit。

五、思考与练习

思考题

为什么exit会刷新标准I/O缓冲区而_exit不会？在什么场景下应该使用_exit？

atexit注册的清理函数为什么按LIFO顺序执行？如果按FIFO顺序会有什么问题？

为什么堆向上增长而栈向下增长？这种设计有什么好处？

malloc(0)返回什么？返回的指针可以free吗？

编程练习

编写一个程序，使用getopt解析命令行参数，支持-v（verbose）、-o file（output）、-n num（count）选项。

实现一个env命令的简化版，列出所有环境变量，支持按前缀过滤。

编写一个程序，打印进程的内存布局（各段的地址范围），与/proc/self/maps的输出对比。

实现一个简单的内存池：预分配一大块内存，提供pool_alloc和pool_free函数。