888 lines
33 KiB
C
888 lines
33 KiB
C
#include <utsm/vmx.h>
|
||
#include <utsm/ept.h>
|
||
#include <utsm/vmm.h>
|
||
#include <utsm/hypercall.h>
|
||
#include <utsm/ipc_shm.h>
|
||
#include <utsm/log.h>
|
||
#include <utsm/types.h>
|
||
#include <utsm/dma.h>
|
||
#include <utsm/linux_loader.h>
|
||
#include <utsm/virtio_mmio.h>
|
||
#include <utsm/instr.h>
|
||
#include "../arch/x86_64/limine.h"
|
||
|
||
/* VM-Exit 处理器：从 VMCS 读取 exit reason 与 guest 状态，分发处理。
|
||
*
|
||
* Phase 1.1：处理 HLT（终止 guest）、EPT violation（动态映射）、异常。
|
||
* Phase 1.3：增加 VMCALL hypercall 处理（读 guest GPR、分发、写返回值）。
|
||
* Phase 1.4：EPT violation 区分 RAM（按需分配 HPA）与 virtio-mmio
|
||
* （路由到设备模拟寄存器读写，不映射真实内存）。
|
||
* Phase 1.5：guest 平台设备模拟（legacy 模式，配合 noapic/nolapic）：
|
||
* - COM1 8250 UART（console=ttyS0 输出 + host 串口输入桥）
|
||
* - 8259 PIC（IMR 跟踪，EOI/ICW 吞掉）
|
||
* - 8254 PIT ch0（divisor 跟踪，按 guest 编程频率注入 IRQ0 tick）
|
||
* - CPUID passthrough（屏蔽 VMX/hypervisor 位）
|
||
* - 虚拟中断注入（pending queue + interrupt-window exiting）
|
||
* - VMX preemption timer 周期 exit（轮询 host 串口 RX + tick）
|
||
*/
|
||
|
||
extern volatile struct limine_hhdm_request g_hhdm_request;
|
||
|
||
extern void vmx_vmresume_wrapper(void);
|
||
|
||
/* serial.c 导出的 host 串口与 TSC 频率接口 */
|
||
extern int serial_try_read(void);
|
||
extern u64 serial_tsc_per_ms(void);
|
||
extern void serial_putc(char c);
|
||
|
||
static u64 g_vmexit_count;
|
||
|
||
/* ---- 插桩: VM-Exit 统计计数器 (热路径，仅 STAT_INC) ---- */
|
||
INSTR_STAT_DECL(vmexit_total);
|
||
INSTR_STAT_DECL(ept_violation);
|
||
INSTR_STAT_DECL(ext_irq);
|
||
INSTR_STAT_DECL(cpuid_exit);
|
||
INSTR_STAT_DECL(io_exit);
|
||
INSTR_STAT_DECL(intr_window);
|
||
INSTR_STAT_DECL(preempt_timer);
|
||
INSTR_STAT_DECL(msr_exit);
|
||
INSTR_STAT_DECL(pre_resume);
|
||
|
||
static void log_exit_diagnostics(u64 reason, u64 qualification, u64 rip, u64 len) {
|
||
log_hex64("[VMEXIT] reason=", reason);
|
||
log_hex64("[VMEXIT] qual=", qualification);
|
||
log_hex64("[VMEXIT] rip=", rip);
|
||
log_hex64("[VMEXIT] ilen=", len);
|
||
}
|
||
|
||
/* 处理 HLT：
|
||
* - self-test guest：终止（guest 完成测试）
|
||
* - Linux guest：park（推进 RIP 越过 HLT，exit-to-host，设 g_guest_parked=1）
|
||
* host 调用 linux_resume() 时 vmresume 唤醒 guest 从 HLT 之后继续执行。 */
|
||
static int handle_hlt(u64 rip, u64 instr_len, int *out_resume) {
|
||
*out_resume = 0; /* 三种情况默认 exit-to-host */
|
||
if (g_linux_guest_active) {
|
||
/* Linux guest: park — 推进 RIP 越过 HLT 指令 */
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
g_guest_parked = 1;
|
||
log_info("[VMEXIT] HLT - Linux guest parked");
|
||
} else if (g_xj380_guest_active) {
|
||
/* OpenXJ380 guest: 推进 RIP 并立即继续执行（不 park 不 terminate） */
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
*out_resume = 1;
|
||
} else {
|
||
/* self-test guest: 终止 */
|
||
log_info("[VMEXIT] HLT - guest halted");
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* ===== EPT violation: guest RAM 按需分配 =====
|
||
*
|
||
* guest 首次访问某 GPA 页时触发 EPT violation。我们按需分配一个
|
||
* 4KB HPA 页并建立 GPA→HPA 映射（不再是错误的 1:1 恒等映射——
|
||
* 那会把 guest GPA 直接当 host 物理地址，可能与 UTSM 自身内存冲突）。
|
||
*
|
||
* 已映射区域的访问权限不足（如先 R 映射后写）也走这里：升级为 RWX。
|
||
*/
|
||
|
||
/* 按需为普通 guest RAM GPA 分配一个 HPA 页并映射。返回 0 成功。 */
|
||
static int ept_map_guest_ram_page(u64 gpa_page) {
|
||
dkm_dma_buffer buf;
|
||
if (dma_alloc_pages(1, EPT_PAGE_SIZE, 0, &buf) != 0) {
|
||
log_error("[VMEXIT] OOM for guest RAM page");
|
||
return -1;
|
||
}
|
||
if (ept_map_range(gpa_page, buf.phys, EPT_PAGE_SIZE, EPT_RWX) != 0) {
|
||
log_error("[VMEXIT] EPT map guest RAM page failed");
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* ===== 虚拟中断注入（legacy PIC 模式，vector = 0x30 + irq） =====
|
||
*
|
||
* Linux 以 noapic/nolapic 启动时走 XT-PIC：master PIC 向量基址 0x30。
|
||
* 我们向 guest 注入的外部中断只能是这些 ISA IRQ 向量：
|
||
* IRQ0 (0x30) PIT tick、IRQ4 (0x34) COM1、IRQ5 (0x35) virtio-blk、
|
||
* IRQ6 (0x36) virtio-net。
|
||
*
|
||
* 注入条件：guest RFLAGS.IF=1 且 interruptibility=0 且 IMR 未 mask。
|
||
* 不满足时 arm CPU_BASED_INTR_WINDOW_EXITING，guest 一旦开中断
|
||
* 立即产生 interrupt-window exit，届时再注入。
|
||
*/
|
||
|
||
#define IRQ_PENDING_MAX 16
|
||
static u8 g_pending_vectors[IRQ_PENDING_MAX];
|
||
static int g_pending_head, g_pending_tail;
|
||
|
||
/* guest 8259 PIC 状态（master） */
|
||
static u8 g_pic_imr = 0xFF; /* 初始全 mask */
|
||
static int g_pic_icw_state = 0; /* 0=就绪(OCW), 1=等ICW2, 2=等ICW3, 3=等ICW4 */
|
||
static int g_pic_icw_sngl = 0;
|
||
static int g_pic_icw_need4 = 0;
|
||
|
||
void vmx_guest_queue_irq(u32 vector) {
|
||
/* 合并连续相同向量（PIT tick 合并 / COM1 RX 去重） */
|
||
if (g_pending_tail != g_pending_head) {
|
||
int last = (g_pending_tail + IRQ_PENDING_MAX - 1) % IRQ_PENDING_MAX;
|
||
if (g_pending_vectors[last] == (u8)vector) return;
|
||
}
|
||
int next = (g_pending_tail + 1) % IRQ_PENDING_MAX;
|
||
if (next == g_pending_head) return; /* 队列满：丢弃 */
|
||
g_pending_vectors[g_pending_tail] = (u8)vector;
|
||
g_pending_tail = next;
|
||
}
|
||
|
||
static void maybe_inject_irq(void) {
|
||
if (g_pending_head == g_pending_tail) return;
|
||
|
||
u8 vec = g_pending_vectors[g_pending_head];
|
||
|
||
/* IMR 检查：master PIC vector 0x30+n → IMR bit n */
|
||
if (vec >= 0x30 && vec < 0x38) {
|
||
if (g_pic_imr & (1u << (vec - 0x30))) {
|
||
/* 被 guest mask：丢弃（级别触发设备下次 notify 会重发） */
|
||
g_pending_head = (g_pending_head + 1) % IRQ_PENDING_MAX;
|
||
return;
|
||
}
|
||
}
|
||
|
||
u64 rflags = vmx_vmcs_read(VMCS_GUEST_RFLAGS);
|
||
u64 intr_st = vmx_vmcs_read(VMCS_GUEST_INTERRUPTIBILITY);
|
||
u64 cpu = vmx_vmcs_read(VMCS_CPU_BASED_VM_EXEC_CONTROL);
|
||
|
||
if ((rflags & 0x200) && intr_st == 0) {
|
||
/* 可注入：写 VM-entry interruption-information field */
|
||
vmx_vmcs_write(VMCS_VM_ENTRY_INTERRUPT_INFO,
|
||
VM_ENTRY_INTR_INFO_VALID |
|
||
(VM_ENTRY_INTR_TYPE_HW_IRQ << 8) | vec);
|
||
g_pending_head = (g_pending_head + 1) % IRQ_PENDING_MAX;
|
||
if (cpu & CPU_BASED_INTR_WINDOW_EXITING) {
|
||
vmx_vmcs_write(VMCS_CPU_BASED_VM_EXEC_CONTROL,
|
||
cpu & ~CPU_BASED_INTR_WINDOW_EXITING);
|
||
}
|
||
} else {
|
||
/* 暂不可注入：arm interrupt-window exiting */
|
||
if (!(cpu & CPU_BASED_INTR_WINDOW_EXITING)) {
|
||
vmx_vmcs_write(VMCS_CPU_BASED_VM_EXEC_CONTROL,
|
||
cpu | CPU_BASED_INTR_WINDOW_EXITING);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ===== guest COM1 8250 UART 模拟 =====
|
||
*
|
||
* console=ttyS0 的 I/O 端口 0x3F8-0x3FF。
|
||
* TX：THR 写 → host 串口输出（与 UTSM log 共用 QEMU stdio）。
|
||
* RX：host 串口输入 → g_guest_rx 环形缓冲 → guest 读 RBR；
|
||
* 有数据时注入 IRQ4（vector 0x34）。
|
||
* 寄存器：DLL/DLM/IER/FCR/LCR/MCR/SCR 存储，LSR/IIR/MSR 按状态合成。
|
||
*/
|
||
|
||
#define GUEST_RX_SIZE 256
|
||
static u8 g_guest_rx[GUEST_RX_SIZE];
|
||
static int g_rx_head, g_rx_tail;
|
||
|
||
static u8 g_com1_dll, g_com1_dlm, g_com1_ier, g_com1_fcr;
|
||
static u8 g_com1_lcr, g_com1_mcr, g_com1_scr;
|
||
|
||
static u64 com1_io(u32 port, int is_in, u64 value) {
|
||
u32 reg = port - 0x3F8;
|
||
int dlab = (g_com1_lcr & 0x80) != 0;
|
||
if (is_in) {
|
||
switch (reg) {
|
||
case 0: /* RBR / DLL */
|
||
if (dlab) return g_com1_dll;
|
||
if (g_rx_head != g_rx_tail) {
|
||
u8 b = g_guest_rx[g_rx_head];
|
||
g_rx_head = (g_rx_head + 1) % GUEST_RX_SIZE;
|
||
return b;
|
||
}
|
||
return 0;
|
||
case 1: return dlab ? g_com1_dlm : g_com1_ier;
|
||
case 2: /* IIR：bit0=0 表示有中断；bits7:6=1 表示 FIFO 启用 */
|
||
if (g_rx_head != g_rx_tail) return 0xC4; /* RX data available */
|
||
return 0xC1; /* no interrupt pending */
|
||
case 3: return g_com1_lcr;
|
||
case 4: return g_com1_mcr;
|
||
case 5: /* LSR：bit0 DR，bit5 THRE，bit6 TEMT */
|
||
return ((g_rx_head != g_rx_tail) ? 0x01 : 0x00) | 0x20 | 0x40;
|
||
case 6: return 0xB0; /* MSR：CTS|DSR|DCD */
|
||
case 7: return g_com1_scr;
|
||
}
|
||
return 0xFF;
|
||
}
|
||
switch (reg) {
|
||
case 0:
|
||
if (dlab) g_com1_dll = (u8)value;
|
||
else serial_putc((char)(value & 0xFF)); /* guest → host 串口 */
|
||
break;
|
||
case 1: if (dlab) g_com1_dlm = (u8)value; else g_com1_ier = (u8)value; break;
|
||
case 2: g_com1_fcr = (u8)value; break;
|
||
case 3: g_com1_lcr = (u8)value; break;
|
||
case 4: g_com1_mcr = (u8)value; break;
|
||
case 7: g_com1_scr = (u8)value; break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* ===== guest 8254 PIT ch0 模拟（仅跟踪 divisor，tick 由 preemption exit 驱动） ===== */
|
||
|
||
static u16 g_pit_divisor = 0; /* 0 = 65536（默认 18.2Hz） */
|
||
static int g_pit_load_state = 0; /* 0=等 lo 字节, 1=等 hi 字节 */
|
||
static u8 g_pit_lo = 0;
|
||
static u64 g_pit_period_tsc = 0; /* 每 tick 的 TSC 周期 */
|
||
static u64 g_pit_accum = 0;
|
||
static u64 g_last_tick_tsc = 0;
|
||
|
||
static u64 rdtsc_local(void) {
|
||
u32 lo, hi;
|
||
__asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
|
||
return ((u64)hi << 32) | lo;
|
||
}
|
||
|
||
static void pit_recompute_period(void) {
|
||
u64 tpm = serial_tsc_per_ms();
|
||
if (tpm == 0) tpm = 2000000; /* 未校准时按 ~2GHz 兜底 */
|
||
u64 div = g_pit_divisor ? g_pit_divisor : 65536;
|
||
/* period_tsc = div / 1193182 Hz，用 ms 刻度换算避免溢出 */
|
||
g_pit_period_tsc = (div * tpm) / 1193; /* ≈ div * tpm * 1000 / 1193182 */
|
||
if (g_pit_period_tsc == 0) g_pit_period_tsc = 1;
|
||
}
|
||
|
||
static u64 pit_io(u32 port, int is_in, u64 value) {
|
||
if (is_in) return 0; /* 计数器读回：恒 0（Linux 用 TSC clocksource，不依赖） */
|
||
if (port == 0x43) {
|
||
/* mode/command：仅关心 ch0 + lo/hi 访问方式 */
|
||
if ((value & 0xC0) == 0x00 && (value & 0x30) == 0x30) {
|
||
g_pit_load_state = 0;
|
||
}
|
||
return 0;
|
||
}
|
||
if (port == 0x40) {
|
||
if (g_pit_load_state == 0) {
|
||
g_pit_lo = (u8)value;
|
||
g_pit_load_state = 1;
|
||
} else {
|
||
g_pit_divisor = (u16)(g_pit_lo | ((u16)(u8)value << 8));
|
||
g_pit_load_state = 0;
|
||
pit_recompute_period();
|
||
}
|
||
return 0;
|
||
}
|
||
return 0; /* 0x41/0x42 吞掉 */
|
||
}
|
||
|
||
/* ===== 其余 legacy 端口（吞掉/返回安全值） ===== */
|
||
|
||
static u64 misc_io(u32 port, int is_in, u64 value, int *out_terminate) {
|
||
/* 8259 PIC master */
|
||
if (port == 0x20) {
|
||
if (!is_in) {
|
||
if (value & 0x10) { /* ICW1 */
|
||
g_pic_icw_sngl = (value & 0x02) != 0;
|
||
g_pic_icw_need4 = (value & 0x01) != 0;
|
||
g_pic_icw_state = 1;
|
||
g_pic_imr = 0xFF;
|
||
}
|
||
/* 其余 OCW2/OCW3（含 EOI）吞掉 */
|
||
}
|
||
return 0;
|
||
}
|
||
if (port == 0x21) {
|
||
if (is_in) return g_pic_imr;
|
||
switch (g_pic_icw_state) {
|
||
case 1: /* ICW2（向量基址，忽略，固定 0x30） */
|
||
g_pic_icw_state = g_pic_icw_sngl ? (g_pic_icw_need4 ? 3 : 0) : 2;
|
||
break;
|
||
case 2: /* ICW3 */
|
||
g_pic_icw_state = g_pic_icw_need4 ? 3 : 0;
|
||
break;
|
||
case 3: /* ICW4 */
|
||
g_pic_icw_state = 0;
|
||
break;
|
||
default: /* OCW1 = IMR */
|
||
g_pic_imr = (u8)value;
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
/* 8259 PIC slave：吞掉（不用） */
|
||
if (port == 0xA0 || port == 0xA1) return is_in ? 0xFF : 0;
|
||
|
||
/* 8254 PIT */
|
||
if (port >= 0x40 && port <= 0x43) return pit_io(port, is_in, value);
|
||
|
||
/* PS/2 键盘/鼠标（i8042）：status 读 0（空），data 读 0，写吞掉。
|
||
* i8042 自检将失败 → guest 无 PS/2 键鼠（console 输入走串口）。 */
|
||
if (port == 0x60 || port == 0x64) return is_in ? 0 : 0;
|
||
|
||
/* CMOS/RTC */
|
||
if (port == 0x70 || port == 0x71) return is_in ? 0 : 0;
|
||
|
||
/* PCI config mechanism #1：对 guest 隐藏整个 PCI 总线。
|
||
* guest reconfig BAR 会破坏 UTSM 的 AHCI/e1000，故全部返回"无设备"。 */
|
||
if (port >= 0xCF8 && port <= 0xCFF) return is_in ? 0xFFFFFFFFULL : 0;
|
||
|
||
/* 0xCF9 reset control：guest 请求重启 → 终止 guest 回 host */
|
||
if (port == 0xCF9) {
|
||
if (!is_in) {
|
||
log_warn("[VMEXIT] guest requested reboot via 0xCF9");
|
||
*out_terminate = 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* COM2-4：无设备 */
|
||
if ((port >= 0x2F8 && port <= 0x2FF) ||
|
||
(port >= 0x3E8 && port <= 0x3EF) ||
|
||
(port >= 0x2E8 && port <= 0x2EF)) {
|
||
return is_in ? 0xFF : 0;
|
||
}
|
||
|
||
/* 其余端口（0x80 delay、0x61 NMI、0x92 A20、0xB2 APM、0xF0-0xFF FPU
|
||
* error、0xED delay、ACPI 等）：读 0，写吞掉 */
|
||
return is_in ? 0 : 0;
|
||
}
|
||
|
||
/* ===== EXIT_IO_INSTRUCTION 处理 =====
|
||
*
|
||
* exit qualification（Intel SDM 27.2.4.2? 实为 Vol 3D 表 27-6）：
|
||
* bits 2:0 = 访问大小-1（0=1B, 1=2B, 3=4B）
|
||
* bit 3 = 方向（0=OUT, 1=IN）
|
||
* bit 4 = string 指令
|
||
* bit 5 = REP 前缀
|
||
* bits31:16 = 端口号
|
||
* OUT 数据在 guest RAX；IN 结果写回 guest RAX。
|
||
*/
|
||
static int handle_io(u64 qualification, u64 rip, u64 instr_len, int *out_resume) {
|
||
u32 port = (u32)(qualification >> 16);
|
||
u32 size = (u32)(qualification & 7) + 1;
|
||
int is_in = (qualification >> 3) & 1;
|
||
u64 value = 0;
|
||
int terminate = 0;
|
||
|
||
if (!is_in) {
|
||
value = g_guest_regs.rax;
|
||
if (size == 1) value &= 0xFF;
|
||
else if (size == 2) value &= 0xFFFF;
|
||
else value &= 0xFFFFFFFFULL;
|
||
}
|
||
|
||
u64 result;
|
||
if (port >= 0x3F8 && port <= 0x3FF) {
|
||
result = com1_io(port, is_in, value);
|
||
} else {
|
||
result = misc_io(port, is_in, value, &terminate);
|
||
}
|
||
|
||
if (is_in) {
|
||
if (size == 1) {
|
||
g_guest_regs.rax = (g_guest_regs.rax & ~0xFFULL) | (result & 0xFF);
|
||
} else if (size == 2) {
|
||
g_guest_regs.rax = (g_guest_regs.rax & ~0xFFFFULL) | (result & 0xFFFF);
|
||
} else {
|
||
g_guest_regs.rax = result & 0xFFFFFFFFULL; /* 32 位写清零高 32 位 */
|
||
}
|
||
}
|
||
|
||
if (terminate) {
|
||
*out_resume = 0;
|
||
return 0;
|
||
}
|
||
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
*out_resume = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* ===== EXIT_CPUID 处理：host passthrough + 屏蔽 VMX/hypervisor =====
|
||
*
|
||
* CPUID 在 VMX non-root 无条件 exit。必须真实执行并把结果写回 guest
|
||
* rax/rbx/rcx/rdx，否则 guest 特性探测全错（原"skip"实现会崩 Linux）。
|
||
* leaf 1 ecx：清 bit5(VMX) 与 bit31(hypervisor)，让 guest 认为自己在裸机。
|
||
*/
|
||
static void cpuid_host(u32 a, u32 c, u32 *oa, u32 *ob, u32 *oc, u32 *od) {
|
||
__asm__ volatile("cpuid"
|
||
: "=a"(*oa), "=b"(*ob), "=c"(*oc), "=d"(*od)
|
||
: "a"(a), "c"(c));
|
||
}
|
||
|
||
static int handle_cpuid(u64 rip, u64 instr_len, int *out_resume) {
|
||
u32 a = (u32)g_guest_regs.rax;
|
||
u32 c = (u32)g_guest_regs.rcx;
|
||
u32 oa, ob, oc, od;
|
||
cpuid_host(a, c, &oa, &ob, &oc, &od);
|
||
|
||
if (a == 1) {
|
||
oc &= ~(1u << 5); /* VMX */
|
||
oc &= ~(1u << 31); /* hypervisor present */
|
||
}
|
||
/* leaf 0x15/0x16 passthrough：QEMU 提供 TSC/总线频率，
|
||
* guest 据此校准 TSC（绕过 PIT ch2 校准路径）。 */
|
||
|
||
g_guest_regs.rax = oa;
|
||
g_guest_regs.rbx = ob;
|
||
g_guest_regs.rcx = oc;
|
||
g_guest_regs.rdx = od;
|
||
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
*out_resume = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* ===== resume 前例行工作：RX 轮询 + PIT tick + 注入 pending IRQ ===== */
|
||
|
||
static void poll_host_serial_to_guest(void) {
|
||
for (int i = 0; i < 32; i++) {
|
||
int b = serial_try_read();
|
||
if (b < 0) break;
|
||
int next = (g_rx_tail + 1) % GUEST_RX_SIZE;
|
||
if (next == g_rx_head) break; /* ring 满 */
|
||
g_guest_rx[g_rx_tail] = (u8)b;
|
||
g_rx_tail = next;
|
||
}
|
||
if (g_rx_head != g_rx_tail) {
|
||
vmx_guest_queue_irq(0x34); /* COM1 = IRQ4 → vector 0x34 */
|
||
}
|
||
}
|
||
|
||
static void pit_tick_update(void) {
|
||
u64 now = rdtsc_local();
|
||
if (g_last_tick_tsc == 0) {
|
||
g_last_tick_tsc = now;
|
||
if (g_pit_period_tsc == 0) pit_recompute_period();
|
||
return;
|
||
}
|
||
u64 delta = now - g_last_tick_tsc;
|
||
g_last_tick_tsc = now;
|
||
if (g_pit_period_tsc == 0) return;
|
||
g_pit_accum += delta;
|
||
int n = 0;
|
||
while (g_pit_accum >= g_pit_period_tsc && n < 8) {
|
||
g_pit_accum -= g_pit_period_tsc;
|
||
vmx_guest_queue_irq(0x30); /* PIT = IRQ0 → vector 0x30（自动合并） */
|
||
n++;
|
||
}
|
||
if (g_pit_accum >= g_pit_period_tsc) g_pit_accum = 0; /* 防积压 */
|
||
}
|
||
|
||
static u64 g_preemption_quantum = 0;
|
||
|
||
u64 vmx_preemption_quantum_1ms(void) {
|
||
if (g_preemption_quantum) return g_preemption_quantum;
|
||
u64 basic = vmx_read_msr(IA32_VMX_BASIC);
|
||
u64 scale = (basic >> 48) & 0xFF; /* preemption timer scale */
|
||
if (scale == 0) scale = 1;
|
||
u64 tpm = serial_tsc_per_ms();
|
||
if (tpm == 0) tpm = 2000000;
|
||
g_preemption_quantum = tpm / scale;
|
||
if (g_preemption_quantum == 0) g_preemption_quantum = 1;
|
||
return g_preemption_quantum;
|
||
}
|
||
|
||
int vmx_preemption_timer_supported(void) {
|
||
u64 msr = vmx_read_msr(IA32_VMX_TRUE_PINBASED_CTLS);
|
||
return (msr & (1ULL << (6 + 32))) != 0; /* bit6 允许置 1 */
|
||
}
|
||
|
||
/* 每次 vmresume 前调用（vmexit_dispatch resume=1 路径末尾）。
|
||
* 重新 arm preemption timer（1ms 周期 exit），轮询 host 串口 RX，
|
||
* 推进 PIT tick，注入 pending IRQ。
|
||
* 同时轮询 virtio-net RX：guest 投满 RX buffer 后不再 notify，
|
||
* host 网卡收到的包靠这里周期性填充并注入 IRQ6。 */
|
||
static void vmexit_before_resume(void) {
|
||
if (!g_linux_guest_active) return;
|
||
vmx_vmcs_write(VMCS_GUEST_PREEMPTION_TIMER, vmx_preemption_quantum_1ms());
|
||
poll_host_serial_to_guest();
|
||
virtio_net_poll();
|
||
virtio_input_poll(); /* VSCode Phase 2: drain pending kbd/mouse events */
|
||
pit_tick_update();
|
||
maybe_inject_irq();
|
||
}
|
||
|
||
/* ===== EPT violation: 指令解码（用于 virtio-mmio MMIO 数据） =====
|
||
*
|
||
* virtio-mmio 寄存器访问是普通 MOV 指令，如:
|
||
* mov eax, [gpa] 读 (8A /r 或 A1)
|
||
* mov [gpa], eax 写 (89 /r 或 A3)
|
||
* movzx/movsx 等
|
||
*
|
||
* 我们不需要完整解码——只需确定:
|
||
* 1. 访问方向（读 or 写）
|
||
* 2. 访问宽度（1/2/4/8 字节）
|
||
* 3. 写访问时的写入数据；读访问时数据写到哪个 guest GPR
|
||
*
|
||
* 这通过解码指令字节 + 读 guest RIP 处的机器码完成。
|
||
* 用 GVA=EPT GPA 简化：guest 采用恒等页表，GUEST_LINEAR_ADDR 即 GPA。
|
||
*/
|
||
|
||
/* 从 guest 内存读指令字节（GPA=GVA 恒等映射，经 EPT 翻译到 HPA）。 */
|
||
static int guest_fetch(u64 gva, u8 *buf, u64 len) {
|
||
u64 hhdm = g_hhdm_request.response ? g_hhdm_request.response->offset : 0;
|
||
for (u64 i = 0; i < len; i++) {
|
||
u64 hpa = ept_gpa_to_hpa(gva + i);
|
||
if (hpa == 0) return -1;
|
||
buf[i] = *(volatile u8 *)(hhdm + hpa);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* 解码 MMIO 访问指令。
|
||
* rip_gpa : guest RIP（GPA，恒等映射）
|
||
* is_write_out : 输出 1=写 MMIO，0=读 MMIO
|
||
* width_out : 输出访问宽度（字节）
|
||
* reg_field_out: 输出目标/源 GPR 在 g_guest_regs 中的索引（0-15）
|
||
* 返回指令总长度（用于回退时推进 RIP），失败返回 0。 */
|
||
static u64 decode_mmio_insn(u64 rip_gpa, int *is_write_out, int *width_out,
|
||
int *reg_field_out) {
|
||
u8 insn[16];
|
||
if (guest_fetch(rip_gpa, insn, sizeof(insn)) != 0) return 0;
|
||
|
||
u64 off = 0;
|
||
int rex_w = 0, rex_r = 0;
|
||
|
||
/* 跳过前缀 + REX */
|
||
for (;;) {
|
||
u8 b = insn[off];
|
||
if (b == 0x66 || b == 0x67 || b == 0xF0 || b == 0xF2 || b == 0xF3 ||
|
||
(b >= 0x2E && b <= 0x3E && (b==0x2E||b==0x36||b==0x3E||b==0x26||b==0x64||b==0x65))) {
|
||
off++;
|
||
continue;
|
||
}
|
||
if (b >= 0x40 && b <= 0x4F) { /* REX */
|
||
rex_w = (b >> 3) & 1;
|
||
rex_r = (b >> 2) & 1;
|
||
off++;
|
||
}
|
||
break;
|
||
}
|
||
|
||
u8 op = insn[off];
|
||
u8 modrm = insn[off + 1];
|
||
int reg = ((modrm >> 3) & 7) | (rex_r << 3);
|
||
|
||
/* mov r, m（读 MMIO）: 8A(8位) / 8B(全宽) */
|
||
if (op == 0x8A || op == 0x8B) {
|
||
*is_write_out = 0;
|
||
*width_out = (op == 0x8A) ? 1 : (rex_w ? 8 : 4);
|
||
*reg_field_out = reg;
|
||
return off + 2; /* 简化：假设 ModRM mod=00,rm=101(无 SIB/disp) */
|
||
}
|
||
/* mov m, r（写 MMIO）: 88(8位) / 89(全宽) */
|
||
if (op == 0x88 || op == 0x89) {
|
||
*is_write_out = 1;
|
||
*width_out = (op == 0x88) ? 1 : (rex_w ? 8 : 4);
|
||
*reg_field_out = reg;
|
||
return off + 2;
|
||
}
|
||
/* movzx: 0F B6(8→宽) / 0F B7(16→宽) 读 */
|
||
if (op == 0x0F && (insn[off+1] == 0xB6 || insn[off+1] == 0xB7)) {
|
||
*is_write_out = 0;
|
||
*width_out = (insn[off+1] == 0xB6) ? 1 : 2;
|
||
u8 m2 = insn[off + 2];
|
||
*reg_field_out = ((m2 >> 3) & 7) | (rex_r << 3);
|
||
return off + 3;
|
||
}
|
||
|
||
/* 无法解码（如带 SIB/displacement 的复杂寻址）。
|
||
* virtio-mmio 驱动用简单寄存器访问，暂不支持则返回 0。 */
|
||
return 0;
|
||
}
|
||
|
||
/* 按索引读写 guest GPR（用于 MMIO 数据的源/目的）。 */
|
||
static u64 *gpr_ptr(int idx) {
|
||
switch (idx & 15) {
|
||
case 0: return (u64 *)&g_guest_regs.rax;
|
||
case 1: return (u64 *)&g_guest_regs.rcx;
|
||
case 2: return (u64 *)&g_guest_regs.rdx;
|
||
case 3: return (u64 *)&g_guest_regs.rbx;
|
||
case 6: return (u64 *)&g_guest_regs.rsi;
|
||
case 7: return (u64 *)&g_guest_regs.rdi;
|
||
case 5: return (u64 *)&g_guest_regs.rbp;
|
||
case 4: return (u64 *)&g_guest_regs.rax; /* rsp 不用作 MMIO 数据，占位 */
|
||
case 8: return (u64 *)&g_guest_regs.r8;
|
||
case 9: return (u64 *)&g_guest_regs.r9;
|
||
case 10: return (u64 *)&g_guest_regs.r10;
|
||
case 11: return (u64 *)&g_guest_regs.r11;
|
||
case 12: return (u64 *)&g_guest_regs.r12;
|
||
case 13: return (u64 *)&g_guest_regs.r13;
|
||
case 14: return (u64 *)&g_guest_regs.r14;
|
||
case 15: return (u64 *)&g_guest_regs.r15;
|
||
}
|
||
return (u64 *)&g_guest_regs.rax;
|
||
}
|
||
|
||
/* 处理 virtio-mmio 设备 GPA 的访问：路由到设备模拟。返回 1=已处理（resume）。 */
|
||
static int handle_virtio_mmio_access(u64 gpa, u64 rip, int *out_resume) {
|
||
int is_write, width, reg;
|
||
u64 insn_len = decode_mmio_insn(rip, &is_write, &width, ®);
|
||
if (insn_len == 0) {
|
||
log_error("[VMEXIT] virtio-mmio: cannot decode access insn");
|
||
log_hex64("[VMEXIT] rip=", rip);
|
||
*out_resume = 0;
|
||
return -1;
|
||
}
|
||
|
||
u64 value = 0;
|
||
if (is_write) {
|
||
/* 从 guest GPR 取写入数据（按宽度截断） */
|
||
u64 raw = *gpr_ptr(reg);
|
||
if (width == 1) value = raw & 0xFF;
|
||
else if (width == 2) value = raw & 0xFFFF;
|
||
else if (width == 4) value = raw & 0xFFFFFFFFULL;
|
||
else value = raw;
|
||
virtio_mmio_write(gpa, value, width);
|
||
} else {
|
||
/* 从设备读，写入 guest GPR（按宽度） */
|
||
value = virtio_mmio_read(gpa, width);
|
||
u64 *dst = gpr_ptr(reg);
|
||
if (width == 1) *dst = (*dst & ~0xFFULL) | (value & 0xFF);
|
||
else if (width == 2) *dst = (*dst & ~0xFFFFULL) | (value & 0xFFFF);
|
||
else if (width == 4) *dst = value & 0xFFFFFFFFULL; /* 32位写清零高32 */
|
||
else *dst = value;
|
||
}
|
||
|
||
/* 推进 RIP 越过 MMIO 指令，resume guest */
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + insn_len);
|
||
*out_resume = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* 处理 EPT violation：区分 guest RAM（按需分配）与 virtio-mmio（设备模拟）。
|
||
*
|
||
* exit qualification bits:
|
||
* bit0 = read access, bit1 = write access, bit2 = instruction fetch
|
||
* bit3 = EPT entry readable, bit4 = writable, bit5 = executable
|
||
* virtio-mmio GPA 故意不映射 → bit3/4/5 全 0 → "访问不存在页"。 */
|
||
static int handle_ept_violation(u64 qualification, u64 rip, int *out_resume) {
|
||
(void)qualification; /* virtio-mmio 判定只看 GPA，不看访问类型 */
|
||
u64 gpa = vmx_vmcs_read(VMCS_GUEST_PHYSICAL_ADDR);
|
||
|
||
/* virtio-mmio 设备区：路由到设备模拟，绝不映射真实内存 */
|
||
if (IS_VIRTIO_MMIO_GPA(gpa)) {
|
||
return handle_virtio_mmio_access(gpa, rip, out_resume);
|
||
}
|
||
|
||
/* 普通 guest RAM：按需分配 HPA 页并映射 */
|
||
u64 page = gpa & ~(EPT_PAGE_SIZE - 1);
|
||
if (ept_map_guest_ram_page(page) != 0) {
|
||
log_error("[VMEXIT] EPT violation: guest RAM map failed");
|
||
log_hex64("[VMEXIT] gpa=", gpa);
|
||
*out_resume = 0;
|
||
return -1;
|
||
}
|
||
*out_resume = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* 处理通用异常：打印诊断信息，终止 guest。 */
|
||
static int handle_exception(u64 qualification, u64 rip, int *out_resume) {
|
||
u64 intr_info = vmx_vmcs_read(0x4404); /* VM_EXIT_INTR_INFO */
|
||
log_hex64("[VMEXIT] exception intr_info=", intr_info);
|
||
log_hex64("[VMEXIT] exception qual=", qualification);
|
||
log_hex64("[VMEXIT] exception rip=", rip);
|
||
*out_resume = 0;
|
||
return 0;
|
||
}
|
||
|
||
/* VM-Exit 主分发器。从 vmx_vm_exit_handler（汇编入口）调用。
|
||
* 返回 1 表示 vmresume；0 表示终止 guest。 */
|
||
int vmexit_dispatch(void) {
|
||
u64 reason = vmx_vmcs_read(VMCS_EXIT_REASON) & 0xFFFF;
|
||
u64 qualification = vmx_vmcs_read(VMCS_EXIT_QUALIFICATION);
|
||
u64 rip = vmx_vmcs_read(VMCS_GUEST_RIP);
|
||
u64 instr_len = vmx_vmcs_read(VMCS_INSTRUCTION_LENGTH);
|
||
int resume = 0;
|
||
|
||
g_vmexit_count++;
|
||
INSTR_STAT_INC(vmexit_total);
|
||
|
||
switch (reason) {
|
||
case EXIT_HLT:
|
||
handle_hlt(rip, instr_len, &resume);
|
||
break;
|
||
case EXIT_EPT_VIOLATION:
|
||
INSTR_STAT_INC(ept_violation);
|
||
handle_ept_violation(qualification, rip, &resume);
|
||
break;
|
||
case EXIT_EPT_MISCONFIG:
|
||
/* MMIO 区域权限配置错误或硬件 EPT 表损坏。诊断后终止。 */
|
||
INSTR_PROBE(EPTM, vmx_vmcs_read(VMCS_GUEST_PHYSICAL_ADDR), rip, 0, 0);
|
||
log_error("[VMEXIT] EPT misconfig");
|
||
log_hex64("[VMEXIT] gpa=", vmx_vmcs_read(VMCS_GUEST_PHYSICAL_ADDR));
|
||
resume = 0;
|
||
break;
|
||
case EXIT_EXCEPTION_NMI:
|
||
INSTR_PROBE(EXCP, qualification, rip, 0, 0);
|
||
handle_exception(qualification, rip, &resume);
|
||
break;
|
||
case EXIT_TRIPLE_FAULT:
|
||
INSTR_PROBE(EXCP, 0, rip, 0, 0);
|
||
log_error("[VMEXIT] triple fault");
|
||
resume = 0;
|
||
break;
|
||
case EXIT_EXTERNAL_INTERRUPT:
|
||
INSTR_STAT_INC(ext_irq);
|
||
/* 外部中断到达 host（真机比 QEMU 更频繁触发）。
|
||
* 当前 UTSM 不处理 host 外部中断（依赖 PIC/IDT），
|
||
* 直接 resume guest。真机上此 exit 由 PIN_EXT_INTERRUPT_EXITING
|
||
* 触发，不应终止 guest。 */
|
||
resume = 1;
|
||
break;
|
||
case EXIT_INIT_SIGNAL:
|
||
/* INIT 信号在 VMX root 下被阻断，但 non-root 会 exit。
|
||
* 真机 BSP 向 AP 发 INIT-IPI-SIPI 时可能触发。
|
||
* 吞掉：不执行 INIT，直接 resume。 */
|
||
resume = 1;
|
||
break;
|
||
case EXIT_INVD:
|
||
/* INVD（cache flush）：吞掉，直接 resume。 */
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
resume = 1;
|
||
break;
|
||
case EXIT_MONITOR:
|
||
case EXIT_MWAIT:
|
||
/* MONITOR/MWAIT：在 noapic 模式下 Linux 不会主动使用，
|
||
* 但某些驱动路径可能触发。直接 resume。 */
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
resume = 1;
|
||
break;
|
||
case EXIT_CPUID:
|
||
INSTR_STAT_INC(cpuid_exit);
|
||
/* host passthrough + 屏蔽 VMX/hypervisor 位（handle_cpuid 内推进 RIP） */
|
||
handle_cpuid(rip, instr_len, &resume);
|
||
break;
|
||
case EXIT_IO_INSTRUCTION:
|
||
INSTR_STAT_INC(io_exit);
|
||
/* legacy 设备模拟：COM1 UART / PIC / PIT / 其余端口吞掉 */
|
||
handle_io(qualification, rip, instr_len, &resume);
|
||
break;
|
||
case EXIT_INTERRUPT_WINDOW:
|
||
INSTR_STAT_INC(intr_window);
|
||
/* guest 刚开中断（RFLAGS.IF=1）：尝试注入 pending IRQ */
|
||
{
|
||
u64 cpu = vmx_vmcs_read(VMCS_CPU_BASED_VM_EXEC_CONTROL);
|
||
vmx_vmcs_write(VMCS_CPU_BASED_VM_EXEC_CONTROL,
|
||
cpu & ~CPU_BASED_INTR_WINDOW_EXITING);
|
||
maybe_inject_irq();
|
||
resume = 1;
|
||
}
|
||
break;
|
||
case EXIT_VMX_PREEMPTION_TIMER:
|
||
INSTR_STAT_INC(preempt_timer);
|
||
/* 1ms 周期 exit：resume 前由 vmexit_before_resume 统一
|
||
* 轮询 host 串口 RX / 推进 PIT tick / 注入 pending IRQ */
|
||
resume = 1;
|
||
break;
|
||
case EXIT_RDMSR:
|
||
case EXIT_WRMSR: {
|
||
INSTR_STAT_INC(msr_exit);
|
||
/* 真机 MSR 访问比 QEMU 严格得多。Linux guest 会访问许多 MSR：
|
||
* - IA32_MISC_ENABLE (0x1A0): QEMU 忽略，真机需要返回合理值
|
||
* - IA32_APIC_BASE (0x1B): APIC base 地址
|
||
* - IA32_TSC_AUX (0xC0000103): RDTSCP auxiliary
|
||
* - IA32_FS_BASE/GS_BASE (0xC0000100/1): 已由 VMCS 管理
|
||
* - IA32_KERNEL_GS_BASE (0xC0000102): swapgs 目标
|
||
* - IA32_BNDCFGS (0xD90): MPX bound config（某些 Intel 有）
|
||
* 当前策略：直接 passthrough host MSR 值（读），或忽略写。
|
||
* 注意：WRMSR 写入某些 MSR 可能影响 host，需要白名单保护。
|
||
*/
|
||
u64 msr = g_guest_regs.rcx & 0xFFFFFFFFULL;
|
||
if (reason == EXIT_RDMSR) {
|
||
u64 val = 0;
|
||
/* 白名单：允许读取的 MSR（passthrough host 值） */
|
||
int allowed = 0;
|
||
/* 通用允许列表 */
|
||
if (msr == 0x1A0 || /* IA32_MISC_ENABLE */
|
||
msr == 0x1B || /* IA32_APIC_BASE */
|
||
msr == 0xC0000100 || /* IA32_FS_BASE */
|
||
msr == 0xC0000101 || /* IA32_GS_BASE */
|
||
msr == 0xC0000102 || /* IA32_KERNEL_GS_BASE */
|
||
msr == 0xC0000103 || /* IA32_TSC_AUX */
|
||
msr == 0xD90 || /* IA32_BNDCFGS */
|
||
msr == 0x3A || /* IA32_FEATURE_CONTROL */
|
||
msr == 0x8B || /* IA32_BIOS_SIGN (microcode) */
|
||
msr == 0x17 || /* IA32_PLATFORM_ID */
|
||
msr == 0x4B || /* IA32_UCODE_REV (some CPUs) */
|
||
msr == 0xCE || /* IA32_PLATFORM_INFO */
|
||
msr == 0x198 || /* IA32_PERF_STATUS */
|
||
msr == 0x199 || /* IA32_PERF_CTL */
|
||
msr == 0x1AD || /* IA32_THREAD_FEEDBACK_CHAR (Raptor Lake) */
|
||
msr == 0x1AE || /* IA32_CORE_THREAD_COUNT */
|
||
(msr >= 0x0 && msr <= 0x1F) || /* Basic CPUID MSRs */
|
||
(msr >= 0x30 && msr <= 0x3F) || /* PMC MSRs */
|
||
(msr >= 0x186 && msr <= 0x18F) || /* Perf MSRs */
|
||
(msr >= 0xC0000000 && msr <= 0xC0000103) /* SYSENTER/EFER etc */
|
||
) {
|
||
allowed = 1;
|
||
}
|
||
if (allowed) {
|
||
/* 安全读取：用 rdmsr 可能 #GP，用 try-catch 模式 */
|
||
__asm__ volatile(
|
||
"1: rdmsr\n"
|
||
" jmp 2f\n"
|
||
".section .text\n"
|
||
"2:\n"
|
||
: "=a"(((u32*)&val)[0]), "=d"(((u32*)&val)[1])
|
||
: "c"(msr)
|
||
);
|
||
}
|
||
g_guest_regs.rax = val & 0xFFFFFFFFULL;
|
||
g_guest_regs.rdx = (val >> 32) & 0xFFFFFFFFULL;
|
||
} else {
|
||
/* WRMSR：白名单保护，防止 guest 修改 host MSR */
|
||
int allowed = 0;
|
||
if (msr == 0xC0000100 || /* IA32_FS_BASE — VMCS 管理，忽略 */
|
||
msr == 0xC0000101 || /* IA32_GS_BASE — VMCS 管理，忽略 */
|
||
msr == 0xC0000102 || /* IA32_KERNEL_GS_BASE — 可安全 passthrough */
|
||
msr == 0xC0000103 || /* IA32_TSC_AUX */
|
||
msr == 0x1B || /* IA32_APIC_BASE — 忽略（guest noapic） */
|
||
msr == 0xD90 || /* IA32_BNDCFGS — 忽略 */
|
||
msr == 0x199 /* IA32_PERF_CTL — 忽略 */
|
||
) {
|
||
allowed = 1;
|
||
}
|
||
/* 不允许的写直接吞掉 */
|
||
if (!allowed) {
|
||
log_hex64("[VMEXIT] WRMSR blocked msr=", msr);
|
||
}
|
||
}
|
||
vmx_vmcs_write(VMCS_GUEST_RIP, rip + instr_len);
|
||
resume = 1;
|
||
break;
|
||
}
|
||
case EXIT_VMCALL:
|
||
INSTR_PROBE(HCALL, g_guest_regs.rax, g_guest_regs.rdi, g_guest_regs.rsi, rip);
|
||
/* VMCALL hypercall: read guest GPRs from g_guest_regs (saved by
|
||
* vmexit_asm.S), dispatch to the hypercall handler, and write
|
||
* the return value into g_guest_regs.rax. The handler also
|
||
* advances GUEST_RIP past the VMCALL instruction. */
|
||
{
|
||
int hcall_resume = hypercall_handle(
|
||
g_guest_regs.rax, g_guest_regs.rdi,
|
||
g_guest_regs.rsi, g_guest_regs.rdx,
|
||
rip, instr_len);
|
||
resume = hcall_resume;
|
||
}
|
||
break;
|
||
default:
|
||
log_exit_diagnostics(reason, qualification, rip, instr_len);
|
||
resume = 0;
|
||
break;
|
||
}
|
||
|
||
(void)qualification;
|
||
|
||
/* resume 前例行工作：arm preemption timer + host 串口 RX 轮询 +
|
||
* PIT tick 推进 + pending IRQ 注入（仅 Linux guest active 时） */
|
||
if (resume) {
|
||
INSTR_STAT_INC(pre_resume);
|
||
vmexit_before_resume();
|
||
}
|
||
return resume;
|
||
}
|
||
|
||
u64 vmexit_get_count(void) { return g_vmexit_count; }
|