virt/kvm/kvm_main.c: 
    static int kvm_dev_ioctl_create_vm(void)
    {
    	int fd;
    	struct kvm *kvm;
    
    	 kvm = kvm_create_vm(type);
    	 if (IS_ERR(kvm))
    	         return PTR_ERR(kvm);
    
    	 r = kvm_coalesced_mmio_init(kvm);
    
    	 r = get_unused_fd_flags(O_CLOEXEC);
    
             /*生成kvm-vm控制文件*/
    	 file = anon_inode_getfile("kvm-vm", &kvm_vm_fops, kvm, O_RDWR);
    
    	return fd;
    }

virt/kvm/kvm_main.c:
    static struct kvm *kvm_create_vm(void)
    {
    	int r, i;
        struct kvm *kvm = kvm_arch_create_vm();
    
        /*设置kvm的mm结构为当前进程的mm,然后引用计数为1*/
        kvm->mm = current->mm;
        kvm_eventfd_init(kvm);
    	mutex_init(&kvm->lock);
    	mutex_init(&kvm->irq_lock);
    	mutex_init(&kvm->slots_lock);
    	refcount_set(&kvm->users_count, 1);
    	INIT_LIST_HEAD(&kvm->devices);
    	INIT_HLIST_HEAD(&kvm->irq_ack_notifier_list);
    
    	r = kvm_arch_init_vm(kvm, type);
    
    	r = hardware_enable_all()
    
    	for (i = 0; i < KVM_NR_BUSES; i++) {
    		rcu_assign_pointer(kvm->buses[i],
    	kzalloc(sizeof(struct kvm_io_bus), GFP_KERNEL));
    	}
    	kvm_init_mmu_notifier(kvm); 
    
        /*把kvm链表加入总链表*/
    	list_add(&kvm->vm_list, &vm_list);
    
    	return kvm;
    }

virt/kvm/kvm_main.c:
    static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
    {
    	int r;
    	struct kvm_vcpu *vcpu, *v;
        /*调用相关cpu的vcpu_create 通过arch/x86/x86.c 进入vmx.c*/
        vcpu = kvm_arch_vcpu_create(kvm, id);
    
        /*调用相关cpu的vcpu_setup*/
    	r = kvm_arch_vcpu_setup(vcpu);
    
        /*判断是否达到最大cpu个数*/
    	mutex_lock(&kvm->lock);
    	if (atomic_read(&kvm->online_vcpus) == KVM_MAX_VCPUS) {
    		r = -EINVAL;
    		goto vcpu_destroy;
    	}
        kvm->created_vcpus++;    
    	mutex_unlock(&kvm->lock);
    
        /*生成kvm-vcpu控制文件*/
    	/* Now it's all set up, let userspace reach it */
        kvm_get_kvm(kvm);
    	r = create_vcpu_fd(vcpu);
    
            kvm_get_kvm(kvm);
            r = create_vcpu_fd(vcpu);
            if (r < 0) {
                    kvm_put_kvm(kvm);
                    goto unlock_vcpu_destroy;
            }
    
            kvm->vcpus[atomic_read(&kvm->online_vcpus)] = vcpu;
    
            /*
             * Pairs with smp_rmb() in kvm_get_vcpu.  Write kvm->vcpus
             * before kvm->online_vcpu's incremented value.
             */
            smp_wmb();
            atomic_inc(&kvm->online_vcpus);
    
            mutex_unlock(&kvm->lock);
            kvm_arch_vcpu_postcreate(vcpu);
    
    }

arch/x86/kvm/x86.c:
    static int vcpu_run(struct kvm_vcpu *vcpu)
    {
            int r;
            struct kvm *kvm = vcpu->kvm;
            for (;;) {
    		/*vcpu进入guest模式*/ 
                    if (kvm_vcpu_running(vcpu)) {
                       r = vcpu_enter_guest(vcpu);
                    } else {
                            r = vcpu_block(kvm, vcpu);
                    }
                    kvm_clear_request(KVM_REQ_PENDING_TIMER, vcpu);
    
    		/*检查是否有阻塞的时钟timer*/
                    if (kvm_cpu_has_pending_timer(vcpu))
                            kvm_inject_pending_timer_irqs(vcpu);
    
    		/*检查是否有用户空间的中断注入*/ 
                    if (dm_request_for_irq_injection(vcpu) &&
                            kvm_vcpu_ready_for_interrupt_injection(vcpu)) {
                            r = 0;
                            vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
                            ++vcpu->stat.request_irq_exits;
                            break;
                    }
                    kvm_check_async_pf_completion(vcpu);
    
    		/*是否有阻塞的signal*/
                    if (signal_pending(current)) {
                            r = -EINTR;
                            vcpu->run->exit_reason = KVM_EXIT_INTR;
                            ++vcpu->stat.signal_exits;
                            break;
                    }
    		/*执行一个调度*/
                     if (need_resched()) {
                             cond_resched();
                     }
             }

arch/x86/kvm/mmu/mmu.c
    void kvm_init_mmu(struct kvm_vcpu *vcpu, bool reset_roots)
    {
    	......
    	/*嵌套虚拟化，我们暂不考虑了 */
            if (mmu_is_nested(vcpu))
                    init_kvm_nested_mmu(vcpu);
            else if (tdp_enabled)
                    init_kvm_tdp_mmu(vcpu);
            else
                    init_kvm_softmmu(vcpu);
    }

arch/x86/kvm/vmx.c:
    static int handle_io(struct kvm_vcpu *vcpu)
    {
            unsigned long exit_qualification;
            int size, in, string;
            unsigned port;
    
            exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
            string = (exit_qualification & 16) != 0;
    
            ++vcpu->stat.io_exits;
    
            if (string)
                    return kvm_emulate_instruction(vcpu, 0) == EMULATE_DONE;
    
            port = exit_qualification >> 16;
            size = (exit_qualification & 7) + 1;
            in = (exit_qualification & 8) != 0;
    
            return kvm_fast_pio(vcpu, size, port, in);
    }