KVM vCPU创建过程

1、基本原理
如之前的文章分析，在KVM虚拟化环境中， 硬件虚拟化使用 VCPU(Virtual CPU) 描述符来描述虚拟 CPU ，VCPU 描述符与 OS 中进程描述符类似，本质是一个结构体kvm_vcpu，其中包含如下信息：

VCPU标识信息，如VCPU的ID号，VCPU属于哪个Guest等。

虚拟寄存器信息，在VT-x的环境中，这些信息包含在VMCS中。

VCPU状态信息，标识白VCPU当前所处的状态(睡眠、运行等)，主要供调度器使用。

额外的寄存器/部件信息，主要指未包含在VMCS中的寄存器或CPU部件，比如：浮点寄存器和虚拟的LAPIC等。

其他信息：用户VMM进行优化或存储额外信息的字段，如：存放该VCPU私有数据的指针。

当 VMM 创建虚拟机时，首先要为虚拟机创建 VCPU ，整个虚拟机的运行实际上可以看做 VMM 调度不同的 VCPU 运行 。
虚拟机的VCPU通过ioctl VM指令 K VM_CREATE_VCPU实现 ，实质为创建kvm_vcpu结构体，并进行相关初始化。本文简单分析VCPU创建过程，qemu-kvm用户态实现部分暂不包括。

2、基本流程
kvm_vm_ioctl() // kvm ioctl vm指令入口
    kvm_vm_ioctl_create_vcpu() // 为虚拟机创建VCPU的ioctl调用的入口函数
        kvm_arch_vcpu_create() // 创建vcpu结构，架构相关，对于intel x86来说，最终调用vmx_create_vcpu
        kvm_arch_vcpu_setup() // 设置VCPU结构
        create_vcpu_fd() // 为新创建的vcpu创建对应的fd，以便于后续通过该fd进行ioctl操作
        kvm_arch_vcpu_postcreate() // 架构相关的善后工作，比如再次调用vcpu_load，以及tsc相关处理

3、代码分析
kvm_vcpu结构：

点击(此处)折叠或打开

1. struct kvm_vcpu {
   
2.     // 指向此vcpu所属的虚拟机对应的kvm结构
   
3.     struct kvm *kvm;
   
4. #ifdef CONFIG_PREEMPT_NOTIFIERS
   
5.     struct preempt_notifier preempt_notifier;
   
6. #endif
   
7.     int cpu;
   
8.     // vcpu id，用于唯一标识该vcpu
   
9.     int vcpu_id;
   
10.     int srcu_idx;
    
11.     int mode;
    
12.     unsigned long requests;
    
13.     unsigned long guest_debug;
    
14. 
    
15.     struct mutex mutex;
    
16.     // 执行虚拟机对应的kvm_run结构
    
17.     struct kvm_run *run;
    
18. 
    
19.     int fpu_active;
    
20.     int guest_fpu_loaded, guest_xcr0_loaded;
    
21.     wait_queue_head_t wq;
    
22.     struct pid *pid;
    
23.     int sigset_active;
    
24.     sigset_t sigset;
    
25.     // vcpu状态信息
    
26.     struct kvm_vcpu_stat stat;
    
27.     // mmio相关部分
    
28. #ifdef CONFIG_HAS_IOMEM
    
29.     int mmio_needed;
    
30.     int mmio_read_completed;
    
31.     int mmio_is_write;
    
32.     int mmio_cur_fragment;
    
33.     int mmio_nr_fragments;
    
34.     struct kvm_mmio_fragment mmio_fragments[KVM_MAX_MMIO_FRAGMENTS];
    
35. #endif
    
36. 
    
37. #ifdef CONFIG_KVM_ASYNC_PF
    
38.     struct {
    
39.         u32 queued;
    
40.         struct list_head queue;
    
41.         struct list_head done;
    
42.         spinlock_t lock;
    
43.     } async_pf;
    
44. #endif
    
45. 
    
46. #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
    
47.     /*
    
48.      * Cpu relax intercept or pause loop exit optimization
    
49.      * in_spin_loop: set when a vcpu does a pause loop exit
    
50.      * or cpu relax intercepted.
    
51.      * dy_eligible: indicates whether vcpu is eligible for directed yield.
    
52.      */
    
53.     struct {
    
54.         bool in_spin_loop;
    
55.         bool dy_eligible;
    
56.     } spin_loop;
    
57. #endif
    
58.     bool preempted;
    
59.     // 架构相关部分，包括的寄存器、apic、mmu相关等架构相关的内容
    
60.     struct kvm_vcpu_arch arch;
    
61. };

kvm_vm_ioctl()-->kvm_vm_ioctl_create_vcpu():

点击(此处)折叠或打开

1. /*
   
2.   * 为虚拟机创建VCPU的ioctl调用的入口函数，本质为创建vcpu结构并初始化，并将其填入kvm结构中。
   
3.   */
   
4. static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
   
5. {
   
6.     int r;
   
7.     struct kvm_vcpu *vcpu, *v;
   
8. 
   
9.     // 创建vcpu结构，架构相关，对于intel x86来说，最终调用vmx_create_vcpu
   
10.     vcpu = kvm_arch_vcpu_create(kvm, id);
    
11.     if (IS_ERR(vcpu))
    
12.         return PTR_ERR(vcpu);
    
13. 
    
14.     preempt_notifier_init(&vcpu->preempt_notifier, &kvm_preempt_ops);
    
15. 
    
16.     /* 
    
17.      * 设置vcpu结构，主要调用kvm_x86_ops->vcpu_load，KVM虚拟机VCPU数据结构载入物理CPU，
    
18.      * 并进行虚拟机mmu相关设置，比如进行ept页表的相关初始工作或影子页表
    
19.      * 相关的设置。
    
20.      */
    
21.     r = kvm_arch_vcpu_setup(vcpu);
    
22.     if (r)
    
23.         goto vcpu_destroy;
    
24. 
    
25.     mutex_lock(&kvm->lock);
    
26.     if (!kvm_vcpu_compatible(vcpu)) {
    
27.         r = -EINVAL;
    
28.         goto unlock_vcpu_destroy;
    
29.     }
    
30.     if (atomic_read(&kvm->online_vcpus) == KVM_MAX_VCPUS) {
    
31.         r = -EINVAL;
    
32.         goto unlock_vcpu_destroy;
    
33.     }
    
34. 
    
35.     // 检测分配的vcpu id是否已经存在
    
36.     kvm_for_each_vcpu(r, v, kvm)
    
37.         if (v->vcpu_id == id) {
    
38.             r = -EEXIST;
    
39.             goto unlock_vcpu_destroy;
    
40.         }
    
41.     /*
    
42.      * kvm->vcpus[]数组包括该vm的所有vcpu，定义为KVM_MAX_VCPUS大小的数组。
    
43.      * 在kvm结构初始化时，其中所有成员都初始化为0，在vcpu还没有
    
44.      * 分配之前，如果不为0，那就是bug了。
    
45.      */
    
46.     BUG_ON(kvm->vcpus[atomic_read(&kvm->online_vcpus)]);
    
47. 
    
48.     /* Now it's all set up, let userspace reach it */
    
49.     // 增加kvm的引用计数
    
50.     kvm_get_kvm(kvm);
    
51.     // 为新创建的vcpu创建对应的fd，以便于后续通过该fd进行ioctl操作
    
52.     r = create_vcpu_fd(vcpu);
    
53.     if (r < 0) {
    
54.         kvm_put_kvm(kvm);
    
55.         goto unlock_vcpu_destroy;
    
56.     }
    
57. 
    
58.     // 将新创建的vcpu填入kvm->vcpus[]数组中
    
59.     kvm->vcpus[atomic_read(&kvm->online_vcpus)] = vcpu;
    
60.     // 内存屏障，防止同时访问kvm结构时乱序
    
61.     smp_wmb();
    
62.     // 增加online vcpu的数量
    
63.     atomic_inc(&kvm->online_vcpus);
    
64. 
    
65.     mutex_unlock(&kvm->lock);
    
66.     // 架构相关的善后工作，比如再次调用vcpu_load，以及tsc相关处理
    
67.     kvm_arch_vcpu_postcreate(vcpu);
    
68.     return r;
    
69. 
    
70. unlock_vcpu_destroy:
    
71.     mutex_unlock(&kvm->lock);
    
72. vcpu_destroy:
    
73.     kvm_arch_vcpu_destroy(vcpu);
    
74.     return r;
    
75. }

kvm_vm_ioctl()-->kvm_vm_ioctl_create_vcpu()-->kvm_arch_vcpu_create()-->kvm_x86_ops->vcpu_create()-->vmx_create_vcpu():

点击(此处)折叠或打开

1. /*
   
2.   * Intel x86架构中创建并初始化VCPU中架构相关部分
   
3.   */
   
4. static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
   
5. {
   
6.     int err;
   
7.     // 从slab中，分配vcpu_vmx结构体，其中包括VMX技术硬件相关信息。
   
8.     struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
   
9.     int cpu;
   
10. 
    
11.     if (!vmx)
    
12.         return ERR_PTR(-ENOMEM);
    
13.     // 分配vpid，vpid为VCPU的唯一标识。
    
14.     allocate_vpid(vmx);
    
15.     // 初始化vmx中的vcpu结构
    
16.     err = kvm_vcpu_init(&vmx->vcpu, kvm, id);
    
17.     if (err)
    
18.         goto free_vcpu;
    
19.     // 分配Guest的msr寄存器保存区
    
20.     vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
    
21.     err = -ENOMEM;
    
22.     if (!vmx->guest_msrs) {
    
23.         goto uninit_vcpu;
    
24.     }
    
25. 
    
26.     vmx->loaded_vmcs = &vmx->vmcs01;
    
27.     /* 
    
28.      * 分配VMCS结构，该结构用于保存虚拟机和虚拟机监控器的系统编程接口状态。
    
29.      * 当执行VM exit和VM entry操作时，VT-x自动根据VMCS中的内容完成虚拟机和虚拟机监
    
30.      * 控器间的系统编程接口状态切换。
    
31.      */
    
32.     vmx->loaded_vmcs->vmcs = alloc_vmcs();
    
33.     if (!vmx->loaded_vmcs->vmcs)
    
34.         goto free_msrs;
    
35.     // 是否设置了vmm_exclusive
    
36.     if (!vmm_exclusive)
    
37.         // VMXON指令用于开启VMX模式
    
38.         kvm_cpu_vmxon(__pa(per_cpu(vmxarea, raw_smp_processor_id())));
    
39.     loaded_vmcs_init(vmx->loaded_vmcs);
    
40.     if (!vmm_exclusive)
    
41.         // VMXON指令用于关闭VMX模式
    
42.         kvm_cpu_vmxoff();
    
43.     // 当前cpu
    
44.     cpu = get_cpu();
    
45.     // KVM虚拟机VCPU数据结构载入物理CPU
    
46.     vmx_vcpu_load(&vmx->vcpu, cpu);
    
47.     vmx->vcpu.cpu = cpu;
    
48.     // 设置vmx相关信息
    
49.     err = vmx_vcpu_setup(vmx);
    
50.     vmx_vcpu_put(&vmx->vcpu);
    
51.     put_cpu();
    
52.     if (err)
    
53.         goto free_vmcs;
    
54.     if (vm_need_virtualize_apic_accesses(kvm)) {
    
55.         err = alloc_apic_access_page(kvm);
    
56.         if (err)
    
57.             goto free_vmcs;
    
58.     }
    
59.     // 是否支持EPT
    
60.     if (enable_ept) {
    
61.         if (!kvm->arch.ept_identity_map_addr)
    
62.             kvm->arch.ept_identity_map_addr =
    
63.                 VMX_EPT_IDENTITY_PAGETABLE_ADDR;
    
64.         err = -ENOMEM;
    
65.         // 分配identity页表
    
66.         if (alloc_identity_pagetable(kvm) != 0)
    
67.             goto free_vmcs;
    
68.         // 初始化identity页表
    
69.         if (!init_rmode_identity_map(kvm))
    
70.             goto free_vmcs;
    
71.     }
    
72. 
    
73.     vmx->nested.current_vmptr = -1ull;
    
74.     vmx->nested.current_vmcs12 = NULL;
    
75. 
    
76.     return &vmx->vcpu;
    
77. 
    
78. free_vmcs:
    
79.     free_loaded_vmcs(vmx->loaded_vmcs);
    
80. free_msrs:
    
81.     kfree(vmx->guest_msrs);
    
82. uninit_vcpu:
    
83.     kvm_vcpu_uninit(&vmx->vcpu);
    
84. free_vcpu:
    
85.     free_vpid(vmx);
    
86.     kmem_cache_free(kvm_vcpu_cache, vmx);
    
87.     return ERR_PTR(err);
    
88. }

kvm_vm_ioctl()-->kvm_vm_ioctl_create_vcpu()-->kvm_arch_vcpu_setup():

点击(此处)折叠或打开

1. int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
   
2. {
   
3.     int r;
   
4. 
   
5.     vcpu->arch.mtrr_state.have_fixed = 1;
   
6.     // KVM虚拟机VCPU数据结构载入物理CPU
   
7.     r = vcpu_load(vcpu);
   
8.     if (r)
   
9.         return r;
   
10.     // vcpu重置，包括相关寄存器、时钟、pmu等，最终调用vmx_vcpu_reset
    
11.     kvm_vcpu_reset(vcpu);
    
12.     /*
    
13.      * 进行虚拟机mmu相关设置，比如进行ept页表的相关初始工作或影子页表
    
14.      * 相关的设置。
    
15.      */
    
16.     r = kvm_mmu_setup(vcpu);
    
17.     vcpu_put(vcpu);
    
18. 
    
19.     return r;
    
20. }

kvm_vm_ioctl()-->kvm_vm_ioctl_create_vcpu()-->kvm_arch_vcpu_setup()-->kvm_mmu_setup()-->init_kvm_mmu():

点击(此处)折叠或打开

1. static int init_kvm_mmu(struct kvm_vcpu *vcpu)
   
2. {
   
3.     // NPT(Nested page table，AMD x86硬件提供的内存虚拟化技术，相当于Intel中的EPT技术)相关初始化
   
4.     if (mmu_is_nested(vcpu))
   
5.         return init_kvm_nested_mmu(vcpu);
   
6.     /* 
   
7.      * EPT(Extended page table，Intel x86硬件提供的内存虚拟化技术)相关初始化
   
8.      * 主要是设置一些函数指针，其中比较重要的如缺页异常处理函数
   
9.      */
   
10.     else if (tdp_enabled)
    
11.         return init_kvm_tdp_mmu(vcpu);
    
12.     // 影子页表(软件实现内存虚拟化技术)相关初始化
    
13.     else
    
14.         return init_kvm_softmmu(vcpu);
    
15. }