CoreOS是一个轻量级的Linux操作系统，CoreOS的自动化、安全性、可扩容性特征，让其非常适用于集群化的部署场景。

与其它的发行版不同，CoreOS没有包管理器，它倾向于在容器（例如Docker）中运行应用程序。CoreOS对流行的容器系统提供了开箱即用的支持。

CoreOS可以在云服务（例如EC2、GCE）、虚拟化平台（VMware、OpenStack、KVM）、裸金属值上运行。

这是CoreOS提供的新的VM初始化机制，用于代替cloud-config。

Ignition能够执行磁盘分区、分区格式化、写入文件、配置用户、配置网络、创建RAID阵列等初始化操作。Ignition的运行时机非常的早，它在systemd启动之前、任何永久存储挂载之前即被调用。

在VM第一次（也仅仅是第一次）启动时，Ignition会从文件系统、URL、Hypervisor bridge读取JSON格式的配置文件，并将配置应用到VM。

即使是学习阶段，也最好创建3台CoreOS的集群，那样更容易认识CoreOS的特性。为了让CoreOS集群正常启动，你需要提供“点火配置”（ Ignition config ），或者通过user_data提供一个cloud-config。

本节记录基于libvirt创建CoreOS客户机的详细过程。

我们可以下载CoreOS官网提供的qcow2格式的镜像，此镜像适用于QEMU：

wget https://stable.release.core-os.net/amd64-usr/current/coreos_production_qemu_image.img.bz2

下载完毕后，解压镜像到

/home/alex/Vmware/KVM/coreos-20/vda.qcow2

为了配置CoreOS实例，我们需要在宿主机上创建一个目录，此目录中包含一些配置信息。此目录最终映射将为客户机上的一个文件系统。执行以下命令：

mkdir -p /home/alex/Vmware/KVM/coreos-20/cloud-config/openstack/latest/
touch /home/alex/Vmware/KVM/coreos-20/cloud-config/openstack/latest/user_data

user_data是cloud config格式的配置文件，它提供了客户机运行时所需要的定制化信息。我们至少需要在其中配置SSH Key以便（初次）登录到CoreOS中：

#cloud-config

ssh_authorized_keys:
 - ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAIBlsU4YrAi ... EIokU+jOd0MrsnOwQn9wJbov8Xhyw==

我们可以使用类似下面的命令来定义CoreOS的Domain：

virt-install --import --name coreos-20 --ram 1024 --vcpus 1
             --disk path=/home/alex/Vmware/KVM/coreos-20/vda.qcow2,format=qcow2,bus=virtio 
             --filesystem /home/alex/Vmware/KVM/coreos-20/cloud-config/,config-2,type=mount,mode=squash

或者，在常规的Domain XML配置文件中，添加devices的子元素：

<filesystem type='mount' accessmode='squash'>
    <source dir='/home/alex/Vmware/KVM/coreos-20/cloud-config/'/>
    <target dir='config-2'/>
</filesystem>

默认情况下，CoreOS会尝试通过DHCP来获得自身的网络配置，我们可以在启动Domain后立即查看控制台，CoreOS的IP地址会打印在上面。执行下面的命令登录到CoreOS：

ssh -i path-to-key core@ip-of-coreos

登录成功后，你可以为core用户设置密码，或者执行其它操作。 

<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>
    <name>coreos-20</name>
    <memory unit='MiB'>1024</memory>
    <vcpu placement='static'>1</vcpu>
    <os>
        <type arch='x86_64' machine='pc'>hvm</type>
    </os>
    <features>
        <acpi/>
    </features>
    <cpu mode='custom' match='exact'>
        <model fallback='allow'>SandyBridge</model>
    </cpu>
    <clock offset='utc'/>
    <on_poweroff>destroy</on_poweroff>
    <on_reboot>restart</on_reboot>
    <on_crash>destroy</on_crash>
    <devices>
        <emulator>/usr/bin/qemu-system-x86_64</emulator>
        <disk type='volume' device='disk'>
            <driver name='qemu' type='qcow2'/>
            <source pool="default" volume="coreos-20.qcow2" />
            <target dev='vda' bus='virtio'/>
            <boot order='1'/>
        </disk>
        <filesystem type='mount' accessmode='squash'>
            <source dir='/home/alex/Vmware/libvirt/mount/coreos-base/cloud-config/'/>
            <target dir='config-2'/>
        </filesystem>
        <controller type='usb' index='0'/>
        <controller type='pci' index='0' model='pci-root'/>
        <interface type='network'>
            <mac address='DE:AD:BE:EF:00:20'/>
            <source network='default'/>
            <model type='virtio'/>
        </interface>
        <serial type='pty'>
            <target port='0'/>
        </serial>
        <console type='pty'>
            <target type='serial' port='0'/>
        </console>
        <input type='mouse' bus='ps2'/>
        <input type='keyboard' bus='ps2'/>
        <memballoon model='virtio'/>
    </devices>
</domain>

当前推荐的配置CoreOS的方式是Ignition，但是目前libvirt没有对Ignition的直接支持，需要引入QEMU特有的配置片断。

Ignition配置为JSON格式，示例：

{
  "ignition": {
    "config": {},
    "timeouts": {},
    "version": "2.1.0"
  },
  "networkd": {},
  "passwd": {
    "users": [
      {
        "name": "core",
        "sshAuthorizedKeys": [
          "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAIBlsU4YrAif8Oh4Qdcq1SuF+CbPdr5T3DE3zzeYGG8nkcDMt/9dEjT8eHTMW+4BzCoIfYrIWIprJoykMnhZONBXnoXc/541tqU6MqF0ZRF0QlzSq6VLLLebG3zz+avdJSNLMAvolCLczP536EIokU+jOd0MrsnOwQn9wJbov8Xhyw=="
        ]
      }
    ]
  },
  "storage": {
    "files": [
      {
        "filesystem": "root",
        "group": {},
        "path": "/etc/hostname",
        "user": {},
        "contents": {
          "source": "data:,coreos-21",
          "verification": {}
        }
      }
    ]
  },
  "systemd": {}
}

libvrit Domain配置示例：

<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>
    ...
    <qemu:commandline>
    	<qemu:arg value="-fw_cfg"/>
    	<qemu:arg value="name=opt/com.coreos/config,file=/home/alex/Vmware/libvirt/mount/coreos-base/provision.ign"/>
  </qemu:commandline>
</domain>

注意：QEMU 2.0版本不支持 -fw_cfg，手工构建最新版本可以支持。 

The post CoreOS知识集锦 appeared first on 绿色记忆.

Hypervisor，即虚拟机监管程序（virtual machine monitor ，VMM）。它可以是电脑上的软件、固件或者硬件，用于建立和执行虚拟机。拥有Hypervisor后，你可以执行一个或者多个虚拟机。这些虚拟机称为客户机（guest machine），相应的Hypervisor所在机器称为宿主机（host machine）。

传统的虚拟化技术都是基于Hypervisor的，它们被分为两类：

1. bare-metal Hypervisor：裸机监管程序，直接运行在硬件上
2. Hosted Hypervisor：被宿主监管程序，Hypervisor运行在操作系统之上，就像一个应用程序一样

X86处理器定义了定义了0-3个特权级，数字越小，权限越高。

对于Linux来说，在没有虚拟化的情况下，内核态对应了0级，用户态对应3级。

传统的虚拟化技术都是在宿主机、客户机之间加一个Hypervisor。因此，当在Linux上运行Linux虚拟机时，两个内核都需要运行在0级。根据解决此冲突（对于Host来说整个Client是用户程序）的方式的不同，虚拟化被分为3种类型：

KVM，即基于内核的虚拟机（Kernel-based Virtual Machine），是构建于支持虚拟化扩展（Intel VT 或者 AMD-V）的x86平台、Linux操作系统之上的，完整虚拟化解决方案。使用KVM，你可以运行多个Linux或者Windows系统镜像，这些虚拟机拥有私有的虚拟化设备，包括网卡、磁盘、显卡等。

KVM主要包含两个内核组件：

1. 可加载的内核模块 kvm.ko，负责核心的虚拟化基础功能
2. 针对处理器的模块：kvm-intel.ko或者kvm-amd.ko

从2.6.20版本的Linux内核开始，KVM的内核组件就被包含在其中。从QEMU 1.3开始，KVM的用户空间组件被包含在其中。要查看你的机器是否支持KVM，可以执行：

lsmod | grep kvm

QEMU是一个基于通用目的开源仿真器/虚拟器软件。它可以模拟：

1. CPU
2. Intel e1000 PCI等网卡
3. 基于PCI IDE接口的硬盘、光驱
4. 软驱
5. 串口
6. AC97兼容声卡以及其它声卡
7. PS/2 键盘鼠标
8. VGA显卡

等多种外围设备。QEMU最多支持255 CPU的SMP。

当作为仿真器（Emulator，模拟器）使用时，它可以在真实机器（例如你的x86_64台式机）上模拟一台机器 + 操作系统 + 程序，而这台模拟的机器的体系结构（例如ARM板）与宿主机器不同。

而作为虚拟器（Virtualizer）使用时，它可以在宿主机器上直接执行客户机（虚拟机）的代码，因而虚拟机的性能接近于宿主机。QEMU通过下列方式之一来支持虚拟化：

1. 在XEN监管程序（Hypervisor）之上执行
2. 在支持KVM的Linux操作系统下运行。使用KVM时QEMU可以虚拟化x86、PowerPC、S390客户机

注意Emulator和Virtualizer的区别，最重要的一点是客户机的代码是直接执行（意味着宿主和客户机体系结构兼容），还是模拟执行，后者的效率要低得多。很多同学喜欢在PC上玩街机游戏，这也是通过模拟器（例如Winkawaks）实现的。

和Vmware、VirtualBox 之类的虚拟机管理软件不同，QEMU不提供图形化的管理界面。你可以使用第三方的图形前端，例如qtemu，但是命令行的丰富性让QEMU更适合在服务器上使用。

单纯靠QEMU来模拟一系列硬件，因为存在指令转译，性能一般很差。而KVM可以基于Intel-VT、AMD-V实现硬件辅助的CPU虚拟化，客户机指令直接在真实CPU上运行。因此结合KVM可以很好的提高QEMU的CPU性能。另一方面KVM仅仅提供CPU的虚拟化，它无法构建一台完整的虚拟机。因此QEMU和KVM整合的需求就很明显了。

qemu-kvm项目就是来整合QEMU和KVM的，此项目在1.3.0版本开始正式合并到QEMU项目的master上。qemu-kvm（qemu-system-***）利用ioctl调用/dev/kvm，将有关CPU的部分交由KVM去做。

如果KVM内核模块存在、且CPU支持，你可以通过下面的选项启用KVM支持：

# 启用基于KVM的虚拟化加速
-enable-kvm

CPU的性能问题解决了，但是QEMU模拟的其它硬件也存在同样的低效问题，于是Virtio被引入了。

Virtio是libvirt的一部分，它是一个关于网络、磁盘等设备的虚拟化标准，在此标准中客户机的设备驱动知道自己运行在虚拟化环境中，因而这些驱动可以和Hypervisor进行直接交互，获得接近于Native驱动的性能。

较新版本的Linux发行版都已经把Virtio编译进内核，因而客户机可以直接使用Virtio驱动。

KVM和XEN都是基于Hypervisor的虚拟化技术。它们的区别包括：

1. Xen是裸机监管程序，而KVM某种程度上把Linux内核变成了Hosted Hypervisor
2. Xen的整体性能高于KVM，但是I/O略差
3. KVM要求CPU必须支持虚拟化技术，但Xen则没有此限制。这个限制在当前的硬件条件下，基本不是问题
4. KVM的优势是它对Linux内核的整合程度，KVM本质上就是一个内核模块，因此你可以很容易的升级内核

VirtualBox是标准的2类Hypervisor，KVM与它的区别包括：

1. VirtualBox它与商用软件Vmware Workstation一样，都以图形界面为主，适合个人用户。但是在商用环境下，大部分虚拟机都是Headless的（不需要图形界面），此时VirtualBox的GUI则是劣势，GUI浪费了资源
2. VirtualBox支持大量的宿主操作系统，例如Windows、Linux、Mac OS X。而KVM显然仅支持Linux
3. 一般情况下，轻量级的KVM的性能要比VirtualBox好的多

LXC即Linux容器（Containers），这是一种操作系统层（传统虚拟机是硬件层）虚拟化技术，要由liblxc库及其多语言绑定、一系列控制容器的工具组成。LXC将整个应用，包括：软件本身代码、所需库、支撑软件，打包为一个“容器”。通过Linux内核的特性，可以实现容器与系统之间的隔离，这些特性包括：

1. 内核命名空间（IPC、uts、mount、pid、network、user）
2. Apparmor（限制每个应用程序访问的资源）和SELinux配置
3. Seccomp（提供应用程序沙盒机制）策略
4. Chroots（通过pivot_root调用）
5. cgroups，即控制组（control groups），用来限制、控制、分离进程组的资源（CPU、内存、磁盘等），此特性最初的名字就叫“进程容器”

通过LXC，你可以创建尽可能接近标准Linux的环境，同时不需要独立的内核。

基于LXC的虚拟化技术和KVM相比，区别如下：

1. LXC的优势在于轻量化和高性能，但是隔离性不高
2. LXC支持任何体系结构，例如x86、ARM、PowerPC等

LXD基于LXC，可以认为是一个Container的Hypervisor，LXD一般创建自包含的操作系统用户空间。也就是说，LXD容器内运行的是一个操作系统，虽然存在用户空间和内核空间隔离，但是这个操作系统和宿主系统共享一个内核。

有测试数据表明：LXD相比KVM可以减少50+%的延迟；LXD启动实例的速度比KVM块90+%

近年来非常流行的容器软件，与LXD最大的不同是，Docker打包应用程序+自包含的文件系统，而不是操作系统用户空间。每个Docker容器，仅仅包含一个应用程序。曾经Docker也是基于lxc技术的，但是现在它使用自己的库ibcontainer。

Docker中的文件系统、网络都是抽象的，而LXD直接使用宿主机的文件系统、网络，LXD可以方便的设置IP地址。

Docker比起LXD更加轻量，可以实现更高的部署密度。

大部分的Linux发行版已经内置了KVM内核模块以及用户空间工具，使用这些内置组件是最容易、推荐的方式：

1. KVM内核模块现在是Linux内核的一部分，除非你使用的是精简过的内核
2. 用户空间组件，软件包名称一般是qemu-kvm或者kvm，例如：
   1. Ubuntu下可以执行

      apt-get install qemu-kvm

       安装
   2. CentOS下可以执行

      yum install kvm

      安装
3. 客户机驱动：Linux客户机的驱动包含在内核中；Windows客户机的驱动需要下载

安装QEMU的依赖包：

sudo apt-get install gcc libsdl1.2-dev zlib1g-dev libasound2-dev linux-kernel-headers pkg-config libgnutls-dev libpci-dev

下载用户空间组件： 

1. QEMU 1.3或者更老版本的，在Sourceforge下载
2. 新版本，在QEMU官网下载

注意：2.6.29以上版本的内核，可以和任何版本的qemu-kvm搭配使用。

tar xzf qemu-kvm-release.tar.gz
cd qemu-kvm-release
./configure --prefix=/usr/local/kvm
make
sudo make install

如果你使用旧版本内核，或者内核精简了KVM，则需要此步骤：

tar xjf kvm-kmod-release.tar.bz2
cd kvm-kmod-release 
./configure
make 
sudo make install

# 对于Intel CPU
sudo /sbin/modprobe kvm-intel
# 对于AMD CPU
sudo /sbin/modprobe kvm-amd

从3.0.0开始QEMU的版本大跃进，每年major版本增加1，目前已经是5.x版本。

wget https://download.qemu.org/qemu-5.1.0.tar.xz
tar xvJf qemu-5.1.0.tar.xz 
cd qemu-5.1.0/
./configure
make

./configure --help

# 方括号中是默认值

Standard options:
  --prefix=PREFIX          install in PREFIX [/usr/local]
  --interp-prefix=PREFIX   where to find shared libraries, etc.
                           use %M for cpu name [/usr/gnemul/qemu-%M]
  # 目标列表，默认所有
  # xxx-softmmu 生成qemu-system-xxx，用于运行xxx架构下的虚拟机
  # xxx-linux-user 生成qemu-xxx，用于模拟运行xxx架构下的应用程序，可以配合binfmt_misc和Docker联用
  --target-list=LIST       set target list (default: build everything)
                           Available targets: aarch64-softmmu alpha-softmmu 
                           arm-softmmu avr-softmmu cris-softmmu hppa-softmmu 
                           i386-softmmu lm32-softmmu m68k-softmmu 
                           microblazeel-softmmu microblaze-softmmu 
                           mips64el-softmmu mips64-softmmu mipsel-softmmu 
                           mips-softmmu moxie-softmmu nios2-softmmu 
                           or1k-softmmu ppc64-softmmu ppc-softmmu 
                           riscv32-softmmu riscv64-softmmu rx-softmmu 
                           s390x-softmmu sh4eb-softmmu sh4-softmmu 
                           sparc64-softmmu sparc-softmmu tricore-softmmu 
                           unicore32-softmmu x86_64-softmmu xtensaeb-softmmu 
                           xtensa-softmmu aarch64_be-linux-user 
                           aarch64-linux-user alpha-linux-user armeb-linux-user 
                           arm-linux-user cris-linux-user hppa-linux-user 
                           i386-linux-user m68k-linux-user 
                           microblazeel-linux-user microblaze-linux-user 
                           mips64el-linux-user mips64-linux-user 
                           mipsel-linux-user mips-linux-user 
                           mipsn32el-linux-user mipsn32-linux-user 
                           nios2-linux-user or1k-linux-user 
                           ppc64abi32-linux-user ppc64le-linux-user 
                           ppc64-linux-user ppc-linux-user riscv32-linux-user 
                           riscv64-linux-user s390x-linux-user sh4eb-linux-user 
                           sh4-linux-user sparc32plus-linux-user 
                           sparc64-linux-user sparc-linux-user 
                           tilegx-linux-user x86_64-linux-user 
                           xtensaeb-linux-user xtensa-linux-user
  --target-list-exclude=LIST exclude a set of targets from the default target-list

Advanced options (experts only):
  --cross-prefix=PREFIX    use PREFIX for compile tools []
  --cc=CC                  use C compiler CC [cc]
  --iasl=IASL              use ACPI compiler IASL [iasl]
  --host-cc=CC             use C compiler CC [cc] for code run at
                           build time
  --cxx=CXX                use C++ compiler CXX [c++]
  --objcc=OBJCC            use Objective-C compiler OBJCC [cc]
  --extra-cflags=CFLAGS    append extra C compiler flags QEMU_CFLAGS
  --extra-cxxflags=CXXFLAGS append extra C++ compiler flags QEMU_CXXFLAGS
  --extra-ldflags=LDFLAGS  append extra linker flags LDFLAGS
  --cross-cc-ARCH=CC       use compiler when building ARCH guest test cases
  --cross-cc-flags-ARCH=   use compiler flags when building ARCH guest tests
  --make=MAKE              use specified make [make]
  --install=INSTALL        use specified install [install]
  --python=PYTHON          use specified python [/usr/bin/python3]
  --sphinx-build=SPHINX    use specified sphinx-build []
  --smbd=SMBD              use specified smbd [/usr/sbin/smbd]
  --with-git=GIT           use specified git [git]
  --static                 enable static build [no]
  --mandir=PATH            install man pages in PATH
  --datadir=PATH           install firmware in PATH/qemu
  --docdir=PATH            install documentation in PATH/qemu
  --bindir=PATH            install binaries in PATH
  --libdir=PATH            install libraries in PATH
  --libexecdir=PATH        install helper binaries in PATH
  --sysconfdir=PATH        install config in PATH/qemu
  --localstatedir=PATH     install local state in PATH (set at runtime on win32)
  --firmwarepath=PATH      search PATH for firmware files
  --efi-aarch64=PATH       PATH of efi file to use for aarch64 VMs.
  --with-confsuffix=SUFFIX suffix for QEMU data inside datadir/libdir/sysconfdir [/qemu]
  --with-pkgversion=VERS   use specified string as sub-version of the package
  --enable-debug           enable common debug build options
  --enable-sanitizers      enable default sanitizers
  --enable-tsan            enable thread sanitizer
  --disable-strip          disable stripping binaries
  --disable-werror         disable compilation abort on warning
  --disable-stack-protector disable compiler-provided stack protection
  --audio-drv-list=LIST    set audio drivers list:
                           Available drivers: oss alsa sdl pa
  --block-drv-whitelist=L  Same as --block-drv-rw-whitelist=L
  --block-drv-rw-whitelist=L
                           set block driver read-write whitelist
                           (affects only QEMU, not qemu-img)
  --block-drv-ro-whitelist=L
                           set block driver read-only whitelist
                           (affects only QEMU, not qemu-img)
  --enable-trace-backends=B Set trace backend
                           Available backends: dtrace ftrace log simple syslog ust
  --with-trace-file=NAME   Full PATH,NAME of file to store traces
                           Default:trace-<pid>
  --disable-slirp          disable SLIRP userspace network connectivity
  --enable-tcg-interpreter enable TCG with bytecode interpreter (TCI)
  --enable-malloc-trim     enable libc malloc_trim() for memory optimization
  --oss-lib                path to OSS library
  # 为指定CPU构建
  --cpu=CPU                Build for host CPU [x86_64]
  --with-coroutine=BACKEND coroutine backend. Supported options:
                           ucontext, sigaltstack, windows
  --enable-gcov            enable test coverage analysis with gcov
  --gcov=GCOV              use specified gcov [gcov]
  --disable-blobs          disable installing provided firmware blobs
  --with-vss-sdk=SDK-path  enable Windows VSS support in QEMU Guest Agent
  --with-win-sdk=SDK-path  path to Windows Platform SDK (to build VSS .tlb)
  --tls-priority           default TLS protocol/cipher priority string
  --enable-gprof           QEMU profiling with gprof
  --enable-profiler        profiler support
  --enable-debug-stack-usage
                           track the maximum stack usage of stacks created by qemu_alloc_stack
  --enable-plugins
                           enable plugins via shared library loading
  --disable-containers     don't use containers for cross-building
  --gdb=GDB-path           gdb to use for gdbstub tests [/usr/bin/gdb]

Optional features, enabled with --enable-FEATURE and
disabled with --disable-FEATURE, default is enabled if available:

  system          all system emulation targets
  user            supported user emulation targets
  linux-user      all linux usermode emulation targets
  bsd-user        all BSD usermode emulation targets
  docs            build documentation
  guest-agent     build the QEMU Guest Agent
  guest-agent-msi build guest agent Windows MSI installation package
  pie             Position Independent Executables
  modules         modules support (non-Windows)
  module-upgrades try to load modules from alternate paths for upgrades
  debug-tcg       TCG debugging (default is disabled)
  debug-info      debugging information
  sparse          sparse checker
  safe-stack      SafeStack Stack Smash Protection. Depends on
                  clang/llvm >= 3.7 and requires coroutine backend ucontext.

  gnutls          GNUTLS cryptography support
  nettle          nettle cryptography support
  gcrypt          libgcrypt cryptography support
  auth-pam        PAM access control
  sdl             SDL UI
  sdl-image       SDL Image support for icons
  gtk             gtk UI
  vte             vte support for the gtk UI
  curses          curses UI
  iconv           font glyph conversion support
  vnc             VNC UI support
  vnc-sasl        SASL encryption for VNC server
  vnc-jpeg        JPEG lossy compression for VNC server
  vnc-png         PNG compression for VNC server
  cocoa           Cocoa UI (Mac OS X only)
  virtfs          VirtFS
  mpath           Multipath persistent reservation passthrough
  xen             xen backend driver support
  xen-pci-passthrough    PCI passthrough support for Xen
  brlapi          BrlAPI (Braile)
  curl            curl connectivity
  membarrier      membarrier system call (for Linux 4.14+ or Windows)
  fdt             fdt device tree
  kvm             KVM acceleration support
  hax             HAX acceleration support
  hvf             Hypervisor.framework acceleration support
  whpx            Windows Hypervisor Platform acceleration support
  rdma            Enable RDMA-based migration
  pvrdma          Enable PVRDMA support
  vde             support for vde network
  netmap          support for netmap network
  linux-aio       Linux AIO support
  linux-io-uring  Linux io_uring support
  cap-ng          libcap-ng support
  attr            attr and xattr support
  vhost-net       vhost-net kernel acceleration support
  vhost-vsock     virtio sockets device support
  vhost-scsi      vhost-scsi kernel target support
  vhost-crypto    vhost-user-crypto backend support
  vhost-kernel    vhost kernel backend support
  vhost-user      vhost-user backend support
  vhost-vdpa      vhost-vdpa kernel backend support
  spice           spice
  rbd             rados block device (rbd)
  libiscsi        iscsi support
  libnfs          nfs support
  smartcard       smartcard support (libcacard)
  libusb          libusb (for usb passthrough)
  live-block-migration   Block migration in the main migration stream
  usb-redir       usb network redirection support
  lzo             support of lzo compression library
  snappy          support of snappy compression library
  bzip2           support of bzip2 compression library
                  (for reading bzip2-compressed dmg images)
  lzfse           support of lzfse compression library
                  (for reading lzfse-compressed dmg images)
  zstd            support for zstd compression library
                  (for migration compression and qcow2 cluster compression)
  seccomp         seccomp support
  coroutine-pool  coroutine freelist (better performance)
  glusterfs       GlusterFS backend
  tpm             TPM support
  libssh          ssh block device support
  numa            libnuma support
  libxml2         for Parallels image format
  tcmalloc        tcmalloc support
  jemalloc        jemalloc support
  avx2            AVX2 optimization support
  avx512f         AVX512F optimization support
  replication     replication support
  opengl          opengl support
  virglrenderer   virgl rendering support
  xfsctl          xfsctl support
  qom-cast-debug  cast debugging support
  tools           build qemu-io, qemu-nbd and qemu-img tools
  bochs           bochs image format support
  cloop           cloop image format support
  dmg             dmg image format support
  qcow1           qcow v1 image format support
  vdi             vdi image format support
  vvfat           vvfat image format support
  qed             qed image format support
  parallels       parallels image format support
  sheepdog        sheepdog block driver support
  crypto-afalg    Linux AF_ALG crypto backend driver
  capstone        capstone disassembler support
  debug-mutex     mutex debugging support
  libpmem         libpmem support
  xkbcommon       xkbcommon support
  rng-none        dummy RNG, avoid using /dev/(u)random and getrandom()
  libdaxctl       libdaxctl support

要创建虚拟机，首先要创建一个虚拟磁盘，然后从光驱启动此虚拟机：

mkdir -p ~/Vmware/KVM

# 以qcow2格式创建一个16G的虚拟磁盘，注意，默认不会预先分配空间
qemu-img create -f qcow2 ~/Vmware/KVM/centos7-base.img 16G

# 指定光盘镜像，从光驱启动虚拟机
# -hda 第一块硬盘的镜像
# -cdrom 光驱的镜像，你可以把宿主的/dev/cdrom传入，这样可以使用物理光驱
# -boot 指定启动顺序，d表示第一个光驱，c表示第一块硬盘
# -m 为虚拟机分配多少内存，默认单位M，默认128M
qemu-system-x86_64 -enable-kvm -hda ~/Vmware/KVM/centos7-base.img  -boot d -m 512
                   -cdrom ~/Software/OS/CentOS-7-x86_64-Minimal-1503-01.iso

上述命令执行完毕之后，会弹出一个窗口，该窗口相当于虚拟机的显示器。你可以在其中完成操作系统的安装。安装完毕后，执行下面的命令，即可启动虚拟机：

qemu-system-x86_64 -enable-kvm -hda ~/Vmware/KVM/centos7-base.img -m 512

后续几个章节，我们深入学习客户机硬件的定制，以满足不同应用场景的需要、提高客户机的性能。

使用选项

-cpu

qemu-system-x86_64 -cpu help

你可以这样配置一个CPU：

-cpu SandyBridge,+erms,+smep,+fsgsbase,+pdpe1gb,+rdrand,+f16c,+osxsave,+dca,+pcid,+pdcm,\
     +xtpr,+tm2,+est,+smx,+vmx,+ds_cpl,+monitor,+dtes64,+pbe,+tm,+ht,+ss,+acpi,+ds,+vme

+表示启用CPU特性，如果要禁用CPU特性，可以使用

-

所谓对称多处理（Symmetrical Multi-Processing） ，是指在一个计算机上汇集了一组处理器，各处理器共享内存子系统以及总线结构。在PC机上QEMU最多可以模拟255个CPU。

你可以这样配置SMP：

-smp 1,sockets=1,cores=1,threads=1

你可以在宿主机上创建一个磁盘镜像文件，然后供客户机使用。客户机磁盘I/O都将针对此文件。镜像文件可以有几种格式。

这种镜像的特点是格式简单，性能较好。

你的文件系统（例如Ext3）必须支持稀疏文件（sparse file），才能避免不必要的磁盘空间占用。稀疏文件是一种高效使用磁盘空间的技术，当文件大小很大，而其绝大部分块都是空白（未使用）的时，可以基于文件元数据来表示那些空白的块（而不是真实的硬盘空间）。

创建Raw镜像：

qemu-img create -f raw hda.img 1G

# 查看镜像信息
qemu-img info hda.img 
# image: hda.img
# file format: raw
# virtual size: 1.0G (1073741824 bytes)
# disk size: 0

你也可以使用dd命令产生Raw镜像，例如：

# 产生非稀疏文件：块大小1MB，写入1024个块，虚拟大小1G，实际大小1G
dd if=/dev/zero of=hda.img bs=1024k count=1024
# 产生稀疏文件：块大小1MB，写入0个块，虚拟大小1G，实际大小0
dd if=/dev/zero of=hda.img bs=1024k count=0 seek=1024

qcow2镜像的动态增长的，即使文件系统不支持稀疏文件，它也会尽可能的小。qcow2支持Copy-on-write、镜像、压缩、加密。 

正是由于qcow2支持Copy-on-write，我们才可以使用backing file——用一个镜像保存针对另外一个镜像的改变，而后面那个镜像不需要被改动。这是多虚拟机公用一个Base镜像，以及Snapshot的基础。

qcow2镜像文件的结构如下图所示：

qcow2镜像文件由一个头、几张表、数据簇组成。所有数据都存放在数据簇（Data Clusters）中，每个数据簇是512字节的扇区。为了方便管理这些数据簇，qcow2建立了两级表：L1、L2。其中L1表的条目指向L2表，而L2表的条目指向数据簇。

要定位数据，需要3个偏移量构成的数组：

1. 通过位于Header中的L1表指针  +offset[0]，得到L2表的指针
2. L2表指针 + offset[1]，得到数据簇指针
3. 数据簇指针 + offset[2]，得到目标数据的指针

你可以这样创建一个qcow2镜像：

qemu-img create -f qcow2 hda-back.img 16G

然后，在未来某个时刻把它作为backing file使用：

qemu-img create -f qcow2 -o backing_file=hda-back.img hda.img

镜像hda.img在一开始是空白的，所有数据都是从hda-back.img中获取，一旦发生写入操作，hda.img就开始有数据而hda-base.img保持不变。

使用下面的命令可以压缩一个qcow2镜像：

qemu-img convert -c -f qcow2 -O qcow2 hda.img hda.compressed.img

使用下面的命令可以为一个qcow2镜像设加密：

qemu-img convert -o encryption -f qcow2 -O qcow2  hda.img hda.encrypted.img
# 提示输入密码

使用压缩镜像启动虚拟机时，必须在Monitor中输入密码才可以。

使用下面的命令，可以扩展一个qcow2镜像的大小：

qemu-img resize hda.img +10G

注意：扩大得到的空间，不会被分区或者格式化。 

要移除镜像中的spare space，直接qcow2-to-qcow2转换即可，压缩（-c）可选：

qemu-img convert -O qcow2 source.qcow2 shrunk.qcow2

rebase操作用于改变一个镜像的backing镜像：

# -u 表示unsafe模式，在此模式下，仅仅改变backing文件的路径，不对文件内容进行检查
#    用于backing文件移动的情况
# -p 表示safe模式，在此模式下，执行真正的rebase操作。backing文件的内容可能和之前
#    不同，qemu-img会小心处理，确保VM可见的内容不变。为达成这一点，新旧backing
#    文件的差异，会合并到被改变镜像中
                    # 格式
qemu-img rebase -u  -f qcow2   
  # 新的backing文件位置                                      新backing文件格式
  -b /home/alex/Vmware/libvirt/images/sdd/xenial-base.qcow2 -F qcow2 
  # 被处理镜像文件
  /home/alex/Vmware/libvirt/images/sdd/xenial-100.qcow2

你可以把一个镜像的格式在Raw和qcow2之间进行转换：

# 把Raw格式的hda.img转换为qcow2格式的hda.qcow2
qemu-img convert -f raw -O qcow2 hda.img hda.qcow2

快照（Snapshot）是Copy-on-write的一种应用。QEMU支持两种快照：

1. 内部快照（internal snapshot）：在qcow2镜像的snapshot table中维护的快照，所有快照都存放在一个镜像文件中
2. 外部快照（external snapshot）：与Backing file很类似，在外部文件中创建新的镜像，原先的镜像只读

内部快照的原理是：

1. 创建一个Snapshot后，在Snapshot Table中新增一项，复制L1 Table
2. 当L2 Table或者Data Cluster发生改变，则把改变前的数据复制一份（Copy-on-write），由新创建的Snapshot的L1 Table来管理
3. L2 Table或者Data Cluster的变化，直接写到原始位置
4. 要删除快照，很简单，直接把Snapshot Table对应项、以及复制的L1-L2-DS删除即可
5. 要加载快照，则需要依据L1-L2-DS信息，将其合并到镜像的L1-L2-DS信息中

可以使用Monitor来创建、加载、删除内部快照：

# 保存一个内部快照
(qemu) savevm snapshot-1

qemu-img info hda.img
# 输出如下：
#Snapshot list:
#ID        TAG                 VM SIZE                DATE       VM CLOCK
#1         snapshot-1             112M 2016-09-07 18:05:48   00:00:21.536
#Format specific information:
#    compat: 1.1
#    lazy refcounts: false

# 加载内部快照
(qemu) loadvm snapshot-1

# 删除内部快照
(qemu) delvm snapshot-1

外部快照与内部快照相反：内部快照是原数据变化，外部快照则是新文件变化。

可以使用Monitor来管理外部快照：

snapshot_blkdev ide0-hd0 snapshot.img qcow2

有了磁盘镜像文件后，你需要为qemu-system-*指定参数，给客户机增加磁盘。有几种不同的配置方式：

# 最简单的方式
-hda hda.img 

# 使用-drive配置块设备，可以指定if为virtio来提升性能
-drive file=hda.img,index=0,media=disk,if=virtio

# 使用-device配置通用设备
-drive file=hda.img,if=none,id=virtio-disk0,format=qcow2,cache=none 
# 可以指定virtio-blk-pci来提升性能
-device virtio-blk-pci,scsi=off,bus=pci.0,addr=0x4,drive=virtio-disk0,bootindex=1

QEMU中的网络，包含两部分的内容：

1. 客户机使用的虚拟网络设备
2. 和上述虚拟设备通信的网络后端，这些后端负责把虚拟设备的数据包发到宿主机的网络中

要创建一个网络后端，可以指定如下选项：

# TYPE为后端类型：user、tap、bridge、socket、vde等
# id为一个标识符，将虚拟网络设备和网络后端关联在一起
# 如果客户机有多个虚拟网络设备，则每一个都需要自己的网络后端
-netdev TYPE,id=NAME,...

QEME支持多种网络后端。

如果没有指定网络选项，QEMU默认会模拟单张Intel e1000 PCI网卡，该网卡基于user后端（SLIRP）连接到宿主机：

# 不指定网络
qemu 
# 等价配置。自0.12开始废弃的配置方式 -net nic相当于-device DEVNAME；-net TYPE相当于-netdev TYPE
qemu -hda disk.img -net nic -net user
# 等价配置。-netdev指定网络后端，-device指定虚拟网络设备，后者通过netdev字段引用后端的ID
qemu -netdev user,id=network0 -device e1000,netdev=network0

在客户机看来：

1. 本身的IP地址被分配为 10.0.2.15+
2. 分配IP的虚拟DHCP为 10.0.2.2
3. 虚拟DNS服务器为 10.0.2.3
4. 虚拟Samba服务器为 10.0.2.4，客户机可以通过此服务器访问宿主机的文件系统

用户模式网络可以很方便的访问网络资源。但是它有很多限制：

1. 默认的，它运作方式类似于防火墙，且不允许任何入站流量。这个限制可以通过端口重定向解决
2. 仅仅支持TCP、UDP协议，对于ICMP则不支持
3. 性能比较差

为了支持入站请求，你可以使用端口重定向（Redirecting ports）——把针对宿主机某个端口的请求转发给客户机的某个端口。映射后，客户机可以对外提供SSH、HTTP等服务：

# 把宿主机的7080端口重定向到客户机的80端口；把宿主机的7022端口重定向到客户机的22端口
qemu-system-x86_64 -redir tcp:7080::80 -redir tcp:7022::22 -hda ~/Vmware/KVM/centos7-base.img -m 512 

# 从宿主机SSH到客户机
ssh root@127.0.0.1 -p 7022

你可以不使用默认的10.0.2网段：

-netdev user,id=network0,net=192.168.5.0/24,dhcpstart=192.168.5.9 

依据客户机安装的操作系统，可能需要进行一些配置，才能正常使用网络。以CentOS 7 Minimal + 用户模式网络为例，需要修改以下配置文件：

NETWORKING=yes
# 如果不使用IPV6
NETWORKING_IPV6=no

# 如果不使用IPV6
IPV6INIT=no
# 开机启动此网卡，默认不启动
ONBOOT=yes

网关、DNS不需要设置。修改完这些配置文件后，重启客户机网络：

/etc/init.d/network restart

yum update

QEMU的TAP后端利用宿主机的TAP设备，为客户机提供完整的桥接网络支持，如果外部需要使用标准端口连接到客户机， 或者多个客户机需要相互通信，可以使用该方式。 TAP后端还具有以下优势：

1. 非常好的性能
2. 可以配置以支持各种网络拓扑

但是，你需要在宿主机上进行网络拓扑的配置，而且各种系统的配置不同。

使用TAP后端前，你需要确认你的宿主机的内核支持TAP网络接口：

/dev/net/tun

sudo mkdir /dev/net
sudo mknod /dev/net/tun c 10 200
sudo /sbin/modprobe tun

如果你想创建几个客户机之间的私有网络，可以使用该方式。未参与进来的客户机、真实网络无法看到此网络。

如果你不是root，则你需要

/dev/kvm

首先，添加一个以太网桥设备：

sudo ip link add br0 type bridge
# 也可以使用：sudo brctl addbr br0添加网桥
# 要删除网桥，执行： ip link delete br0
# 注意：网桥会在重启后消失

# 启用此网桥
sudo ip link set br0 up

# 为网桥分配IP地址
sudo ip addr add 10.0.0.1 dev br0

# 在宿主机添加一条直接路由，便于它能和客户机通信
sudo ip route add 10.0.0.0/8 dev br0

创建一个创建TAP设备并桥接到网桥的脚本：

#!/bin/sh

switch=br0

if [ -n "$1" ];then
        # tunctl -u `whoami` -t $1
        # 添加一个tap设备，在我的机器上不需要，原因见下面
        # ip tuntap add $1 mode tap user `whoami`
        # 不知道从什么时候开始，QEMU会在执行此脚本之前就创建好tap设备，因此会报下面的错误
        # ioctl(TUNSETIFF): Device or resource busy
        # 启动tap设备
        ip link set $1 up
        # brctl addif $switch $1
        # 将网桥和tap设备进行桥接
        ip link set $1 master $switch
        exit 0
else
        echo "Error: no interface specified"
        exit 1
fi

创建一个生成随机MAC地址的脚本：

#!/bin/bash
# generate a random mac address for the qemu nic
printf 'DE:AD:BE:EF:%02X:%02X\n' $((RANDOM%256)) $((RANDOM%256))

启动客户机的脚本：

#!/bin/bash
# $1 base name of virtual disk
# $2 memory size
# $3 tap device id

mac=`/usr/bin/qemu-genmac`
src=/usr/bin/qemu-ifup
sudo qemu-system-x86_64 -enable-kvm -device e1000,netdev=$3,mac=$mac -netdev tap,id=$3,script=$src,downscript=no \
                        -hda ~/Vmware/KVM/$1.img -m $2

为上面的脚本文件添加可执行权限：

sudo chmod +x /usr/bin/qemu-ifup-br0
sudo chmod +x /usr/bin/qemu-genmac
sudo chmod +x /usr/bin/qemu-start-br0

执行下面的命令，启动一台客户机（或者更多虚拟机，但是命令中的tap0要更换为不同的名字）：

/usr/bin/qemu-start centos7-base 512 tap0

修改客户机的IP地址，使用10.0.0.0/8网段：

TYPE=Ethernet
BOOTPROTO=static
DEFROUTE=yes
PEERDNS=yes
PEERROUTES=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=no
NAME=ens3
UUID=d9f47102-b177-4a27-ae98-86f6939d6680
DEVICE=ens3
ONBOOT=yes
IPADDR=10.0.0.10
PREFIX=8
GATEWAY=10.0.0.1

好了，你现在可以互相ping客户机和宿主机，应该可以正常连通了。 

上一节介绍的这种基于TAP的私有桥接网络，可以让客户机、宿主机相互连通，但是客户机无法访问互联网。

要解决此问题，你可以选择以下方法之一：

1. 让客户机通过宿主机暴露的HTTP/SOCKS代理上网
2. 配置宿主机的路由规则，设置好源地址转换即可：
   

   # 宿主机需要启用IP转发功能，这样它就可以像路由器那样中转IP封包了
   sudo sysctl -w net.ipv4.ip_forward=1 
   # 对客户机网段进行源地址转换
   sudo iptables -t nat -A POSTROUTING  -s 10.0.0.0/255.0.0.0 ! -d 10.0.0.0/255.0.0.0 -j MASQUERADE 

此方式和私有桥接网络类似，主要区别是，除了TAP设备桥接到网桥之外，以太网卡（例如eth0）也桥接到网桥（例如br1）。

你可以通过发行版的配置文件来配置网桥：

# 注意网络管理器组件的影响
# 去掉 auto eth0，改为：
auto br1

# 配置br1
iface br1 inet dhcp
    bridge_ports    eth0
    bridge_stp      off
    bridge_maxwait  0
    bridge_fd       0
    # 这里附加上原来属于eth0的配置

或者基于脚本来配置： 

sudo ip link add br1 type bridge
sudo ip link set br1 up
sudo ip link set eth0 master br1 

# DHCP
sudo killall dhclient && sudo ip addr flush dev eth0
sudo dhclient br1

无论用哪种方式，都应该注意到eth0的IP地址需要转移给br1，这样才能确保网络正常运作——br1必须在链路层接收到相关ARP请求，并决定是否需要转发给客户机，eth0没有这种转发能力。

如果eth0所在网络是基于DHCP的，那么客户机配置为DHCP后，会自动获取公共IP地址。否则，需要手工设置客户机的IP地址。 

现在QEMU支持自动桥接TAP设备到宿主机的一个网桥，因此你不再需要编写脚本，修改网络后端为bridge即可：

-netdev bridge,id=tap0,br=br0

注意，使用上述选项时，QEMU需要读取配置文件/etc/qemu/bridge.conf，你只需在此文件中添加一行代码：

allow br0

你可以编写如下脚本自动创建网桥、配置iptables规则。示例：

# Create private bridge link for QEMU
/sbin/ip link add br0 type bridge
/sbin/ip link set br0 up
/sbin/ip addr add 10.0.0.1 dev br0
/sbin/ip route add 10.0.0.0/8 dev br0
# NAT for 10.0.0.0/8
/sbin/iptables -t nat -A POSTROUTING  -s 10.0.0.0/255.0.0.0 ! -d 10.0.0.0/255.0.0.0  -j MASQUERADE


# Create public bridge link for QEMU
/sbin/ip link add br1 type bridge
/sbin/ip link set br1 up
/sbin/ip link set eth0 master br1 
/usr/bin/killall dhclient && /sbin/ip addr flush dev eth0
/sbin/dhclient br1

建议和libvirt一起使用macvtap。 

在使用libvirt时，客户机（Domain）的网络接口配置可以简化为：

<interface type='bridge'>
    <mac address='DE:AD:BE:EF:F1:00'/>
    <source bridge='br0'/>
    <target dev='tap0'/>
    <model type='virtio'/>
</interface>

可以使用libvrit的虚拟局域网，这样宿主机上不会为客户机创建专门的tap设备，那些手工编写的脚本也全都不需要了。虚拟网络配置示例：

<network>
  <name>default</name>
  <uuid>9bae4de8-ca58-48c5-ba58-109aebf8b954</uuid>
  <forward mode='nat'>
  </forward>
  <bridge name='virbr0' stp='on' delay='0'/>
  <ip address='10.0.0.1' netmask='255.0.0.0'>
    <dhcp>
      <range start='10.0.0.100' end='10.0.0.200'/>
    </dhcp>
  </ip>
</network>

客户机（Domain）的网络接口配置示例：

<interface type='network'>
    <mac address='DE:AD:BE:EF:F1:00'/>
    <source network='default'/>
    <model type='virtio'/>
</interface>

另外，libvirt的虚拟网络提供了DHCP功能，因此客户机的IP地址不需要静态设置。

SMBIOS即DMI表，存放了X86系统硬件信息，这个表依据DMI type分为数十个段，type0是BIOS、type1是系统信息、type2是主板信息……

QEMU支持模拟这些信息，例如：

# 设置客户机的type1信息
-smbios type=1,manufacturer=OpenStack Foundation,product=OpenStack Nova,version=2011,serial=8059dfb4,uuid=1f8ee7f308

要设置客户机的内存容量，可以使用

-m

客户机没必要占据着空闲的内存不用，因此我们一般启用内存实际大小的动态调整功能，例如：

-device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5

在本文的第一章，谈到周围硬件性能的时候，我们提及了virtio——它是规定了虚拟设备的前端驱动与宿主机硬件的后端驱动之间通信接口的标准，并且知道目前的很多Linux发行版已经把virtio驱动编译进内核了。前面的章节我们也使用了很多virtio驱动，包括磁盘、网络、内存相关的。

基于virtio驱动的虚拟设备，我们成为“半虚拟化设备”，因为这些设备驱动知道自己工作在虚拟化模式下。为客户机配置半虚拟化设备，可以提高内存、硬盘、网络方面的性能，由其对于网络，性能提升很明显。

除了virtio，Vmware Tools也属于半虚拟化驱动，QEMU客户机也可以利用Vmware Tools（例如-vga指定vmware）。virtio驱动的具体实现包括：virtio-blk、virtio-net、virtio-pci、virtio-balloon、virtio-console等。

半/全虚拟化的区别如下：

1. 在全虚拟化状态下，Guest OS不知道自己是虚拟机，于是像发送普通的IO一样发送数据，被Hypervisor拦截，转发给真正的硬件。
2. 在半虚拟化状态下，Guest OS知道自己是虚拟机（需安装半虚拟化驱动），所以数据直接发送给半虚拟化设备，经过特殊处理，发送给真正的硬件

这是一个特殊的半虚拟化设备，它能够动态（不需要重启客户机）的调整客户机的内存大小。如果你指定了-m参数，则不能调整的比-m更大。使用选项

-balloon virtio

要基于半虚拟化来访问磁盘，可以使用选项：

-drive file=vda.qcow2,if=virtio

可以使用驱动virtio-blk-data-plane进一步提高性能（I/O性能较virtio-blk能提高10-20%），此驱动自QEMU 1.4开始引入。与传统的virtio-blk不同的是，virtio-blk-data-plane为每个块设备独立分配一个线程用于I/O处理，此线程不需要和QEMU执行线程同步、竞争锁。此驱动基于宿主机的原生AIO响应客户机的请求。启用此驱动的选项示例：

-drive if=none,id=drive0,cache=none,aio=native,format=raw,file=vda.img
-device virtio-blk-pci,drive=drive0,scsi=off,x-data-plane=on

但是，启用virtio-blk-data-plane后，存储迁移（storage migration）、热拔插、I/O限流（throttling） 等功能无法使用。而且该驱动仅支持Raw格式的磁盘。

要基于半虚拟化来访问网络，可以使用选项：

-device virtio-net-pci,netdev=network0

宿主机网卡的某些特性可能会影响virtio的性能，例如：

1. TSO（TCP Segmentation Offload）：通过网络设备进行TCP段的分割，从而来提高网络性能
2. GSO（Generic Segmentation Offload）：类似，用TCPv6、UDP等传输层协议

你可以开关这些特性来测试对客户机网络性能的影响。要检查宿主机网卡是否支持、开启这些特性，可以执行命令：

ethtool -k eth0

网络块设备（Network Block Device）是一种把虚拟块设备通过TCP/IP暴露出去，供远程共享访问的技术。

你可以通过UNIX套接字来暴露：

qemu-nbd -t -k /home/alex/Vmware/KVM/.images/fedora-108 fedora-108/hda.img

 也可以通过普通套接字来暴露：

qemu-nbd  -p 1025 fedora-108/hda.img 

甚至是把镜像直接挂载到宿主机的NBD设备中：

# 在宿主机上启用NBD内核模块，最多16个分区：
sudo modprobe nbd max_part=16
# 查看NBD设备文件
ls /dev/nbd*
# 输出/dev/nbd0 ... /dev/nbd15

# 挂载
sudo qemu-nbd -c /dev/nbd0 fedora-108/hda.img

# 查看nbd0的分区情况
sudo fdisk -l /dev/nbd0
#  Device Boot Start End Blocks Id System
#  /dev/nbd0p1 * 2048 1026047 512000 83 Linux
#  /dev/nbd0p2 1026048 33554431 16264192 8e Linux LVM

客户机可以直接使用NBD作为磁盘：

# 使用UNIX套接字：
qemu-system-x86_64 -hda nbd:unix:/home/alex/Vmware/KVM/.images/fedora-108
# 使用普通套接字
qemu-system-x86_64 -hda nbd:10.0.0.1:1025

QEMU支持离线或者在线的迁移，你可以在Monitor中使用迁移命令。当迁移完毕后，虚拟机会在目标主机上继续运行。

AMD和Intel宿主机之间可以随意的迁移虚拟机，64位虚拟机只能迁移到64位宿主机上，32位则没有限制。某些老旧的Intel CPU不支持NX（禁止执行比特位），这种CPU处于启用NX的宿主机群中，会导致问题，你需要禁止客户机的NX：

-cpu qemu64,-nx

QEMU的迁移功能具有以下特性：

1. 极短暂的客户机停机时间
2. 如果迁移成功，则客户机在目标主机上运行；如果迁移失败，则客户机继续在源主机上运行
3. 几乎对硬件没有依赖

使用共享存储时，QEMU迁移会很便利，因为不牵涉到磁盘映像的移动。共享存储包括：NFS、NBD、SAN等。 我们以NBD为例说明：

1. 启动供源、目的虚拟机共享的NBD服务：

   qemu-nbd -p 1025 --share=2 fedora-108/hda.img

    
2. 确保源、目的虚拟机的配置，它们要具有相同的网络环境
3. 启动源虚拟机：
   

   sudo qemu-system-x86_64 -netdev bridge,id=tap0,br=br0 -device virtio-net-pci,netdev=tap0,mac=DE:AD:BE:EF:F1:08 
                           -hda nbd:10.0.0.1:1025 -monitor stdio -enable-kvm  

4. 源虚拟机运作一段时间后，其宿主机的硬件需要维护，因此准备迁移。在另外一台宿主机上启动目的虚拟机，并监听migration端口：
   

   # qemu选项同源虚拟机，附加：
   -incoming tcp:0:4444

    注意，这个监听端口是开在宿主机上的。实际上，以-incoming启动目的虚拟机后，虚拟机是处于Stopped状态的

5. 登录到源虚拟机，确认它与目的虚拟机的宿主机之间的网络是畅通的
6. 在源虚拟机的Monitor中，发起迁移命令：

   (qemu) migrate -d tcp:10.0.0.1:4444

    
7. 在迁移过程中，可以通过

   info migrate

    查看迁移状态，完毕后会显示Migration status: completed，并列出迁移消耗的时间、停机时间
8. 迁移完成后，源虚拟机变为Stopped，而目的虚拟机开始运行，获得源虚拟机的全部瞬时状态

这种情况下，源虚拟机的磁盘镜像需要拷贝到目标宿主机中。因而需要更长的时间、更多的网络带宽消耗。步骤如下：

1. 查看源虚拟机的磁盘镜像信息：

   qemu-img info fedora-108/hda.img

    
2. 在目的机器上创建与之大小（Virtual size）一致的空磁盘镜像：

   qemu-img create -f qcow2 fedora-108-m/hda.img 16G

    
3. 使用与共享存储一样的步骤进行迁移，只是源、目的虚拟机使用各自的磁盘镜像

前面的章节我们已经多次使用QEMU的监控功能，通过使用QEMU的HMI（Monitor）可以在(qemu)提示符下进行各种监控操作，包括查看虚拟机信息、动态添加设备、执行迁移等等。在《QEMU命令与快捷键》一章我们会详细的讲解HMI命令，本章主要介绍监控相关的QEMU配置

你可以通过多种方式使用Monitor：

1. 默认的，可以在QEMU的虚拟机窗口中，按Ctrl + Alt + 2切换到Monitor
2. 可以使用

   -monitor stdio

    ，让Monitor重定向到启动虚拟机的Terminal
3. 可以启动一个TCP监听

   -monitor tcp::4444,server,nowait

    ，这样你可以

   telnet hostip:4444

    访问Monitor
4. 可以通过字符设备：

   -chardev stdio,id=x -monitor chardev=x

    访问Monitor

非交互式监控时，QEMU监控协议（QEMU Monitor Protocol）是更好的选择，这是一个基于JSON格式的协议。要启用QMP，你可以：

1. 基于stdio：

   -qmp stdio

    
2. 基于TCP：

   -qmp tcp:localhost:4444,server

    
3. 基于UNIX Socket：

   -qmp unix:./qmp-sock,server

    

以下列出一些应用基于QEMU/KVM的虚拟化方案时的最佳实践：

1. 使用半虚拟化驱动virtio
   1. 性能好：延迟低、吞吐量高
   2. 纯虚拟设备的劣势：需要高吞吐能力的设备在硬件方面会有特殊的实现，这些纯虚拟设备是没法利用的
   3. 网络、块设备、内存，都可以使用virtio
   4. 兼容性较差
2. 虚拟机最好直接使用块设备做存储
   1. 性能好、无需管理宿主机的文件系统、无需管理稀疏文件
   2. I/O 缓存以4K为边界
   3. 如果没有条件使用块设备，只能使用镜像文件
   4. 宿主机最好使用ext3文件系统，ext4的barrier会影响性能
   5. Raw格式镜像的性能优于qcow2
   6. 选择正确的缓存策略，缓存模式推荐none，I/O调度器推荐Deadline I/O scheduler
3. CPU配置
   1. 每个客户机相当于一个进程，而每个客户机的虚拟CPU相当于一个线程。因此超配CPU是可行的
   2. CPU超配可能带来额外的上下文切换，影响性能
   3. 要保证客户机获得足够的时间片，可以利用cgroup的cpu.cfs_period_us、cpu.cfs_quota_us来干预CFS调度器的行为
   4. Pin CPU：可以将虚拟CPU Pin到一个物理CPU，或者一组共享缓存的物理CPU，便于缓存共享。缺点是Pin导致其它空闲CPU可能得不到利用
4. 内存配置
   1. 使用内核特性KSM（Kernel Same Page Merging），KSM通过扫描将相同的内存区域设置为共享，并且Copy-on-write。共享内存节约可以内存空间，但是内存扫描同时影响性能
   2. 尽量避免使用swap，可以设置/proc/sys/vm/swappiness=0
5. 网络配置
   1. 使用tap类型的网络后端
   2. 启用PCI passthough可以提高性能，但是影响迁移

HMI即 Human Monitor Interface，是QEMU在运行客户机时提供的一个console（下面我们称此console为Monitor），它让你可以和运行中的虚拟机进行交互，你可以获得内存Dump、列出虚拟设备树、获取屏幕截图等操作。

默认情况下QEMU使用SDL来显示客户机的视频输出，此所谓图形模式。如果启用-nographic选项则会禁用图形模式。

在图形模式下，你可以使用以下方式之一访问HMI：

1. 在客户机的虚拟控制台（客户机弹窗）访问HMI，按Ctrl + Alt + 2可以切换到Monitor，在其中你可以调用HMI命令
2. 指定-monitor stdio，则启动虚拟机的Terminal变为Monitor

在基于-nographic的非图形模式下，Monitor、虚拟串口都被重定向到stdio，你可以Ctrl + a c来切换。你可以同时把虚拟串口配置为系统控制台，这样你可以通过单个窗口完成客户机登录、HMI操作

info kvm           # 显示KVM支持情况
info pci           # 显示PCI信息
info qtree         # 显示QEMU系统总线树
info network       # 显示网络设备信息
info block         # 显示块设备信息
info blockstatus   # 显示块设备读写统计信息
info snapshots     # 显示快照信息
info migrate       # 显示迁移状态

sendkey ctrl-alt-f1

savevm blankos

loadvm blankos

info block
# ide0-hd0: /home/alex/Vmware/KVM/fedora-108/hda.img (qcow2)
snapshot_blkdev_internal  ide0-hd0 blankos

snapshot_blkdev ide0-hd0 blankos.img

该命令即QEMU模拟器，使用它可以指定硬件设备，并从虚拟磁盘镜像启动一台客户机。

-machine [type=]name[,prop=value[,...]]

qemu-system-x86_64 -machine help

qemu-system-x86_64 -cpu help

-smp [cpus=]n[,cores=cores][,threads=threads][,sockets=sockets][,maxcpus=maxcpus]

-global driver.prop=value

-global ide-drive.physical_block_size=4096

-boot [order=drives][,once=drives][,menu=on|off][,splash=sp_name]
      [,splash-time=sp_time][,reboot-timeout=rb_timeout][,strict=on|off]

-soundhw card1[,card2,...]
# 或者
-soundhw all

# 显示可用硬件列表
qemu-system-x86_64 -soundhw help
# 示例
qemu-system-x86_64 -soundhw ac97 disk.img

# 禁用balloon设备
-balloon none
# 启用balloon设备，可以指定一个PCI地址
-balloon virtio[,addr=addr]

-device driver[,prop[=value][,...]]

-device help

-device driver,help

bus=pci.x

addr=0xM.0xN

# 添加e1000网卡，以network0为后端
-device e1000,netdev=network0
# 添加基于Virtio的网卡，等价于 -net nic,model=virtio ...
-device virtio-net-pci,netdev=network0,id=net0,mac=DE:AD:BE:EF:F1:08,bus=pci.0,addr=0x3

# 启用virtio balloon设备（收回客户机空闲内存），等价于-balloon ...
-device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5

# 添加基于Virtio的硬盘（前端）
-device virtio-blk-pci,scsi=off,bus=pci.0,addr=0x4,drive=drive-virtio-disk0

-drive option[,option[,option[,...]]]

-drive file=file,index=2,media=cdrom

-drive file=file,index=0,media=disk
-drive file=file,index=1,media=disk
-drive file=file,index=2,media=disk
-drive file=file,index=3,media=disk

-vnc 0.0.0.0:10

-g widthxheight[xdepth]

-net nic[,vlan=n][,macaddr=mac][,model=type] [,name=name][,addr=addr][,vectors=v] 

-net nic,model=help

-netdev user,id=id[,option][,option][,...]
-net user[,option][,option][,...]

-netdev tap,id=id[,fd=h][,ifname=name][,script=file][,downscript=dfile][,helper=helper]
-net tap[,vlan=n][,name=name][,fd=h][,ifname=name][,script=file][,downscript=dfile][,helper=helper]

-netdev bridge,id=id[,br=bridge][,helper=helper]
-net bridge[,vlan=n][,name=name][,br=bridge][,helper=helper]

allow br0

-chardev backend ,id=id [,mux=on|off] [,options]

-chardev vc ,id=id [[,width=width] [,height=height]] [[,cols=cols] [,rows=rows]] 

-chardev ringbuf ,id=id [,size=size]

-chardev pipe ,id=id ,path=path

-chardev file ,id=id ,path=path

-chardev serial ,id=id ,path=path

-nographic

-display none

在图形化模拟期间，你可以使用快捷键：

 如果你使用了-nographic，则可以使用以下快捷键：

用于创建QEMU网络块设备（Network Block Device）服务器，即通过NBD协议把磁盘镜像暴露出去。 命令格式：

qemu-nbd [OPTION]... diskimgfile

常用选项如下表：

报错信息：'virtio-9p-pci' is not a valid device model name

解决办法：参考下面的脚本构建QEMU：

apt install libattr1-dev
configure --prefix=/usr --enable-virtfs
make && make install

报错信息：qemu-system-x86_64: -sdl: SDL support is disabled

解决办法：参考下面的脚本构建QEMU：

sudo apt install libsdl2-dev
./configure --prefix=/usr --enable-virtfs --enable-sdl

报错信息：Image is corrupt; cannot be opened read/write

解决办法：

qemu-img check -r all /media/alex/v12n2/libvirt/images/xenial-23

The post KVM和QEMU学习笔记 appeared first on 绿色记忆.

libvirt是广泛使用的、通用虚拟化管理工具，它提供多种命令行工具、多种语言的编程API。

libvirt的目标是：提供一个通用、稳定的抽象层，来安全有效的远程管理一个节点（node）之上的域（domains），因此它需要提供全套的API来完成管理，这些API必须完成Domain的创建、修改、配置、监控、迁移、停止。

libvirt可以管理的虚拟化机制（hypervisor或container）包括：KVM/QEMU、Xen、LXC、OpenVZ、VirtualBox、VMware ESX/GSX、VMware Workstation/Player、Microsoft Hyper-V、IBM PowerVM。

libvirt的二进制组件可能已经随操作系统安装，如果没有，你可以：

sudo apt-get install libvirt-bin

可以安装virt-install，这是一个用来创建基于KVM、XEN或者Linux容器的客户机的工具：

sudo apt-get install virtinst

可以安装virt-manager，它提供了基于libvirt的图形化管理工具：

sudo apt-get install virt-manager

可以安装virt-viewer，它用于连接到虚拟机的Graphical Console：

# 安装
sudo apt-get install virt-viewer
# 使用
virt-viewer -c qemu:///system

virsh是libvirt提供的一个命令行工具，利用它你可以通过命令行，交互式的管理你的虚拟机（Domain）。使用此命令，你可以创建、暂停、关闭domain，可以列出当前的domain。

libvirt会在宿主机上运行一个libvirtd守护进程，此进程可以被本地/远程的virsh调用。libvirtd则可以直接调用qemu-kvm来操控客户机。大部分virsh命令需要libvirtd处于运行状态才可用。

使用virsh的define、edit、start、shutdown|destroy、reboot、suspend、resumen、undefined子命令，分别可以定义、编辑、启动、关闭、暂停、唤醒、删除Domain。这些命令比较简单，参考virsh命令详解一节。

快照可以分为三个级别：

1. 卷管理器（Volume Manager） 级别，例如LVM的Snapsot功能
2. 文件系统级别，常用的Ext3不支持，OCFS2支持
3. 文件级别，Raw格式的镜像不支持快照，qcow2格式则支持，且快照分为两类：
   1. 内部快照：保存在qcow2文件内部的快照：
      1. 虚拟机状态快照（VM State snapshot）：整个虚拟机的状态，不仅仅是磁盘
      2. 磁盘状态快照（Disk State snapshot）：仅仅针对磁盘的快照
   2. 外部快照：将原先（Backing）的qcow2镜像设置为只读，新的改变保存到另外的qcow2文件

使用virsh save / virsh restore命令，可以仅仅将Domain的内存状态保存，然后停止Domain，最后恢复。恢复时假设磁盘没有任何改动：

# 保存内存快照
virsh save fedora-10 fedora-10.vmstate

# 恢复内存快照
virsh restore fedora-10.vmstate

内部快照、外部快照使用同一组命令来管理的。这些快照默认包含内存、磁盘、设备等全部状态。内部快照示例：

# 创建一个快照
virsh snapshot-create fedora-10
# Domain snapshot 1473667716 created

# 列出Domain的快照
virsh snapshot-list fedora-10
#  Name                 Creation Time             State
# ------------------------------------------------------------
#  1473667716           2016-09-12 16:08:36 +0800 running

# 创建的是内部快照，可以使用底层命令查看
qemu-img info ~/Vmware/KVM/fedora-10/hda.img

注意，一旦创建了快照，Domain就不能被undefine。

要删除内部快照，可以执行：

virsh snapshot-delete fedora-10 1473667716
# Domain snapshot 1473667716 deleted

执行下面的命令创建一个外部快照： 

# 这里我们仅针对vda磁盘创建了快照，内存状态没有做快照
snapshot-create-as fedora-10 blankos "Initial snapshot" 
    --diskspec=vda,file=/home/alex/Vmware/KVM/fedora-10/blankos.vda.qcow2 --disk-only --atomic

现在查看客户机关联的块设备：

virsh domblklist fedora-10
# Target     Source
# ------------------------------------------------
# vda        /home/alex/Vmware/KVM/fedora-10/blankos.vda.qcow2

可以发现关联性转移到外部快照上了，原先的磁盘镜像成为Backing file。注意：Domain的后续写操作都发生在新创建的磁盘上

要删除外部快照，执行：

virsh snapshot-delete fedora-10 --metadata blankos

我们来创建三个快照：

DIR=/home/alex/Vmware/KVM/fedora-10
virsh snapshot-create-as fedora-10 snap0 "snap0" --diskspec=vda,file=$DIR/snap0.vda.qcow2 --disk-only --atomic
virsh snapshot-create-as fedora-10 snap1 "snap1" --diskspec=vda,file=$DIR/snap1.vda.qcow2 --disk-only --atomic
virsh snapshot-create-as fedora-10 snap2 "snap2" --diskspec=vda,file=$DIR/snap2.vda.qcow2 --disk-only --atomic

查看当前快照：

# 默认的，新创建的快照作为当前快照
virsh snapshot-current fedora-10 --name

查看快照链（Backing chain）：

virsh snapshot-list fedora-10 --tree
# vda.qcow2 是base
# snap0
#   |
#   +- snap1
#       |
#       +- snap2    这个是top

libvrit支持多种方式来管理磁盘的快照链：

方式一：基于blockcommit，合并到base镜像

我们可以清理快照链条，将snap2、snap1、snap0中的变更都提交到vda.qcow2中

# 必须在Domain运行着的情况下执行命令
virsh blockcommit fedora-10 vda --base $DIR/vda.qcow2 --top $DIR/snap2.vda.qcow2 --wait --verbose
# 目前带--delete参数会导致 error: unsupported flags (0x2) in function qemuDomainBlockCommit

提交后，可以安全的删除快照及其元数据（snapshot-delete --metadata），libvrit是分开管理backing链和snapshot列表的。 

方式二：基于blockpull，合并到top镜像

也可以反过来，把base一直pull到top位置（必须是叶子节点）的snapshot，然后此snapshot就成为完整的磁盘镜像了（不依赖backing镜像）： 

virsh blockpull fedora-10 --path $DIR/snap2.vda.qcow2 --base $DIR/vda.qcow2 --wait –verbose

方法三：基于blockcopy，可以在线迁移磁盘

首先，需要取消Domain定义，将其变为transient的：

# 导出Domain配置
virsh dumpxml --inactive fedora-10 $DIR/domain.xml
# 取消定义
virsh undefine fedora-10

然后执行拷贝：

# --shallow 浅拷贝，copy.vda.qcow2与snap2.vda.qcow2将具有相同的backing chain即base ⇦ snap0 ⇦ snap1
# --pivot  操作完成后，此Domain改用copy
virsh blockcopy --domain fedora-10 vda $DIR/copy.vda.qcow2 --wait --verbose --shallow --pivot

拷贝完成后，瞬时的Domain使用copy继续运行：

virsh domblklist fedora-10
# Target     Source
# ------------------------------------------------
# vda        /home/alex/Vmware/KVM/fedora-10/copy.vda.qcow2 

而原先的磁盘可以迁移走了。

要通过virsh来访问远程宿主机上的Domain时，需要提供URI。URI的格式如下：

driver[+transport]://[username@][hostname][:port]/[path][?extraparameters]

URI各部分说明如下：

要连接到远程宿主机，可以使用-c选项或者connect子命令：

virsh -c qemu+ssh://root@zircon.local/system

使用该transport时，需要注意配置文件：

# 这些项都是默认值
unix_sock_group = "libvirtd"
unix_sock_ro_perms = "0777"
unix_sock_rw_perms = "0770"

也就是说，用户必须加入到libvirtd组，才可以使用unix传输，否则会报错：error: Failed to connect socket to '/var/run/libvirt/libvirt-sock': Permission denied。执行下面的命令添加用户到组：

sudo usermod -a -G libvirtd alex

注意：连接到qemu时，不指定主机名默认使用unix socket。

在目标宿主机上，修改配置文件：

# 启用TCP监听
libvirtd_opts="-d -l"

然后再修改配置文件：

# 默认TCP监听是禁用的
listen_tcp = 1
# 可以修改监听地址和端口
listen_addr = "0.0.0.0"
tcp_port = "16509"
# 可以不启用验证，但是缺乏安全性，所有流量都是明文
auth_tcp = "none"

最后重启libvirtd即可。  

相关文章：Linux知识集锦 - cgroup

libvirt基于cgroup来限制客户机对宿主机资源的访问。libvirt不会尝试加载任何controllers，它只会检测哪些controllers被mount。

QEMU驱动支持cpuset, cpu, memory, blkio, devices这几个controller，修改配置文件/etc/libvirt/qemu.conf可以针对QEMU禁用某些controller。

LXC驱动支持 cpuset, cpu, cpuacct, freezer, memory, blkio,devices 这几个controller， 其中cpuacct, devices, memory是必须的，如果这几个controller没有被mount则容器不会被启动。

libvrit引入两个概念，以方便cgroups管理：

1. partitions：不包含任何进程的cgroup，仅仅包含资源控制规则，它可以包含多个子目录，这些子目录要么是partition要么是consumers
2. consumers：是包含了单个虚拟机/容器进程的cgroup

对于不使用systemd的宿主机，consumers命名规则为

$VMNAME.libvirt-{qemu,lxc}

ls /sys/fs/cgroup/cpu/machine
# fedora-10.libvirt-qemu  ...

直到cgroups布局后，你就可以直接读写cgroups文件系统，来控制客户机的资源访问。但是virsh也提供了一些命令在运行时控制资源访问。

1. 对于CPU访问控制，可以使用virsh schedinfo命令
2. 对于块设备的访问控制，可以使用virsh blkiotune命令
3. 对于网卡流量的控制，可以使用domiftune或者tc命令

该命令最常见的调用形式为：

virsh [OPTION]... <command> <domain> [ARG]...

1. command 是一个virsh子命令
2. domain 是操控的虚拟机的名称、ID或者UUID
3. ARG是针对特定子命令的参数
4. OPTION为一般性选项

# 列出子命令列表
virsh help
# 显示一个子命令的用法
virsh help define

dumpxml

virsh domblkstat fedora-10 vda

virsh domifstat fedora-10 tap0

virsh domiftune fedora-10 tap0

# 发送右侧Ctrl + C到fedora-10
virsh send-key fedora-10 KEY_RIGHTCTRL KEY_C
# 发送Ctrl + Alt + Del
virsh send-key debian-20 KEY_LEFTCTRL KEY_LEFTALT KEY_DELETE
# 发送TAB，按下1秒
virsh send-key fedora-10 --holdtime 1000 0xf 

virsh # domblklist debian-20
# Target     Source
# ------------------------------------------------
# vda        /home/alex/Vmware/KVM/debian-20/vda.qcow2
# hdd        /home/alex/Software/OS/debian-8.6.0-amd64-netinst.iso

change-media debian-20 --eject --live

这些子命令用来管理Domain的快照，快照是Domain的磁盘、内存、设备在某一个时刻的状态，这些状态可以在未来恢复。每个快照由唯一性的名字来识别。

vol-create default definitions/volumes/fedora-10.xml

virsh vol-create-as v12n1 centos7-base 128G --format qcow2

vol-delete --pool default fedora-10.qcow2

vol-dumpxml --pool default coreos.qcow2

vol-list default

模拟器QEMU和hypervisor KVM可以被libvirt管理。

如果driver检测到/usr/bin/qemu-system-*则QEMU可用；如果driver检测到设备节点/dev/kvm和可执行文件/usr/bin/qemu-kvm则支持KVM全虚拟化和客户机硬件加速。

QEMU的驱动是一个多实例驱动，包含一个系统级别的特权驱动（system实例）和多个用户级别的非特权驱动。驱动的URI的协议名为qemu，URI示例：

# 本地访问per-user的实例
qemu:///session
# 本地访问per-user的实例
qemu+unix:///session
# 本地访问系统级实例
qemu:///system
# 本地访问系统级实例
qemu+unix:///system 
# 基于 TLS/x50的远程访问
qemu://example.com/system 
# 基于SSH隧道远程访问
qemu+ssh://root@example.com/system

virsh domxml-from-native

1. 将QEMU命令行保存到文件qemu.cmd：

   /usr/bin/qemu-system-x86_64 -name fedora-10 -enable-kvm -cpu Haswell -daemonize -display none -m 512 -drive file=/home/alex/Vmware/KVM/fedora-10/hda.img,index=0,media=disk,if=virtio -netdev bridge,id=tap0,br=br0 -device virtio-net-pci,netdev=tap0,mac=DE:AD:BE:EF:F1:00

    
2. 执行命令：

   virsh domxml-from-native qemu-argv ~/Vmware/KVM/fedora-10/qemu.cmd ~/Vmware/KVM/fedora-10/domain.xml

    

生成的配置文件内容如下：

<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>
  <name>fedora-10</name>
  <uuid>51480ab5-864e-4eb7-9e1c-55b56105139e</uuid>
  <memory unit='KiB'>524288</memory>
  <currentMemory unit='KiB'>524288</currentMemory>
  <vcpu placement='static'>1</vcpu>
  <os>
    <type arch='x86_64' machine='pc'>hvm</type>
  </os>
  <features>
    <acpi/>
  </features>
  <cpu mode='custom' match='exact'>
    <model fallback='allow'>Haswell</model>
  </cpu>
  <clock offset='utc'/>
  <on_poweroff>destroy</on_poweroff>
  <on_reboot>restart</on_reboot>
  <on_crash>destroy</on_crash>
  <devices>
    <emulator>/usr/bin/qemu-system-x86_64</emulator>
    <disk type='file' device='disk'>
      <driver name='qemu' type='raw'/>
      <source file='/home/alex/Vmware/KVM/fedora-10/hda.img'/>
      <target dev='vda' bus='virtio'/>
    </disk>
    <controller type='usb' index='0'/>
    <controller type='pci' index='0' model='pci-root'/>
    <input type='mouse' bus='ps2'/>
    <input type='keyboard' bus='ps2'/>
    <graphics type='sdl'/>
    <video>
      <model type='cirrus' vram='9216' heads='1'/>
    </video>
    <memballoon model='virtio'/>
  </devices>
  <qemu:commandline>
    <qemu:arg value='-daemonize'/>
    <qemu:arg value='-display'/>
    <qemu:arg value='none'/>
    <qemu:arg value='-netdev'/>
    <qemu:arg value='bridge,id=tap0,br=br0'/>
    <qemu:arg value='-device'/>
    <qemu:arg value='virtio-net-pci,netdev=tap0,mac=DE:AD:BE:EF:F1:00'/>
  </qemu:commandline>
</domain>

可以看到，很多QEMU选项没有对应到常规的Domain配置元素，而是使用qemu:commandline的形式，在启动客户机的时候直接传递给QEMU了。因此，新建客户机时，不要使用这种导入配置的方法，而应调用libvirt API或者手工创建Domain的XML配置。

注意：virsh自动导入得到XML配置存在不少错误，需要调整后才能使用。上例修改后的配置如下：

<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>
    <name>fedora-10</name>
    <memory unit='KiB'>524288</memory>
    <currentMemory unit='KiB'>524288</currentMemory>
    <vcpu placement='static'>1</vcpu>
    <os>
        <type arch='x86_64' machine='pc'>hvm</type>
    </os>
    <features>
        <acpi/>
    </features>
    <cpu mode='custom' match='exact'>
        <model fallback='allow'>SandyBridge</model>
    </cpu>
    <clock offset='utc'/>
    <on_poweroff>destroy</on_poweroff>
    <on_reboot>restart</on_reboot>
    <on_crash>destroy</on_crash>
    <devices>
        <emulator>/usr/bin/qemu-system-x86_64</emulator>
        <disk type='file' device='disk'>
            <driver name='qemu' type='qcow2'/> <!-- 镜像格式要设置对 -->
            <source file='/home/alex/Vmware/KVM/fedora-10/hda.img'/>
            <target dev='vda' bus='virtio'/>
            <boot order='1'/>  <!-- 要指定启动顺序，否则不会从此硬盘启动系统 -->
        </disk>
        <controller type='usb' index='0'/>
        <controller type='pci' index='0' model='pci-root'/>
        <!-- 把基于qemu:commandline的网络配置改为标准的Domain配置方式 -->
        <interface type='bridge'>
            <mac address='DE:AD:BE:EF:F1:00'/>
            <source bridge='br0'/>
            <target dev='tap0'/>
            <model type='virtio'/>
        </interface> 
        <!-- 添加串口控制台配置，去掉视频相关配置 -->
        <serial type='pty'>
            <target port='0'/>
        </serial>
        <console type='pty'>
            <target type='serial' port='0'/>
        </console>
        <input type='mouse' bus='ps2'/>
        <input type='keyboard' bus='ps2'/>
        <memballoon model='virtio'/>
    </devices>
</domain> 

类似的，可以把Domain配置文件转换为QEMU命令行：

virsh domxml-to-native qemu-argv ~/Vmware/KVM/fedora-10/domain.xml

libvirt使用XML文件描述一个Domain的全部配置信息：

<!--
任何Domain配置的根元素都是domin，它有两个属性：
    type 驱动（hypervisor）的类型，可选值：xen | kvm | qemu | lxc | kqemu
    id 正在运行的Domain的唯一标识，整数。非活动Domain没有id
-->
<domain type='kvm' id='1'>
    <!-- 在单个node下唯一的虚拟机名字 -->
    <name>fedora-10</name>
    <!-- RFC 4122兼容的、虚拟机的全局唯一标识，如果在定义/创建虚拟机时不指定，则会自动生成一个  -->
    <uuid>4dea22b31d52d8f32516782e98ab3fa0</uuid>
    <!-- 虚拟机的简短描述，可以多行 -->
    <title>A short description</title>
    <!-- 虚拟机的描述-->
    <description>Some human readable description</description>
    <!-- 元数据：由应用程序使用，子树必须使用应用程序自己的名字空间 -->
    <metadata>
        <app1:foo xmlns:app1="http://app1.org/app1/">..</app1:foo>
        <app2:bar xmlns:app2="http://app1.org/app2/">..</app2:bar>
    </metadata>
</domain>

下面介绍如何配置Domain各方面的细节。

虚拟机可以不同的方式启动，各有其优缺点。

对于全虚拟化的hypervisor可以选择通过BIOS启动，BIOS定义启动优先级，来确定从软盘、硬盘、光驱还是网络获取启动镜像（boot image）。配置示例：

<os>
    <type>hvm</type>
    <loader readonly='yes' secure='no' type='rom'>/usr/lib/xen/boot/hvmloader</loader>
    <nvram template='/usr/share/OVMF/OVMF_VARS.fd'>/var/lib/libvirt/nvram/guest_VARS.fd</nvram>
    <boot dev='hd'/>
    <boot dev='cdrom'/>
    <bootmenu enable='yes' timeout='3000'/>
    <smbios mode='sysinfo'/>
    <bios useserial='yes' rebootTimeout='0'/>
</os>

各子元素的说明如下：

当启动基于容器虚拟化的Domain时，需要指定一个init程序：

<os>
    <type arch='x86_64'>exe</type>
    <!-- init binary -->
    <init>/bin/systemd</init>
    <!-- argumsnts -->
    <initarg>--unit</initarg>
    <initarg>emergency.service</initarg>
</os>

如果你要启用user namespace映射，可以：

<idmap>
    <!-- start容器内第1个用户的ID，target容器内第1个用户映射到宿主机的用户的ID，count容器最多映射宿主机多少用户-->
    <uid start='0' target='1000' count='10'/>
    <gid start='0' target='1000' count='10'/>
</idmap>

<os>
    <smbios mode='sysinfo'/>
</os>
<!-- type属性必须，它的值决定子元素第布局-->
<sysinfo type='smbios'>
    <bios>
        <entry name='vendor'>LENOVO</entry>
    </bios>
    <system>
        <entry name='manufacturer'>Fedora</entry>
        <entry name='product'>Virt-Manager</entry>
        <entry name='version'>0.9.4</entry>
    </system>
    <baseBoard>
        <entry name='manufacturer'>LENOVO</entry>
        <entry name='product'>20BE0061MC</entry>
        <entry name='version'>0B98401 Pro</entry>
        <entry name='serial'>W1KS427111E</entry>
    </baseBoard>
</sysinfo>

配置示例如下：

<vcpu placement='static' cpuset="1-4,^3,6" current="1">2</vcpu>
<vcpus>
    <vcpu id='0' enabled='yes' hotpluggable='no' order='1'/>
    <vcpu id='1' enabled='no' hotpluggable='yes'/>
</vcpus>

此元素定义客户机最大的虚拟CPU的数量，有效值的范围是1-hypervisor支持的最大数量。属性说明如下：

此元素控制每个单独虚拟CPU的状态，每个vcpu子元素对应一个虚拟CPU，vcpu子元素的属性说明如下：

cputune元素可以对Domain的虚拟CPU进行微调，配置示例如下：

<cputune>
    <vcpupin vcpu="0" cpuset="1-4,^2"/>
    <vcpupin vcpu="1" cpuset="0,1"/>
    <vcpupin vcpu="2" cpuset="2,3"/>
    <vcpupin vcpu="3" cpuset="0,4"/>
    <emulatorpin cpuset="1-3"/>
    <iothreadpin iothread="1" cpuset="5,6"/>
    <iothreadpin iothread="2" cpuset="7,8"/>
    <shares>2048</shares>
    <period>1000000</period>
    <quota>-1</quota>
    <emulator_period>1000000</emulator_period>
    <emulator_quota>-1</emulator_quota>
    <iothread_period>1000000</iothread_period>
    <iothread_quota>-1</iothread_quota>
    <vcpusched vcpus='0-4,^3' scheduler='fifo' priority='1'/>
    <iothreadsched iothreads='2' scheduler='batch'/>
</cputune>

各子元素说明如下：

IO线程是一种专门的事件循环线程，用于提高磁盘Block I/O的scalability，这些线程会分配给支持的磁盘设备。每个物理CPU只有1-2个IO线程，每个IO线程也可能分配给多个磁盘设备。配置示例：

<!-- 分配给Domain使用的IO线程数-->
<iothreads>4</iothreads>

<!-- 定义每个IO线程的ID -->
<iothreadids>
    <iothread id="2"/>
    <iothread id="4"/>
    <iothread id="6"/>
    <iothread id="8"/>
</iothreadids>

配置示例如下：

<maxMemory slots='16' unit='KiB'>1524288</maxMemory>
<memory unit='KiB'>524288</memory>
<currentMemory unit='KiB'>524288</currentMemory>

各元素说明如下：

memoryBacking元素控制虚拟内存页如何映射到宿主机的内存页，配置示例：

<memoryBacking>
    <hugepages>
        <!-- 为了除4之外的numa节点分配1G的巨页 -->
        <page size="1" unit="G" nodeset="0-3,5"/>
        <page size="2" unit="M" nodeset="4"/>
    </hugepages>
    <nosharepages/>
    <locked/>
</memoryBacking>

子元素说明如下：

memtune提供Domain的内存微调参数，如果不设置这些参数，则使用OS提供的默认值。对于QEMU/KVM，这些参数限制包含QEMU进程本身的内存消耗

<memtune>
    <hard_limit unit='G'>1</hard_limit>
    <soft_limit unit='M'>128</soft_limit>
    <swap_hard_limit unit='G'>2</swap_hard_limit>
    <min_guarantee unit='bytes'>67108864</min_guarantee>
</memtune>

子元素说明如下：

numatune元素通过控制针对Domain进程的numa策略来影响宿主机的性能，配置示例如下：

<numatune>
    <memory mode="strict" nodeset="1-4,^3"/>
    <memnode cellid="0" mode="strict" nodeset="1"/>
    <memnode cellid="2" mode="preferred" nodeset="2"/>
</numatune>

子元素说明如下：

blkiotune元素能够微调Domain的Blkio cgroup可调整参数，如果不指定此元素，则使用OS默认值。配置示例如下：

<blkiotune>
    <weight>800</weight>
    <device>
        <path>/dev/sda</path>
        <weight>1000</weight>
    </device>
    <device>
        <path>/dev/sdb</path>
        <weight>500</weight>
        <read_bytes_sec>10000</read_bytes_sec>
        <write_bytes_sec>10000</write_bytes_sec>
        <read_iops_sec>20000</read_iops_sec>
        <write_iops_sec>20000</write_iops_sec>
    </device>
</blkiotune>

子元素说明如下：

对CPU型号、特性的要求，以及它的拓扑结构的要求，可以使用如下方式配置：

<cpu match='exact'>
    <model fallback='allow'>core2duo</model>
    <vendor>Intel</vendor>
    <topology sockets='1' cores='2' threads='1'/>
    <feature policy='disable' name='lahf_lm'/>
</cpu>

<cpu mode='host-model'>
    <model fallback='forbid'/>
    <topology sockets='1' cores='2' threads='1'/>
</cpu>

<cpu mode='host-passthrough'>
    <feature policy='disable' name='lahf_lm'/>
</cpu>

cpu元素是描述客户机CPU需求的容器元素，它的属性如下：

<numa>
    <cell id='0' cpus='0-3' memory='512000' unit='KiB'/>
    <cell id='1' cpus='4-7' memory='512000' unit='KiB' memAccess='shared'/>
</numa>

你可能需要覆盖某些事件发生时采取的动作，注意并非所有hypervisors支持所有事件和动作。使用

virsh reboot

virsh shutdown

<on_poweroff>destroy</on_poweroff>
<on_reboot>restart</on_reboot>
<on_crash>restart</on_crash>
<on_lockfailure>poweroff</on_lockfailure>

 事件类型采用元素表示：

这几种事件都支持的动作包括：

1. destroy，终止Domain并释放一切相关资源
2. restart，Domain被终止，并以相同的配置再次启动
3. preserve，Domain被终止但是其资源被保留供分析
4. rename-restart，以另外一个名字重启Domain

on_crash支持额外的动作：

1. coredump-destroy，崩溃Domain的core被dump出来，然后destroy
2. coredump-restart，崩溃Domain的core被dump出来，然后重启

仅QEMU支持，强制启用/禁止客户机BIOS的电源管理功能：

<pm>
    <!-- 是否启用ACPI的S4睡眠状态 -->
    <suspend-to-disk enabled='no'/>
    <!-- 是否启用ACPI的S3睡眠状态 -->
    <suspend-to-mem enabled='yes'/>
</pm>

Hypervisor能够启用/禁用一些CPU/机器特性。配置示例：

<features>
    <pae/> <!-- 物理地址扩展，允许32位客户机访问超过4GB内存 -->
    <acpi/> <!-- 对于电源管理有用，例如可以优雅的关闭KVM客户机 -->
    <apic/> <!-- 支持可编程的中断请求管理 -->
    <hap/>  <!-- 根据state=on|off，启禁硬件辅助paging -->
    <privnet/> <!-- 总是创建私有的网络命名空间，如果任何网络接口设备被添加，则自动设置。仅和容器虚拟化相关 -->
    <hyperv> <!-- 调整Windows客户机的性能，仅QEMU2.x -->
        <relaxed state='on'/>
        <vapic state='on'/>
        <spinlocks state='on' retries='4096'/>
        <vpindex state='on'/>
        <runtime state='on'/>
        <synic state='on'/>
        <reset state='on'/>
        <vendor_id state='on' value='KVM Hv'/>
    </hyperv>
    <kvm>
        <hidden state='on'/> <!-- 从标准的MSR发现中隐藏KVM的Hypervisor -->
    </kvm>
    <pvspinlock state='on'/>  <!-- 通知客户机，宿主机支持半虚拟化的自旋锁 -->
</features>

客户机的时间通常是基于宿主机时间来初始化的，大部分OS期望硬件中存储的是UTC时间，然而Windows期望的则是“本地时间”。

配置示例：

<clock offset='localtime'>
    <timer name='rtc' tickpolicy='catchup' track='guest'>
        <catchup threshold='123' slew='120' limit='10000'/>
    </timer>
    <timer name='pit' tickpolicy='delay'/>
</clock>

clock的offset属性控制客户机的时间如何与宿主机同步：

1. utc，客户机启动时总是基于UTC时间来同步
2. localtime，客户机启动时基于宿主机的timezone配置来同步时间
3. timezone，客户机基于指定的时区来同步
4. variable，客户机的时钟相对于UTC或者localtime（由basis属性指定，默认utc）具有一定的偏移，偏移量单位秒，由adjustment指定

提供给客户机的所有设备，都在

<devices>

可以使用下面的元素来指定模拟器全限定的路径：

<devices>
    <emulator>/usr/lib/xen/bin/qemu-dm</emulator>
</devices>

capabilities的XML配置指明了特定Domain类型-体系结构组合对应的最佳模拟器。

任何软盘、硬盘、光盘或者半虚拟化的驱动器，都是通过

disk

<devices>
    <!-- 后端支持是文件的磁盘，使用外部快照 -->
    <disk type='file' snapshot='external'>
        <!-- xen的驱动微调 -->
        <driver name="tap" type="aio" cache="default"/>
        <!-- 磁盘的源——文件的位置 -->
        <source file='/var/lib/xen/images/fv0' startupPolicy='optional'>
            <seclabel relabel='no'/>
        </source>
        <!-- 磁盘在客户机中的期望设备名，总线类型 -->
        <target dev='hda' bus='ide'/>
        <!-- IO节流阀 -->
        <iotune>
            <total_bytes_sec>10000000</total_bytes_sec>
            <read_iops_sec>400000</read_iops_sec>
            <write_iops_sec>100000</write_iops_sec>
        </iotune>
        <!-- 该磁盘可以作为启动盘，顺序2 -->
        <boot order='2'/>
        <!-- 启用磁盘加密 -->
        <encryption type='...'>
            ...
        </encryption>
        <shareable/><!-- 磁盘可以被多个Domain共享-->
        <serial>...</serial><!-- 指定磁盘序列号 -->
    </disk>
    <!-- 该磁盘的源位于网络上 -->
    <disk type='network'>
        <!-- QEMU驱动微调，指定AIO基于pthread -->
        <driver name="qemu" type="raw" io="threads" ioeventfd="on" event_idx="off"/>
        <!-- 基于sheepdog的网络源 -->
        <source protocol="sheepdog" name="image_name">
            <host name="hostname" port="7000"/><!-- 磁盘源所在的主机 -->
        </source>
        <target dev="hdb" bus="ide"/>
        <boot order='1'/>
        <transient/>
        <address type='drive' controller='0' bus='1' unit='0'/>
    </disk>
    <disk type='network'>
        <driver name="qemu" type="raw"/>
        <source protocol="rbd" name="image_name2">
            <host name="hostname" port="7000"/>
            <snapshot name="snapname"/>
            <config file="/path/to/file"/>
        </source>
        <target dev="hdc" bus="ide"/>
        <!-- 提供网络身份验证信息 -->
        <auth username='myuser'>
            <secret type='ceph' usage='mypassid'/>
        </auth>
    </disk>
    <!-- 定义一个光驱设备 -->
    <disk type='block' device='cdrom'>
        <driver name='qemu' type='raw'/>
        <target dev='hdd' bus='ide' tray='open'/>
    </disk>
    <!-- 定义一个光驱设备，使用ISO镜像文件 -->
    <disk type='file' device='cdrom'>
        <driver name='qemu' type='raw'/>
        <!-- 使用镜像文件 -->
        <source file='/home/alex/Vmware/KVM/coreos.iso'/>
        <target dev='hdd' bus='ide'/>
        <readonly/>
    </disk>
    <!-- 从libvirt管理的存储池中取得源 -->
    <disk type='volume' device='disk'>
        <driver name='qemu' type='qcow2'/>
        <source pool="default" volume="coreos.qcow2" />
        <target dev='vda' bus='virtio'/>
        <boot order='1'/>
    </disk>
    <!-- 来自iscsi池的源 -->
    <disk type='network' device='disk'>
        <driver name='qemu' type='raw'/>
        <source protocol='iscsi' name='iqn.gmem.cc.example:iscsi-nopool/2'>
            <host name='example.com' port='3260'/>
        </source>
        <auth username='myuser'>
            <secret type='iscsi' usage='libvirtiscsi'/>
        </auth>
        <target dev='vda' bus='virtio'/>
    </disk>
    <!-- 来自iscsi池的源，lun与disk不同的是，客户机的请求直接pass through到物理设备 -->
    <disk type='network' device='lun'>
        <driver name='qemu' type='raw'/>
        <source protocol='iscsi' name='iqn.gmem.cc.example:iscsi-nopool/1'>
            <host name='example.com' port='3260'/>
        </source>
        <auth username='myuser'>
            <secret type='iscsi' usage='libvirtiscsi'/>
        </auth>
        <target dev='sdb' bus='scsi'/>
    </disk>
    <disk type='file' device='disk'>
        <driver name='qemu' type='qcow2'/>
        <source file='/var/lib/libvirt/images/domain.qcow'/>
        <!-- 多级嵌套的backing store -->
        <backingStore type='file'>
            <format type='qcow2'/>
            <source file='/var/lib/libvirt/images/snapshot.qcow'/>
            <backingStore type='block'>
                <format type='raw'/>
                <source dev='/dev/mapper/base'/>
                <backingStore/>
            </backingStore>
        </backingStore>
        <target dev='vdd' bus='virtio'/>
    </disk>
</devices>

 指定磁盘的来源（source），其包含的属性依赖于disk的type属性：

source子元素可以包含以下子元素：

紧跟着source元素，用于指定磁盘使用的backing store ，backing store是构成磁盘的逻辑成分（类似于QEMU的backing file）。如果不指定此元素，则意味着source是自包含的。backingStore元素的属性列表如下：

backingStore可以有下列子元素：

此子元素控制虚拟磁盘在什么总线/设备下暴露给客户机。属性如下：

针对单块磁盘进行IO微调，与 blkiotune 功能类似，但是后者针对Domain全局。

目前可设置的微调项都是针对QEMU的IO throttling微调，这些微调由子元素指定，取值0表示无限制。子元素列表：

与hypervisor驱动相关的更多细节配置，属性列表：

用于指定该磁盘是可启动的，order属性指定其启动顺序。

指定卷如何被加密。

指定此磁盘不能被客户机修改，对于device=cdrom的设备默认true。

假设hypervisor和OS支持的话，指示此设备可以被多个Domain共享。指定此元素，应当同时禁用磁盘的缓存。

指示当客户机退出时，对磁盘的所有修改将回退。对于某些hypervisor，把磁盘标记为transient会禁止快照与迁移。

指定磁盘的序列号。

指定磁盘的世界范围名称（World Wide Name），此值必须唯一，由16位16进制数字组成。

指定磁盘的生产厂商，不超过8个可打印字符

指定磁盘的产品名称，不超过16个可打印字符

很多设备可以提供一个address 子元素，来指明设备挂载客户机虚拟总线的什么位置上。如果不指定address，libvirt会生成一个合适的地址。该子元素的属性列表如下：

对于disk.type=network，且protocol为rbd、iscsi的磁盘，可以指定此子元素，提供访问磁盘源时使用的凭据。

用于QEMU/KVM，覆盖块设备的属性。属性列表：

使用filesystem元素可以把宿主机上的目录直接暴露给客户机访问，配置示例：

<devices>
    <filesystem type='template'>
        <source name='my-vm-template'/><!-- OpenVZ模板名称 -->
        <target dir='/'/>
    </filesystem>
    <filesystem type='mount' accessmode='passthrough'>
        <driver type='path' wrpolicy='immediate'/>
        <source dir='/export/to/guest'/> <!-- 指定宿主机目录 -->
        <target dir='/import/from/host'/>
        <readonly/>
    </filesystem>
    <filesystem type='file' accessmode='passthrough'>
        <driver name='loop' type='raw'/>
        <driver type='path' wrpolicy='immediate'/>
        <source file='/export/to/guest.img'/>
        <target dir='/import/from/host'/>
        <readonly/>
    </filesystem>
</devices>

filesystem元素的属性列表：

子元素列表：

有几种方式（type）来指定客户机能够看到的网络接口，网络接口的容器元素是

interface

对于基于动态地址分配/无线网络的宿主机获得连接性的虚拟机，推荐此方式。

虚拟网络提供一个其详细信息由一个命名网络定义（named network definition）所描述的连接。依据虚拟网络的转发模式（forward mode）设置，它可能是：

1. 完全隔离的，不配置

   <forward>

    元素
2. NAT到一个指定的网络设备或者默认路由，配置

   <forward mode='nat'>

    
3. 不基于NAT来路由，配置

   <forward mode='route'/>

    
4. 直接连接到宿主机的网络接口（通过macvtap）或桥接设备，配置

   <forward mode='bridge|private|vepa|passthrough'/>

    

对于转发模式设置为bridge | private | vepa | passthrough的网络，宿主机在libvirt管理范围之外应拥有必要的DNS、DHCP服务。对于转发模式设置为isolated | nat |routed的网络，libvirt提供的虚拟网络中包含了DHCP和DNS。虚拟网络自动分配的IP地址范围可以通过命令

virsh net-dumpxml [networkname]

得到。一个开箱即用的、称为default的虚拟网络NAT到宿主机默认路由，其IP地址范围是192.168.122.0/24，在宿主机中你可以ifconfig看到一个名为virbr0的网络接口，与这个default虚拟网络有关。要自定义虚拟网络，需要修改其它类型（network XML）的配置文件L。

每个客户机会有一个命名为

vnetN

类似于direct类型的接口，network类型的接口可以指定一个virtualport子元素，用于将配置信息转发给vepa（802.1Qbg）或 802.1Qbh兼容的交换机，或Open vSwich虚拟交换机。

配置示例：

<devices>
    <interface type='network'>
        <!-- 如果接口的source是一个网络，则可以设置soure元素的portgroup属性，一个网络可能定义了多个portgroup，
             每个portgroup包含些许不同的配置信息，用于不同类别的网络连接 -->
        <source network='default'/>
    </interface>
    <interface type='network'>
        <!-- -->
        <source network='default' portgroup='engineering'/>
        <target dev='vnet7'/>  <!-- 设置虚拟网卡的名称 -->
        <mac address="00:11:22:33:44:55"/><!-- 设置虚拟网卡的MAC地址 -->
        <virtualport>
            <parameters instanceid='09b11c53-8b5c-4eeb-8f00-d84eaa0aaa4f'/>
        </virtualport>
    </interface>
</devices>

对于基于静态地址的有线网络的宿主机获得连接性的虚拟机，推荐此方式。

该方式将虚拟机直接桥接到宿主机所在的局域网，libvirt假设宿主机上的网桥设备enslaved了1-N个物理网卡。客户机的IP地址范围与宿主机局域网的IP地址范围一样。

在Linux系统中，网桥通常是标准的Linux主机网桥（host bridge）。如果主机支持Open vSwitch，则可以添加

<virtualport type='openvswitch'/>

每个客户机会有一个命名为

vnetN

配置示例：

<interface type='bridge'>
    <!-- 桥接到宿主机的br0网桥 -->
    <source bridge='br0'/>
</interface>
<interface type='bridge'>
    <source bridge='br1'/>
    <!-- 设置客户机中虚拟网卡的名称和MAC -->
    <target dev='vnet7'/>
    <mac address="00:11:22:33:44:55"/>
</interface>
<interface type='bridge'>
    <source bridge='ovsbr'/>
    <!-- 连接到Open vSwitch -->
    <virtualport type='openvswitch'>
        <!-- interfaceid是此虚拟网卡的唯一标识，如果不指定自动生成；profileid作为虚拟网卡的port-profile发送给vSwitch -->
        <parameters profileid='menial' interfaceid='09b11c53-8b5c-4eeb-8f00-d84eaa0aaa4f'/>
    </virtualport>
</interface>

提供一个虚拟局域网并NAT到外面的世界，此虚拟网络使用10.0.2.x网段。默认路由10.0.2.2，DNS服务器10.0.2.3，客户机地址从10.0.2.15开始。此网络仅仅用于没有特权的宿主机用户。配置示例：

<interface type='user'/>
<interface type='user'>
    <mac address="00:11:22:33:44:55"/>
</interface>

如果hypervisor支持，则可以设置虚拟网卡的型号。示例：

<interface type='network'>
    <model type='ne2k_pci'/>
</interface>

QEMU支持的型号包括 ne2k_isa i82551 i82557b i82559er ne2k_pci pcnet rtl8139 e1000 virtio。

可以设置网卡是启用还是断开的：

<interface type='network'>
    <link state='down'/>
</interface>

网络设备、具有网络特性的hostdev设备可以配置一个或者多个IP地址，某些hypervisor会忽略这些配置。配置示例：

<devices>
    <interface type='network'>
        <source network='default'/>
        <target dev='vnet0'/>
        <ip address='192.168.122.5' prefix='24'/>
        <!-- peer指定点对点连接中对端的IP地址 -->
        <ip address='192.168.122.5' prefix='24' peer='10.0.0.10'/>
        <!-- route仅用于LXC -->
        <route family='ipv4' address='192.168.122.0' prefix='24' gateway='192.168.122.1'/>
        <route family='ipv4' address='192.168.122.8' gateway='192.168.122.1'/>
    </interface>
    <hostdev mode='capabilities' type='net'>
        <source>
            <interface>eth0</interface>
        </source>
        <ip address='192.168.122.6' prefix='24'/>
        <route family='ipv4' address='192.168.122.0' prefix='24' gateway='192.168.122.1'/>
        <route family='ipv4' address='192.168.122.8' gateway='192.168.122.1'/>
    </hostdev>
</devices> 

配置图形（Graphical）设备，可以让你与客户机进行图形化的交互。客户机通常提供一个framebuffer或者text console，作为人机接口。配置示例：

<!-- 基于SDL的图形接口，弹出QEMU的图形化控制台窗口 -->
<graphics type='sdl' display=':0' xauth='/home/alex/.Xauthority'/>
<!-- 基于VNC的图形接口 -->
<graphics type='vnc' port='-1' autoport='yes' listen='0.0.0.0' sharePolicy='allow-exclusive'>
    <listen type='address' address='0.0.0.0'/>
</graphics>

<graphics type='rdp' autoport='yes' multiUser='yes'/>
<graphics type='desktop' fullscreen='yes'/>
<graphics type='spice'>
    <listen type='network' network='rednet'/>
</graphics>

根据强制属性type的取值，grpahics的属性、子元素有所差异：

<channel name='main' mode='secure'/>
<channel name='record' mode='insecure'/>

<image compression='auto_glz'/> 

<streaming mode='filter'/>

<clipboard copypaste='no'/> 

<mouse mode='client'/>

<filetransfer enable='no'/>

<gl enable='yes'/>

用于指明在何处监听客户机连接。

video是描述视频设备的容器，为了向后兼容，如果配置了graphics却没有配置video，libvirt会根据客户机的类型自动添加一个video。配置示例：

<!-- 默认第一个配置video是主视频设备，可以用primary属性覆盖 -->
<video primary='yes'>
    <model type='vga' vram='16384' heads='1'>
        <acceleration accel3d='yes' accel2d='yes'/>
    </model>
</video>
<video>
   <!-- 下面的配置是KVM客户机的默认值 -->
   <model type='cirrus' vram='16384' heads='1' />
</video>

子元素说明如下：

libguestfs是一组工具集，用来（在不启动客户机的情况下）访问、修改虚拟机的磁盘文件，通过libguestfs你可以好对磁盘进行以下操作：

1. 查看或者修改文件
2. 创建虚拟磁盘
3. 改变虚拟磁盘大小
4. 执行磁盘备份、克隆等操作

libguestfs支持多种虚拟磁盘格式，包括Vmware、Hyper-V。日常工作中我们主要使用libguestfs提供的命令行guestfish。libguestfs不依赖于libvirt。

与libguestfs类型工具包括：

1. kpartx 需要root权限，并且将文件系统挂载到宿主机的内核中。相比之下libguestfs把文件系统隔离在appliance中，安全性高
2. vdfuse 该工具类似于kpartx，但是仅仅针对VirtualBox虚拟磁盘
3. qemu-nbd  用QEMU提供的工具，基于QEMU支持的磁盘格式（raw、qcow2）构建网络块服务器。libguestfs可以与之配合使用：
   

   guestfish -a nbd://remote

执行下面的命令安装libguestfs：

sudo apt-get install libguestfs-tools

在Ubuntu下，需要执行：

sudo chmod 0644 /boot/vmlinuz* 

否则在使用过程中你会遇到cp: cannot open '/boot/vmlinuz-4.4.0-38-generic' for reading: Permission denied错误。

执行下面的命令，以编辑一个虚拟磁盘：

# 附加-v参数，可以看到很多调试信息，例如appliance的启动过程日志
guestfish -a vda.qcow2

# 出现提示符
><fs> 

# 添加一个磁盘，只能在run之前执行
# add-drive filename [readonly:true|false] [format:..] [iface:..] [name:..] [label:..] [protocol:..] [server:..]
add-drive vdb,qcow2 format:qcow2

# 执行run命令，一个appliance（类似于微型虚拟机）会被启动
><fs> run

# 列出设备
><fs> list-devices
# 输出：/dev/sda

# 列出分区
><fs> list-partitions
# 输出：
# /dev/sda1
# /dev/sda2

# 显示各分区详细信息
><fs> part-list /dev/sda
# [0] = {
#   part_num: 1
#   part_start: 1048576
#   part_end: 525336575
#   part_size: 524288000
# }
# [1] = {
#   part_num: 2
#   part_start: 525336576
#   part_end: 17179869183
#   part_size: 16654532608
# }
# 测试第一个分区是否可启动
><fs> part-get-bootable /dev/sda 1
# 其它分区相关命令： part-add，part-del，part-disk，part-get-bootable，part-get-gpt-type，part-get-mbr-id，
#                 part-get-name，part-get-parttype，part-init，part-list，part-set-bootable，part-set-gpt-type，
#                 part-set-mbr-id，part-set-name，part-to-dev，part-to-partnum

# 操作LVM
# 显示物理卷详细信息
pvs-full 
# 显示逻辑卷组详细信息
vgs-full
# 其它LVM相关命令：
# lvcreate, lvcreate-free, lvm-canonical-lv-name, lvm-clear-filter, lvm-remove-all, lvm-set-filter, 
# lvremove, lvrename, lvresize, lvresize-free, lvs, lvs-full, lvuuid, pvcreate, pvremove, pvresize, 
# pvresize-size, pvs, pvs-full, pvuuid, vg-activate, vg-activate-all, vgchange-uuid, vgchange-uuid-all, 
# vgcreate, vglvuuids, vgmeta, vgpvuuids, vgremove, vgrename, vgs, vgs-full, vgscan, vguuid
# 列出文件系统
><fs> list-filesystems
# 输出：
# /dev/sda1: ext4
# /dev/fedora_bogon/root: xfs
# /dev/fedora_bogon/swap: swap

# 挂载文件系统
><fs> mount /dev/fedora_bogon/root /

# 列出目录
><fs> ls /
# 创建新目录
><fs> mkdir /temp
# 其它支持的文件系统命令包括：cp chown chmod cp

# 下载文件到当前目录
download /root/.bash_history test
# 上传文件到虚拟磁盘
upload test /temp/test

# 查看文件内容
cat /temp/test

# 退出
><fs> quit

执行run子命令后，需要等待一会，这时libguestfs在启动一个 appliance。再此appliance中会运行一个Linux内核，LVM、ext2等用户空间工具，以及一个守护程序guestfsd。宿主机进程基于RPC与这个守护进程通信，完成对磁盘镜像的操作。

该命令可以把虚拟磁盘挂载到宿主机的目录上：

# 创建挂载点
mkdir vda
# 挂载一个文件系统
guestmount -a vda.qcow2 --rw -m /dev/fedora_bogon/root vda
# 现在你可以在宿主机中修改虚拟磁盘中的文件
# 操作完毕后，取消挂载
guestunmount vda

该命令可以用来快速的创建虚拟机磁盘镜像：

# 列出所有支持的客户机类型
virt-builder --list
# 创建一个Fedora 24的虚拟磁盘镜像，第一次使用某个客户机类型，需要从网络上下载镜像文件
virt-builder fedora-24 
    -o fedora-24.qcow2 --format qcow2 --size 20G 
    --hostname fedora-24-01   # 设置主机名
    --root-password file:/tmp/pswd  # 设置root密码，密码从文件中读取
    --install "apache2"  # 安装软件
    --firstboot  /tmp/fb.sh  # 第一次启动时执行的脚本

virt-ls -a vda.qcow2 /

virt-cat -a vda.qcow2 /root/.bashrc

virt-copy-in -a vda.qcow2 hello /root/

virt-copy-out -a vda.qcow2 /root/hello .

通过配置libvirt的虚拟局域网，可以简化Domain的网络接口配置，比QEMU的脚本方式好很多。此外虚拟局域网还提供DHCP服务。

libvirt引入了virtual network switch的概念，这是运行在宿主机上的软件。客户机可以“插入”到这个交换机上并传递流量。在Linux宿主机上，这个交换机表现为网络接口——默认情况下名字为virbr0，这个接口实质上是一个网桥。

默认情况下虚拟网络交换机工作在NAT模式下，实质上是基于宿主机的iptables设置IP遮掩（不使用SNAT/DNAT），客户机对外通信时，使用宿主机的IP地址。

与NAT不同，这种模式直接转发客户机的IP封包，不进行NAT转换。这需要物理网络的路由器配置适当的路由，让客户机子网的流量流向所在的宿主机。

这种模式下，虚拟网络交换机不把客户机的IP封包转发到真实网络上去。只有宿主机、各客户机之间可以进行通信。

每个虚拟网络交换机可以设置一个用于动态分配的IP地址范围，供连接到此交换机的客户机使用，客户机可以通过DHCP服务自动获得IP地址。

libvirt基于dnsmasq实现DHCP和DNS，对于每个需要DHCP的虚拟网络交换机，libvirt在宿主机上启动一个dnsmasq实例。

除了简单的DNS请求转发，dnsmasq可以做更多的事情：

1. 它可以读取宿主机的 /etc/hosts 中条目，来应答DNS查询请求

一个可能的虚拟网络架构的逻辑图如下：

对应的物理拓扑如下：

其中：

1. VLAN 1，这个虚拟局域网通过网桥virbr0与eth1进行桥接，并基于NAT连接到真实局域网lan2
2. VLAN 2，这个虚拟局域网桥接到virbr0，但是与真实局域网完全隔离
3. Guest A，该虚拟机的：
   1. eth0桥接到宿主机的网桥eth0，后者直接连接到真实网卡pth0，从而与lan1互联
   2. eth1桥接到virbr0，可以基于NAT受限访问lan2
4. Guest B，基于NAT、隔离网络
5. Guest C，基于隔离网络

# 列出所有活动的虚拟局域网，libvrit默认创建一个桥接到virbr0的vlan，名为default
virsh net-list
#  Name                 State      Autostart     Persistent
# ----------------------------------------------------------
#  default              active     yes           yes

# 列出所有虚拟局域网
virsh net-list --all

# 显示一个虚拟局域网的详细信息
net-info default
# Name:           default
# UUID:           e9e308a3-dea9-46dc-bc92-fad27f2a970a
# Active:         yes
# Persistent:     yes
# Autostart:      yes
# Bridge:         virbr0

# 导出一个虚拟局域网的XML
virsh net-dumpxml default

# 定义一个新的虚拟局域网
virsh net-define /home/alex/Vmware/KVM/vlans/default.xml
# 解除虚拟局域网定义
virsh net-undefine default

# 关闭一个虚拟局域网
virsh net-destroy default

# 将一个虚拟局域网标记为自动启动
net-autostart default

# 启动虚拟局域网，启动后，宿主机上可能出现一个网桥设备
net-start default

类似于Domain，虚拟局域网的配置也是存放在XML文件中的。每个虚拟局域网对应一个XML配置文件，根元素为network。包括属性：

包含以下基本子元素：

以下子元素用于配置VLAN的连通性：

<bridge name='br'/>

<virtualport type='openvswitch'/>

<interface dev='eth0' />

# sudo iptables -t nat -L -nv

Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in  out     source         destination         
    0     0 MASQUERADE  tcp  --  *   wlan0   10.0.0.0/16   !10.0.0.0/16   masq ports: 1024-65535
    0     0 MASQUERADE  udp  --  *   wlan0   10.0.0.0/16   !10.0.0.0/16   masq ports: 1024-65535
    0     0 MASQUERADE  all  --  *   wlan0   10.0.0.0/16   !10.0.0.0/16

<!-- 桥接到物理网络，基于macvtap -->
<network connections='1'>
  <name>default</name>
  <uuid>519cbf63-8ec0-4893-ba9c-0747430bdecd</uuid>
  <forward dev='eth0' mode='bridge'>
    <interface dev='eth0' connections='1'/>
  </forward>
</network>

<!-- NAT转发，创建VLAN -->
<network connections='1'>
  <name>default</name>
  <uuid>9bae4de8-ca58-48c5-ba58-109aebf8b954</uuid>
  <forward mode='nat' dev="wlan0">
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <bridge name='virbr0' stp='off' delay='0'/>
  <mac address='de:ad:be:ef:00:00'/>
  <ip address='10.0.0.1' netmask='255.0.0.0'>
    <dhcp>
      <range start='10.0.0.100' end='10.0.0.200'/>
      <host mac='DE:AD:BE:EF:00:02' ip='10.0.0.2'/>
    </dhcp>
  </ip>
</network>

<bandwidth>
    <inbound average='1000' peak='5000' burst='5120'/>
    <outbound average='128' peak='256' burst='256'/>
</bandwidth>

<!-- 子网10.0.0.0/8，网桥地址10.0.0.1 -->
<ip address='10.0.0.1' netmask='255.0.0.0'>

<dhcp>
    <!-- 自动分配的地址范围 -->
    <range start='10.0.0.100' end='10.0.0.200'/>
    <!-- 对于给定的MAC地址，总是绑定到某个IP、机器网络名 -->
    <host mac="DE:AD:BE:EF:F1:10" name="fedora-10" ip="10.0.0.10" />
</dhcp>

<!-- 如果enable为no，则libvirt不会启动DNS服务 -->
<dns enable="yes">
    <!--
        每个forwarder元素定义一个备选DNS服务器：
        如果指定domain属性，则仅针对该domain下的子域名的查询请求转发给addr对应的DNS服务器
    -->
    <forwarder addr="8.8.8.8"/>
    <forwarder domain='example.com' addr="8.8.4.4"/>
    <forwarder domain='www.example.com'/>
    <!-- 静态DNS映射 -->
    <host ip='10.0.0.10'>
        <hostname>fedora-10</hostname>
        <hostname>fedora-10.local</hostname>
    </host>
</dns>

<mac address='DE:AD:BE:EF:F1:00'/>

当你创建一个新的虚拟网络后，libvrit会在

/etc/libvirt/qemu/networks

基于NAT转发，启用DHCP，静态映射MAC到IP地址的例子：

<network>
  <name>default</name>
  <forward mode='nat'>
  </forward>
  <bridge name='virbr0' stp='off' delay='0'/>
  <mac address='DE:AD:BE:EF:F1:00'/>
  <ip address='10.0.0.1' netmask='255.0.0.0'>
    <dhcp>
      <range start='10.0.0.100' end='10.0.0.200'/>
      <host mac="DE:AD:BE:EF:F1:10" ip="10.0.0.10" />
      <host mac="DE:AD:BE:EF:F1:11" ip="10.0.0.11" />
    </dhcp>
  </ip>
</network>

使用宿主机既有网桥的例子： 

<network>
    <name>default</name>
    <forward mode="bridge"/>
    <!-- br1是宿主机上既有的网桥，它可能直接连接到物理网络 -->
    <bridge name="br1"/>
</network>

macvtap直连，需要 2.6.34+内核、仅支持QEMU/KVM。通过macvtap可以通过一组物理网络接口（不需要网桥）之一，直接连接到物理网络。客户机将直接具有物理网络的子网IP地址，并且与物理网络中其它机器互联互通。示例：

<network>
    <name>direct-macvtap</name>
    <forward mode="bridge">
        <interface dev="eth0"/>
        <interface dev="eth1"/>
    </forward>
</network>

通过存储池，libvirt集中管理物理机器上的存储资源，供客户机使用。存储池被划分为卷（volume），卷则可以作为块设备分配给客户机使用。

libvirt支持以下类型的存储池后端：

通常存储管理员负责维护存储设备，例如NFS服务器。而宿主机的管理员定义存储池，存储池包含了NFS shares到挂载目录的映射。当存储池启动时，libvirt会自动执行挂载操作。一旦存储池启动完毕，NFS share中的文件被当作卷看待，你可以在客户机的Domain配置文件中引用卷的路径，作为块设备的source。

使用NFS时，基于libvirt的API可以在池中创建/删除卷（即NFS上的文件），但是不能超过池的尺寸限制（NFS share有容量控制）。注意不是所有类型的池支持卷的创建/删除操作。 

你可以通过XML文件来定义存储池，使用virsh命令可以定义、启动、停止、解除定义池，就像操作Domain、虚拟网络一样。你的配置文件被libvrit修改后，存放在

/etc/libvirt/storage/

<!-- 基于本地目录的存储池 -->
<pool type="dir">
    <name>virtimages</name>
    <target>
        <path>/var/lib/virt/images</path>
    </target>
</pool>

<!-- 基于iscsi的存储池 -->
<pool type="iscsi">
    <name>virtimages</name>
    <source>
        <host name="iscsi.example.com"/>
        <device path="iqn.2013-06.com.example:iscsi-pool"/>
        <auth type='chap' username='myuser'>
            <secret usage='libvirtiscsi'/>
        </auth>
    </source>
    <target>
        <path>/dev/disk/by-path</path>
    </target>
</pool>

<!-- 基于本地文件系统的池 -->
<pool type="fs">
    <name>sda</name>
    <source>
        <!-- 使用的文件系统 -->
    	<device path="/dev/sda3"/>
  	</source>
    <target>
    	<!-- 指定挂载点 -->
        <path>/home/alex/Vmware/libvirt/images/sda</path>
        <permissions>
            <mode>0777</mode>
        </permissions>
    </target>
</pool>

一个存储池配置的根元素为pool，最基础的配置项如下：

<pool type="iscsi">
    <name>virtimages</name>
    <uuid>3e3fce45-4f53-4fa7-bb32-11f34168b82b</uuid>
    <allocation>10000000</allocation>
    <capacity>50000000</capacity>
    <available>40000000</available>
</pool>

属性和子元素说明如下：

存储池具有最多一个（某些类型的池后端没有）source子元素，用于描述池的来源。source包含的内容取决于池的type。 配置示例：

<!-- disk池配置 -->
<source>
    <device path='/dev/mapper/mpatha' part_separator='no'/>
    <format type='gpt'/>
</source>

<!-- SCSI池配置 -->
<source>
    <adapter type='scsi_host' name='scsi_host1'/>
</source>
<source>
    <adapter type='scsi_host'>
        <parentaddr unique_id='1'>
            <address domain='0x0000' bus='0x00' slot='0x1f' addr='0x2'/>
        </parentaddr>
    </adapter>
</source>

各子元素说明如下：

对于dir, fs, netfs, logical, disk, iscsi, scsi, mpath类型池后端，可以具有单个target子元素。该元素描述如何映射存储池的source到宿主机的文件系统命名空间。配置示例：

<target>
    <path>/dev/disk/by-path</path>
    <permissions>
        <owner>107</owner>
        <group>107</group>
        <mode>0744</mode>
        <label>virt_image_t</label>
    </permissions>
    <timestamps>
        <atime>1341933637.273190990</atime>
        <mtime>1341930622.047245868</mtime>
        <ctime>1341930622.047245868</ctime>
    </timestamps>
    <encryption type='...'></encryption>
</target>

各子元素说明如下：

存储卷，通常对应一个文件或者设备节点。注意：当创建了存储池后，池中的镜像文件会被libvirt自动识别，并创建相应的卷定义。

配置示例：

<!-- 基于文件的卷 -->
<volume type='file'>
    <name>fedora-10.qcow2</name>
    <capacity unit='GiB'>16</capacity>
    <target>
        <path>/home/alex/Vmware/libvirt/images/fedora-10.qcow2</path>
        <format type='qcow2'/>
        <permissions>
            <mode>0666</mode>
        </permissions>
    </target>
    <backingStore>
        <path>/home/alex/Vmware/libvirt/images/fedora-base.qcow2</path>
        <format type='qcow2'/>
        <permissions>
            <mode>0666</mode>
        </permissions>
    </backingStore>
</volume>
<!-- 使用LUKS加密的卷-->
<volume>
    <name>MyLuks.img</name>
    <capacity unit="G">5</capacity>
    <target>
        <path>/var/lib/virt/images/MyLuks.img</path>
        <format type='raw'/>
        <encryption format='luks'>
            <secret type='passphrase' uuid='f52a81b2-424e-490c-823d-6bd4235bc572'/>
        </encryption>
    </target>
</volume>

一个卷配置的根元素是volume，最基础的配置项如下：

<volume type='file'>
    <name>sparse.img</name>
    <key>/var/lib/xen/images/sparse.img</key>
    <allocation>0</allocation>
    <capacity unit="T">1</capacity>
</volume>

 属性和子元素说明如下：

volume包含一个target子元素，指定卷如何映射到宿主机的文件系统中：

volume可能包含一个backingStore子元素，用来描述卷的copy-on-write后端存储，配置示例：

<backingStore>
    <path>/var/lib/virt/images/master.img</path>
    <format type='raw'/>
    <permissions>
        <owner>107</owner>
        <group>107</group>
        <mode>0744</mode>
        <label>virt_image_t</label>
    </permissions>
</backingStore> 

在不同宿主机之间迁移客户机是比较复杂的问题，为了应对不同的需求，libvirt实现了多种解决方案。

从数据传输的角度来看，libvirt支持两种类型的迁移：

从通信控制路径角度来看，libvirt支持三种类型的迁移：

迁移时，客户机的内存需要完整的在网络上传输，这可能导致客户机中的敏感信息被嗅探。

如果宿主机有多个网络接口，或者交换机支持Tagged虚拟局域网，最好将客户机的网络流量和迁移/管理网络流量隔离开来。

某些场景下，仅仅依靠网络隔离不能满足安全性需要，这时，需要使用libvirt的tunnelled传输，启用数据加密。

所谓离线迁移，就是把源主机的Domain状态设置为inactive，并且在迁移完毕后，Domain在源主机上继续运行，在目标主机上保持inactive状态。目前离线迁移不支持拷贝非共享存储。

开发虚拟机固件（Open Virtual Machine Firmware）是一个为虚拟机提供UEFI支持的项目。从Linux 3.9开始，配合最近版本的QEMU，能够支持PCI设备直通，例如将显卡直接分配给虚拟机，这样虚拟机就获得接近原生显卡的性能。

对于Intel CPU，除了CPU需要支持VT-x之外，还需要支持VT-d（Intel Virtualization Technology for Directed I/O ）。此技术改善系统的安全性、可靠性，同时支持提升虚拟化环境下的IO性能。

Intel的VT-d和AMD的AMD-Vi，通称IOMMU。IOMMU特性不但要求CPU支持，主板、BIOS也需要配合。开启IOMMU能够实现PCI直通、内存保护（免于被恶意、缺陷设备错误修改）。

intel_iommu=on iommu=pt

设置iommu=pt能够防止内核触碰不能直通的设备。

重启后，使用下面的命令确认IOMMU已经正确启用： 

dmesg | grep -i -e DMAR -e IOMMU
[    0.000000] Command line: BOOT_IMAGE=/boot/vmlinuz-5.8.0-45-generic root=UUID=66acedc4-69d6-48b2-888c-9516089e004a ro quiet splash net.ifnames=0 biosdevname=0 intel_iommu=on iommu=pt vt.handoff=7
[    0.010062] ACPI: DMAR 0x0000000073AE3000 0000C8 (v01 INTEL  CML      00000002 INTL 01000013)
[    0.223797] Kernel command line: BOOT_IMAGE=/boot/vmlinuz-5.8.0-45-generic root=UUID=66acedc4-69d6-48b2-888c-9516089e004a ro quiet splash net.ifnames=0 biosdevname=0 intel_iommu=on iommu=pt vt.handoff=7
# IOMMU被启用
[    0.223929] DMAR: IOMMU enabled
[    0.546449] DMAR: Host address width 39
[    0.546450] DMAR: DRHD base: 0x000000fed90000 flags: 0x0
[    0.546455] DMAR: dmar0: reg_base_addr fed90000 ver 1:0 cap 1c0000c40660462 ecap 19e2ff0505e
[    0.546456] DMAR: DRHD base: 0x000000fed91000 flags: 0x1
[    0.546459] DMAR: dmar1: reg_base_addr fed91000 ver 1:0 cap d2008c40660462 ecap f050da
[    0.546460] DMAR: RMRR base: 0x0000007372c000 end: 0x0000007374bfff
[    0.546461] DMAR: RMRR base: 0x00000078000000 end: 0x0000007c7fffff
[    0.546462] DMAR: RMRR base: 0x00000073792000 end: 0x00000073811fff
[    0.546464] DMAR-IR: IOAPIC id 2 under DRHD base  0xfed91000 IOMMU 1
[    0.546465] DMAR-IR: HPET id 0 under DRHD base 0xfed91000
[    0.546465] DMAR-IR: Queued invalidation will be enabled to support x2apic and Intr-remapping.
[    0.549640] DMAR-IR: Enabled IRQ remapping in x2apic mode
[    4.330593] iommu: Default domain type: Passthrough (set via kernel command line)
[    4.510270] DMAR: No ATSR found
[    4.510351] DMAR: dmar0: Using Queued invalidation
[    4.510354] DMAR: dmar1: Using Queued invalidation
# PCI设备被加入到的分组信息
[    4.510868] pci 0000:00:00.0: Adding to iommu group 0
[    4.510888] pci 0000:00:01.0: Adding to iommu group 1
[    4.510901] pci 0000:00:02.0: Adding to iommu group 2
[    4.510911] pci 0000:00:04.0: Adding to iommu group 3
[    4.510928] pci 0000:00:12.0: Adding to iommu group 4
[    4.510950] pci 0000:00:14.0: Adding to iommu group 5
[    4.510963] pci 0000:00:14.2: Adding to iommu group 5
[    4.510975] pci 0000:00:14.3: Adding to iommu group 6
[    4.510997] pci 0000:00:15.0: Adding to iommu group 7
[    4.511008] pci 0000:00:15.1: Adding to iommu group 7
[    4.511031] pci 0000:00:16.0: Adding to iommu group 8
[    4.511042] pci 0000:00:16.3: Adding to iommu group 8
[    4.511087] pci 0000:00:1b.0: Adding to iommu group 9
[    4.511121] pci 0000:00:1b.4: Adding to iommu group 9
[    4.511161] pci 0000:00:1c.0: Adding to iommu group 10
[    4.511197] pci 0000:00:1c.5: Adding to iommu group 10
[    4.511226] pci 0000:00:1d.0: Adding to iommu group 11
[    4.511265] pci 0000:00:1f.0: Adding to iommu group 12
[    4.511277] pci 0000:00:1f.3: Adding to iommu group 12
[    4.511290] pci 0000:00:1f.4: Adding to iommu group 12
[    4.511301] pci 0000:00:1f.5: Adding to iommu group 12
[    4.511316] pci 0000:00:1f.6: Adding to iommu group 12
[    4.511321] pci 0000:01:00.0: Adding to iommu group 1
[    4.511325] pci 0000:01:00.1: Adding to iommu group 1
[    4.511330] pci 0000:01:00.2: Adding to iommu group 1
[    4.511335] pci 0000:01:00.3: Adding to iommu group 1
[    4.511350] pci 0000:02:00.0: Adding to iommu group 9
[    4.511363] pci 0000:03:00.0: Adding to iommu group 9
[    4.511373] pci 0000:04:00.0: Adding to iommu group 10
[    4.511383] pci 0000:05:00.0: Adding to iommu group 10
[    4.511392] pci 0000:05:01.0: Adding to iommu group 10
[    4.511399] pci 0000:05:02.0: Adding to iommu group 10
[    4.511409] pci 0000:05:04.0: Adding to iommu group 10
[    4.511435] pci 0000:06:00.0: Adding to iommu group 10
[    4.511458] pci 0000:3a:00.0: Adding to iommu group 10
[    4.511471] pci 0000:6e:00.0: Adding to iommu group 10
[    4.511484] pci 0000:6f:00.0: Adding to iommu group 11
# VT-d被启用
[    4.511850] DMAR: Intel(R) Virtualization Technology for Directed I/O
[    4.711749]     intel_iommu=on

使用下面的脚本可以更加清楚的看到PCI设备是如何并映射到IOMMU分组的：

#!/bin/bash
shopt -s nullglob
for g in `find /sys/kernel/iommu_groups/* -maxdepth 0 -type d | sort -V`; do
    echo "IOMMU Group ${g##*/}:"
    for d in $g/devices/*; do
        echo -e "\t$(lspci -nns ${d##*/})"
    done;
done;

输出如下： 

IOMMU Group 0:
	00:00.0 Host bridge [0600]: Intel Corporation Device [8086:9b44] (rev 02)
# Nvidia显卡被分配在组1
IOMMU Group 1:
	00:01.0 PCI bridge [0604]: Intel Corporation Xeon E3-1200 v5/E3-1500 v5/6th Gen Core Processor PCIe Controller (x16) [8086:1901] (rev 02)
	01:00.0 VGA compatible controller [0300]: NVIDIA Corporation TU104GLM [Quadro RTX 5000 Mobile / Max-Q] [10de:1eb5] (rev a1)
	01:00.1 Audio device [0403]: NVIDIA Corporation TU104 HD Audio Controller [10de:10f8] (rev a1)
	01:00.2 USB controller [0c03]: NVIDIA Corporation TU104 USB 3.1 Host Controller [10de:1ad8] (rev a1)
	01:00.3 Serial bus controller [0c80]: NVIDIA Corporation TU104 USB Type-C UCSI Controller [10de:1ad9] (rev a1)
# Intel集成显卡被分配在组2
IOMMU Group 2:
    #                                                                  设备ID
	00:02.0 VGA compatible controller [0300]: Intel Corporation Device [8086:9bf6] (rev 05)
IOMMU Group 3:
	00:04.0 Signal processing controller [1180]: Intel Corporation Xeon E3-1200 v5/E3-1500 v5/6th Gen Core Processor Thermal Subsystem [8086:1903] (rev 02)
IOMMU Group 4:
	00:12.0 Signal processing controller [1180]: Intel Corporation Comet Lake PCH Thermal Controller [8086:06f9]
IOMMU Group 5:
	00:14.0 USB controller [0c03]: Intel Corporation Comet Lake USB 3.1 xHCI Host Controller [8086:06ed]
	00:14.2 RAM memory [0500]: Intel Corporation Comet Lake PCH Shared SRAM [8086:06ef]
# 无线网卡被分到组6
IOMMU Group 6:
	00:14.3 Network controller [0280]: Intel Corporation Wi-Fi 6 AX201 [8086:06f0]
IOMMU Group 7:
	00:15.0 Serial bus controller [0c80]: Intel Corporation Comet Lake PCH Serial IO I2C Controller #0 [8086:06e8]
	00:15.1 Serial bus controller [0c80]: Intel Corporation Comet Lake PCH Serial IO I2C Controller #1 [8086:06e9]
IOMMU Group 8:
	00:16.0 Communication controller [0780]: Intel Corporation Comet Lake HECI Controller [8086:06e0]
	00:16.3 Serial controller [0700]: Intel Corporation Device [8086:06e3]
# 指纹识别器、三星硬盘被分到组9
IOMMU Group 9:
	00:1b.0 PCI bridge [0604]: Intel Corporation Comet Lake PCI Express Root Port #17 [8086:06c0] (rev f0)
	00:1b.4 PCI bridge [0604]: Intel Corporation Comet Lake PCI Express Root Port #21 [8086:06ac] (rev f0)
	02:00.0 Non-Volatile memory controller [0108]: Samsung Electronics Co Ltd NVMe SSD Controller SM981/PM981/PM983 [144d:a808]
	03:00.0 Non-Volatile memory controller [0108]: Silicon Motion, Inc. Device [126f:2262] (rev 03)
# 雷电、读卡器被分到组10
IOMMU Group 10:
	00:1c.0 PCI bridge [0604]: Intel Corporation Device [8086:06b8] (rev f0)
	00:1c.5 PCI bridge [0604]: Intel Corporation Device [8086:06bd] (rev f0)
	04:00.0 PCI bridge [0604]: Intel Corporation JHL7540 Thunderbolt 3 Bridge [Titan Ridge 4C 2018] [8086:15ea] (rev 06)
	05:00.0 PCI bridge [0604]: Intel Corporation JHL7540 Thunderbolt 3 Bridge [Titan Ridge 4C 2018] [8086:15ea] (rev 06)
	05:01.0 PCI bridge [0604]: Intel Corporation JHL7540 Thunderbolt 3 Bridge [Titan Ridge 4C 2018] [8086:15ea] (rev 06)
	05:02.0 PCI bridge [0604]: Intel Corporation JHL7540 Thunderbolt 3 Bridge [Titan Ridge 4C 2018] [8086:15ea] (rev 06)
	05:04.0 PCI bridge [0604]: Intel Corporation JHL7540 Thunderbolt 3 Bridge [Titan Ridge 4C 2018] [8086:15ea] (rev 06)
	06:00.0 System peripheral [0880]: Intel Corporation JHL7540 Thunderbolt 3 NHI [Titan Ridge 4C 2018] [8086:15eb] (rev 06)
	3a:00.0 USB controller [0c03]: Intel Corporation JHL7540 Thunderbolt 3 USB Controller [Titan Ridge 4C 2018] [8086:15ec] (rev 06)
	6e:00.0 Unassigned class [ff00]: Realtek Semiconductor Co., Ltd. RTS525A PCI Express Card Reader [10ec:525a] (rev 01)
IOMMU Group 11:
	00:1d.0 PCI bridge [0604]: Intel Corporation Comet Lake PCI Express Root Port #9 [8086:06b0] (rev f0)
	6f:00.0 Non-Volatile memory controller [0108]: Silicon Motion, Inc. Device [126f:2262] (rev 03)
# 有线网卡被分到组12
IOMMU Group 12:
	00:1f.0 ISA bridge [0601]: Intel Corporation Device [8086:068e]
	00:1f.3 Multimedia audio controller [0401]: Intel Corporation Comet Lake PCH cAVS [8086:06c8]
	00:1f.4 SMBus [0c05]: Intel Corporation Comet Lake PCH SMBus Controller [8086:06a3]
	00:1f.5 Serial bus controller [0c80]: Intel Corporation Comet Lake PCH SPI Controller [8086:06a4]
	00:1f.6 Ethernet controller [0200]: Intel Corporation Ethernet Connection (10) I219-LM [8086:0d4e] 

需要注意，IOMMU组是直通的最小调度单元。也就是说，你可能被迫将多个设备一起直通给虚拟机，或者将设备放到其他PCI插槽。

为了将设备分配给虚拟机，它和它所在分组的所有其他设备的驱动，必须更换为一个占位符驱动（stub 或 VFIO驱动）。这样，宿主机就不会和该设备进行交互。大部分设备，可以在启动虚拟机之前，即席的完成驱动更换操作。

对于显卡，没有这么方便。GPU驱动通常对动态rebinding支持的不好，不能将宿主机上正在使用的GPU透明的直通给虚拟机。因此，我们需要在宿主机启动时，尽早将占位符驱动bind给GPU。这样，除非驱动被换回，或者虚拟机claim该GPU，它会保持inactive状态。

之所以要求尽早，是因为Linux现有的驱动机制是每个驱动在初始化时，自行去寻找没有初始化的，自己关注的硬件。因此驱动的初始化顺序非常关键。如果慢了，物理驱动就会抢先绑定设备。

从内核4.1开始，VFIO驱动vfio-pci被包含其中。可以用来代替pci-stub。

修改内核参数：

pci-stub.ids=8086:9bf6

pci-stub根据ID来识别设备，也就是说，我们需要提供用于直通的PCI设备的ID。对于上面的输出中，Intel显卡的ID是8086:9bf6。

如果要绑定多个设备，ID需要用逗号分隔。 

随后我们需要执行下面的命令并重启：

sudo update-grub

内核总是先初始化所有内建的驱动，然后才逐个初始化外部模块。 在外部模块中，我们可以通过softdep来增加模块间的依赖关键： 例如我们可以把vfio-pci列为nvidia的依赖，那么vfio-pci总会被在nvidia之前初始化，而确保能抢占到硬件。

我们首先需要弄清楚，需要直通的硬件，当前是被什么驱动所绑定：

lspci -nnv

00:02.0 VGA compatible controller [0300]: Intel Corporation Device [8086:9bf6] (rev 05) (prog-if 00 [VGA controller])
	DeviceName: Onboard IGD
	Subsystem: Hewlett-Packard Company Device [103c:8780]
	Flags: bus master, fast devsel, latency 0, IRQ 221
	Memory at df000000 (64-bit, non-prefetchable) [size=16M]
	Memory at a0000000 (64-bit, prefetchable) [size=256M]
	I/O ports at 4000 [size=64]
	Expansion ROM at 000c0000 [virtual] [disabled] [size=128K]
	Capabilities: <access denied>
    # 当前使用的驱动
	Kernel driver in use: i915
	Kernel modules: i915

i915是内核builtin的驱动，无法通过修改softdep，改变驱动加载顺序。解决此问题，有两种方案：

1. 将i915从内核剥离出来，编译为模块
2. 将vfio-pci编译进内核

如果选择方案2，则使用内核参数：

vfio-pci.ids=8086:9bf6

libvirt提供钩子（Hooks）功能，你可以添加自定义的脚本，存放在/etc/libvirt/hooks目录下，以便在：

1. libvirt守护程序启动、停止、reload时（对应daemon子目录）
2. QEMU客户机启动、停止时（对应qemu子目录）
3. 一个虚拟网络启动、停止时，或者一个网络接口接入、断开网络时（对应network子目录）

执行特定的逻辑。Hooks可以基于Bash或者Python编写。

报错：The virtual machine's operating system has attempted to enable promiscuous mode on adapter 'Ethernet0'.

要解决此问题，需要在宿主机上执行：

# vmnet0改为实际使用的Vmware虚拟网络
sudo chmod a+rw /dev/vmnet0

报错信息：error: unsupported configuration: Domain requires KVM, but it is not available. Check that virtualization is enabled in the host BIOS, and host configuration is setup to load the kvm modules.

解决办法：VM ⇨ Settings，弹出的对话框中，选择Processors，在面板右侧勾选Virtualize Intel VT-X/EPT or AMD-V/RVI

报错信息：error: internal error: cannot load AppArmor profile 'libvirt-cf9a1d56-306d-4a6f-8b0e-79ac070aa8fe'

这个错误与安全模块AppArmor有关，你可以简单的禁用libvirt的QEMU驱动的安全驱动来规避：

# 添加
security_driver = "none"

并执行：

sudo touch /etc/apparmor.d/disable/usr.sbin.libvirtd

然后重启libvirtd：

sudo service libvirt-bin restart

报错信息：
error: internal error: process exited while connecting to monitor: failed to open /dev/net/tun: Operation not permitted
failed to launch bridge helper
qemu-system-x86_64: -netdev bridge,id=tap0,br=br0: Device 'bridge' could not be initialized

解决办法：

# 添加如下几行 

user = "root"
group = "root"
cgroup_device_acl = [
        "/dev/null", "/dev/full", "/dev/zero",
        "/dev/random", "/dev/urandom",
        "/dev/ptmx", "/dev/kvm", "/dev/kqemu",
        "/dev/rtc", "/dev/hpet", "/dev/net/tun"
]
clear_emulator_capabilities = 0

报错信息：error: internal error: process exited while connecting to monitor

解决办法：从Domain配置文件中去掉

<qemu:arg value='-daemonize'/>

症状：无法启动成功，配置SDL则可以启动，但是需要Headless的服务器。

解决办法：配置一个graphics，类型为VNC。

这导致虚拟机无法启动，QEMU的SDL窗口不出现。

报错信息：error: internal error: process exited while connecting to monitor: Could not initialize SDL(No available video device) - exiting

解决办法：

1. 首先在宿主机执行

   env | egrep "DISPLAY|XAUTH"

    ，获取两个环境变量的值
2. 然后修改Domain配置文件，把type=sdl的graphics元素的display和xauth属性修改为上面命令输出的环境变量值：
   

   <graphics type='sdl' display=':0' xauth='/home/alex/.Xauthority'/>

报错信息：

Booting from Hard Disk...
Boot failed: not abootable disk
No bootable device.

报错原因：可能是Domain配置文件搞错了镜像文件的格式。

解决办法：修改为正确的镜像格式，例如：

<driver name='qemu' type='qcow2'/>

报错信息：error: internal error: cannot find character device <null>

解决办法：可能是你的Domain配置中缺少Console和串口的配置，添加：

<serial type='pty'>
    <target port='0'/>
</serial>
<console type='pty'>
    <target type='serial' port='0'/>
</console>

要退出从virsh console进入的控制台，可以按组合键

Ctrl+]

问题现象：光标在Escape character is ^]下面一行闪烁，但是按任何键都没有反应。

问题原因：客户机没有进行适当的配置。

解决办法： 通过其它方式登录到客户机，修改配置。

以Fedora为例：

1. 修改/etc/sysconfig/grub（该文件是指向/etc/default/grub的符号链接）：
   

   # 修改这一行，在命令行尾部添加console=...这个内核参数
   GRUB_CMDLINE_LINUX="... console=ttyS0,115200"

2. 更新GRUB：

   grub2-mkconfig > /boot/grub2/grub.cfg

     
3. 执行命令

   echo ttyS0 >> /etc/securetty

    并重启客户机

现在你可以使用virsh console连接到客户机，并执行Shell命令了。

当通过串口（上面的方式）连接到Linux时，缺乏协商机制（Negotiate About Window Size ，NAWS），Linux也不知道你的（通过串口连接的）控制台屏幕屏幕大小。

在这种情况下，通常会使用

stty -a

你可以在.bashrc中增加

/usr/bin/resize > /dev/null

报错信息：unsupported configuration: deletion of 1 external disk snapshots not supported yet

解决办法：目前libvirt无法删除外部快照的磁盘文件，因此我们仅仅需要删除它的元数据，调用snapshot-delete时添加--metadata参数。磁盘文件可以手工删除。

问题现象：无法ping通网桥，无法ping通外网，Vmware无法桥接到libvirt创建的网桥

原因分析：

在我的机器上，外网是通过Wifi连接的。如果设置虚拟局域网为net-autostart，则虚拟局域网启动时Wifi可能尚未连接，这会导致客户机无法连通外网的情况，原因未知。

将Vmware workstation中的虚拟机也桥接到virbr0时，提示无法连接。出现这种现象的原因也未知，但是先启动一个libvirt管理的客户机“激活”一下VLAN，然后启动Vmware就没事了。

解决办法：在Wifi连接后，启动VLAN、一台libvirt管理的虚拟机，然后再启动Vmware。

设置NFS导出时，要启用no_root_squash选项，让NFS客户端（QEMU宿主机）以root权限访问NFS：

/home/alex/Vmware/libvirt/images/default  10.0.0.0/8(rw,no_root_squash) 

然后，参考本文针对问题《AppArmor导致无法启动QEMU虚拟机》、 《无法启动桥接的QEMU虚拟机》的解决方案。

可能是因为虚拟局域网配置错误：

<network>
  <name>default</name>
  <forward mode="bridge">
    <interface dev="eth0"/> <!-- 必须和宿主机的以太网设备名称一致 -->
  </forward>
</network> 

在Domain配置文件中指定宿主机集群中通用的机器类型，避免此问题：

<os>
    <type arch='x86_64' machine='pc-i440fx-2.0'>hvm</type>
</os>

报错信息：

unable to connect to server at 'Zircon:49152': Connection refused 
unable to connect to server at 'centos.local:49152': No route to host

报错原因：默认情况下，迁移的源使用目的主机的主机名来建立迁移连接，出现此错误说明源无法正确连接到目标主机——Zircon，可以ping验证一下

解决方案：

1. 修改目的主机libvirt的QEMU配置：
   

   # 指向目的主机可被迁移源访问的IP地址或者DNS名称
   migration_host = "zircon.local"

2.  老版本的libvirt可能不支持上述配置，这时可以配置DNS服务器或者迁移源的/etc/hosts文件

3. No route to host错误可能是因为目标主机的防火墙导致，注意检查设置

问题现象：迁移进度到达100%报如上错误。这个报错很笼统，详细的错误信息可以在目的宿主机的客户机运行日志（

/var/log/libvirt/qemu/$VM.log

qemu: warning: error while loading state for instance 0x0 of device 'cpu'
load of migration failed
2016-10-19 01:47:45.913+0000: shutting down

可能是因为卷所在的物理磁盘空间不足。

The post libvirt学习笔记 appeared first on 绿色记忆.