10.2KVM嵌套虚拟化原理

10.2.1 KVM嵌套虚拟化简介

KVM使用Intel的vmx来提高虚拟机性能, ,现在如果我们需要多台具备VMX支持的主机, 但是又没有太多物理机器可使用, 那应该怎么办呢？ 如果我们的虚拟机能够和物理机一样支持VMX,就能解决这个问题了. 为此，KVM引入了嵌套(nested)虚拟化的支持。也就是能够在第一级的kvm虚拟机(L1 VM)上在启动第二级kvm虚拟机(L2 VM). 在物理机KVM模块加载时添加"nested =1"的选项； 并在第一级虚拟机Qemu启动时设置 "-cpu host"选项，就能开启该功能。

 

下面看看当nested为1时KVM与普通流程的区别：

(1)hardware_setup 时会调用 nested_vmx_setup_ctls_msrs初始化nested  寄存器相关的变量，这些变量将用于一级虚拟机读取Cpu虚拟化相关能力寄存器时返回：

handle_rdmsr==》 vmx_get_msr ==> vmx_get_vmx_msr

对于MSR_IA32_VMX_BASIC的case会返回VMCS12_REVISION, 该标志用于是L2虚拟机的VMCS.

 

(2)虚拟化指令的实现，一级虚拟机将会使用vmxon, vmlaunch等指令

    [EXIT_REASON_VMCALL]                  = handle_vmcall,

    [EXIT_REASON_VMCLEAR]                  =handle_vmclear,

    [EXIT_REASON_VMLAUNCH]                = handle_vmlaunch,

    [EXIT_REASON_VMPTRLD]                 = handle_vmptrld,

    [EXIT_REASON_VMPTRST]                 = handle_vmptrst,

    [EXIT_REASON_VMREAD]                  = handle_vmread,

    [EXIT_REASON_VMRESUME]                = handle_vmresume,

    [EXIT_REASON_VMWRITE]                 = handle_vmwrite,

    [EXIT_REASON_VMOFF]                   = handle_vmoff,

    [EXIT_REASON_VMON]                    = handle_vmon,

下一小节将按虚拟机初始化的顺序来分析这些函数。

 

(3)Nested的内存虚拟化与普通模式不同

init_kvm_mmu==> init_kvm_nested_mmu

10.2.2VMX指令虚拟化

10.2.2.1L2虚拟机的创建与运行

L1虚拟机出创建L2虚拟机的指令流程如下：

a)  CPU虚拟机能力检测.

b)  VMXON

c)  VMCLEAR清除VMCS状态

d)   VMPTRLD 装载当前VMCS

e)   VMWrite 初始化VMCS

f)  VMLaunch启动虚拟机

下面我们按照这个顺序来看Host对L1的这几个指令的实现

 

(1) CPU虚拟机能力检测

该步骤由handle_rdmsr==》 vmx_get_msr ==> vmx_get_vmx_msr

实现。

 

(2) VMXON

handle_vmon 流程如下：

a. 当前CPU能力与状态检察

b. nested_vmx_check_vmptr 检察VMXON区域

       page =nested_get_page(vcpu, vmptr);

       if (page == NULL ||

           *(u32 *)kmap(page) != VMCS12_REVISION) {

           nested_vmx_failInvalid(vcpu);

           kunmap(page);

           skip_emulated_instruction(vcpu);

           return 1;

       }

c. 为Vmx-Preemptiontimer机制准备timer和回调用于模拟该机制

    hrtimer_init(&vmx->nested.preemption_timer,CLOCK_MONOTONIC,

            HRTIMER_MODE_REL);

    vmx->nested.preemption_timer.function= vmx_preemption_timer_fn;

d.  设置vmxon 为True

    vmx->nested.vmxon =true;

    skip_emulated_instruction(vcpu);

    nested_vmx_succeed(vcpu);

 

(3) VMCLEAR

handle_vmclear 流程如下：

    vmcs12 = kmap(page);

    vmcs12->launch_state= 0; //设子launch为0

    kunmap(page);

    nested_release_page(page);

 

(4) VMPTRLD 装载当前VMCS

handle_vmptrld

a)  取得vmptr: nested_vmx_check_vmptr(vcpu,EXIT_REASON_VMPTRLD, &vmptr)

b)  取得vmcs区域内存虚拟地址:

page= nested_get_page(vcpu, vmptr);

new_vmcs12= kmap(page);

c)  存储到vmx结构中去

vmx->nested.current_vmptr= vmptr;

vmx->nested.current_vmcs12= new_vmcs12;

vmx->nested.current_vmcs12_page= page;

 

(4) VMWrite 初始化VMCS

handle_vmwrite

a)  用get_vmx_mem_address取得要写的地址的gva

b)  kvm_read_guest_virt从上面的gva中取出要写的值

c)  kvm_register_read取得要写的寄存器的偏移

d)  vmcs12_write_any(vcpu,field, field_value);

写入到nested.current_vmcs12对应的位置

 

(5) VMLaunch 启动虚拟机

handle_vmlaunch ==> nested_vmx_run(vcpu, true);

下面分析nested_vmx_run的流程：

a. 检察vmcs12的状态

b. 调用nested_get_current_vmcs02分配一个vmcs02结构作为L2 VM的VMCS

   vmx->nested.vmcs02_pool链表用于管理已经分配的vmcs02.

   并调用loaded_vmcs_init 在物理机上对vmcs02执行vmclear

c. enter_guest_mode 设置L1 cpu的arch.hflags |= HF_GUEST_MASK

d. 准备切换vmcs

    vmx->loaded_vmcs =vmcs02;

    vmx_vcpu_put保存当前hoststate到vmx->host_state

e. vmx_vcpu_load==> vmcs_load(vmx->loaded_vmcs->vmcs);

    在物理机上执行vmptrld， 加载vmcs02

    然后更新当前vmcs的host state:TSSand GDT与Esp

d. vmcs12->launch_state

e. prepare_vmcs02用于设置vmcs02的vmcs

f. vmx->nested.nested_run_pending= 1;

 

上面的流程并未结束，当vm-exit后续代码执行时，cpu会回到L2虚拟机eip执行，流程如下：

r = kvm_x86_ops->handle_exit(vcpu); 结束后

__vcpu_run下次循环将重新调用vcpu_enter_guest==》 kvm_x86_ops->run(vcpu);

由于此时loaded_vmcs 已为vmcs02，所以最终将返回到L2 VM上的EIP执行。

 

小结:vmcs12用于记录L1上管理的L2的VMCS;vmcs02用于记录物理机到L2的vmcs； vmcs01用于管理物理机到L1VM的VMCS.

 

10.2.2.2 L2虚拟机VM-Exit流程分析

下面以L2虚拟机写CR0为例来分析该流程

vmx_handle_exit 此时由于如下条件成立：

is_guest_mode(vcpu) 成立， 但nested_vmx_exit_handled返回true

所以并不走普通流程而是执行下面代码和返回：

    if (is_guest_mode(vcpu)&& nested_vmx_exit_handled(vcpu)) {

       nested_vmx_vmexit(vcpu,exit_reason,

                vmcs_read32(VM_EXIT_INTR_INFO),

                vmcs_readl(EXIT_QUALIFICATION));

       return 1;

    }

 

nested_vmx_exit_handled  ==》 nested_vmx_exit_handled_cr 将要操作的cr值存储到vmcs12中

 

nested_vmx_vmexit流程如下：

a. 根据当前vmcs02设置vmcs12的值prepare_vmcs12

b.加载vmcs01（vmcs01为L1在物理机上的vmcs)

  vmx->loaded_vmcs =&vmx->vmcs01;

    vmx_vcpu_put(vcpu);

    vmx_vcpu_load(vcpu,cpu);

b. 更新vmcs01的值

    vm_entry_controls_init(vmx,vmcs_read32(VM_ENTRY_CONTROLS));

    vm_exit_controls_init(vmx,vmcs_read32(VM_EXIT_CONTROLS));

c. 从vmcs12中load host state到vmcs(vmcs01)

 

这样当返回时将返回到L1 VM的KVM 代码的VM-Exit处理位置。 L1 KVM来进一步处理L2的vm-exit,最后L1的vmresume指令将会触发，再次进入到物理机的vmx_handle_exit. 下面我们分析该流程。

handle_vmresume==> nested_vmx_run(vcpu, false);该流程与vmlaunch类似； 最终再次进入L2.

 

本节最后在分析external interrupt导致的vm-exit的例子。

由于nested_vmx_exit_handled返回False,所以直接进入

kvm_vmx_exit_handlers[exit_reason](vcpu) ==》 handle_external_interrupt 然后直接由物理机resume到L2 VM.

 

10.2.3 EPT内存嵌套虚拟化

10.2.3.1 物理机对L1和 L2的内存管理的区别

本节先从EPT表的切换开始分析内存虚拟化：

KVM 初始化时在kvm_create中

    vcpu->arch.mmu.translate_gpa= translate_gpa;

    vcpu->arch.nested_mmu.translate_gpa= translate_nested_gpa;

 

Case 1: VM-Exit 到L2 VM

nested_vmx_run ==> prepare_vmcs02 ==> {

        if (nested_cpu_has_ept(vmcs12)) {

       kvm_mmu_unload(vcpu);//解除当前的ept映射

       nested_ept_init_mmu_context(vcpu);

    }

    。。。。。。

       kvm_set_cr3(vcpu,vmcs12->guest_cr3); //采用L1的EPT映射

       kvm_mmu_reset_context(vcpu);//调用init_kvm_nested_mmu

}

这里切换了物理机对内存访问的函数指针。

 

static void nested_ept_init_mmu_context(struct kvm_vcpu *vcpu)

{

    kvm_init_shadow_ept_mmu(vcpu,&vcpu->arch.mmu,

           nested_vmx_ept_caps& VMX_EPT_EXECUTE_ONLY_BIT);

 

    vcpu->arch.mmu.set_cr3           = vmx_set_cr3;

    vcpu->arch.mmu.get_cr3           = nested_ept_get_cr3;

    vcpu->arch.mmu.inject_page_fault= nested_ept_inject_page_fault;

    //walk_mmu用于EPT页的查找这里替换为nested_mmu的

    vcpu->arch.walk_mmu             = &vcpu->arch.nested_mmu;

}

 

void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, structkvm_mmu *context,

       bool execonly)

{

    context->shadow_root_level= kvm_x86_ops->get_tdp_level();

 

    context->nx = true;

   context->page_fault= ept_page_fault;

   context->gva_to_gpa= ept_gva_to_gpa;

   context->sync_page= ept_sync_page;

   context->invlpg= ept_invlpg;

   context->update_pte= ept_update_pte;

    context->root_level= context->shadow_root_level;

    context->root_hpa = INVALID_PAGE;

    context->direct_map= false;

 

    update_permission_bitmask(vcpu,context, true);

    reset_rsvds_bits_mask_ept(vcpu,context, execonly);

}

当物理机VMM Host 为L2 服务时，page_fault等函数处理函数也发生了切换（原来为tdp_page_fault。

 

    kvm_mmu_reset_context  ==> init_kvm_nested_mmu     会切换vcpu->arch.nested_mmu ->gva_to_gpa gva_to_gpa 到 xxxx_gva_to_gpa_nested （该函数遍历nested_mmu完成gva到gpa)

当需要在host上访问取虚拟机内存数据时，如kvm_read_guest_virt_system，

其调用流程如下：

kvm_read_guest_virt_system ==》 kvm_read_guest_virt_helper {

       gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu,addr, access,

                             exception);

       unsigned offset =addr & (PAGE_SIZE-1);

       unsigned toread =min(bytes, (unsigned)PAGE_SIZE - offset);

       int ret;

       ret =kvm_read_guest(vcpu->kvm, gpa, data, toread);

}

这时vcpu->arch.walk_mmu->gva_to_gpa会被调用, 该函数会调用

static int FNAME(walk_addr_nested)(struct guest_walker *walker,

                 struct kvm_vcpu *vcpu, gva_t addr,

                 u32 access)

{

    returnFNAME(walk_addr_generic)(walker, vcpu, &vcpu->arch.nested_mmu,

                  addr,access);

}

walk_addr_generic ==> mmu->translate_gpa (这里的mmu为nested mmu)

gpa_t translate_nested_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32access)

{

    access |=PFERR_USER_MASK;

    t_gpa  = vcpu->arch.mmu.gva_to_gpa(vcpu, gpa,access, &exception);

    return t_gpa;

}

vcpu->arch.mmu.gva_to_gpa ==> ept_gva_to_gpa = gva_to_gpa

static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, gva_tvaddr, u32 access,

                  struct x86_exception *exception)

{

    r =FNAME(walk_addr)(&walker, vcpu, vaddr, access);

 

    if (r) {

       gpa = gfn_to_gpa(walker.gfn);

       gpa |= vaddr &~PAGE_MASK;

    } else if (exception)

       *exception =walker.fault;

 

    return gpa;

}

当在物理机上访问L2内存时， 要做两层次搜索， 根据nested_mmu遍历L2的页目录表， 但执行到translate_gpa时会搜索L1的目录表。

 

Case 2: Vm-Exit退出L2VM到L1 VM:

nested_vmx_vmexit ==> load_vmcs12_host_state ==> {

 nested_ept_uninit_mmu_context

 kvm_set_cr3(vcpu,vmcs12->host_cr3);

kvm_mmu_reset_context(vcpu); //init_kvm_tdp_mmu 回被调用

}

static void nested_ept_uninit_mmu_context(struct kvm_vcpu *vcpu)

{

    vcpu->arch.walk_mmu= &vcpu->arch.mmu; //切回对L1 的EPT管理

}

由于init_kmv_tdp_mmu被调用，因此包括缺页在内的处理方式有变回了default的ept方式。

 

 

小结：对于对客户机内存的访问，当为L1时，和普通流程相同。 当为L2是，需要进行两层的转换。

 

10.2.3.2 L2 EPT异常的处理

 

L1的EPT处理和3.3同:

kvm_mmu_page_fault ==> vcpu->arch.mmu.page_fault = tdp_page_fault.

 

下面从L2的EPT异常处理分析嵌套虚拟化的内存管理机制：

VM-Exit ==> nested_vmx_exit_handled 返回0所以会调用到

kvm_vmx_exit_handlers[exit_reason](vcpu) ==》 handle_ept_violation ==> kvm_mmu_page_fault==>  vcpu->arch.mmu.page_fault==> ept_page_fault

该函数用宏实现位于page_tmpl.h, 其流程如下：

(a) 处理mmio case: handle_mmio_page_fault

(b) FNAME(walk_addr)(&walker, vcpu, addr, error_code);根据出错的addr(addr为gva），从客户机页目录表(cr3从得到)开始遍历得到指向该gva的gfn,若gfn不存在则返回让L1 VM处理.

(c) try_async_pf根据gfn的到pfn（若不存在底层的hva_to_pfn_slow会建立物理页)

由此看出对于ept_violation，nest与基于影子页表的内存虚拟化流程基本相同(参考3.4)； 不能直接用ept的处理的原因是L2 GVA不能直接对应的L1的GPA(EPT处理L1 GPA->HPA).

 

接下来kvm_mmu_page_fault会调用x86_emulate_instruction==》 inject_emulated_exception ==》kvm_propagate_fault ==> vcpu->arch.nested_mmu.inject_page_fault==> kvm_inject_page_fault注入异常让L1 VM处理。

 

最后来看看L2->物理机->L1的内存管理切换开销

 

下面看看物理机KVM如何管理这vmcs01 和vmcs02对应的EPT：

vcpu_enter_guest 准备进入guest时会先调用：kvm_mmu_reload ==》 kvm_mmu_load 该函数会:

int kvm_mmu_load(struct kvm_vcpu *vcpu)

{

    ............

    r = mmu_alloc_roots(vcpu); //分配root_hpa

    kvm_mmu_sync_roots(vcpu);

    vcpu->arch.mmu.set_cr3(vcpu,vcpu->arch.mmu.root_hpa);

    .........

}

mmu_alloc_roots ==> kvm_mmu_get_page

 

当虚拟机vmcs切换时，kvm_mmu_reset_context==> kvm_mmu_unload,由此完成了页表的切换

 

问题，切换时销毁了EPT表， 是否会导致性能问题呢？

原来此时并不会free所有kvm_mmu_page信息，mmu_free_roots相关代码如下：
        if(!sp->root_count && sp->role.invalid){

           kvm_mmu_prepare_zap_page(vcpu->kvm,sp, &invalid_list);

           kvm_mmu_commit_zap_page(vcpu->kvm,&invalid_list);

       }

不光引用计数要为0，而且sp->role.invalid要被设置。 如果未销毁，下次分配将从kvm->arch.mmu_page_hash[kvm_page_table_hashfn(_gfn)]中取得，而不需要多次调用kvm_mmu_alloc_page。

 

当kvm真正销毁时，kvm_destroy_vm ==》 kvm_arch_flush_shadow_all ==》 kvm_mmu_invalidate_zap_all_pages会将该标志设置，之后kvm_mmu_unload是就会是否所有内存了， 而切换时并不会， 仅仅是root_hpa设为空而已，下次换入时为root_hap设个值就可以了。