Executando o Windows 10 no Linux usando KVM com VGA Passthrough

Este tutorial explica como instalar e executar o Windows 10 no Linux usando GPU passthrough e drivers VFIO para obter desempenho quase nativo – para jogos, edição de fotos ou vídeos e outras tarefas gráficas e intensivas da CPU. Ele também lista as armadilhas comuns e as possíveis maneiras de melhorar ainda mais o desempenho. Por último, não menos importante, oferece uma lista abrangente de recursos externos e links úteis. Facebook Twitter Reddit Compartilhar

Índice

A necessidade

Você deseja usar o Linux como sistema operacional principal, mas ainda precisa do Windows para certos aplicativos indisponíveis no Linux. Você precisa de um desempenho gráfico de alto nível (3D) no Windows para jogos de computador, edição de fotos ou vídeos, etc. E não quer fazer boot duplo no Linux ou Windows. Nesse caso, continue a ler.

Muitas CPUs modernas têm recursos integrados que melhoram o desempenho das máquinas virtuais (VM), até o ponto em que os sistemas virtualizados são indistinguíveis dos sistemas não virtualizados. Isso nos permite criar máquinas virtuais em uma plataforma host Linux sem comprometer o desempenho do sistema convidado (Windows).

Para alguns benchmarks do meu sistema atual, consulte Windows 10 Virtual Machine Benchmarks

A solução

No tutorial a seguir, descrevo como instalar e executar o Windows 10 como uma máquina virtual KVM em um host Linux Mint ou Ubuntu. O tutorial usa uma tecnologia chamada VGA passthrough (também conhecida como “GPU passthrough” ou “vfio” para o driver vfio usado) que fornece desempenho gráfico quase nativo na VM. Tenho feito a passagem VGA desde o verão de 2012, executando pela primeira vez o Windows 7 em um hipervisor Xen, mudando para KVM e Windows 10 em dezembro de 2015. O desempenho – gráfico e de computação – no Xen e KVM tem sido nada menos que estelar!

O tutorial abaixo só funcionará com hardware adequado! Se o seu computador não atender aos requisitos básicos de hardware descritos abaixo, você não conseguirá fazê-lo funcionar.

O tutorial não foi escrito para o iniciante! Presumo que você tenha alguma experiência em Linux, pelo menos o suficiente para ser capaz de restaurar seu sistema quando algo der errado.

Também estou fornecendo links para outros tutoriais semelhantes que podem ajudar. Veja a seção de Referências abaixo. Por último, você encontrará links para diferentes fóruns e comunidades, onde poderá encontrar mais informações e ajuda.

Nota: O tutorial foi postado originalmente no do fórum Linux Mint .

aviso Legal

Todas as informações e dados fornecidos neste tutorial são apenas para fins informativos. Não faço representações quanto à precisão, integridade, atualidade, adequação ou validade de qualquer informação neste tutorial e não serei responsável por quaisquer erros, omissões ou atrasos nessas informações ou quaisquer perdas, lesões ou danos decorrentes de seu uso . Todas as informações são fornecidas no estado em que se encontram.

Você está ciente de que, ao seguir este tutorial, você pode arriscar a perda de dados ou tornar seu computador inoperante. Faça backup do seu computador! Certifique-se de que documentos / dados importantes podem ser acessados em outro lugar, caso o computador fique inoperante.

Para obter um glossário de termos usados no tutorial, consulte Glossário de termos de virtualização .

Tutorial

Nota para usuários do Ubuntu: Meu tutorial usa o comando “xed” encontrado no Linux Mint Mate para editar documentos. Você terá que substituí-lo por “gedit” ou qualquer outro editor que você usa no Ubuntu / Xubuntu / Lubuntu…

Nota 2: acabei de publicar um novo tutorial para um sistema baseado em Ryzen executando Pop! _OS. Consulte “ Criando uma VM Windows 10 no AMD Ryzen 9 3900X usando Qemu 4.0 e VGA Passthrough “.

Observação importante: este tutorial foi escrito há vários anos e foi atualizado para a sintaxe do Linux Mint 19 e do Ubuntu 18.04. Ele usa QEMU 2.11 ou QEMU 2.12. Hoje eu uso libvirt / virt-manager e QEMU 4.2 (no Linux Mint 20 / Ubuntu 20.04) ou QEMU 5.0 no Manjaro (veja o link acima).

Se você estiver seguindo este tutorial ao executar uma versão mais recente do sistema operacional e do QEMU (por exemplo, QEMU 4.2 ou 5.0), algumas das sintaxes do QEMU foram alteradas. Para as alterações, consulte a do QEMU documentação do usuário .

Simplesmente não encontrei tempo para revisar o tutorial. Dito isso, você ainda deve ser capaz de usá-lo e encontrar informações valiosas.

Parte 1 – Requisitos de Hardware

Para que este tutorial seja bem-sucedido, o hardware do seu computador deve atender a todos os seguintes requisitos:

Suporte IOMMU

No jargão da Intel, é chamado de VT-d . A AMD o chama de AMD Virtualization , AMD-Vi ou Secure Virtual Machine (SVM) . Até IOMMU apareceu. Se você planeja comprar um novo PC / CPU, verifique os seguintes sites para obter mais informações:

Grupo Reddit VFIO – configuração de hardware para VFIO bem-sucedido
Wiki do Arch Linux – passagem PCI via exemplos OVMF
Relatórios da comunidade sobre sistemas de trabalho – https://passthroughpo.st/vfio-increments/
A comunidade Reddit VFIO – a comunidade de passagem de GPU mais ativa ao redor
Intel – http://ark.intel.com/Search/FeatureFilter?productType=processors&VTD=true
Processadores Intel com suporte ACS – http://vfio.blogspot.com/2015/10/intel-processors-with-acs-support.html
Wikipedia – https://en.wikipedia.org/wiki/List_of_IOMMU-supporting_hardware
AMD – http://products.amd.com/en-us e verifique as especificações do processador
As placas- AMD- mãe B350 NÃO suportam IOMMU.

Tanto a Intel quanto a AMD melhoraram seu suporte a IOMMU nos últimos anos. Ainda existem diferenças entre as CPUs – especificamente ACS (Serviços de Controle de Acesso) pode variar entre os modelos de CPU. De modo geral, as CPUs Intel ou AMD de ponta fornecem melhores ACS ou recursos de isolamento de dispositivo. Isso não quer dizer que as CPUs mais práticas não funcionarão, desde que suportem IOMMU.

O primeiro link acima fornece uma lista não abrangente de configurações de CPU / placa-mãe / GPU onde os usuários tiveram sucesso com a passagem de GPU. Ao construir um novo PC, certifique-se de comprar componentes que suportam passagem de GPU.

A maioria dos fabricantes de PC / placa-mãe desabilita o IOMMU por padrão. Você terá que habilitar o IOMMU no BIOS. Para verificar o suporte atual de CPU / placa-mãe IOMMU e ativá-lo, faça o seguinte:

Reinicialize seu PC e entre no menu de configuração do BIOS (normalmente você pressiona F2, DEL ou similar durante a inicialização para entrar na configuração do BIOS).
Pesquise IOMMU, VT-d, SVM ou “tecnologia de virtualização para E / S direcionada” ou qualquer outro nome que possa ser chamado em seu sistema. Ligue VT-d / IOMMU .
Salve e saia do BIOS e inicialize no Linux.
Edite o arquivo / etc / default / grub (você precisa de permissão de root para fazer isso). Abra uma janela de terminal (Ctrl + Alt + T) e digite (copiar / colar):
xed admin:///etc/default/grub
(use gksudo gedit /etc/default/grubpara versões mais antigas do Linux Mint / Ubuntu)
Aqui está meu arquivo / etc / default / grub antes da edição:
GRUB_DEFAULT = 0
# GRUB_HIDDEN_TIMEOUT = 10
# GRUB_HIDDEN_TIMEOUT_QUIET = true
GRUB_TIMEOUT_STYLE = contagem regressiva
GRUB_TIMEOUT = 0
GRUB_DISTRIBUTOR = `lsb_release -i -s 2> / dev / null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT = ”quiet”
GRUB_CMDLINE_LINUX = ””

Procure a linha que começa com GRUB_CMDLINE_LINUX_DEFAULT = ”…” . Você precisa adicionar uma das seguintes opções a esta linha, dependendo do seu hardware:
CPU Intel :
intel_iommu=on
CPU AMD :
amd_iommu=on
Salve o arquivo e saia. Em seguida, digite:
sudo update-grub
Agora verifique se IOMMU é realmente compatível. Reinicialize o PC . Abra uma janela de terminal.
Em AMD máquinas , use:
dmesg | grep AMD-Vi
A saída deve ser semelhante a esta:
…
AMD-Vi: Habilitando IOMMU em 0000: 00: 00.2 cap 0x40
AMD-Vi: Lazy IO / TLB flushing habilitado
AMD-Vi: Inicializado para modo Passthrough
…
Ou use:
cat /proc/cpuinfo | grep svm

Em Intel máquinas , use:
dmesg | grep "Virtualization Technology for Directed I/O"

A saída deve ser esta:
[0.902214] DMAR: Tecnologia de virtualização Intel (R) para E / S direcionada

Se você não obtiver esta saída, o VT-d ou AMD-V não está funcionando – você precisa consertar isso antes de continuar! Provavelmente significa que o seu hardware (CPU ou placa-mãe) não suporta IOMMU, caso em que não vale a pena continuar este tutorial 😥. Verifique novamente para ter certeza de que sua CPU suporta IOMMU. Se sim, a causa pode ser um BIOS da placa-mãe com defeito. Consulte a seção de solução de problemas abaixo. Você pode precisar atualizar o BIOS da placa-mãe (tenha cuidado, atualizar o BIOS pode potencialmente bloquear a placa-mãe).

Dois processadores gráficos

Além de uma CPU e placa-mãe com suporte para IOMMU, você precisa de dois processadores gráficos (GPU) :

1. Uma GPU para seu host Linux (o sistema operacional que você está executando no momento, espero);

2. Uma GPU (placa gráfica) para o convidado do Windows.

Estamos construindo um sistema que executa dois sistemas operacionais ao mesmo tempo. Muitos recursos, como espaço em disco, memória, etc., podem ser alternados entre o host e o convidado, conforme necessário. Infelizmente, a GPU não pode ser trocada ou compartilhada entre os dois sistemas operacionais, pelo menos não de uma maneira fácil. (Existem maneiras de redefinir a placa gráfica, bem como o servidor X no Linux para que você possa se safar com uma placa gráfica , mas eu pessoalmente acredito que não é a ideal. Veja por exemplo aqui e aqui para mais informações.)

Se, como eu, você usa Linux para as coisas do dia a dia, como e-mails, navegação na web, documentos, etc., e Windows para jogos, edição de fotos ou vídeos, você terá que dar ao Windows uma GPU mais poderosa, enquanto o Linux será executado felizmente com uma GPU barata ou o processador gráfico integrado (IGP). (Você também pode criar uma VM Linux com GPU passthru se precisar do Linux para jogos ou aplicativos gráficos.)

A placa gráfica a ser passada para o Windows (ou Linux) deve ser capaz de redefinir corretamente após o desligamento da VM. Eu escrevi um post separado sobre placas de vídeo AMD vs. Nvidia, mas o ponto principal é este: evite GPUs AMD! Veja também passthroughpo.st e abra “GPUs Convidadas” na parte inferior.

Suporte UEFI na GPU usada com Windows

Neste tutorial, eu uso UEFI para inicializar a VM do Windows. Isso significa que a placa de vídeo que você vai usar para o convidado do Windows deve oferecer suporte a UEFI – a maioria das placas mais recentes tem . Você pode verificar aqui se sua placa de vídeo e BIOS suportam UEFI. Se você executa o Windows, baixe e execute o GPU-Z e veja se há uma marca de seleção ao lado de UEFI. (Para obter mais informações, clique aqui .)

GPU-Z com UEFI informação da placa gráfica

Existem várias vantagens no UEFI, nomeadamente, inicia mais rapidamente e ultrapassa alguns problemas associados ao arranque antigo (Seabios).

Se você planeja usar o Intel IGD (dispositivo gráfico integrado) para o seu host Linux, a inicialização UEFI é o caminho a percorrer. A UEFI supera o problema de arbitragem VGA associado ao IGD e ao uso do Seabios legado.
Se, por algum motivo, você não puder inicializar a VM usando UEFI e quiser usar o Intel IGD para o host, será necessário compilar o patch do árbitro VGA i915 no kernel. Antes de fazer isso, verifique a observação abaixo. Para obter mais informações sobre arbitragem VGA, consulte aqui . Para o patch do árbitro VGA i915, veja aqui ou na Parte 15 – Referências .

Nota: Se sua GPU NÃO suporta UEFI, ainda há esperança. Você pode encontrar um UEFI BIOS para sua placa em TechPowerUp Video BIOS Collection . Um blogueiro do Youtube que se autodenomina Spaceinvader produziu um muito útil vídeo sobre como usar um VBIOS.

Se não houver BIOS de vídeo UEFI para sua placa gráfica do Windows, você terá que procurar um tutorial usando o método Seabios. Não é muito diferente disso aqui, mas há algumas coisas a serem consideradas.

Usuários de laptop com tecnologia Nvidia Optimus : Misairu_G (nome de usuário) publicou um guia detalhado para passagem VGA em laptops com tecnologia Nvidia Optimus – consulte o GUIA para passagem VGA em laptops Nvidia Optimus . (Para referência, aqui alguns posts mais antigos sobre o assunto: https://forums.linuxmint.com/viewtopic.php?f=231&t=212692&p=1300764#p1300634 .)

Nota: Nos últimos anos, as placas de vídeo AMD sofreram de um bug denominado “bug de redefinição”. As placas de vídeo modernas da AMD geralmente não são capazes de realizar uma “redefinição de nível de função” adequada (FLR, em resumo). Eles inicializarão bem, mas quando você desligar a VM e inicializá-la novamente, receberá um “ erro interno: tipo de cabeçalho PCI desconhecido ‘127’ “.

Existem algumas soluções alternativas para esse erro. Consulte a seção Solução de problemas abaixo.

Parte 2 – Instalando Qemu / KVM

O lançamento do Qemu enviado com o Linux Mint 19 é a versão 2.11 e oferece suporte aos recursos KVM mais recentes.

Para que o Linux Mint “lembre” os pacotes instalados, use o Gerenciador de Software para instalar os seguintes pacotes:

qemu-kvm
qemu-utils
seabios
ovmf
largepages
cpu-checker
bridge-utils

Para AMD Ryzen , veja também aqui (observe que o Linux Mint 19 / Ubuntu 18.04 requer apenas a atualização do BIOS). Geralmente, a AMD teve uma série de problemas com o suporte a passagem de VFIO / GPU. Leia a seção de solução de problemas abaixo e verifique os links em compatibilidade de hardware para obter mais informações.

Como alternativa , use
sudo apt install qemu-kvm qemu-utils seabios ovmf hugepages cpu-checker bridge-utils
para instalar os pacotes necessários.

Parte 3 – Determinando os dispositivos para passar para o Windows

Precisamos encontrar o (s) PCI ID (s) da placa gráfica e talvez de outros dispositivos que desejamos passar para a VM do Windows. Normalmente o IGP (a GPU dentro do processador) será usado para Linux e a placa de vídeo discreta para o convidado do Windows. Minha CPU não tem uma GPU integrada, então eu uso 2 placas gráficas. Aqui está minha configuração de hardware:

GPU para Linux: Nvidia Quadro 2000 residente no primeiro slot de placa gráfica PCIe.
GPU para Windows: Nvidia GTX 970 residente no segundo slot de placa gráfica PCIe.

Para determinar o número do barramento PCI e IDs PCI, digite:
lspci | grep VGA

Aqui está a saída em meu sistema:
01: 00.0 controlador compatível com VGA: NVIDIA Corporation GF106GL [Quadro 2000] (rev a1)
02: 00.0 controlador compatível com VGA: NVIDIA Corporation Device 13c2 (rev a1)

A primeira placa em 01: 00.0 é a Quadro 2000 que desejo usar para o host Linux. O outro cartão em 02: 00.0 quero passar para o Windows.

Placas de vídeo modernas geralmente vêm com um controlador de áudio on-board, pelo qual também precisamos passar. Para encontrar seu ID, digite:
lspci -nn | grep 02:00.

Substitua “ 02:00. ”Com o número do barramento da placa de vídeo que você deseja passar para o Windows, sem o“ à direita 0 “ . Aqui está a saída em meu computador:
02: 00.0 controlador compatível com VGA [0300]: Dispositivo NVIDIA Corporation [ 10de: 13c2 ] (rev a1)
02: 00.1 Dispositivo de áudio [0403]: Dispositivo NVIDIA Corporation [ 10de: 0fbb ] (rev a1 )

Anote os do números barramento (02: 00.0 e 02: 00.1 acima), bem como os IDs PCI (10de: 13c2 e 10de: 0fbb no exemplo acima). Precisamos deles na próxima parte.

Agora verifique se a placa gráfica reside em seu próprio grupo IOMMU:
find /sys/kernel/iommu_groups/ -type l

Para obter uma lista classificada, use:
for a in /sys/kernel/iommu_groups/*; do find $a -type l; done | sort --version-sort

Procure o número do barramento da placa gráfica pela qual deseja passar. Aqui está a saída (reduzida) em meu sistema:
…
/sys/kernel/iommu_groups/19/devices/0000:00:1f.3
/sys/kernel/iommu_groups/20/devices/0000:01:00.0
/ sys / kernel /iommu_groups/20/devices/0000:01:00.1
/sys/kernel/iommu_groups/21/devices/0000:02:00.0
/sys/kernel/iommu_groups/21/devices/0000:02:00.1
/ sys / kernel / iommu_groups /22/devices/0000:05:00.0
/sys/kernel/iommu_groups/22/devices/0000:06:04.0
…

Certifique-se de que a GPU e talvez outros dispositivos PCI pelos quais deseja passar residam em seu próprio grupo IOMMU. No meu caso, a placa de vídeo e seu controlador de áudio designado para passagem residem no grupo IOMMU 21. Nenhum outro dispositivo PCI reside neste grupo, então está tudo bem.

Se sua placa VGA compartilha um grupo IOMMU com outros dispositivos PCI, consulte GRUPO IOMMU CONTÉM DISPOSITIVOS ADICIONAIS para uma solução!

O próximo passo é encontrar o mouse e o teclado (dispositivos USB) que queremos atribuir ao convidado do Windows. Lembre-se, vamos rodar dois sistemas operacionais independentes lado a lado e os controlaremos por meio do mouse e do teclado.

Sobre teclado e mouse

Dependendo se e quanto controle você deseja ter sobre cada sistema, existem diferentes abordagens:

1. Obtenha um USB- switch KVM (teclado / VGA / mouse) . Este é um pequeno dispositivo de hardware com geralmente 2 portas USB para teclado e mouse, bem como saídas de vídeo VGA ou (o mais caro) DVI ou HDMI. Além disso, o switch USB-KVM possui dois cabos USB e 2 cabos VGA / DVI / HDMI para conectar a dois PCs diferentes. Como rodamos 2 PCs virtuais em um único sistema, esta é uma solução viável. Veja também minha acessórios de hardware de virtualização postagem sobre .
Vantagens:
– Funciona sem software especial no SO, apenas os habituais drivers de mouse e teclado;
– Melhor em desempenho – sem sobrecarga de software.
Desvantagens:
– Requer hardware extra (embora barato);
– Mais confusão de cabos e outra caixa com cabos na sua mesa;
– Requer que você pressione um botão para alternar entre anfitrião e convidado e vice-versa;
– Muitos KVM de baixo custo não são confiáveis e não inicializam o teclado ou mouse adequadamente ao alternar as portas USB;
– Precisa passar por uma porta USB ou controlador – veja abaixo em grupos IOMMU.

2. Sem gastar um níquel, você pode simplesmente passar pelo mouse e teclado quando a VM é iniciada.
Vantagens:
– Fácil de implementar;
– Sem dinheiro para investir;
– Boa solução para configurar o Windows.

Existem pelo menos duas maneiras de realizar essa tarefa. Descreverei ambas as opções.

3. Synergy ( http://symless.com/synergy/ ) é uma solução de software comercial que, uma vez instalada e configurada, permite interagir com dois PCs ou máquinas virtuais.
Vantagens:
– Solução mais versátil, especialmente com telas duplas;
– Apenas software, fácil de configurar;
– Nenhuma compra de hardware necessária.
Desvantagens:
– Requer a instalação de software no host e no convidado;
– Não funciona durante a instalação do Windows (ver opção 2);
– Custa $ 10 para uma licença básica vitalícia;
– Pode produzir lag, embora eu duvide que você notará, a menos que haja algo errado com a configuração da ponte.

4. “ multi-dispositivos Teclado e mouse bluetooth ” que podem se conectar a dois dispositivos diferentes e alternar entre eles com o pressionar de um botão (veja por exemplo aqui ):
Vantagens:
– Solução mais conveniente;
– Mesmo desempenho da opção 1.
Desvantagens:
– Preço.
– Certifique-se de que o dispositivo é compatível com Linux ou que você pode devolvê-lo se não suportar!

Eu escolhi a opção 1 pela simplicidade e universalidade, mas a substituí pela opção 4. O USB-KVM logo começou a funcionar mal e me deu muitos problemas.

Agora estou usando um mouse mestre 2S Logitech MX e um teclado Logitech K780 BT. Veja aqui como emparelhar esses dispositivos com os dongles USB.

Ambas as opções 1 e 4 geralmente requerem a passagem de um dispositivo USB PCI para o convidado do Windows. Eu precisava das portas USB2 e USB3 na minha VM do Windows e consegui passar por dois controladores USB para o meu convidado do Windows, usando o PCI passthrough.

Para a instalação da VM, escolhemos a opção 2 (veja acima), ou seja, passamos nosso teclado e mouse para a VM do Windows. Para fazer isso, precisamos identificar seu ID USB:
lsusb

Aqui, a saída do meu sistema (truncada):
…
Dispositivo Bus 010 006: ID 045e: 076c Microsoft Corp. Comfort Mouse 4500
Bus 010 Dispositivo 005: ID 045e: 0750 Microsoft Corp. Teclado com fio 600
…

Anote os IDs: 045e: 076c e 045e: 0750 no meu caso.

Parte 4 – Prepare-se para Passthrough

Para disponibilizar a placa de vídeo para a VM do Windows, atribuiremos um driver “fictício” como espaço reservado: vfio-pci. Para fazer isso, primeiro temos que evitar que o driver padrão se vincule à placa de vídeo. Isso às vezes pode ser complicado, pois alguns drivers são carregados no início do processo de inicialização e impedem a ligação ao vfio-pci.

(Uma maneira de fazer isso é colocando os módulos do driver na lista negra ou usando as configurações do modo Kernel. Para obter mais informações sobre a configuração do modo Kernel, consulte https://wiki.archlinux.org/index.php/kernel_mode_setting .)

Nota: Se você tiver duas placas de vídeo idênticas para o host e a VM, o método abaixo não funcionará. Nesse caso, consulte Usando o recurso driver_override .

O método que descrevo abaixo usa o alias do módulo (graças a esta postagem ). Outro método promissor é descrito neste tutorial .

Execute o seguinte comando:
cat /sys/bus/pci/devices/0000:02:00.0/modalias
onde 0000: 02: 00.0 é o número do barramento PCI de sua placa gráfica obtido na Parte 3 acima. A saída será semelhante a:
pci: v000010DEd000013C2sv00001458sd00003679bc03sc00i00

Repita o comando acima com o número do barramento PCI da parte de áudio:
cat /sys/bus/pci/devices/0000:02:00.1/modalias
onde 0000: 02: 00.1 é o número do barramento PCI do dispositivo de áudio da placa gráfica.

Na janela do terminal, digite o seguinte:
sudo -i
seguido de sua senha para ter um terminal root.

Abra ou crie /etc/modprobe.d/local.conf:
xed admin:///etc/modprobe.d/local.conf
e copie e cole os resultados dos dois comandos cat / sys /… acima. Em seguida, preceda as linhas com “alias” e anexe as linhas com “vfio-pci”, conforme mostrado abaixo:
alias pci:v000010DEd000013C2sv00001458sd00003679bc03sc00i00 vfio-pci
alias pci:v000010DEd00000FBBsv00001458sd00003679bc04sc03i00 vfio-pci

No final desse arquivo, adicione a seguinte linha:
options vfio-pci ids=10de:13c2,10de:0fbb
onde 10de: 13c2 e 10de: 0fbb são os IDs PCI para VGA e parte de áudio de sua placa de vídeo, conforme determinado no parágrafo anterior.

Você também pode adicionar a seguinte opção abaixo das opções de vfio-pci entrada :
options vfio-pci disable_vga=1
(A entrada acima só é válida para kernels 4.1 e mais recentes e convidados UEFI . Ajuda a evitar que a arbitragem VGA interfira nos dispositivos host.)

Salve o arquivo e saia do editor.

Alguns aplicativos como Passmark e Windows 10 versões 1803 e mais recentes exigem a seguinte opção:
echo "options kvm ignore_msrs=1" >> /etc/modprobe.d/kvm.conf

Para carregar o vfio e outros módulos necessários na inicialização, edite o arquivo / etc / initramfs-tools / modules:
xed admin:///etc/initramfs-tools/modules

No final do arquivo, adicione na ordem listada abaixo:
vfio
vfio_iommu_type1
vfio_pci
vfio_virqfd
vhost-net

Salve e feche o arquivo.

Quaisquer mudanças em /etc/modprobe.d requerem que você atualize o initramfs . Digite na linha de comando:
update-initramfs -u

Parte 5 – Configurações de rede

Por motivos de desempenho, é melhor criar uma ponte de rede virtual que conecte a VM ao host. Em uma postagem separada, escrevi um tutorial detalhado sobre como configurar uma ponte usando o Network Manager .

Nota: Bridging só funciona para redes com fio. Se o seu PC estiver conectado a um roteador por meio de um link sem fio (Wifi), você não conseguirá usar uma ponte. A maneira mais fácil de obter rede dentro da VM do Windows é NÃO usar nenhuma configuração de rede. Você também precisa excluir a configuração de rede no comando qemu (script). Se você ainda deseja usar uma rede com ponte, existem soluções alternativas como roteamento ou ebtables (veja https://wiki.debian.org/BridgeNetworkConnections#Bridging_with_a_wireless_NIC ).

Depois de configurar a rede, reinicie o computador e teste a configuração da rede – abra o navegador e veja se você tem acesso à Internet.

Parte 6 – Configurando Hugepages

Movido para a Parte 18 – Ajuste de desempenho . Esta é uma medida de ajuste de desempenho e não é necessária para executar o Windows no Linux. Consulte Configurar Hugepages na Parte 18 – Ajuste de desempenho .

Parte 7 – Baixe os drivers VFIO

Baixe o driver ISO VFIO para ser usado com a instalação do Windows em https://docs.fedoraproject.org/en-US/quick-docs/creating-windows-virtual-machines-using-virtio-drivers/index.html . Abaixo estão os links diretos para as imagens ISO:

Drivers VIRTIO mais recentes: https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/latest-virtio/virtio-win.iso

Drivers VIRTIO estáveis: https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso

Eu escolhi o mais recente driver ISO .

Parte 8 – Prepare o espaço de armazenamento do Windows VM

Precisamos de algum espaço de armazenamento para instalar a VM do Windows. Existem várias opções:

Crie um arquivo de imagem raw .
Vantagens:
– Fácil de implementar;
– Flexível – o arquivo pode crescer com suas necessidades;
– Instantâneos;
– Fácil migração;
– Boa performance.
Desvantagens:
– Ocupa todo o espaço que você especificar.
Crie um dedicado volume LVM .
Vantagens:
– Tecnologia familiar (pelo menos para mim);
– Excelente desempenho, como bare-metal;
– Flexível – você pode adicionar drives físicos para aumentar o tamanho do volume;
– Instantâneos;
– Montável no host Linux usando kpartx.
Desvantagens:
– Ocupa todo o espaço especificado;
– A migração não é tão fácil.
Passe por um controlador PCI SATA / disco .
Vantagens:
– Excelente desempenho, utilizando drivers de disco originais do Windows;
– Permite o uso de recursos de drive virtual do Windows;
– Pode usar uma instalação bare-metal existente do Windows em uma VM;
– Possibilidade de inicializar o Windows diretamente, ou seja, não como VM;
– Possível adicionar mais unidades.
Desvantagens:
– O PC precisa de pelo menos dois controladores SATA discretos;
– O host não tem acesso ao disco enquanto a VM está em execução;
– Requer um controlador SATA dedicado e unidade (s);
– O controlador SATA deve ter seu próprio grupo IOMMU;
– Possíveis conflitos no Windows entre a operação bare-metal e VM.

Para obter mais informações sobre essas e outras opções de imagem, consulte aqui: https://en.wikibooks.org/wiki/QEMU/Images

Embora eu esteja usando um volume LVM, sugiro que você comece com a imagem bruta. Vamos criar uma imagem de disco bruta:

qemu-img create -f raw -o preallocation=full /media/user/win.img 100G

para desempenho, ou simplesmente: fallocate -l 100G /media/user/win.img
Nota: Ajuste o tamanho (100G) e o caminho para corresponder às suas necessidades ou recursos.

Veja também minha postagem sobre Ajustando o desempenho do disco VM .

Parte 9 – Verifique a configuração

É melhor verificar se temos tudo:

KVM: kvm-ok
INFO: / dev / kvm existe A
aceleração KVM pode ser usada

Módulo KVM: lsmod | grep kvm
kvm_intel 200704 0
kvm 593920 1 kvm_intel
irqbypass 16384 2 kvm, vfio_pci
Acima é a saída para o módulo Intel.

VFIO: lsmod | grep vfio
vfio_pci 45056 0
vfio_virqfd 16384 1 vfio_pci
irqbypass 16384 2 sqm, vfio_pci
vfio_iommu_type1 24576 0
vfio 32768 2 vfio_iommu_type1, vfio_pci

QEMU: qemu-system-x86_64 --version
você precisa do emulador QEMU versão 2.5.0 ou mais recente. No Linux Mint 19 / Ubuntu 18.04, a versão QEMU é 2.11.

O vfio foi carregado e vinculado à placa de vídeo?
lspci -kn | grep -A 2 02:00
onde 02:00 é o número do barramento da placa gráfica para passar para o Windows. Aqui, a saída no meu PC:
02: 00.0 0300: 10de: 13c2 (rev a1)
Subsistema: 1458: 3679
Driver do kernel em uso: vfio-pci
02: 00.1 0403: 10de: 0fbb (rev a1)
Subsistema: 1458: 3679
Kernel driver em uso: vfio-pci

O driver do kernel em uso é vfio-pci. Funcionou!

Interromper remapeamento: dmesg | grep VFIO
[3.288843] VFIO – Versão do meta-driver de nível de usuário: 0.3
Tudo de bom!

Se você receber esta mensagem:
vfio_iommu_type1_attach_group: Sem suporte para remapeamento de interrupção. Use o parâmetro de módulo “allow_unsafe_interrupts” para habilitar o suporte VFIO IOMMU nesta plataforma,
insira o seguinte comando em um terminal raiz (ou use sudo -i ):
echo "options vfio_iommu_type1 allow_unsafe_interrupts=1" > /etc/modprobe.d/vfio_iommu_type1.conf
seguido por:
update-initramfs -u
Neste caso, você precisa reiniciar mais uma vez.

Parte 10 – Criar script para iniciar o Windows

Para criar e iniciar a VM do Windows, copie o script abaixo e guarde-o como windows10vm.sh (ou qualquer nome que desejar, basta manter a extensão .sh):

#!/bin/bash

vmname="windows10vm"

if ps -ef | grep qemu-system-x86_64 | grep -q multifunction=on; then
echo "A passthrough VM is already running." &
exit 1

else

# use pulseaudio
export QEMU_AUDIO_DRV=pa
export QEMU_PA_SAMPLES=8192
export QEMU_AUDIO_TIMER_PERIOD=99
export QEMU_PA_SERVER=/run/user/1000/pulse/native

cp /usr/share/OVMF/OVMF_VARS.fd /tmp/my_vars.fd

qemu-system-x86_64 \
-name $vmname,process=$vmname \
-machine type=q35,accel=kvm \
-cpu host,kvm=off \
-smp 4,sockets=1,cores=2,threads=2 \
-m 8G \
-balloon none \
-rtc clock=host,base=localtime \
-vga none \
-nographic \
-serial none \
-parallel none \
-soundhw hda \
-usb \-deviceusb-host,vendorid=0x045e,productid=0x076c \
-device usb-host,vendorid=0x045e,productid=0x0750 \
-device vfio-pci,host=02:00.0,multifunction=on \
-device vfio-pci,host=02:00.1 \
-drive if=pflash,format=raw,readonly,file=/usr/share/OVMF/OVMF_CODE.fd \
-drive if=pflash,format=raw,file=/tmp/my_vars.fd \
-boot order=dc \
-drive id=disk0,if=virtio,cache=none,format=raw,file=/media/user/win.img \
-drive file=/home/user/ISOs/win10.iso,index=1,media=cdrom \
-drive file=/home/user/Downloads/virtio-win-0.1.140.iso,index=2,media=cdrom \
-netdev type=tap,id=net0,ifname=vmtap0,vhost=on \
-device virtio-net-pci,netdev=net0,mac=00:16:3e:00:01:01

exit 0
fi

Torne o arquivo executável:
sudo chmod +x windows10vm.sh

Você precisa editar o arquivo e alterar as configurações e caminhos para corresponder à sua CPU e configuração. Veja abaixo as explicações sobre as opções qemu-system-x86:

-name $ vmname, process = $ vmname
Nome e nome do processo da VM. O nome do processo é exibido ao usar ps -Apara mostrar todos os processos e usado no script para determinar se a VM já está em execução. Não use win10 como nome de processo, por alguma razão inexplicável ele não funciona!

-máquina type = q35, accel = kvm
Isso especifica uma máquina para emular. A accel = kvm opção diz ao qemu para usar a aceleração KVM – sem ela, o convidado do Windows será executado no modo de emulação qemu, ou seja, será executado bem devagar.
Escolhi a type = q35 opção , pois melhorou minhas velocidades de leitura e gravação de SSD. Veja https://wiki.archlinux.org/index.php/QEMU#Virtual_machine_runs_too_slowly . Em alguns casos, type = q35 impedirá que você instale o Windows; em vez disso, pode ser necessário usar type = pc, accel = kvm . Veja a postagem aqui . Para ver todas as opções de type =… , digite o seguinte comando:
qemu-system-x86_64 -machine help
Importante : Vários usuários passando pelas placas Radeon RX 480 e Radeon RX 470 relataram loops de reinicialização após atualizar e instalar os drivers Radeon. Se você passar por uma placa de vídeo Radeon, é melhor substituir a linha -machine no script de inicialização pela seguinte linha:
-machine type=pc,accel=kvm
para usar a emulação i440fx padrão.
Nota para usuários IGD : Se você tiver uma CPU Intel com gráficos internos (IGD) e quiser usar o Intel IGD para Windows, há uma nova opção para habilitar o passthrough:
igd-passthru=on|offcontrola o suporte ao passthrough IGD GFX (padrão = desligado).
Na maioria dos casos, você desejará usar uma placa gráfica discreta com o Windows.

-cpu host, kvm = off
Isso diz ao qemu para emular a CPU exata do host. Existem mais opções, mas é melhor ficar com o anfitrião .
A kvm = off opção é apenas necessária para placas de vídeo Nvidia – se você tiver uma placa AMD / Radeon para o seu convidado do Windows, pode remover essa opção e especificar -cpu host .

-smp 4, sockets = 1, núcleos = 2, threads = 2
Isso especifica o multiprocessamento. -smp 4 diz ao sistema para usar 4 processadores (virtuais). Minha CPU tem 6 núcleos, cada um suportando 2 threads, o que perfaz um total de 12 threads. Provavelmente, é melhor não atribuir todos os recursos da CPU à VM do Windows – o host também precisa de alguns recursos (lembre-se de que parte do processamento e I / O vindos do convidado consome recursos da CPU no host). No exemplo acima, dei processadores virtuais do Windows 4. sockets = 1 especifica o número de sockets de CPU reais que o qemu deve atribuir, núcleos = 2 diz ao qemu para atribuir 2 núcleos de processador à VM e threads = 2 especifica 2 threads por núcleo. Pode ser suficiente simplesmente especificar -smp 4 , mas não tenho certeza sobre as consequências de desempenho (se houver).
Se você tiver uma CPU Intel de 4 núcleos com hyper-threading, poderá especificar -smp 6, sockets = 1, cores = 3, threads = 2 para atribuir 75% dos recursos da CPU à VM do Windows. Normalmente, isso deve ser suficiente, mesmo para jogos e aplicativos exigentes.
Nota: Se sua CPU não suportar hyper-threading, especifique threads = 1 .

-m 8G
A -m opção atribui memória (RAM) à VM, neste caso 8 GByte. O mesmo que -m 8192 . Você pode aumentar ou diminuir, dependendo de seus recursos e necessidades. Com versões modernas do Windows, não faz sentido fornecer menos do que 4G, a menos que você esteja realmente sobrecarregado com RAM. Se você usar páginas enormes, certifique-se de que o tamanho da página grande corresponde a isso!

-mem-path / dev / largepages
Isso diz ao qemu onde encontrar as enormes páginas que reservamos. Se você não configurou o largepages, você precisa remover esta opção.

-mem-prealloc Pré-aloca atribuímos
a memória que à VM.

-balloon nenhum aumento da
Não queremos o memória.

-rtc clock = host, base = localtime
-rtc clock = host diz ao qemu para usar o relógio do host para sincronização. base = localtime permite que o convidado do Windows use a hora local do sistema host. Outra opção é utc .

-vga nenhum
Desativa a emulação embutida da placa de vídeo. Você pode remover esta opção para depuração.

-nographic
Desativa totalmente a saída gráfica SDL. Para fins de depuração, remova esta opção se você não chegar à tela do Tiano Core.

-serial nenhum
-paralelo nenhum
Desativa interfaces seriais e paralelas. Quem precisa deles, afinal?

-soundhw hda
Junto com o export QEMU_AUDIO_DRV=pacomando shell, esta opção ativa o som por meio do PulseAudio.
Se você deseja passar por uma placa de áudio física ou dispositivo de áudio e transmitir áudio de seu host Linux para seu convidado Windows, veja aqui: Transmissão de áudio do Linux para o Windows .

-usb
-dispositivo usb-host, vendorid = 0x045e, productid = 0x076c
-device usb-host, vendorid = 0x045e, productid = 0x0750
-usb ativa o suporte USB e -device usb-host… atribui o mouse de dispositivos de host USB ( 045e: 076c ) e teclado ( 045e: 0750 ) para o convidado. Substitua os IDs do dispositivo pelos que você encontrou usando o lsusbcomando na Parte 3 acima!
Observe a nova sintaxe. Existem também muitas outras opções que você pode encontrar aqui: file: ///usr/share/doc/qemu-system-common/qemu-doc.html .
Existem três opções para atribuir dispositivos host aos convidados. Aqui a sintaxe:
-usb \
-device usb-kbd \
-device usb-mouse \
passa pelo teclado e mouse para a VM. Ao usar esta opção, remova as opções -vga none e -nographic do script para permitir a alternância entre a VM do Windows e o host Linux usando CTRL + ALT.
-usb \ -device usb-host,hostbus=bus,hostaddr=addr \
passa pelo dispositivo host identificado por barramento e addr .
-usb \ -device usb-host,vendorid=vendor,productid=product \
passa pelo dispositivo host identificado pelo fornecedor e produto ID do

-dispositivo vfio-pci, host = 02: 00.0, multifuncional = on
-dispositivo vfio-pci, host = 02: 00.1
Aqui especificamos a placa de vídeo para passar para o convidado, usando vfio-pci. Preencha os IDs PCI que você encontrou na Parte 3 acima. É um multifuncional dispositivo (gráfico e som). Certifique-se de passar pelo vídeo e pela parte sonora ( 02: 00.0 e 02: 00.1 no meu caso).

-drive if = pflash, format = raw, readonly, file = / usr / share / OVMF / OVMF_CODE.fd
Especifica a localização e o formato do arquivo OVMF UEFI inicializável. Este arquivo não contém as variáveis, que são carregadas separadamente (veja logo abaixo).

-drive if = pflash, format = raw, file = / tmp / my_vars.fd
Estas são as variáveis para o arquivo de inicialização UEFI, que foram copiadas pelo script para /tmp/my_vars.fd .

-boot order = dc
Inicia a inicialização do CD ( d ) e, em seguida, primeiro o disco rígido ( c ). Após a instalação do Windows, você pode remover o “ d ” para inicializar diretamente do disco.

-drive id = disk0, if = virtio, cache = none, format = raw, file = / media / user / win.img
Define o primeiro disco rígido. Com as opções acima, ele será acessado como um paravirtualizado ( if = virtio drive ) em formato bruto ( format = raw ).
Importante: file = /… insira o caminho para o arquivo win.img criado anteriormente.
Outras opções de unidade possíveis são file = / dev / mapper / group-vol para volumes LVM ou file = / dev / sdx1 para discos ou partições inteiros.
Para algumas básicas da unidade opções , veja minha postagem aqui . Para a nova sintaxe Qemu e ajuste de desempenho da unidade, consulte Ajustando o desempenho do disco VM .

-drive file = / home / user / ISOs / win10.iso, index = 1, media = cdrom \
Isso anexa o Windows win10.iso como CD ou DVD. O driver usado é o driver ide-cd.
Importante: arquivo = /… insira o caminho para sua imagem ISO do Windows.
Nota: esta opção é necessária apenas durante a instalação. Em seguida, copie a linha para o final do arquivo e comente com #.

-drive file = / home / user / Downloads / virtio-win-0.1.140.iso, index = 2, media = cdrom \
Isso anexa a imagem ISO do virtio como um CD. Observe o índice diferente.
Importante: arquivo = /… insira o caminho para a imagem ISO do virtio. Se você baixou para o local padrão, deve estar no diretório de Downloads.
Nota 1: Existem muitas maneiras de anexar imagens ISO ou unidades e chamar drivers. Meu sistema não queria usar um segundo dispositivo scsi-cd, então esta opção fez o trabalho. A menos que isso não funcione para você, não mude.
Nota 2: esta opção é necessária apenas durante a instalação. Em seguida, copie a linha para o final do arquivo e comente com #.

-netdev type = tap, id = net0, ifname = vmtap0, vhost = on \
-device virtio-net-pci, netdev = net0, mac = 00: 16: 3e: 00: 01: 01
Define a interface de rede e o driver de rede . É melhor definir um endereço MAC, aqui 00: 16: 3e: 00: 01: 01 . O MAC é especificado em Hex e você pode alterar o last : 01: 01 ao seu gosto. Certifique-se de que não haja dois endereços MAC iguais!
vhost = on é opcional – algumas pessoas relataram problemas com esta opção. É para melhorar o desempenho da rede.
Para mais informações: https://wiki.archlinux.org/index.php/QEMU#Network e https://wiki.archlinux.org/index.php/QEMU#Networking .

Importante : a documentação sobre o QEMU instalado pode ser encontrada aqui: file: ///usr/share/doc/qemu-system-common/qemu-doc.html .

Para alterações de sintaxe em versões mais recentes, consulte https://wiki.qemu.org/Features/RemovedFeatures .

Linux Mint 19.2 e Ubuntu 18.04 vêm com QEMU 2.11, Ubuntu 18.10 com 2.12. Ubuntu 19.04 usa QEMU 3.1. A última versão estável do QEMU é 4.1.0. Para documentação adicional sobre QEMU, consulte https://www.qemu.org/documentation/ . Alguns exemplos de configuração podem ser encontrados no seguinte diretório:
/usr/share/doc/qemu-system-common/config

Parte 11 – Instale o Windows

Inicie a VM executando o script como root:
sudo ./windows10vm.sh
(certifique-se de especificar o caminho correto.)

Você deve obter uma tela inicial do Tiano Core com o resultado do teste de memória.

Você pode pousar em um shell EFI. Digite exit e você deverá obter um menu. Entre no menu “Boot Manager”, selecione seu disco de boot e pressione Enter . (Ver abaixo.)

Menu do gerenciador de inicialização UEFI (OVMF)

Agora o Windows ISO inicializa e pede que você:
Pressione qualquer tecla para iniciar o CD / DVD…

Pressione uma tecla!

O Windows solicitará que você:
Selecione o driver a ser instalado

Clique em “Browse”, a seguir selecione sua imagem ISO VFIO e vá para “ viostor “, abra e selecione sua versão do Windows (w10 para Windows 1o), então selecione a versão “AMD64” para sistemas de 64 bits, clique em OK.

Nota: Em vez do driver viostor, você também pode instalar o vioscsi driver . Consulte a documentação do qemu para obter a sintaxe apropriada no comando qemu – certifique-se de alterar o script de inicialização antes de escolher este driver. O driver vioscsi oferece suporte a trim para unidades SSD.

O Windows solicitará a chave de licença e você precisará especificar como instalar – escolha “Personalizar”. Em seguida, selecione sua unidade (deve haver apenas disk0) e instale.

O Windows pode reiniciar várias vezes. Quando terminar de reinicializar, abra o Gerenciador de dispositivos e selecione a interface de rede. Clique com o botão direito e selecione atualizar. Em seguida, navegue até o disco VFIO e instale o NetKVM .

O Windows deve procurar um driver de vídeo sozinho. Caso contrário, instale-o manualmente.

Nota: No meu caso, o Windows não detectou corretamente minhas unidades como unidades SSD. O Windows 10 não apenas executará tarefas desnecessárias de otimização de disco, mas essas “otimizações” podem realmente levar à redução da vida útil do SSD e de problemas de desempenho. Para fazer o Windows 10 determinar o tipo de unidade de disco correto, faça o seguinte:

1. No Windows 10, clique com o botão direito no menu Iniciar.
2. Selecione “Prompt de comando (admin)”.
3. No prompt de comando, execute:
winsat formal
4. Ele será executado por alguns instantes e depois imprimirá o Índice de Experiência do Windows (WEI).
5. Por favor, compartilhe seu WEI em um comentário abaixo!

Para verificar se o Windows identificou corretamente seu SSD:
1. Abra o Explorer
2. Clique em “Este PC” na guia esquerda.
3. Clique com o botão direito na sua unidade (por exemplo, C 🙂 e selecione “Propriedades”.
4. Selecione a guia “Ferramentas”.
5. Clique em “Otimizar”.
Você deve ver algo semelhante a isto:

Otimização SSD — Use Optimize Drives para otimizar para SSD

No meu caso, tenho a unidade C: (minha partição do sistema Windows 10) e uma partição de “Recuperação” localizada em um SSD, as outras duas partições (“fotos” e “raw_photos”) estão usando discos rígidos regulares (HDD). Observe a “Otimização não disponível” 😀.

Desligue a hibernação e suspenda! Ter qualquer um deles habilitado pode fazer com que a VM do Windows trave ou até mesmo afetar o host. Para desligar a hibernação e suspender, siga as instruções para hibernação e suspensão .

Desligue a inicialização rápida! Quando você desliga a VM do Windows, a inicialização rápida deixa o sistema de arquivos em um estado que não pode ser montado pelo Linux. Se algo der errado, você está ferrado. NUNCA deixe que tecnologia proprietária tenha controle sobre seus dados. Siga estas instruções para desligar a inicialização rápida.

Agora você deve ter uma VM do Windows funcionando com passagem VGA.

Parte 12 – Solução de problemas

Abaixo estão alguns problemas comuns ao tentar instalar / executar o Windows em um ambiente de passagem VGA.

Kernel 5.1 a 5.3 com problemas com VFIO resolvidos com a atualização de kernel mais recente

Foi relatado que os branches 5.1, 5.2 e 5.3 do Kernel introduziram problemas com a passagem de VFIO e travamentos totais. Mas se você seguir o bom e velho sistema Linux Mint 19.2 e os kernels fornecidos no repositório LTS, você não precisa se preocupar.

Importante: O problema foi resolvido com os kernels 5.3 mais recentes! Atualmente estou executando o kernel 5.3.0-40 sem problemas em meu sistema.

Exceção de thread do sistema não tratada

Quando você recebe uma tela azul do Windows com o erro:

Exceção de thread do sistema não tratada

digite o seguinte comando de terminal:

echo "options kvm ignore_msrs=1" >> /etc/modprobe.d/kvm.conf

Veja também a Parte 4 acima.

Sem saída de vídeo após passagem de GPU (tela preta)

Várias pessoas relatam que não podem obter saída de vídeo em sua GPU de passagem. Este é um problema bastante comum.

Ao inicializar o PC, o host UEFI inicializa a GPU e faz uma “cópia de sombra” modificada do vBIOS da GPU. Posteriormente, quando você inicia a VM, o Linux expõe esse BIOS shadow inválido para o carregador UEFI convidados. O mesmo acontece quando você tenta passar sua GPU primária (e única) para o convidado. Um sinal revelador é o seguinte erro ao executar o script de inicialização da VM:

qemu-system-x86_64: -device vfio-pci, host = 02: 00.0, multifunction = on: Falha ao mmap 0000: 02: 00.0 BAR 3. O desempenho pode ser lento

Se você usar 2 placas gráficas (uma para o host e outra para a VM), antes de tentar qualquer uma das seguintes etapas, verifique o seguinte:

Seu BIOS pode permitir que você selecione o slot PCIE onde sua placa gráfica (host) está localizada. Inicialize no BIOS e verifique se a placa gráfica do host está selecionada.
Em qualquer outro caso, você normalmente desejaria colocar sua GPU host no slot 1 e sua GPU de passagem em outro slot (por exemplo, slot 2 PCIE). Se esse não for o caso, você precisará seguir as etapas abaixo para fornecer um vBIOS adequado para a GPU de passagem.

Existem várias soluções possíveis, todas descritas em Explicando CSM, efifb = off e Configurando a GPU de inicialização manualmente . A primeira solução a tentar é habilitar o CSM (Compatibility Support Module) no BIOS da placa-mãe. Isso pode definir outra GPU como a GPU primária, deixando a GPU de passagem intacta. Execute lspci | grep VGApara ver se as atribuições do barramento PCI não mudaram.

Se a solução CSM acima não funcionar, provavelmente a melhor solução é:

Coloque a GPU de passagem em um slot PCI secundário;
Instale temporariamente uma placa gráfica no slot PCI principal;
Crie um arquivo de despejo do BIOS fora da GPU de passagem;
Remova a GPU primária temporária, instale a GPU de passagem e inicialize a VM usando o arquivo romfile = /… / GPU_BIOS.dump que criamos.

Desligue o PC e desconecte-o da tomada . Remova a GPU de passagem de seu slot, coloque-a em outro slot e coloque outra GPU no slot de GPU principal.

Agora ligue o PC, abra uma janela de terminal e digite:
lspci -v | grep VGA

Você deve ver suas duas placas VGA, por exemplo:
01: 00.0 controlador compatível com VGA: NVIDIA Corporation GF106GL [Quadro 2000] (rev a1) (prog-if 00 [controlador VGA])
02: 00.0 controlador compatível com VGA: NVIDIA Corporation GM204 [ GeForce GTX 970 ] (rev a1) (prog-if 00 [controlador VGA])

Observe o barramento PCI da GPU que você deseja passar (no exemplo acima: 02: 00.0). Para desvincular este cartão do driver vfio-pci (caso esteja vinculado), use estes comandos:
sudo -i
echo "0000:02:00.0" > /sys/bus/pci/drivers/vfio-pci/unbind
Se você receber um erro: significa apenas que não foi vinculado ao driver vfio-pci.

Agora digite:
cd /sys/bus/pci/devices/0000:02:00.0/
(substitua 02: 00.0 pelo número do barramento PCI) seguido por:
echo 1 > rom

cat rom > /path/to/GPU_BIOS.dump

echo 0 > rom

No caso de sua placa de vídeo ter sido vinculada a vfio-pci (sem mensagem de erro ao desvincular), digite o seguinte:
echo "0000:02:00.0" > /sys/bus/pci/drivers/vfio-pci/bind
(substitua 02: 00.0 por seu barramento PCI).

Desligue o PC, desconecte-o da rede elétrica e substitua a GPU temporária pela GPU de passagem.

(Observação: em vez do procedimento acima, você pode baixar seu BIOS de vídeo em TechPowerUp e modificar o arquivo vBIOS conforme mostrado aqui .)

Depois de inicializar o host novamente, edite o script de início da VM e adicione a romfile opção ao comando qemu -device para sua GPU:
-device vfio-pci,host=02:00.0,multifunction=on,romfile=/path/to/GPU_BIOS.dump \

A atualização do BIOS da placa-mãe AMD interrompe o VFIO

Foi relatado que atualizar o BIOS da placa-mãe AMD X370 e X470 para suportar as CPUs Ryzen mais recentes quebra a passagem de VFIO. Veja Atualizando meu BIOS pronto para Nextgen Ryzen Broke my Passthrough Twice! e Atenção e usuários vfio não atualizam seu BIOS . Esse problema já foi relatado há algum tempo e o trabalho foi feito para produzir um patch para o kernel. Mas, contanto que a AMD e / ou os fornecedores de placa-mãe / BIOS não consertem seus bugs, você deve NÃO atualizar o BIOS , a menos que seja porque você atualizou para uma CPU que não é suportada pelo BIOS atual.

Certifique-se de verificar o fórum VFIO Reddit para ver o que funciona e o que não funciona.

Youtuber Spaceinvador One criou um vídeo sobre como fazer o downgrade de um BIOS atualizado: Como fazer o downgrade de um AMD Bios e Agesa . Proceda com cautela, se necessário.

Considerações sobre AMD Ryzen 3000

Depois de ver algumas histórias de sucesso e tutoriais baseados em Zen 2 / Ryzen, decidi tentar e comprei uma placa-mãe X570 e uma CPU AMD Ryzen 9 3900X. Este novo hardware precisava de um lançamento QEMU mais atualizado, então usei uma distro baseada no Ubuntu 19.04 e escrevi um novo – consulte tutorial Criando uma VM do Windows 10 no AMD Ryzen 9 3900X usando Qemu 4.0 e VGA Passthrough .

Espera-se que o Linux Mint tenha um novo lançamento em junho de 2020, que será baseado no Ubuntu 20.04 LTS. Se você comprou um sistema AMD Ryzen ou Threadripper, recomendo enfaticamente que você não use esse sistema e use o novo Linux Mint 20 quando disponível.

GPU AMD não redefine após o desligamento da VM

Muitas placas gráficas AMD modernas não são reiniciadas corretamente após o desligamento da VM. Isso requer uma reinicialização do host para executar novamente a VM do Windows.

O blogueiro do Youtube, Spaceinvader , publicou um pequeno script que reinicia a placa gráfica. Aqui está:

#! / bin / bash 
 # 
 #substitua xx \: xx.x com o número do seu gpu e contrapartida de som 
 # 
 # 
 echo "desconectando gráficos amd" 
 echo "1" | tee -a /sys/bus/pci/devices/0000\:xx\:xx.x/remove 
 echo "desconectando e som equivalente" 
 echo "1" | tee -a /sys/bus/pci/devices/0000\:xx\:xx.x/remove 
 echo "entrou no estado suspenso, pressione o botão liga / desliga para continuar" 
 echo -n mem> / sys / power / state 
 echo "reconectando amd gpu e equivalente de som" 
 echo "1" | tee -a / sys / bus / pci / rescan 
 echo "Placa de vídeo AMD redefinida com sucesso"

Veja seu vídeo para mais explicações.

Um programador apelidado de @gnif escreveu um patch para o kernel do Linux que redefine a placa de vídeo AMD. Veja a postagem na Level1Techs , assim como o vídeo .

Outra solução (uma das primeiras soluções alternativas) é a correção de reinicialização de passagem de GPU, que usa um utilitário de linha de comando do Windows chamado devcon64.exe que essencialmente ativa ou desativa o hardware. Dois arquivos em lote do Windows são criados, um que é executado na inicialização do Windows e o outro quando o Windows é encerrado. Na inicialização da VM, o vídeo e o áudio da placa gráfica são ativados; no desligamento, eles são desativados.

Para obter mais informações sobre as placas de vídeo AMD e como fazê-las funcionar, veja mais adiante.

Áudio – Som crepitante

Se você ouvir estalos em sua VM, habilite o MSI em sua VM do Windows 10. Consulte Ativar interrupções sinalizadas por mensagem MSI em sua VM .

Se a etapa acima não resolver o problema do som crepitante, dê uma olhada na Mathias Hueber configuração de áudio da máquina virtual de – ou como fazer o áudio de pulso funcionar .

O usuário do Reddit spheenik escreveu um patch para se livrar dos estalos de áudio . Este patch é incorporado ao QEMU 4.0 e posterior – consulte Melhorias de áudio do Qemu 4.0 abaixo. (Observação: meu tutorial mais recente já incorpora o patch de áudio.)

Se as etapas acima não resolverem o problema e você estiver executando uma versão QEMU anterior à 4.0, você pode querer ler Como: Patch Qemu e corrigir áudio VM .

O desenvolvedor Geoff, também conhecido como gniff, escreveu um patch para trazer nativo suporte de áudio JACK ao QEMU, que supostamente resolve todos os problemas de áudio.

VM não inicia – driver gráfico

Um problema comum é a ligação de um driver à placa de vídeo pela qual queremos passar. Enquanto eu estava escrevendo este manual e fazia alterações em meu sistema (que funcionava anteriormente), de repente não consegui mais iniciar a VM. A primeira coisa a verificar se você não obtém uma tela preta do Tianocore é se a placa de vídeo pela qual você tenta passar está vinculada ao driver vfio-pci:
dmesg | grep -i vfio
A saída deve ser semelhante a esta:
[2.735931] VFIO – User Versão do meta-driver de nível: 0.3
[2.757208] vfio_pci: add [10de: 13c2 [ffff: ffff]] classe 0x000000 / 00000000
[2.773223] vfio_pci: add [10de: 0fbb [ffff: ffff]] classe 0x000000 / 00000000
[8.437128] vfio-pci 0000: 02: 00.0: habilitando dispositivo (0000 -> 0003)

O exemplo acima mostra que a placa de vídeo está vinculada ao driver vfio-pci (veja a última linha), que é o que queremos. Se o comando não produz nenhuma saída, ou uma saída muito diferente da anterior, algo está errado. Para verificar mais, digite:
lspci -k | grep -i -A 3 vga
Aqui está o que eu obtive quando minha VM não queria mais iniciar:
01: 00.0 Controlador compatível com VGA: NVIDIA Corporation GF106GL [Quadro 2000] (rev a1)
Subsistema: NVIDIA Corporation GF106GL [Quadro 2000]
Kernel driver em uso: nvidia
módulos Kernel: nvidiafb, nouveau, nvidia_361
–
02: 00.0 Controlador compatível com VGA: NVIDIA Corporation GM204 [GeForce GTX 970] (rev a1)
Subsistema: Gigabyte Technology Co., Ltd GM204 [GeForce GTX 970]
Driver de kernel em use: nvidia
módulos do kernel da : nvidiafb, nouveau, nvidia_361

A placa gráfica 01: 00.0 (Quadro 2000) usa o driver Nvidia – exatamente o que eu quero.

A placa de vídeo 02: 00.0 (GTX 970) também usa o driver Nvidia – NÃO era isso que eu esperava. Esta placa deve ser vinculada ao driver vfio-pci. Então, o que fazemos?

No Linux Mint, clique no botão de menu, clique em “Centro de Controle” e depois em “Gerenciador de Driver” na seção Administração. Coloque sua senha. Você verá então os drivers associados às placas gráficas. Mude o driver da placa gráfica para que ela use o driver de código aberto (neste exemplo “Nouveau”) e pressione “Aplicar alterações”. Após a alteração, deve ser semelhante à foto abaixo:

Gerente de Motorista — Gerenciador de driver no Linux Mint

Se acima não ajudar, ou se você não conseguir se livrar do driver nouveau, veja se o nvidia-fallback.service está rodando. Se sim, ele carregará o driver nouveau de código aberto sempre que não puder encontrar o driver proprietário da Nvidia. Você precisa desativá-lo executando o seguinte comando como sudo:

systemctl disable nvidia-fallback.service

BSOD ao instalar drivers AMD Crimson no Windows

Vários usuários na lista de discussão Redhat VFIO relataram problemas com a instalação de drivers AMD Crimson no Windows. Isso parece afetar várias placas de vídeo AMD, bem como várias versões de driver AMD Crimson diferentes. Uma solução alternativa é descrita aqui: https://www.redhat.com/archives/vfio-users/2016-April/msg00153.html

Nesta solução alternativa, a seguinte linha é adicionada ao script de inicialização, logo acima da definição do dispositivo gráfico:
-device ioh3420,bus=pci,addr=1c.0,multifunction=on,port=1,chassis=1,id=root.1

Se a configuração acima apresentar um erro “Bus ‘pci’ não encontrado”, altere a linha da seguinte forma:
-device ioh3420,bus=pci.0,addr=1c.0,multifunction=on,port=1,chassis=1,id=root.1

Em seguida, você altera as opções de passagem da placa gráfica da seguinte maneira:
-device vfio-pci,host=02:00.0,bus=root.1,addr=00.0,multifunction=on \
-device vfio-pci,host=02:00.1,bus=root.1,addr=00.1 \

Placas gráficas idênticas para anfitrião e convidado

Se você usar duas placas gráficas idênticas para o host Linux e o convidado do Windows, siga estas instruções:

Modifique o arquivo /etc/modprobe.d/local.conf da seguinte maneira:

install vfio-pci /sbin/vfio-pci-override-vga.sh

Crie um arquivo /sbin/vfio-pci-override-vga.sh com o seguinte conteúdo:

#!/bin/sh

DEVS="0000:02:00.0 0000:02:00.1"

for DEV in $DEVS; do
echo "vfio-pci" > /sys/bus/pci/devices/$DEV/driver_override
done

modprobe -i vfio-pci

Torne o arquivo vfio-pci-override-vga.sh executável:

chmod u+x /sbin/vfio-pci-override-vga.sh

ISO do Windows não inicializa – 1

Se você não conseguir iniciar o ISO do Windows, pode ser necessário executar uma versão mais recente do Qemu para obter recursos ou soluções alternativas que resolvam os problemas. Se você precisar de uma versão mais atualizada do Qemu (versão 2.12 a partir desta atualização), adicione o seguinte PPA (aviso: este não é um repositório oficial – use por sua própria conta e risco ). No prompt do terminal, digite:
sudo add-apt-repository ppa:jacob/virtualisation

A última versão estável do QEMU em abril de 2019 é o QEMU 4.0.0. Veja também acima em “ Áudio – Som crepitante “.

ISO do Windows não inicializa – 2

Às vezes, os arquivos OVMF BIOS do repositório oficial do Ubuntu não funcionam com o seu hardware e a VM não inicializa. Nesse caso, você pode baixar arquivos OVMF alternativos aqui: http://www.ubuntuupdates.org/package/core/wily/multiverse/base/ovmf , ou obter a versão mais atualizada aqui:
https: //www.kraxel .org / repos / jenkins / edk2 /
Baixe o mais recente arquivo edk2.git-ovmf-x64 , a partir desta atualização é “edk2.git-ovmf-x64-0-20180807.221.g1aa9314e3a.noarch.rpm” para uma instalação de 64 bits . Abra o arquivo .rpm baixado com privilégios de root e descompacte em / .
Copie os seguintes arquivos:
sudo cp /usr/share/edk2.git/ovmf-x64/OVMF-pure-efi.fd /usr/share/ovmf/OVMF.fd

sudo cp /usr/share/edk2.git/ovmf-x64/OVMF_CODE-pure-efi.fd /usr/share/OVMF/OVMF_CODE.fd

sudo cp /usr/share/edk2.git/ovmf-x64/OVMF_VARS-pure-efi.fd /usr/share/OVMF/OVMF_VARS.fd

Verifique se o link /usr/share/ovmf/OVMF.fd existe, se não, crie-o:
sudo ln -s '/usr/share/ovmf/OVMF.fd' '/usr/share/qemu/OVMF.fd'

ISO do Windows não inicializa – 3

Às vezes, a imagem ISO do Windows está corrompida ou simplesmente é uma versão antiga que não funciona com passagem. Vá para https://www.microsoft.com/en-us/software-download/windows10ISO e baixe a ISO necessária (consulte a licença do software). Em seguida, tente novamente.

Bugs de BIOS da placa-mãe

Alguns BIOS de placas-mãe têm bugs e impedem a passagem. Use “dmesg” e procure por entradas como estas:
[0.297481] [Firmware Bug]: AMD-Vi: IOAPIC [7] não está na tabela IVRS
[0.297485] [Firmware Bug]: AMD-Vi: IOAPIC [8] não está no IVRS tabela
[0.297487] [Bug de firmware]: AMD-Vi: Nenhum IOAPIC do southbridge encontrado na tabela IVRS
[0.297490] AMD-Vi: Desativar o remapeamento de interrupção devido a bug (s) de BIOS
Se você encontrar entradas que apontam para um BIOS defeituoso ou problemas com interromper o remapeamento, vá para Solução fácil para fazer o IOMMU funcionar em mobos com BIOS quebrados . (Todos os créditos vão para leonmaxx no fórum do Ubuntu!)

Intel IGD e bug de arbitragem

Para usuários de CPUs Intel com IGD (dispositivo gráfico Intel): O driver Intel i915 tem um bug, que exigiu um patch de kernel denominado patch de árbitro i915 vga. De acordo com o desenvolvedor Alex Williamson, esse patch é necessário sempre que você hospeda gráficos da Intel e usa a opção x-vga = on. Este tutorial, no entanto, NÃO usa a opção x-vga; o tutorial é baseado na inicialização UEFI e não usa VGA. Isso significa que você NÃO precisa do patch de árbitro i915 vga! Consulte http://vfio.blogspot.com/2014/08/primary-graphics-assignment-without-vga.html .

Em alguns casos, você pode precisar interromper o carregamento do driver i915 adicionando nomodeset à seguinte linha em / etc / default / grub como mostrado:
GRUB_CMDLINE_LINUX_DEFAULT = ”quiet nomodeset intel_iommu = on”

Então corra:
sudo update-grub

O nomodeset impede que o kernel carregue drivers de vídeo e diz a ele para usar os modos BIOS, até que o X seja carregado.

O grupo IOMMU contém dispositivos adicionais

Ao verificar os grupos IOMMU, a parte de vídeo e áudio da sua placa gráfica deve ser as únicas 2 entradas no respectivo grupo IOMMU (algumas placas gráficas têm mais, consulte “AMD Vega” abaixo). O mesmo vale para qualquer outro dispositivo PCI pelo qual você queira passar, já que você deve passar por todos os dispositivos dentro de um grupo IOMMU, ou nada. Se – além do (s) dispositivo (s) PCI que você deseja passar para o convidado – houver outros dispositivos no mesmo grupo IOMMU, consulte E se houver outros dispositivos em meu grupo IOMMU para uma solução.

Placas Gráficas AMD Vega / RX 5700 XT / Navi

Numerosos usuários de placas de vídeo AMD relataram problemas que impediram a passagem de VFIO ou reclamaram de outros bugs (mais infame o “bug de redefinição” – veja acima para soluções alternativas). O usuário / desenvolvedor do github “gnif” escreveu um patch (uma peculiaridade do kernel, para ser mais preciso) que fornece uma solução alternativa. Porém, ele precisa ser compilado no kernel.

Nota: Não posso recomendar a compra de nenhum produto baseado em AMD Navi – o patch do kernel é uma solução alternativa, não uma correção de bug. É trabalho do fabricante (ou seja, AMD) corrigir seus bugs, especialmente porque este já existe há muito tempo.

Além ou em vez do patch do kernel mencionado acima, existem mais algumas sugestões dos usuários (siga os links para ver as postagens originais):

1. Quando passado como GPU primária, passe pelo VBIOS. Consulte AMD RX 5700XT – Revisando a passagem para máquinas virtuais KVM .

2. Use a opção q35 (veja o link acima).

3. Algumas placas de vídeo AMD Vega têm, na verdade, 3 dispositivos. Verifique com:

lspci -t -v

Além do dispositivo gráfico e do dispositivo de áudio, você encontrará uma ponte PCI. Para passar com sucesso por um cartão Vega, você precisa replicar a topologia no comando QEMU:

-device ioh3420,id=root_port1,chassis=1,slot=2,bus=pcie.0 \
-device x3130-upstream,id=upstream_port1,bus=root_port1 \
-device xio3130-downstream,id=downstream_port1,chassis=11,slot=21,bus=upstream_port1 \
-device vfio-pci,host=05:00.0,bus=downstream_port1,multifunction=on \
-device vfio-pci,host=05:00.1,bus=downstream_port1

Altere os PCI-IDs acima para refletir seu sistema. Consulte o fórum Reddit VFIO .

Usuários AMD Vega, consulte Slot primário VEGA passthrough agora funciona, VEGA reset problem corrigido para obter detalhes sobre como fazê-lo funcionar.

Não possuo nenhuma placa de vídeo AMD baseada em Navi e não posso testar as soluções sugeridas acima.

Laptops com gráficos duplos (por exemplo, tecnologia Optimus)

Misairu_G (nome de utilizador no fórum) publicou um Guia de passagem VGA para portáteis Optimus . Você pode consultar esse guia se usar um laptop com placa de vídeo Nvidia.

O usuário bash64 no do fórum Linux Mint relatou sucesso com apenas pequenas modificações neste tutorial. Os principais desvios foram:

A opção nomodeset no arquivo / etc / default / grub (consulte “Intel IGD e bug de arbitragem” acima)
Seabios em vez de UEFI / ovmf
Pequenas modificações no arquivo de script qemu

Problemas com CPUs Skylake

Outro problema surgiu com as CPUs Intel Skylake. Este problema provavelmente já está resolvido. Atualize para um kernel recente (por exemplo, 4.18 ou mais recente), conforme descrito acima.

Caso a atualização do kernel não resolva o problema, consulte ver https://lkml.org/lkml/2016/3/31/1112 para um patch disponível. Outra solução possível pode ser encontrada aqui: https://teksyndicate.com/2015/09/13/wendells-skylake-pc-build-i7-6700k/ .

Problemas com CPUs AMD Threadripper

Por algum tempo, a família AMD Threadripper de CPUs sofreu com um bug que impedia a passagem de GPU adequada. O problema é descrito neste tópico do Reddit . Os fabricantes de placas-mãe lançaram recentemente atualizações do BIOS que resolvem o problema. Instale a atualização mais recente do BIOS da placa-mãe.

Esteja ciente de que, com algumas outras combinações de CPU e placa-mãe da AMD, uma atualização do BIOS pode, na verdade, impedir o passagem funcionamento da .

AMD Ryzen congelar

Além de agrupamentos IOMMU deficientes que podem ser resolvidos com a atualização do BIOS, as CPUs AMD Ryzen também congelam ocasionalmente. Este vídeo mostra como consertar isso com uma opção de inicialização simples do grub:
rcu_nocbs=0-7

onde 0-7 é o número total de threads que sua CPU Ryzen possui. Consulte também O que o argumento do kernel rcu_nocbs do Linux faz (e meus problemas com o Ryzen novamente) e Corrigir travamentos do Ryzen relacionados ao baixo uso do sistema para obter mais informações.

Nota: Estou executando o QEMU 4.0 em uma CPU AMD Ryzen 9 3900X e placa X570 sem nenhum problema. Veja meu tutorial para detalhes.

AMD Ryzen Hyperthreading (SMT) não compatível

As versões do Qemu anteriores ao Qemu 3.0 não reconhecem o hyperthreading nas CPUs AMD Ryzen , o que leva à degradação do desempenho. Para corrigir isso, você pode querer atualizar para o Qemu 3.0 ou posterior. As instruções em Como faço para instalar o QEMU 3.0 no ubuntu 18.04? também deve funcionar no Linux Mint 19.

qemu: erro de hardware: vfio: mapeamento DMA falhou, não foi possível continuar

Ao executar o script de inicialização para a VM, a VM trava com o erro acima. Talvez seja necessário desconectar e reconectar os cabos USB do mouse e do teclado para recuperar o controle do PC. Isso acontece quando o limite de memória bloqueado do usuário é muito pequeno.

Abra um terminal e digite o seguinte:
ulimit -a | grep locked

Se você obter
memória máxima bloqueada (kbytes, -l) 16384,
seu limite de memória bloqueada é muito baixo. Consulte Executar a VM do Windows no modo de usuário (não root) abaixo para saber como aumentar a memória bloqueada.

Nenhuma solução encontrada

Se você não encontrou uma solução para seu problema, verifique as referências . Você também pode deixar um comentário e eu ou outra pessoa tentaremos ajudar.

Parte 13 – Execute o Windows VM no modo de usuário (não root)

Para executar sua VM do Windows no modo de usuário tornou-se fácil.

Adicione seu usuário ao grupo kvm:
sudo usermod -a -G kvm myusername
Nota: Sempre substitua “ meunomedeusuario ” pelo seu nome de usuário.
Reinicialize (ou saia e faça login) para ver seu usuário no grupo kvm.
Se você usar páginas enormes, certifique-se de que estejam configuradas corretamente. Abra seu / etc / fstab arquivo e compare sua hugetlbfs configuração com o seguinte:
hugetlbfs /dev/hugepages hugetlbfs mode=1770,gid=129 0 0
Observe que o gid = 129 pode ser diferente para o seu sistema. O resto deve ser idêntico!
Agora digite o seguinte comando:
getent group kvm
Isso deve retornar algo como:
kvm: x: 129: myusername
O número de ID do grupo (gid) corresponde. Caso contrário, edite o arquivo fstab para que a gid = entrada corresponda ao número gid que você obteve usando getent .
Edite o arquivo /etc/security/limits.conf e adicione as seguintes linhas:
@kvm soft memlock unlimited
@kvm hard memlock unlimited
Edite o arquivo /etc/security/limits.d/hugepages.conf e adicione as seguintes linhas (se não houver):
@hugepages hard memlock unlimited @hugepages soft memlock unlimited
Edite o script de início da VM do Windows e adicione a seguinte linha abaixo da entrada “ cp /usr/share/OVMF/OVMF_VARS.fd /tmp/my_vars.fd “:
chown myusername:kvm /tmp/my_vars.fd
Em seguida, adicione a seguinte entrada logo abaixo da entrada qemu-system-x86_64 \ , em uma linha separada:
-runas myusername \
Salve o arquivo e inicie sua VM do Windows. Você ainda precisará do sudo para executar o script, já que ele executa algumas tarefas privilegiadas, mas o convidado será executado no modo de usuário com seus privilégios de usuário.
Após inicializar no Windows, mude para o host Linux e execute em um terminal:
top
Sua saída deve ser semelhante a esta: parte superior mostra a VM do Windows 10 em execução com privilégios de usuário

Observe a entrada win10vm associada ao meu nome de usuário “heiko” em vez de “root”.

Por favor, relate se você encontrar problemas (use a seção de comentários abaixo).

Para outras referências, consulte o seguinte tutorial: https://www.evonide.com/non-root-gpu-passthrough-setup/ .

Parte 14 – Passando mais dispositivos PCI para convidados

Se você deseja passar dispositivos PCI adicionais para o convidado do Windows, certifique-se de passar por todos os dispositivos PCI que residem no mesmo grupo IOMMU. Além disso, NÃO PASSE dispositivos root para seu convidado. Para verificar quais dispositivos PCI residem no mesmo grupo, use o seguinte comando:
find /sys/kernel/iommu_groups/ -type l
A saída em meu sistema é:
/sys/kernel/iommu_groups/0/devices/0000:00:00.0
/ sys / kernel / iommu_groups / 1 / devices / 0000: 00: 01.0
/sys/kernel/iommu_groups/2/devices/0000:00:02.0
/sys/kernel/iommu_groups/3/devices/0000:00:03.0
/ sys / kernel / iommu_groups / 4 / devices / 0000: 00: 05.0
/sys/kernel/iommu_groups/4/devices/0000:00:05.2
/sys/kernel/iommu_groups/4/devices/0000:00:05.4
/ sys / kernel / iommu_groups / 5 / devices / 0000: 00: 11.0
/sys/kernel/iommu_groups/6/devices/0000:00:16.0
/sys/kernel/iommu_groups/7/devices/0000:00:19.0
/ sys / kernel / iommu_groups / 8 / devices / 0000: 00: 1a. 0
/sys/kernel/iommu_groups/9/devices/0000:00:1c.0
/sys/kernel/iommu_groups/10/devices/0000:00:1c.1
/ sys / kernel / iommu_groups / 11 / devices / 0000: 00: 1c.2
/sys/kernel/iommu_groups/12/devices/0000:00:1c.3
/sys/kernel/iommu_groups/13/devices/0000:00:1c.4
/ sys / kernel / iommu_groups / 14 / devices / 0000: 00: 1c.7
/sys/kernel/iommu_groups/15/devices/0000:00:1d.0
/ sys / kernel / iommu_g roups / 16 / devices / 0000: 00: 1e.0
/sys/kernel/iommu_groups/17/devices/0000:00:1f.0
/sys/kernel/iommu_groups/17/devices/0000:00:1f.2
/ sys / kernel / iommu_groups / 17 / devices / 0000: 00: 1f.3
/sys/kernel/iommu_groups/18/devices/0000:01:00.0
/sys/kernel/iommu_groups/18/devices/0000:01:00.1
/ sys / kernel / iommu_groups / 19 / devices / 0000: 02: 00.0
/sys/kernel/iommu_groups/19/devices/0000:02:00.1
/sys/kernel/iommu_groups/20/devices/0000:05:00.0
/ sys / kernel / iommu_groups / 20 / devices / 0000: 06: 04.0
…

Como você pode ver na lista acima, alguns grupos IOMMU contêm vários dispositivos no barramento PCI. Eu queria ver quais dispositivos estão no grupo IOMMU 17 e usaram a ID do barramento PCI:
lspci -nn | grep 00:1f.
Aqui está o que eu obtive:
00: 1f.0 Ponte ISA [0601]: Controlador LPC do chipset Intel Corporation série C600 / X79 [8086: 1d41] ( rev 05)
00: 1f.2 Controlador SATA [0106]: Intel Corporation C600 / X79 chipset 6 portas SATA AHCI Controller [8086: 1d02] (rev 05)
00: 1f.3 SMBus [0c05]: Intel Corporation C600 / Controlador de host SMBus do chipset série X79 [8086: 1d22] (rev 05)

Todos os dispositivos listados são usados pelo meu host Linux:
– A ponte ISA é um dispositivo padrão usado pelo host. Você não deve passar para um convidado!
– Todas as minhas unidades são controladas pelo host, portanto, passar por um controlador SATA seria uma péssima ideia!
– NÃO passe por um controlador de host, como o controlador de host SMBus do chipset série C600 / X79!

Para passar por dispositivos PCI individuais, edite o script de inicialização da VM e insira o seguinte código abaixo da linha vmname =…:
configfile=/etc/vfio-pci.cfg

vfiobind() {
dev="$1"
vendor=$(cat /sys/bus/pci/devices/$dev/vendor)
device=$(cat /sys/bus/pci/devices/$dev/device)
if [ -e /sys/bus/pci/devices/$dev/driver ]; then
echo $dev > /sys/bus/pci/devices/$dev/driver/unbind
fi
echo $vendor $device > /sys/bus/pci/drivers/vfio-pci/new_id

}

Abaixo da linha que contém “outro”, insira:

cat $configfile | while read line;do
echo $line | grep ^# >/dev/null 2>&1 && continue
vfiobind $line
done

Você precisa criar um arquivo vfio-pci.cfg em / etc contendo os números do barramento PCI da seguinte maneira:
0000:00:1a.0
0000:08:00.0
Certifique-se de que o arquivo NÃO contenha linhas em branco. Substitua os IDs de PCI pelos que você encontrou!

Parte 15 – Referências

Para documentação sobre QEMU, consulte o seguinte diretório em sua máquina Linux: /usr/share/doc/qemu-system-common. Para obter uma documentação parcial sobre o QEMU e seus vários lançamentos, consulte https://qemu.weilnetz.de/doc/ . (Observação: estou procurando uma documentação completa e abrangente sobre QEMU e kvm por cerca de 9 anos e nunca encontrei uma.)

DIRETRIZES PCI EXPRESS – uma breve explicação da configuração do dispositivo PCI no QEMU – alguma sintaxe (ioh3420 agora é porta pcie-root) mudou nesse meio tempo

Enlightenments do Hyper-V – uma breve explicação dos esclarecimentos do Hyper-V que são suportados

Máquinas virtuais com passagem PCI no Ubuntu 20.04, guia direto para jogos em uma máquina virtual – um dos tutoriais mais completos e atualizados da web

https://github.com/bryansteiner/gpu-passthrough-tutorial/ – um tutorial específico do AMD Ryzen 3900X baseado em Pop! _OS 20.04 usando ganchos libvirt

Criando uma VM Windows 10 no AMD Ryzen 9 3900X usando Qemu 4.0 e VGA Passthrough – minha própria versão de um guia de passagem VFIO com dicas sobre áudio etc.

VFIO em 2019 – Pop! _OS How-To (guia geral) [DRAFT] – Guia de passagem Wendells VFIO

https://passthroughpo.st/ – uma “publicação de notícias online com foco em virtualização e jogos Linux, bem como desenvolvimentos em tecnologia de código aberto”

https://www.reddit.com/r/VFIO/ – o Reddit r / VFIO subreddit para discutir todas as coisas relacionadas a VFIO e jogos em máquinas virtuais em geral

https://github.com/joeknock90/Single-GPU-Passthrough – como o nome diz, explica a passagem de GPU quando você tem apenas uma GPU (para host e VM)

Passe uma GPU Nvidia como principal – excelente vídeo do Youtube de “Spaceinvader One” sobre a preparação de uma GPU para passagem primária

Técnicas avançadas de passagem de GPU no Unraid – outro ótimo vídeo sobre passagem de GPU por “Spaceinvader One” – vale a pena assistir

https://www.mankier.com/1/qemu – página de manual QEMU atualizada (observe que este tutorial é baseado no Qemu 2.11 e muito mudou desde então)

https://davidyat.es/2016/09/08/gpu-passthrough/ – um tutorial bem escrito que oferece script qemu e virt-manager como opções

https://blog.zerosector.io/2018/07/28/kvm-qemu-windows-10-gpu-passthrough/ – um tutorial direto para Ubuntu 18.04 usando virt-manager

https://clayfreeman.github.io/gpu-passthrough/ – um tutorial baseado em libvirt para uma máquina Intel

https://ycnrg.org/vga-passthrough-with-ovmf-vfio/ – um tutorial do Ubuntu 16.04 usando virt-manager

https://qemu.weilnetz.de/doc/qemu-doc.html – manual do usuário QEMU

http://ubuntuforums.org/showthread.php?t=2266916 – Ubuntu tutorial

https://wiki.archlinux.org/index.php/QEMU – Documentação do Arch Linux no QEMU – de longe o melhor

https://wiki.archlinux.org/index.php/PCI_passthrough_via_OVMF – Tutorial PCI passthrough via OVMF para Arch Linux – fornece informações excelentes

https://aur.archlinux.org/cgit/aur.git/tree/?h=linux-vfio – uma fonte para os patches de árbitro ACS e i915

http://vfio.blogspot.com/2014/08/vfiovga-faq.html – um dos desenvolvedores, Alex fornece informações e conselhos valiosos

http://vfio.blogspot.com/2014/08/primary-graphics-assignment-without-vga.html

http://www.linux-kvm.org/page/Tuning_KVM – Redhat é o principal desenvolvedor do kvm, seu site tem muitas informações, mas geralmente está um pouco desatualizado

https://wiki.archlinux.org/index.php/KVM – página Arch Linux KVM

https://www.suse.com/documentation/sles11/book_kvm/data/part_2_book_book_kvm.html – Documentação do Suse Linux no KVM – boa referência

https://www.evonide.com/non-root-gpu-passthrough-setup/ – não tentei, mas parece um bom tutorial

https://forum.level1techs.com/t/gta-v-on-linux-skylake-build-hardware-vm-passthrough/87440 – tutorial com vídeo do Youtube para acompanhar, muito útil e atualizado, incluindo como aplicar o patch de substituição ACS

https://gitlab.com/YuriAlek/vfio – passagem de GPU única com QEMU e VFIO

https://null-src.com/posts/qemu-optimization/post.php – métodos para otimizar e ajustar o qemu (tentei apenas alguns)

https://libvirt.org/format.html e https://libvirt.org/formatdomain.html – se você quiser brincar com o virt-manager, você precisará mexer no libvirt.

Abaixo está o script de inicialização da VM que uso, apenas para referência.
Nota: o script é específico para meu hardware. Não use sem modificá-lo!

#!/bin/bash

configfile=/etc/vfio-pci.cfg
vmname="win10vm"

}

if ps -ef | grep qemu-system-x86_64 | grep -q multifunction=on; then
zenity --info --window-icon=info --timeout=15 --text="A VM is already running." &
exit 1

else

#modprobe vfio-pci

cat $configfile | while read line;do
echo $line | grep ^# >/dev/null 2>&1 && continue
vfiobind $line
done

# use pulseaudio
#export QEMU_AUDIO_DRV=pa
#export QEMU_PA_SAMPLES=8192
#export QEMU_AUDIO_TIMER_PERIOD=100
#export QEMU_PA_SERVER=/run/user/1000/pulse/native
#export QEMU_PA_SINK=alsa_output.pci-0000_06_04.0.analog-stereo
#export QEMU_PA_SOURCE=input

#use ALSA
export QEMU_AUDIO_DRV=alsa
export QEMU_ALSA_ADC_BUFFER_SIZE=1024 QEMU_ALSA_ADC_PERIOD_SIZE=256
export QEMU_ALSA_DAC_BUFFER_SIZE=1024 QEMU_ALSA_DAC_PERIOD_SIZE=256
export QEMU_AUDIO_DAC_FIXED_SETTINGS=1
export QEMU_AUDIO_DAC_FIXED_FREQ=44100 QEMU_AUDIO_DAC_FIXED_FMT=S16 QEMU_AUDIO_ADC_FIXED_FREQ=44100 QEMU_AUDIO_ADC_FIXED_FMT=S16
export QEMU_AUDIO_DAC_TRY_POLL=1 QEMU_AUDIO_ADC_TRY_POLL=1
export QEMU_AUDIO_TIMER_PERIOD=50

cp /usr/share/OVMF/OVMF_VARS.fd /tmp/my_vars.fd
chown heiko:kvm /tmp/my_vars.fd

#taskset -c 0-9

qemu-system-x86_64 \
-enable-kvm \
-runas heiko \
-monitor stdio \
-serial none \
-parallel none \
-nodefaults \
-nodefconfig \
-name $vmname,process=$vmname \
-machine q35,accel=kvm,kernel_irqchip=on \
-cpu host,kvm=off,hv_vendor_id=1234567890ab,hv_vapic,hv_time,hv_relaxed,hv_spinlocks=0x1fff,l3-cache=on,-hypervisor,migratable=no,+invtsc \
-smp 12,sockets=1,cores=6,threads=2 \
-m 16G \
-balloon none \
-mem-path /dev/hugepages \
-mem-prealloc \
-rtc base=localtime,clock=host \
-soundhw hda \
-vga none \
-nographic \
-device ioh3420,id=root_port1,chassis=0,slot=0,bus=pcie.0 \
-device vfio-pci,host=02:00.0,id=hostdev1,bus=root_port1,addr=0x00,multifunction=on \
-device vfio-pci,host=02:00.1,id=hostdev2,bus=root_port1,addr=0x00.1 \
-device vfio-pci,host=00:1a.0 \
-device vfio-pci,host=08:00.0 \
-drive if=pflash,format=raw,readonly,file=/usr/share/OVMF/OVMF_CODE.fd \
-drive if=pflash,format=raw,file=/tmp/my_vars.fd \
-boot order=c \
-object iothread,id=io1 \
-device virtio-blk-pci,drive=disk0,iothread=io1 \
-drive if=none,id=disk0,cache=none,format=raw,aio=threads,cache.direct=on,discard=unmap,detect-zeroes=unmap,file=/dev/mapper/lm13-win10 \
-device virtio-blk-pci,drive=disk1,iothread=io1 \
-drive if=none,id=disk1,cache=none,format=raw,aio=native,file=/dev/mapper/photos-photo_stripe \
-device virtio-blk-pci,drive=disk2,iothread=io1 \
-drive if=none,id=disk2,cache=none,format=raw,aio=native,file=/dev/mapper/media-photo_raw \
-netdev type=tap,id=net0,ifname=vmtap0,vhost=on \
-device virtio-net-pci,netdev=net0,mac=00:16:3e:00:01:01

#EOF

# -drive file=/media/heiko/tmp_stripe/OS-backup/ISOs/win10.iso,id=isocd,format=raw,if=none -device scsi-cd,drive=isocd \
# -drive file=/media/heiko/tmp_stripe/OS-backup/ISOs/virtio.iso,id=virtiocd,format=raw,if=none -device ide-cd,bus=ide.1,drive=virtiocd \

exit 0
fi

O comando
taskset -c 0-9 qemu-system-x86_64...

fixa as vCPUs do convidado aos threads de processador 0-9 (tenho uma CPU de 6 núcleos com 2 threads por núcleo = 12 threads). Aqui, atribuo 10 de 12 threads ao convidado. Enquanto o convidado estiver em execução, o host terá que fazer o vencimento com apenas 1 núcleo (2 threads). A pinagem da CPU pode melhorar o desempenho do convidado, embora eu não a use no meu PC.

Nota: Atualmente estou passando por todos os núcleos e threads, sem pinagem de CPU. Isso parece me dar os melhores resultados nos benchmarks, bem como desempenho na vida real.

Parte 16 – Postagens Relacionadas

Aqui está uma lista de postagens relacionadas:

Desenvolvimentos em virtualização

Máquinas Virtuais no Userbenchmark

Ajustando o desempenho do disco VM

Driver gráfico na lista negra

GPU Passthrough com CPU Intel i3-6100 Low-End

Máquina de jogo virtual Linux

Benchmark de baixo gráfico 2D com Windows 10 (1803) KVM VM

Parte 17 – Benchmarks

Eu tenho uma postagem separada mostrando benchmarks Passmark do meu sistema .

Aqui estão os do resultados UserBenchmark para minha configuração :

Referência do usuário: Jogo 60%, Mesa 71%, Trabalho 64%
CPU: Intel Core i7-3930K – 79,7%
GPU: Nvidia GTX 970 – 60,4%
SSD: Red Hat VirtIO 140 GB – 74,6%
HDD: Red Hat VirtIO 2TB – 64,6%
HDD : Red Hat VirtIO 2TB – 66,1%
RAM: QEMU 20GB – 98,2%
MBD: QEMU PC padrão (Q35 + ICH9, 2009)

Parte 18 – Ajuste de desempenho

Eu continuo atualizando este capítulo, então espero que mais dicas sejam adicionadas aqui no futuro.

Habilitar Hyper-V Enlightenments

Por mais engraçado que pareça, esta é outra maneira de melhorar o desempenho do Windows no kvm. Os esclarecimentos do Hyper-V são fáceis de implementar: no script que inicia a VM, altere a seguinte linha:
-cpu host,kvm=off \

para:
-cpu host,kvm=off,hv_vendor_id=1234567890ab,hv_vapic,hv_time,hv_relaxed,hv_spinlocks=0x1fff,l3-cache=on,-hypervisor,migratable=no,+invtsc \

Você deve obter a seguinte saída:
hv_vapic
hv_time
hv_relaxed
hv_spinlocks = 0x1fff

Para obter mais informações sobre os esclarecimentos do Hyper-V, consulte aqui .

Configurar páginas enormes

Esta etapa não é necessária para executar a VM do Windows, mas ajuda a melhorar o desempenho. Primeiro, precisamos decidir quanta memória queremos dar ao Windows. Aqui estão minhas sugestões:

Não menos do que 4 GB. Use 8 GB ou mais para uma VM de jogos do Windows.
Se você tem 16 GB no total e não está executando várias VMs, dê ao Windows 8 GB-12 GB, dependendo do que você planeja fazer com o Windows.

Para este tutorial, eu uso 8 GB. Hugepages são habilitados por padrão nas versões mais recentes do Linux Mint (desde 18) e Ubuntu (desde 16.04). Para obter mais informações ou se você estiver executando uma versão mais antiga, consulte KVM – Usando o Hugepages .

Vamos ver o que temos:
hugeadm --explain

Memória total do sistema: 24108 MB

Opções de ponto de montagem
/ dev / largepages rw, relatime, pagesize = 2M

Enormes pools de páginas:
Tamanho mínimo atual máximo Padrão
2097152 0 0 0 *
1073741824 0 0 0
…

Como você pode ver, as páginas grandes são montadas em / dev / páginas grandes e o tamanho da página grande padrão é 2097152 bytes / (1024 * 1024) = 2 MB.

Outra forma de obter informações sobre páginas enormes:
grep "Huge" /proc/meminfo

AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB

Aqui está um pouco de matemática:
Queremos reservar 8 GB para Windows:
8 GB = 8×1024 MB = 8192 MB

Nosso tamanho de página enorme é de 2 MB, então precisamos reservar:
8192 MB / 2 MB = 4096 páginas grandes

Configuramos o enorme pool de páginas durante a inicialização. Abra o arquivo / etc / default / grub como root:
xed admin:///etc/default/grub

Procure a linha GRUB_CMDLINE_LINUX_DEFAULT = ”…” que editamos antes e adicione:
hugepages=4096

Isto é o que eu tenho:
GRUB_CMDLINE_LINUX_DEFAULT = ”modprobe.blacklist = nouveau quiet intel_iommu = on largepages = 4096 ″

Salvar e fechar. Então corra:
sudo update-grub

Agora reinicie para que a configuração de nossas enormes páginas tenha efeito.

Após a reinicialização, execute em um terminal:
hugeadm --explain

Memória total do sistema: 24108 MB

Opções de ponto de montagem
/ dev / largepages rw, relatime, pagesize = 2M

Enormes pools de páginas:
Tamanho mínimo atual máximo padrão
2097152 4096 4096 4096 *
1073741824 0 0 0

Tamanhos de página enormes com pools configurados:
2097152

O / proc / sys / vm / min_free_kbytes de 67584 é muito pequeno. Para maximizar a eficiência de evitar a fragmentação, deve haver pelo menos uma grande página livre por zona no sistema que requer no mínimo um valor min_free_kbytes de 112640

Um valor / proc / sys / kernel / shmmax de 17179869184 bytes pode ser abaixo do ideal. Para maximizar o uso da memória compartilhada, isso deve ser definido como o tamanho do maior segmento de memória compartilhada que você deseja poder usar. Como alternativa, defina-o para um tamanho que corresponda ao tamanho máximo de alocação possível de todas as páginas grandes. Isso pode ser feito automaticamente, usando a opção –set-recommended-shmmax.

O shmmax recomendado para suas páginas enormes alocadas atualmente é 8589934592 bytes.
Para tornar as configurações de shmmax persistentes, adicione a seguinte linha a /etc/sysctl.conf:
kernel.shmmax = 8589934592

Para tornar suas configurações de hugetlb_shm_group persistentes, adicione a seguinte linha a /etc/sysctl.conf:
vm.hugetlb_shm_group = 129

Nota: O espaço de troca permanente deve ser preferido quando conjuntos de páginas enormes dinâmicos são usados.

Observe o valor shmmax abaixo do ideal. Nós corrigimos isso permanentemente editando /etc/sysctl.conf:
xed admin:///etc/sysctl.conf

e adicionando as seguintes linhas:
kernel.shmmax = 8589934592 vm.hugetlb_shm_group = 129 min_free_kbytes = 112640

Nota 1: Use os valores recomendados por hugeadm – explique, mas verifique novamente kernel.shmmax! O valor recomendado geralmente é irreal. Como um valor lógico , experimente 1/2 da quantidade de RAM em múltiplos de 1024.

Em relação a vm.hugetlb_shm_group = 129 : “129” é o GID do grupo kvm. Verificar com:
getent group kvm

Execute sudo sysctl -ppara colocar as novas configurações em vigor. Em seguida, edite o arquivo / etc / fstab para configurar o ponto de montagem largepages com permissões e ID de grupo (GID):
xed admin:///etc/fstab

Adicione a seguinte linha ao final do arquivo e salve:
hugetlbfs /dev/hugepages hugetlbfs mode=1770,gid=129 0 0

onde gid = 129 é o ID do grupo do grupo kvm determinado com getent group kvm.

É melhor adicionar seu usuário ao kvm grupo , então você terá permissão para acessar as enormes páginas:
usermod -a -G kvm user
onde “usuário” é o seu nome de usuário.

Verifique os resultados com hugeadm --explain.

Agora precisamos editar o arquivo de script windows10vm.sh que contém o comando qemu e adicionar as seguintes linhas em -m 8G \ :
-mem-path /dev/hugepages \
-mem-prealloc \

Reinicialize o PC para que as alterações do fstab tenham efeito.

Ative as interrupções sinalizadas de mensagem MSI em sua VM

O desenvolvedor Alex Williamson argumenta que as interrupções sinalizadas por mensagem MSI podem fornecer uma maneira mais eficiente de lidar com as interrupções . Uma descrição detalhada sobre como ativar o MSI em uma VM do Windows pode ser encontrada aqui: Interrupções baseadas em linha vs. interrupções baseadas em sinal de mensagem . Para aqueles que acham este procedimento um pouco desafiador, existe um utilitário do Windows que o torna mais fácil: o utilitário MSI (role para baixo no final do post). Como sempre, tenha cuidado com software de terceiros não verificado – você foi avisado.

Certifique-se de fazer backup de toda a instalação do Windows ou, pelo menos, defina um ponto de restauração para o Windows.

No meu caso, melhorou a qualidade do som (sem estalos), outros relataram resultados semelhantes – veja estes comentários .

Importante: a cada atualização importante do Windows 10 (por exemplo, 1803 a 1809), os talentosos engenheiros de software da Microsoft conseguem reverter suas configurações MSI. A Nvidia também está ocupada revertendo para interrupções baseadas em linha a cada atualização de driver. Portanto, após uma atualização, você deve executar esta etapa novamente . 😡

Ajustando o desempenho do disco VM

Eu escrevi uma postagem separada sobre como ajustar o desempenho do disco VM . No kvm, o ajuste de desempenho do disco pode oferecer um aumento dramático na velocidade de leitura / gravação. Minha postagem descreve diferentes cenários e qual configuração pode funcionar melhor. Como em todas as etapas de ajuste, faça benchmarks para verificar se realmente funciona para você!

Baixo desempenho gráfico 2D

A versão 1803 do Windows adicionou proteção contra a vulnerabilidade Spectre, por meio de uma atualização do microcódigo da Intel. Esta atualização causou uma significativa queda no desempenho de gráficos 2D dentro do Windows VM.

As versões recentes do Windows 10 mais ou menos resolvem esse problema. Com o Windows 10 versão 1903, não há necessidade de desativar a proteção Spectre e Meltdown . Certifique-se de que seu host Linux esteja atualizado, pois não está claro para mim qual atualização corrigiu o problema.

SR-IOV e IOMMU Pass Through

Alguns dispositivos oferecem suporte a um recurso chamado SR-IOV ou Virtualização de entrada / saída de raiz única. Isso permite que várias máquinas virtuais acessem o hardware PCIe usando funções virtuais (vf), melhorando assim o desempenho. Consulte Compreendendo a configuração do arquivo grub do iommu Linux .

O recurso SR-IOV precisa ser habilitado no BIOS, assim como os drivers. Veja aqui um exemplo.

Em alguns casos, o desempenho pode ser melhorado adicionando a opção “passagem” iommu = pt ao arquivo / etc / default / grub:

GRUB_CMDLINE_LINUX_DEFAULT=”quiet intel_iommu=on iommu=pt”

Seguido por sudo update-grub

Fixação de CPU

Muitas CPUs modernas oferecem multitarefa de hardware, conhecida como “hyper-threading” no jargão da Intel ou “SMT” na linguagem da AMD. Essas CPUs executam dois threads em cada núcleo, alternando entre os threads de maneira eficiente. É quase como ter o dobro de núcleos, mas não é bem assim. Cada núcleo só pode processar um encadeamento por vez. O hyper-threading ainda ajuda no desempenho da CPU porque nosso PC precisa executar várias tarefas simultaneamente, e a alternância de tarefas é mais rápida com suporte de hardware.

Algumas tarefas, no entanto, podem ser afetadas negativamente por essa alternância. Um exemplo são as tarefas de entrada-saída (IO) de alta velocidade. O Linux nos permite dedicar (“fixar”) um núcleo para tais tarefas, de forma que a tarefa não precise compartilhar recursos da CPU com outras tarefas.

Para descobrir a topologia da CPU em seu PC, use o seguinte comando:

lscpu -e

A saída da minha CPU Intel i7 3930K é esta:

CPU	NÓ	SOQUETE	TESTEMUNHO	L1d: L1i: L2: L3	CONECTADOS	MAXMHZ	MINMHZ
0	0	0	0	0:0:0:0	sim	5700.0000	1200.0000
1	0	0	1	1:1:1:0	sim	5700.0000	1200.0000
2	0	0	2	2:2:2:0	sim	5700.0000	1200.0000
3	0	0	3	3:3:3:0	sim	5700.0000	1200.0000
4	0	0	4	4:4:4:0	sim	5700.0000	1200.0000
5	0	0	5	5:5:5:0	sim	5700.0000	1200.0000
6	0	0	0	0:0:0:0	sim	5700.0000	1200.0000
7	0	0	1	1:1:1:0	sim	5700.0000	1200.0000
8	0	0	2	2:2:2:0	sim	5700.0000	1200.0000
9	0	0	3	3:3:3:0	sim	5700.0000	1200.0000
10	0	0	4	4:4:4:0	sim	5700.0000	1200.0000
11	0	0	5	5:5:5:0	sim	5700.0000	1200.0000

* Nota: Minha CPU está com overclock, daí o alto valor MAXMHZ.

Observe a coluna 4 “Núcleo”: mostra qual núcleo a vCPU (coluna 1 – CPU) está realmente usando. Com este processador Intel, as vCPU 0 e 6 compartilham o núcleo 0.

Uma maneira mais direta de obter os pares de threads dos núcleos da CPU é esta:

cat /sys/devices/system/cpu/cpu*/topology/thread_siblings_list | sort | uniq
0,6
1,7
2,8
3,9
4,10
5,11

O ganho (ou perda) de desempenho da fixação da CPU depende do seu hardware e do que você está fazendo com a VM do Windows. Um bom benchmark de diferentes tarefas pode ser encontrado aqui: CPU Pinning Benchmarks .

Alguns usuários relatam que a fixação da CPU ajudou a melhorar a latência, mas às vezes à custa do desempenho. Aqui está outra postagem útil: Melhor estratégia de fixação para troca de latência / desempenho .

Uma boa explicação sobre a pinagem da CPU e outras melhorias de desempenho pode ser encontrada aqui: Ajuste de desempenho .

No meu PC, NÃO uso pinagem de CPU. É complicado, na melhor das hipóteses, e tudo o que tentei não melhorou, mas reduziu o desempenho. Importante : os efeitos da fixação da CPU são altamente individuais e dependem do que você deseja alcançar. Para uma VM de jogos, pode ajudar a melhorar o desempenho (consulte benchmarks de fixação de CPU ).

Melhorias no Kernel 4.17 e Qemu 3.0

Se você encontrar quedas de quadros, problemas de latência ou tiver problemas com sua RV, verifique suas interrupções:

watch -n1 "cat /proc/interrupts"

Se você vir altos números de RES (como na casa dos milhões), consulte o ajuste de interrupção e problema com alta contagem de interrupções de reprogramação post de . Se você segui-lo, verá que atualizar o kernel para 4.17 e usar o Qemu 3.0 pode ajudar. Como configurar o QEMU 3.0 no Ubuntu 18.04 fornece mais instruções.

Melhorias de áudio para Qemu 4.0

Um grande problema que tem atormentado os usuários de passagem é o ruído de áudio. Em alguns casos, o ajuste de desempenho ajudou a superar o problema, mas o usuário do Reddit spheenik escreveu um patch que pode tornar o áudio crepitante uma coisa do passado. Este patch de áudio foi mesclado com o Qemu a partir da versão 4.0. Veja o do tópico Reddit para mais informações sobre este patch e como configurar corretamente sua VM

A necessidade

A solução

aviso Legal

Tutorial

Parte 1 – Requisitos de Hardware

Suporte IOMMU

Dois processadores gráficos

Suporte UEFI na GPU usada com Windows

Parte 2 – Instalando Qemu / KVM

Parte 3 – Determinando os dispositivos para passar para o Windows

Sobre teclado e mouse

Parte 4 – Prepare-se para Passthrough

Parte 5 – Configurações de rede

Parte 6 – Configurando Hugepages

Parte 7 – Baixe os drivers VFIO

Parte 8 – Prepare o espaço de armazenamento do Windows VM

Parte 9 – Verifique a configuração

Parte 10 – Criar script para iniciar o Windows

Parte 11 – Instale o Windows

Parte 12 – Solução de problemas

Kernel 5.1 a 5.3 com problemas com VFIO resolvidos com a atualização de kernel mais recente

Exceção de thread do sistema não tratada

Sem saída de vídeo após passagem de GPU (tela preta)

A atualização do BIOS da placa-mãe AMD interrompe o VFIO

Considerações sobre AMD Ryzen 3000

GPU AMD não redefine após o desligamento da VM

Áudio – Som crepitante

VM não inicia – driver gráfico

BSOD ao instalar drivers AMD Crimson no Windows

Placas gráficas idênticas para anfitrião e convidado

ISO do Windows não inicializa – 1

ISO do Windows não inicializa – 2

ISO do Windows não inicializa – 3

Bugs de BIOS da placa-mãe

Intel IGD e bug de arbitragem

O grupo IOMMU contém dispositivos adicionais

Placas Gráficas AMD Vega / RX 5700 XT / Navi

Laptops com gráficos duplos (por exemplo, tecnologia Optimus)

Problemas com CPUs Skylake

Problemas com CPUs AMD Threadripper

AMD Ryzen congelar

AMD Ryzen Hyperthreading (SMT) não compatível

qemu: erro de hardware: vfio: mapeamento DMA falhou, não foi possível continuar

Nenhuma solução encontrada

Parte 13 – Execute o Windows VM no modo de usuário (não root)

Parte 14 – Passando mais dispositivos PCI para convidados

Parte 15 – Referências

Parte 16 – Postagens Relacionadas

Parte 17 – Benchmarks

Parte 18 – Ajuste de desempenho

Habilitar Hyper-V Enlightenments

Configurar páginas enormes

Ative as interrupções sinalizadas de mensagem MSI em sua VM

Ajustando o desempenho do disco VM

Baixo desempenho gráfico 2D

SR-IOV e IOMMU Pass Through

Fixação de CPU

Melhorias no Kernel 4.17 e Qemu 3.0

Melhorias de áudio para Qemu 4.0

Compartilhe isso:

Relacionado

Deixe um comentário Cancelar resposta