1
// include/linux/sched.h 中的关键字段
2
struct task_struct {
3
    pid_t pid;      // 进程/线程的唯一标识
4
    pid_t tgid;     // 线程组 ID（用户态的"进程 ID"）
5
    // ...
6
};
7

8
// getpid() 系统调用实际返回的是 tgid
9
SYSCALL_DEFINE0(getpid)
10
{
11
    return task_tgid_vnr(current);  // 返回 tgid，而非 pid
12
}

1
struct task_struct {
2
    pid_t pid;          // 全局唯一的进程/线程 ID
3
    pid_t tgid;         // 线程组 ID = 用户态的"进程 ID"
4
    struct task_struct *group_leader;  // 线程组首领（主线程）
5
    struct list_head thread_group;     // 同一线程组的链表
6

7
    // 父子关系
8
    struct task_struct __rcu *real_parent;  // 真实父进程
9
    struct task_struct __rcu *parent;       // "养父"（被调试器时为调试器）
10
    struct list_head children;              // 子进程链表
11
    struct list_head sibling;               // 兄弟进程链表
12
    // ...
13
};

1
struct task_struct {
2
    volatile long state;    // 进程状态，-1 不可运行，0 可运行，>0 停止
3
    // ...
4
};

1
struct task_struct {
2
    int prio;              // 动态优先级（调度器使用）
3
    int static_prio;       // 静态优先级（nice 值转换而来）
4
    int normal_prio;       // 基于静态优先级和调度策略计算的"正常"优先级
5
    unsigned int rt_priority;  // 实时优先级（1~99）
6

7
    const struct sched_class *sched_class;  // 调度类
8
    struct sched_entity se;      // CFS 调度实体
9
    struct sched_rt_entity rt;   // 实时调度实体
10
    unsigned int policy;         // 调度策略（SCHED_NORMAL/SCHED_FIFO/SCHED_RR）
11
    // ...
12
};

1
struct task_struct {
2
    struct mm_struct *mm;       // 用户态地址空间（内核线程为 NULL）
3
    struct mm_struct *active_mm; // 内核线程借用前一个进程的 mm
4
    // ...
5
};

1
struct task_struct {
2
    struct files_struct *files;  // 打开文件表
3
    // ...
4
};

1
struct task_struct {
2
    struct signal_struct *signal;      // 进程共享的信号信息
3
    struct sighand_struct *sighand;    // 信号处理函数表
4
    sigset_t blocked;                  // 被阻塞的信号集
5
    struct sigpending pending;         // 私有挂起信号队列
6
    // ...
7
};

1
struct task_struct {
2
    struct nsproxy *nsproxy;  // 命名空间代理
3
    // ...
4
};
5

6
struct nsproxy {
7
    struct uts_namespace *uts_ns;     // 主机名、版本
8
    struct ipc_namespace *ipc_ns;     // System V IPC、POSIX MQ
9
    struct mnt_namespace *mnt_ns;     // 挂载点
10
    struct pid_namespace *pid_ns_for_children;  // PID 命名空间
11
    struct net *net_ns;               // 网络命名空间
12
    struct cgroup_namespace *cgroup_ns;  // Cgroup 命名空间
13
    // ...
14
};

1
// 判断进程是否在运行队列上
2
static inline int task_on_rq_queued(struct task_struct *p)
3
{
4
    return p->on_rq == TASK_ON_RQ_QUEUED;
5
}

1
// clone() 的函数原型
2
long clone(unsigned long flags, void *child_stack,
3
           int *ptid, int *ctid, unsigned long newtls);

1
// fs/exec.c 中 load_elf_binary() 的关键步骤（简化）
2
static int load_elf_binary(struct linux_binprm *bprm)
3
{
4
    // 1. 释放旧 mm
5
    flush_old_exec(bprm);  // → exec_mmap() → mm_release() + 分配新 mm
6

7
    // 2. 映射 ELF 段
8
    for (each PT_LOAD segment) {
9
        vm_mmap(file, phdr->p_vaddr, phdr->p_memsz,
10
                prot, flags, phdr->p_offset);
11
    }
12

13
    // 3. 设置入口点
14
    if (elf_interpreter) {
15
        // 动态链接：入口 = ld.so 的入口
16
        entry = load_elf_interp(&loc->interp_elf_ex, ...);
17
    } else {
18
        // 静态链接：入口 = e_entry
19
        entry = elf_ex.e_entry;
20
    }
21

22
    start_thread(regs, entry, bprm->p);  // 设置 PC 和 SP
23
    return 0;
24
}

1
// 僵尸进程保留的信息（kernel/exit.c）
2
// release_task() 被调用时才真正释放 task_struct
3
void release_task(struct task_struct *p)
4
{
5
    // 只有父进程 wait() 后才会执行到这里
6
    zap_leader = 0;
7
    leader = p->group_leader;
8
    // 释放 PID
9
    detach_pid(p, PIDTYPE_PID);
10
    // 释放 task_struct
11
    free_task(p);
12
}

1
// 双 fork 技巧：避免僵尸进程
2
if (fork() == 0) {        // 子进程
3
    if (fork() == 0) {    // 孙子进程
4
        // 孙子进程执行实际工作
5
        // 父进程（子进程）已退出，自动被 init 收养
6
        do_work();
7
        _exit(0);
8
    }
9
    _exit(0);  // 子进程立即退出
10
}
11
// 父进程只需 wait 一次（回收子进程）
12
wait(NULL);   // 孙子进程由 init 回收

1
struct task_struct {
2
    pid_t pgid;  // 进程组 ID
3
    // ...
4
};

1
struct task_struct {
2
    pid_t sid;   // 会话 ID
3
    // ...
4
};

1
// 创建守护进程的经典方法
2
int daemonize(void)
3
{
4
    // 1. fork() 后父进程退出
5
    if (fork() != 0) _exit(0);
6

7
    // 2. setsid() 创建新会话，脱离控制终端
8
    setsid();
9

10
    // 3. 再次 fork()，确保不会重新获取控制终端
11
    if (fork() != 0) _exit(0);
12

13
    // 4. 将工作目录改为根目录
14
    chdir("/");
15

16
    // 5. 关闭继承的文件描述符
17
    for (int i = 0; i < 1024; i++) close(i);
18

19
    // 6. 重定向 stdin/stdout/stderr 到 /dev/null
20
    open("/dev/null", O_RDWR);  // stdin → fd 0
21
    dup(0);                     // stdout → fd 1
22
    dup(0);                     // stderr → fd 2
23

24
    return 0;
25
}

1
$ cat /proc/self/status
2
Name:   cat                          // comm 字段
3
Umask:  0022
4
State:  R (running)                  // task_struct.state
5
Tgid:   12345                        // tgid
6
Ngid:   0
7
Pid:    12345                        // pid
8
PPid:   12344                        // real_parent->pid
9
TracerPid: 0                         // 被调试时的调试器 PID
10
Uid:    1000  1000  1000  1000       // real/effective/saved/fs
11
Gid:    1000  1000  1000  1000
12
FDSize: 64                           // files->max_fds
13
Groups: 4 24 27 30 46 118 128
14
NStgid: 1                            // 嵌套命名空间层级
15
NSpid:  1
16
VmSize:     5524 kB                  // mm->total_vm
17
VmRSS:       820 kB                  // mm->hiwater_rss
18
VmData:     1236 kB                  // mm->data_vm
19
VmStk:       136 kB                  // mm->stack_vm
20
Threads: 1                           // 线程组内线程数
21
SigQ:   0/14378                      // 信号队列使用/上限
22
SigPnd: 0000000000000000             // 私有挂起信号
23
ShdPnd: 0000000000000000             // 共享挂起信号
24
SigBlk: 0000000000000000             // 被阻塞的信号
25
SigIgn: 0000000000000000             // 被忽略的信号
26
SigCgt: 0000000000000000             // 被捕获的信号

1
$ cat /proc/self/maps
2
55a1c0000000-55a1c0023000 r--p 00000000 08:01 1234567  /usr/bin/cat
3
55a1c0023000-55a1c0045000 r-xp 00023000 08:01 1234567  /usr/bin/cat
4
55a1c0045000-55a1c004e000 r--p 00045000 08:01 1234567  /usr/bin/cat
5
55a1c004f000-55a1c0050000 r--p 0004e000 08:01 1234567  /usr/bin/cat
6
55a1c0050000-55a1c0051000 rw-p 0004f000 08:01 1234567  /usr/bin/cat
7
55a1c1a00000-55a1c1a21000 rw-p 00000000 00:00 0        [heap]
8
7f4e8c000000-7f4e8c021000 rw-p 00000000 00:00 0
9
7f4e8c021000-7f4e8c100000 ---p 00000000 00:00 0
10
7f4e8c400000-7f4e8c500000 r--p 00000000 08:01 2345678  /usr/lib/locale/...
11
7f4e8c800000-7f4e8c900000 r--p 00000000 08:01 3456789  /usr/lib/x86_64-linux-gnu/libc.so.6
12
7f4e8c900000-7f4e8cb18000 r-xp 00100000 08:01 3456789  /usr/lib/x86_64-linux-gnu/libc.so.6
13
...
14
7ffd5a7fe000-7ffd5a820000 rw-p 00000000 00:00 0        [stack]
15
7ffd5a8a0000-7ffd5a8a4000 r--p 00000000 00:00 0        [vvar]
16
7ffd5a8a4000-7ffd5a8a6000 r-xp 00000000 00:00 0        [vdso]

1
# 查看当前进程的状态信息
2
cat /proc/self/status
3

4
# 观察所有进程的状态
5
ps aux    # BSD 格式
6
ps -ef    # System V 格式
7
ps -eo pid,ppid,stat,cmd   # 自定义格式
8

9
# 查看进程树
10
pstree -p    # 带PID的进程树
11
pstree -p $$

1
# 编译并运行
2
gcc -o fork_exec_demo fork_exec_demo.c
3
./fork_exec_demo
4

5
# 用 strace 追踪系统调用
6
strace -f ./fork_exec_demo 2>&1 | head -60
7

8
# 关注以下系统调用：
9
# clone()    → fork 的内核实现
10
# execve()   → 执行新程序
11
# wait4()    → 等待子进程
12
# exit_group() → 进程退出

1
# 编译运行
2
gcc -o zombie_demo zombie_demo.c
3
./zombie_demo &
4

5
# 在另一个终端观察僵尸进程
6
ps aux | grep Z
7
# 或
8
ps -eo pid,ppid,stat,cmd | grep zombie_demo
9

10
# 你会看到类似输出：
11
# 12345 12344 Z    [zombie_demo] <defunct>
12

13
# 查看 /proc 中的僵尸进程信息
14
ls -la /proc/$(pgrep -f zombie_demo)/
15
cat /proc/$(pgrep -f zombie_demo)/status | grep State
16
# State:  Z (zombie)

1
# 查看完整进程树
2
pstree -p
3

4
# 查看当前进程的命名空间
5
ls -la /proc/self/ns/
6

7
# 输出示例：
8
# cgroup -> 'cgroup:[4026531835]'
9
# ipc    -> 'ipc:[4026531839]'
10
# mnt    -> 'mnt:[4026531840]'
11
# net    -> 'net:[4026531992]'
12
# pid    -> 'pid:[4026531836]'
13
# user   -> 'user:[4026531837]'
14
# uts    -> 'uts:[4026531838]'
15

16
# 比较两个进程是否在同一命名空间
17
readlink /proc/1/ns/pid
18
readlink /proc/self/ns/pid
19
# 如果 inode 号相同，则在同一命名空间

1
# 查看进程的完整内存映射
2
cat /proc/self/maps
3

4
# 查看更详细的内存信息（含 RSS、PSS）
5
cat /proc/self/smaps | head -50
6

7
# 查看进程的内存统计
8
cat /proc/self/status | grep Vm
9

10
# 查看进程打开的所有文件
11
ls -la /proc/self/fd/
12

13
# 查看进程的命令行
14
cat /proc/self/cmdline | tr '\0' ' '