1
runc/
2
├── main.go              # CLI 入口
3
├── create.go            # runc create 命令
4
├── start.go             # runc start 命令
5
├── run.go               # runc run 命令
6
├── kill.go              # runc kill 命令
7
├── delete.go            # runc delete 命令
8
├── spec.go              # runc spec 命令
9
├── libcontainer/        # 核心库
10
│   ├── container.go     # Container 接口
11
│   ├── process.go       # Process 定义
12
│   ├── factory.go       # 容器工厂
13
│   ├── linux/
14
│   │   ├── container.go # Linux 容器实现
15
│   │   ├── process.go   # Linux 进程实现
16
│   │   ├── init.go      # 容器初始化
17
│   │   ├── standard_init.go  # 标准初始化
18
│   │   └── nsenter/     # Namespace 进入
19
│   ├── configs/
20
│   │   ├── config.go    # 容器配置
21
│   │   ├── mount.go     # 挂载配置
22
│   │   └── ns.go        # Namespace 配置
23
│   ├── cgroups/         # Cgroup 管理
24
│   ├── seccomp/         # seccomp 配置
25
│   ├── apparmor/        # AppArmor 配置
26
│   ├── system/          # 系统调用封装
27
│   └── user/            # 用户命名空间
28
├── contrib/             # 辅助工具
29
└── tests/               # 测试

1
// run.go（简化）
2
func runAction(ctx *cli.Context) error {
3
    // 1. 解析命令行参数
4
    spec, err := setupSpec(ctx)
5

6
    // 2. 创建容器工厂
7
    factory, err := libcontainer.New(
8
        libcontainer.RootPath(rootfs),
9
    )
10

11
    // 3. 创建容器
12
    container, err := factory.Create(ctx.String("id"), spec.Config)
13

14
    // 4. 启动容器
15
    process := &libcontainer.Process{
16
        Args:   spec.Process.Args,
17
        Env:    spec.Process.Env,
18
        User:   spec.Process.User.UID,
19
        Stdin:  os.Stdin,
20
        Stdout: os.Stdout,
21
        Stderr: os.Stderr,
22
    }
23
    err = container.Run(process)
24

25
    // 5. 等待容器退出
26
    status, err := process.Wait()
27
    return nil
28
}

1
// libcontainer/factory.go（简化）
2
func (f *LinuxFactory) Create(id string, config *configs.Config) (Container, error) {
3
    // 1. 验证配置
4
    if err := validateConfig(config); err != nil {
5
        return nil, err
6
    }
7

8
    // 2. 创建容器状态目录
9
    containerRoot := filepath.Join(f.Root, id)
10
    if err := os.MkdirAll(containerRoot, 0711); err != nil {
11
        return nil, err
12
    }
13

14
    // 3. 保存配置到状态目录
15
    if err := writeConfig(containerRoot, config); err != nil {
16
        return nil, err
17
    }
18

19
    // 4. 创建容器对象
20
    c := &linuxContainer{
21
        id:            id,
22
        root:          containerRoot,
23
        config:        config,
24
        initProcess:   nil,
25
        initStartTime: time.Now().UTC(),
26
    }
27

28
    return c, nil
29
}

1
// libcontainer/linux/container.go（简化）
2
func (c *linuxContainer) Run(process *Process) error {
3
    // 1. 如果容器未启动，先创建
4
    if c.initProcess == nil {
5
        if err := c.start(process); err != nil {
6
            return err
7
        }
8
    }
9
    // 2. 执行用户进程
10
    return process.Start()
11
}
12

13
func (c *linuxContainer) start(process *Process) error {
14
    // 1. 创建父进程管道（用于与子进程通信）
15
    parentPipe, childPipe, err := newPipe()
16

17
    // 2. 准备命令（runc init 是容器初始化进程）
18
    cmd := exec.Command("/proc/self/exe", "init")
19
    cmd.Stdin = process.Stdin
20
    cmd.Stdout = process.Stdout
21
    cmd.Stderr = process.Stderr
22

23
    // 3. 设置 Namespace clone 标志
24
    cmd.SysProcAttr = &syscall.SysProcAttr{
25
        Cloneflags: c.getCloneFlags(),
26
    }
27

28
    // 4. 启动子进程（runc init）
29
    if err := cmd.Start(); err != nil {
30
        return err
31
    }
32

33
    // 5. 通过管道发送配置给子进程
34
    if err := writeConfig(childPipe, c.config); err != nil {
35
        return err
36
    }
37

38
    // 6. 等待子进程初始化完成
39
    if err := readError(parentPipe); err != nil {
40
        return err
41
    }
42

43
    c.initProcess = process
44
    return nil
45
}

1
func (c *linuxContainer) getCloneFlags() uintptr {
2
    var flag uintptr
3
    for _, ns := range c.config.Namespaces {
4
        switch ns.Type {
5
        case configs.NEWPID:
6
            flag |= syscall.CLONE_NEWPID
7
        case configs.NEWNS:
8
            flag |= syscall.CLONE_NEWNS
9
        case configs.NEWUTS:
10
            flag |= syscall.CLONE_NEWUTS
11
        case configs.NEWIPC:
12
            flag |= syscall.CLONE_NEWIPC
13
        case configs.NEWNET:
14
            flag |= syscall.CLONE_NEWNET
15
        case configs.NEWUSER:
16
            flag |= syscall.CLONE_NEWUSER
17
        case configs.NEWCGROUP:
18
            flag |= syscall.CLONE_NEWCGROUP
19
        }
20
    }
21
    return flag
22
}

1
// libcontainer/linux/standard_init_linux.go（简化）
2
func (l *linuxStandardInit) Init() error {
3
    // 1. 设置 User Namespace UID/GID 映射
4
    if err := l.setupUser(); err != nil {
5
        return err
6
    }
7

8
    // 2. 配置 Cgroup
9
    if err := l.setupCgroup(); err != nil {
10
        return err
11
    }
12

13
    // 3. 准备 rootfs
14
    if err := l.prepareRootfs(); err != nil {
15
        return err
16
    }
17

18
    // 4. 设置 hostname
19
    if l.config.Hostname != "" {
20
        if err := syscall.Sethostname([]byte(l.config.Hostname)); err != nil {
21
            return err
22
        }
23
    }
24

25
    // 5. 设置网络
26
    if err := l.setupNetwork(); err != nil {
27
        return err
28
    }
29

30
    // 6. 设置路由
31
    if err := l.setupRoute(); err != nil {
32
        return err
33
    }
34

35
    // 7. 设置 seccomp
36
    if l.config.Seccomp != nil {
37
        if err := seccomp.InitSeccomp(l.config.Seccomp); err != nil {
38
            return err
39
        }
40
    }
41

42
    // 8. 设置 AppArmor
43
    if l.config.AppArmorProfile != "" {
44
        if err := apparmor.ApplyProfile(l.config.AppArmorProfile); err != nil {
45
            return err
46
        }
47
    }
48

49
    // 9. 设置 Capabilities
50
    if err := l.setupCapabilities(); err != nil {
51
        return err
52
    }
53

54
    // 10. 切换到用户身份
55
    if err := syscall.Setuid(l.config.UID); err != nil {
56
        return err
57
    }
58

59
    // 11. 执行用户命令
60
    return syscall.Exec(l.config.Args[0], l.config.Args, l.config.Env)
61
}

1
func (l *linuxStandardInit) prepareRootfs() error {
2
    // 1. 挂载所有配置的挂载点
3
    for _, m := range l.config.Mounts {
4
        if err := mount(m.Source, m.Destination, m.Type, m.Flags, m.Data); err != nil {
5
            return err
6
        }
7
    }
8

9
    // 2. pivot_root 切换根文件系统
10
    if err := pivotRoot(l.config.Rootfs); err != nil {
11
        return err
12
    }
13

14
    // 3. 重新挂载 /proc, /sys 等
15
    if err := remountProc(); err != nil {
16
        return err
17
    }
18

19
    return nil
20
}
21

22
func pivotRoot(rootfs string) error {
23
    // 1. 绑定挂载 rootfs 到自身（确保是挂载点）
24
    if err := syscall.Mount(rootfs, rootfs, "", syscall.MS_BIND, ""); err != nil {
25
        return err
26
    }
27

28
    // 2. 创建 pivot_root 的 put_old 目录
29
    putOld := filepath.Join(rootfs, ".pivot_root")
30
    if err := os.MkdirAll(putOld, 0755); err != nil {
31
        return err
32
    }
33

34
    // 3. 执行 pivot_root 系统调用
35
    if err := syscall.PivotRoot(rootfs, putOld); err != nil {
36
        return err
37
    }
38

39
    // 4. 修正工作目录
40
    if err := syscall.Chdir("/"); err != nil {
41
        return err
42
    }
43

44
    // 5. 卸载旧的根文件系统
45
    if err := syscall.Unmount(".pivot_root", syscall.MNT_DETACH); err != nil {
46
        return err
47
    }
48

49
    return os.Remove(".pivot_root")
50
}

1
// libcontainer/cgroups/fs2/manager.go（简化）
2
type Manager struct {
3
    controllers map[string]controller
4
    path        string
5
}
6

7
func (m *Manager) Apply(pid int) error {
8
    // 1. 创建 cgroup 目录
9
    if err := os.MkdirAll(m.path, 0755); err != nil {
10
        return err
11
    }
12

13
    // 2. 将进程加入 cgroup
14
    if err := os.WriteFile(
15
        filepath.Join(m.path, "cgroup.procs"),
16
        []byte(strconv.Itoa(pid)),
17
        0644,
18
    ); err != nil {
19
        return err
20
    }
21

22
    // 3. 应用各控制器配置
23
    for _, c := range m.controllers {
24
        if err := c.Apply(m.path); err != nil {
25
            return err
26
        }
27
    }
28

29
    return nil
30
}
31

32
// CPU 控制器
33
type cpuController struct{}
34

35
func (c *cpuController) Apply(path string) error {
36
    // 写入 cpu.max
37
    if err := os.WriteFile(filepath.Join(path, "cpu.max"), []byte("200000 100000"), 0644); err != nil {
38
        return err
39
    }
40
    // 写入 cpu.weight
41
    return os.WriteFile(filepath.Join(path, "cpu.weight"), []byte("100"), 0644)
42
}
43

44
// 内存控制器
45
type memoryController struct{}
46

47
func (c *memoryController) Apply(path string) error {
48
    // 写入 memory.max
49
    return os.WriteFile(filepath.Join(path, "memory.max"), []byte("536870912"), 0644)
50
}

1
func (l *linuxStandardInit) setupCapabilities() error {
2
    // 1. 清除所有 Capabilities
3
    if err := cap.Reset(); err != nil {
4
        return err
5
    }
6

7
    // 2. 只添加 config.json 中指定的 Capabilities
8
    for _, capName := range l.config.Capabilities.Bounding {
9
        if err := cap.Set(capName); err != nil {
10
            return err
11
        }
12
    }
13

14
    return nil
15
}

1
func InitSeccomp(config *configs.Seccomp) error {
2
    // 1. 构建 BPF 程序
3
    filter, err := buildSeccompFilter(config)
4
    if err != nil {
5
        return err
6
    }
7

8
    // 2. 加载 BPF 程序
9
    prog := &syscall.SockFprog{
10
        Len:    uint16(len(filter)),
11
        Filter: &filter[0],
12
    }
13

14
    // 3. 应用 seccomp 过滤
15
    if _, _, err := syscall.Syscall(
16
        syscall.SYS_PRCTL,
17
        syscall.PR_SET_SECCOMP,
18
        syscall.SECCOMP_MODE_FILTER,
19
        uintptr(unsafe.Pointer(prog)),
20
    ); err != 0 {
21
        return err
22
    }
23

24
    return nil
25
}

1
// containerd-shim 调用 runc 的方式
2
func (s *service) Create(ctx context.Context, r *task.CreateRequest) (*task.CreateResponse, error) {
3
    // 1. 准备 OCI Bundle
4
    bundle := &Bundle{
5
        ID:    r.ID,
6
        Path:  r.Bundle,
7
        Rootfs: r.Rootfs,
8
    }
9

10
    // 2. 构造 runc 命令
11
    cmd := exec.Command("runc", "create",
12
        "--bundle", bundle.Path,
13
        "--pid-file", pidFile,
14
        r.ID,
15
    )
16

17
    // 3. 执行 runc create
18
    if err := cmd.Run(); err != nil {
19
        return nil, err
20
    }
21

22
    // 4. 读取容器 PID
23
    pid, _ := os.ReadFile(pidFile)
24

25
    return &task.CreateResponse{Pid: uint32(pid)}, nil
26
}

1
#!/bin/bash
2
# 追踪 runc 的系统调用
3

4
# 1. 创建 OCI Bundle
5
mkdir -p /tmp/strace-bundle/rootfs
6
cd /tmp/strace-bundle
7
docker export $(docker create busybox) | tar -C rootfs -xvf -
8
runc spec
9

10
# 2. 用 strace 追踪 runc
11
sudo strace -f -o /tmp/runc-strace.log \
12
  -e trace=clone,unshare,mount,pivot_root,prctl,capset,write \
13
  runc run strace-test
14

15
# 3. 分析系统调用
16
echo "=== clone 调用（创建 Namespace）==="
17
grep "clone" /tmp/runc-strace.log | head -5
18

19
echo "=== mount 调用（挂载文件系统）==="
20
grep "mount" /tmp/runc-strace.log | head -10
21

22
echo "=== pivot_root 调用（切换根文件系统）==="
23
grep "pivot_root" /tmp/runc-strace.log
24

25
echo "=== prctl 调用（seccomp/Capabilities）==="
26
grep "prctl" /tmp/runc-strace.log | head -5
27

28
echo "=== Cgroup 写入 ==="
29
grep "cgroup" /tmp/runc-strace.log | head -5

1
// 在 libcontainer/linux/standard_init_linux.go 的 Init 方法中添加日志
2
func (l *linuxStandardInit) Init() error {
3
    logFile, _ := os.OpenFile("/tmp/runc-init.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
4
    log := log.New(logFile, "[runc-init] ", log.Lmicroseconds)
5

6
    log.Println("Starting container initialization")
7
    log.Printf("Container ID: %s", l.config.ContainerID)
8
    log.Printf("Namespaces: %v", l.config.Namespaces)
9

10
    // ... 原有初始化代码 ...
11

12
    log.Println("Setting up user namespace")
13
    if err := l.setupUser(); err != nil {
14
        log.Printf("setupUser failed: %v", err)
15
        return err
16
    }
17

18
    log.Println("Setting up cgroup")
19
    // ... 继续添加日志 ...
20

21
    log.Println("Container initialization complete, executing user command")
22
    return syscall.Exec(l.config.Args[0], l.config.Args, l.config.Env)
23
}