Linux KVM x86 CPU虚拟化原理及源代码分析

struct kvm {
	spinlock_t mmu_lock;
	struct mutex slots_lock;
	struct mm_struct *mm; /* userspace tied to this vm */
	struct kvm_memslots *memslots[KVM_ADDRESS_SPACE_NUM]; /* KVM虚拟机分配的内存slot，用于记录GPA-HVA的映射，内存虚拟化使用 */
	struct srcu_struct srcu;
	struct srcu_struct irq_srcu;
	struct kvm_vcpu *vcpus[KVM_MAX_VCPUS]; /* KVM虚拟机中包含的vCPU结构体，一个虚拟机CPU对应一个vCPU结构体 */
	atomic_t online_vcpus;
	int last_boosted_vcpu;
	struct list_head vm_list; /* HOST上VM管理链表，multiple "KVM structs"的双向链表 */
	struct mutex lock;
	struct kvm_io_bus *buses[KVM_NR_BUSES]; /* KVM虚拟机中的I/O总线，一条总线对应一个kvm_io_bus结构体，如ISA总线、PCI总线 */
	struct kvm_vm_stat stat; /* KVM虚拟机中的页表、MMU等运行时的状态信息 */
	struct kvm_arch arch; /* 这个是host的arch的一些参数 */
	atomic_t users_count;
	struct mutex irq_lock;
	long tlbs_dirty;
	struct list_head devices;
  ...
};

struct kvm_vcpu {
	struct kvm *kvm; /* 这个CPU所属的KVM */
	int cpu;
	int vcpu_id; /* 对应的CPU的ID，由用户进程指定*/
	int srcu_idx;
	int mode;
	unsigned long requests;
	unsigned long guest_debug;
	struct mutex mutex;
	struct kvm_run *run;  /* CPU运行时的状态，其中保存了内存信息、虚拟机状态等各种动态信息，如VM-Exit发生的原因等 */
	int fpu_active;
	int guest_fpu_loaded, guest_xcr0_loaded;
	unsigned char fpu_counter;
	wait_queue_head_t wq;
	struct pid *pid;
	int sigset_active;
	sigset_t sigset;
	struct kvm_vcpu_stat stat;
	bool preempted;
	struct kvm_vcpu_arch arch; // 当前VCPU虚拟的架构，存储有KVM虚拟机的运行时参数，如定时器、中断、内存槽等方面的信息
	...
};

ioctl(KVM_CREATE_VM..)
  -->kvm_dev_ioctl  // /dev/kvm设备的ioctl接口的处理函数，用于分发不同的ioctl
      --> kvm_dev_ioctl_create_vm  // 调用kvm_create_vm，并生成kvm-vm的控制文件，用于vm的ioctl
        -->kvm_create_vm

// virt/kvm/kvm_main.c: (有所省略)
static int kvm_dev_ioctl_create_vm(void)
{
	int fd;
	struct kvm *kvm;

  kvm = kvm_create_vm(type); 	/*创建VM*/
  if (IS_ERR(kvm))
         return PTR_ERR(kvm);
  r = kvm_coalesced_mmio_init(kvm);
  r = get_unused_fd_flags(O_CLOEXEC);
  /*生成kvm-vm控制文件，这个文件的作用是提供对vm的io_ctl控制*/
  file = anon_inode_getfile("kvm-vm", &kvm_vm_fops, kvm, O_RDWR);
  ...
  fd_install(fd, file);
	return fd;
}

// virt/kvm/kvm_main.c
static struct kvm *kvm_create_vm(unsigned long type)
{
	int r, i;
	struct kvm *kvm = kvm_arch_alloc_vm(); // 申请kvm结构体内存
  ...
  // 调用架构相关的初始化函数，初始化虚拟机
  // 这部分主要是初始化KVM中类型为kvm_arch的arch成员，用于存放与架构相关的数据
	r = kvm_arch_init_vm(kvm, type); 
	...
  // 启用硬件虚拟化支持，主要设置相关寄存器和标记，使CPU进入虚拟化相关模式中
	r = hardware_enable_all(); 
	...
	r = -ENOMEM;
  // 初始化memslots结构体信息
	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
		kvm->memslots[i] = kvm_alloc_memslots();
		if (!kvm->memslots[i])
			goto out_err_no_srcu;
	}

	...
  // 初始化BUS总线结构体信息
	for (i = 0; i < KVM_NR_BUSES; i++) {
		kvm->buses[i] = kzalloc(sizeof(struct kvm_io_bus),
					GFP_KERNEL);
		if (!kvm->buses[i])
			goto out_err;
	}
	
  // 由于虚拟机的内存其实也就是QEMU进程的虚拟内存，因此这里需要引用到当前QEMU进程的mm_struct
  // 并且初始化mmu_lock成员来表示操作虚拟机MMU数据的锁
	spin_lock_init(&kvm->mmu_lock);
	kvm->mm = current->mm;
	atomic_inc(&kvm->mm->mm_count);
  
  // 初始化事件通知信息
	kvm_eventfd_init(kvm);
	mutex_init(&kvm->lock);
	mutex_init(&kvm->irq_lock);
	mutex_init(&kvm->slots_lock);
	atomic_set(&kvm->users_count, 1);
	INIT_LIST_HEAD(&kvm->devices);
	
  // 初始化内存管理单元（MMU）通知器，用于跟踪内存的变化
	r = kvm_init_mmu_notifier(kvm);
	...
	
  // 将创建的虚拟机添加到虚拟机列表vm_list中
	spin_lock(&kvm_lock);
	list_add(&kvm->vm_list, &vm_list);
	spin_unlock(&kvm_lock);

	preempt_notifier_inc();
	return kvm;

out_err:
...
	return ERR_PTR(r);
}

ioctl(KVM_CREATE_VCPU..)
  -->kvm_vm_ioctl  // kvm-vm匿名设备的ioctl接口的处理函数，用于分发不同的ioctl
      --> kvm_vm_ioctl_create_vcpu  // 进行一些错误判断、vcpu_fd创建，调用创建/初始化vCPU的函数
  			--> kvm_arch_vcpu_create & kvm_arch_vcpu_setup // 创建vCPU的主体函数

// 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个数 */
	if (id >= KVM_MAX_VCPUS)
		return -EINVAL;
	/* 调用相关cpu的vcpu_create 通过arch/x86/x86.c 进入vmx.c */
  /* 创建kvm_vcpu结构体，具体实现跟架构相关，直接调用kvm_x86_ops中的create_cpu方法执行，主要完成相关寄存器和CPUID的初始化 */
	vcpu = kvm_arch_vcpu_create(kvm, id);
	if (IS_ERR(vcpu))
		return PTR_ERR(vcpu);

	preempt_notifier_init(&vcpu->preempt_notifier, &kvm_preempt_ops);
	/* 调用相关cpu的vcpu_setup，初始化kvm_vcpu结构体 */
	r = kvm_arch_vcpu_setup(vcpu);
	if (r)
		goto vcpu_destroy;
  

	mutex_lock(&kvm->lock);
	if (!kvm_vcpu_compatible(vcpu)) {
		r = -EINVAL;
		goto unlock_vcpu_destroy;
	}
  /* 判断是否达到最大cpu个数，如果是，则销毁刚创建的实例 */
	if (atomic_read(&kvm->online_vcpus) == KVM_MAX_VCPUS) {
		r = -EINVAL;
		goto unlock_vcpu_destroy;
	}
	/* 判断当前VCPU是否已经加入了某个KVM主机，如果是，则销毁刚创建的实例 */
	kvm_for_each_vcpu(r, v, kvm)
		if (v->vcpu_id == id) {
			r = -EEXIST;
			goto unlock_vcpu_destroy;
		}

	BUG_ON(kvm->vcpus[atomic_read(&kvm->online_vcpus)]);

	/* Now it's all set up, let userspace reach it */
  /* 生成kvm-vcpu控制文件，创建vcpu_fd */
	kvm_get_kvm(kvm);
	r = create_vcpu_fd(vcpu);
	if (r < 0) {
		kvm_put_kvm(kvm);
		goto unlock_vcpu_destroy;
	}
	// 将创建的kvm_vcpu结构体加入kvm的VCPU数组中
	kvm->vcpus[atomic_read(&kvm->online_vcpus)] = vcpu;
	smp_wmb();
	atomic_inc(&kvm->online_vcpus); // 增加online vcpu数量

	mutex_unlock(&kvm->lock);
	kvm_arch_vcpu_postcreate(vcpu);
	return r;
	...
}

ioctl(KVM_RUN..)
  -->kvm_vcpu_ioctl  // kvm-vm匿名设备的ioctl接口的处理函数，用于分发不同的ioctl
      --> kvm_arch_vcpu_ioctl_run  
  			--> vcpu_run // 运行vCPU的主体函数
  				--> vcpu_enter_guest
  					--> kvm_x86_ops->run / vmx_vcpu_run

static int vcpu_run(struct kvm_vcpu *vcpu)
{
	int r;
	struct kvm *kvm = vcpu->kvm;

	vcpu->srcu_idx = srcu_read_lock(&kvm->srcu);

	for (;;) {
    /* 通过vcpu_enter_guest进入guest模式 */ 
		if (kvm_vcpu_running(vcpu))
			r = vcpu_enter_guest(vcpu);
		else
			r = vcpu_block(kvm, vcpu);
		if (r <= 0)
			break;
    // 以下是vmexit后的一些处理函数
		/* 检查是否有阻塞的时钟timer */
		clear_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests);
		if (kvm_cpu_has_pending_timer(vcpu))
			kvm_inject_pending_timer_irqs(vcpu);
		/* 检查是否有用户空间的中断注入 */ 
		if (dm_request_for_irq_injection(vcpu)) {
			r = -EINTR;
			vcpu->run->exit_reason = KVM_EXIT_INTR;
			++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()) {
			srcu_read_unlock(&kvm->srcu, vcpu->srcu_idx);
			cond_resched();
			vcpu->srcu_idx = srcu_read_lock(&kvm->srcu);
		}
	}

	srcu_read_unlock(&kvm->srcu, vcpu->srcu_idx);
	return r;
}