1
// Linux 内核进程描述符（简化）
2
// 源码: https://github.com/torvalds/linux/blob/master/include/linux/sched.h
3
struct task_struct {
4
    unsigned int        state;          // 进程状态
5
    int                 prio;           // 动态优先级
6
    int                 static_prio;    // 静态优先级
7
    pid_t               pid;            // 进程 ID
8
    pid_t               tgid;           // 线程组 ID
9
    struct mm_struct    *mm;            // 内存描述符
10
    struct files_struct *files;         // 打开的文件
11
    struct signal_struct *signal;       // 信号
12
    struct sched_entity  se;            // 调度实体
13
    const struct sched_class *sched_class; // 调度类
14
    struct thread_info  thread_info;    // 线程信息
15
    // ... 几百个字段
16
};

1
每个进程在内核中有两块核心内存:
2

3
+-------------------+  低地址
4
|  用户态栈          |
5
+-------------------+
6
|  ...               |
7
+-------------------+
8
|  用户空间           |  0x0000000000000000 ~ 0x00007FFFFFFFFFFF
9
|  (代码/数据/堆/栈) |
10
+-------------------+  0x00007FFFFFFFFFFF (TASK_SIZE)
11
|  不可访问区         |
12
+-------------------+
13
|  内核空间           |  0xFFFF800000000000 (x86_64)
14
|  +---------------+ |
15
|  | 内核栈 (8KB)   | |
16
|  | thread_info    | |
17
|  +---------------+ |
18
|  | task_struct    | |
19
|  | (slab 分配)    | |
20
|  +---------------+ |
21
+-------------------+

1
fork 后的内存布局:
2

3
父进程页表              物理内存              子进程页表
4
+----------+        +----------+         +----------+
5
| PTE (RO) |------->| Page A   |<-------| PTE (RO) |
6
+----------+        +----------+         +----------+
7
| PTE (RO) |------->| Page B   |<-------| PTE (RO) |
8
+----------+        +----------+         +----------+
9
| PTE (RO) |------->| Page C   |<-------| PTE (RO) |
10
+----------+        +----------+         +----------+
11

12
父进程写入 Page B 后:
13

14
父进程页表              物理内存              子进程页表
15
+----------+        +----------+         +----------+
16
| PTE (RW) |------->| Page A   |<-------| PTE (RO) |
17
+----------+        +----------+         +----------+
18
| PTE (RW) |---+    | Page B   |<-------| PTE (RO) |
19
+----------+   +--->| Page B'  |         +----------+
20
| PTE (RW) |------->| Page C   |<-------| PTE (RO) |
21
+----------+        +----------+         +----------+

1
// fork 核心实现
2
// 源码: https://github.com/torvalds/linux/blob/master/kernel/fork.c
3

4
// sys_fork 的实际实现
5
SYSCALL_DEFINE0(fork)
6
{
7
    return kernel_clone(clone_args);
8
}
9

10
// 更通用的 clone 实现
11
static __latent_entropy struct task_struct *copy_process(
12
    struct pid *pid, int trace, int node,
13
    struct kernel_clone_args *args)
14
{
15
    struct task_struct *p;
16

17
    // 1. 分配 task_struct
18
    p = dup_task_struct(current, node);
19
    if (!p)
20
        return ERR_PTR(-ENOMEM);
21

22
    // 2. 复制进程上下文
23
    retval = copy_creds(p, clone_flags);    // 复制凭证
24
    retval = copy_mm(clone_flags, p);       // 复制内存空间 (COW)
25
    retval = copy_namespaces(clone_flags, p); // 复制命名空间
26
    retval = copy_files(clone_flags, p);    // 复制文件描述符
27
    retval = copy_fs(clone_flags, p);       // 复制 fs 信息
28
    retval = copy_sighand(clone_flags, p);  // 复制信号处理
29
    retval = copy_signal(clone_flags, p);   // 复制信号
30
    retval = copy_thread(p, args);          // 复制线程上下文
31

32
    // 3. 设置 PID
33
    p->pid = pid_nr(pid);
34

35
    // 4. 初始化调度信息
36
    retval = sched_fork(clone_flags, p);
37

38
    return p;
39
}

1
// 不同创建方式的 clone flags
2
// fork:     clone(SIGCHLD, 0)
3
// vfork:    clone(CLONE_VFORK | CLONE_VM | SIGCHLD, 0)
4
// thread:   clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ...)
5

6
// 创建线程 (共享地址空间、文件、信号处理)
7
clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, stack_ptr);
8

9
// 创建进程 (什么都不共享)
10
clone(SIGCHLD, 0);

1
ELF 文件结构:
2

3
+-------------------+
4
| ELF Header        |  魔数: 7f 45 4c 46 (DEL E L F)
5
| e_type: ET_EXEC   |  类型: 可执行文件
6
| e_entry: 0x400xxx |  入口点地址
7
| e_phoff: 64       |  Program Header 偏移
8
| e_shoff: xxx      |  Section Header 偏移
9
+-------------------+
10
| Program Header    |  描述运行时的段 (Segment)
11
|   PT_LOAD (.text) |  可加载段: 代码
12
|   PT_LOAD (.data) |  可加载段: 数据
13
|   PT_INTERP       |  动态链接器路径
14
|   PT_DYNAMIC      |  动态链接信息
15
|   PT_STACK        |  栈标志
16
+-------------------+
17
| .text             |  代码段 (机器指令)
18
| .rodata           |  只读数据 (字符串常量等)
19
| .data             |  已初始化数据
20
| .bss              |  未初始化数据 (不占文件空间)
21
| .dynamic          |  动态链接信息
22
| .dynsym           |  动态符号表
23
| .strtab           |  字符串表
24
+-------------------+
25
| Section Header    |  描述链接时的节 (Section)
26
+-------------------+

1
# 查看 ELF 文件信息
2
readelf -h ./hello          # ELF Header
3
readelf -l ./hello          # Program Headers
4
readelf -S ./hello          # Section Headers
5
readelf -d ./hello          # Dynamic Section
6
file ./hello                # 文件类型
7
objdump -d ./hello          # 反汇编

1
// execve 系统调用入口
2
// 源码: https://github.com/torvalds/linux/blob/master/fs/exec.c
3

4
SYSCALL_DEFINE3(execve, const char __user *, filename,
5
    const char __user *const __user *, argv,
6
    const char __user *const __user *, envp)
7
{
8
    return do_execve(getname(filename), argv, envp);
9
}
10

11
// exec 核心实现
12
static int exec_binprm(struct linux_binprm *bprm)
13
{
14
    // 搜索注册的二进制格式处理器
15
    // ELF -> load_elf_binary()
16
    // 脚本 -> load_script()
17
    // a.out -> load_aout_binary()
18
    ret = search_binary_handler(bprm);
19

20
    return ret;
21
}
22

23
// ELF 加载器
24
// 源码: https://github.com/torvalds/linux/blob/master/fs/binfmt_elf.c
25
static int load_elf_binary(struct linux_binprm *bprm)
26
{
27
    // 1. 读取并验证 ELF Header
28
    retval = elf_read(&loc->elf_ex, sizeof(loc->elf_ex), bprm);
29

30
    // 2. 找到 PT_INTERP 段，获取动态链接器路径
31
    for (i = 0; i < loc->elf_ex.e_phnum; i++) {
32
        if (elf_ppnt->p_type == PT_INTERP) {
33
            // 读取 ld.so 路径
34
            retval = elf_read(&elf_interpreter, ...);
35
        }
36
    }
37

38
    // 3. 释放旧地址空间
39
    retval = begin_new_exec(bprm);  // flush_old_exec 内部
40

41
    // 4. 映射各 PT_LOAD 段
42
    for (i = 0; i < loc->elf_ex.e_phnum; i++) {
43
        if (elf_ppnt->p_type != PT_LOAD)
44
            continue;
45
        // mmap 映射到进程地址空间
46
        elf_map(bprm->file, load_addr + elf_ppnt->p_vaddr,
47
                elf_ppnt, elf_prot, elf_flags, total_size);
48
    }
49

50
    // 5. 设置入口点
51
    if (elf_interpreter) {
52
        // 动态链接程序: 入口 = ld.so
53
        elf_entry = load_elf_interp(&loc->interp_elf_ex, ...);
54
    } else {
55
        // 静态链接程序: 入口 = e_entry
56
        elf_entry = loc->elf_ex.e_entry;
57
    }
58

59
    return 0;
60
}

1
延迟绑定 (Lazy Binding) 机制:
2

3
第一次调用 printf:
4

5
程序代码                    PLT                      GOT
6
+------------------+   +------------------+    +------------------+
7
| call printf@plt  |-->| printf@plt:      |    | [printf@got]     |
8
|                  |   |   jmp *[printf@got]|-->| 0x0 (未解析)     |
9
|                  |   |   push reloc_index|    +------------------+
10
|                  |   |   jmp PLT[0]      |         |
11
+------------------+   +------------------+         v
12
                                                      ld.so 动态解析
13
                                                      printf 的实际地址
14
                                                      填入 GOT 表
15

16
第二次调用 printf:
17

18
程序代码                    PLT                      GOT
19
+------------------+   +------------------+    +------------------+
20
| call printf@plt  |-->| printf@plt:      |    | [printf@got]     |
21
|                  |   |   jmp *[printf@got]|-->| printf 实际地址  |---> printf()
22
+------------------+   +------------------+    +------------------+

1
# 查看 GOT/PLT 信息
2
objdump -d -j .plt ./hello          # 查看 PLT
3
objdump -d -j .got ./hello          # 查看 GOT
4
readelf -r ./hello                   # 查看重定位条目
5
readelf --dyn-syms ./hello           # 查看动态符号
6

7
# 查看动态依赖
8
ldd ./hello
9
# 输出:
10
#   linux-vdso.so.1 (0x00007ff...)
11
#   libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6
12
#   /lib64/ld-linux-x86-64.so.2

1
// glibc 动态链接器入口
2
// 源码: https://github.com/bminor/glibc/blob/master/elf/rtld.c
3

4
// ld.so 的真正入口 (_start → _dl_start → _dl_start_final)
5
void _dl_start_final(void *arg)
6
{
7
    // 1. 自身重定位 (自举)
8
    // 2. 加载依赖库
9
    // 3. 执行重定位
10
    // 4. 初始化各库
11
    // 5. 跳转到程序入口
12
    _dl_init(main_map, argc, argv, envp);
13
    entry = _dl_sysdep_start(main_map, ...);
14
    // 跳转到程序 _start
15
}

1
进程虚拟地址空间布局 (x86_64):
2

3
高地址 0xFFFFFFFFFFFFFFFF
4
+-------------------+
5
| 内核空间           | 不可访问 (用户态)
6
| (所有进程共享)     |
7
+-------------------+ 0x00007FFFFFFFFFFF (TASK_SIZE)
8
|                   |
9
| 栈 (Stack)        | ↓ 向低地址增长
10
|                   |
11
+-------------------+
12
| ...               |
13
+-------------------+
14
| 内存映射区 (mmap)  | 文件映射、共享库
15
| ld.so / libc.so   | ↑ 向高地址增长
16
+-------------------+
17
| ...               |
18
+-------------------+
19
| 堆 (Heap)         | ↑ 向高地址增长 (brk/sbrk)
20
|                   |
21
+-------------------+
22
| BSS 段            | 未初始化的全局/静态变量 (零填充)
23
+-------------------+
24
| Data 段           | 已初始化的全局/静态变量
25
+-------------------+
26
| Text 段           | 代码 (只读、可执行)
27
+-------------------+
28
| ELF Header 等     |
29
+-------------------+ 0x400000 (典型加载地址)
30
| 不可访问区         |
31
+-------------------+ 0x0
32
低地址

1
# 查看进程内存映射
2
cat /proc/<pid>/maps
3
# 或
4
pmap -x <pid>
5

6
# 示例输出:
7
# 地址范围            权限    偏移     设备   inode  路径
8
# 00400000-00401000   r--p    00000000 08:01  12345  /home/user/hello
9
# 00401000-00402000   r-xp    00001000 08:01  12345  /home/user/hello  (.text)
10
# 00402000-00403000   r--p    00002000 08:01  12345  /home/user/hello  (.rodata)
11
# 00403000-00404000   rw-p    00003000 08:01  12345  /home/user/hello  (.data)
12
# 7f0000000-7f0020000 r-xp    00000000 ...    /lib/x86_64/libc.so.6
13
# 7ffff7a00000-...    rw-p    ...              堆
14
# 7ffffffde000-...    rw-p    ...              栈
15

16
# 查看进程详细信息
17
cat /proc/<pid>/status
18
cat /proc/<pid>/statm    # 内存使用 (页数)

1
// 进程内存描述符
2
// 源码: https://github.com/torvalds/linux/blob/master/include/linux/mm_types.h
3
struct mm_struct {
4
    pgd_t *pgd;              // 页全局目录
5
    unsigned long start_code, end_code;    // 代码段
6
    unsigned long start_data, end_data;    // 数据段
7
    unsigned long start_brk, brk;          // 堆
8
    unsigned long start_stack;             // 栈
9
    unsigned long mmap_base;               // mmap 区基址
10
    struct vm_area_struct *mmap;           // VMA 链表
11
    struct rb_root mm_rb;                  // VMA 红黑树
12
    // ...
13
};
14

15
// 虚拟内存区域
16
struct vm_area_struct {
17
    unsigned long vm_start;    // 起始地址
18
    unsigned long vm_end;      // 结束地址
19
    struct vm_area_struct *vm_next;    // 链表
20
    struct rb_node vm_rb;     // 红黑树节点
21
    struct mm_struct *vm_mm;  // 所属 mm_struct
22
    unsigned long vm_flags;   // 权限标志
23
    const struct vm_operations_struct *vm_ops; // 操作函数
24
};

1
// 设置 CLOEXEC
2
// 源码: https://github.com/torvalds/linux/blob/master/fs/file.c
3

4
// 打开文件时设置 (原子操作)
5
int fd = open("file.txt", O_RDONLY | O_CLOEXEC);
6

7
// 或在已有的 fd 上设置
8
fcntl(fd, F_SETFD, FD_CLOEXEC);
9

10
// 为什么需要 CLOEXEC?
11
// 1. 安全: 防止子进程意外访问父进程的文件
12
// 2. 资源泄漏: exec 后 fd 不再使用但不关闭
13
// 3. 多线程安全: 传统 SETFD + exec 之间有竞态条件

1
// pipe + CLOEXEC 示例
2
int pipefd[2];
3
pipe2(pipefd, O_CLOEXEC);  // 原子设置 CLOEXEC
4

5
// fork 后子进程
6
if (fork() == 0) {
7
    // 关闭读端
8
    close(pipefd[0]);
9
    // 重定向 stdout 到管道写端
10
    // pipefd[1] 没有 CLOEXEC，可以 exec 后使用
11
    dup2(pipefd[1], STDOUT_FILENO);
12
    execlp("ls", "ls", NULL);
13
}

1
# 重定向原理
2
# ls > output.txt 等价于:
3
# 1. fork
4
# 2. 子进程中: open("output.txt") → 得到 fd 3
5
# 3. dup2(3, 1)  → fd 1 (stdout) 指向 output.txt
6
# 4. close(3)
7
# 5. exec("ls")

1
// 标准重定向实现
2
void redirect_stdout(const char *filename) {
3
    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
4
    dup2(fd, STDOUT_FILENO);  // STDOUT_FILENO = 1
5
    close(fd);
6
}
7

8
// 管道实现
9
void pipe_example() {
10
    int pipefd[2];
11
    pipe(pipefd);
12

13
    if (fork() == 0) {
14
        close(pipefd[0]);          // 关闭读端
15
        dup2(pipefd[1], STDOUT_FILENO);
16
        close(pipefd[1]);
17
        execlp("ls", "ls", NULL);
18
    }
19

20
    close(pipefd[1]);              // 关闭写端
21
    dup2(pipefd[0], STDIN_FILENO);
22
    close(pipefd[0]);
23
    execlp("wc", "wc", "-l", NULL);
24
}

1
// CFS 调度器核心数据结构
2
// 源码: https://github.com/torvalds/linux/blob/master/kernel/sched/fair.c
3

4
// 调度实体
5
struct sched_entity {
6
    struct load_weight      load;       // 权重
7
    struct rb_node          run_node;   // 红黑树节点
8
    unsigned int            on_rq;      // 是否在运行队列
9
    u64                     vruntime;   // 虚拟运行时间
10
    u64                     sum_exec_runtime; // 累计执行时间
11
};
12

13
// CFS 运行队列 (红黑树，按 vruntime 排序)
14
struct cfs_rq {
15
    struct rb_root_cached   tasks_timeline; // 红黑树根
16
    struct sched_entity     *curr;          // 当前运行实体
17
    unsigned int            nr_running;     // 运行中进程数
18
    u64                     min_vruntime;   // 最小 vruntime
19
};

1
CFS 红黑树 (按 vruntime 排序):
2

3
                    vruntime=50
4
                   /            \
5
          vruntime=20          vruntime=80
6
          /        \           /         \
7
     vr=10       vr=35     vr=65      vr=120
8
                                         ↑
9
                                    下一个调度的进程
10
                                    (vruntime 最小)

1
# 查看进程调度策略和优先级
2
chrt -p <pid>
3

4
# 设置进程调度策略
5
chrt -f 10 ./realtime_app     # SCHED_FIFO, 优先级 10
6
chrt -r 50 ./realtime_app     # SCHED_RR, 优先级 50
7
chrt -o 0 ./normal_app        # SCHED_NORMAL
8

9
# nice 值 (影响普通进程优先级)
10
nice -n 10 ./low_priority_app  # nice 值 +10
11
renice -n -5 -p <pid>          # 提高优先级

1
// 进程退出实现
2
// 源码: https://github.com/torvalds/linux/blob/master/kernel/exit.c
3

4
void __noreturn do_exit(long code)
5
{
6
    struct task_struct *tsk = current;
7

8
    // 1. 检查退出合法性
9
    if (unlikely(in_interrupt()))
10
        panic("Aiee, killing interrupt handler!");
11

12
    // 2. 设置退出码
13
    tsk->exit_code = code;
14

15
    // 3. 释放资源
16
    exit_signals(tsk);       // 退出信号处理
17
    exit_mm(tsk);            // 释放内存空间
18
    exit_sem(tsk);           // 释放信号量
19
    exit_shm(tsk);           // 释放共享内存
20
    exit_files(tsk);         // 关闭文件描述符
21
    exit_fs(tsk);            // 释放 fs 信息
22
    exit_task_namespaces(tsk); // 释放命名空间
23

24
    // 4. 设置僵尸状态
25
    tsk->state = TASK_DEAD;
26
    tsk->exit_state = EXIT_ZOMBIE;
27

28
    // 5. 通知父进程
29
    do_notify_parent(tsk, tsk->exit_signal);
30

31
    // 6. 重新调度
32
    do_task_dead();
33
}

1
僵尸进程 (Zombie):
2
  子进程已退出，但父进程未调用 waitpid 回收
3
  task_struct 仍保留在内核中，占用 PID 资源
4

5
  +-----------+          +-----------+
6
  | 父进程     |          | 子进程 (Z) |
7
  | 活跃       |  SIGCHLD | task_struct|
8
  | 没有wait   |<---------| 保留       |
9
  +-----------+          +-----------+
10

11
  危害: PID 耗尽，无法创建新进程
12
  解决: 父进程调用 wait/waitpid
13
        或 kill 父进程让 init 回收
14

15
孤儿进程 (Orphan):
16
  父进程先于子进程退出
17
  子进程被 init (PID 1) 或 subreaper 接管
18

19
  +-----------+
20
  | 父进程     | exit
21
  +-----------+  ↓
22
                   init (PID 1) 接管
23
                   +-----------+
24
                   | 子进程     |
25
                   | 继续运行   |
26
                   +-----------+

1
# 查找僵尸进程
2
ps aux | grep 'Z'
3
# 或
4
ps -eo pid,ppid,stat,cmd | grep 'Z'
5

6
# 消除僵尸进程:
7
# 1. 让父进程调用 wait()
8
# 2. kill 父进程，init 接管并回收
9
# 3. 使用 SIGCHLD 信号处理 (SA_NOCLDSTOP|SA_NOCLDWAIT)
10

11
# 设置 subreaper (PR_SET_CHILD_SUBREAPER)
12
# systemd / Docker 常用此机制
13
prctl(PR_SET_CHILD_SUBREAPER, 1);

1
// waitpid 系统调用
2
// 源码: https://github.com/torvalds/linux/blob/master/kernel/exit.c
3

4
SYSCALL_DEFINE4(wait4, pid_t, pid, int __user *, stat_addr,
5
    int, options, struct rusage __user *, ru)
6
{
7
    return kernel_wait4(pid, stat_addr, options, ru);
8
}
9

10
static long kernel_wait4(pid_t pid, int __user *stat_addr,
11
    int options, struct rusage __user *ru)
12
{
13
    struct wait_opts wo;
14

15
    // 遍历子进程
16
    for_each_thread(current, p) {
17
        // 检查子进程状态
18
        if (p->exit_state == EXIT_ZOMBIE) {
19
            // 找到僵尸子进程
20
            // 读取退出码
21
            // 释放 task_struct
22
            // 返回子进程 PID
23
        }
24
    }
25

26
    // 如果设置了 WNOHANG，立即返回
27
    if (options & WNOHANG)
28
        return 0;
29

30
    // 否则阻塞等待子进程退出
31
    return do_wait_thread(wo);
32
}

1
# 跟踪进程启动全过程
2
strace -f -o trace.log ./hello
3

4
# 关键输出分析
5
# -f: 跟踪子进程
6
# -o: 输出到文件
7

8
# 典型 strace 输出:
9
execve("./hello", ["./hello"], 0x7ffd... /* 50 vars */) = 0
10
brk(NULL)                               = 0x5600000
11
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f...
12
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT
13
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
14
fstat(3, {st_size=89012, ...})          = 0
15
mmap(NULL, 89012, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f...
16
close(3)                                = 0
17
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
18
read(3, "\x7fELF\x02\x01\x01\x03", 832) = 832
19
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f...
20
mmap(NULL, 18325696, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f...
21
mprotect(0x7f...24000, 2097152, PROT_NONE) = 0
22
mmap(0x7f...42000, 1552384, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x24000) = 0x7f...
23
mmap(0x7f...99000, 303104, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x199000) = 0x7f...
24
close(3)                                = 0
25
mprotect(0x7f...99000, 24576, PROT_READ) = 0
26
set_tid_address(0x7f...)               = 12345
27
set_robust_list(0x7f..., 24)           = 0
28
rt_sigaction(SIGPIPE, {sa_handler=SIG_IGN}, ...) = 0
29
write(1, "Hello, World!\n", 14)         = 14
30
exit_group(0)                           = ?
31
+++ exited with 0 +++

1
# 跟踪库函数调用
2
ltrace ./hello
3

4
# 典型输出:
5
__libc_start_main(0x560c..., 1, 0x7ffd..., 0x560c... <incomplete ...>
6
puts("Hello, World!")                   = 14
7
+++ exited (status 0) +++

1
# 启动一个后台进程
2
./hello &
3
PID=$!
4

5
# 查看进程信息
6
cat /proc/$PID/status | head -20
7
# Name:   hello
8
# State:  S (sleeping)
9
# Tgid:   12345
10
# Pid:    12345
11
# PPid:   1234
12
# Uid:    1000    1000    1000    1000
13
# Gid:    1000    1000    1000    1000
14

15
# 查看内存映射
16
cat /proc/$PID/maps
17

18
# 查看命令行
19
cat /proc/$PID/cmdline | tr '\0' ' '
20

21
# 查看打开的文件
22
ls -la /proc/$PID/fd/

1
// 简化版 Shell: fork + exec + wait
2
// 模拟 Shell 执行命令的过程
3
#include <stdio.h>
4
#include <unistd.h>
5
#include <sys/wait.h>
6

7
int main() {
8
    char *argv[] = {"/bin/ls", "-la", "/tmp", NULL};
9
    char *envp[] = {NULL};
10

11
    pid_t pid = fork();        // 1. fork 创建子进程
12

13
    if (pid == 0) {
14
        // 子进程
15
        // 2. exec 替换进程映像
16
        execve("/bin/ls", argv, envp);
17
        // 如果 exec 成功，下面的代码不会执行
18
        perror("execve failed");
19
        _exit(1);
20
    } else if (pid > 0) {
21
        // 父进程
22
        int status;
23
        // 3. wait 等待子进程
24
        waitpid(pid, &status, 0);
25
        printf("Child exited with status: %d\n", WEXITSTATUS(status));
26
    } else {
27
        perror("fork failed");
28
    }
29

30
    return 0;
31
}

1
; _start 的汇编实现 (x86_64)
2
; 源码: https://github.com/bminor/glibc/blob/master/sysdeps/x86_64/start.S
3

4
_start:
5
    ; 清空 rbp
6
    xor ebp, ebp
7

8
    ; 提取 argc (栈顶)
9
    mov r9, rsp            ; 保存栈指针 (用于对齐)
10
    pop rsi                ; argc → rsi
11
    mov rdx, rsp           ; argv → rdx
12

13
    ; 对齐栈
14
    and rsp, -16
15

16
    ; 调用 __libc_start_main
17
    ; 参数: main, argc, argv, init, fini, rtld_fini, stack_end
18
    call __libc_start_main
19

20
    ; 如果 __libc_start_main 返回 (不应该)
21
    hlt

1
C 程序初始化和终止的完整顺序:
2

3
初始化:
4
1. 内核映射 ELF 段
5
2. ld.so 加载动态库，执行重定位
6
3. 各 .init 段按依赖顺序执行
7
4. .init_array 中的函数指针（按注册顺序）
8
5. C++ 全局对象构造函数
9
6. main()
10

11
终止:
12
7. main() 返回 / exit() 调用
13
8. atexit() 注册的函数（按相反顺序）
14
9. .fini_array 中的函数指针
15
10. C++ 全局对象析构函数
16
11. 各 .fini 段
17
12. _exit() 系统调用