7.2 namespace 與 cgroups：以 Rust 實作容器隔離#

// src/mini_container.rs — 需要 Linux + root
use libc::{clone, CLONE_NEWNS, CLONE_NEWPID, CLONE_NEWUTS, SIGCHLD};
use std::ffi::CString;

const STACK_SIZE: usize = 1024 * 1024;

pub fn run_in_namespaces<F>(child: F) -> std::io::Result<i32>
where
    F: FnOnce(),
{
    let stack: &mut [u8; STACK_SIZE] = Box::leak(Box::new([0; STACK_SIZE]));
    // clone 旗標 = 在新行程中同時建立多種 namespace
    let flags = SIGCHLD | CLONE_NEWNS | CLONE_NEWPID | CLONE_NEWUTS;

    extern "C" fn trampoline(_arg: *mut libc::c_void) -> i32 {
        // 在新 namespace 內執行的第一行程
        unsafe {
            // PID namespace 內我們是 1 號
            println!("in new namespaces: pid = {}", libc::getpid());
        }
        container_child();
        0
    }

    let ret = unsafe {
        clone(trampoline, stack.as_mut_ptr().add(STACK_SIZE), flags, std::ptr::null_mut())
    };
    if ret < 0 { return Err(std::io::Error::last_os_error()); }
    Ok(ret)
}

fn container_child() {
    // 1. 改 hostname（UTS namespace 隔離）
    let host = CString::new("mini-container").unwrap();
    unsafe { libc::sethostname(host.as_ptr(), 14); }

    // 2. 掛新的 procfs（mount namespace 隔離）——
    //    讓 /proc 反映「只有容器內的程序」
    unsafe {
        let proc_dir = CString::new("proc").unwrap();
        let proc_fs = CString::new("proc").unwrap();
        libc::mkdir(proc_dir.as_ptr(), 0o755);
        libc::mount(proc_fs.as_ptr(), proc_dir.as_ptr(), proc_fs.as_ptr(), 0, std::ptr::null());
    }

    // 3. chroot 到容器根檔案系統（7.3 節用 overlayfs 準備）
    // chroot(".");
}

# 建立 cgroup，限制 CPU 50%、記憶體 100MB
mkdir /sys/fs/cgroup/mini
echo "50000 100000" > /sys/fs/cgroup/mini/cpu.max    # 50ms / 100ms
echo "104857600" > /sys/fs/cgroup/mini/memory.max    # 100MB
echo $PID > /sys/fs/cgroup/mini/cgroup.procs         # 把行程放進去

// src/cgroup.rs
use std::fs;
use std::path::Path;

pub struct Cgroup {
    pub path: String,   // 例 "/sys/fs/cgroup/mini"
}

pub struct CgroupSpec {
    pub cpu_quota_us: u64,      // 每 period 的配額
    pub cpu_period_us: u64,
    pub memory_max: u64,
    pub pid_max: u32,
}

impl Cgroup {
    pub fn create(name: &str, spec: CgroupSpec) -> std::io::Result<Self> {
        let path = format!("/sys/fs/cgroup/{name}");
        fs::create_dir_all(&path)?;

        // 寫配額——每個檔案就是一個核心介面
        fs::write(format!("{path}/cpu.max"),
            format!("{} {}", spec.cpu_quota_us, spec.cpu_period_us))?;
        fs::write(format!("{path}/memory.max"), spec.memory_max.to_string())?;
        fs::write(format!("{path}/pids.max"), spec.pid_max.to_string())?;
        Ok(Cgroup { path })
    }

    pub fn attach(&self, pid: i32) -> std::io::Result<()> {
        fs::write(format!("{}/cgroup.procs", self.path), pid.to_string())
    }

    pub fn current_usage(&self) -> std::io::Result<u64> {
        let s = fs::read_to_string(format!("{}/memory.current", self.path))?;
        Ok(s.trim().parse().unwrap_or(0))
    }
}

fn main() -> std::io::Result<()> {
    let spec = CgroupSpec {
        cpu_quota_us: 50_000, cpu_period_us: 100_000,
        memory_max: 100 * 1024 * 1024,
        pid_max: 64,
    };
    let cg = Cgroup::create("mini", spec)?;

    let pid = run_in_namespaces(|| {
        // 進入容器後：
        // - 我們是 PID 1
        // - hostname 是 mini-container
        // - /proc 只顯示容器內程序
        // - CPU 最多 50%、記憶體最多 100MB
        println!("hello from container");
    })?;

    cg.attach(pid)?;
    Ok(())
}

$ sudo cargo run
in new namespaces: pid = 1        # ← 容器內第一行程，PID 1
hello from container