• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营

    • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机

    qemu、virtual box、vmware、xen都是虚拟机，一般用户接触到的virtual box和vmware比较多，都是用来ubuntu中跑windows，或者windows中跑ubuntu的。

    qemu其实是鼎鼎大名的最基础的开源模拟器，可以纯软件模拟x86、arm、mips，这一点完虐其它模拟器；也可以使用硬件加速，比如linux下kvm和windows以及mac下的haxm。这些硬件加速又是基于initel VT-x, intel VT-d，以及amd对应的技术，这些技术提供了vCPU，以及硬件的影子页表(intel EPT)，大大减轻了qemu软件模拟的工作量。

    virtual box，qemu-kvm都使用到了qemu，但是仅仅用到了它的设备模拟功能。qemu对于gpu的模拟比较渣，所以基于qemu的Android emulator自己实现了opengles 的qemu pipe，使用host电脑上的opengl进行绘图。
    xen在云计算中用的比较多，在这里不做详细介绍。其它模拟器基本都是运行在普通操作系统之上的一个进程，每一个核是其中的一个线程。

    本文介绍kvm的使用，在intel平台下ubuntu12.04中实现一个最简单的模拟器，计算2+2的结果并通过io端口输出。

    内核中kvm api的介绍可以看：Documentation/virtual/kvm/api.txt，其它的一些文档：Documentation/virtual/kvm/。完整的源码：https://lwn.net/Articles/658512/。

    使用kvm的真正的虚拟机，模拟了很多虚拟的设备和固件，还有复杂的初始化状态(各个设备的初始化，CPU寄存器的初始化等)，以及内存的初始化。本文所述的模拟器demo，将使用如下16bit的x86的代码(为什么是16bit呢，因为x86一上电是实模式，工作于16bit；之后再切换到32bit的保护模式的)：

    Ruby Code复制内容到剪贴板
    1. mov $0x3f8, %dx     
    2. add %bl, %al     
    3. add $'0', %al     
    4. out %al, (%dx)     
    5. mov $'\n', %al     
    6. out %al, (%dx)     
    7. hlt    

    这段代码充当了guest os，基本上算是一个裸奔的系统了。它实现了2+2，然后再加上'0'，把4转为ascii的'4'，并通过端口0x3f8输出。然后再输出了'\n'，就关机了。

    我们把这段代码对应的二进制存到数组里面：

    Ruby Code复制内容到剪贴
    1.   const uint8_t code[] = {     
    2. 0xba, 0xf8, 0x03, /* mov $0x3f8, %dx */     
    3. 0x00, 0xd8,       /* add %bl, %al */     
    4. 0x04, '0',        /* add $'0', %al */     
    5. 0xee,             /* out %al, (%dx) */     
    6. 0xb0, '\n',       /* mov $'\n', %al */     
    7. 0xee,             /* out %al, (%dx) */     
    8. 0xf4,             /* hlt */     
    9.    };    

    怎么得到这些机器码呢？

    Ruby Code复制内容到剪贴板
    1. shuyin.wsy@10-101-175-19:~$ cat simple_os.asm     
    2.     mov $0x3f8, %dx     
    3.     add %bl, %al     
    4.     add $'0', %al     
    5.     out %al, (%dx)     
    6.     mov $'\n', %al     
    7.     out %al, (%dx)     
    8.     hlt     
    9. shuyin.wsy@10-101-175-19:~$ as -o simple_os.o simple_os.asm     
    10. shuyin.wsy@10-101-175-19:~$ objdump -d  simple_os.o     
    11. simple_os.o:     file format elf64-x86-64     
    12. Disassembly of section .text:     
    13. 0000000000000000 .text>:     
    14.    0:   66 ba f8 03             mov    $0x3f8,%dx     
    15.    4:   00 d8                   add    %bl,%al     
    16.    6:   04 30                   add    $0x30,%al     
    17.    8:   ee                      out    %al,(%dx)     
    18.    9:   b0 0a                   mov    $0xa,%al     
    19.    b:   ee                      out    %al,(%dx)     
    20.    c:   f4                      hlt    

    可以在这个网页上查看汇编指令，以及对应的机器码：http://x86.renejeschke.de/
    注意开头多了一个0x66，解释如下：

    http://wiki.osdev.org/X86-64_Instruction_Encoding里面的Prefix group 3

    所以我们需要在simple_os.asm文件的开头添加.code16，这样的话就对了，但是objdump显示的又不对了，需要这样使用才行：

    Ruby Code复制内容到剪贴板
    1. shuyin.wsy@10-101-175-19:~$ objdump -d -Mintel,i8086 simple_os.o     
    2. simple_os.o:     file format elf64-x86-64     
    3. Disassembly of section .text:     
    4. 0000000000000000 .text>:     
    5.    0:   ba f8 03                mov    dx,0x3f8     
    6.    3:   00 d8                   add    al,bl     
    7.    5:   04 30                   add    al,0x30     
    8.    7:   ee                      out    dx,al     
    9.    8:   b0 0a                   mov    al,0xa     
    10.    a:   ee                      out    dx,al     
    11.    b:   f4                      hlt     
    12. https://sourceware.org/binutils/docs/as/i386_002d16bit.html   
    13. http://stackoverflow.com/questions/1737095/how-do-i-disassemble-raw-x86-code  

    我们会把这段代码，放到虚拟物理内存，也就是GPA(guest physical address)的第二个页面中(to avoid conflicting with a non-existent real-mode interrupt descriptor table at address 0)，防止和实模式的中断向量表冲突。al和bl初始化为2，cs初始化为0，ip指向第二个页面的起始位置0x1000。
    除此之外，我们还有一个虚拟的串口设备，端口是0x3f8，8bit，用于输出字符。

    为了实现一个虚拟机，我们首先需要打开/dev/kvm：

    Ruby Code复制内容到剪贴板
    1. kvm = open("/dev/kvm", O_RDWR | O_CLOEXEC);    

    在使用kvm之前，需要使用KVM_GET_API_VERSION ioctl()去检查下kvm的版本是否正确，看看是否为api12，是才可以继续运行

    Ruby Code复制内容到剪贴板
    1.  ret = ioctl(kvm, KVM_GET_API_VERSION, NULL);     
    2.    if (ret == -1)     
    3. err(1, "KVM_GET_API_VERSION");     
    4.    if (ret != 12)     
    5. errx(1, "KVM_GET_API_VERSION %d, expected 12", ret);    

    检查完api版本后，可以使用KVM_CHECK_EXTENSION ioctl()去检查其它extensions是否可用，比如KVM_SET_USER_MEMORY_REGION，用来检查kvm是否支持硬件影子页表(http://royluo.org/2016/03/13/kvm-mmu-virtualization/)：

    Ruby Code复制内容到剪贴板
    1.  ret = ioctl(kvm, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);     
    2.    if (ret == -1)     
    3. err(1, "KVM_CHECK_EXTENSION");     
    4.    if (!ret)     
    5. errx(1, "Required extension KVM_CAP_USER_MEM not available");   

    然后再创建一个虚拟机vm，这个vm和内存，设备，所有的vCPU相关，在host系统中对应一个进程：

    Ruby Code复制内容到剪贴板
    1. vmfd = ioctl(kvm, KVM_CREATE_VM, (unsigned long)0);    

    虚拟机需要一些虚拟物理内存，用来存放guest os。当guest os进行内存访问时，如果缺页，kvm会根据KVM_SET_USER_MEMORY_REGION的设置，去尝试解决缺页的问题，如果kvm无法解决，就会退出，退出原因是KVM_EXIT_MMIO，然后由qemu或者其它东西去进行设备的模拟(《android qemu-kvm内存管理和IO映射》)。

    我们先在host中申请一页内存，然后把guest os裸奔的代码拷贝过去：

    Ruby Code复制内容到剪贴板
    1. mem = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);     
    2. memcpy(mem, code, sizeof(code));    

    然后我们需要把host 虚拟空间的内存和guest os虚拟物理内存的映射关系使用KVM_SET_USER_MEMORY_REGION ioctl()告知kvm：

    Ruby Code复制内容到剪贴板
    1. struct kvm_userspace_memory_region region = {     
    2. .slot = 0,     
    3. .guest_phys_addr = 0x1000,     
    4. .memory_size = 0x1000,     
    5. .userspace_addr = (uint64_t)mem,     
    6.    };     
    7.    ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, ®ion);    

    这样，当guest os访问到虚拟物理内存的0x1000~0x2000之间的话，kvm会直接访问到mem所对应的真实的物理内存。

    现在，我们有了一个虚拟机vm，有了一些虚拟物理内存，内存里面有guest os的代码，那么我们需要给虚拟机添加一个核(vCPU)，对应一个线程。当然也可以多核(vCPUs，调用多次KVM_CREATE_VCPU)：

    Ruby Code复制内容到剪贴板
    1. vcpufd = ioctl(vmfd, KVM_CREATE_VCPU, (unsigned long)0);    

    每一个vCPU都和一个kvm_run结构体相关，kvm_run用于内核态和用户态信息的同步，比如从用户态的虚拟机中获得内核态的kvm退出的原因，KVM_EXIT_MMIO, KVM_EXIT_IO之类的。先获得kvm_run结构体的大小，然后分配内存并和vCPU进行绑定：

    Ruby Code复制内容到剪贴板
    1. mmap_size = ioctl(kvm, KVM_GET_VCPU_MMAP_SIZE, NULL);     
    2. run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpufd, 0);    

    vCPU中还有处理器寄存器的状态，分为两组，struct kvm_regs和struct kvm_sregs，我们需要设置其中的cs，al，bl，ip等寄存器：

    Ruby Code复制内容到剪贴板
    1. ioctl(vcpufd, KVM_GET_SREGS, sregs);     
    2. sregs.cs.base = 0;     
    3. sregs.cs.selector = 0;     
    4. ioctl(vcpufd, KVM_SET_SREGS, sregs);     
    5.   
    6.    struct kvm_regs regs = {     
    7. .rip = 0x1000,     
    8. .rax = 2,     
    9. .rbx = 2,     
    10. .rflags = 0x2,     
    11.    };     
    12.    ioctl(vcpufd, KVM_SET_REGS, ®s);    


    好了，东西都准备好了，我们可以开始运行vCPU了：

    Ruby Code复制内容到剪贴板
    1.    while (1) {     
    2. ioctl(vcpufd, KVM_RUN, NULL);     
    3. switch (run->exit_reason) {     
    4. /* Handle exit */     
    5. }     
    6.    }    

    我们需要根据run->exit_reason来处理kvm的退出状态，比如guest 关机：

    Ruby Code复制内容到剪贴板
    1. case KVM_EXIT_HLT:     
    2.  puts("KVM_EXIT_HLT");     
    3.  return 0;    

    初始化失败：

    Ruby Code复制内容到剪贴板
    1.  case KVM_EXIT_FAIL_ENTRY:     
    2.   errx(1, "KVM_EXIT_FAIL_ENTRY: hardware_entry_failure_reason = 0x%llx",     
    3. (unsigned long long)run->fail_entry.hardware_entry_failure_reason);      
    4.  case KVM_EXIT_INTERNAL_ERROR:     
    5.   errx(1, "KVM_EXIT_INTERNAL_ERROR: suberror = 0x%x",     
    6.        run->internal.suberror);    

    以及需要进行设备的模拟器，在这里，只有一个端口为0x3f8的串口设备。模拟设备的效果就是把字符打印出来：

    Ruby Code复制内容到剪贴板
    1. case KVM_EXIT_IO:     
    2.         if (run->io.direction == KVM_EXIT_IO_OUT      
    3.             run->io.size == 1      
    4.             run->io.port == 0x3f8      
    5.             run->io.count == 1)     
    6.         putchar(*(((char *)run) + run->io.data_offset));     
    7.         else     
    8.         errx(1, "unhandled KVM_EXIT_IO");     
    9.         break;    

    测试结果：

    Ruby Code复制内容到剪贴板
    1. tree@tree-OptiPlex-7010:~/Desktop$ gcc -o kvmtest kvmtest.c     
    2. tree@tree-OptiPlex-7010:~/Desktop$ ./kvmtest      
    3. KVM_EXIT_HLT    

    qemu-kvm中，qemu的主要任务就是KVM_EXIT_IO, KVM_EXIT_MMIO之后的虚拟设备的模拟，以及KVM_RUN之前设置好相关的设备的东西并进行初始化。

    以上所述是小编给大家介绍的ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！

    上一篇：ubuntu开启wifi热点的图文教程(亲测16.04与14.04可用)
    下一篇：Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
  • 相关文章
    • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机 ubuntu12.04,环境,下,使用,