Linux 隔离与虚拟化

September 2, 2026

系统调用拦截

拦截系统调用并在用户态实现它（用户态内核）。

ptrace 是以线程为单位，通过信号追踪系统调用和寄存器的机制。

#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/user.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

static long handle_syscall(pid_t child, struct user_regs_struct *regs) {
    long syscall_nr = regs->orig_rax;
    switch (syscall_nr) {
    case SYS_getpid: return 1;
    case SYS_getuid: return 0;
    default: return -1;
    }
}

static void run_sentry(pid_t child) {
    int status;
    waitpid(child, &status, 0); // 等待子进程信号。实际等待子进程主动发起的 raise(SIGSTOP)
    ptrace(PTRACE_SETOPTIONS, child, 0, PTRACE_O_TRACESYSGOOD); // 当子进程因为系统调用而暂停时，往信号上加 0x80（即 SIGTRAP | 0x80）
    ptrace(PTRACE_SYSCALL, child, 0, 0); // 让子进程恢复执行，但指示内核"在每次系统调用的入口和出口都暂停一次"
    // 注意：gVisor 使用 PTRACE_SYSEMU，即"完全跳过系统调用执行"，这样需要处理所有系统调用号
    // 这里使用 PTRACE_SYSCALL，只伪造我们处理的系统调用，系统调用本身仍会执行

    int entering = 0;
    long result;
    while (1) {
        waitpid(child, &status, 0); // 等待子进程信号
        if (WIFEXITED(status)) break; // 忽略无关信号
        if (WIFSTOPPED(status) && (WSTOPSIG(status) & 0x80)) { // 有 0x80 标识
            entering = !entering; // 第一次为系统调用入口，entering = 1

            struct user_regs_struct regs;
            ptrace(PTRACE_GETREGS, child, 0, &regs); // 读取子进程通用寄存器
            if (entering) {
                // 入口时保存伪造结果
                if ((result = handle_syscall(child, &regs)) != -1) {
                    // 系统调用进入时，让实际执行的系统调用号为特殊的-1，即不实际执行系统调用
                    regs.orig_rax = -1; // 原始系统调用寄存器
                    ptrace(PTRACE_SETREGS, child, 0, &regs); // 写回子进程通用寄存器
                }
            } else {
                // 出口时使用入口保存的伪造值
                if (result != -1) {
                    // 系统调用返回时，覆盖为 handle_syscall 的伪造值
                    regs.rax = result; // 结果寄存器
                    ptrace(PTRACE_SETREGS, child, 0, &regs);
                }
            }
        }
        ptrace(PTRACE_SYSCALL, child, 0, 0); // 恢复子进程执行
    }
}

// 执行 ./PROGRAM python -c "import os; print(os.getpid())"
// 输出 1
int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <cmd> [args...]\n", argv[0]);
        return 1;
    }
    pid_t child = fork();
    if (child == 0) {
        ptrace(PTRACE_TRACEME, 0, 0, 0); // PTRACE_TRACEME 请求内核让父进程追踪当前进程
        raise(SIGSTOP); // 暂停当前进程
        execvp(argv[1], &argv[1]); // 执行给定命令
        perror("execvp");
        _exit(127);
    }
    printf("[sentry] tracing pid %d\n", child);
    run_sentry(child);
    printf("[sentry] child exited\n");
    return 0;
}

seccomp (Secure Computing state of the process) 用于操作调用进程的安全计算（允许执行的系统调用）状态。
seccomp 支持通过 SECCOMP_IOCTL_NOTIF_*，通过 ioctl 实现用户态进程监听和拦截系统调用。

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stddef.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>

// BPF 过滤器：命中 getpid/getuid 时暂停系统调用并通知监控进程，其余一律放行
static struct sock_filter filter[] = {
    // 校验架构，避免 x32 ABI 等导致系统调用号歧义
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, arch)),
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, AUDIT_ARCH_X86_64, 1, 0),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL_PROCESS),

    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_getpid, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_USER_NOTIF), //! 这里设置拦下并通知监控者，不真正执行
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_getuid, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_USER_NOTIF),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
};

// 安装过滤器，返回 notify fd（本进程及其子孙的命中事件都会发到这个 fd）
static int install_filter(void) {
    struct sock_fprog prog = {
        .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
        .filter = filter,
    };
    // no_new_privs 是无 CAP_SYS_ADMIN 时安装 seccomp 过滤器的前提
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
        perror("prctl");
        return -1;
    }
    // https://www.man7.org/linux/man-pages/man2/seccomp.2.html
    int fd = syscall(SYS_seccomp, SECCOMP_SET_MODE_FILTER,
                     SECCOMP_FILTER_FLAG_NEW_LISTENER, &prog);
    if (fd < 0) perror("seccomp");
    return fd;
}

// 通过 unix socket 用 SCM_RIGHTS 把 notify fd 从子进程（被过滤者）传给父进程（监控者）
static int send_fd(int sock, int fd) {
    char dummy = 'x';
    struct iovec iov = { .iov_base = &dummy, .iov_len = 1 };
    char buf[CMSG_SPACE(sizeof(int))];
    struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1,
                          .msg_control = buf, .msg_controllen = sizeof(buf) };
    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(int));
    memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
    return sendmsg(sock, &msg, 0);
}

static int recv_fd(int sock) {
    char dummy;
    struct iovec iov = { .iov_base = &dummy, .iov_len = 1 };
    char buf[CMSG_SPACE(sizeof(int))];
    struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1,
                          .msg_control = buf, .msg_controllen = sizeof(buf) };
    if (recvmsg(sock, &msg, 0) < 0) return -1;
    int fd;
    memcpy(&fd, CMSG_DATA(CMSG_FIRSTHDR(&msg)), sizeof(int));
    return fd;
}

// 监控循环：等价于 ptrace 版的 run_sentry
static void run_monitor(int notify_fd, pid_t child) {
    // 协商 seccomp_notif/resp 结构体大小，兼容新旧内核 ABI
    struct seccomp_notif_sizes sizes = {0};
    if (syscall(SYS_seccomp, SECCOMP_GET_NOTIF_SIZES, 0, &sizes) < 0) {
        perror("GET_NOTIF_SIZES");
    }
    struct seccomp_notif *req = calloc(1, sizes.seccomp_notif);
    struct seccomp_notif_resp *resp = calloc(1, sizes.seccomp_notif_resp);

    int reaped = 0;
    while (1) {
        // 内核 6.13+ 要求 RECV 的缓冲区必须全零（check_zeroed_user，为结构体扩展预留），
        // 上次 RECV 写入的通知数据必须清掉，否则返回 EINVAL
        memset(req, 0, sizes.seccomp_notif);
        // RECV 阻塞，直到目标进程命中 getpid/getuid；此时目标的系统调用被内核挂起
        if (ioctl(notify_fd, SECCOMP_IOCTL_NOTIF_RECV, req) < 0) {
            // 目标进程退出会唤醒阻塞的 RECV：通知队列已空，属正常结束。
            // （此刻目标可能尚未变成僵尸，回收交给循环后的 waitpid）
            if (errno == ENOENT || errno == ENODEV) break;
            // 6.13+ 的内核在最后一个被过滤任务退出、通知状态销毁后也可能返回 EINVAL，
            // 用 waitpid 确认目标确实退出，避免把真正的调用错误当正常结束
            if (errno == EINVAL && waitpid(child, NULL, WNOHANG) == child) {
                reaped = 1;
                break;
            }
            perror("NOTIF_RECV");
            break;
        }

        memset(resp, 0, sizes.seccomp_notif_resp);
        resp->id = req->id;   // 响应对应哪次请求（内核据此找到挂起的任务）
        resp->val = (req->data.nr == SYS_getpid) ? 1 : 0; // 伪造 pid=1、uid=0(root)
        resp->error = 0;      // 0 表示成功（负值表示 -errno）
        resp->flags = 0;      // 不设 SECCOMP_USER_NOTIF_FLAG_CONTINUE：系统调用从不真正执行，
                              // 效果等同 ptrace 版把 orig_rax 改为 -1（PTRACE_SYSEMU 式拦截）
        if (ioctl(notify_fd, SECCOMP_IOCTL_NOTIF_SEND, resp) < 0) {
            if (errno == ENOENT) continue; // 目标在等待回复期间被杀，丢弃即可
            perror("NOTIF_SEND");
            break;
        }
    }

    free(req);
    free(resp);
    if (!reaped) waitpid(child, NULL, 0); // 回收子进程（上面已回收过则跳过）
}

// 执行 ./PROGRAM python3 -c "import os; print(os.getpid())"
// 输出 1
int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <cmd> [args...]\n", argv[0]);
        return 1;
    }

    int sv[2];
    if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) < 0) {
        perror("socketpair");
        return 1;
    }

    pid_t child = fork();
    if (child == 0) {
        close(sv[0]);
        // 子进程自己安装过滤器，避免监控者（父进程）自身的 getpid 也被拦
        int notify_fd = install_filter();
        if (notify_fd < 0) _exit(1);
        // seccomp 过滤器随 exec 保留，但 notify fd 默认带 CLOEXEC，先发给父进程再 exec
        if (send_fd(sv[1], notify_fd) < 0) _exit(1);
        close(notify_fd);
        close(sv[1]);
        execvp(argv[1], &argv[1]);
        perror("execvp");
        _exit(127);
    }

    close(sv[1]);
    int notify_fd = recv_fd(sv[0]); // 拿到 notify fd，角色类似 ptrace 中的 tracer
    close(sv[0]);
    if (notify_fd < 0) {
        perror("recv_fd");
        return 1;
    }

    printf("[sentry] monitoring pid %d via seccomp notify fd %d\n", child, notify_fd);
    run_monitor(notify_fd, child);
    close(notify_fd);
    printf("[sentry] child exited\n");
    return 0;
}

操作系统级虚拟化

Linux namespaces 是内核级隔离机制，通过包装全局系统资源，使命名空间内的进程拥有独立的资源实例，常用于实现容器。Linux 提供 8 种命名空间，包括 Cgroup、IPC、Network、Mount、PID、Time、User 和 UTS。

docker/podman 通过这种方式实现。

// 最小容器实现：namespace + cgroup + pivot_root
// 需要 root 权限运行，创建具有隔离 PID/NET/MNT/UTS 的容器
#define _GNU_SOURCE
#include <sched.h>       // clone, CLONE_NEW*
#include <unistd.h>      // execvp, sethostname, chdir
#include <sys/mount.h>   // mount, umount2
#include <sys/stat.h>    // mkdir
#include <sys/wait.h>    // waitpid
#include <sys/syscall.h> // SYS_pivot_root
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>

#define STACK_SIZE (1024 * 1024)

struct child_args {
    char **argv;
    char rootfs[PATH_MAX];
};

static const char cg_path[] = "/sys/fs/cgroup/mini_container";

// 向容器 cgroup 下的控制文件写入内容，如 write_cgroup("pids.max", "64")
static void write_cgroup(const char *filename, const char *content) {
    char path[PATH_MAX];
    snprintf(path, sizeof(path), "%s/%s", cg_path, filename);
    int fd = open(path, O_WRONLY);
    if (fd >= 0) {
        write(fd, content, strlen(content));
        close(fd);
    }
}

static int child_fn(void *arg) {
    struct child_args *ca = (struct child_args *)arg;

    sethostname("container", 9); // 设置容器内主机名（在新 UTS namespace 中生效）

    // 用 pivot_root 切换根文件系统
    mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL); // 根挂载点改为私有，避免挂载传播污染宿主机
    mount(ca->rootfs, ca->rootfs, NULL, MS_BIND | MS_REC, NULL); // 绑定挂载到自身，使其成为挂载点（pivot_root 要求）

    char old_root[PATH_MAX];
    snprintf(old_root, sizeof(old_root), "%s/.old_root", ca->rootfs);
    mkdir(old_root, 0700); // 旧根的挂载点（pivot_root 要求 put_old 位于 new_root 之下）

    syscall(SYS_pivot_root, ca->rootfs, old_root); // 把根切换为 rootfs，旧根挂到 .old_root
    chdir("/"); // 切到新根，否则卸载旧根会失败

    umount2("/.old_root", MNT_DETACH); // 卸载旧根文件系统
    rmdir("/.old_root");

    // 挂载 /proc；procfs 绑定当前 PID namespace，只显示容器内进程
    mkdir("/proc", 0555);
    mount("proc", "/proc", "proc", 0, NULL);

    // 不继承宿主机环境变量，只设置容器需要的最小集合
    clearenv();
    setenv("PATH", "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 1); // execvp 按此 PATH 在新根内搜索
    setenv("HOME", "/", 1);
    setenv("TERM", "xterm", 1);

    execvp(ca->argv[0], ca->argv); // 按新根解析路径执行容器内命令（该进程为 PID 1）
    perror("execvp");
    return 1;
}

// 测试命令：
// sudo ./PROGRAM ./rootfs /busybox hostname   # 输出 container（UTS 隔离）
// sudo ./PROGRAM ./rootfs /busybox ps         # 只看到 ps 自己（PID 隔离）
// sudo ./PROGRAM ./rootfs /busybox ip addr    # 只有 lo 且 DOWN（网络隔离）
// sudo ./PROGRAM ./rootfs /busybox sh         # 交互 shell，自由探索
int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <rootfs> <cmd> [args...]\n", argv[0]);
        return 1;
    }

    struct child_args ca;
    realpath(argv[1], ca.rootfs); // 解析为绝对路径
    ca.argv = &argv[2]; // 容器内要执行的命令

    // 配置 cgroup v2 资源限制
    mkdir(cg_path, 0755);
    write_cgroup("memory.max", "67108864"); // 内存上限 64MB，超限触发 OOM kill
    write_cgroup("pids.max", "64");         // 进程数上限 64，防 fork 炸弹

    // 带 namespace 标志的 clone，创建隔离的子进程：
    // NEWPID 独立进程号空间  NEWNS 独立挂载表  NEWUTS 独立主机名
    // NEWNET 独立网络栈（默认断网）  NEWIPC 独立 IPC
    char *stack = malloc(STACK_SIZE);
    int flags = CLONE_NEWPID | CLONE_NEWNS | CLONE_NEWUTS |
                CLONE_NEWNET | CLONE_NEWIPC;

    pid_t pid = clone(child_fn, stack + STACK_SIZE, flags | SIGCHLD, &ca); // 栈向下增长，故传入栈顶
    if (pid < 0) {
        perror("clone");
        return 1;
    }

    // 把子进程加入 cgroup，限制对它及其全部子孙生效
    char pid_str[32];
    snprintf(pid_str, sizeof(pid_str), "%d", pid);
    write_cgroup("cgroup.procs", pid_str);

    waitpid(pid, NULL, 0); // 等待容器内进程退出

    // 清理 cgroup
    rmdir(cg_path);
    free(stack);
    return 0;
}

硬件级虚拟化

KVM（Kernel-based Virtual Machine）基于内核的虚拟机，实际是内核提供的、对不同硬件平台（Intel VT-x/AMD-V/...）虚拟化（CPU/内存）提供统一的接口（/dev/kvm）。

qemu firecracker 一般使用这种方式实现。用户态进程需要自己虚拟化其它设备。

// KVM 需要 root 权限。模拟 x86 平台 16 位实模式。
#include <linux/kvm.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <time.h>

#define GUEST_MEM_SIZE  (64 * 1024 * 1024)
// 模拟以下设备，下面的宏定义设备对应的端口号（一个设备可以有多个 I/O 端口）
// 端口号是按PC架构约定写死的，guest 通过 in/out 指令使用设备
// 例如：in al, 0x71 = 从 I/O 端口 0x71 读一个字节，存入 al 寄存器
#define SERIAL_PORT     0x3F8    // COM1 串口：最古老的输出设备
#define RTC_INDEX_PORT  0x70     // RTC 索引端口：先写它选中要读哪个时钟寄存器（0x04=时、0x02=分……）
#define RTC_DATA_PORT   0x71     // RTC 数据端口：再读它拿到选中寄存器的值（BCD 编码）
#define RESET_PORT      0xCF9    // PCI 复位控制寄存器：写 0x06 = 请求主板硬复位（本例当作"关机请求"）

// 串口设备（UART 16550）
// 真实串口芯片有 8 个寄存器（占 8 个连续端口号）。我们逐个模拟它们的行为
struct serial_device {
    uint8_t thr;       // 发送保持寄存器：guest 写它 = 发送（打印）一个字符
    uint8_t ier;       // 中断使能寄存器：本例不模拟中断，仅记录
    uint8_t lcr;       // 线路控制寄存器：配置波特率等，本例仅记录
    int output_count;
};

static void serial_write(struct serial_device *dev, uint16_t offset, uint8_t val) {
    switch (offset) {
    case 0: // THR：发送一个字符
        dev->thr = val;
        putchar(val);
        fflush(stdout);
        dev->output_count++;
        break;
    case 1: dev->ier = val; break;
    case 3: dev->lcr = val; break;
    }
}

static uint8_t serial_read(struct serial_device *dev, uint16_t offset) {
    switch (offset) {
    case 5: return 0x60; // LSR：发送器为空 + 就绪
    default: return 0;
    }
}

// RTC 设备（CMOS 实时时钟）
// 主板上的时钟芯片，关机后也靠电池走字。内部 128 个寄存器，但只对外暴露
// 两个端口：先往 0x70 写寄存器号（如 0x04=小时），再从 0x71 读对应的值
struct rtc_device {
    uint8_t index;  // 当前选中的寄存器（guest 上次写入 0x70 的值）
};

static void rtc_write(struct rtc_device *dev, uint16_t port, uint8_t val) {
    if (port == RTC_INDEX_PORT) {
        dev->index = val & 0x7F;
    }
    // 本示例忽略对数据端口的写入
}

static uint8_t rtc_read(struct rtc_device *dev, uint16_t port) {
    if (port == RTC_DATA_PORT) {
        time_t t = time(NULL);
        struct tm *tm = gmtime(&t);
        // 像真实 CMOS RTC 一样返回 BCD 编码的时间值
        switch (dev->index) {
        case 0x00: return (uint8_t)((tm->tm_sec / 10) << 4 | (tm->tm_sec % 10));
        case 0x02: return (uint8_t)((tm->tm_min / 10) << 4 | (tm->tm_min % 10));
        case 0x04: return (uint8_t)((tm->tm_hour / 10) << 4 | (tm->tm_hour % 10));
        case 0x07: return (uint8_t)((tm->tm_mday / 10) << 4 | (tm->tm_mday % 10));
        case 0x08: return (uint8_t)(((tm->tm_mon + 1) / 10) << 4 | ((tm->tm_mon + 1) % 10));
        case 0x09: return (uint8_t)(((tm->tm_year % 100) / 10) << 4 | ((tm->tm_year % 100) % 10));
        default: return 0;
        }
    }
    return 0xFF;
}

// Guest 代码：
// 1. 从 RTC 读取当前 时:分
// 2. 通过串口打印 "Time: HH:MM"
// 3. 打印 "QEMU-style VM!\n"
// 4. 向复位端口写入，触发 VM 关机
static const uint8_t guest_code[] = {
    // 串口端口号放入 dx，之后统一用 out dx, al（imm8 形式的 out 无法编码 0x3F8）
    0xBA, 0xF8, 0x03,         // mov dx, 0x3F8（COM1）

    // 读取 RTC 小时
    0xB0, 0x04,                // mov al, 0x04（小时寄存器）
    0xE6, 0x70,                // out 0x70, al
    0xE4, 0x71,                // in al, 0x71 → BCD 小时存入 al
    0x88, 0xC3,                // mov bl, al（保存小时）

    // 读取 RTC 分钟
    0xB0, 0x02,                // mov al, 0x02（分钟寄存器）
    0xE6, 0x70,                // out 0x70, al
    0xE4, 0x71,                // in al, 0x71 → BCD 分钟存入 al
    0x88, 0xC5,                // mov ch, al（保存分钟）

    // 打印 "Time: "
    0xB0, 'T', 0xEE,
    0xB0, 'i', 0xEE,
    0xB0, 'm', 0xEE,
    0xB0, 'e', 0xEE,
    0xB0, ':', 0xEE,
    0xB0, ' ', 0xEE,

    // 打印小时的高位数字
    0x88, 0xD8,                // mov al, bl
    0xC0, 0xE8, 0x04,         // shr al, 4
    0x04, 0x30,                // add al, '0'
    0xEE,                      // out dx, al（串口）
    // 打印小时的低位数字
    0x88, 0xD8,                // mov al, bl
    0x24, 0x0F,                // and al, 0x0F
    0x04, 0x30,                // add al, '0'
    0xEE,                      // out dx, al（串口）

    0xB0, ':', 0xEE,          // 打印 ':'

    // 打印分钟的高位数字
    0x88, 0xE8,                // mov al, ch
    0xC0, 0xE8, 0x04,         // shr al, 4
    0x04, 0x30,                // add al, '0'
    0xEE,                      // out dx, al（串口）
    // 打印分钟的低位数字
    0x88, 0xE8,                // mov al, ch
    0x24, 0x0F,                // and al, 0x0F
    0x04, 0x30,                // add al, '0'
    0xEE,                      // out dx, al（串口）

    0xB0, '\n', 0xEE,         // 换行

    // 通过串口打印消息
    0xBE, 0x80, 0x00,         // mov si, 0x80（消息偏移）
    // loop:
    0xAC,                      // lodsb
    0x3C, 0x00,                // cmp al, 0
    0x74, 0x03,                // je done（+3：跳过 out 和 jmp）
    0xEE,                      // out dx, al（串口）
    0xEB, 0xF8,               // jmp loop（-8：回到 lodsb）

    // 触发复位（VM 退出）
    0xB0, 0x06,                // mov al, 0x06（硬复位）
    0xBA, 0xF9, 0x0C,         // mov dx, 0x0CF9
    0xEE,                      // out dx, al
    0xF4,                      // hlt（兜底）
};

// 消息位于 guest 内存偏移 0x80 处
static const char guest_msg[] = "QEMU-style VM with device emulation!\n";

int main(void) {
    int kvm_fd, vm_fd, vcpu_fd;
    void *guest_mem;
    struct kvm_run *run;
    size_t run_size;

    struct serial_device serial = {0};
    struct rtc_device rtc = {0};

    // /dev/kvm 是内核暴露的字符设备
    // 用户态 VMM（虚拟机监控器）通过对它发 ioctl 来创建和控制虚拟机
    kvm_fd = open("/dev/kvm", O_RDWR);
    if (kvm_fd < 0) { perror("/dev/kvm"); return 1; }

    vm_fd = ioctl(kvm_fd, KVM_CREATE_VM, 0); // 创建一台空虚拟机，内核返回代表它的 fd
    if (vm_fd < 0) { perror("CREATE_VM"); return 1; }

    // 分配一块普通用户态内存，充当 guest 的物理内存
    guest_mem = mmap(NULL, GUEST_MEM_SIZE, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    memcpy(guest_mem, guest_code, sizeof(guest_code));            // guest 代码放到"物理地址"0x0
    memcpy((uint8_t *)guest_mem + 0x80, guest_msg, sizeof(guest_msg)); // 消息放到"物理地址"0x80

    // 把这块内存注册给 VM，硬件（EPT 二级页表）会自动翻译到这块用户态内存
    struct kvm_userspace_memory_region region = {
        .slot = 0,
        .guest_phys_addr = 0,
        .memory_size = GUEST_MEM_SIZE,
        .userspace_addr = (uint64_t)guest_mem,
    };
    ioctl(vm_fd, KVM_SET_USER_MEMORY_REGION, &region);

    // 创建 vCPU：每个 vCPU 一个 fd，代表一条可供 guest 使用的执行线程
    vcpu_fd = ioctl(vm_fd, KVM_CREATE_VCPU, 0);
    run_size = ioctl(kvm_fd, KVM_GET_VCPU_MMAP_SIZE, 0); // 查询 kvm_run 结构需要多大
    // mmap vcpu fd 得到一块内核与用户态共享的内存：struct kvm_run
    // KVM_RUN 返回后通过读取此块内存获取 VMM exit 原因、I/O 端口等数据
    run = mmap(NULL, run_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpu_fd, 0);

    // 设置特殊寄存器：让 vCPU 以 16 位实模式启动（CS base = 0），模拟 PC 上电时的状态
    struct kvm_sregs sregs;
    ioctl(vcpu_fd, KVM_GET_SREGS, &sregs); // 先读出内核填好的默认值再改，避免破坏其它字段
    sregs.cs.base = 0;
    sregs.cs.selector = 0;
    ioctl(vcpu_fd, KVM_SET_SREGS, &sregs);

    // 设置通用寄存器：rip = 0 表示从物理地址 0 开始执行
    // rflags 第 1 位是保留位，硬件规定恒为 1，所以必须写 0x2
    struct kvm_regs regs = { .rip = 0, .rflags = 0x2 };
    ioctl(vcpu_fd, KVM_SET_REGS, &regs);

    printf("[qemu] VM started — emulating serial + RTC + reset controller\n");
    printf("[qemu] guest output: ");
    fflush(stdout);

    int running = 1;
    while (running) {
        // "运行 guest"：内核借助硬件虚拟化（VT-x/SVM）让物理 CPU 直接执行 guest 的机器码，
        // 绝大多数指令不经过任何软件模拟（所以 VM 能接近原生速度），这期间 ioctl 阻塞
        // 当 guest 碰到自己处理不了的事（本例中是 in/out 访问 I/O 端口、hlt 停机）
        // CPU 自动触发 VM-exit 退回内核；内核把退出原因和现场数据写进共享内存 run，并从 ioctl 返回
        ioctl(vcpu_fd, KVM_RUN, 0);

        // KVM_RUN 返回后，从共享内存里读取返回原因
        switch (run->exit_reason) {
        case KVM_EXIT_IO: {
            // guest 执行了 in/out 指令访问 I/O 端口
            uint16_t port = run->io.port;                         // 访问了哪个端口
            uint8_t *data = (uint8_t *)run + run->io.data_offset; // 数据存放处（相对 run 的偏移）
            // run->io.direction 区分是 out（guest 写设备）还是 in（guest 读设备）

            // VMM 的设备分发：按端口号判断设备，转给对应设备模拟器
            if (port >= SERIAL_PORT && port < SERIAL_PORT + 8) {
                // 串口设备（UART 占 0x3F8~0x3FF 共 8 个端口）
                if (run->io.direction == KVM_EXIT_IO_OUT) {
                    serial_write(&serial, port - SERIAL_PORT, *data); // out：从 data 取走 guest 写的字节
                } else {
                    *data = serial_read(&serial, port - SERIAL_PORT); // in：结果写进 data，guest 恢复执行后读到
                }
            } else if (port == RTC_INDEX_PORT || port == RTC_DATA_PORT) {
                // RTC 设备
                if (run->io.direction == KVM_EXIT_IO_OUT) {
                    rtc_write(&rtc, port, *data);
                } else {
                    *data = rtc_read(&rtc, port);
                }
            } else if (port == RESET_PORT) {
                // 复位控制器：guest 要求关机，不再继续循环
                printf("\n[qemu] guest triggered reset (port 0xCF9)\n");
                running = 0;
            } else {
                // 忽略未知端口
            }
            break; // 处理完本次 exit，回到 while 再次 KVM_RUN，guest 从断点继续执行
        }

        case KVM_EXIT_HLT: // guest 执行了 hlt 指令（CPU 停机），停止 VM
            printf("\n[qemu] guest halted\n");
            running = 0;
            break;

        case KVM_EXIT_SHUTDOWN: // guest 发生三重故障等致命错误，等同于按下电源键
            printf("\n[qemu] triple fault / shutdown\n");
            running = 0;
            break;

        default: // 本示例不处理的其它 exit（MMIO、中断窗口……），直接停机
            printf("\n[qemu] exit reason %d\n", run->exit_reason);
            running = 0;
            break;
        }
    }

    printf("[qemu] serial output total: %d chars\n", serial.output_count);

    munmap(run, run_size);
    munmap(guest_mem, GUEST_MEM_SIZE);
    close(vcpu_fd);
    close(vm_fd);
    close(kvm_fd);
    return 0;
}

eBPF

eBPF is a revolutionary technology that can run sandboxed programs in the Linux kernel without changing kernel source code or loading a kernel module.

Linux 内核态执行的虚拟机字节码（通过 bpf 系统调用交由内核加载），用于在不改内核代码/不重启内核的前提下安全地动态挂接和观测数据

bpf 字节码可通过 LLVM 编译生成。

/**
 * clang -O2 -g -target bpf -c ebpf_syscnt.kern.c -o ebpf_syscnt.kern.o
 */
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <stdint.h>

#define MAP_SIZE 512

/* array map：key=pid%MAP_SIZE, value=计数 */
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, MAP_SIZE);
    __type(key, uint32_t);
    __type(value, uint64_t);
} syscall_counts SEC(".maps");

/* 挂到 raw tracepoint: sys_enter —— 每个系统调用进入时执行一次 */
SEC("raw_tracepoint/sys_enter")
int trace_sys_enter(void *ctx)
{
    uint64_t pid_tgid = bpf_get_current_pid_tgid();
    uint32_t key = (uint32_t)(pid_tgid >> 32) % MAP_SIZE;  /* pid % N */
    uint64_t *count;

    count = bpf_map_lookup_elem(&syscall_counts, &key);
    if (count)
        __sync_fetch_and_add(count, 1);          /* 原子累加 */

    return 0;
}

char _license[] SEC("license") = "GPL";

然后用户态进程通过 bpf 系统调用执行字节码

/**
 * 编译: gcc -O2 -o ebpf_openat ebpf_openat_user.c -lbpf -lelf -lz
 * 运行: sudo ./ebpf_openat ./ebpf_openat.kern.o
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <bpf/libbpf.h>
#include <bpf/bpf.h>
#include <linux/bpf.h>

static volatile sig_atomic_t stop;

static void sig_int(int signo) { (void)signo; stop = 1; }

int main(int argc, char **argv)
{
    struct bpf_object *obj = NULL;
    struct bpf_program *prog;
    struct bpf_link *link = NULL;
    struct bpf_map *map;
    int err;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s <bpf_prog.o>\n", argv[0]);
        return 1;
    }

    /* 打开 eBPF 对象文件 */
    obj = bpf_object__open_file(argv[1], NULL);
    if (libbpf_get_error(obj)) {
        fprintf(stderr, "open_file failed: %s\n", strerror(-(long)obj));
        return 1;
    }

    /** 加载进内核：bpf() syscall + verifier 验证
     *  需要 root/CAP_BPF，否则 verifier 拒绝 */
    err = bpf_object__load(obj);
    if (err) {
        fprintf(stderr, "load failed: %s\n", strerror(-err));
        goto cleanup;
    }

    /* 找到要挂接的程序 */
    prog = bpf_object__find_program_by_name(obj, "trace_sys_enter");
    if (!prog) {
        fprintf(stderr, "program trace_openat not found\n");
        goto cleanup;
    }

    /** 动态挂接到 raw tracepoint */
    link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");
    if (libbpf_get_error(link)) {
        fprintf(stderr, "attach failed: %s\n", strerror(-(long)link));
        link = NULL;
        goto cleanup;
    }

    printf("Tracing openat syscalls... press Ctrl-C to stop\n");
    signal(SIGINT, sig_int);

    /* 找到 map 以读取数据，取其内核 fd */
    map = bpf_object__find_map_by_name(obj, "syscall_counts");
    if (!map) {
        fprintf(stderr, "map open_counts not found\n");
        goto cleanup;
    }
    int map_fd = bpf_map__fd(map);
    if (map_fd < 0) {
        fprintf(stderr, "map fd invalid\n");
        goto cleanup;
    }

    /** 每秒遍历 map 并打印 */
    uint32_t key, prev_key;
    uint64_t value;
    while (!stop) {
        sleep(1);
        printf("\n--- syscalls per pid ---\n");
        prev_key = 0;
        while (bpf_map_get_next_key(map_fd, &prev_key, &key) == 0) {
            if (bpf_map_lookup_elem(map_fd, &key, &value) == 0 && value != 0)
                printf("  pid %-6d: %llu\n", key, (unsigned long long)value);
            prev_key = key;
        }
    }

cleanup:
    if (link)
        bpf_link__destroy(link);
    if (obj)
        bpf_object__close(obj);
    printf("\n[done] detached and unloaded\n");
    return 0;
}

WebAssembly

WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable compilation target for programming languages, enabling deployment on the web for client and server applications.

面向栈式虚拟机的字节码，平台无关。

通过 LLVM nostdlib 编译，目标为 wasm32。

/**
 * clang --target=wasm32 -O2 -nostdlib \
 *   -Wl,--no-entry -Wl,--export-all \
 *   -o demo.wasm demo.c
 */

int square(int x) { return x * x; }

int add(int a, int b) { return a + b; }

int fib(int n) {
    int a = 0, b = 1, t;
    for (int i = 0; i < n; i++) {
        t = a + b; a = b; b = t;
    }
    return a;
}

static int counter = 42;

int get_counter(void) { return counter; }
void bump_counter(void) { counter++; }

static char message[] = "Hello from WebAssembly!";

int message_offset(void) { return (int)(long)message; }
int message_len(void) { return sizeof(message); }

long long mul64(long long a, long long b) { return a * b; }

在 JavaScript 中执行

const fs = require("fs");
const wasmPath = process.argv[2] || "demo.wasm";
const bytes = fs.readFileSync(wasmPath);
const instance = new WebAssembly.Instance(new WebAssembly.Module(bytes));
const ex = instance.exports;
console.log(Object.fromEntries(Object.entries(ex).map(([e, v]) => [e, typeof v])));

console.log(`square(12) = ${ex.square(12)}`);
console.log(`add(3, 4) = ${ex.add(3, 4)}`);
console.log(`fib(10) = ${ex.fib(10)}`);
console.log(`get_counter() = ${ex.get_counter()}`);
ex.bump_counter();
ex.bump_counter();
console.log(`bump_counter() x2 = ${ex.get_counter()}`);

const mem = new Uint8Array(ex.memory.buffer);
const off = ex.message_offset();
const len = ex.message_len();

let str = "";
for (let i = 0; i < len - 1; i++) str += String.fromCharCode(mem[off + i]);

console.log(`message at offset ${off}, length ${len}`);
console.log(`read from linear memory: "${str}"`);

const big = ex.mul64(1000000n, 1000000n);
console.log(`mul64(1000000n, 1000000n) = ${big} ${typeof big}`);

WASI

WebAssembly System Interface (WASI) 是一组规范的系统接口，编译器（clang/LLVM）把 WASI 程序的系统调用编译成对 wasi_snapshot_preview1 模块的 import（导入函数）。 syscall 指令

/**
 * clang --target=wasm32-wasi -O2 -o wasi_demo.wasm wasi_demo.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main(int argc, char *argv[])
{
    printf("This wasm program is running through WASI.\n\n");
    // 环境变量
    const char *vars[] = { "HOME", "USER" };
    for (int i = 0; i < 2; i++) {
        const char *v = getenv(vars[i]);
        printf("  %s = %s\n", vars[i], v ? v : "(unset)");
    }
    printf("\n");
    // 文件系统
    if (argc > 1) {
        FILE *f = fopen(argv[1], "r");
        if (f) {
            char line[256];
            printf("  contents of %s:\n", argv[1]);
            while (fgets(line, sizeof line, f))
                printf("    %s", line);
            fclose(f);
        } else {
            printf("  cannot open %s\n", argv[1]);
        }
    } else {
        printf("  (pass a file path as argument to read it)\n");
    }
    printf("\n");
    // 时钟
    time_t now = time(NULL);
    printf("  current epoch seconds: %ld\n", (long)now);
    printf("  ctime: %s", ctime(&now));
    return 0;
}

Unikernel

Unikernels are specialised, single-address-space machine images constructed by using library operating systems.

将应用程序与库操作系统（libOS）打包在（同一个地址空间）一起运行。

附

OCI (Open Container Initiative)

Image Spec: 容器镜像的格式（分层、manifest、config）
Runtime Spec: 运行一个容器所需的 bundle 结构（rootfs + config.json），以及runtime 如何起/停/查容器
Distribution Spec : 镜像仓库的 push/pull API

OCI runtime : runc / runsc (gVisor) / kata / crun / youki

CRI (Container Runtime Interface)

Kubernetes 内置的 gRPC 接口规范，定义 kubelet 如何操作容器运行时。

containerd 是一个通用的容器运行时，支持通过 CRI 插件接入 k8s。
containerd 通过插件配置底层使用的 OCI 运行时（默认为 runc）。

CRI-O 是专门为实现 Kubernetes 的 CRI，支持任意符合 OCI runtime-spec 的运行时（默认为 crun）

←Back to home

This work is licensed under CC BY-NC-SA 4.0