KVM 虚拟化原理探究— overview

标签(空格分隔): KVM


写在前面的话

本文不介绍kvm和qemu的基本安装操作,希望读者具有一定的KVM实践经验。同时希望借此系列博客,能够对KVM底层有一些清晰直观的认识,当然我没有通读KVM的源码,文中的内容一部分来自于书籍和资料,一部分来自于实践,还有一些来自于自己的理解,肯定会有一些理解的偏差,欢迎讨论并指正。本系列文章敬代表我个人观点和实践,不代表公司层面。

KVM虚拟化简介

KVM 全称 kernel-based virtual machine,由Qumranet公司发起,2008年被RedHat收购。
KVM实现主要基于Intel-V或者AMD-V提供的虚拟化平台,利用普通的Linux进程运行于虚拟态的指令集,模拟虚拟机监视器和CPU。KVM不提供硬件虚拟化操作,其IO操作等都借助QEMU来完成。

KVM有如下特点:

  • guest作为一个普通进程运行于宿主机
  • guest的CPU(vCPU)作为进程的线程存在,并受到宿主机内核的调度
  • guest继承了宿主机内核的一些属性,比如huge pages(大页表)
  • guest的磁盘IO和网络IO会受到宿主机的设置的影响
  • guest通过宿主机上的虚拟网桥与外部相连

KVM整体架构

每一个虚拟机(guest)在Host上都被模拟为一个QEMU进程,即emulation进程。
我们创建一个虚拟机后,用普通的ps 命令就可以查看到。

➜  ~ virsh list --allId    Name                           State
----------------------------------------------------1     kvm-01                         running➜  ~ ps aux | grep qemu
libvirt+ 20308 15.1  7.5 5023928 595884 ?      Sl   17:29   0:10 /usr/bin/qemu-system-x86_64 -name kvm-01 -S -machine pc-i440fx-wily,accel=kvm,usb=off -m 2048 -realtime mlock=off -smp 2 qemu ....

可以看到,此虚拟机就是一个普通的Linux进程,他有自己的pid。并且有四个线程,线程数量不是固定的,但是至少会有三个(vCPU,IO,Signal)。其中有两个是vCPU线程,有一个IO线程还有一个信号处理线程。

➜  ~ pstree -p 20308
qemu-system-x86(20308)-+-{qemu-system-x86}(20353)|-{qemu-system-x86}(20408)|-{qemu-system-x86}(20409)|-{qemu-system-x86}(20412)

虚拟CPU

guest的所有用户级别(user)的指令集,都会直接由宿主机线程执行,此线程会调用KVM的ioctl方式提供的接口加载guest的指令并在特殊的CPU模式下运行,不需要经过CPU指令集的软件模拟转换,大大的减少了虚拟化成本,这也是KVM优于其他虚拟化方式的点之一。

KVM向外提供了一个虚拟设备/dev/kvm,通过ioctl(IO设备带外管理接口)来对KVM进行操作,包括虚拟机的初始化,分配内存,指令加载等等。

虚拟IO设备

guest作为一个进程存在,当然他的内核的所有驱动等都存在,只是硬件被QEMU所模拟(后面介绍virtio的时候特殊)。guest的所有硬件操作都会有QEMU来接管,QEMU负责与真实的宿主机硬件打交道。

虚拟内存

guest的内存在host上由emulator提供,对emulator来说,guest访问的内存就是他的虚拟地址空间,guest上需要经过一次虚拟地址到物理地址的转换,转换到guest的物理地址其实也就是emulator的虚拟地址,emulator再次经过一次转换,转换为host的物理地址。后面会有介绍各种虚拟化的优化手段,这里只是做一个overview。

虚拟机启动过程

第一步,获取到kvm句柄
kvmfd = open("/dev/kvm", O_RDWR);
第二步,创建虚拟机,获取到虚拟机句柄。
vmfd = ioctl(kvmfd, KVM_CREATE_VM, 0);
第三步,为虚拟机映射内存,还有其他的PCI,信号处理的初始化。
ioctl(kvmfd, KVM_SET_USER_MEMORY_REGION, &mem);
第四步,将虚拟机镜像映射到内存,相当于物理机的boot过程,把镜像映射到内存。
第五步,创建vCPU,并为vCPU分配内存空间。
ioctl(kvmfd, KVM_CREATE_VCPU, vcpuid);
vcpu->kvm_run_mmap_size = ioctl(kvm->dev_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
第五步,创建vCPU个数的线程并运行虚拟机。
ioctl(kvm->vcpus->vcpu_fd, KVM_RUN, 0);
第六步,线程进入循环,并捕获虚拟机退出原因,做相应的处理。
这里的退出并不一定是虚拟机关机,虚拟机如果遇到IO操作,访问硬件设备,缺页中断等都会退出执行,退出执行可以理解为将CPU执行上下文返回到QEMU。
open("/dev/kvm")
ioctl(KVM_CREATE_VM)
ioctl(KVM_CREATE_VCPU)
for (;;) {ioctl(KVM_RUN)switch (exit_reason) {case KVM_EXIT_IO:  /* ... */case KVM_EXIT_HLT: /* ... */}
}

关于KVM_CREATE_VM参数的描述,创建的VM是没有cpu和内存的,需要QEMU进程利用mmap系统调用映射一块内存给VM的描述符,其实也就是给VM创建内存的过程。

KVM ioctl接口文档

先来一个KVM API开胃菜

下面是一个KVM的简单demo,其目的在于加载 code 并使用KVM运行起来.
这是一个at&t的8086汇编,.code16表示他是一个16位的,当然直接运行是运行不起来的,为了让他运行起来,我们可以用KVM提供的API,将这个程序看做一个最简单的操作系统,让其运行起来。
这个汇编的作用是输出al寄存器的值到0x3f8端口。对于x86架构来说,通过IN/OUT指令访问。PC架构一共有65536个8bit的I/O端口,组成64KI/O地址空间,编号从0~0xFFFF。连续两个8bit的端口可以组成一个16bit的端口,连续4个组成一个32bit的端口。I/O地址空间和CPU的物理地址空间是两个不同的概念,例如I/O地址空间为64K,一个32bit的CPU物理地址空间是4G。
最终程序理想的输出应该是,al,bl的值后面KVM初始化的时候有赋值。
4\n (并不直接输出\n,而是换了一行),hlt 指令表示虚拟机退出

.globl _start.code16
_start:mov $0x3f8, %dxadd %bl, %aladd $'0', %alout %al, (%dx)mov $'\n', %alout %al, (%dx)hlt

我们编译一下这个汇编,得到一个 Bin.bin 的二进制文件

as -32 bin.S -o bin.o
ld -m elf_i386 --oformat binary -N -e _start -Ttext 0x10000 -o Bin.bin bin.o

查看一下二进制格式

➜  demo1 hexdump -C bin.bin
00000000  ba f8 03 00 d8 04 30 ee  b0 0a ee f4              |......0.....|
0000000c
对应了下面的code数组,这样直接加载字节码就不需要再从文件加载了const uint8_t code[] = {0xba, 0xf8, 0x03, /* mov $0x3f8, %dx */0x00, 0xd8,       /* add %bl, %al */0x04, '0',        /* add $'0', %al */0xee,             /* out %al, (%dx) */0xb0, '\n',       /* mov $'\n', %al */0xee,             /* out %al, (%dx) */0xf4,             /* hlt */};
#include <err.h>
#include <fcntl.h>
#include <linux/kvm.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>int main(void)
{int kvm, vmfd, vcpufd, ret;const uint8_t code[] = {0xba, 0xf8, 0x03, /* mov $0x3f8, %dx */0x00, 0xd8,       /* add %bl, %al */0x04, '0',        /* add $'0', %al */0xee,             /* out %al, (%dx) */0xb0, '\n',       /* mov $'\n', %al */0xee,             /* out %al, (%dx) */0xf4,             /* hlt */};uint8_t *mem;struct kvm_sregs sregs;size_t mmap_size;struct kvm_run *run;// 获取 kvm 句柄kvm = open("/dev/kvm", O_RDWR | O_CLOEXEC);if (kvm == -1)err(1, "/dev/kvm");// 确保是正确的 API 版本ret = ioctl(kvm, KVM_GET_API_VERSION, NULL);if (ret == -1)err(1, "KVM_GET_API_VERSION");if (ret != 12)errx(1, "KVM_GET_API_VERSION %d, expected 12", ret);// 创建一虚拟机vmfd = ioctl(kvm, KVM_CREATE_VM, (unsigned long)0);if (vmfd == -1)err(1, "KVM_CREATE_VM");// 为这个虚拟机申请内存,并将代码(镜像)加载到虚拟机内存中mem = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);if (!mem)err(1, "allocating guest memory");memcpy(mem, code, sizeof(code));// 为什么从 0x1000 开始呢,因为页表空间的前4K是留给页表目录struct kvm_userspace_memory_region region = {.slot = 0,.guest_phys_addr = 0x1000,.memory_size = 0x1000,.userspace_addr = (uint64_t)mem,};// 设置 KVM 的内存区域ret = ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, &region);if (ret == -1)err(1, "KVM_SET_USER_MEMORY_REGION");// 创建虚拟CPUvcpufd = ioctl(vmfd, KVM_CREATE_VCPU, (unsigned long)0);if (vcpufd == -1)err(1, "KVM_CREATE_VCPU");// 获取 KVM 运行时结构的大小ret = ioctl(kvm, KVM_GET_VCPU_MMAP_SIZE, NULL);if (ret == -1)err(1, "KVM_GET_VCPU_MMAP_SIZE");mmap_size = ret;if (mmap_size < sizeof(*run))errx(1, "KVM_GET_VCPU_MMAP_SIZE unexpectedly small");// 将 kvm run 与 vcpu 做关联,这样能够获取到kvm的运行时信息run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpufd, 0);if (!run)err(1, "mmap vcpu");// 获取特殊寄存器ret = ioctl(vcpufd, KVM_GET_SREGS, &sregs);if (ret == -1)err(1, "KVM_GET_SREGS");// 设置代码段为从地址0处开始,我们的代码被加载到了0x0000的起始位置sregs.cs.base = 0;sregs.cs.selector = 0;// KVM_SET_SREGS 设置特殊寄存器ret = ioctl(vcpufd, KVM_SET_SREGS, &sregs);if (ret == -1)err(1, "KVM_SET_SREGS");// 设置代码的入口地址,相当于32位main函数的地址,这里16位汇编都是由0x1000处开始。// 如果是正式的镜像,那么rip的值应该是类似引导扇区加载进来的指令struct kvm_regs regs = {.rip = 0x1000,.rax = 2,    // 设置 ax 寄存器初始值为 2.rbx = 2,    // 同理.rflags = 0x2,   // 初始化flags寄存器,x86架构下需要设置,否则会粗错};ret = ioctl(vcpufd, KVM_SET_REGS, &regs);if (ret == -1)err(1, "KVM_SET_REGS");// 开始运行虚拟机,如果是qemu-kvm,会用一个线程来执行这个vCPU,并加载指令while (1) {// 开始运行虚拟机ret = ioctl(vcpufd, KVM_RUN, NULL);if (ret == -1)err(1, "KVM_RUN");// 获取虚拟机退出原因switch (run->exit_reason) {case KVM_EXIT_HLT:puts("KVM_EXIT_HLT");return 0;// 汇编调用了 out 指令,vmx 模式下不允许执行这个操作,所以// 将操作权切换到了宿主机,切换的时候会将上下文保存到VMCS寄存器// 后面CPU虚拟化会讲到这部分// 因为虚拟机的内存宿主机能够直接读取到,所以直接在宿主机上获取到// 虚拟机的输出(out指令),这也是后面PCI设备虚拟化的一个基础,DMA模式的PCI设备case KVM_EXIT_IO:if (run->io.direction == KVM_EXIT_IO_OUT && run->io.size == 1 && run->io.port == 0x3f8 && run->io.count == 1)putchar(*(((char *)run) + run->io.data_offset));elseerrx(1, "unhandled KVM_EXIT_IO");break;case KVM_EXIT_FAIL_ENTRY:errx(1, "KVM_EXIT_FAIL_ENTRY: hardware_entry_failure_reason = 0x%llx",(unsigned long long)run->fail_entry.hardware_entry_failure_reason);case KVM_EXIT_INTERNAL_ERROR:errx(1, "KVM_EXIT_INTERNAL_ERROR: suberror = 0x%x", run->internal.suberror);default:errx(1, "exit_reason = 0x%x", run->exit_reason);}}
}

编译并运行这个demo

gcc -g demo.c -o demo
➜  demo1 ./demo
4
KVM_EXIT_HLT

另外一个简单的QEMU emulator demo

IBM的徐同学有做过介绍,在此基础上我再详细介绍一下qemu-kvm的启动过程。

.globl _start.code16
_start:xorw %ax, %ax   # 将 ax 寄存器清零loop1:out %ax, $0x10  # 像 0x10 的端口输出 ax 的内容,at&t汇编的操作数和Intel的相反。inc %ax         # ax 值加一jmp loop1       # 继续循环

这个汇编的作用就是一直不停的向0x10端口输出一字节的值。

从main函数开始说起

int main(int argc, char **argv) {int ret = 0;// 初始化kvm结构体struct kvm *kvm = kvm_init();if (kvm == NULL) {fprintf(stderr, "kvm init fauilt\n");return -1;}// 创建VM,并分配内存空间if (kvm_create_vm(kvm, RAM_SIZE) < 0) {fprintf(stderr, "create vm fault\n");return -1;}// 加载镜像load_binary(kvm);// only support one vcpu nowkvm->vcpu_number = 1;// 创建执行现场kvm->vcpus = kvm_init_vcpu(kvm, 0, kvm_cpu_thread);// 启动虚拟机kvm_run_vm(kvm);kvm_clean_vm(kvm);kvm_clean_vcpu(kvm->vcpus);kvm_clean(kvm);
}

第一步,调用kvm_init() 初始化了 kvm 结构体。先来看看怎么定义一个简单的kvm。

struct kvm {int dev_fd;              // /dev/kvm 的句柄int vm_fd;               // GUEST 的句柄__u64 ram_size;          // GUEST 的内存大小__u64 ram_start;         // GUEST 的内存起始地址,// 这个地址是qemu emulator通过mmap映射的地址int kvm_version;         struct kvm_userspace_memory_region mem; // slot 内存结构,由用户空间填充、// 允许对guest的地址做分段。将多个slot组成线性地址struct vcpu *vcpus;      // vcpu 数组int vcpu_number;         // vcpu 个数
};

初始化 kvm 结构体。

struct kvm *kvm_init(void) {struct kvm *kvm = malloc(sizeof(struct kvm));kvm->dev_fd = open(KVM_DEVICE, O_RDWR);  // 打开 /dev/kvm 获取 kvm 句柄if (kvm->dev_fd < 0) {perror("open kvm device fault: ");return NULL;}kvm->kvm_version = ioctl(kvm->dev_fd, KVM_GET_API_VERSION, 0);  // 获取 kvm API 版本return kvm;
}

第二步+第三步,创建虚拟机,获取到虚拟机句柄,并为其分配内存。

int kvm_create_vm(struct kvm *kvm, int ram_size) {int ret = 0;// 调用 KVM_CREATE_KVM 接口获取 vm 句柄kvm->vm_fd = ioctl(kvm->dev_fd, KVM_CREATE_VM, 0);if (kvm->vm_fd < 0) {perror("can not create vm");return -1;}// 为 kvm 分配内存。通过系统调用.kvm->ram_size = ram_size;kvm->ram_start =  (__u64)mmap(NULL, kvm->ram_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);if ((void *)kvm->ram_start == MAP_FAILED) {perror("can not mmap ram");return -1;}// kvm->mem 结构需要初始化后传递给 KVM_SET_USER_MEMORY_REGION 接口// 只有一个内存槽kvm->mem.slot = 0;// guest 物理内存起始地址kvm->mem.guest_phys_addr = 0;// 虚拟机内存大小kvm->mem.memory_size = kvm->ram_size;// 虚拟机内存在host上的用户空间地址,这里就是绑定内存给guestkvm->mem.userspace_addr = kvm->ram_start;// 调用 KVM_SET_USER_MEMORY_REGION 为虚拟机分配内存。ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &(kvm->mem));if (ret < 0) {perror("can not set user memory region");return ret;}return ret;
}

接下来就是load_binary把二进制文件load到虚拟机的内存中来,在第一个demo中我们是直接把字节码放到了内存中,这里模拟镜像加载步骤,把二进制文件加载到内存中。

void load_binary(struct kvm *kvm) {int fd = open(BINARY_FILE, O_RDONLY);  // 打开这个二进制文件(镜像)if (fd < 0) {fprintf(stderr, "can not open binary file\n");exit(1);}int ret = 0;char *p = (char *)kvm->ram_start;while(1) {ret = read(fd, p, 4096);           // 将镜像内容加载到虚拟机的内存中if (ret <= 0) {break;}printf("read size: %d", ret);p += ret;}
}

加载完镜像后,需要初始化vCPU,以便能够运行镜像内容

struct vcpu {int vcpu_id;                 // vCPU id,vCPUint vcpu_fd;                 // vCPU 句柄pthread_t vcpu_thread;       // vCPU 线程句柄struct kvm_run *kvm_run;     // KVM 运行时结构,也可以看做是上下文int kvm_run_mmap_size;       // 运行时结构大小struct kvm_regs regs;        // vCPU的寄存器struct kvm_sregs sregs;      // vCPU的特殊寄存器void *(*vcpu_thread_func)(void *);  // 线程执行函数
};struct vcpu *kvm_init_vcpu(struct kvm *kvm, int vcpu_id, void *(*fn)(void *)) {// 申请vcpu结构struct vcpu *vcpu = malloc(sizeof(struct vcpu));// 只有一个 vCPU,所以这里只初始化一个vcpu->vcpu_id = 0;// 调用 KVM_CREATE_VCPU 获取 vCPU 句柄,并关联到kvm->vm_fd(由KVM_CREATE_VM返回)vcpu->vcpu_fd = ioctl(kvm->vm_fd, KVM_CREATE_VCPU, vcpu->vcpu_id);if (vcpu->vcpu_fd < 0) {perror("can not create vcpu");return NULL;}// 获取KVM运行时结构大小vcpu->kvm_run_mmap_size = ioctl(kvm->dev_fd, KVM_GET_VCPU_MMAP_SIZE, 0);if (vcpu->kvm_run_mmap_size < 0) {perror("can not get vcpu mmsize");return NULL;}printf("%d\n", vcpu->kvm_run_mmap_size);// 将 vcpu_fd 的内存映射给 vcpu->kvm_run结构。相当于一个关联操作// 以便能够在虚拟机退出的时候获取到vCPU的返回值等信息vcpu->kvm_run = mmap(NULL, vcpu->kvm_run_mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpu->vcpu_fd, 0);if (vcpu->kvm_run == MAP_FAILED) {perror("can not mmap kvm_run");return NULL;}// 设置线程执行函数vcpu->vcpu_thread_func = fn;return vcpu;
}

最后一步,以上工作就绪后,启动虚拟机。

void kvm_run_vm(struct kvm *kvm) {int i = 0;for (i = 0; i < kvm->vcpu_number; i++) {// 启动线程执行 vcpu_thread_func 并将 kvm 结构作为参数传递给线程if (pthread_create(&(kvm->vcpus->vcpu_thread), (const pthread_attr_t *)NULL, kvm->vcpus[i].vcpu_thread_func, kvm) != 0) {perror("can not create kvm thread");exit(1);}}pthread_join(kvm->vcpus->vcpu_thread, NULL);
}

启动虚拟机其实就是创建线程,并执行相应的线程回调函数。
线程回调函数在kvm_init_vcpu的时候传入

void *kvm_cpu_thread(void *data) {// 获取参数struct kvm *kvm = (struct kvm *)data;int ret = 0;// 设置KVM的参数kvm_reset_vcpu(kvm->vcpus);while (1) {printf("KVM start run\n");// 启动虚拟机,此时的虚拟机已经有内存和CPU了,可以运行起来了。ret = ioctl(kvm->vcpus->vcpu_fd, KVM_RUN, 0);if (ret < 0) {fprintf(stderr, "KVM_RUN failed\n");exit(1);}// 前文 kvm_init_vcpu 函数中,将 kvm_run 关联了 vCPU 结构的内存// 所以这里虚拟机退出的时候,可以获取到 exit_reason,虚拟机退出原因switch (kvm->vcpus->kvm_run->exit_reason) {case KVM_EXIT_UNKNOWN:printf("KVM_EXIT_UNKNOWN\n");break;case KVM_EXIT_DEBUG:printf("KVM_EXIT_DEBUG\n");break;// 虚拟机执行了IO操作,虚拟机模式下的CPU会暂停虚拟机并// 把执行权交给emulatorcase KVM_EXIT_IO:printf("KVM_EXIT_IO\n");printf("out port: %d, data: %d\n", kvm->vcpus->kvm_run->io.port,  *(int *)((char *)(kvm->vcpus->kvm_run) + kvm->vcpus->kvm_run->io.data_offset));sleep(1);break;// 虚拟机执行了memory map IO操作case KVM_EXIT_MMIO:printf("KVM_EXIT_MMIO\n");break;case KVM_EXIT_INTR:printf("KVM_EXIT_INTR\n");break;case KVM_EXIT_SHUTDOWN:printf("KVM_EXIT_SHUTDOWN\n");goto exit_kvm;break;default:printf("KVM PANIC\n");goto exit_kvm;}}exit_kvm:return 0;
}void kvm_reset_vcpu (struct vcpu *vcpu) {if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &(vcpu->sregs)) < 0) {perror("can not get sregs\n");exit(1);}// #define CODE_START 0x1000/* sregs 结构体x86struct kvm_sregs {struct kvm_segment cs, ds, es, fs, gs, ss;struct kvm_segment tr, ldt;struct kvm_dtable gdt, idt;__u64 cr0, cr2, cr3, cr4, cr8;__u64 efer;__u64 apic_base;__u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];};*/// cs 为code start寄存器,存放了程序的起始地址vcpu->sregs.cs.selector = CODE_START;vcpu->sregs.cs.base = CODE_START * 16;// ss 为堆栈寄存器,存放了堆栈的起始位置vcpu->sregs.ss.selector = CODE_START;vcpu->sregs.ss.base = CODE_START * 16;// ds 为数据段寄存器,存放了数据开始地址vcpu->sregs.ds.selector = CODE_START;vcpu->sregs.ds.base = CODE_START *16;// es 为附加段寄存器vcpu->sregs.es.selector = CODE_START;vcpu->sregs.es.base = CODE_START * 16;// fs, gs 同样为段寄存器vcpu->sregs.fs.selector = CODE_START;vcpu->sregs.fs.base = CODE_START * 16;vcpu->sregs.gs.selector = CODE_START;// 为vCPU设置以上寄存器的值if (ioctl(vcpu->vcpu_fd, KVM_SET_SREGS, &vcpu->sregs) < 0) {perror("can not set sregs");exit(1);}// 设置寄存器标志位vcpu->regs.rflags = 0x0000000000000002ULL;// rip 表示了程序的起始指针,地址为 0x0000000// 在加载镜像的时候,我们直接将binary读取到了虚拟机的内存起始位// 所以虚拟机开始的时候会直接运行binaryvcpu->regs.rip = 0;// rsp 为堆栈顶vcpu->regs.rsp = 0xffffffff;// rbp 为堆栈底部vcpu->regs.rbp= 0;if (ioctl(vcpu->vcpu_fd, KVM_SET_REGS, &(vcpu->regs)) < 0) {perror("KVM SET REGS\n");exit(1);}
}

运行一下结果,可以看到当虚拟机执行了指令 out %ax, $0x10 的时候,会引起虚拟机的退出,这是CPU虚拟化里面将要介绍的特殊机制。
宿主机获取到虚拟机退出的原因后,获取相应的输出。这里的步骤就类似于IO虚拟化,直接读取IO模块的内存,并输出结果。

➜  kvmsample git:(master) ✗ ./kvmsample
read size: 712288
KVM start run
KVM_EXIT_IO
out port: 16, data: 0
KVM start run
KVM_EXIT_IO
out port: 16, data: 1
KVM start run
KVM_EXIT_IO
out port: 16, data: 2
KVM start run
KVM_EXIT_IO
out port: 16, data: 3
KVM start run
KVM_EXIT_IO
out port: 16, data: 4
...

总结

虚拟机的启动过程基本上可以这么总结:
创建kvm句柄->创建vm->分配内存->加载镜像到内存->启动线程执行KVM_RUN。从这个虚拟机的demo可以看出,虚拟机的内存是由宿主机通过mmap调用映射给虚拟机的,而vCPU是宿主机的一个线程,这个线程通过设置相应的vCPU的寄存器指定了虚拟机的程序加载地址后,开始运行虚拟机的指令,当虚拟机执行了IO操作后,CPU捕获到中断并把执行权又交回给宿主机。

当然真实的qemu-kvm比这个复杂的多,包括设置很多IO设备的MMIO,设置信号处理等。

下一篇将介绍CPU虚拟化相关知识。

上一篇文章笼统的介绍了一个虚拟机的诞生过程,从demo中也可以看到,运行一个虚拟机再也不需要像以前想象的那样,需要用软件来模拟硬件指令集了。虚拟机的指令集直接运行在宿主机物理CPU上,当虚拟机中的指令设计到IO操作或者一些特殊指令的时候,控制权转让给了宿主机(这里其实是转让给了vm monitor,下面检查VMM),也就是一个demo进程,他在宿主机上的表现形式也就是一个用户级进程。

用一张图来解释更为贴切。

VMM完成vCPU,内存的初始化后,通过ioctl调用KVM的接口,完成虚拟机的创建,并创建一个线程来运行VM,由于VM在前期初始化的时候会设置各种寄存器来帮助KVM查找到需要加载的指令的入口(main函数)。所以线程在调用了KVM接口后,物理CPU的控制权就交给了VM。VM运行在VMX non-root模式,这是Intel-V或者AMD-V提供的一种特殊的CPU执行模式。然后当VM执行了特殊指令的时候,CPU将当前VM的上下文保存到VMCS寄存器(这个寄存器是一个指针,保存了实际的上下文地址),然后执行权切换到VMM。VMM 获取 VM 返回原因,并做处理。如果是IO请求,VMM 可以直接读取VM的内存并将IO操作模拟出来,然后再调用VMRESUME指令,VM继续执行,此时在VM看来,IO操作的指令被CPU执行了。

Intel-V 技术

Intel-V 技术是Intel为了支持虚拟化而提供的一套CPU特殊运行模式。

Intel-V虚拟化技术结构

Intel-V 在IA-32处理器上扩展了处理器等级,原来的CPU支持ring0~ring3 4个等级,但是Linux只使用了其中的两个ring0,ring3。当CPU寄存器标示了当前CPU处于ring0级别的时候,表示此时CPU正在运行的是内核的代码。而当CPU处于ring3级别的时候,表示此时CPU正在运行的是用户级别的代码。当发生系统调用或者进程切换的时候,CPU会从ring3级别转到ring0级别。ring3级别是不允许执行硬件操作的,所有硬件操作都需要系统提供的API来完成。
比如说一个IO操作:

int nread = read(fd, buffer, 1024);

当执行到此段代码的时候,然后查找到系统调用号,保存到寄存器eax,然后会将对应的参数压栈后产生一个系统调用中断,对应的是 int $0x80。产生了系统调用中断后,此时CPU将切换到ring0模式,内核通过寄存器读取到参数,并完成最后的IO后续操作,操作完成后返回ring3模式。

movel  $3,%eax
movel  fd,%ebx
movel  buffer,%ecx
movel  1024,%edx      
int    $0x80

Intel-V 在 ring0~ring3 的基础上,增加了VMX模式,VMX分为root和non-root。这里的VMX root模式是给VMM(前面有提到VM monitor),在KVM体系中,就是qemu-kvm进程所运行的模式。VMX non-root模式就是运行的Guest,Guest也分ring0~ring3,不过他并不感知自己处于VMX non-root模式下。

Intel的虚拟架构基本上分两个部分:

  • 虚拟机监视器
  • 客户机(Guest VM)

虚拟机监视器(Virtual-machine monitors - VMM)

虚拟机监视器在宿主机上表现为一个提供虚拟机CPU,内存以及一系列硬件虚拟的实体,这个实体在KVM体系中就是一个进程,如qemu-kvm。VMM负责管理虚拟机的资源,并拥有所有虚拟机资源的控制权,包括切换虚拟机的CPU上下文等。

Guest

这个Guest在前面的Demo里面也提到,可能是一个操作系统(OS),也可能就是一个二进制程序,whatever,对于VMM来说,他就是一堆指令集,只需要知道入口(rip寄存器值)就可以加载。
Guest运行需要虚拟CPU,当Guest代码运行的时候,处于VMX non-root模式,此模式下,该用什么指令还是用什么指令,该用寄存器该用cache还是用cache,但是在执行到特殊指令的时候(比如Demo中的out指令),把CPU控制权交给VMM,由VMM来处理特殊指令,完成硬件操作。

VMM 与 Guest 的切换

Guest与VMM之间的切换分两个部分:VM entry 和 VM exit。有几种情况会导致VM exit,比如说Guest执行了硬件访问操作,或者Guest调用了VMCALL指令或者调用了退出指令或者产生了一个page fault,或者访问了特殊设备的寄存器等。当Guest处于VMX模式的时候,没有提供获取是否处于此模式下的指令或者寄存器,也就是说,Guest不能判断当前CPU是否处于VMX模式。当产生VM exit的时候,CPU会将exit reason保存到MSRs(VMX模式的特殊寄存器组),对应到KVM就是vCPU->kvm_run->exit_reason。VMM根据exit_reason做相应的处理。

VMM 的生命周期

如上图所示,VMM 开始于VMXON 指令,结束与VMXOFF指令。
第一次启动Guest,通过VMLAUNCH指令加载Guest,这时候一切都是新的,比如说起始的rip寄存器等。后续Guest exit后再entry,是通过VMRESUME指令,此指令会将VMCS(后面会介绍到)所指向的内容加载到当前Guest的上下文,以便Guest继续执行。

VMCS (Virtual-Machine control structure)

顾名思义,VMCS就是虚拟机控制结构,前面提到过很多次,Guest Exit的时候,会将当前Guest的上下文保存到VMCS中,Guest entry的时候把VMCS上下文恢复到VMM。VMCS是一个64位的指针,指向一个真实的内存地址,VMCS是以vCPU为单位的,就是说当前有多少个vCPU,就有多少个VMCS指针。VMCS的操作包括VMREAD,VMWRITE,VMCLEAR。

Guest exit Reason

下面是qemu-kvm定义的exit reason。可以看到有很多可能会导致Guest转让控制权。选取几个解释一下。

static int (*const kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {[EXIT_REASON_EXCEPTION_NMI]           = handle_exception, [EXIT_REASON_EXTERNAL_INTERRUPT]      = handle_external_interrupt, [EXIT_REASON_TRIPLE_FAULT]            = handle_triple_fault,[EXIT_REASON_NMI_WINDOW]              = handle_nmi_window,// 访问了IO设备[EXIT_REASON_IO_INSTRUCTION]          = handle_io,// 访问了CR寄存器,地址寄存器,和DR寄存器(debug register)一样,用于调试[EXIT_REASON_CR_ACCESS]               = handle_cr,[EXIT_REASON_DR_ACCESS]               = handle_dr, [EXIT_REASON_CPUID]                   = handle_cpuid,// 访问了MSR寄存器[EXIT_REASON_MSR_READ]                = handle_rdmsr,[EXIT_REASON_MSR_WRITE]               = handle_wrmsr,[EXIT_REASON_PENDING_INTERRUPT]       = handle_interrupt_window,// Guest执行了HLT指令,Demo开胃菜就是这个指令[EXIT_REASON_HLT]                     = handle_halt,[EXIT_REASON_INVD]                    = handle_invd,[EXIT_REASON_INVLPG]                  = handle_invlpg,[EXIT_REASON_RDPMC]                   = handle_rdpmc,// 不太清楚以下VM系列的指令有什么用,猜测是递归VM(虚拟机里面运行虚拟机)[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,[EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold,// 访问了高级PCI设备[EXIT_REASON_APIC_ACCESS]             = handle_apic_access,[EXIT_REASON_APIC_WRITE]              = handle_apic_write,[EXIT_REASON_EOI_INDUCED]             = handle_apic_eoi_induced,[EXIT_REASON_WBINVD]                  = handle_wbinvd,[EXIT_REASON_XSETBV]                  = handle_xsetbv,// 进程切换[EXIT_REASON_TASK_SWITCH]             = handle_task_switch,[EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,// ept 是Intel的一个硬件内存虚拟化技术[EXIT_REASON_EPT_VIOLATION]           = handle_ept_violation,[EXIT_REASON_EPT_MISCONFIG]           = handle_ept_misconfig,// 执行了暂停指令[EXIT_REASON_PAUSE_INSTRUCTION]       = handle_pause,[EXIT_REASON_MWAIT_INSTRUCTION]       = handle_invalid_op,[EXIT_REASON_MONITOR_INSTRUCTION]     = handle_invalid_op,[EXIT_REASON_INVEPT]                  = handle_invept,
};

总结

KVM的CPU虚拟化依托于Intel-V提供的虚拟化技术,将Guest运行于VMX模式,当执行了特殊操作的时候,将控制权返回给VMM。VMM处理完特殊操作后再把结果返回给Guest。

CPU虚拟化可以说是KVM的最关键的核心,弄清楚了VM Exit和VM Entry。后续的IO虚拟化,内存虚拟化都是建立在此基础上。下一章介绍内存虚拟化。

前面文章中我们讲过Qemu、KVM、Guest OS这三种层次以及对应的三种模式,也知道这三种模式之间的配合,下面上一张图回顾一下。

那现在我们就从代码的角度来讲一下这三层之间具体是如何配合的。

前面我们也讲过,首先Qemu层用户发起启动虚拟机命令后会通过ioctl调用进入到kvm内核层,完成相关初始化工作之后就运行虚拟机。

在kvm内核层中,当接收到ioctl的KVM_RUN命令后,实际调用的是kvm_arch_vcpu_ioctl_run()函数。

[objc] view plaincopy
  1. case KVM_RUN:
  2. r = -EINVAL;
  3. if (arg)
  4. goto out;
  5. r =kvm_arch_vcpu_ioctl_run(vcpu, vcpu->run);//
  6. trace_kvm_userspace_exit(vcpu->run->exit_reason,r);
  7. break;

随后依次调用__vcpu_run(),vcpu_enter_guest(),kvm_x86_ops->run(),vmx_vcpu_run(),在vmx_vcpu_run()函数中有一段汇编语言被调用,这段汇编中执行了ASM_VMX_VMLAUNCH或者ASM_VMX_VMRESUME指令进入到客户模式。

[objc] view plaincopy
  1. asm(
  2. .........//省略部分代码
  3. /* Enter guest mode */
  4. "jne 1f \n\t"
  5. __ex(ASM_VMX_VMLAUNCH)"\n\t"
  6. "jmp 2f \n\t"
  7. "1: "__ex(ASM_VMX_VMRESUME) "\n\t"
  8. ........//省略部分代码
  9. );

执行汇编指令进入到客户模式能够实现是因为KVM采用了硬件虚拟化的技术,比如Intel的芯片上提供了硬件支持并提供了相关一系列指令。再具体我也不知道了,查看Intel手册吧。那么进入到客户模式后,客户模式因为一些异常需要退出到KVM内核进行处理,这个是怎么实现的呢?

首先我们要说一下一个与异常处理相关的重要的数据结构VMCS。VMCS是虚拟机控制结构,他分为三部分:版本信息;终止标识符;VMCS数据域。其中VMCS数据域包含六类信息:客户状态域,宿主机状态域,VM-Entry控制域,VM-Execution控制域,VM-Exit控制域以及VM-Exit信息域。宿主机状态域保存了基本的寄存器信息,其中CS:RIP指向KVM中异常处理程序的入口地址,VM-Exit信息域中存放异常退出原因等信息。实际上,在KVM内核初始化vcpu时就将异常处理程序入口地址装载进VMCS中CS:RIP寄存器结构,当客户机发生异常时,就根据这个入口地址退出到内核模式执行异常处理程序。

KVM内核中异常处理总入口函数是vmx_handle_exit()函数。

[objc] view plaincopy
  1. static intvmx_handle_exit(struct kvm_vcpu *vcpu)
  2. {
  3. struct vcpu_vmx *vmx = to_vmx(vcpu);
  4. u32 exit_reason = vmx->exit_reason;
  5. ........//一些处理,省略这部分代码
  6. if (exit_reason <kvm_vmx_max_exit_handlers
  7. && kvm_vmx_exit_handlers[exit_reason])
  8. returnkvm_vmx_exit_handlers[exit_reason](vcpu);
  9. else {
  10. vcpu->run->exit_reason= KVM_EXIT_UNKNOWN;
  11. vcpu->run->hw.hardware_exit_reason= exit_reason;
  12. }
  13. return 0;
  14. }

该函数中,首先读取exit_reason,然后进行一些必要的处理,最后调用kvm_vmx_exit_handlers[exit_reason](vcpu),我们来看一下这个结构,实际上是一个函数指针数组,里面对应着所有的异常相应的异常处理函数。

[objc] view plaincopy
  1. static int(*const kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
  2. [EXIT_REASON_EXCEPTION_NMI]           = handle_exception,
  3. [EXIT_REASON_EXTERNAL_INTERRUPT]      = handle_external_interrupt,
  4. [EXIT_REASON_TRIPLE_FAULT]            = handle_triple_fault,
  5. [EXIT_REASON_NMI_WINDOW]          = handle_nmi_window,
  6. [EXIT_REASON_IO_INSTRUCTION]          = handle_io,
  7. [EXIT_REASON_CR_ACCESS]               = handle_cr,
  8. [EXIT_REASON_DR_ACCESS]               = handle_dr,
  9. [EXIT_REASON_CPUID]                   = handle_cpuid,
  10. [EXIT_REASON_MSR_READ]                = handle_rdmsr,
  11. [EXIT_REASON_MSR_WRITE]               = handle_wrmsr,
  12. [EXIT_REASON_PENDING_INTERRUPT]       = handle_interrupt_window,
  13. [EXIT_REASON_HLT]                     = handle_halt,
  14. [EXIT_REASON_INVD]                     = handle_invd,
  15. [EXIT_REASON_INVLPG]               = handle_invlpg,
  16. [EXIT_REASON_RDPMC]                   = handle_rdpmc,
  17. [EXIT_REASON_VMCALL]                  = handle_vmcall,
  18. [EXIT_REASON_VMCLEAR]                    = handle_vmclear,
  19. [EXIT_REASON_VMLAUNCH]                = handle_vmlaunch,
  20. [EXIT_REASON_VMPTRLD]                 = handle_vmptrld,
  21. [EXIT_REASON_VMPTRST]                 = handle_vmptrst,
  22. [EXIT_REASON_VMREAD]                  = handle_vmread,
  23. [EXIT_REASON_VMRESUME]                = handle_vmresume,
  24. [EXIT_REASON_VMWRITE]                 = handle_vmwrite,
  25. [EXIT_REASON_VMOFF]                   = handle_vmoff,
  26. [EXIT_REASON_VMON]                    = handle_vmon,
  27. [EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold,
  28. [EXIT_REASON_APIC_ACCESS]             = handle_apic_access,
  29. [EXIT_REASON_APIC_WRITE]              = handle_apic_write,
  30. [EXIT_REASON_EOI_INDUCED]             = handle_apic_eoi_induced,
  31. [EXIT_REASON_WBINVD]                  = handle_wbinvd,
  32. [EXIT_REASON_XSETBV]                  = handle_xsetbv,
  33. [EXIT_REASON_TASK_SWITCH]             = handle_task_switch,
  34. [EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,
  35. [EXIT_REASON_EPT_VIOLATION]         = handle_ept_violation,
  36. [EXIT_REASON_EPT_MISCONFIG]           = handle_ept_misconfig,
  37. [EXIT_REASON_PAUSE_INSTRUCTION]       = handle_pause,
  38. [EXIT_REASON_MWAIT_INSTRUCTION]       =handle_invalid_op,
  39. [EXIT_REASON_MONITOR_INSTRUCTION]     = handle_invalid_op,
  40. };

这里面比如handle_ept_violation就是影子页(EPT页)缺页异常的处理函数。

我们以handle_ept_violation()为例向下说明,依次调用kvm_mmu_page_fault(),vcpu->arch.mmu.page_fault(),tdp_page_fault()等后续函数完成缺页处理。

在这里,我们要注意kvm_vmx_exit_handlers[exit_reason](vcpu)的返回值,比如当实际调用handle_ept_violation()时返回值大于0,就直接切回客户模式。但是有时候可能需要Qemu的协助。在实际调用(r = kvm_x86_ops->handle_exit(vcpu);)时,返回值大于0,那么就说明KVM已经处理完成,可以再次切换进客户模式,但如果返回值小于等于0,那就说明需要Qemu的协助,KVM会在run结构体中的exit_reason中记录退出原因,并进入到Qemu中进行处理。这个判断过程是在__vcpu_run()函数中进行的,实际是一个while循环。

[objc] view plaincopy
  1. static int__vcpu_run(struct kvm_vcpu *vcpu)
  2. {
  3. ......//省略部分代码
  4. r = 1;
  5. while (r > 0) {
  6. if (vcpu->arch.mp_state ==KVM_MP_STATE_RUNNABLE &&
  7. !vcpu->arch.apf.halted)
  8. r =vcpu_enter_guest(vcpu);
  9. else {
  10. ......//省略部分代码
  11. }
  12. if (r <= 0)
  13. break;
  14. ......//省略部分代码
  15. }
  16. srcu_read_unlock(&kvm->srcu,vcpu->srcu_idx);
  17. vapic_exit(vcpu);
  18. return r;
  19. }

上面函数中vcpu_enter_guest()我们前面讲过,是在kvm内核中转入客户模式的函数,他处于while循环中,也就是如果不需要Qemu的协助,即r>0,那就继续循环,然后重新切换进客户系统运行,如果需要Qemu的协助,那返回值r<=0,退出循环,向上层返回r。

上面说的r一直往上层返回,直到kvm_vcpu_ioctl()函数中的

case KVM_RUN:

trace_kvm_userspace_exit(vcpu->run->exit_reason, r);

这一条语句就是将退出原因注入到Qemu层。

Qemu层这时候读取到ioctl的返回值,然后继续执行,就会判断有没有KVM的异常注入,这里其实我在前一篇文章中简单提及了一下。

[objc] view plaincopy
  1. int kvm_cpu_exec(CPUArchState *env)
  2. {
  3. .......
  4. do {
  5. ......
  6. run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN,0);
  7. ......
  8. trace_kvm_run_exit(cpu->cpu_index,run->exit_reason);
  9. switch (run->exit_reason) {
  10. case KVM_EXIT_IO:
  11. ......
  12. break;
  13. case KVM_EXIT_MMIO:
  14. ......
  15. break;
  16. case KVM_EXIT_IRQ_WINDOW_OPEN:
  17. .......
  18. break;
  19. case KVM_EXIT_SHUTDOWN:
  20. ......
  21. break;
  22. case KVM_EXIT_UNKNOWN:
  23. ......
  24. break;
  25. case KVM_EXIT_INTERNAL_ERROR:
  26. ......
  27. break;
  28. default:
  29. ......
  30. break;
  31. }
  32. } while (ret == 0);
  33. }

trace_kvm_run_exit(cpu->cpu_index,run->exit_reason);这条语句就是接收内核注入的退出原因,后面switch语句进行处理,每一个case对应一种退出原因,这里你也可以自己添加的。因为也是在while循环中,处理完一次后又进行ioctl调用运行虚拟机并切换到客户模式,这就形成了一个完整的闭环。

内存虚拟化简介

前一章介绍了CPU虚拟化的内容,这一章介绍一下KVM的内存虚拟化原理。可以说内存是除了CPU外最重要的组件,Guest最终使用的还是宿主机的内存,所以内存虚拟化其实就是关于如何做Guest到宿主机物理内存之间的各种地址转换,如何转换会让转换效率更高呢,KVM经历了三代的内存虚拟化技术,大大加快了内存的访问速率。

传统的地址转换

在保护模式下,普通的应用进程使用的都是自己的虚拟地址空间,一个64位的机器上的每一个进程都可以访问0到2^64的地址范围,实际上内存并没有这么多,也不会给你这么多。对于进程而言,他拥有所有的内存,对内核而言,只分配了一小段内存给进程,待进程需要更多的进程的时候再分配给进程。
通常应用进程所使用的内存叫做虚拟地址,而内核所使用的是物理内存。内核负责为每个进程维护虚拟地址到物理内存的转换关系映射。
首先,逻辑地址需要转换为线性地址,然后由线性地址转换为物理地址。

逻辑地址 ==> 线性地址 ==> 物理地址

逻辑地址和线性地址之间通过简单的偏移来完成。

一个完整的逻辑地址 = [段选择符:段内偏移地址],查找GDT或者LDT(通过寄存器gdtr,ldtr)找到描述符,通过段选择符(selector)前13位在段描述符做index,找到Base地址,Base+offset就是线性地址。

为什么要这么做?据说是Intel为了保证兼容性。

逻辑地址到线性地址的转换在虚拟化中没有太多的需要介绍的,这一层不存在实际的虚拟化操作,和传统方式一样,最重要的是线性地址到物理地址这一层的转换。

传统的线性地址到物理地址的转换由CPU的页式内存管理,页式内存管理。
页式内存管理负责将线性地址转换到物理地址,一个线性地址被分五段描述,第一段为基地址,通过与当前CR3寄存器(CR3寄存器每个进程有一个,线程共享,当发生进程切换的时候,CR3被载入到对应的寄存器中,这也是各个进程的内存隔离的基础)做运算,得到页表的地址index,通过四次运算,最终得到一个大小为4K的页(有可能更大,比如设置了hugepages以后)。整个过程都是CPU完成,进程不需要参与其中,如果在查询中发现页已经存在,直接返回物理地址,如果页不存在,那么将产生一个缺页中断,内核负责处理缺页中断,并把页加载到页表中,中断返回后,CPU获取到页地址后继续进行运算。

KVM中的内存结构

由于qemu-kvm进程在宿主机上作为一个普通进程,那对于Guest而言,需要的转换过程就是这样。

  Guest虚拟内存地址(GVA)|Guest线性地址 |Guest物理地址(GPA)|             Guest------------------|             HVHV虚拟地址(HVA)|HV线性地址|HV物理地址(HPA)

What's the fu*k ?这么多...
别着急,Guest虚拟地址到HV线性地址之间的转换和HV虚拟地址到线性地址的转换过程可以省略,这样看起来就更清晰一点。

  Guest虚拟内存地址(GVA)|Guest物理地址(GPA)|             Guest------------------|             HVHV虚拟地址(HVA)|HV物理地址(HPA)

前面也说到KVM通过不断的改进转换过程,让KVM的内存虚拟化更加的高效,我们从最初的软件虚拟化的方式介绍。

软件虚拟化方式实现

第一层转换,由GVA->GPA的转换和传统的转换关系一样,通过查找CR3然后进行页表查询,找到对应的GPA,GPA到HVA的关系由qemu-kvm负责维护,我们在第二章KVM启动过程的demo里面就有介绍到怎样给KVM映射内存,通过mmap的方式把HV的内存映射给Guest。

struct kvm_userspace_memory_region region = {.slot = 0,.guest_phys_addr = 0x1000,.memory_size = 0x1000,.userspace_addr = (uint64_t)mem,
};

可以看到,qemu-kvm的kvm_userspace_memory_region结构体描述了guest的物理地址起始位置和内存大小,然后描述了Guest的物理内存在HV的映射userspace_addr,通过多个slot,可以把不连续的HV的虚拟地址空间映射给Guest的连续的物理地址空间。

软件模拟的虚拟化方式由qemu-kvm来负责维护GPA->HVA的转换,然后再经过一次HVA->HPA的方式,从过程上来看,这样的访问是很低效的,特别是在当GVA到GPA转换时候产生缺页中断,这时候产生一个异常Guest退出,HV捕获异常后计算出物理地址(分配新的内存给Guest),然后重新Entry。这个过程会可能导致频繁的Guest退出,且转换过程过长。于是KVM使用了一种叫做影子页表的技术。

影子页表的虚拟化方式

影子页表的出现,就是为了减少地址转换带来的开销,直接把GVA转换到HVP的技术。在软件虚拟化的内存转换中,GVA到GPA的转换通过查询CR3寄存器来完成,CR3保存了Guest中的页表基地址,然后载入MMU来做地址转换。
在加入了影子页表的技术后,当访问到CR3寄存器的时候(可能是由于Guest进程后导致的),KVM捕获到这个操作,CPU虚拟化章节EXIT_REASON_CR_ACCESS,qemu-kvm通过载入特俗的CR3和影子页表来欺骗Guest这个就是真实的CR3,后面的操作就和传统的访问内存的方式一致,当需要访问物理内存的时候,只会经过一层的影子页表的转换。

影子页表由qemu-kvm进程维护,实际上就是一个Guest的页表到宿主机页表的映射,每一级的页表的hash值对应到qemu-kvm中影子页表的一个目录。在初次GVA->HPA的转换时候,影子页表没有建立,此时Guest产生缺页中断,和传统的转换过程一样,经过两次转换(VA->PA),然后影子页表记录GVA->GPA->HVA->HPA。这样产生GVA->GPA的直接关系,保存到影子页表中。

影子页表的引入,减少了GVA->HPA的转换过程,但是坏处在于qemu-kvm需要为Guest的每个进程维护一个影子页表,这将带来很大的内存开销,同时影子页表的建立是很耗时的,如果Guest进程过多,将导致频繁的影子页表的导入与导出,虽然用了cache技术,但是还是软件层面的,效率并不是最好,所以Intel和AMD在此基础上提供了硬件虚拟化技术。

EPT硬件加速的虚拟化方式


EPT(extended page table)可以看做一个硬件的影子页表,在Guest中通过增加EPT寄存器,当Guest产生了CR3和页表的访问的时候,由于对CR3中的页表地址的访问是GPA,当地址为空时候,也就是Page fault后,产生缺页异常,如果在软件模拟或者影子页表的虚拟化方式中,此时会有VM退出,qemu-kvm进程接管并获取到此异常。但是在EPT的虚拟化方式中,qemu-kvm忽略此异常,Guest并不退出,而是按照传统的缺页中断处理,在缺页中断处理的过程中会产生EXIT_REASON_EPT_VIOLATION,Guest退出,qemu-kvm捕获到异常后,分配物理地址并建立GVA->HPA的映射,并保存到EPT中,将EPT载入到MMU,下次转换时候直接查询根据CR3查询EPT表来完成GVA->HPA的转换。以后的转换都由硬件直接完成,大大提高了效率,且不需要为每个进程维护一套页表,减少了内存开销。
在笔者的测试中,Guest和HV的内存访问速率对比为3756MB/s对比4340MB/s。可以看到内存访问已经很接近宿主机的水平了。

总结

KVM内存的虚拟化就是一个将虚拟机的虚拟内存转换为宿主机物理内存的过程,Guest使用的依然是宿主机的物理内存,只是在这个过程中怎样减少转换带来的开销成为优化的主要点。
KVM经过软件模拟->影子页表->EPT的技术的进化,效率也越来越高。

IO 虚拟化简介

前面的文章介绍了KVM的启动过程,CPU虚拟化,内存虚拟化原理。作为一个完整的风诺依曼计算机系统,必然有输入计算输出这个步骤。传统的IO包括了网络设备IO,块设备IO,字符设备IO等等,在KVM虚拟化原理探究里面,我们最主要介绍网络设备IO和块设备IO,其实他们的原理都很像,但是在虚拟化层又分化开了,这也是为什么网络设备IO虚拟化和块设备IO虚拟化要分开讲的原因。这一章介绍一下网络设备IO虚拟化,下一章介绍块设备IO虚拟化。

传统的网络IO流程

这里的传统并不是真的传统,而是介绍一下在非虚拟化环境下的网络设备IO流程。我们平常所使用的Linux版本,比如Debian或者CentOS等都是标准的Linux TCP/IP协议栈,协议栈底层提供了driver抽象层来适配不同的网卡,在虚拟化中最重要的是设备的虚拟化,但是了解整个网络IO流程后去看待虚拟化就会更加容易理解了。

标准的TCP/IP结构

在用户层,我们通过socket与Kernel做交互,包括创建端口,数据的接收发送等操作。
在Kernel层,TCP/IP协议栈负责将我们的socket数据封装到TCP或者UDP包中,然后进入IP层,加入IP地址端口信息等,进入数据链路层,加入Mac地址等信息后,通过驱动写入到网卡,网卡再把数据发送出去。如下图所示,比较主观的图。

在Linux的TCP/IP协议栈中,每个数据包是有内核的skb_buff结构描述的,如下图所示,socket发送数据包的时候后,进入内核,内核从skb_buff的池中分配一个skb_buff用来承载数据流量。


当数据到了链路层,链路层做好相应的链路层头部封装后,调用驱动层适配层的发送接口 dev_queue_xmit,最终调用到 net_start_xmit 接口。

发送数据和接收数据驱动层都采用DMA模式,驱动加载时候会为网卡映射内存并设置描述状态(寄存器中),也就是内存的起始位,长度,剩余大小等等。发送时候将数据放到映射的内存中,然后设置网卡寄存器产生一个中断,告诉网卡有数据,网卡收到中断后处理对应的内存中的数据,处理完后向CPU产生一个中断告诉CPU数据发送完成,CPU中断处理过程中向上层driver通知数据发送完成,driver再依次向上层返回。在这个过程中对于driver来说,发送是同步的。接收数据的流程和发送数据几乎一致,这里就不细说了。DMA的模式对后面的IO虚拟化来说很重要。

KVM 网络IO虚拟化

准确来说,KVM只提供了一些基本的CPU和内存的虚拟化方案,真正的IO实现都由qemu-kvm来完成,只不过我们在介绍KVM的文章里都默认qemu-kvm和KVM为一个体系,就没有分的那么仔细了。实际上网络IO虚拟化都是由qemu-kvm来完成的。

KVM 全虚拟化IO

还记得我们第一章节的demo里面,我们的“镜像”调用了 out 指令产生了一个IO操作,然后因为此操作为敏感的设备访问类型的操作,不能在VMX non-root 模式下执行,于是VM exits,模拟器接管了这个IO操作。

switch (kvm->vcpus->kvm_run->exit_reason) {case KVM_EXIT_UNKNOWN:printf("KVM_EXIT_UNKNOWN\n");break;// 虚拟机执行了IO操作,虚拟机模式下的CPU会暂停虚拟机并// 把执行权交给emulatorcase KVM_EXIT_IO:printf("KVM_EXIT_IO\n");printf("out port: %d, data: %d\n", kvm->vcpus->kvm_run->io.port,  *(int *)((char *)(kvm->vcpus->kvm_run) + kvm->vcpus->kvm_run->io.data_offset));break;...

虚拟机退出并得知原因为 KVM_EXIT_IO,模拟器得知由于设备产生了IO操作并退出,于是获取这个IO操作并打印出数据。这里其实我们就最小化的模拟了一个虚拟IO的过程,由模拟器接管这个IO。

在qemu-kvm全虚拟化的IO过程中,其实原理也是一样,KVM捕获IO中断,由qemu-kvm接管这个IO,由于采用了DMA映射,qemu-kvm在启动时候会注册设备的mmio信息,以便能获取到DMA设备的映射内存和控制信息。

static int pci_e1000_init(PCIDevice *pci_dev)
{e1000_mmio_setup(d); // 为PCI设备设置 mmio 空间pci_register_bar(&d->dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio); pci_register_bar(&d->dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->io);d->nic = qemu_new_nic(&net_e1000_info, &d->conf, object_get_typename(OBJECT(d)), d->dev.qdev.id, d);   add_boot_device_path(d->conf.bootindex, &pci_dev->qdev, "/ethernet-phy@0");
}

对于PCI设备来说,当设备与CPU之间通过映射了一段连续的物理内存后,CPU对PCI设备的访问只需要像访问内存一样访问既可以。IO设备通常有两种模式,一种是port模式,一种是MMIO模式,前者就是我们demo里面的in/out指令,后者就是PCI设备的DMA访问方式,两种方式的操作都能被KVM捕获。

于是qemu-kvm将此操作代替Guest完成后并执行相应的“回调”,也就是向vCPU产生中断告诉IO完成并返回Guest继续执行。vCPU中断和CPU中断一样,设置相应的寄存器后中断便会触发。

在全虚拟化环境下,Guest中的IO都由qemu-kvm接管,在Guest中看到的一个网卡设备并不是真正的一块网卡,而是由物理机产生的一个tap设备。知识在驱动注册的时候将一些tap设备所支持的特性加入到了Guest的驱动注册信息里面,所以在Guest中看到有网络设备。

如上图所示,qemu接管了来自Guest的IO操作,真实的场景肯定是需要将数据再次发送出去的,而不是像demo一样打印出来,在Guest中的数据包二层封装的Mac地址后,qemu层不需要对数据进行拆开再解析,而只需要将数据写入到tap设备,tap设备和bridge之间交互完成后,由bridge直接发送到网卡,bridge(其实NIC绑定到了Bridge)开启了混杂模式,可以将所有请求都接收或者发送出去。

以下来自这篇文章的引用

当一个 TAP 设备被创建时,在 Linux 设备文件目录下将会生成一个对应 char 设备,用户程序可以像打开普通文件一样打开这个文件进行读写。当执行 write()操作时,数据进入 TAP 设备,此时对于 Linux 网络层来说,相当于 TAP 设备收到了一包数据,请求内核接受它,如同普通的物理网卡从外界收到一包数据一样,不同的是其实数据来自 Linux 上的一个用户程序。Linux 收到此数据后将根据网络配置进行后续处理,从而完成了用户程序向 Linux 内核网络层注入数据的功能。当用户程序执行 read()请求时,相当于向内核查询 TAP 设备上是否有需要被发送出去的数据,有的话取出到用户程序里,完成 TAP 设备的发送数据功能。针对 TAP 设备的一个形象的比喻是:使用 TAP 设备的应用程序相当于另外一台计算机,TAP 设备是本机的一个网卡,他们之间相互连接。应用程序通过 read()/write()操作,和本机网络核心进行通讯。

类似这样的操作

fd = open("/dev/tap", XXX)
write(fd, buf, 1024);
read(fd, buf, 1024);

bridge可能是一个Linux bridge,也可能是一个OVS(Open virtual switch),在涉及到网络虚拟化的时候,通常需要利用到bridge提供的VLAN tag功能。

以上就是KVM的网络全虚拟化IO流程了,我们也可以看到这个流程的不足,比如说当网络流量很大的时候,会产生过多的VM的切换,同时产生过多的数据copy操作,我们知道copy是很浪费CPU时钟周期的。于是qemu-kvm在发展的过程中,实现了virtio驱动。

KVM Virtio 驱动

基于 Virtio 的虚拟化也叫作半虚拟化,因为要求在Guest中加入virtio驱动,也就意味着Guest知道了自己运行于虚拟环境了。

不同于全虚拟化的方式,Virtio通过在Guest的Driver层引入了两个队列和相应的队列就绪描述符与qemu-kvm层Virtio Backend进行通信,并用文件描述符来替代之前的中断。
Virtio front-end与Backend之间通过Vring buffer交互,在qemu中,使用事件循环机制来描述buffer的状态,这样当buffer中有数据的时候,qemu-kvm会监听到eventfd的事件就绪,于是就可以读取数据后发送到tap设备,当有数据从tap设备过来的时候,qemu将数据写入到buffer,并设置eventfd,这样front-end监听到事件就绪后从buffer中读取数据。

可以看到virtio在全虚拟化的基础上做了改动,降低了Guest exit和entry的开销,同时利用eventfd来建立控制替代硬件中断面膜是,一定程度上改善了网络IO的性能。
不过从整体流程上来看,virtio还是存在过多的内存拷贝,比如qemu-kvm从Vring buffer中拷贝数据后发送到tap设备,这个过程需要经过用户态到内核态的拷贝,加上一系列的系统调用,所以在流程上还可以继续完善,于是出现了内核态的virtio,被称作vhost-net。

KVM Vhost-net

我们用一张图来对比一下virtio与vhost-net,图片来自redhat官网。

vhost-net 绕过了 QEMU 直接在Guest的front-end和backend之间通信,减少了数据的拷贝,特别是减少了用户态到内核态的拷贝。性能得到大大加强,就吞吐量来说,vhost-net基本能够跑满一台物理机的带宽。
vhost-net需要内核支持,Redhat 6.1 后开始支持,默认状态下是开启的。

总结

KVM的网络设备IO虚拟化经过了全虚拟化->virtio->vhost-net的进化,性能越来越接近真实物理网卡,但是在小包处理方面任然存在差距,不过已经不是一个系统的瓶颈了,可以看到KVM在经过了这多年的发展后,性能也是越发的强劲,这也是他领先于其他虚拟化的重要原因之一。
在本章介绍了IO虚拟化后,下一章介绍块设备的虚拟化,块设备虚拟化同样利用了DMA的特性。

块设备IO虚拟化简介

上一篇文章讲到了网络IO虚拟化,作为另外一个重要的虚拟化资源,块设备IO的虚拟化也是同样非常重要的。同网络IO虚拟化类似,块设备IO也有全虚拟化和virtio的虚拟化方式(virtio-blk)。现代块设备的工作模式都是基于DMA的方式,所以全虚拟化的方式和网络设备的方式接近,同样的virtio-blk的虚拟化方式和virtio-net的设计方式也是一样,只是在virtio backend端有差别。

传统块设备架构

块设备IO协议栈

如上图所示,我们把块设备IO的流程也看做一个TCP/IP协议栈的话,从最上层说起。

Page cache层,这里如果是非直接IO,写操作如果在内存够用的情况下,都是写到这一级后就返回。在IO流程里面,属于writeback模式。 需要持久化的时候有两种选择,一种是显示的调用flush操作,这样此文件(以文件为单位)的cache就会同步刷到磁盘,另一种是等待系统自动flush。

VFS,也就是我们通常所说的虚拟文件系统层,这一层给我们上层提供了统一的系统调用,我们常用的create,open,read,write,close转化为系统调用后,都与VFS层交互。VFS不仅为上层系统调用提供了统一的接口,还组织了文件系统结构,定义了文件的数据结构,比如根据inode查找dentry并找到对应文件信息,并找到描述一个文件的数据结构struct file。文件其实是一种对磁盘中存储的一堆零散的数据的一种描述,在Linux上,一个文件由一个inode 表示。inode在系统管理员看来是每一个文件的唯一标识,在系统里面,inode是一个结构,存储了关于这个文件的大部分信息。这个数据结构有几个回调操作就是提供给不同的文件系统做适配的。下层的文件系统需要实现file_operation的几个接口,做具体的数据的读写操作等。

struct file_operations {//文件读操作ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);//文件写操作ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);int (*readdir) (struct file *, void *, filldir_t);//文件打开操作int (*open) (struct inode *, struct file *);
};

再往下就是针对不同的文件系统层,比如我们的ext3,ext4等等。 我们在VFS层所说的几个文件系统需要实现的接口,都在这一层做真正的实现。这一层的文件系统并不直接操作文件,而是通过与下层的通用块设备层做交互,为什么要抽象一层通用块设备呢?我们的文件系统适用于不同的设备类型,比如可能是一个SSD盘又或者是一个USB设备,不同的设备的驱动不一样,文件系统没有必要为每一种不同的设备做适配,只需要兼容通用快设备层的接口就可以。

位于文件系统层下面的是通用快设备层,这一层在程序设计里面是属于接口层,用于屏蔽底层不同的快设备做的抽象,为上层的文件系统提供统一的接口。

通用快设备下层就是IO调度层。用如下命令可以看到系统的IO调度算法.

➜  ~ cat /sys/block/sda/queue/scheduler
noop deadline [cfq]
  1. noop,可以看成是FIFO(先进先出队列),对IO做一些简单的合并,比如对同一个文件的操作做合并,这种算法适合比如SSD磁盘不需要寻道的块设备。

  2. cfq,完全公平队列。此算法的设计是从进程级别来保证的,就是说公平的对象是每个进程。系统为此算法分配了N个队列用来保存来自不同进程的请求,当进程有IO请求的时候,会散列到不同的队列,散列算法是一致的,同一个进程的请求总是被散列到同一个队列。然后系统根据时间片轮训这N个队列的IO请求来完成实际磁盘读写。

  3. deadline,在Linux的电梯调度算法的基础上,增加了两个队列,用来处理即将超时或者超时的IO请求,这两个队列的优先级比其他队列的优先级较高,所以避免了IO饥饿情况的产生。

块设备驱动层就是针对不同的块设备的真实驱动层了,块设备驱动层完成块设备的内存映射并处理块设备的中断,完成块设备的读写。

块设备就是真实的存储设备,包括SAS,SATA,SSD等等。块设备也可能有cache,一般称为Disk cache,对于驱动层来说,cache的存在是很重要的,比如writeback模式下,驱动层只需要写入到Disk cache层就可以返回,块设备层保证数据的持久化以及一致性。
通常带有Disk cache的块设备都有电池管理,当掉电的时候保证cache的内容能够保持一段时间,下次启动的时候将cache的内容写入到磁盘中。

块设备IO流程

应用层的读写操作,都是通过系统调用read,write完成,由Linux VFS提供的系统调用接口完成,屏蔽了下层块设备的复杂操作。write操作有直接IO和非直接IO之分(缓冲IO),非直接IO的写操作直接写入到page cache后就返回,后续的数据依赖系统的flush操作,如果在flush操作未完成的时候发生了系统掉电,那可能会丢失一部分数据。直接IO(Direct IO),绕过了page cache,数据必须达到磁盘后才返回IO操作完成。

对于I/O的读写流程,逻辑比较复杂,这里以写流程简单描述如下:

  1. 用户调用系统调用write写一个文件,会调到sys_write函数;
  2. 经过VFS虚拟文件系统层,调用vfs_write,如果是缓存写方式,则写入page cache,然后就返回,后续就是刷脏页的流程;如果是Direct I/O的方式,就会走到块设备直接IO(do_blockdev_direct_IO)的流程;
  3. 构造bio请求,调用submit_bio往具体的块设备下发请求,submit_bio函数通过generic_make_request转发bio,generic_make_request是一个循环,其通过每个块设备下注册的q->make_request_fn函数与块设备进行交互;
  4. 请求下发到底层的块设备上,调用块设备请求处理函数__make_request进行处理,在这个函数中就会调用blk_queue_bio,这个函数就是合并bio到request中,也就是I/O调度器的具体实现:如果几个bio要读写的区域是连续的,就合并到一个request;否则就创建一个新的request,把自己挂到这个request下。合并bio请求也是有限度的,如果合并后的请求超过阈值(在/sys/block/xxx/queue/max_sectors_kb里设置),就不能再合并成一个request了,而会新分配一个request;
  5. 接下来的I/O操作就与具体的物理设备有关了,块设备驱动的读写也是通过DMA方式进行。

如上图所示,在初始化IO设备的时候,会为IO设备分配一部分物理内存,这个物理内存可以由CPU的MMU和连接IO总线的IOMMU管理,作为共享内存存在。以一个读取操作为例子,当CPU需要读取块设备的某个内容的时候,CPU会通过中断告知设备内存地址以及大小和需要读取的块设备地址,然后CPU返回,块设备完成实际的读取数据后,将数据写入到共享的内存,并以中断方式通知CPU IO流程完成,并设置内存地址,接着CPU直接从内存中读取数据。
写请求类似,都是通过共享内存的方式,这样可以解放CPU,不需要CPU同步等待IO的完成并且不需要CPU做过多的运算操作。
因为块设备IO的虚拟化需要经过两次IO协议栈,一次Guest,一次HV。所以需要把块设备IO协议栈说的很具体一点。

至此,Linux块设备的IO层就基本介绍完整了,以上内容也只是做一个简单的介绍,这部分的内容可以很深入的去了解,在此限于篇幅限制,就不做过多介绍了。

块设备IO虚拟化

块设备的全虚拟化方式和网络IO的DMA设备虚拟化方式类似,这里就不过多介绍了,主要介绍一下virtio-blk。

如上图所示,块设备IO的虚拟化流程和网络IO的流程基本一致,差别在于virtio-backend一段,virtio-net是写入到tap设备,virtio-blk是写入到镜像文件中。
块设备IO的流程需要经过两次IO协议栈,一次位于Guest,一次位于HV。当我们指定virtio的cache模式的时候,实际上指定的是virtio-backend(下面简称v-backend)写入HV块设备的方式。
在虚拟化层次来看,Guest对于这几种Cache模式是没有感知的,也就是无论Cache模式是怎样,Guest都不会有所谓的绕过Guest的Page cache等操作,Virtio-front模拟的是驱动层的操作,不会涉及到更上层的IO协议栈。

如上图所示,蓝色表示 writethrough,黄色表示 none,红色表示 writeback。其中虚线表示写到哪一个层次后write调用返回。

  • cache=writethrough (蓝色线)
    表示v-backend打开镜像文件并写入时候采用非直接IO+flush操作,也就是说每次写入到Page cache并flush一次,直到数据被真实写入到磁盘后write调用返回,这样必然会导致数据写入变慢,但是好处就是安全性较高。

  • cache=none (黄色线)
    cache为none模式表示了v-backend写入文件时候使用到了DIRECT_IO,将会绕过HV的Page cache,直接写入磁盘,如果磁盘有Disk cache的话,写入Disk cache就返回,此模式的好处在于保证性能的前提下,也能保证数据的安全性,在使用了Disk cache电池的情况下。但是对于读操作,因为没有写入HV Page cache,所以会有一定性能影响。

  • cache=writeback (红色线)
    此模式表示v-backend使用了非直接IO,写入到HV的Page后就返回,有可能会导致数据丢失。

总结

块设备IO的虚拟化方式也是统一的virtio-x模式,但是virtio-blk需要经过两次IO协议栈,带来了不必要的开销。前面的铺垫都是为了介绍三种重要的cache模式。

使用KVM API实现Emulator Demo

这边文章来描述如何用KVM API来写一个Virtualizer的demo code, 也就是相当与Qemu,用来做设备模拟。 此文是帮助想了解KVM原理已经Qemu原理的人 or Just for fun.

完整的Code在这里: https://github.com/soulxu/kvmsample

这个code其实是很久以前写的,以前在team内部分享过,用来帮助大家理解kvm工作原理。现在既然要开始写code了,就用这个先来个开端。

当然我不可能写一个完整的Qemu,只是写出Qemu中最基本的那些code。这个虚拟机只有一个VCPU和512000000字节内存(其实富裕了) 可以进行一些I/O,当然这些I/O的结果只能导致一些print,没有实际模拟任何设备。所以所能执行的Guest也很简单。

首先来看看Guest有多简单。

1
2
3
4
5
6
7
8
9
.globl _start
    .code16
_start:
    xorw %ax, %ax

loop1:
    out %ax, $0x10
    inc %ax
    jmp loop1

不熟悉汇编也没关系,这code很简单,基本也能猜到干啥了。对,Guest只是基于at&t汇编写的一个在8086模式下的死循环,不停的向端口0x10写东西。目标就是让这个Guest跑起来了。

我们的目标就是让这个Guest能执行起来。下面开始看我们虚拟机的code了。

我们先来看看main函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int main(int argc, char **argv) {    int ret = 0;
    struct kvm *kvm = kvm_init();

    if (kvm == NULL) {        fprintf(stderr, "kvm init fauilt\n");
        return -1;
    }

    if (kvm_create_vm(kvm, RAM_SIZE) < 0) {        fprintf(stderr, "create vm fault\n");
        return -1;
    }

    load_binary(kvm);

    // only support one vcpu now
    kvm->vcpu_number = 1;
    kvm->vcpus = kvm_init_vcpu(kvm, 0, kvm_cpu_thread);

    kvm_run_vm(kvm);

    kvm_clean_vm(kvm);
    kvm_clean_vcpu(kvm->vcpus);
    kvm_clean(kvm);
}

这里正是第一个kvm基本原理: 一个虚拟机就是一个进程,我们的虚拟机从这个main函数开始

让我先来看看kvm_init。这里很简单,就是打开了/dev/kvm设备,这是kvm的入口,对kvm的所有操作都是通过对文件描述符上执行ioctl来完成。 这里很简单,就是打开kvm设备,然后将文件描述符返回到我自己创建的一个结构体当中。

然后我们就开始创建一个vm,然后为其分配内存。

1
kvm->vm_fd = ioctl(kvm->dev_fd, KVM_CREATE_VM, 0);

创建一个虚拟机很简单,在kvm设备上执行这么一个ioctl即可,然后会得到新建的vm的文件描述,用来操作这个vm。

然后我们来分配内存,这里最重要的是struct kvm_userspace_memory_region这个数据结构。

1
2
3
4
5
6
7
8
/* for KVM_SET_USER_MEMORY_REGION */
struct kvm_userspace_memory_region {        __u32 slot;
        __u32 flags;
        __u64 guest_phys_addr;
        __u64 memory_size; /* bytes */
        __u64 userspace_addr; /* start of the userspace allocated memory */
};

memory_size是guest的内存的大小。userspace_addr是你为其份分配的内存的起始地址,而guest_phys_addr则是这段内存映射到guest的什么物理内存地址。

这里用mmap创建了一段匿名映射,并将地址置入userspace_addr。随后来告诉我们的vm这些信息:

1
ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &(kvm->mem));

这里是来操作我们的vm了,不是kvm设备文件了。

我们有了内存了,现在可以把我们的guest code加载的进来了,这个实现很简单就是打开编译后的二进制文件将其写入我们分配的内存空间当中。 这里所要注意的就是如何编译guest code,这里我们编译出来的是flat binary,不需要什么elf的封装。

有了内存,下一步就是vcpu了,创建vcpu是在kvm_init_vcpu函数里。 这里最重要的操作只有这个:

1
2
3
vcpu->kvm_run_mmap_size = ioctl(kvm->dev_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
...
vcpu->kvm_run = mmap(NULL, vcpu->kvm_run_mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpu->vcpu_fd, 0);

struct kvm_run是保存vcpu状态的一个数据结构,稍后我们可以看到我们可以从这里得到当陷入后具体陷入原因。

有了内存和vcpu就可以运行了:

1
pthread_create(&(kvm->vcpus->vcpu_thread), (const pthread_attr_t *)NULL, kvm->vcpus[i].vcpu_thread_func, kvm)

这里是另一个kvm基本概念了,一个vcpu就是一个线程。这里让我们为vcpu创建一个线程。

最终我们到了最关键的部分了,就是这个vcpu线程。其实他就是一个循环。 当循环开始的时候,我们让他执行guest code:

1
ret = ioctl(kvm->vcpus->vcpu_fd, KVM_RUN, 0)

当执行这条语句后,guest code就开始执行了,这个函数就阻塞在这里了。直到something happened而且需要由hypervisor进行处理的时候这个函数才会返回。 比如说I/O发生了,这个函数就会返回了,这里我们就需要通过struct kvm_run中得到具体的陷入原因。我们的guest只是做一些I/O port的操作,所以可以看到 当退出原因是KVM_EXIT_IO时,我将guest的所写入的数据print出来。

到这里这就是这个virtualizer的全部了. 如果你想体验一下,只需要执行make。

1
2
3
4
5
:~/code/kvmsample$ make
cc    -c -o main.o main.c
gcc main.c -o kvmsample -lpthread
as -32 test.S -o test.o
ld -m elf_i386 --oformat binary -N -e _start -Ttext 0x10000 -o test.bin test.o

然后执行kvmsample

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ ./kvmsample
read size: 712288
KVM start run
KVM_EXIT_IO
out port: 16, data: 0
KVM start run
KVM_EXIT_IO
out port: 16, data: 1
KVM start run
KVM_EXIT_IO
out port: 16, data: 2
KVM start run
KVM_EXIT_IO
out port: 16, data: 3
....

其实qemu里面的code也就是这样,你也可以在其中找到这个loop,只不过它被qemu内部的各种设备框架所隐藏起来了。

The entry point of QEMU is int main in vl.c

01 int main(int argc, char **argv, char **envp)
02 {
03    ......
04    GMemVTable mem_trace = {
05         .malloc = malloc_and_trace,
06         .realloc = realloc_and_trace,
07         .free = free_and_trace,
08     }; // This data structure is prepared for glib.
09        // The three values are function pointers which are required by glib if you want to use glib library.
10  
11    g_mem_set_vtable(&mem_trace);// Register these functions in glib
12  
13    g_thread_init(NULL);// If you use gLib from more than one thread, you must initialize the thread system by calling
14  
15    module_call_init(MODULE_INIT_QOM);
16    // Check Code1-1 for Module_INIT_QOM definition.
17    // This function will retrieve ModuleEntry in the list of Module_INIT_QOM. Actually, QEMU maintain one list for each Module Type. Then execute the init function for each ModuleEntry.
18    // See module_call_init for which "init" function will be executed?
19  
20  
21  
22 }

MODULE_INIT_TYPE (Code1-1)

1 typedef enum {
2     MODULE_INIT_BLOCK,
3     MODULE_INIT_MACHINE,
4     MODULE_INIT_QAPI,
5     MODULE_INIT_QOM,
6     MODULE_INIT_MAX
7 } module_init_type;

Four types Module Definition

1 #define block_init(function) module_init(function, MODULE_INIT_BLOCK)
2 #define machine_init(function) module_init(function, MODULE_INIT_MACHINE)
3 #define qapi_init(function) module_init(function, MODULE_INIT_QAPI)
4 #define type_init(function) module_init(function, MODULE_INIT_QOM)

module_init()

1 #define module_init(function, type)                                         \
2 static void __attribute__((constructor)) do_qemu_init_ ## function(void) {  \
3     register_module_init(function, type);                                   \
4 }

register_module_init()

01 void register_module_init(void (*fn)(void), module_init_type type)
02 {
03     ModuleEntry *e;
04     ModuleTypeList *l;
05  
06     e = g_malloc0(sizeof(*e));
07     e->init = fn;
08  
09     l = find_type(type);
10  
11     QTAILQ_INSERT_TAIL(l, e, node);
12 }

module_call_init(...)

01 void module_call_init(module_init_type type)
02 {
03     ModuleTypeList *l;
04     ModuleEntry *e;
05  
06     l = find_type(type);
07  
08     QTAILQ_FOREACH(e, l, node) {
09         e->init(); // Here, only the init function for QOM module is executed.
10                    // For example, one object "x86_cpu_register_types" is registered by type_init(x86_cpu_register_types)
11                    // Then only x86_cpu_register_types() is executed and this function only set up each parameter in TypeInfo
12                    // TypeInfo can be found in the following.
13     }
14 }

TypeInfo The basic parameter used to restore QEMU Object.

view sourceprint?
01 /**
02  * TypeInfo:
03  * @name: The name of the type.
04  * @parent: The name of the parent type.
05  * @instance_size: The size of the object (derivative of #Object).  If
06  *   @instance_size is 0, then the size of the object will be the size of the
07  *   parent object.
08  * @instance_init: This function is called to initialize an object.  The parent
09  *   class will have already been initialized so the type is only responsible
10  *   for initializing its own members.
11  * @instance_post_init: This function is called to finish initialization of
12  *   an object, after all @instance_init functions were called.
13  * @instance_finalize: This function is called during object destruction.  This
14  *   is called before the parent @instance_finalize function has been called.
15  *   An object should only free the members that are unique to its type in this
16  *   function.
17  * @abstract: If this field is true, then the class is considered abstract and
18  *   cannot be directly instantiated.
19  * @class_size: The size of the class object (derivative of #ObjectClass)
20  *   for this object.  If @class_size is 0, then the size of the class will be
21  *   assumed to be the size of the parent class.  This allows a type to avoid
22  *   implementing an explicit class type if they are not adding additional
23  *   virtual functions.
24  * @class_init: This function is called after all parent class initialization
25  *   has occurred to allow a class to set its default virtual method pointers.
26  *   This is also the function to use to override virtual methods from a parent
27  *   class.
28  * @class_base_init: This function is called for all base classes after all
29  *   parent class initialization has occurred, but before the class itself
30  *   is initialized.  This is the function to use to undo the effects of
31  *   memcpy from the parent class to the descendents.
32  * @class_finalize: This function is called during class destruction and is
33  *   meant to release and dynamic parameters allocated by @class_init.
34  * @class_data: Data to pass to the @class_init, @class_base_init and
35  *   @class_finalize functions.  This can be useful when building dynamic
36  *   classes.
37  * @interfaces: The list of interfaces associated with this type.  This
38  *   should point to a static array that's terminated with a zero filled
39  *   element.
40  */
41 struct TypeInfo
42 {
43     const char *name;
44     const char *parent;
45  
46     size_t instance_size;
47     void (*instance_init)(Object *obj);
48     void (*instance_post_init)(Object *obj);
49     void (*instance_finalize)(Object *obj);
50  
51     bool abstract;
52     size_t class_size;
53  
54     void (*class_init)(ObjectClass *klass, void *data);
55     void (*class_base_init)(ObjectClass *klass, void *data);
56     void (*class_finalize)(ObjectClass *klass, void *data);
57     void *class_data;
58  
59     InterfaceInfo *interfaces;
60 };

QEMU Part



configure_accelerator()


01 static int configure_accelerator(void)
02 {
03     const char *p;
04     char buf[10];
05     int i, ret;
06     bool accel_initialised = false;
07     bool init_failed = false;
08  
09     p = qemu_opt_get(qemu_get_machine_opts(), "accel");
10     if (p == NULL) {
11         /* Use the default "accelerator", tcg */
12         p = "tcg";
13     }
14  
15     while (!accel_initialised && *p != '\0') {
16         if (*p == ':') {
17             p++;
18         }
19         p = get_opt_name(buf, sizeof (buf), p, ':'); // buf records the name of hypervisor
20         for (i = 0; i < ARRAY_SIZE(accel_list); i++) { // accel_list[] can be found in the following.
21             if (strcmp(accel_list[i].opt_name, buf) == 0) { // Retrieve accel_list to match the name of hypervisor
22                 if (!accel_list[i].available()) { // Check if this hypervisor is available
23                     printf("%s not supported for this target\n",
24                            accel_list[i].name);
25                     continue;
26                 }
27                 *(accel_list[i].allowed) = true;
28                 ret = accel_list[i].init(); // Run the initialization function for the chosen hypervisor. For example, kvm -> kvm_init()
29                 if (ret < 0) {
30                     init_failed = true;
31                     fprintf(stderr, "failed to initialize %s: %s\n",
32                             accel_list[i].name,
33                             strerror(-ret));
34                     *(accel_list[i].allowed) = false;
35                 else {
36                     accel_initialised = true;
37                 }
38                 break;
39             }
40         }
41         if (i == ARRAY_SIZE(accel_list)) {
42             fprintf(stderr, "\"%s\" accelerator does not exist.\n", buf);
43         }
44     }
45  
46     if (!accel_initialised) {
47         if (!init_failed) {
48             fprintf(stderr, "No accelerator found!\n");
49         }
50         exit(1);
51     }
52  
53     if (init_failed) {
54         fprintf(stderr, "Back to %s accelerator.\n", accel_list[i].name);
55     }
56  
57     return !accel_initialised;
58 }

accel_list[]

01 static struct {
02     const char *opt_name;
03     const char *name;
04     int (*available)(void);
05     int (*init)(void);
06     bool *allowed;
07 } accel_list[] = {
08     "tcg""tcg", tcg_available, tcg_init, &tcg_allowed },
09     "xen""Xen", xen_available, xen_init, &xen_allowed },
10     "kvm""KVM", kvm_available, kvm_init, &kvm_allowed }, // kvm_available and kvm_init are both pointers to functions.
11     "qtest""QTest", qtest_available, qtest_init, &qtest_allowed },
12 };

kvm_init()


001 int kvm_init(void)
002 {
003     static const char upgrade_note[] =
004         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
005         "(see http://sourceforge.net/projects/kvm).\n";
006     struct {
007         const char *name;
008         int num;
009     } num_cpus[] = {
010         "SMP",          smp_cpus },
011         "hotpluggable", max_cpus },
012         { NULL, }
013     }, *nc = num_cpus;
014     int soft_vcpus_limit, hard_vcpus_limit;
015     KVMState *s;
016     const KVMCapabilityInfo *missing_cap;
017     int ret;
018     int i;
019  
020     s = g_malloc0(sizeof(KVMState)); // KVMState definition could be found in the following
021  
022     /*
023      * On systems where the kernel can support different base page
024      * sizes, host page size may be different from TARGET_PAGE_SIZE,
025      * even with KVM.  TARGET_PAGE_SIZE is assumed to be the minimum
026      * page size for the system though.
027      */
028     assert(TARGET_PAGE_SIZE <= getpagesize());
029  
030 #ifdef KVM_CAP_SET_GUEST_DEBUG
031     QTAILQ_INIT(&s->kvm_sw_breakpoints);
032 #endif
033     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
034         s->slots[i].slot = i;
035     }
036     s->vmfd = -1;
037     s->fd = qemu_open("/dev/kvm", O_RDWR); // Return the KVM fd
038     if (s->fd == -1) {
039         fprintf(stderr, "Could not access KVM kernel module: %m\n");
040         ret = -errno;
041         goto err;
042     }
043  
044     ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0); // Send Command "KVM_GET_API_VERSION" to KVM fd. kvm_ioctl can be found in the following.
045     if (ret < KVM_API_VERSION) {                // The definition of "KVM_GET_API_VERSION" could be found in the following.
046         if (ret > 0) {
047             ret = -EINVAL;
048         }
049         fprintf(stderr, "kvm version too old\n");
050         goto err;
051     }
052  
053     if (ret > KVM_API_VERSION) {
054         ret = -EINVAL;
055         fprintf(stderr, "kvm version not supported\n");
056         goto err;
057     }
058  
059     /* check the vcpu limits */
060     soft_vcpus_limit = kvm_recommended_vcpus(s);
061    // call kvm_check_extension(s, KVM_CAP_NR_VCPUS) -> kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_NR_VCPUS). Default is 4 vcpus.
062    // s: KVMState.
063    // KVM_CAP_NR_VCPUS: one of API in KVM_Extension.
064    // KVM_CHECK_EXTENSION: KVM API which can be recognized by KVM fd.
065      
066     hard_vcpus_limit = kvm_max_vcpus(s); 
067    // call kvm_check_extension(s, KVM_CAP_MAX_VCPUS) -> kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_MAX_VCPUS). Default is 4 vcpus.      
068    // KVM_CAP_MAX_VCPUS: one of API in KVM Extension.
069    // KVM_CHECK_EXTENSION: KVM API which can be recognized by KVM fd.
070     while (nc->name) {
071         if (nc->num > soft_vcpus_limit) {
072             fprintf(stderr,
073                     "Warning: Number of %s cpus requested (%d) exceeds "
074                     "the recommended cpus supported by KVM (%d)\n",
075                     nc->name, nc->num, soft_vcpus_limit);
076  
077             if (nc->num > hard_vcpus_limit) {
078                 ret = -EINVAL;
079                 fprintf(stderr, "Number of %s cpus requested (%d) exceeds "
080                         "the maximum cpus supported by KVM (%d)\n",
081                         nc->name, nc->num, hard_vcpus_limit);
082                 goto err;
083             }
084         }
085         nc++;
086     }
087     /* call KVM API "KVM_CREATE_VM" to create a new VM */
088     s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0); // VM fd will be assigned to s->vmfd
089     if (s->vmfd < 0) {
090 #ifdef TARGET_S390X
091         fprintf(stderr, "Please add the 'switch_amode' kernel parameter to "
092                         "your host kernel command line\n");
093 #endif
094         ret = s->vmfd;
095         goto err;
096     }
097  
098     missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
099     if (!missing_cap) {
100         missing_cap =
101             kvm_check_extension_list(s, kvm_arch_required_capabilities);
102     }
103     if (missing_cap) {
104         ret = -EINVAL;
105         fprintf(stderr, "kvm does not support %s\n%s",
106                 missing_cap->name, upgrade_note);
107         goto err;
108     }
109  
110     s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
111  
112     s->broken_set_mem_region = 1;
113     ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
114     if (ret > 0) {
115         s->broken_set_mem_region = 0;
116     }
117  
118 #ifdef KVM_CAP_VCPU_EVENTS
119     s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
120 #endif
121  
122     s->robust_singlestep =
123         kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
124  
125 #ifdef KVM_CAP_DEBUGREGS
126     s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
127 #endif
128  
129 #ifdef KVM_CAP_XSAVE
130     s->xsave = kvm_check_extension(s, KVM_CAP_XSAVE);
131 #endif
132  
133 #ifdef KVM_CAP_XCRS
134     s->xcrs = kvm_check_extension(s, KVM_CAP_XCRS);
135 #endif
136  
137 #ifdef KVM_CAP_PIT_STATE2
138     s->pit_state2 = kvm_check_extension(s, KVM_CAP_PIT_STATE2);
139 #endif
140  
141 #ifdef KVM_CAP_IRQ_ROUTING
142     s->direct_msi = (kvm_check_extension(s, KVM_CAP_SIGNAL_MSI) > 0);
143 #endif
144  
145     s->intx_set_mask = kvm_check_extension(s, KVM_CAP_PCI_2_3);
146  
147     s->irq_set_ioctl = KVM_IRQ_LINE;
148     if (kvm_check_extension(s, KVM_CAP_IRQ_INJECT_STATUS)) {
149         s->irq_set_ioctl = KVM_IRQ_LINE_STATUS;
150     }
151  
152 #ifdef KVM_CAP_READONLY_MEM
153     kvm_readonly_mem_allowed =
154         (kvm_check_extension(s, KVM_CAP_READONLY_MEM) > 0);
155 #endif
156  
157     ret = kvm_arch_init(s);
158     if (ret < 0) {
159         goto err;
160     }
161  
162     ret = kvm_irqchip_create(s);
163     if (ret < 0) {
164         goto err;
165     }
166  
167     kvm_state = s;
168     memory_listener_register(&kvm_memory_listener, &address_space_memory);
169     memory_listener_register(&kvm_io_listener, &address_space_io);
170  
171     s->many_ioeventfds = kvm_check_many_ioeventfds();
172  
173     cpu_interrupt_handler = kvm_handle_interrupt;
174  
175     return 0;
176  
177 err:
178     if (s->vmfd >= 0) {
179         close(s->vmfd);
180     }
181     if (s->fd != -1) {
182         close(s->fd);
183     }
184     g_free(s);
185  
186     return ret;
187 }

KVMState

01 struct KVMState
02 {
03     KVMSlot slots[32];
04     int fd;    // KVM fd
05     int vmfd;  // VM fd
06     int coalesced_mmio;
07     struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
08     bool coalesced_flush_in_progress;
09     int broken_set_mem_region;
10     int migration_log;
11     int vcpu_events;
12     int robust_singlestep;
13     int debugregs;
14 #ifdef KVM_CAP_SET_GUEST_DEBUG
15     struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
16 #endif
17     int pit_state2;
18     int xsave, xcrs;
19     int many_ioeventfds;
20     int intx_set_mask;
21     /* The man page (and posix) say ioctl numbers are signed int, but
22      * they're not.  Linux, glibc and *BSD all treat ioctl numbers as
23      * unsigned, and treating them as signed here can break things */
24     unsigned irq_set_ioctl;
25 #ifdef KVM_CAP_IRQ_ROUTING
26     struct kvm_irq_routing *irq_routes;
27     int nr_allocated_irq_routes;
28     uint32_t *used_gsi_bitmap;
29     unsigned int gsi_count;
30     QTAILQ_HEAD(msi_hashtab, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
31     bool direct_msi;
32 #endif
33 };

kvm_ioctl(KVMState *s, int type, ...)

01 int kvm_ioctl(KVMState *s, int type, ...)
02 {
03     int ret;
04     void *arg;
05     va_list ap;
06  
07     va_start(ap, type); // Use va_start/va_arg/va_end to get variable parameter list.
08     arg = va_arg(ap, void *);
09     va_end(ap);
10  
11     trace_kvm_ioctl(type, arg);
12     ret = ioctl(s->fd, type, arg); // User ioctl to call kvm fd
13     if (ret == -1) {
14         ret = -errno;
15     }
16     return ret;
17 }



KVM Part



Register ioctl handler


vmx_init() -> kvm_init(...) -> misc_register(kvm_dev) -> kvm.&kvm_chardev_ops 
kvm_dev

1 static struct miscdevice kvm_dev = {
2  KVM_MINOR,
3  "kvm",
4  &kvm_chardev_ops,
5 };

kvm_chardev_ops

1 static struct file_operations kvm_chardev_ops = {
2  .unlocked_ioctl = kvm_dev_ioctl,
3  .compat_ioctl   = kvm_dev_ioctl, // When QEMU send a command to KVM fd (e.g. KVM_GET_API_VERSION), this function will be invoked.
4  .llseek  = noop_llseek,
5 };

KVM API


The "/dev/kvm" ioctl handler is as follows: 
KVM_GET_API_VERSIONThis API just return the API version of KVM. The handler just return he version of KVM. This parameter is defined in ./include/uapi/linux/kvm.h

1 #define KVM_GET_API_VERSION       _IO(KVMIO,   0x00)  // According to the following datastructure, KVM_GET_API_VERSION will be a number with format ||dir||type||nr||size||.
1 #define _IO(type,nr)  _IOC(_IOC_NONE,(type),(nr),0)
1 #define _IOC(dir,type,nr,size)   \
2  ((unsigned int)    \
3   (((dir)  << _IOC_DIRSHIFT) |  \
4    ((type) << _IOC_TYPESHIFT) |  \
5    ((nr)   << _IOC_NRSHIFT) |  \
6    ((size) << _IOC_SIZESHIFT)))

KVM_CREATE_VMThis API is used by QEMU to ask KVM create VM. "KVM_CREATE_VM" definition is the same as KVM_GET_API_VERSION.

1 case KVM_CREATE_VM:
2  r = kvm_dev_ioctl_create_vm(arg);
3  break;

QEMU Source Code Study (3) - KVM_CREATE_VCPU

x86_cpu_register_types() ----> type_register_static(&x86_cpu_type_info) ----> TypeInfo x86_cpu_type_info.class_init = x86_cpu_common_class_init ----> x86_cpu_common_class_init(ObjectClass *oc, void *data) ----> dc->realize = x86_cpu_realizefn ----> x86_cpu_realizefn(DeviceState *dev, Error **error) ----> qemu_init_vcpu(cpu) ----> qemu_kvm_start_vcpu(cpu) ----> qemu_thread_create(cpu->thread, qemu_kvm_cpu_thread_fn, cpu) ----> nqemu_kvm_cpu_thread_fn(arg) ----> kvm_cpu_exec(cpu) ----> kvm_vcpu_ioctl(cpu, KVM_RUN, 0);

How to execute these object?

QEMU Part



kvm_init_vcpu(...)

01 int kvm_init_vcpu(CPUState *cpu)
02 {
03     KVMState *s = kvm_state;
04     long mmap_size;
05     int ret;
06  
07     DPRINTF("kvm_init_vcpu\n");
08  
09     ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, (void *)kvm_arch_vcpu_id(cpu)); // Send vm fd a command "KVM_CREATE_VCPU"
10     if (ret < 0) {
11         DPRINTF("kvm_create_vcpu failed\n");
12         goto err;
13     }
14  
15     cpu->kvm_fd = ret;
16     cpu->kvm_state = s;
17     cpu->kvm_vcpu_dirty = true;
18  
19     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0); // Send kvm fd (/dev/kvm) a command "KVM_GET_VCPU_MMAP_SIZE"
20     if (mmap_size < 0) {
21         ret = mmap_size;
22         DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
23         goto err;
24     }
25  
26     cpu->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, // Map the kvm fd into the kernel memory. So that, can access kvm fd by memory operation rather than read/write
27                         cpu->kvm_fd, 0);
28     if (cpu->kvm_run == MAP_FAILED) {
29         ret = -errno;
30         DPRINTF("mmap'ing vcpu state failed\n");
31         goto err;
32     }
33  
34     if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
35         s->coalesced_mmio_ring =
36             (void *)cpu->kvm_run + s->coalesced_mmio * PAGE_SIZE;
37     }
38  
39     ret = kvm_arch_init_vcpu(cpu); // This function is quite long. I guess it is responsible for configuring vcpu . This is an important function
40                                    // call cpu_x86_cpuid(...) to emulate all physical cpu.
41     if (ret == 0) {
42         qemu_register_reset(kvm_reset_vcpu, cpu);
43         kvm_arch_reset_vcpu(cpu);
44     }
45 err:
46     return ret;
47 }

KVM Part



kvm_vm_ioctl()

1 case KVM_CREATE_VCPU:
2      r = kvm_vm_ioctl_create_vcpu(kvm, arg);
3      break;

kvm_vm_ioctl_create_vcpu(kvm, id)

01 static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
02 {
03  int r;
04  struct kvm_vcpu *vcpu, *v;
05  
06  vcpu = kvm_arch_vcpu_create(kvm, id); // just run kvm_x86_ops-> vcpu_create(kvm,id);
07  if (IS_ERR(vcpu))
08   return PTR_ERR(vcpu);
09  
10  preempt_notifier_init(&vcpu->preempt_notifier, &kvm_preempt_ops);
11  
12  r = kvm_arch_vcpu_setup(vcpu);
13  if (r)
14   goto vcpu_destroy;
15  
16  mutex_lock(&kvm->lock);
17  if (!kvm_vcpu_compatible(vcpu)) {
18   r = -EINVAL;
19   goto unlock_vcpu_destroy;
20  }
21  if (atomic_read(&kvm->online_vcpus) == KVM_MAX_VCPUS) {
22   r = -EINVAL;
23   goto unlock_vcpu_destroy;
24  }
25  
26  kvm_for_each_vcpu(r, v, kvm)
27   if (v->vcpu_id == id) {
28    r = -EEXIST;
29    goto unlock_vcpu_destroy;
30   }
31  
32  BUG_ON(kvm->vcpus[atomic_read(&kvm->online_vcpus)]);
33  
34  /* Now it's all set up, let userspace reach it */
35  kvm_get_kvm(kvm);
36  r = create_vcpu_fd(vcpu);
37  if (r < 0) {
38   kvm_put_kvm(kvm);
39   goto unlock_vcpu_destroy;
40  }
41  
42  kvm->vcpus[atomic_read(&kvm->online_vcpus)] = vcpu;
43  smp_wmb();
44  atomic_inc(&kvm->online_vcpus);
45  
46  mutex_unlock(&kvm->lock);
47  kvm_arch_vcpu_postcreate(vcpu);
48  return r;
49  
50 unlock_vcpu_destroy:
51  mutex_unlock(&kvm->lock);
52 vcpu_destroy:
53  kvm_arch_vcpu_destroy(vcpu);
54  return r;
55 }

kvm_x86_ops

001 static struct kvm_x86_ops vmx_x86_ops = {
002  .cpu_has_kvm_support = cpu_has_kvm_support,
003  .disabled_by_bios = vmx_disabled_by_bios,
004  .hardware_setup = hardware_setup,
005  .hardware_unsetup = hardware_unsetup,
006  .check_processor_compatibility = vmx_check_processor_compat,
007  .hardware_enable = hardware_enable,
008  .hardware_disable = hardware_disable,
009  .cpu_has_accelerated_tpr = report_flexpriority,
010  
011  .vcpu_create = vmx_create_vcpu, // The construction function for vcpu
012  .vcpu_free = vmx_free_vcpu,
013  .vcpu_reset = vmx_vcpu_reset,
014  
015  .prepare_guest_switch = vmx_save_host_state,             // Save host machine state
016  .vcpu_load = vmx_vcpu_load,
017  .vcpu_put = vmx_vcpu_put,
018  
019  .update_db_bp_intercept = update_exception_bitmap,
020  .get_msr = vmx_get_msr,
021  .set_msr = vmx_set_msr,
022  .get_segment_base = vmx_get_segment_base,
023  .get_segment = vmx_get_segment,
024  .set_segment = vmx_set_segment,
025  .get_cpl = vmx_get_cpl,
026  .get_cs_db_l_bits = vmx_get_cs_db_l_bits,
027  .decache_cr0_guest_bits = vmx_decache_cr0_guest_bits,
028  .decache_cr3 = vmx_decache_cr3,
029  .decache_cr4_guest_bits = vmx_decache_cr4_guest_bits,
030  .set_cr0 = vmx_set_cr0,
031  .set_cr3 = vmx_set_cr3,
032  .set_cr4 = vmx_set_cr4,
033  .set_efer = vmx_set_efer,
034  .get_idt = vmx_get_idt,
035  .set_idt = vmx_set_idt,
036  .get_gdt = vmx_get_gdt,
037  .set_gdt = vmx_set_gdt,
038  .set_dr7 = vmx_set_dr7,
039  .cache_reg = vmx_cache_reg,
040  .get_rflags = vmx_get_rflags,
041  .set_rflags = vmx_set_rflags,
042  .fpu_activate = vmx_fpu_activate,
043  .fpu_deactivate = vmx_fpu_deactivate,
044  
045  .tlb_flush = vmx_flush_tlb,
046  
047  .run = vmx_vcpu_run,                                   // The function to run a guest VM
048  .handle_exit = vmx_handle_exit,                        // VMEXIT handler function
049  .skip_emulated_instruction = skip_emulated_instruction,
050  .set_interrupt_shadow = vmx_set_interrupt_shadow,
051  .get_interrupt_shadow = vmx_get_interrupt_shadow,
052  .patch_hypercall = vmx_patch_hypercall,
053  .set_irq = vmx_inject_irq,
054  .set_nmi = vmx_inject_nmi,
055  .queue_exception = vmx_queue_exception,
056  .cancel_injection = vmx_cancel_injection,
057  .interrupt_allowed = vmx_interrupt_allowed,
058  .nmi_allowed = vmx_nmi_allowed,
059  .get_nmi_mask = vmx_get_nmi_mask,
060  .set_nmi_mask = vmx_set_nmi_mask,
061  .enable_nmi_window = enable_nmi_window,
062  .enable_irq_window = enable_irq_window,
063  .update_cr8_intercept = update_cr8_intercept,
064  .set_virtual_x2apic_mode = vmx_set_virtual_x2apic_mode,
065  .vm_has_apicv = vmx_vm_has_apicv,
066  .load_eoi_exitmap = vmx_load_eoi_exitmap,
067  .hwapic_irr_update = vmx_hwapic_irr_update,
068  .hwapic_isr_update = vmx_hwapic_isr_update,
069  .sync_pir_to_irr = vmx_sync_pir_to_irr,
070  .deliver_posted_interrupt = vmx_deliver_posted_interrupt,
071  
072  .set_tss_addr = vmx_set_tss_addr,
073  .get_tdp_level = get_ept_level,
074  .get_mt_mask = vmx_get_mt_mask,
075  
076  .get_exit_info = vmx_get_exit_info,
077  
078  .get_lpage_level = vmx_get_lpage_level,
079  
080  .cpuid_update = vmx_cpuid_update,
081  
082  .rdtscp_supported = vmx_rdtscp_supported,
083  .invpcid_supported = vmx_invpcid_supported,
084  
085  .set_supported_cpuid = vmx_set_supported_cpuid,
086  
087  .has_wbinvd_exit = cpu_has_vmx_wbinvd_exit,
088  
089  .set_tsc_khz = vmx_set_tsc_khz,
090  .read_tsc_offset = vmx_read_tsc_offset,
091  .write_tsc_offset = vmx_write_tsc_offset,
092  .adjust_tsc_offset = vmx_adjust_tsc_offset,
093  .compute_tsc_offset = vmx_compute_tsc_offset,
094  .read_l1_tsc = vmx_read_l1_tsc,
095  
096  .set_tdp_cr3 = vmx_set_cr3,
097  
098  .check_intercept = vmx_check_intercept,
099  .handle_external_intr = vmx_handle_external_intr,
100 };

vmx_create_vcpu

view sourceprint?
01 static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
02 {
03  int err;
04  struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
05  int cpu;
06  
07  if (!vmx)
08   return ERR_PTR(-ENOMEM);
09  
10  allocate_vpid(vmx);
11  
12  err = kvm_vcpu_init(&vmx->vcpu, kvm, id);
13  if (err)
14   goto free_vcpu;
15  
16  vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
17  err = -ENOMEM;
18  if (!vmx->guest_msrs) {
19   goto uninit_vcpu;
20  }
21  
22  vmx->loaded_vmcs = &vmx->vmcs01;
23  vmx->loaded_vmcs->vmcs = alloc_vmcs();
24  if (!vmx->loaded_vmcs->vmcs)
25   goto free_msrs;
26  if (!vmm_exclusive)
27   kvm_cpu_vmxon(__pa(per_cpu(vmxarea, raw_smp_processor_id())));
28  loaded_vmcs_init(vmx->loaded_vmcs);
29  if (!vmm_exclusive)
30   kvm_cpu_vmxoff();
31  
32  cpu = get_cpu();
33  vmx_vcpu_load(&vmx->vcpu, cpu);
34  vmx->vcpu.cpu = cpu;
35  err = vmx_vcpu_setup(vmx);
36  vmx_vcpu_put(&vmx->vcpu);
37  put_cpu();
38  if (err)
39   goto free_vmcs;
40  if (vm_need_virtualize_apic_accesses(kvm)) {
41   err = alloc_apic_access_page(kvm);
42   if (err)
43    goto free_vmcs;
44  }
45  
46  if (enable_ept) {
47   if (!kvm->arch.ept_identity_map_addr)
48    kvm->arch.ept_identity_map_addr =
49     VMX_EPT_IDENTITY_PAGETABLE_ADDR;
50   err = -ENOMEM;
51   if (alloc_identity_pagetable(kvm) != 0)
52    goto free_vmcs;
53   if (!init_rmode_identity_map(kvm))
54    goto free_vmcs;
55  }
56  
57  vmx->nested.current_vmptr = -1ull;
58  vmx->nested.current_vmcs12 = NULL;
59  
60  return &vmx->vcpu;
61  
62 free_vmcs:
63  free_loaded_vmcs(vmx->loaded_vmcs);
64 free_msrs:
65  kfree(vmx->guest_msrs);
66 uninit_vcpu:
67  kvm_vcpu_uninit(&vmx->vcpu);
68 free_vcpu:
69  free_vpid(vmx);
70  kmem_cache_free(kvm_vcpu_cache, vmx);
71  return ERR_PTR(err);
72 }

QEMU Part



Like  KVM_VCPU_CREATE() ,  kvm_cpu_exec()  is also called by function " qemu_kvm_cpu_thread_fn(...) ". For the execution process of  qemu_kvm_cpu_thread_fn(...) , please check the  KVM_VCPU_CREATE()  post.


kvm_vcpu_exec()


01 int kvm_cpu_exec(CPUState *cpu)
02 {
03     struct kvm_run *run = cpu->kvm_run; // kvm_run: restores the vmexit reason and information including: VMEXIT/IO etc,. Actually, this structure is used to switch information between guest and hypervisor
04                                         // The definition of kvm_run can be found in the following.
05     int ret, run_ret;
06  
07     DPRINTF("kvm_cpu_exec()\n");
08  
09     if (kvm_arch_process_async_events(cpu)) {
10         cpu->exit_request = 0;
11         return EXCP_HLT;
12     }
13  
14     do {
15         if (cpu->kvm_vcpu_dirty) {
16             kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
17             cpu->kvm_vcpu_dirty = false;
18         }
19  
20         kvm_arch_pre_run(cpu, run);  // Check if an interrupt should be delivered to the guest.
21         if (cpu->exit_request) {
22             DPRINTF("interrupt exit requested\n");
23             /*
24              * KVM requires us to reenter the kernel after IO exits to complete
25              * instruction emulation. This self-signal will ensure that we
26              * leave ASAP again.
27              */
28             qemu_cpu_kick_self();
29         }
30         qemu_mutex_unlock_iothread();
31  
32         run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0); // Send "KVM_RUN" command to kvm/vcpu
33  
34         qemu_mutex_lock_iothread();
35         kvm_arch_post_run(cpu, run);
36  
37         if (run_ret < 0) {
38             if (run_ret == -EINTR || run_ret == -EAGAIN) {
39                 DPRINTF("io window exit\n");
40                 ret = EXCP_INTERRUPT;
41                 break;
42             }
43             fprintf(stderr, "error: kvm run failed %s\n",
44                     strerror(-run_ret));
45             abort();
46         }
47  
48         trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
49         switch (run->exit_reason) {
50         case KVM_EXIT_IO:
51             DPRINTF("handle_io\n");
52             kvm_handle_io(run->io.port,
53                           (uint8_t *)run + run->io.data_offset,
54                           run->io.direction,
55                           run->io.size,
56                           run->io.count);
57             ret = 0;
58             break;
59         case KVM_EXIT_MMIO:
60             DPRINTF("handle_mmio\n");
61             cpu_physical_memory_rw(run->mmio.phys_addr,
62                                    run->mmio.data,
63                                    run->mmio.len,
64                                    run->mmio.is_write);
65             ret = 0;
66             break;
67         case KVM_EXIT_IRQ_WINDOW_OPEN:
68             DPRINTF("irq_window_open\n");
69             ret = EXCP_INTERRUPT;
70             break;
71         case KVM_EXIT_SHUTDOWN:
72             DPRINTF("shutdown\n");
73             qemu_system_reset_request();
74             ret = EXCP_INTERRUPT;
75             break;
76         case KVM_EXIT_UNKNOWN:
77             fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
78                     (uint64_t)run->hw.hardware_exit_reason);
79             ret = -1;
80             break;
81         case KVM_EXIT_INTERNAL_ERROR:
82             ret = kvm_handle_internal_error(cpu, run);
83             break;
84         default:
85             DPRINTF("kvm_arch_handle_exit\n");
86             ret = kvm_arch_handle_exit(cpu, run);
87             break;
88         }
89     while (ret == 0);
90  
91     if (ret < 0) {
92         cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
93         vm_stop(RUN_STATE_INTERNAL_ERROR);
94     }
95  
96     cpu->exit_request = 0;
97     return ret;
98 }

kvm_arch_pre_run(cpu, run)

01 void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
02 {
03     X86CPU *x86_cpu = X86_CPU(cpu);
04     CPUX86State *env = &x86_cpu->env;
05     int ret;
06  
07     /* Inject NMI */
08     if (cpu->interrupt_request & CPU_INTERRUPT_NMI) {
09         cpu->interrupt_request &= ~CPU_INTERRUPT_NMI;
10         DPRINTF("injected NMI\n");
11         ret = kvm_vcpu_ioctl(cpu, KVM_NMI); // Send KVM a command "KVM_NMI" to inject NMI
12         if (ret < 0) {
13             fprintf(stderr, "KVM: injection failed, NMI lost (%s)\n",
14                     strerror(-ret));
15         }
16     }
17  
18     if (!kvm_irqchip_in_kernel()) {
19         /* Force the VCPU out of its inner loop to process any INIT requests
20          * or pending TPR access reports. */
21         if (cpu->interrupt_request &
22             (CPU_INTERRUPT_INIT | CPU_INTERRUPT_TPR)) {
23             cpu->exit_request = 1;
24         }
25  
26         /* Try to inject an interrupt if the guest can accept it */
27         if (run->ready_for_interrupt_injection &&
28             (cpu->interrupt_request & CPU_INTERRUPT_HARD) &&
29             (env->eflags & IF_MASK)) {
30             int irq;
31  
32             cpu->interrupt_request &= ~CPU_INTERRUPT_HARD;
33             irq = cpu_get_pic_interrupt(env);
34             if (irq >= 0) {
35                 struct kvm_interrupt intr;
36  
37                 intr.irq = irq;
38                 DPRINTF("injected interrupt %d\n", irq);
39                 ret = kvm_vcpu_ioctl(cpu, KVM_INTERRUPT, &intr); // Send KVM a command "KVM_INTERRUPT" to inject the interrupt handled by guest.
40                 if (ret < 0) {
41                     fprintf(stderr,
42                             "KVM: injection failed, interrupt lost (%s)\n",
43                             strerror(-ret));
44                 }
45             }
46         }
47  
48         /* If we have an interrupt but the guest is not ready to receive an
49          * interrupt, request an interrupt window exit.  This will
50          * cause a return to userspace as soon as the guest is ready to
51          * receive interrupts. */
52         if ((cpu->interrupt_request & CPU_INTERRUPT_HARD)) {
53             run->request_interrupt_window = 1;
54         else {
55             run->request_interrupt_window = 0;
56         }
57  
58         DPRINTF("setting tpr\n");
59         run->cr8 = cpu_get_apic_tpr(env->apic_state);
60     }
61 }

struct kvm_run


001 struct kvm_run {
002  /* in */
003  __u8 request_interrupt_window;
004  __u8 padding1[7];
005  
006  /* out */
007  __u32 exit_reason;
008  __u8 ready_for_interrupt_injection;
009  __u8 if_flag;
010  __u8 padding2[2];
011  
012  /* in (pre_kvm_run), out (post_kvm_run) */
013  __u64 cr8;
014  __u64 apic_base;
015  
016 #ifdef __KVM_S390
017  /* the processor status word for s390 */
018  __u64 psw_mask; /* psw upper half */
019  __u64 psw_addr; /* psw lower half */
020 #endif
021  union {
022   /* KVM_EXIT_UNKNOWN */
023   struct {
024    __u64 hardware_exit_reason;
025   } hw;
026   /* KVM_EXIT_FAIL_ENTRY */
027   struct {
028    __u64 hardware_entry_failure_reason;
029   } fail_entry;
030   /* KVM_EXIT_EXCEPTION */
031   struct {
032    __u32 exception;
033    __u32 error_code;
034   } ex;
035   /* KVM_EXIT_IO */
036   struct {
037 #define KVM_EXIT_IO_IN  0
038 #define KVM_EXIT_IO_OUT 1
039    __u8 direction;
040    __u8 size; /* bytes */
041    __u16 port;
042    __u32 count;
043    __u64 data_offset; /* relative to kvm_run start */
044   } io;
045   struct {
046    struct kvm_debug_exit_arch arch;
047   } debug;
048   /* KVM_EXIT_MMIO */
049   struct {
050    __u64 phys_addr;
051    __u8  data[8];
052    __u32 len;
053    __u8  is_write;
054   } mmio;
055   /* KVM_EXIT_HYPERCALL */
056   struct {
057    __u64 nr;
058    __u64 args[6];
059    __u64 ret;
060    __u32 longmode;
061    __u32 pad;
062   } hypercall;
063   /* KVM_EXIT_TPR_ACCESS */
064   struct {
065    __u64 rip;
066    __u32 is_write;
067    __u32 pad;
068   } tpr_access;
069   /* KVM_EXIT_S390_SIEIC */
070   struct {
071    __u8 icptcode;
072    __u16 ipa;
073    __u32 ipb;
074   } s390_sieic;
075   /* KVM_EXIT_S390_RESET */
076 #define KVM_S390_RESET_POR       1
077 #define KVM_S390_RESET_CLEAR     2
078 #define KVM_S390_RESET_SUBSYSTEM 4
079 #define KVM_S390_RESET_CPU_INIT  8
080 #define KVM_S390_RESET_IPL       16
081   __u64 s390_reset_flags;
082   /* KVM_EXIT_S390_UCONTROL */
083   struct {
084    __u64 trans_exc_code;
085    __u32 pgm_code;
086   } s390_ucontrol;
087   /* KVM_EXIT_DCR */
088   struct {
089    __u32 dcrn;
090    __u32 data;
091    __u8  is_write;
092   } dcr;
093   struct {
094    __u32 suberror;
095    /* Available with KVM_CAP_INTERNAL_ERROR_DATA: */
096    __u32 ndata;
097    __u64 data[16];
098   } internal;
099   /* KVM_EXIT_OSI */
100   struct {
101    __u64 gprs[32];
102   } osi;
103   struct {
104    __u64 nr;
105    __u64 ret;
106    __u64 args[9];
107   } papr_hcall;
108   /* KVM_EXIT_S390_TSCH */
109   struct {
110    __u16 subchannel_id;
111    __u16 subchannel_nr;
112    __u32 io_int_parm;
113    __u32 io_int_word;
114    __u32 ipb;
115    __u8 dequeued;
116   } s390_tsch;
117   /* KVM_EXIT_EPR */
118   struct {
119    __u32 epr;
120   } epr;
121   /* Fix the size of the union. */
122   char padding[256];
123  };
124  
125  /*
126   * shared registers between kvm and userspace.
127   * kvm_valid_regs specifies the register classes set by the host
128   * kvm_dirty_regs specified the register classes dirtied by userspace
129   * struct kvm_sync_regs is architecture specific, as well as the
130   * bits for kvm_valid_regs and kvm_dirty_regs
131   */
132  __u64 kvm_valid_regs;
133  __u64 kvm_dirty_regs;
134  union {
135   struct kvm_sync_regs regs;
136   char padding[1024];
137  } s;
138 };

KVM Part



kvm_vcpu_ioctl(...)

001 static long kvm_vcpu_ioctl(struct file *filp,
002       unsigned int ioctl, unsigned long arg)
003 {
004  struct kvm_vcpu *vcpu = filp->private_data;
005  void __user *argp = (void __user *)arg;
006  int r;
007  struct kvm_fpu *fpu = NULL;
008  struct kvm_sregs *kvm_sregs = NULL;
009  
010  if (vcpu->kvm->mm != current->mm)
011   return -EIO;
012  
013 #if defined(CONFIG_S390) || defined(CONFIG_PPC) || defined(CONFIG_MIPS)
014  /*
015   * Special cases: vcpu ioctls that are asynchronous to vcpu execution,
016   * so vcpu_load() would break it.
017   */
018  if (ioctl == KVM_S390_INTERRUPT || ioctl == KVM_INTERRUPT)
019   return kvm_arch_vcpu_ioctl(filp, ioctl, arg);
020 #endif
021  
022  
023  r = vcpu_load(vcpu);
024  if (r)
025   return r;
026  switch (ioctl) {
027  case KVM_RUN:                             // KVM_RUN
028   r = kvm_arch_vcpu_ioctl_run(vcpu, vcpu->run);     // Actually, it will call function vcpu_enter_guest(kvm_vcpu *vcpu).
029   break;
030  case KVM_GET_REGS: {
031   struct kvm_regs *kvm_regs;
032  
033   r = -ENOMEM;
034   kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL);
035   r = kvm_arch_vcpu_ioctl_get_regs(vcpu, kvm_regs);
036   if (copy_to_user(argp, kvm_regs, sizeof(struct kvm_regs)))
037    goto out_free1;
038   r = 0;
039 out_free1:
040   kfree(kvm_regs);
041   break;
042  }
043  case KVM_SET_REGS: {                     // KVM_SET_REGS
044   struct kvm_regs *kvm_regs;
045  
046   kvm_regs = memdup_user(argp, sizeof(*kvm_regs));
047   r = kvm_arch_vcpu_ioctl_set_regs(vcpu, kvm_regs);
048   kfree(kvm_regs);
049   break;
050  }
051  case KVM_GET_SREGS: {                    // KVM_GET_SREGS
052   kvm_sregs = kzalloc(sizeof(struct kvm_sregs), GFP_KERNEL);
053   r = kvm_arch_vcpu_ioctl_get_sregs(vcpu, kvm_sregs);
054   if (copy_to_user(argp, kvm_sregs, sizeof(struct kvm_sregs)))
055    goto out;
056   r = 0;
057   break;
058  }
059  case KVM_SET_SREGS: {                   // KVM_SET_SREGS
060   kvm_sregs = memdup_user(argp, sizeof(*kvm_sregs));
061   r = kvm_arch_vcpu_ioctl_set_sregs(vcpu, kvm_sregs);
062   break;
063  }
064  case KVM_GET_MP_STATE: {                // KVM_GET_MP_STATE
065   struct kvm_mp_state mp_state;
066  
067   r = kvm_arch_vcpu_ioctl_get_mpstate(vcpu, &mp_state);
068   if (copy_to_user(argp, &mp_state, sizeof mp_state))
069    goto out;
070   r = 0;
071   break;
072  }
073  case KVM_SET_MP_STATE: {               // KVM_SET_MP_STATE
074   struct kvm_mp_state mp_state;
075  
076   if (copy_from_user(&mp_state, argp, sizeof mp_state))
077    goto out;
078   r = kvm_arch_vcpu_ioctl_set_mpstate(vcpu, &mp_state);
079   break;
080  }
081  case KVM_TRANSLATE: {                 // KVM_TRANSLATE
082   struct kvm_translation tr;
083  
084   if (copy_from_user(&tr, argp, sizeof tr))
085    goto out;
086   r = kvm_arch_vcpu_ioctl_translate(vcpu, &tr);
087    
088   if (copy_to_user(argp, &tr, sizeof tr))
089    goto out;
090   r = 0;
091   break;
092  }
093  case KVM_SET_GUEST_DEBUG: {           // KVM_SET_GUEST_DEBUG
094   struct kvm_guest_debug dbg;
095  
096   if (copy_from_user(&dbg, argp, sizeof dbg))
097    goto out;
098   r = kvm_arch_vcpu_ioctl_set_guest_debug(vcpu, &dbg);
099   break;
100  }
101  case KVM_SET_SIGNAL_MASK: {           // KVM_SET_SIGNAL_MASK
102   struct kvm_signal_mask __user *sigmask_arg = argp;
103   struct kvm_signal_mask kvm_sigmask;
104   sigset_t sigset, *p;
105  
106   p = NULL;
107   if (argp) {
108    r = -EFAULT;
109    if (copy_from_user(&kvm_sigmask, argp,
110         sizeof kvm_sigmask))
111     goto out;
112    r = -EINVAL;
113    if (kvm_sigmask.len != sizeof sigset)
114     goto out;
115    r = -EFAULT;
116    if (copy_from_user(&sigset, sigmask_arg->sigset,
117         sizeof sigset))
118     goto out;
119    p = &sigset;
120   }
121   r = kvm_vcpu_ioctl_set_sigmask(vcpu, p);
122   break;
123  }
124  case KVM_GET_FPU: {                     // KVM_GET_FPU
125   fpu = kzalloc(sizeof(struct kvm_fpu), GFP_KERNEL);
126   r = -ENOMEM;
127   r = kvm_arch_vcpu_ioctl_get_fpu(vcpu, fpu);
128   if (copy_to_user(argp, fpu, sizeof(struct kvm_fpu)))
129    goto out;
130   r = 0;
131   break;
132  }
133  case KVM_SET_FPU: {                     // KVM_SET_FPU
134   fpu = memdup_user(argp, sizeof(*fpu));
135    
136   r = kvm_arch_vcpu_ioctl_set_fpu(vcpu, fpu);
137   break;
138  }
139  default:
140   r = kvm_arch_vcpu_ioctl(filp, ioctl, arg);       // Default Handler
141                                                    // kvm_arch_vcpu_ioctl(...) can be found in the following
142  }
143 out:
144  vcpu_put(vcpu);
145  kfree(fpu);
146  kfree(kvm_sregs);
147  return r;
148 }

kvm_arch_vcpu_ioctl(filp, ioctl, arg)

001 long kvm_arch_vcpu_ioctl(struct file *filp,
002     unsigned int ioctl, unsigned long arg)
003 {
004  struct kvm_vcpu *vcpu = filp->private_data;
005  void __user *argp = (void __user *)arg;
006  int r;
007  union {
008   struct kvm_lapic_state *lapic;
009   struct kvm_xsave *xsave;
010   struct kvm_xcrs *xcrs;
011   void *buffer;
012  } u;
013  
014  u.buffer = NULL;
015  switch (ioctl) {
016  case KVM_GET_LAPIC: {                     // KVM_GET_LAPIC
017   r = -EINVAL;
018  
019   u.lapic = kzalloc(sizeof(struct kvm_lapic_state), GFP_KERNEL);
020  
021   r = -ENOMEM;
022    
023   r = kvm_vcpu_ioctl_get_lapic(vcpu, u.lapic);
024    
025   r = -EFAULT;
026   if (copy_to_user(argp, u.lapic, sizeof(struct kvm_lapic_state)))
027    goto out;
028   r = 0;
029   break;
030  }
031  case KVM_SET_LAPIC: {                     // KVM_SET_LAPIC
032   r = -EINVAL;
033    
034   u.lapic = memdup_user(argp, sizeof(*u.lapic));
035    
036  
037   r = kvm_vcpu_ioctl_set_lapic(vcpu, u.lapic);
038   break;
039  }
040  case KVM_INTERRUPT: {                     // KVM_INTERRUPT
041   struct kvm_interrupt irq;
042  
043   r = -EFAULT;
044   if (copy_from_user(&irq, argp, sizeof irq))
045    goto out;
046   r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
047   break;
048  }
049  case KVM_NMI: {                           // KVM_NMI
050   r = kvm_vcpu_ioctl_nmi(vcpu);
051   break;
052  }
053  case KVM_SET_CPUID: {                     // KVM_SET_CPUID
054   struct kvm_cpuid __user *cpuid_arg = argp;
055   struct kvm_cpuid cpuid;
056  
057   r = -EFAULT;
058   if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid))
059    goto out;
060   r = kvm_vcpu_ioctl_set_cpuid(vcpu, &cpuid, cpuid_arg->entries);
061   break;
062  }
063  case KVM_SET_CPUID2: {                    // KVM_SET_CPUID2
064   struct kvm_cpuid2 __user *cpuid_arg = argp;
065   struct kvm_cpuid2 cpuid;
066  
067   r = -EFAULT;
068   if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid))
069    goto out;
070   r = kvm_vcpu_ioctl_set_cpuid2(vcpu, &cpuid,
071            cpuid_arg->entries);
072   break;
073  }
074  case KVM_GET_CPUID2: {                                         // KVM_GET_CPUID2
075   struct kvm_cpuid2 __user *cpuid_arg = argp;
076   struct kvm_cpuid2 cpuid;
077  
078   r = -EFAULT;
079   if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid))
080    goto out;
081   r = kvm_vcpu_ioctl_get_cpuid2(vcpu, &cpuid,
082            cpuid_arg->entries);
083   if (r)
084    goto out;
085   r = -EFAULT;
086   if (copy_to_user(cpuid_arg, &cpuid, sizeof cpuid))
087    goto out;
088   r = 0;
089   break;
090  }
091  case KVM_GET_MSRS:                                             // KVM_GET_MSRS
092   r = msr_io(vcpu, argp, kvm_get_msr, 1);
093   break;
094  case KVM_SET_MSRS:                                             // KVM_SET_MSRS
095   r = msr_io(vcpu, argp, do_set_msr, 0);
096   break;
097  case KVM_TPR_ACCESS_REPORTING: {                               // KVM_TPR_ACCESS_PERORITING
098   struct kvm_tpr_access_ctl tac;
099  
100   r = -EFAULT;
101   if (copy_from_user(&tac, argp, sizeof tac))
102    goto out;
103   r = vcpu_ioctl_tpr_access_reporting(vcpu, &tac);
104   if (r)
105    goto out;
106   r = -EFAULT;
107   if (copy_to_user(argp, &tac, sizeof tac))
108    goto out;
109   r = 0;
110   break;
111  };
112  case KVM_SET_VAPIC_ADDR: {                                     // KVM_SET_VAPIC_ADDR
113   struct kvm_vapic_addr va;
114  
115   r = -EINVAL;
116   if (!irqchip_in_kernel(vcpu->kvm))
117    goto out;
118   r = -EFAULT;
119   if (copy_from_user(&va, argp, sizeof va))
120    goto out;
121   r = 0;
122   kvm_lapic_set_vapic_addr(vcpu, va.vapic_addr);
123   break;
124  }
125  case KVM_X86_SETUP_MCE: {                                       // KVM_X86_SETUP_MCE
126   u64 mcg_cap;
127  
128   r = -EFAULT;
129   if (copy_from_user(&mcg_cap, argp, sizeof mcg_cap))
130    goto out;
131   r = kvm_vcpu_ioctl_x86_setup_mce(vcpu, mcg_cap);
132   break;
133  }
134  case KVM_X86_SET_MCE: {                                         // KVM_x86_SET_MCE
135   struct kvm_x86_mce mce;
136  
137   r = -EFAULT;
138   if (copy_from_user(&mce, argp, sizeof mce))
139    goto out;
140   r = kvm_vcpu_ioctl_x86_set_mce(vcpu, &mce);
141   break;
142  }
143  case KVM_GET_VCPU_EVENTS: {                                     // KVM_GET_VCPU_EVENTS
144   struct kvm_vcpu_events events;
145  
146   kvm_vcpu_ioctl_x86_get_vcpu_events(vcpu, &events);
147  
148   r = -EFAULT;
149   if (copy_to_user(argp, &events, sizeof(struct kvm_vcpu_events)))
150    break;
151   r = 0;
152   break;
153  }
154  case KVM_SET_VCPU_EVENTS: {                                     // KVM_SET_VCPU_EVENTS
155   struct kvm_vcpu_events events;
156  
157   r = -EFAULT;
158   if (copy_from_user(&events, argp, sizeof(struct kvm_vcpu_events)))
159    break;
160  
161   r = kvm_vcpu_ioctl_x86_set_vcpu_events(vcpu, &events);
162   break;
163  }
164  case KVM_GET_DEBUGREGS: {                                       // KVM_GET_DEBUGERGS
165   struct kvm_debugregs dbgregs;
166  
167   kvm_vcpu_ioctl_x86_get_debugregs(vcpu, &dbgregs);
168  
169   r = -EFAULT;
170   if (copy_to_user(argp, &dbgregs,
171      sizeof(struct kvm_debugregs)))
172    break;
173   r = 0;
174   break;
175  }
176  case KVM_SET_DEBUGREGS: {                                      // KVM_SET_DEBUGERS
177   struct kvm_debugregs dbgregs;
178  
179   r = -EFAULT;
180   if (copy_from_user(&dbgregs, argp,
181        sizeof(struct kvm_debugregs)))
182    break;
183  
184   r = kvm_vcpu_ioctl_x86_set_debugregs(vcpu, &dbgregs);
185   break;
186  }
187  case KVM_GET_XSAVE: {                                         // KVM_GET_XSAVE
188   u.xsave = kzalloc(sizeof(struct kvm_xsave), GFP_KERNEL);
189   r = -ENOMEM;
190   if (!u.xsave)
191    break;
192  
193   kvm_vcpu_ioctl_x86_get_xsave(vcpu, u.xsave);
194  
195   r = -EFAULT;
196   if (copy_to_user(argp, u.xsave, sizeof(struct kvm_xsave)))
197    break;
198   r = 0;
199   break;
200  }
201  case KVM_SET_XSAVE: {                                        // KVM_SET_XSAVE
202   u.xsave = memdup_user(argp, sizeof(*u.xsave));
203   if (IS_ERR(u.xsave))
204    return PTR_ERR(u.xsave);
205  
206   r = kvm_vcpu_ioctl_x86_set_xsave(vcpu, u.xsave);
207   break;
208  }
209  case KVM_GET_XCRS: {                                         // KVM_GET_XCRS
210   u.xcrs = kzalloc(sizeof(struct kvm_xcrs), GFP_KERNEL);
211   r = -ENOMEM;
212   if (!u.xcrs)
213    break;
214  
215   kvm_vcpu_ioctl_x86_get_xcrs(vcpu, u.xcrs);
216  
217   r = -EFAULT;
218   if (copy_to_user(argp, u.xcrs,
219      sizeof(struct kvm_xcrs)))
220    break;
221   r = 0;
222   break;
223  }
224  case KVM_SET_XCRS: {                                        // KVM_SET_XCRS
225   u.xcrs = memdup_user(argp, sizeof(*u.xcrs));
226   if (IS_ERR(u.xcrs))
227    return PTR_ERR(u.xcrs);
228  
229   r = kvm_vcpu_ioctl_x86_set_xcrs(vcpu, u.xcrs);
230   break;
231  }
232  case KVM_SET_TSC_KHZ: {                                      // KVM_SET_TSC_KHZ
233   u32 user_tsc_khz;
234  
235   r = -EINVAL;
236   user_tsc_khz = (u32)arg;
237  
238   if (user_tsc_khz >= kvm_max_guest_tsc_khz)
239    goto out;
240  
241   if (user_tsc_khz == 0)
242    user_tsc_khz = tsc_khz;
243  
244   kvm_set_tsc_khz(vcpu, user_tsc_khz);
245  
246   r = 0;
247   goto out;
248  }
249  case KVM_GET_TSC_KHZ: {                                    // KVM_GET_TSC_KHZ
250   r = vcpu->arch.virtual_tsc_khz;
251   goto out;
252  }
253  case KVM_KVMCLOCK_CTRL: {                                  // KVM_KVMCLOCK_CTRL
254   r = kvm_set_guest_paused(vcpu);
255   goto out;
256  }
257  default:                                                   // Default: Error
258   r = -EINVAL;
259  }
260 out:
261  kfree(u.buffer);
262  return r;
263 }

vcpu_enter_guest(kvm_vcpu *vcpu)

001 static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
002 {
003  int r;
004  bool req_int_win = !irqchip_in_kernel(vcpu->kvm) &&
005   vcpu->run->request_interrupt_window;
006  bool req_immediate_exit = false;
007  
008  if (vcpu->requests) {                                      // Check if there is any requests which are not handled.
009   if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu))
010    kvm_mmu_unload(vcpu);
011   if (kvm_check_request(KVM_REQ_MIGRATE_TIMER, vcpu))
012    __kvm_migrate_timers(vcpu);
013   if (kvm_check_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu))
014    kvm_gen_update_masterclock(vcpu->kvm);
015   if (kvm_check_request(KVM_REQ_GLOBAL_CLOCK_UPDATE, vcpu))
016    kvm_gen_kvmclock_update(vcpu);
017   if (kvm_check_request(KVM_REQ_CLOCK_UPDATE, vcpu)) {
018    r = kvm_guest_time_update(vcpu);
019    if (unlikely(r))
020     goto out;
021   }
022   if (kvm_check_request(KVM_REQ_MMU_SYNC, vcpu))
023    kvm_mmu_sync_roots(vcpu);
024   if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu))
025    kvm_x86_ops->tlb_flush(vcpu);
026   if (kvm_check_request(KVM_REQ_REPORT_TPR_ACCESS, vcpu)) {
027    vcpu->run->exit_reason = KVM_EXIT_TPR_ACCESS;
028    r = 0;
029    goto out;
030   }
031   if (kvm_check_request(KVM_REQ_TRIPLE_FAULT, vcpu)) {
032    vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
033    r = 0;
034    goto out;
035   }
036   if (kvm_check_request(KVM_REQ_DEACTIVATE_FPU, vcpu)) {
037    vcpu->fpu_active = 0;
038    kvm_x86_ops->fpu_deactivate(vcpu);
039   }
040   if (kvm_check_request(KVM_REQ_APF_HALT, vcpu)) {
041    /* Page is swapped out. Do synthetic halt */
042    vcpu->arch.apf.halted = true;
043    r = 1;
044    goto out;
045   }
046   if (kvm_check_request(KVM_REQ_STEAL_UPDATE, vcpu))
047    record_steal_time(vcpu);
048   if (kvm_check_request(KVM_REQ_NMI, vcpu))
049    process_nmi(vcpu);
050   if (kvm_check_request(KVM_REQ_PMU, vcpu))
051    kvm_handle_pmu_event(vcpu);
052   if (kvm_check_request(KVM_REQ_PMI, vcpu))
053    kvm_deliver_pmi(vcpu);
054   if (kvm_check_request(KVM_REQ_SCAN_IOAPIC, vcpu))
055    vcpu_scan_ioapic(vcpu);
056  }
057  
058  if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win) {             // Check if inject an event?
059   kvm_apic_accept_events(vcpu);
060   if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
061    r = 1;
062    goto out;
063   }
064  
065   inject_pending_event(vcpu);
066  
067   /* enable NMI/IRQ window open exits if needed */
068   if (vcpu->arch.nmi_pending)
069    req_immediate_exit =
070     kvm_x86_ops->enable_nmi_window(vcpu) != 0;
071   else if (kvm_cpu_has_injectable_intr(vcpu) || req_int_win)
072    req_immediate_exit =
073     kvm_x86_ops->enable_irq_window(vcpu) != 0;
074  
075   if (kvm_lapic_enabled(vcpu)) {
076    /*
077     * Update architecture specific hints for APIC
078     * virtual interrupt delivery.
079     */
080    if (kvm_x86_ops->hwapic_irr_update)
081     kvm_x86_ops->hwapic_irr_update(vcpu,
082      kvm_lapic_find_highest_irr(vcpu));
083    update_cr8_intercept(vcpu);
084    kvm_lapic_sync_to_vapic(vcpu);
085   }
086  }
087  
088  r = kvm_mmu_reload(vcpu);                   // Load VM memory page table
089  if (unlikely(r)) {
090   goto cancel_injection;
091  }
092  
093  preempt_disable();                          // Set preemption disable
094  
095  kvm_x86_ops->prepare_guest_switch(vcpu);    // Actually, kvm_x86_ops->vmx_save_host_state(). Save host machine state including fs and gs segment selector
096  if (vcpu->fpu_active)
097   kvm_load_guest_fpu(vcpu);
098  kvm_load_guest_xcr0(vcpu);                  // Check CR4.OSXSAVE feature.
099  
100  vcpu->mode = IN_GUEST_MODE;
101  
102  /* We should set ->mode before check ->requests,
103   * see the comment in make_all_cpus_request.
104   */
105  smp_mb();                                   // Guess: this is used to lock other CPU in order to force strict CPU ordering
106  
107  local_irq_disable();                        // Finally, it will executes native_irq_disable() = CLI instruction
108  
109  if (vcpu->mode == EXITING_GUEST_MODE || vcpu->requests
110      || need_resched() || signal_pending(current)) {
111   vcpu->mode = OUTSIDE_GUEST_MODE;
112   smp_wmb();
113   local_irq_enable();
114   preempt_enable();
115   r = 1;
116   goto cancel_injection;
117  }
118  
119  srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);  // RCU is a synchronization mechanism added to linux kernel during 2.5
120  
121  if (req_immediate_exit)
122   smp_send_reschedule(vcpu->cpu);
123  
124  kvm_guest_enter();                                   // Guess: this is RCU and scheduling related.
125  
126  if (unlikely(vcpu->arch.switch_db_regs)) {
127   set_debugreg(0, 7);
128   set_debugreg(vcpu->arch.eff_db[0], 0);
129   set_debugreg(vcpu->arch.eff_db[1], 1);
130   set_debugreg(vcpu->arch.eff_db[2], 2);
131   set_debugreg(vcpu->arch.eff_db[3], 3);
132  }
133  
134  trace_kvm_entry(vcpu->vcpu_id);
135  kvm_x86_ops->run(vcpu);                            //
136  
137  /*
138   * If the guest has used debug registers, at least dr7
139   * will be disabled while returning to the host.
140   * If we don't have active breakpoints in the host, we don't
141   * care about the messed up debug address registers. But if
142   * we have some of them active, restore the old state.
143   */
144  if (hw_breakpoint_active())
145   hw_breakpoint_restore();
146  
147  vcpu->arch.last_guest_tsc = kvm_x86_ops->read_l1_tsc(vcpu,
148           native_read_tsc());
149  
150  vcpu->mode = OUTSIDE_GUEST_MODE;
151  smp_wmb();
152  
153  /* Interrupt is enabled by handle_external_intr() */
154  kvm_x86_ops->handle_external_intr(vcpu);
155  
156  ++vcpu->stat.exits;
157  
158  /*
159   * We must have an instruction between local_irq_enable() and
160   * kvm_guest_exit(), so the timer interrupt isn't delayed by
161   * the interrupt shadow.  The stat.exits increment will do nicely.
162   * But we need to prevent reordering, hence this barrier():
163   */
164  barrier();
165  
166  kvm_guest_exit();
167  
168  preempt_enable();
169  
170  vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
171  
172  /*
173   * Profile KVM exit RIPs:
174   */
175  if (unlikely(prof_on == KVM_PROFILING)) {
176   unsigned long rip = kvm_rip_read(vcpu);
177   profile_hit(KVM_PROFILING, (void *)rip);
178  }
179  
180  if (unlikely(vcpu->arch.tsc_always_catchup))
181   kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
182  
183  if (vcpu->arch.apic_attention)
184   kvm_lapic_sync_from_vapic(vcpu);
185  
186  r = kvm_x86_ops->handle_exit(vcpu);
187  return r;
188  
189 cancel_injection:
190  kvm_x86_ops->cancel_injection(vcpu);
191  if (unlikely(vcpu->arch.apic_attention))
192   kvm_lapic_sync_from_vapic(vcpu);
193 out:
194  return r;
195 }

vmx_vcpu_run( kvm_vcpu *vcpu)

001 static void __noclone vmx_vcpu_run(struct kvm_vcpu *vcpu)
002 {
003  struct vcpu_vmx *vmx = to_vmx(vcpu);
004  unsigned long debugctlmsr;
005  
006  /* Record the guest's net vcpu time for enforced NMI injections. */
007  if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked))
008   vmx->entry_time = ktime_get();
009  
010  /* Don't enter VMX if guest state is invalid, let the exit handler
011     start emulation until we arrive back to a valid state */
012  if (vmx->emulation_required)
013   return;
014  
015  if (vmx->nested.sync_shadow_vmcs) {
016   copy_vmcs12_to_shadow(vmx);
017   vmx->nested.sync_shadow_vmcs = false;
018  }
019  
020  if (test_bit(VCPU_REGS_RSP, (unsigned long *)&vcpu->arch.regs_dirty))
021   vmcs_writel(GUEST_RSP, vcpu->arch.regs[VCPU_REGS_RSP]);
022  if (test_bit(VCPU_REGS_RIP, (unsigned long *)&vcpu->arch.regs_dirty))
023   vmcs_writel(GUEST_RIP, vcpu->arch.regs[VCPU_REGS_RIP]);
024  
025  /* When single-stepping over STI and MOV SS, we must clear the
026   * corresponding interruptibility bits in the guest state. Otherwise
027   * vmentry fails as it then expects bit 14 (BS) in pending debug
028   * exceptions being set, but that's not correct for the guest debugging
029   * case. */
030  if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
031   vmx_set_interrupt_shadow(vcpu, 0);
032  
033  atomic_switch_perf_msrs(vmx);
034  debugctlmsr = get_debugctlmsr();
035  
036  vmx->__launched = vmx->loaded_vmcs->launched;
037  asm(
038   /* Store host registers */
039   "push %%" _ASM_DX "; push %%" _ASM_BP ";"
040   "push %%" _ASM_CX " \n\t" /* placeholder for guest rcx */
041   "push %%" _ASM_CX " \n\t"
042   "cmp %%" _ASM_SP ", %c[host_rsp](%0) \n\t"
043   "je 1f \n\t"
044   "mov %%" _ASM_SP ", %c[host_rsp](%0) \n\t"
045   __ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t"
046   "1: \n\t"
047   /* Reload cr2 if changed */
048   "mov %c[cr2](%0), %%" _ASM_AX " \n\t"
049   "mov %%cr2, %%" _ASM_DX " \n\t"
050   "cmp %%" _ASM_AX ", %%" _ASM_DX " \n\t"
051   "je 2f \n\t"
052   "mov %%" _ASM_AX", %%cr2 \n\t"
053   "2: \n\t"
054   /* Check if vmlaunch of vmresume is needed */
055   "cmpl $0, %c[launched](%0) \n\t"
056   /* Load guest registers.  Don't clobber flags. */
057   "mov %c[rax](%0), %%" _ASM_AX " \n\t"
058   "mov %c[rbx](%0), %%" _ASM_BX " \n\t"
059   "mov %c[rdx](%0), %%" _ASM_DX " \n\t"
060   "mov %c[rsi](%0), %%" _ASM_SI " \n\t"
061   "mov %c[rdi](%0), %%" _ASM_DI " \n\t"
062   "mov %c[rbp](%0), %%" _ASM_BP " \n\t"
063 #ifdef CONFIG_X86_64
064   "mov %c[r8](%0),  %%r8  \n\t"
065   "mov %c[r9](%0),  %%r9  \n\t"
066   "mov %c[r10](%0), %%r10 \n\t"
067   "mov %c[r11](%0), %%r11 \n\t"
068   "mov %c[r12](%0), %%r12 \n\t"
069   "mov %c[r13](%0), %%r13 \n\t"
070   "mov %c[r14](%0), %%r14 \n\t"
071   "mov %c[r15](%0), %%r15 \n\t"
072 #endif
073   "mov %c[rcx](%0), %%" _ASM_CX " \n\t" /* kills %0 (ecx) */
074  
075   /* Enter guest mode */
076   "jne 1f \n\t"
077   __ex(ASM_VMX_VMLAUNCH) "\n\t"
078   "jmp 2f \n\t"
079   "1: " __ex(ASM_VMX_VMRESUME) "\n\t"
080   "2: "
081   /* Save guest registers, load host registers, keep flags */
082   "mov %0, %c[wordsize](%%" _ASM_SP ") \n\t"
083   "pop %0 \n\t"
084   "mov %%" _ASM_AX ", %c[rax](%0) \n\t"
085   "mov %%" _ASM_BX ", %c[rbx](%0) \n\t"
086   __ASM_SIZE(pop) " %c[rcx](%0) \n\t"
087   "mov %%" _ASM_DX ", %c[rdx](%0) \n\t"
088   "mov %%" _ASM_SI ", %c[rsi](%0) \n\t"
089   "mov %%" _ASM_DI ", %c[rdi](%0) \n\t"
090   "mov %%" _ASM_BP ", %c[rbp](%0) \n\t"
091 #ifdef CONFIG_X86_64
092   "mov %%r8,  %c[r8](%0) \n\t"
093   "mov %%r9,  %c[r9](%0) \n\t"
094   "mov %%r10, %c[r10](%0) \n\t"
095   "mov %%r11, %c[r11](%0) \n\t"
096   "mov %%r12, %c[r12](%0) \n\t"
097   "mov %%r13, %c[r13](%0) \n\t"
098   "mov %%r14, %c[r14](%0) \n\t"
099   "mov %%r15, %c[r15](%0) \n\t"
100 #endif
101   "mov %%cr2, %%" _ASM_AX "   \n\t"
102   "mov %%" _ASM_AX ", %c[cr2](%0) \n\t"
103  
104   "pop  %%" _ASM_BP "; pop  %%" _ASM_DX " \n\t"
105   "setbe %c[fail](%0) \n\t"
106   ".pushsection .rodata \n\t"
107   ".global vmx_return \n\t"
108   "vmx_return: " _ASM_PTR " 2b \n\t"
109   ".popsection"
110        : : "c"(vmx), "d"((unsigned long)HOST_RSP),
111   [launched]"i"(offsetof(struct vcpu_vmx, __launched)),
112   [fail]"i"(offsetof(struct vcpu_vmx, fail)),
113   [host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)),
114   [rax]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RAX])),
115   [rbx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBX])),
116   [rcx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RCX])),
117   [rdx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDX])),
118   [rsi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RSI])),
119   [rdi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDI])),
120   [rbp]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBP])),
121 #ifdef CONFIG_X86_64
122   [r8]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R8])),
123   [r9]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R9])),
124   [r10]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R10])),
125   [r11]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R11])),
126   [r12]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R12])),
127   [r13]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R13])),
128   [r14]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R14])),
129   [r15]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R15])),
130 #endif
131   [cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2)),
132   [wordsize]"i"(sizeof(ulong))
133        "cc""memory"
134 #ifdef CONFIG_X86_64
135   "rax""rbx""rdi""rsi"
136   "r8""r9""r10""r11""r12""r13""r14""r15"
137 #else
138   "eax""ebx""edi""esi"
139 #endif
140        );
141  
142  /* MSR_IA32_DEBUGCTLMSR is zeroed on vmexit. Restore it if needed */
143  if (debugctlmsr)
144   update_debugctlmsr(debugctlmsr);
145  
146 #ifndef CONFIG_X86_64
147  /*
148   * The sysexit path does not restore ds/es, so we must set them to
149   * a reasonable value ourselves.
150   *
151   * We can't defer this to vmx_load_host_state() since that function
152   * may be executed in interrupt context, which saves and restore segments
153   * around it, nullifying its effect.
154   */
155  loadsegment(ds, __USER_DS);
156  loadsegment(es, __USER_DS);
157 #endif
158  
159  vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP)
160       | (1 << VCPU_EXREG_RFLAGS)
161       | (1 << VCPU_EXREG_CPL)
162       | (1 << VCPU_EXREG_PDPTR)
163       | (1 << VCPU_EXREG_SEGMENTS)
164       | (1 << VCPU_EXREG_CR3));
165  vcpu->arch.regs_dirty = 0;
166  
167  vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD);
168  
169  vmx->loaded_vmcs->launched = 1;
170  
171  vmx->exit_reason = vmcs_read32(VM_EXIT_REASON);
172  trace_kvm_exit(vmx->exit_reason, vcpu, KVM_ISA_VMX);
173  
174  vmx_complete_atomic_exit(vmx);
175  vmx_recover_nmi_blocking(vmx);
176  vmx_complete_interrupts(vmx);
177 }

vmx_handle_exit()

1  

static int (*const kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu)

view sourceprint?
01 static int (*const kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
02  [EXIT_REASON_EXCEPTION_NMI]           = handle_exception,
03  [EXIT_REASON_EXTERNAL_INTERRUPT]      = handle_external_interrupt,
04  [EXIT_REASON_TRIPLE_FAULT]            = handle_triple_fault,
05  [EXIT_REASON_NMI_WINDOW]       = handle_nmi_window,
06  [EXIT_REASON_IO_INSTRUCTION]          = handle_io,
07  [EXIT_REASON_CR_ACCESS]               = handle_cr,
08  [EXIT_REASON_DR_ACCESS]               = handle_dr,
09  [EXIT_REASON_CPUID]                   = handle_cpuid,
10  [EXIT_REASON_MSR_READ]                = handle_rdmsr,
11  [EXIT_REASON_MSR_WRITE]               = handle_wrmsr,
12  [EXIT_REASON_PENDING_INTERRUPT]       = handle_interrupt_window,
13  [EXIT_REASON_HLT]                     = handle_halt,
14  [EXIT_REASON_INVD]        = handle_invd,
15  [EXIT_REASON_INVLPG]        = handle_invlpg,
16  [EXIT_REASON_RDPMC]                   = handle_rdpmc,
17  [EXIT_REASON_VMCALL]                  = handle_vmcall,
18  [EXIT_REASON_VMCLEAR]               = handle_vmclear,
19  [EXIT_REASON_VMLAUNCH]                = handle_vmlaunch,
20  [EXIT_REASON_VMPTRLD]                 = handle_vmptrld,
21  [EXIT_REASON_VMPTRST]                 = handle_vmptrst,
22  [EXIT_REASON_VMREAD]                  = handle_vmread,
23  [EXIT_REASON_VMRESUME]                = handle_vmresume,
24  [EXIT_REASON_VMWRITE]                 = handle_vmwrite,
25  [EXIT_REASON_VMOFF]                   = handle_vmoff,
26  [EXIT_REASON_VMON]                    = handle_vmon,
27  [EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold,
28  [EXIT_REASON_APIC_ACCESS]             = handle_apic_access,
29  [EXIT_REASON_APIC_WRITE]              = handle_apic_write,
30  [EXIT_REASON_EOI_INDUCED]             = handle_apic_eoi_induced,
31  [EXIT_REASON_WBINVD]                  = handle_wbinvd,
32  [EXIT_REASON_XSETBV]                  = handle_xsetbv,
33  [EXIT_REASON_TASK_SWITCH]             = handle_task_switch,
34  [EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,
35  [EXIT_REASON_EPT_VIOLATION]       = handle_ept_violation,
36  [EXIT_REASON_EPT_MISCONFIG]           = handle_ept_misconfig,
37  [EXIT_REASON_PAUSE_INSTRUCTION]       = handle_pause,
38  [EXIT_REASON_MWAIT_INSTRUCTION]       = handle_invalid_op,
39  [EXIT_REASON_MONITOR_INSTRUCTION]     = handle_invalid_op,
40  [EXIT_REASON_INVEPT]                  = handle_invept,
41 };

QEMU Source Code Notes

Here’s some of my badly organized notes while reading QEMU’s source code. These notes only cover some small parts of QEMU.

I’ll update this note when I encounter any of the following situations:

  • The implementation of some specific part is complicated
  • I forget something I understand previously

I find pictures are easier to follow, and use LucidChart as my drawing tool. (I find LucidChart most easier to use for me.) But I haven’t found a satisfactory way to represent the logic of code in graph. I’ve tried various forms of graphs, like plain flowcharts, UML sequence diagram. So the style of my picture is not consistent, sorry for that.

CPU emulation

CPU initialization

The CPU initialization process is illustrated in the following picture.

CPU emulation thread

Starting from QEMU 1.0, all emulated CPUs run in a single thread. Here’s an overview of what this thread is doing.

Emulated Memory

Emulated memory allocation

Note the following description applies to QEMU 0.13. It’s changed in QEMU 1.0.

The following picture is an overview of how is emulated main memory allocated.

Let’s look into how the main memory is allocated in QEMU. In hw/pc_piix.cpc_init1 is initialize the whole PC, it calls pc_memory_init to allocate emulated memory. The memory is actually allocated by qemu_ram_alloc which is called in pc_memory_init.

QEMU needs to emulated many kinds of devices, each kind of device needs there own memory, e.g. RAM, BIOS, VGA. QEMU uses a list to manage all the allocated device memory.

In qemu_ram_alloc, it allocates a new RAMBlock node, which records:

  • host the actual host memory (in QEMU)
  • length the size of this memory region
  • offset the ram_addr (more details following)

To support pluggable device, emulated memory needs to be releasable. This means the same guest physical memory address (guest is the emulated target) may refer to different devices, thus different host memory. I guess this is why QEMU creates an indirection between guest physical memory address and host memory, which is ram_addr. (I’m not sure about this because I don’t see problems of directly mapping from guest physical memory to host memory.)

ram_addr is allocated when memory is allocated. Using ram_list, it’s possible to convert between ram_addr and host address. There are many places in the softmmu system uses this ram_addr to refer to the allocated memory.

After memory is allocated, it needs to be registered by calling cpu_register_physical_memory_offset so that the softmmu system knows how to access it (use IO function or memory read/write function). To register memory, we need to specify which guest physical memory range does the allocated memory represent. To accelerate the process of finding ram_addr from guest physical memory (which is used in functions like ldl_phys), the register function will set up a data structure which is very similar to the page table, l1_phys_map. (TODO: more details)

Softmmu

The softmmu emulation uses C macro to emulated template system. There are several template head files which are included in other files multiple times to generate functions that work for different sized memory and functions to access guest memory with different privileges.

The following picture shows the including relationship between the related files.

IRQState and related function

There are 2 types of hardware IRQ:

  • Triggered if the electronic level is high (level sensitive)
  • Triggered if the electronic incurs a pulse (edge triggered)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* in hw/irq.h */

typedef void (*qemu_irq_handler)(void *opaque, int n, int level);

/* in hw/irq.c */
struct IRQState {    qemu_irq_handler handler;
    void *opaque;
    int n;
}
/* qemu-common.h typedef struct IRQState *qemu_irq */

void qemu_set_irq(qemu_irq irq, int level)
{    if (!irq)
        return;

    irq->handler(irq->opaque, irq->n, level);
}

In hw/irq.cqemu_irq_set calls the irq handler stored in IRQStateqemu_irq_raiseqemu_irq_lower and qemu_irq_pulse simply calls qemu_irq_set to adjust the level of the IRQ.

qemu_allocate_irqs will allocate memory for several qemu_irq, each pointing to new allocated IRQState, but all with the same handler and opaque value.

i8254 as an example

TODO

Timer

I’m not very familiar with x86 hardware, the description related to hardware is very likely to be wrong.

Host alarm

On x86, both main board and cpu cores have timer. I call the main board timer host alarm, which corresponds to PIT timer. More specifically, qemu emulates i8254 timer attached to i8259 interrupt controller.

QEMUTimer

In pit_init, it creates a QEMUTimer whose callback is pit_irq_timer. The definition for QEMUTimer is:

1
2
3
4
5
6
7
struct QEMUTimer {  QEMUClock *clock;
  int64_t expire_time;
  QEMUTimerCB *cb;
  void *opaque;
  struct QEMUTimer *next;
};

The clock type for pit timer is vm_clock, which only runs when the vm runs. (There are also rt_clock and host_clock, the difference is commented in qemu-timer.h.) The timer should be put onto the active_timers list (using qemu_mod_timer) in order to run. main_loop_wait will call qemu_run_all_timers which will then invoke all expired timers’ (with expire time > current time) callbacks.

QEMUTimer only describes when the callback should be called. As QEMU uses block chaining, virtual cpu may execute lots of translated code and does not run timer callback as soon as possible. So it uses alarm timer (introduced later) to avoid waiting too long before handling timer interrupt.

Timer IRQ handler

When the timer fires, it should send an interrupt to the CPU. This is done through the timer irq handler.

In pit_initfn, a new QEMUTimer is created, and an irq handler is acquired from

The irq passed to pit_init needs explanation. Here’s the initialization function calls:

pc_init1 (pc_iiix.c):isa_irq = qemu_allocate_irqs(isa_irq_handler, …);...pc_basic_device_init(isa_irq, …);pc_basic_device_init (pc.c):pit = pit_init(0x40, isa_reserve_irq(0));

Here, the reserved irq 0’s handler is allocated in pc_init1, so the handler is isa_irq_handler, which actually calls i8259_set_irq.

i8259’s parent irq is cpu irq, whose handler function is pic_irq_request, which will modify CPUState’s interrupt_request field which finally delivers the irq to the virtual cpu.

Alarm timer

To periodically notify the cpu, interval timer is provided by qemu_alarm_timer:

struct qemu_alarm_timer {char const *name;int (*start)(struct qemu_alarm_timer *t);void (*stop)(struct qemu_alarm_timer *t);void (*rearm)(struct qemu_alarm_timer *t);void *priv;char expired;char pending;
};

On different system, the alarm timer can use different mechanism to implement. On Linux, it is implemented using timer_create(CLOCK_REALTIME) and is named “dynticks”. (Other alarm timer can be “hpet”, “rtc”, “unix”.)

Each time the alarm timer fires, a signal will be sent. The signal handler will set the alarm timer’s pending field if it is expired, so we know it’s fired and can rearm it later. The most important thing is to notify the cpu, so they will stop executing translated code and handler timer as soon as possible.

Module inrastructure

The module infrastructure provides easy initialization for device, machine and other components in QEMU. The following description using QEMU v1.0.1.

Types of modules:

  • block
  • device
  • machine
  • qapi

In module.h, the module_init macro generates a function with constructor attribute, this function will register module initialization function. Each type modules has a corresponding macro to invoke this macro with the module type specified.

1
2
3
4
5
6
7
8
9
#define module_init(function, type)                                         \
static void __attribute__((constructor)) do_qemu_init_ ## function(void) {  \
    register_module_init(function, type);                                   \
}

#define block_init(function) module_init(function, MODULE_INIT_BLOCK)
#define device_init(function) module_init(function, MODULE_INIT_DEVICE)
#define machine_init(function) module_init(function, MODULE_INIT_MACHINE)
#define qapi_init(function) module_init(function, MODULE_INIT_QAPI)

Take the i8254 timer as an example

1
2
3
4
5
6
7
8
9
10
11
/* In hw/i8254.c */
static void pit_register(void)
{    isa_qdev_register(&pit_info);
}
device_init(pit_register)

/* Generated function after macro expansion. */
static void __attribute__((constructor)) do_qemu_init_pit_register(void) {    register_module_init(pit_register, MODULE_INIT_DEVICE);
}

Each module has a list holding all the initialization function pointer, register_module_init will find the corresponding list, then add the function pointer to the end of the list.

When is the initialization function called?

module_call_init will get the specified module’s initialization functions list and invoke the function one by one. Simply grep this function can find the calling site. Here’s a list:

  • vl.c: module_call_init(MODULE_INIT_MACHINE)
  • vl.c: module_call_init(MODULE_INIT_DEVICE)
  • block.c: module_call_init(MODULE_INIT_BLOCK)
  • qemu-ga.c: module_call_init(MODULE_INIT_QAPI)

Coroutine in QEMU

Learning the coroutine concept

I recommend Simon Tatham’s article Coroutines in C

The key is to provide a way for a function to ‘return and continue’. By continue it means starts executing at the same point when it “returns” upon next call.

QEMU’s implementation

Commit 00dccaf1f848 introduces coroutine, here’s the commit message

coroutine: introduce coroutinesAsynchronous code is becoming very complex.  At the same time
synchronous code is growing because it is convenient to write.
Sometimes duplicate code paths are even added, one synchronous and the
other asynchronous.  This patch introduces coroutines which allow code
that looks synchronous but is asynchronous under the covers.A coroutine has its own stack and is therefore able to preserve state
across blocking operations, which traditionally require callback
functions and manual marshalling of parameters.Creating and starting a coroutine is easy:coroutine = qemu_coroutine_create(my_coroutine);qemu_coroutine_enter(coroutine, my_data);The coroutine then executes until it returns or yields:void coroutine_fn my_coroutine(void *opaque) {MyData *my_data = opaque;/* do some work */qemu_coroutine_yield();/* do some more work */}Yielding switches control back to the caller of qemu_coroutine_enter().
This is typically used to switch back to the main thread's event loop
after issuing an asynchronous I/O request.  The request callback will
then invoke qemu_coroutine_enter() once more to switch back to the
coroutine.Note that if coroutines are used only from threads which hold the global
mutex they will never execute concurrently.  This makes programming with
coroutines easier than with threads.  Race conditions cannot occur since
only one coroutine may be active at any time.  Other coroutines can only
run across yield.This coroutines implementation is based on the gtk-vnc implementation
written by Anthony Liguori <anthony@codemonkey.ws> but it has been
significantly rewritten by Kevin Wolf <kwolf@redhat.com> to use
setjmp()/longjmp() instead of the more expensive swapcontext() and by
Paolo Bonzini <pbonzini@redhat.com> for Windows Fibers support.
  • On Debian Linux 6, makecontext is defined, so coroutine-ucontext.c is used to provide coroutine implementatoin

The coroutine implementation in QEMU is quite complicated. Here’s a graph showing the relationship between the related functions.

TCG related

A useful debugging technique to pass state in translated code to outside is to store the information in global variable. This out be helpful for debugging purpose and ugly hacking.

TODO

IO port emulation

All IO port related devices for PC emulation

Format: device address comment

  • vmport 0x5658 (hw/vmport.c)
  • firmware 0x511 (hw/fw_cfg.c)
  • i8259 0x20,0x4d0,0xa0,0x4d1 Programmable Interrupt Controller (hw/i8259.c)
  • i440FX/PIIX3 PCI Bridge 0xcf8, 0xcfc (hw/piix_pci.c)
  • Cirrus VGA emulator 0x3c0, 0x3b4, 0x3d4, 0x3ba, 0x3da (hw/cirrus_vga.c)
  • RTC emulation 0x70 (hw/mc146818rtc.c)
  • i8254 interval timer 0x40 (hw/i8254.c)
  • PC speaker 0x61 (`hw/pcspk.c)
  • UART 0x3f8 (hw/serial.c)
  • Parallel PORT 0x378 (hw/parallel.c)
  • PC keyboard 0x60, 0x64 (hw/pckbd.c)
  • Port 92 0x92 (hw/pc.c)
  • DMA 0x0~0xf,0x81~0x83,0x87,0x89,0x8a,0x8b,0x8f,0xc0~0xce/2,0xd0,0xd2~0xde/2 (hw/dma.c)
  • Floppy disk 0x3f1,0x3f7 (hw/fdc.c)
  • IDE 0x1f0,0x170,0x3f6,0x376 (hw/ide/core.c)
  • ACPI 0xb2,0xb100,0xafe0,0xae00,0xae08 (hw/acpi_piix4.c)
  • IDE PCI PIIX ¾ 0xc000,0xc004,0xc008,0xc00c (hw/ide/piix.c dmdma_map)
  • Unknown 0xb000 (while executing TC, registers ioport_readx)

KVM 虚拟化原理探究--启动过程及各部分虚拟化原理相关推荐

  1. KVM 虚拟化原理探究(5)— 网络IO虚拟化

    2019独角兽企业重金招聘Python工程师标准>>> IO 虚拟化简介 前面的文章介绍了KVM的启动过程,CPU虚拟化,内存虚拟化原理.作为一个完整的风诺依曼计算机系统,必然有输入 ...

  2. Linux X Window System运行原理和启动过程

    本文主要说明X Window System的基本运行原理,其启动过程,及常见的跨网络运行X Window System. 一) 基本运行原理 X Window System采用C/S结构,但和我们常见 ...

  3. hive底层原理 sql执行过程_Hive mapreduce SQL实现原理——SQL最终分解为MR任务,而group by在MR里和单词统计MR没有区别了-阿里云开发者社区...

    转自:http://blog.csdn.net/sn_zzy/article/details/43446027 SQL转化为MapReduce的过程 了解了MapReduce实现SQL基本操作之后,我 ...

  4. [20160229]探究oracle的启动过程.txt

    [20160229]探究oracle的启动过程.txt --昨天自己研究了sys.bootstrap$,链接http://blog.itpub.net/267265/viewspace-2016219 ...

  5. linux 启动过程

    Linux 启动过程详解 下面来详细了解一下 Linux 的启动过程.     Linux 的启动 过程包含了 Linux 工作原理的精髓,      而且在嵌入式的开发过程也非常需要这方面知识的积累 ...

  6. [原] KVM 虚拟化原理探究(6)— 块设备IO虚拟化

    目录 KVM 虚拟化原理探究(6)- 块设备IO虚拟化 块设备IO虚拟化简介 传统块设备架构 块设备IO协议栈 块设备IO流程 块设备IO虚拟化 总结 KVM 虚拟化原理探究(6)- 块设备IO虚拟化 ...

  7. kvm 监控内存,替换页表(linux版的win VT晶核)(这个整复杂了,不用小内核也可以实现,留着吧,主要记录了bootLoad的启动过程)

    kvm 监控内存,替换页表等问题 一.如何利用kvm 监控整个linux系统 不过kvm似乎只能监控自己的虚拟机,自己的主机监控不了.那么,只能利用kvm重新启动linux内核.kvm启动可以简化为小 ...

  8. linux efi 启动原理,Linux系统启动过程

    了解Linux系统的启动过程有助于我们深入理解Linux系统运行原理,下面我们将介绍一些系统启动过程中一些重要的细节.在这里,我们将Linux系统启动过程分成7个步骤介绍,这个过程如下图所示. 1.启 ...

  9. Android系统在新进程中启动自定义服务过程(startService)的原理分析 (下)

    Step 10. ActivityManagerService.attachApplicationLocked 这个函数定义在frameworks/base/services/java/com/and ...

最新文章

  1. 用DataBindings属性绑定控件的值
  2. java 远程调试超时_java 远程调试
  3. 将本地win10作为web服务器
  4. Oracle bbed 五个 实用示例
  5. 深入理解CachingConnectionFactory
  6. WINCE 网卡控制
  7. [转]UpdatePanel的用法详解
  8. 服务器中修改项目端口,c#-在Visual Studio 2013中更改项目端口号
  9. 学校如何搭建文件服务器,学校服务器搭建
  10. CCF NOI1048 检测矩阵
  11. 44.用Tornado实现web界面爬虫
  12. 微型计算机忘记密码,一种基于微型计算机的密码锁的制作方法
  13. js设计模式-状态模式-示例(高压锅状态)
  14. 搞研究的没有好下场 哈哈哈(精华在最后)
  15. python图形包是什么_介绍Python 图形计算工具包
  16. 蜗牛星际A单开启WOL功能
  17. 最后采用加权求和的方式得到样本的_论文阅读笔记《Principal characteristic networks for few-shot...
  18. composer错误
  19. 线性代数学习笔记7-4:马尔可夫矩阵、矩阵幂的稳态问题
  20. 适合新手的MySQL的基本操作第三期——存储过程篇

热门文章

  1. 遭遇Web print
  2. centos 6 上安装l7 filter尝试过滤xunlei
  3. 如何在多线程中调用winform窗体控件2——实例篇
  4. [置顶]       【Visual C++】游戏开发笔记之一——API函数、DirectX的关键系统...
  5. [最近公共祖先(LCA)]
  6. redis 导出导入详解
  7. PyQt的Layout的比例化分块。
  8. ios 如何对UITableView中的内容进行排序
  9. 一个很有意思的问题: 揭示了计算机程序问题的一般处理思路
  10. 跟我一起考PMP--项目质量管理