VM Windows avec VFIO / PCI Passthrough

Accessoires facultatifs

En plus des pièces centrales (carte mère, CPU, etc), j’ai également utilisé le matériel suivant pour la partie USB.

• un contrôleur USB PCI-Express
• un switch USB (pour partager le clavier et la souris)
• un hub USB (pour rendre accessible des ports USB du contrôleur en passthrough)

Activer le support dans le firmware

Selon votre carte mère, il est probable que tout ou partie des extensions de paravirtualisation soient désactivées par défaut. Faites un tour dans la configuration de l’UEFI pour les activer. Vous la trouverez généralement dans les paramètres avancés du CPU, mais il n’est pas impossible que le constructeur ait décidé de la planquer à un endroit pas forcément très logique (je l’ai trouvé dans les options Overclocking de ma carte MSI).

Activer le support dans Grub

Le switch à passer à Grub dépendra du constructeur du CPU, intel_iommu=on pour Intel et amd_iommu=on pour AMD. iommu=pt permet de protéger les périphériques incompatibles avec le passthrough. Ces options sont à passer dans /etc/default/grub.

GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt"

Mettre à jour Grub pour prendre en compte la modification et relancer le système pour activer le support.

update-grub
reboot

Analyser les groupes IOMMU

Une fois IOMMU activé, il va falloir s’assurer que les groupes d’isolation correspondent bien à ce qu’on cherche. il est possible d’aller farfouiller dans /sys pour trouver ce qu’on cherche, mais ce script affichera les informations de façon plus lisible.

#!/bin/bash
shopt -s nullglob
for d in /sys/kernel/iommu_groups/*/devices/*; do
    n=${d#*/iommu_groups/*}; n=${n%%/*}
    printf 'IOMMU Group %s ' "$n"
    lspci -nns "${d##*/}"
done;

Les groupes exactes dépendront de la façon dont la carte mère aura répartie les pistes PCI Express, en particulier celles du CPU et celles du chipset. Il n’est pas forcément problématique d’avoir plusieurs périphériques dans un même groupe, tant que vous pouvez tous les transmettre à l’invité. Vous devriez toutefois ignorer toute entrée désignant une section générique PCI Express (port racine, concentrateur PCI).

IOMMU Group 1 00:01.0 PCI bridge [0604]: Intel Corporation Skylake PCIe Controller (x16) [8086:1901] (rev 07)
IOMMU Group 1 01:00.0 VGA compatible controller [0300]: NVIDIA Corporation GP104 [GeForce GTX 1070] [10de:1b81] (rev a1)
IOMMU Group 1 01:00.1 Audio device [0403]: NVIDIA Corporation GP104 High Definition Audio Controller [10de:10f0] (rev a1)

Dans cet exemple (tiré de ma configuration), le groupe IOMMU n°1 correspond aux pistes CPU, tout le reste passe par le PCH. Les entrées 01:00.0 et 01:00.1 devront être transmises à la VM, mais pas la 00:01.0.

Isoler le GPU

Beaucoup de cartes PCI Express peuvent être passés à la volée sans autre forme de procès à la VM au lancement de cette dernière. Pour un GPU, l’opération est toutefois rendu délicate de part la complexité et la taille des pilotes, ainsi que leur importance pour le poste personnel typique dont vous perdrez tout contrôle si la sortie graphique n’est plus disponible. De ce fait, on va s’assurer de lier le plus tôt possible un pilote dédié pour l’isolation afin d’éviter que les habituels (nvidia, nouveau, amdgpu, etc) s’accaparent la carte et causent des conflits.

Il va de soit qu’à ce point, il est capital de s’assurer que l’hôte fonctionne bien sur un GPU alternatif à celui qui va être passé à l’invité, sinon vous allez perdre toute sortie graphique dès le boot du système.

Commencer par reprendre les ID PCI et les renseigner dans /etc/modprobe.d/vfio.conf.

options vfio-pci ids=10de:1b81,10de:10f0

Il vaut mieux s’assurer que les modules VFIO sont chargés dès que possible, dans l’initramfs, via le fichier /etc/initramfs-tools/modules.

vfio_pci
vfio
vfio_iommu_type1
vfio_virqfd

Mettre à jour l’initramfs et relancer le système pour application de la configuration.

update-initramfs
reboot

Constater si le pilote vfio-pci a bien pris possession des périphériques.

lspci -nnk -d 10de:1b81

La sortie devrait ressemble à quelque chose comme ci-dessous.

01:00.0 VGA compatible controller [0300]: NVIDIA Corporation GP104 [GeForce GTX 1070] [10de:1b81] (rev a1)
    Subsystem: ASUSTeK Computer Inc. GP104 [GeForce GTX 1070] [1043:8599]
    Kernel driver in use: vfio-pci
    Kernel modules: nvidia

Installation de libvirt

On peut à présent s’intéresser de plus près à la question de la virtualisation. La solution choisie pour cet article sera KVM/QEMU via libvirt.

apt install virt-manager libvirt-daemon-system virt-viewer bridge-utils qemu-kvm ovmf libvirt-clients

Outre les briques de base libvirt/QEMU, on notera l’ajout d’OVMF qui servira de firmware UEFI (à la place de SeaBIOS qui ne fait que du BIOS) et virt-manager qui va permettre d’élaborer un squelette de base pour la VM sans avoir à taper trop de XML.

Les connexions à virsh peuvent être simplifiées en rajoutant une variable d’environnement

LIBVIRT_DEFAULT_URI=qemu:///system

Configuration du pont

Cette partie est entièrement facultative, mais recommandée si vous voulez une VM autonome sur la partie réseau. Si vous l’omettez, vous risquez d’avoir des problèmes plus tard, en particulier avec la couche de NAT rajoutée par défaut sur l’hyperviseur, ou si vous voulez faire communiquer l’hôte avec l’invité.

allow-hotplug eno1
iface eno1 inet manual

auto br0
iface br0 inet dhcp
    bridge_ports eno1

iface br0 inet6 auto

<network>
  <name>bridge0</name>
  <forward mode="bridge"/>
  <bridge name="bridge0" />
</network>

virsh -c qemu:///system net-define bridge.xml
virsh -c qemu:///system net-start bridge0
virsh -c qemu:///system net-autostart bridge0

Configuration libvirt

OVMF n’est pas déclaré par défaut à libvirt, il convient donc de le spécifier dans /etc/libvirt/qemu.conf.

nvram = [
    "/usr/share/OVMF/OVMF_CODE.fd:/usr/share/OVMF/OVMF_VARS.fd"
]

Relancer le service libvirtd pour prise en compte.

systemctl restart libvirtd.service

Créer une machine standard avec virt-manager, préremplir les parties évidentes, ignorer le stockage pour l’instant, cocher “personnaliser” à la fin.

• Sur CPU, copier la configuration de l’hôte
• Sur Overview, passer la machine en UEFI et choisir le nvram OVMF précédement configuré
• Créer un contrôleur VirtIO SCSI
• Créer un disque SCSI

pnputil /add-driver virtstor.inf

Attacher les périphériques PCI

Une fois l’installation terminée, vous pouvez détacher toute ce qui a trait à Spice/QXL et remplacer par les périphériques PCI précédemment isolés.

virsh edit mavm

<features>
    <hyperv>
        ...
        <vendor_id state='on' value='whatever'/>
        ...
    </hyperv>
    ...
    <kvm>
    <hidden state='on'/>
    </kvm>
</features>

Périphériques dédiés

Le setup le plus simple est de passer les périphériques USB qui vous intéressent en USB Passthrough. Ces périphériques seront naturellement inutilisables depuis l’hôte dès le lancement de la VM et vous aurez besoin de deux claviers et deux souris pour piloter les deux en même temps.

N’espérez pas faire le malin en passant un hub USB, ça ne marchera pas. De par la nature d’USB, seul le hub sera exposé à la VM et le reste restera sur l’hôte.

Contrôleur USB dédié

Une solution alternative consiste à passer en PCI Passthrough tout un contrôleur USB. Cette solution est celle offrant le plus de souplesse à l’usage, étant donné que vous pourrez ensuite utiliser un hub USB pour démultiplier les possibilités de branchement et passer un périphérique de l’hôte à l’invité simplement en changeant de port, voir en utilisant un switch (très pratique pour échanger le clavier et la souris).

Vous pouvez vous arranger avec les contrôleurs présents de base sur votre carte mère si ça vous convient. Par exemple, vous pourriez en avoir un pour les ports boîtier/avant et un pour les ports arrière, mais à confirmer au cas par cas. Sinon, vous pouvez également vous appuyer sur une carte d’extension PCI Express et garder ceux de la carte mère pour l’hôte.

Le code suivant permet de visualiser un peu mieux quel périphérique USB correspond à quel périphérique PCI. Le reste viendra d’expérimentation à base de branchement/débranchement.

for usb_ctrl in $(find /sys/bus/usb/devices/usb* -maxdepth 0 -type l); do pci_path="$(dirname "$(realpath "${usb_ctrl}")")"; echo "Bus $(cat "${usb_ctrl}/busnum") --> $(basename $pci_path) (IOMMU group $(basename $(realpath $pci_path/iommu_group)))"; lsusb -s "$(cat "${usb_ctrl}/busnum"):"; echo; done

À noter que ce contrôleur n’aura pas besoin d’être assigné prématurément à vfio-pci, les chances étant grandes qu’il supporte le reset PCI. Vous pouvez vous en assurer avec le script suivant.

for iommu_group in $(find /sys/kernel/iommu_groups/ -maxdepth 1 -mindepth 1 -type d);do echo "IOMMU group $(basename "$iommu_group")"; for device in $(\ls -1 "$iommu_group"/devices/); do if [[ -e "$iommu_group"/devices/"$device"/reset ]]; then echo -n "[RESET]"; fi; echo -n $'\t';lspci -nns "$device"; done; done

evdev

La solution evdev permet de passer un clavier et une souris de l’hôte à l’invité simplement avec la combinaison des deux touches Control. Si elle semble en apparence simple, notez que vous aurez quand même une couche d’émulation qui peut provoquer des problèmes avec des jeux même modérément nerveux et demandant beaucoup d’inputs.

Pour commencer, listes les périphériques disponibles.

ls -l /dev/input/by-id

Vous pouvez tester si une device est bien ce que vous chercher avec un cat, puis en provoquant des évènements dessus (bouger la souris, taper sur le clavier). ^C vous fera sortir du cat. Si vous notez plusieurs ID similaires avec des versions en event, privilégiez les event.

Pour résoudre les problèmes de permission à venir, faire tourner la VM en tant qu’utilisateur ayant accès à input et rajouter les périphériques nécessaires au cgroup de QEMU (sans oublier ceux définis par défaut) dans /etc/libvirt/qemu.conf.

gpasswd -a monutilisateur input

user = "monutilisateur"
group = "kvm"
cgroup_device_acl = [
    "/dev/input/by-id/usb-046d_Gaming_Keyboard_G110-event-kbd",
    "/dev/input/by-id/usb-Logitech_Gaming_Mouse_G600_9193F9B4F5E20017-event-mouse",
    "/dev/null", "/dev/full", "/dev/zero",
    "/dev/random", "/dev/urandom",
    "/dev/ptmx", "/dev/kvm", "/dev/kqemu",
    "/dev/rtc","/dev/hpet"
]

Ne pas oublier de relancer libvirtd.

systemctl restart libvirtd

Si votre système tourne avec une couche de protection type AppArmor ou SELinux, il sera également nécessaire de relâcher les permissions à ce niveau, soit avec des règles plus souples, soit en les désactivant complètement.

Reste à assigner ces périphériques à la VM. virt-manager ou libvirt ne supportent pas encore cette configuration, il faudra donc régler ça directement avec la ligne de commande QEMU.

Rajouter un espace de nom XML à l’élément racine

<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>

Rajouter les arguments QEMU à la fin, après le bloc <devices>.

<qemu:commandline>
    <qemu:arg value='-object'/>
    <qemu:arg value='input-linux,id=mouse1,evdev=/dev/input/by-id/MOUSE_NAME'/>
    <qemu:arg value='-object'/>
    <qemu:arg value='input-linux,id=kbd1,evdev=/dev/input/by-id/KEYBOARD_NAME,grab_all=on,repeat=on'/>
</qemu:commandline>

Audio HDMI/DP

Étant donné qu’on passe déjà une carte graphique pour la vidéo, le plus simple est encore de passer l’audio par le même chemin et de tirer profit des sorties audio de votre écran, vous éviterez ainsi tous les problèmes qui viennent avec l’émulation d’une carte son. Le seul point noir est évidemment que sans matériel supplémentaire, vous aurez à faire un choix entre le son de l’hôte ou celui de l’invité.

Vous pouvez supprimer la carte son ICH6 installée par défaut sur votre VM dans virt-manager, elle ne servira plus et risque de vous poser des problèmes plus qu’autre chose.

load-module module-loopback

pulseaudio -k

pacmd load-module module-loopback
pacmd unload-module module-loopback

Carte son virtuelle

user = "monutilisateur"

# pour qemu 3.0 et plus

nographics_allow_host_audio = 1

systemctl restart libvirtd

virsh edit MAVM

<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>
  ...
  <qemu:commandline>
    <qemu:env name='QEMU_AUDIO_DRV' value='pa'/>
    <qemu:env name='QEMU_PA_SERVER' value='/run/user/1000/pulse/native'/>
  </qemu:commandline>

sudo lspci -vs 01:00.1

01:00.1 Audio device: NVIDIA Corporation GP104 High Definition Audio Controller (rev a1)
    Subsystem: ASUSTeK Computer Inc. GP104 High Definition Audio Controller
    Flags: bus master, fast devsel, latency 0, IRQ 146
    Memory at df080000 (32-bit, non-prefetchable) [size=16K]
    Capabilities: [60] Power Management version 3
    Capabilities: [68] MSI: Enable+ Count=1/1 Maskable- 64bit+
    Capabilities: [78] Express Endpoint, MSI 00
    Capabilities: [100] Advanced Error Reporting
    Kernel driver in use: vfio-pci
    Kernel modules: snd_hda_intel

<#
.SYNOPSIS
MSI-mode utility

.DESCRIPTION
Main purpose of this script is turning on MSI-mode for all PCI devices in bulk. Script offers four modes which can be selected through following command line arguments:
'on' - turning MSI-mode on;
'off' - turning MSI-mode off;
'reg' - printing reg-file for backup purposes (to save text to reg-file use standard redirection or piplining to comandlet Out-File);
- started without command line argument script prints devices capable for MSI-mode.

.INPUTS
None. You cannot pipe objects to MSI_mode_utils.ps1.

.OUTPUTS
Script prints text which can be redirected to any text file by means of either standard redirection (>) or pipilining to comandlet Out-File.

.EXAMPLE
PS C:\Tools> .\MSI_mode_utils.ps1 'on'

.EXAMPLE
PS C:\Tools> .\MSI_mode_utils.ps1 'off'

.EXAMPLE
PS C:\Tools> .\MSI_mode_utils.ps1 'reg' > c:\tools\msi_mode_backup.reg

.LINK
http://forums.guru3d.com/showthread.php?t=378044
#>

#requires -version 2

[hashtable]$dev_descr_dict = @{}
[hashtable]$dev_irqman_dict = @{}
[hashtable]$dev_msiprops_dict = @{}
[hashtable]$dev_msisupported_dict = @{}

# enumerate all HW IDs - subkeys of hklm\system\CurrentControlSet\Enum\PCI

[Microsoft.Win32.RegistryKey]$pci_rk = gi registry::hklm\system\CurrentControlSet\Enum\PCI -ErrorAction Stop
try {
    foreach($id in $pci_rk.GetSubKeyNames()) {
        [Microsoft.Win32.RegistryKey]$id_rk = $null
        try {
            $id_rk = $pci_rk.OpenSubKey($id)
            if(!$id_rk) { continue }

            # enumerate all devices - subkeys of HW ID

            foreach($dev in $id_rk.GetSubKeyNames()) {
                [Microsoft.Win32.RegistryKey]$dev_rk = $null
                try {
                    $dev_rk = $id_rk.OpenSubKey($dev)
                    if(!$dev_rk) { continue }
                    # skip devices without 'Device Parameters' and 'Device Parameters\Interrupt Management' subkeys
                    [Microsoft.Win32.RegistryKey]$dev_params_rk = $dev_rk.OpenSubKey('Device Parameters')
                    if(!$dev_params_rk) { continue }
                    [Microsoft.Win32.RegistryKey]$irq_management_rk = $dev_params_rk.OpenSubKey('Interrupt Management', $true)
                    $dev_params_rk.Close(); $dev_params_rk = $null
                    if(!$irq_management_rk) { continue }
                    [string]$devkey = $id+'\'+$dev
                    # store device`s description
                    $dev_descr_dict[$devkey] = $dev_rk.GetValue('DeviceDesc', $dev)
                    # store device`s 'Interrupt Management' registry key
                    $dev_irqman_dict[$devkey] = $irq_management_rk
                    # store device`s 'MessageSignaledInterruptProperties' registry key
                    [Microsoft.Win32.RegistryKey]$dev_msiprops_rk = $irq_management_rk.OpenSubKey('MessageSignaledInterruptProperties', $true)
                    $dev_msiprops_dict[$devkey] = $dev_msiprops_rk
                    # store device`s 'MSISupported' registry value
                    if($dev_msiprops_rk) { $dev_msisupported_dict[$devkey] = $dev_msiprops_rk.GetValue('MSISupported') }
                    else { $dev_msisupported_dict[$devkey] = $null }
                }
                finally { if($dev_rk) { $dev_rk.Close(); $dev_rk = $null } }
            }
        }
        finally { if($id_rk) { $id_rk.Close(); $id_rk = $null } }
    }

    if($args.Count -eq 0) {
        #print devices` info

        filter print_devices_with_MSI_turned_on {
            begin { '--------------------- Devices with MSI-mode turned on ---------------------' }
            process {
                if($dev_msiprops_dict[$_] -and $dev_msisupported_dict[$_] -eq 1) { $dev_descr_dict[$_] }
            }
        }

        filter print_devices_with_MSI_turned_off {
            begin { '--------------------- Devices with MSI-mode turned off ---------------------' }
            process {
                if($dev_msiprops_dict[$_] -and $dev_msisupported_dict[$_] -eq 0) { $dev_descr_dict[$_] }
            }
        }

        filter print_devices_without_MSI {
            begin { '--------------------- Devices with not configured MSI-mode ---------------------' }
            process {
                if(!$dev_msiprops_dict[$_] -or $dev_msisupported_dict[$_] -eq $null) { $dev_descr_dict[$_] }
            }
        }

        $dev_descr_dict.Keys | print_devices_with_MSI_turned_on
        $dev_descr_dict.Keys | print_devices_with_MSI_turned_off
        $dev_descr_dict.Keys | print_devices_without_MSI
    }
    elseif($args[0] -eq 'off') {
        # turning MSI-mode off

        filter turn_MSI_off {
            begin { '--------------------- Turning MSI-mode off ---------------------' }
            process {
                if($dev_msiprops_dict[$_] -and $dev_msisupported_dict[$_] -eq 1) {
                    $dev_descr_dict[$_]
                    [Microsoft.Win32.RegistryKey]$rk = $dev_msiprops_dict[$_]
                    $rk.SetValue('MSISupported', 0, 'DWord')
                    $dev_msisupported_dict[$_] = 0
                }
            }
        }

        $dev_descr_dict.Keys | turn_MSI_off
    }
    elseif($args[0] -eq 'on') {
        # turning MSI-mode on

        filter turn_MSI_on {
            begin { '--------------------- Turning MSI-mode on ---------------------' }
            process {
                if(!$dev_msiprops_dict[$_]) {
                    $dev_descr_dict[$_]
                    [Microsoft.Win32.RegistryKey]$rk = $dev_irqman_dict[$_]
                    $rk = $rk.CreateSubKey('MessageSignaledInterruptProperties')
                    $dev_msiprops_dict[$_] = $rk
                    $rk.SetValue('MSISupported', 1, 'DWord')
                    $dev_msisupported_dict[$_] = 1
                }
                elseif($dev_msisupported_dict[$_] -ne 1) {
                    $dev_descr_dict[$_]
                    [Microsoft.Win32.RegistryKey]$rk = $dev_msiprops_dict[$_]
                    $rk.SetValue('MSISupported', 1, 'DWord')
                    $dev_msisupported_dict[$_] = 1
                }
            }
        }

        $dev_descr_dict.Keys | turn_MSI_on
    }
    elseif($args[0] -eq 'reg') {
        # print backup reg-file content

        filter print_MSI_registry {
            begin { 'Windows Registry Editor Version 5.00'; '' }
            process {
                if(!$dev_msiprops_dict[$_]) {
                    '[-HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\PCI\{0}\Device Parameters\Interrupt Management\MessageSignaledInterruptProperties]' -f $_
                }
                elseif($dev_msisupported_dict[$_] -eq $null) {
                    '[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\PCI\{0}\Device Parameters\Interrupt Management\MessageSignaledInterruptProperties]' -f $_
                    '"MSISupported"=-'
                }
                else {
                    '[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\PCI\{0}\Device Parameters\Interrupt Management\MessageSignaledInterruptProperties]' -f $_
                    '"MSISupported"=dword:0000000{0}' -f $dev_msisupported_dict[$_]
                }
                ''
            }
        }

        $dev_descr_dict.Keys | print_MSI_registry
    }
}
finally {
# clenaup
    foreach($rk in $dev_irqman_dict.Values) { $rk.Close() }
    foreach($rk in $dev_msiprops_dict.Values) { if($rk) { $rk.Close() } }
    $dev_irqman_dict.Clear(); $dev_irqman_dict = $null
    $dev_msiprops_dict.Clear(); $dev_msiprops_dict = $null
    $dev_descr_dict.Clear(); $dev_descr_dict = $null
    $dev_msisupported_dict.Clear(); $dev_msisupported_dict = $null

    $pci_rk.Close(); $pci_rk = $null

Set-ExecutionPolicy -ExecutionPolicy Unrestricted

apt install build-essential
apt build-dep qemu-kvm
git clone https://github.com/spheenik/qemu.git

util/memfd.c:40:12: error: static declaration of memfd_create follows non-static declaration

diff --git a/configure b/configure
index 6587e8014b..0c0c610468 100755
--- a/configure
+++ b/configure
@@ -3847,7 +3847,7 @@ fi
 # check if memfd is supported
 memfd=no
 cat > $TMPC << EOF
-#include <sys/memfd.h>
+#include <sys/mman.h>

 int main(void)
 {
diff --git a/util/memfd.c b/util/memfd.c
index 4571d1aba8..412e94a405 100644
--- a/util/memfd.c
+++ b/util/memfd.c
@@ -31,9 +31,7 @@

 #include "qemu/memfd.h"

-#ifdef CONFIG_MEMFD
-#include <sys/memfd.h>
-#elif defined CONFIG_LINUX
+#if defined CONFIG_LINUX && !defined CONFIG_MEMFD
 #include <sys/syscall.h>
 #include <asm/unistd.h>

cd qemu
mkdir build
cd build
../configure --prefix=/opt/qemu-test --python=/usr/bin/python2 --target-list=x86_64-softmmu --audio-drv-list=pa --disable-werror
make

sudo make install

<emulator>/opt/qemu-test/bin/qemu-system-x86_64</emulator>

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

Pin des CPU et threads IO

Épingler des cœurs CPU à la VM permettra de limiter la perte de temps lié au context switching. Si votre CPU supporte l’hyperthreading, soyez attentifs à la disposition de ces cœurs logiques supplémentaires et adressez les en conséquence. Passer les deux cœurs logiques d’un même cœur physique permet de mieux isoler la VM. Répartir la VM sur tous les cœurs physiques vous donnera peut-être plus de performances sous certaines conditions, mais peut tout autant vous en faire perdre si la VM fini par étouffer l’hôte.

Épingler les IO sur d’autres cœurs permet de laisser l’émulation des IO à part et d’éviter les blocages sur ce point.

<iothreads>2</iothreads>
<cputune>
  <vcpupin vcpu='0' cpuset='0'/>
  <vcpupin vcpu='1' cpuset='6'/>
  <vcpupin vcpu='2' cpuset='1'/>
  <vcpupin vcpu='3' cpuset='7'/>
  <vcpupin vcpu='4' cpuset='2'/>
  <vcpupin vcpu='5' cpuset='8'/>
  <vcpupin vcpu='6' cpuset='3'/>
  <vcpupin vcpu='7' cpuset='9'/>
  <emulatorpin cpuset='5-11'/>
  <iothreadpin iothread='1' cpuset='5'/>
  <iothreadpin iothread='2' cpuset='11'/>
</cputune>

Huge pages mémoire

Afin de limiter la fragmentation de l’espace mémoire, il peut être préférable de s’appuyer sur les huge pages. Dans le cas d’une VM avec IOMMU, la mémoire devra être allouée d’un bloc sur des pages statiques allouées en avance. La taille d’une page par défaut étant de 2Mo, à vous de faire le calcul sur combien de ces pages vous avez besoin. Cette allocation peut se faire par sysctl.

sysctl vm.nr_hugepages=8192

Pour rendre cette allocation automatique au boot, par exemple dans /etc/sysctl.d/00-vfio.conf.

vm.nr_hugepages = 8192

Il faudra également indiquer à la VM de taper dans ces hugepages.

<memoryBacking>
    <hugepages/>
</memoryBacking>

Patch NPT pour les CPU AMD

Un patch a été appliqué sur les noyaux Linux 4.9, 4.14 et plus récents pour corriger un bug touchant les tables de pages mémoires imbriquées sur les CPU AMD qui dégradait sérieusement les performances quand NPT était activé. Je n’ai pas vérifié si le noyaux standard de Stretch le propose, c’est possible étant donné qu’il est basé sur la branche LTS 4.9, mais à confirmer. Buster ne devrait pas poser de problème, étant basé sur la branche 4.16 à l’heure actuelle.