Linux 内核 KVM 虚拟化深度实战：从 VMX 硬件根模式到 QEMU 生产级部署与调优全链路

VMXON [vmxon_region]      ; 进入 VMX 操作模式，初始化 VMXON 区域
VMXCLEAR [vmcs_ptr]       ; 清除指定 VMCS，使其处于未激活状态
VMPTRLD [vmcs_ptr]        ; 加载 VMCS 指针为当前 VMCS
VMPTRST [mem]             ; 存储当前 VMCS 指针到内存

; VMCS 字段读写
VMREAD field              ; 从 VMCS 读取字段到寄存器
VMWRITE field, value      ; 向 VMCS 字段写入值

; VM Entry/Exit
VMLAUNCH                  ; 首次进入 Guest（加载当前 VMCS）
VMRESUME                  ; 重新进入 Guest（恢复已存在的 VMCS 状态）

; VMXOFF                   ; 退出 VMX 操作模式
VMCALL                    ; Guest 调用 Hypervisor（相当于 syscall）

section .data
align 4096
vmcs: times 4096 db 0

section .text
global setup_vmcs
setup_vmcs:
    ; vmcs 区域初始化
    mov rax, [vmxon_region]
    mov dword [rax], 0x00000001  ; VMCS revision ID (从 VMX_BASIC MSR 读取)

    ; 加载 VMCS
    lea rax, [vmcs]
    vmx_clear rax        ; 清除
    vmptrld rax          ; 加载指针

    ; 写入 Guest RIP (0x1000 = 引导扇区入口)
    mov rax, 0x0000000000001000
    vmwrite GUEST_RIP, rax

    ; 写入 Guest RSP
    mov rax, 0x0000000000007c00
    vmwrite GUEST_RSP, rax

    ; 设置异常位图 - 仅 #PF (bit 14) 和 #GP (bit 13) 触发 VM Exit
    mov rax, 0x0000000060000000
    vmwrite EXCEPTION_BITMAP, rax

    ; 设置 Pin-Based Controls: NMI exiting = 1
    mov rax, 0x0000000000000008
    vmwrite PIN_BASED_VM_EXEC_CONTROL, rax

    ; 设置 Proc-Based Controls: Use MSR bitmaps, Use I/O bitmaps, Secondary controls = 1
    mov rax, 0x0000000010020012
    vmwrite CPU_BASED_VM_EXEC_CONTROL, rax

    ; Host RIP = vmexit_handler
    lea rax, [vmexit_handler]
    vmwrite HOST_RIP, rax

    ; Host CR3 = host page tables
    mov rax, [host_cr3]
    vmwrite HOST_CR3, rax

    ; 启动 VM
    vmlaunch
    ; 如果失败，跳转到错误处理
    jmp vmx_error

VMRUN [vmcb]    ; 进入 Guest
VMLOAD [vmcb]   ; 加载 VMCB 状态
VMSAVE [vmcb]   ; 保存 Guest 状态到 VMCB
STGI            ; 设置 Global Interrupt Flag（开中断）
CLGI            ; 清除 Global Interrupt Flag（关中断）
INVLPGA         ; 刷新 TLB 指定 ASID
SKINIT          ; 安全初始化和安全启动

用户态 QEMU
    |
    |-- open("/dev/kvm")                    -> kvm_dev_ioctl()
    |-- ioctl(fd, KVM_CREATE_VM, 0)         -> kvm_create_vm()    # 创建 VM
    |-- ioctl(vmfd, KVM_CREATE_VCPU, id)    -> kvm_vm_ioctl_create_vcpu()  # 创建 vCPU
    |-- ioctl(vcpufd, KVM_SET_USER_MEMORY_REGION) -> kvm_set_memory_region() # 配置内存
    |-- ioctl(vcpufd, KVM_SET_REGS)         # 设置寄存器
    |-- ioctl(vcpufd, KVM_SET_SREGS)        # 设置段寄存器
    |-- ioctl(vcpufd, KVM_RUN)              -> kvm_arch_vcpu_ioctl_run()   # 进入 VM |
                                                                              |
                                                                     VM Entry (硬件)
                                                                              |
                                                                          Guest 执行
                                                                              |
                                                                     VM Exit (硬件)
                                                                              |
                                                                   kvm_handle_exit()
                                                                              |
                                                            模拟设备 / 注入中断 / 处理 EPT Violation
                                                                              |
                                                                     循环回到 KVM_RUN

/**
 * Intel VT-x VM Exit 处理入口 (arch/x86/kvm/vmx/vmx.c)
 * 硬件恢复 Host 上下文后直接跳转到这里
 */
__noclk void vmx_vcpu_run(struct kvm_vcpu *vcpu)
{
    struct vcpu_vmx *vmx = to_vmx(vcpu);

    /* 1. 从 VMCS 读取退出原因 */
    vmx->exit_reason = vmcs_read32(VM_EXIT_REASON);

    /* 2. 快速路径处理（KVM 自己处理，不需要进入 QEMU） */
    if (likely(vcpu->arch.exit_handlers[kvm_handle_exit_fast(vmx)])) {
        /* 处理 PIO/MMIO/EPT Violation/QEMU 通知等 */
        handle_fastpath_exit(vcpu, vmx);
        return; /* 直接 VMRESUME，不进入用户态 */
    }

    /* 3. 慢速路径 - 需要 QEMU 参与（设备模拟） */
    vcpu->run->exit_reason = KVM_EXIT_IO;  /* 或 KVM_EXIT_MMIO 等 */
    kvm_make_request(KVM_REQ_EXIT, vcpu);
}

Guest 视角：
    GVA --(Guest Page Table)--> GPA --(页面权限检查)--> 以为自己访问了物理内存

实际硬件流程：
    CPU 自动执行两级翻译：
    Step 1: GVA --> Guest Page Table (Guest 内部) --> GPA
    Step 2: GPA --> EPT/NPT (Hypervisor 维护的扩展页表) --> HPA

    如果 EPT 中该 GPA 未映射或权限不足：
        -> EPT Violation VM Exit (通知 KVM/QEMU 处理缺页)

static void update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
{
    if (irqchip_split(vcpu->kvm) || kvm_vcpu_apic(vcpu))
        return;
    /* VPID + TPR virtualization: 无需 VM Exit 就能更新任务优先级 */
}

static void enable_ept(struct kvm_vcpu *vcpu)
{
    /* 写入 Secondary Processor-Based VM-Execution Controls */
    exec_controls |= SECONDARY_EXEC_ENABLE_EPT;
    /* 启用 VPID */
    exec_controls |= SECONDARY_EXEC_ENABLE_VPID;
    vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_controls);
}

/**
 * QEMU Memory Region 子系统
 * 每个设备注册一组 Memory Region（MR），这些 MR 构成地址空间的树形结构
 */
typedef struct MemoryRegion {
    struct MemoryRegion *parent;      // 父节点
    uint64_t addr;                    // 在父节点中的偏移
    uint64_t size;                    // 区域大小
    MemoryRegionOps *ops;             // 读写操作回调
    QLIST_HEAD(, MemoryRegion) subregions; // 子区域链表
} MemoryRegion;

// 示例：virtio-blk 设备初始化时注册 MMIO 区域
static void virtio_blk_init(VirtIODevice *vdev)
{
    MemoryRegion *mr = g_new0(MemoryRegion, 1);
    memory_region_init_io(mr, obj, &virtio_blk_mmio_ops, s, "virtio-blk", 0x1000);
    /* Guest 访问 0x1000 偏移时会触发这里的 ops->read/write */
}

/**
 * Virtqueue 的三表结构 (Virtio 1.2 规范)
 * 所有 Virtqueue 结构由 Guest 内核分配，通过 PCI BAR 共享给设备和 Host
 */
struct vring {
    unsigned int num;  // 描述符数量（必须是 2 的幂）

    // 三个表在 Guest 物理内存中连续分布，通过 PCI 配置空间告诉设备：
    struct vring_desc  desc[];   // 描述符表：DMA 地址 + 长度 + 标志 + next
    struct vring_avail avail;    // 可用环：Guest 将请求放入后更新 idx，通知 Host
    struct vring_used  used;     // 使用环：Host 完成后放入结果，通知 Guest
};

// 描述符结构
struct vring_desc {
    __virtio64 addr;   // Guest 物理地址（DMA）
    __virtio32 len;    // 数据长度
    __virtio16 flags;  // VRING_DESC_F_NEXT | VRING_DESC_F_WRITE | VRING_DESC_F_INDIRECT
    __virtio16 next;   // 下一个描述符索引（链式）
};

// 可用环
struct vring_avail {
    __virtio16 flags;      // 通常 = 0
    __virtio16 idx;        // Guest 每次添加请求后递增，Host 通过对比检测新请求
    __virtio16 ring[];     // 描述符索引数组
    /* 可选：__virtio16 used_event;  // 用于 VIRTIO_F_EVENT_IDX 抑制 */
};

1. Virtio-net 数据发送流程：

[Guest Driver (virtio_net)]
    a. 将数据包 dma_addr/len 写入 desc[n]
    b. 将 desc 索引放入 avail.ring[last_avail_idx % num]
        -- 注意：这里有一个 memory barrier！
    c. 写 avail.idx += 1 （更新指针）
    d. 检查 used.idx 判断 Host 是否处理完成
        -- 如果 VIRTIO_F_EVENT_IDX：
            if (used.idx < avail_ring->used_event) 不注入中断

[Host 侧 (QEMU 或 vhost-net)]
    a. 轮询或等待 avail.idx 变化（通过 eventfd 通知）
    b. 从 avail.ring 读取描述符索引，获取数据包
    c. 调用 sendmsg/sendfile 将数据包发送到 TAP 设备或 macvtap
    d. 将完成的描述符索引写入 used.ring[m]
    e. 写 used.idx += 1
    f. 注入 MSI-X 中断告知 Guest（或被中断抑制逻辑跳过）

/**
 * KVM irqfd: 将 Host 的中断事件通知转换为虚拟中断注入
 * 通过 eventfd 机制实现零拷贝中断注册
 */
struct kvm_kernel_irqfd {
    struct kvm *kvm;
    struct eventfd_ctx *eventfd;  // 等待文件描述符
    int gsi;                     // 全局系统中断号（GSI）
    struct list_head list;
    wait_queue_entry_t wait;
    struct work_struct shutdown;
    struct irq_bypass_consumer consumer;
};

/**
 * 注入虚拟中断的核心函数
 * 如果 vCPU 正在 Guest 运行：发送 IPI 唤醒 vCPU，注入中断
 * 如果 vCPU 在 Host 等待：直接唤醒
 */
static int kvm_irqfd_assign(struct kvm *kvm, struct kvm_irqfd *args)
{
    // 配置 GSI 到 irqfd 的映射
    // 后端（vhost-net 等）通过 eventfd_write() 触发中断
    init_waitqueue_func_entry(&irqfd->wait, irqfd_wakeup);
    add_wait_queue(&irqfd->wqh, &irqfd->wait);
    return 0;
}

// vhost-net 发送完成后调用
static void vhost_signal(struct vhost_dev *dev, struct vhost_virtqueue *vq)
{
    if (!vhost_has_feature(vq, VIRTIO_F_NOTIFICATION_DATA))
        eventfd_signal(vq->call_ctx.ctx, 1);  // 触发 KVM irqfd -> 注入中断
}

[Guest virtio-net Driver]
        |
        | Virtqueue (共享内存，EPT 映射到 Host)
        |
+-------v-------+
|  Host Kernel   |
|  vhost-net.ko  |
|   - 轮询 avail 环
|   - 读取数据包描述符
|   - 调用 tap/mactap sendmsg()
|   - 写 used 环
|   - 通过 eventfd 通知中断
+---------------+
        |
        | TAP/macvtap/veth
        |
     物理网卡

# NUMA 拓扑查看
$ numactl --hardware
available: 2 nodes (0-1)
node 0 cpus: 0-31 64-95
node 0 size: 192 GB
node 1 cpus: 32-63 96-127
node 1 size: 192 GB
node distances: 10 21

# QEMU 启动参数 - 将 vCPU 绑定到 node 0
qemu-system-x86_64 \
  -enable-kvm \
  -cpu host \
  -smp 16,sockets=1,cores=16,threads=1 \
  -m 64G \
  -mem-path /dev/hugepages \                                  # 使用大页
  -mem-prealloc \                                             # 预分配内存
  -numa node,nodeid=0,cpus=0-15,memdev=mem0 \
  -object memory-backend-file,id=mem0,size=64G,mem-path=/dev/hugepages,share=on,prealloc=yes \
  ...

<domain type='kvm'>
  <name>prod-db-server</name>
  <vcpu placement='static'>16</vcpu>
  <cputune>
    <vcpupin vcpu='0' cpuset='2'/>
    <vcpupin vcpu='1' cpuset='3'/>
    <vcpupin vcpu='2' cpuset='4'/>
    <!-- ... 跳过超线程兄弟，避免 HT 争抢 -->
    <emulatorpin cpuset='0-1'/>  <!-- QEMU 线程绑定到独立核心 -->
    <iothreadpin iothread='1' cpuset='62-63'/>  <!-- IOThread 与 vCPU 隔离 -->
  </cputune>
  <numatune>
    <memory mode='strict' nodeset='0'/>  <!-- 严格绑定 NUMA 节点 -->
  </numatune>
</domain>

# 在 /etc/sysctl.conf 中配置
vm.nr_hugepages = 32768        # 2MB 大页，共 64GB
# 或使用 1GB 巨页（在 GRUB 内核参数中）
# GRUB_CMDLINE_LINUX="default_hugepagesz=1G hugepagesz=1G hugepages=64"

# 创建 hugetlbfs 挂载点
mkdir -p /dev/hugepages
mount -t hugetlbfs hugetlbfs /dev/hugepages

# QEMU 启动中使用大页
qemu-system-x86_64 \
  -m 64G \
  -mem-path /dev/hugepages \
  -mem-prealloc \
  ...

# 1. host-passthrough: 暴露所有 Host CPU 特性（性能最佳，迁移受限）
-cpu host

# 2. host-model: 根据 Host CPU 自动选择一个标准模型（可迁移）
-cpu host-model

# 3. 自定义模式 + 手动添加特性
-cpu Skylake-Server,topoext=on,hv_relaxed=on,hv_spinlocks=0x1fff,hv_vapic=on,hv_time=on

# 推荐的 Hyper-V Enlightenments（Linux Guest 性能优化）
-cpu host,hv_relaxed,hv_spinlocks=0x1fff,hv_vapic,hv_time,hv_synic,hv_stimer,hv_tlbflush,hv_ipi,hv_runtime,hv_reset

# 1. CFS 默认分组（默认行为）- 适合通用业务
# 使用 nice 值调整优先级
nice -n -5 qemu-system-x86_64 ...

# 2. 实时调度（chrt）- 适合低延迟业务
chrt -f 80 qemu-system-x86_64 ...  # SCHED_FIFO, 优先级 80
# 或
chrt -r 80 qemu-system-x86_64 ...  # SCHED_RR, 优先级 80

# 3. 内核启动参数隔离 CPU（isolcpus）- 最佳实时性
# GRUB_CMDLINE_LINUX="isolcpus=2-7 nohz_full=2-7 rcu_nocbs=2-7"
# 然后在 QEMU 中只用隔离核心
taskset -c 2-7 qemu-system-x86_64 ...
# 或使用 vcpupin 将 vCPU 绑定到隔离核心

# 1. 加载 SR-IOV 驱动（以 Intel X710 网卡为例）
modprobe iavf                              # VF 驱动
echo 8 > /sys/class/net/ens801f0/device/sriov_numvfs  # 创建 8 个 VF

# 2. 查看 VF 创建的 PCI 设备
lspci | grep -i "Virtual Function"
05:00.0 Ethernet controller: Intel Corporation X710 VF (rev 01)
05:00.1 Ethernet controller: Intel Corporation X710 VF (rev 01)
...

# 3. 将 VF 绑定到 vfio-pci 驱动（允许直通）
echo "8086 154c" > /sys/bus/pci/drivers/vfio-pci/new_id
echo 0000:05:00.0 > /sys/bus/pci/devices/0000:05:00.0/driver/unbind
echo 0000:05:00.0 > /sys/bus/pci/drivers/vfio-pci/bind

# 4. QEMU 启动时添加直通设备
-device vfio-pci,host=05:00.0

# 5. 或 libvirt XML
<hostdev mode='subsystem' type='pci' managed='yes'>
  <source>
    <address domain='0x0000' bus='0x05' slot='0x00' function='0x0'/>
  </source>
</hostdev>

# 启用嵌套虚拟化（Intel）
echo "options kvm-intel nested=Y" > /etc/modprobe.d/kvm-nested.conf
modprobe -r kvm-intel && modprobe kvm-intel

# 启用嵌套虚拟化（AMD）
echo "options kvm-amd nested=Y" > /etc/modprobe.d/kvm-nested.conf
modprobe -r kvm-amd && modprobe kvm-amd

# QEMU 启动时启用嵌套
-cpu host,vmx=on   # Intel
-cpu host,svm=on   # AMD

/**
 * Intel VMCS Shadowing 机制
 * L0 维护一份 "Shadow VMCS" 链接到真实 VMCS
 * L1 读写 Shadow VMCS 无 VM Exit，硬件自动合并到真实 VMCS
 */
static struct {
    unsigned long   vmcs_pa;       // 影子 VMCS 物理地址
    unsigned int    launch_state;  // VMCS launch state (clear/active)
    struct vmcs     *shadow_vmcs;  // L0 的副本
} shadow_vmcs_table[MAX_NESTED_VCPU];

Live Migration 流程:

[Phase 1: Pre-Migration]
    - 目标 VM 在目的 Host 启动（处于 paused 状态）
    - 目的 Host 创建相同配置的 VM
    - 源 VM 与目的 VM 之间建立连接

[Phase 2: Iterative Pre-Copy]
    Round 1: 拷贝全部内存（dirty pages tracking 开启）
    Round 2: 仅拷贝上次拷贝后变脏的页面
    Round 3: 仅拷贝新脏的页面
    ...
    每一轮传输的脏页越来越少（收敛条件：脏页率 < 网络传输率）

[Phase 3: Stop-and-Copy]
    - 源 VM 暂停
    - 拷贝剩余脏页 + CPU 状态
    - 切换到目的 VM
    - 如果迁移总脏页量超过 50MB 且传输超时 -> 回退到 Post-Copy 或取消迁移

[Phase 4: Commit]
    - 目的 VM 恢复执行
    - 更新 ARP 表（免费 GARP 通告）
    - 源虚拟机销毁

# 1. 内存脏页加速 - 利用 KVM dirty page tracking
# 内核自动计算脏页率，QEMU 据此动态调整传输速率

# 2. 网络带宽限制（避免影响业务）
migrate_set_parameter max-bandwidth 10G   # 限制迁移带宽 10Gbps

# 3. 多线程压缩（减小迁移数据量）
migrate_set_parameter compress-level 1     # Zlib 压缩，level 1 最快
migrate_set_parameter compress-threads 4   # 压缩线程数
migrate_set_parameter decompress-threads 4

# 4. 并发拷贝（Multi-FD）- QEMU 7+ 支持多连接并行迁移
migrate_set_parameter multifd-channels 4    # 4 条 FD 通道并行传输

# 5. XBZRLE 增量缓存（适合低带宽、高脏页率场景）
migrate_set_parameter xbzrle-cache-size 64M

# 6. 收敛控制：pause-before-switchover（KVM 内置）
migrate_set_parameter downtime-limit 300    # 最大停机时间 300ms
migrate_set_parameter max-postcopy-bandwidth 0  # 禁止 Post-Copy 兜底

# 1. kvm_stat 工具 - 实时监控 VM Exit 分布
apt install linux-tools-common linux-tools-generic
kvm_stat -m  1 10    # 每秒采样一次，共10次

# 输出示例（相对值）:
# EXIT              COUNT       AVG ns
# EXTERNAL_INTERRUPT    8500      1420
# EPT_VIOLATION         12000     3200
# IO_INSTRUCTION        45000     1800    <<-- 异常！
# CPUID                 3500      950
# HLT                   9800      1100

# 2. 针对 IO_INSTRUCTION 过多的处理
#    原因：Guest 频繁访问设备的I/O端口（模拟IDE或传统键盘）
#    A. 切换到 virtio-blk/virtio-net 驱动
#    B. 在 QEMU 中卸载不必要的模拟设备（如 PS/2 键盘、IDE 控制器）
#    C. 启用 PV-Clock（KVM Clock 半虚拟化时钟），减少 RDTSC 引起的 Exit

# 3. 针对 EPT_VIOLATION 过多的处理
#    原因：Guest 大量分配/释放内存（内存碎片或频繁 swap）
#    A. 使用大页减少 TLB miss
#    B. 调整 KSM（Kernel Samepage Merging）合并率
#        echo 1 > /sys/kernel/mm/ksm/run
#        echo 1000 > /sys/kernel/mm/ksm/pages_to_scan
#    C. 禁用透明大页（THP）避免页面合并延迟
#        echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 使用 runqlat BPF 工具查看所有线程的调度延迟分布
bpftrace -e '
kprobe:try_to_wake_up /args->task->comm == "qemu-system-x86"/ {
    @start[args->task->pid] = nsecs;
}

kprobe:sched_switch /@start[args->prev->pid]/ {
    $ts = @start[args->prev->pid];
    if ($ts) {
        $lat = (nsecs - $ts) / 1000;  // 微秒
        @vcpu_latency = hist($lat);
    }
    delete(@start[args->prev->pid]);
}
'

# 如果 @vcpu_latency 的 99th percentile > 500us：
# - 可能原因1：Host CPU 过载
# - 可能原因2：未绑定 CPU，被 CFS 调度到远离本地 NUMA 节点
# - 可能原因3：irq 中断太多抢占了 vCPU 时间
# - 可能原因4：NUMA 远端内存访问延迟