1
// Linux 内核中 Namespace 的核心数据结构（简化）
2
struct nsproxy {
3
    struct uts_namespace *uts_ns;     // UTS: 主机名
4
    struct ipc_namespace *ipc_ns;     // IPC: 进程间通信
5
    struct mnt_namespace *mnt_ns;     // Mount: 挂载点
6
    struct pid_namespace *pid_ns;     // PID: 进程 ID
7
    struct net *net_ns;               // Network: 网络栈
8
    struct cgroup_namespace *cgroup_ns; // Cgroup: Cgroup 视图
9
    struct user_namespace *user_ns;   // User: 用户 ID
10
    struct time_namespace *time_ns;   // Time: 时钟
11
};
12

13
// 每个进程的 task_struct 包含 nsproxy 指针
14
struct task_struct {
15
    struct nsproxy *nsproxy;
16
    // ...
17
};

1
// clone: 创建新进程并加入新 Namespace
2
#define _GNU_SOURCE
3
#include <sched.h>
4
#include <stdio.h>
5
#include <stdlib.h>
6

7
static int child_func(void *arg) {
8
    printf("Child PID: %d\n", getpid());  // 在新 PID Namespace 中，PID 为 1
9
    return 0;
10
}
11

12
int main() {
13
    // 分配子进程栈
14
    char *stack = malloc(1024 * 1024);
15
    char *stack_top = stack + 1024 * 1024;
16

17
    // 创建子进程，同时创建新的 PID 和 Mount Namespace
18
    pid_t pid = clone(child_func, stack_top,
19
                      CLONE_NEWPID | CLONE_NEWNS | SIGCHLD, NULL);
20
    if (pid == -1) {
21
        perror("clone");
22
        return 1;
23
    }
24

25
    printf("Parent PID: %d, Child PID: %d\n", getpid(), pid);
26
    wait(NULL);
27
    free(stack);
28
    return 0;
29
}

1
# unshare: 将当前进程移入新 Namespace
2
# 创建新的 Mount Namespace 并挂载 proc
3
sudo unshare --mount --pid --fork --mount-proc /bin/bash
4

5
# setns: 加入已有的 Namespace
6
# 进入 Docker 容器的 Network Namespace
7
sudo nsenter -t $(docker inspect -f '{{.State.Pid}}' mycontainer) -n ip addr

1
# 在容器中看到的 PID
2
docker exec mycontainer ps aux
3
# PID   USER     COMMAND
4
# 1     root     nginx: master process
5
# 10    nginx    nginx: worker process
6

7
# 在宿主机上看到的同一进程
8
ps aux | grep nginx
9
# root  12345  ...  nginx: master process
10
# 101   12346  ...  nginx: worker process

1
# 创建新的 Mount Namespace
2
sudo unshare --mount /bin/bash
3

4
# 在新 Namespace 中挂载 tmpfs
5
mount -t tmpfs tmpfs /mnt
6
mount | grep /mnt
7
# tmpfs on /mnt type tmpfs
8

9
# 在另一个终端（宿主 Namespace）查看
10
mount | grep /mnt
11
# 看不到 /mnt 的挂载——因为 Mount Namespace 隔离了挂载点视图

1
# 查看挂载点的传播类型
2
findmnt -o TARGET,PROPAGATION
3

4
# 将挂载点设为 private（容器常用）
5
mount --make-private /
6

7
# 将挂载点设为 slave
8
mount --make-slave /sys

1
# runc 的典型 mount 操作（简化）
2
mount -t proc proc /proc                    # 挂载 procfs
3
mount -t sysfs sysfs /sys                    # 挂载 sysfs
4
mount -t devtmpfs devtmpfs /dev              # 挂载 devtmpfs
5
mount -t tmpfs tmpfs /dev/shm                # 挂载共享内存
6
mount -t tmpfs tmpfs /run                    # 挂载运行时目录
7
mount -t cgroup2 cgroup2 /sys/fs/cgroup      # 挂载 Cgroup v2

1
# 创建 Network Namespace
2
sudo ip netns add ns1
3
sudo ip netns add ns2
4

5
# 查看 Namespace 中的网络设备
6
sudo ip netns exec ns1 ip link
7
# 1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN
8
# 只有 loopback 设备，且处于 DOWN 状态
9

10
# 创建 veth pair 连接两个 Namespace
11
sudo ip link add veth1 type veth peer name veth2
12
sudo ip link set veth1 netns ns1
13
sudo ip link set veth2 netns ns2
14

15
# 配置 IP 地址
16
sudo ip netns exec ns1 ip addr add 10.0.0.1/24 dev veth1
17
sudo ip netns exec ns1 ip link set veth1 up
18
sudo ip netns exec ns1 ip link set lo up
19

20
sudo ip netns exec ns2 ip addr add 10.0.0.2/24 dev veth2
21
sudo ip netns exec ns2 ip link set veth2 up
22
sudo ip netns exec ns2 ip link set lo up
23

24
# 测试连通性
25
sudo ip netns exec ns1 ping -c 3 10.0.0.2

1
{
2
  "cniVersion": "0.4.0",
3
  "name": "bridge-network",
4
  "type": "bridge",
5
  "bridge": "cni0",
6
  "ipam": {
7
    "type": "host-local",
8
    "subnet": "10.244.0.0/16",
9
    "routes": [{"dst": "0.0.0.0/0"}]
10
  }
11
}

1
# 创建 User Namespace，映射 UID
2
sudo unshare --user --map-root-user /bin/bash
3

4
# 在新 User Namespace 中
5
id
6
# uid=0(root) gid=0(root)
7

8
# 但在宿主机上，这个进程的实际 UID 是普通用户
9
# 从另一个终端查看
10
ps -o pid,uid,ruid,comm -p $(pgrep -f "unshare")

1
# 查看 Docker 容器的 UID 映射
2
cat /proc/$(docker inspect -f '{{.State.Pid}}' mycontainer)/uid_map
3
# 0  100000  65536
4
# 含义：容器内 UID 0-65535 → 宿主机 UID 100000-165535
5

6
# 手动配置 UID 映射
7
echo "0 100000 65536" > /proc/$PID/uid_map
8
echo "0 100000 65536" > /proc/$PID/gid_map

1
# 查看 System V IPC 对象
2
ipcs -q   # 消息队列
3
ipcs -m   # 共享内存
4
ipcs -s   # 信号量
5

6
# 在新 IPC Namespace 中，看不到宿主的 IPC 对象
7
sudo unshare --ipc /bin/bash
8
ipcs -q   # 空的

1
# 创建新 UTS Namespace 并设置主机名
2
sudo unshare --uts /bin/bash
3
hostname mycontainer
4
hostname
5
# mycontainer
6

7
# 宿主机的主机名不受影响

1
# 不使用 Cgroup Namespace
2
cat /proc/self/cgroup
3
# 0::/system.slice/docker-abc123.scope  → 看到完整路径
4

5
# 使用 Cgroup Namespace
6
sudo unshare --cgroup /bin/bash
7
cat /proc/self/cgroup
8
# 0::/  → 看到的是根目录，不知道自己在子树中

1
# 创建 Time Namespace
2
sudo unshare --time /bin/bash
3

4
# 修改 Time Namespace 的偏移
5
# /proc/PID/timens_offsets

1
{
2
  "linux": {
3
    "namespaces": [
4
      { "type": "pid" },
5
      { "type": "mount" },
6
      { "type": "ipc" },
7
      { "type": "uts" },
8
      { "type": "network" },
9
      { "type": "cgroup" }
10
    ]
11
  }
12
}

1
package main
2

3
import (
4
    "fmt"
5
    "os"
6
    "os/exec"
7
    "syscall"
8
)
9

10
func main() {
11
    switch os.Args[1] {
12
    case "run":
13
        run()
14
    case "child":
15
        child()
16
    default:
17
        panic("invalid command")
18
    }
19
}
20

21
func run() {
22
    cmd := exec.Command("/proc/self/exe", append([]string{"child"}, os.Args[2:]...)...)
23
    cmd.Stdin = os.Stdin
24
    cmd.Stdout = os.Stdout
25
    cmd.Stderr = os.Stderr
26

27
    // 创建新的 Namespace
28
    cmd.SysProcAttr = &syscall.SysProcAttr{
29
        Cloneflags: syscall.CLONE_NEWUTS |
30
            syscall.CLONE_NEWPID |
31
            syscall.CLONE_NEWNS |
32
            syscall.CLONE_NEWNET |
33
            syscall.CLONE_NEWIPC,
34
    }
35

36
    must(cmd.Run())
37
}
38

39
func child() {
40
    fmt.Printf("Running %v as PID %d\n", os.Args[2:], os.Getpid())
41

42
    // 挂载 proc（在新 Mount Namespace 中）
43
    must(syscall.Mount("proc", "/proc", "proc", 0, ""))
44

45
    cmd := exec.Command(os.Args[2], os.Args[3:]...)
46
    cmd.Stdin = os.Stdin
47
    cmd.Stdout = os.Stdout
48
    cmd.Stderr = os.Stderr
49
    must(cmd.Run())
50
}
51

52
func must(err error) {
53
    if err != nil {
54
        panic(err)
55
    }
56
}

1
#!/bin/bash
2
# 可视化进程的 Namespace 关系
3

4
echo "=== 容器进程的 Namespace ==="
5
for pid in $(docker top mycontainer -o pid | tail -n +2); do
6
    echo "PID $pid:"
7
    ls -la /proc/$pid/ns/ 2>/dev/null | awk '{print "  " $NF}'
8
done
9

10
echo ""
11
echo "=== 宿主进程的 Namespace ==="
12
echo "PID 1 (systemd):"
13
ls -la /proc/1/ns/ | awk '{print "  " $NF}'
14

15
echo ""
16
echo "=== Namespace 差异 ==="
17
echo "容器进程与宿主进程的 Namespace 不同 = 隔离生效"

1
ls -la /proc/self/ns/

1
cgroup:[4026531835]
2
ipc:[4026532213]
3
mnt:[4026532224]
4
net:[4026531840]
5
pid:[4026532226]
6
time:[4026531834]
7
user:[4026531837]
8
uts:[4026532225]

1
# 在新 UTS Namespace 中设置主机名
2
unshare --uts sh -c 'hostname isolated-host && hostname'
3
# isolated-host
4

5
# 宿主主机名未变
6
hostname
7
# LAPTOP-NMOAUL8E

1
# 创建新的 PID Namespace，--fork 必须，--mount-proc 让 ps 只看到新 Namespace 的进程
2
unshare --pid --fork --mount-proc sh -c 'echo "容器内 PID: $$" && ps aux'

1
容器内 PID: 1
2
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
3
root           1  0.0  0.0   2800  1664 ?        S    01:32   0:00 sh -c echo "容器内 PID: $$" && ps aux
4
root           2  0.0  0.0  11320  4352 ?        R    01:32   0:00 ps aux

1
echo "宿主 PID: $$"
2
# 宿主 PID: 3361650

1
# 创建新的 Network Namespace
2
unshare --net sh -c 'ip link show'

1
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT qlen 1000
2
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

1
# 找到容器的 PID
2
CONTAINER_PID=$(docker inspect -f '{{.State.Pid}}' mycontainer)
3

4
# 进入容器的 Namespace
5
nsenter -t $CONTAINER_PID -m -p -u -i -n -- /bin/sh