第12章：容器与命名空间

传统 Unix 进程视图：
    /
    ├── bin/
    ├── etc/
    ├── home/
    └── usr/

chroot 后的进程视图：
    / (实际上是 /var/chroot)
    ├── bin/
    ├── etc/
    └── lib/

// include/linux/nsproxy.h
struct nsproxy {
    atomic_t count;                    // 引用计数
    struct uts_namespace *uts_ns;     // UTS 命名空间
    struct ipc_namespace *ipc_ns;     // IPC 命名空间
    struct mnt_namespace *mnt_ns;     // Mount 命名空间
    struct pid_namespace *pid_ns_for_children; // PID 命名空间
    struct net *net_ns;                // Network 命名空间
    struct time_namespace *time_ns;    // Time 命名空间
    struct time_namespace *time_ns_for_children;
    struct cgroup_namespace *cgroup_ns; // Cgroup 命名空间
};

// include/linux/sched.h
struct task_struct {
    // ... 其他字段
    struct nsproxy *nsproxy;  // 命名空间代理
    // ...
};

// 创建新命名空间的标志位
#define CLONE_NEWNS     0x00020000  // Mount namespace
#define CLONE_NEWUTS    0x04000000  // UTS namespace
#define CLONE_NEWIPC    0x08000000  // IPC namespace
#define CLONE_NEWPID    0x20000000  // PID namespace
#define CLONE_NEWNET    0x40000000  // Network namespace
#define CLONE_NEWUSER   0x10000000  // User namespace
#define CLONE_NEWCGROUP 0x02000000  // Cgroup namespace
#define CLONE_NEWTIME   0x00000080  // Time namespace

主机视角：
    systemd (PID 1)
    ├── sshd (PID 1234)
    ├── container-runtime (PID 5678)
    │   └── container-init (PID 5679)  <- 容器内的 PID 1
    │       ├── app (PID 5680)         <- 容器内的 PID 2
    │       └── worker (PID 5681)      <- 容器内的 PID 3

容器内视角：
    init (PID 1)
    ├── app (PID 2)
    └── worker (PID 3)

// kernel/pid.c - PID 分配的核心结构
struct pid {
    atomic_t count;
    unsigned int level;           // PID 命名空间的层级
    /* 每个命名空间层级的 PID 号 */
    struct upid numbers[1];
};

struct upid {
    int nr;                       // 在该命名空间中的 PID
    struct pid_namespace *ns;    // 所属的命名空间
};

// PID 命名空间结构
struct pid_namespace {
    struct kref kref;
    struct pidmap pidmap[PIDMAP_ENTRIES];
    struct task_struct *child_reaper;  // init 进程
    unsigned int level;                // 层级深度
    struct pid_namespace *parent;      // 父命名空间
    // ...
};

// include/net/net_namespace.h
struct net {
    atomic_t count;               // 引用计数
    struct list_head list;        // 命名空间链表

    struct net_device *loopback_dev;  // 环回设备
    struct list_head dev_base_head;   // 网络设备链表

    struct sock *rtnl;            // rtnetlink 套接字
    struct sock *genl_sock;       // generic netlink

    struct netns_ipv4 ipv4;      // IPv4 相关
    struct netns_ipv6 ipv6;      // IPv6 相关
    struct netns_packet packet;   // packet 套接字
    struct netns_unix unx;        // Unix 域套接字

    struct net_generic *gen;      // 通用存储
    // ...
};

主机网络命名空间
    eth0 (10.0.0.1)
    docker0 (172.17.0.1) ──┐
                           │
                      veth pair
                           │
容器网络命名空间          │
    eth0 (172.17.0.2) ────┘
    lo (127.0.0.1)

// fs/mount.h
struct mnt_namespace {
    atomic_t count;
    struct mount *root;           // 根挂载点
    struct list_head list;        // 挂载点链表
    struct user_namespace *user_ns;
    u64 seq;                      // 序列号
    wait_queue_head_t poll;
    int event;
};

struct mount {
    struct hlist_node mnt_hash;
    struct mount *mnt_parent;     // 父挂载点
    struct dentry *mnt_mountpoint; // 挂载位置
    struct vfsmount mnt;
    // ...
};

// kernel/user_namespace.c
struct user_namespace {
    struct uid_gid_map uid_map;   // UID 映射
    struct uid_gid_map gid_map;   // GID 映射
    struct uid_gid_map projid_map; // 项目 ID 映射
    atomic_t count;
    struct user_namespace *parent;
    kuid_t owner;                  // 创建者的 UID
    kgid_t group;                  // 创建者的 GID
    unsigned int proc_inum;
    unsigned long flags;
    // ...
};

struct uid_gid_extent {
    u32 first;      // 映射的起始 ID
    u32 lower_first; // 父命名空间中的起始 ID
    u32 count;      // 映射数量
};

容器内 UID    主机 UID
0 (root)  ->  100000
1         ->  100001
999       ->  100999

/sys/fs/cgroup/
├── cpu/           # CPU 使用限制
│   ├── docker/
│   │   └── <container-id>/
│   │       ├── cpu.shares
│   │       └── cpu.cfs_quota_us
├── memory/        # 内存限制
│   ├── docker/
│   │   └── <container-id>/
│   │       ├── memory.limit_in_bytes
│   │       └── memory.usage_in_bytes
└── blkio/         # 块设备 I/O 限制

// kernel/cgroup/cgroup.c
struct cgroup {
    struct cgroup_subsys_state self;
    unsigned long flags;
    int id;
    int level;                    // 层级深度

    struct cgroup *parent;        // 父 cgroup
    struct kernfs_node *kn;       // kernfs 节点

    struct cgroup_file procs_file; // cgroup.procs 文件
    struct cgroup_file events_file; // cgroup.events 文件

    u16 subtree_control;          // 子树控制掩码
    u16 subtree_ss_mask;          // 子树子系统掩码

    struct list_head pidlists;    // PID 列表
    struct cgroup_rstat_cpu __percpu *rstat_cpu;
    // ...
};

/sys/fs/cgroup/unified/
├── cgroup.controllers      # 可用控制器
├── cgroup.subtree_control  # 子树启用的控制器
├── user.slice/
│   └── user-1000.slice/
│       ├── memory.max
│       ├── memory.current
│       ├── cpu.max
│       └── io.max
└── system.slice/
    └── docker.service/

// mm/memcontrol.c
struct mem_cgroup {
    struct cgroup_subsys_state css;

    struct mem_cgroup_id id;

    /* 内存计数器 */
    struct page_counter memory;    // 内存使用
    struct page_counter swap;      // 交换使用
    struct page_counter memsw;     // 内存+交换
    struct page_counter kmem;      // 内核内存
    struct page_counter tcpmem;    // TCP 缓冲区

    /* 软限制 */
    unsigned long soft_limit;

    /* 统计信息 */
    struct mem_cgroup_stat_cpu __percpu *stat_cpu;

    /* OOM 控制 */
    struct mem_cgroup_oom_info oom_info;
    bool oom_kill_disable;

    /* 内存回收 */
    struct work_struct high_work;
    unsigned long memory_pressure;
    // ...
};

// kernel/sched/fair.c
struct cfs_bandwidth {
    raw_spinlock_t lock;
    ktime_t period;               // 周期（默认 100ms）
    u64 quota;                    // 配额
    u64 runtime;                  // 剩余运行时间
    s64 hierarchical_quota;

    struct hrtimer period_timer;  // 周期定时器
    struct hrtimer slack_timer;   // 松弛定时器
    struct list_head throttled_cfs_rq;

    int nr_periods;
    int nr_throttled;
    u64 throttled_time;
};

// 简化的容器创建流程
pid_t create_container() {
    // 1. 创建新的命名空间
    int flags = CLONE_NEWNS | CLONE_NEWPID | CLONE_NEWNET | 
                CLONE_NEWIPC | CLONE_NEWUTS | CLONE_NEWUSER;

    // 2. 克隆进程并创建命名空间
    pid_t pid = clone(container_init, stack_top, flags | SIGCHLD, NULL);

    if (pid > 0) {  // 父进程
        // 3. 配置 user namespace 映射
        write_uid_map(pid);
        write_gid_map(pid);

        // 4. 设置 cgroups
        setup_cgroups(pid);

        // 5. 配置网络
        setup_network(pid);
    }

    return pid;
}

int container_init(void *arg) {
    // 容器内的 init 进程
    // 1. 设置主机名
    sethostname("container", 9);

    // 2. 挂载必要的文件系统
    mount("proc", "/proc", "proc", 0, NULL);
    mount("sys", "/sys", "sysfs", 0, NULL);

    // 3. pivot_root 切换根文件系统
    pivot_root("/new_root", "/new_root/.old_root");

    // 4. 卸载旧根
    umount2("/.old_root", MNT_DETACH);

    // 5. 执行容器应用
    execve("/bin/sh", argv, envp);
}

// config.json - OCI 运行时配置示例
{
    "ociVersion": "1.0.2",
    "process": {
        "terminal": true,
        "user": {
            "uid": 0,
            "gid": 0
        },
        "args": ["/bin/sh"],
        "env": [
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
            "TERM=xterm"
        ],
        "cwd": "/",
        "capabilities": {
            "bounding": ["CAP_NET_BIND_SERVICE"],
            "effective": ["CAP_NET_BIND_SERVICE"],
            "permitted": ["CAP_NET_BIND_SERVICE"]
        },
        "rlimits": [{
            "type": "RLIMIT_NOFILE",
            "hard": 1024,
            "soft": 1024
        }]
    },
    "root": {
        "path": "rootfs",
        "readonly": false
    },
    "mounts": [{
        "destination": "/proc",
        "type": "proc",
        "source": "proc"
    }],
    "linux": {
        "namespaces": [
            {"type": "pid"},
            {"type": "network"},
            {"type": "ipc"},
            {"type": "uts"},
            {"type": "mount"}
        ],
        "resources": {
            "memory": {
                "limit": 536870912
            },
            "cpu": {
                "shares": 1024,
                "quota": 100000,
                "period": 100000
            }
        }
    }
}

// libcontainer/process_linux.go 简化版
func (p *initProcess) start() error {
    // 1. 创建管道用于父子进程通信
    parentPipe, childPipe := newPipe()

    // 2. 启动进程
    cmd := p.cmd
    cmd.ExtraFiles = []*os.File{childPipe}
    cmd.Env = append(cmd.Env, 
        fmt.Sprintf("_LIBCONTAINER_INITPIPE=%d", 3))

    if err := cmd.Start(); err != nil {
        return err
    }

    // 3. 发送配置到子进程
    if err := p.sendConfig(); err != nil {
        return err
    }

    // 4. 等待子进程准备就绪
    if err := p.waitForChildExit(); err != nil {
        return err
    }

    // 5. 配置 cgroups
    if err := p.manager.Apply(p.pid()); err != nil {
        return err
    }

    // 6. 设置网络
    if err := p.createNetworkInterfaces(); err != nil {
        return err
    }

    // 7. 通知子进程继续
    if err := p.sendContinue(); err != nil {
        return err
    }

    return nil
}

   主机网络命名空间                    容器网络命名空间
   ┌──────────────┐                  ┌──────────────┐
   │              │                  │              │
   │  docker0     │                  │    eth0      │
   │  (bridge)    │◄────veth pair───►│  172.17.0.2  │
   │  172.17.0.1  │                  │              │
   │              │                  │              │
   │     eth0     │                  │              │
   │  10.0.0.100  │                  │              │
   └──────────────┘                  └──────────────┘
          │
          ▼
    外部网络 (NAT)

// 创建 veth pair
int create_veth_pair(const char *veth1, const char *veth2) {
    struct nl_sock *sock = nl_socket_alloc();
    struct rtnl_link *link = rtnl_link_alloc();
    struct rtnl_link *peer = rtnl_link_alloc();

    // 设置 veth 类型
    rtnl_link_set_type(link, "veth");
    rtnl_link_set_name(link, veth1);
    rtnl_link_set_name(peer, veth2);

    // 创建 veth pair
    return rtnl_link_add(sock, link, NLM_F_CREATE);
}

// 将 veth 一端移到容器命名空间
int move_veth_to_netns(const char *veth, pid_t pid) {
    char path[256];
    snprintf(path, sizeof(path), "/proc/%d/ns/net", pid);

    int netns_fd = open(path, O_RDONLY);
    struct nl_sock *sock = nl_socket_alloc();
    struct rtnl_link *link = rtnl_link_get_by_name(sock, veth);

    rtnl_link_set_ns_fd(link, netns_fd);
    return rtnl_link_change(sock, link, link, 0);
}

应用程序
    │
    ▼ 系统调用
Sentry (用户态内核)
    │
    ▼ 有限的系统调用
主机内核

// Sentry 系统调用拦截
func (k *Kernel) SyscallEnter(t *Task, sysno uintptr, args arch.SyscallArguments) {
    // 检查系统调用是否允许
    if !k.featureSet.HasFeature(sysno) {
        return syserror.ENOSYS
    }

    // 执行系统调用模拟
    switch sysno {
    case syscall.SYS_OPEN:
        return k.sysOpen(t, args)
    case syscall.SYS_READ:
        return k.sysRead(t, args)
    case syscall.SYS_WRITE:
        return k.sysWrite(t, args)
    // ...
    }
}

容器运行时 (containerd/CRI-O)
         │
         ▼
    kata-runtime
         │
    ┌────┴────┐
    ▼         ▼
kata-proxy  kata-shim
    │         │
    └────┬────┘
         ▼
    kata-agent (VM内)
         │
         ▼
    Guest Kernel
         │
         ▼
    Container App

// DAX (Direct Access) 内存映射
struct dax_device {
    struct inode *inode;
    struct cdev cdev;
    void *private;
    unsigned long flags;
    const struct dax_operations *ops;
};

// 内存去重 (KSM - Kernel Same-page Merging)
struct ksm_scan {
    struct mm_struct *mm_slot;
    unsigned long address;
    struct rmap_item **rmap_list;
    unsigned long seqnr;
};

// 定义 seccomp 过滤规则
struct sock_filter filter[] = {
    // 加载系统调用号
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 
             offsetof(struct seccomp_data, nr)),

    // 允许的系统调用
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_read, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),

    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),

    // 默认拒绝
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL),
};

struct sock_fprog prog = {
    .len = sizeof(filter) / sizeof(filter[0]),
    .filter = filter,
};

// 应用过滤规则
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

# AppArmor 容器配置文件示例
profile docker-container flags=(attach_disconnected,mediate_deleted) {
  # 网络访问
  network inet,
  network inet6,

  # 文件访问
  deny @{PROC}/* w,
  deny @{PROC}/.* w,
  deny /sys/[^f]*/** w,
  deny /sys/f[^s]*/** w,

  # 挂载权限
  mount,
  umount,
  pivot_root,

  # 权能限制
  capability net_bind_service,
  capability setuid,
  capability setgid,
  deny capability sys_admin,
}

// 权能集合管理
struct cred {
    // ... 其他字段
    kernel_cap_t cap_inheritable;  // 可继承权能
    kernel_cap_t cap_permitted;    // 允许的权能
    kernel_cap_t cap_effective;    // 生效的权能
    kernel_cap_t cap_bset;        // 边界集
    kernel_cap_t cap_ambient;     // 环境权能
    // ...
};

// 常用容器权能配置
#define CONTAINER_CAPS ( \
    CAP_TO_MASK(CAP_CHOWN) | \
    CAP_TO_MASK(CAP_DAC_OVERRIDE) | \
    CAP_TO_MASK(CAP_FSETID) | \
    CAP_TO_MASK(CAP_FOWNER) | \
    CAP_TO_MASK(CAP_SETGID) | \
    CAP_TO_MASK(CAP_SETUID) | \
    CAP_TO_MASK(CAP_SETPCAP) | \
    CAP_TO_MASK(CAP_NET_BIND_SERVICE) | \
    CAP_TO_MASK(CAP_KILL) \
)

// Pod 内容器的命名空间配置
struct pod_namespace_config {
    // 共享的命名空间
    struct net *net_ns;        // 共享网络命名空间
    struct ipc_namespace *ipc_ns; // 共享 IPC 命名空间
    struct uts_namespace *uts_ns; // 共享 UTS 命名空间

    // 独立的命名空间
    struct pid_namespace *pid_ns; // 各自的 PID 命名空间
    struct mnt_namespace *mnt_ns; // 各自的挂载命名空间
};

// Pause 容器（基础设施容器）
void create_pause_container() {
    // 创建共享的命名空间
    unshare(CLONE_NEWNET | CLONE_NEWIPC | CLONE_NEWUTS);

    // Pause 容器只是持有命名空间
    while (1) {
        pause();  // 永久休眠
    }
}

// 共享内存 IPC
struct shm_container_ipc {
    int shmid;
    void *addr;
    size_t size;
};

// Unix 域套接字
struct unix_socket_ipc {
    int sock_fd;
    struct sockaddr_un addr;
};

// 内存映射文件
struct mmap_ipc {
    int fd;
    void *addr;
    size_t length;
};

// 使用 cgroup v2 的压力指标进行动态调整
struct psi_group {
    struct mutex trigger_lock;
    struct psi_trigger *triggers;
    u64 total[NR_PSI_TASK_COUNTS][NR_PSI_STATES];
    u64 avg[NR_PSI_STATES][3];  // 10s, 60s, 300s
};

// 内存压力监控
void monitor_memory_pressure(struct cgroup *cgrp) {
    struct psi_group *psi = cgrp->psi;
    u64 pressure = psi->avg[PSI_MEM_SOME][0];  // 10s average

    if (pressure > THRESHOLD_HIGH) {
        // 触发内存回收
        reclaim_memory(cgrp);
    } else if (pressure < THRESHOLD_LOW) {
        // 可以增加内存限制
        increase_memory_limit(cgrp);
    }
}

# CRIU 容器检查点
criu dump -t $PID -D /checkpoint --shell-job

# 快速恢复
criu restore -D /checkpoint --shell-job