Iremos usar tanto o sistema UEFI para BOOT como MBR (para sistemas mais antigos).

Primeiro formate o pendrive com uma partição pequena de 40M como FAT32, para usar como EFI. A tabela de partição não precisa ser em GPT, usaremos a tabela DOS, a tabela GPT é superior a tabela DOS – principalmente pelo tamanho, na GPT pode se ter partições de 9,4ZB e na DOS é somente até 2T. Porém, com a tabela GPT o GRUB não escreve no MBR.

Instale algumas Ferramentas no seu sistema, antes de gerir o pendrive:

sudo pacman -S arch-install-scripts exfatprogs mtools dosfstools libisoburn

Detectando qual unidade é o pendrive:

sudo fdisk -l

Criando a tabela de partição no pendrive:

sudo cfdisk -z /dev/sdX # Onde X é a letra que corresponde ao seu pendrive.

Ao escolher a tabela DOS crie a primeira partição de 40M a segunda com o tamanho inteiro, e se quiser ter o Instalador do Windows no pendrive basta, criar uma terceira partição como FAT32, porém, esta partição tem que ser no tamanho exato da imagem ISO, exemplo, para uma imagem do Windows 8.1, essa partição precisará ter 4,5G.

Não crie mais que três partições, pois a partir da 4ª partição o pendrive ficará lento. Então, só crie 3 partições. A primeira use como FAT32/EFI. A segunda, será a maior partição como EXT4 e a terceira para Windows Installer como FAT32.

Supondo que o seu pendrive seja a segunda unidade de disco com a letra B, lembrando, antes detecte a unidade com sudo fdisk -l. Então, formate assim:

sudo mkfs.vfat -F32 -n EFI /dev/sdb1
sudo mkfs.ext4 /dev/sdb2
sudo mkfs.vfat -F32 -n WIN_INSTALL /dev/sdb3

Montando às unidades – substitua a letra B pela letra correspondente do seu pendrive:

sudo mount /dev/sdb2 /mnt
sudo mkdir -p /mnt/boot/EFI
sudo mkdir -p /mnt/WIN_INSTALL
sudo mkdir -p /mnt/ISOs
sudo mount /dev/sdb1 /mnt/boot/EFI
sudo mount /dev/sdb3 /mnt/WIN_INSTALL
sudo chown -R "$USER":users /mnt/

Instale o básico no pendrive, NÂO instale o kernel

sudo pacstrap -i /mnt efibootmgr exfatprogs grub pacman dosfstools libisoburn os-prober mtools fuse2 freetype2 ntfs-3g sed f2fs-tools parted fatresize tar psmisc pciutils usbutils libusb-compat memtest86

Baixe às imagems ISO que deseja que o pendrive tenha no BOOT.

Para Windows, faça o seguinte:

mkdir ~/WIN
sudo modprobe loop
sudo mount -o loop Instalador-do-Windows.iso ~/WIN

cp -rf ~/WIN/* /mnt/WIN_INSTALL/ && sync

sudo umount -R ~/WIN && rm -rf ~/WIN

Se você você for ter uma imagem de alguma distribuição Linux no pendrive, copie no pendrive na pasta ISOs.

cp -f imagem-da-distribuição-linux.iso /mnt/ISOs/

Editando o 40_custom do GRUB para ter múltiplos boots no pendrive. Use o editor de texto da sua preferência, no exemplo aqui será o vim

sudo vim /mnt/etc/grub.d/40_custom

Exemplo de 40_custom com o Instalador do Windows na partição do pendrive e ArchLinux ISO, lembrando que você poderá ter qualquer distribuição Linux no pendrive, mas para cada distribuição Linux os parâmetros da ISO são diferentes:

Antes de tudo verifique o UUID de cada partição do pendrive com o comando: sudo blkid e substitua onde está 1234-5678 pelo UUID correspondente da partição onde estão às ISOs e a partição do Windows Installer.

menuentry "ArchLinux-2020.iso" --class dvd {
      insmod part_msdos
      insmod search_fs_uuid
      set root=UUID=1234-5678
      set isofile="/ISOs/ArchLinux-2020.iso" root=UUID=1234-5678
      set dri="free"
      search --no-floppy -f --set=root $isofile
      probe -u $root --set=abc
      set pqr="/dev/disk/by-uuid/$abc"
      loopback loop $isofile
      linux (loop)/arch/boot/x86_64/vmlinuz img_dev=$pqr img_loop=$isofile driver=$dri
      initrd (loop)/arch/boot/x86_64/archiso.img
}

menuentry "Windows 10 Installer Partition" --class windows --class os {
        insmod part_msdos
        insmod chain
        insmod exfat
        insmod fat
        insmod search_fs_uuid
        set root=UUID=1234-5678
        search --no-floppy --fs-uuid --set=root 1234-5678
        chainloader /efi/boot/bootx64.efi root=UUID=1234-5678
}

Após às devidas modificações no arquivo 40_custom – lembrando que você deve alterar conforme o seu caso – entre no Pendrive e faça a atualização do GRUB:

Agora entre no mini sistema arch e vamos gerir o GRUB:

sudo arch-chroot /mnt

grub-install --target=i386-pc --recheck /dev/sdb   #Este comando é para instalar o GRUB na MBR

grub-install --verbose --recheck --force --target=x86_64-efi --efi-directory=/boot/EFI --bootloader-id=MULTIBOOT --removable

grub-mkconfig -o /boot/grub/grub.cfg

exit    #Ou control + D - para sair do chroot

sudo umount -R /mnt

Pendrive pronto, basta reiniciar o sistema e dar boot pelo pendrive. Não esqueça de ler esse artigo com cautela para fazer tudo certinho 😉

Segue alguns exemplos de 40_custom:

Exemplo 1

Exemplo 2

Exemplo 3

fdisk -l

fdisk /dev/sdX

Acesse o menu HELP:
 
 # m

# n (adicionar uma nova partição)
 
 Início da partição “1”: <ENTER>
 
 Fim da partição, default: <ENTER>
 
 # p (Listar partições)
 
 # t (a letra “L” irá lhe mostrar as opções. A opção “8e” é Linux LVM. Troque a Label para Linux LVM)
 
 # w (para gravar as alterações) 

Ou criar a partição através do Gparted

# sudo pvcreate /dev/sdXnº
 
 Explicação: pvcreate (comando) /<device_formatada>
 
 Vamos criar o VG (group volume) com o nome de “rootvg”:

# sudo vgcreate rootvg  /dev/sdXnº

• vgcreate: criação da partição/HD
• rootvg: nome do grupo, podendo qual desejar
• /dev/sdXnº: partição a ser escolhida para o LVM

sudo vgs rootvg

para ver o espaço livre do grupo “rootvg”

sudo lvcreate -n nome_lv -L30G rootvg

Explicação: lvcreate -n <nome_do_lv> -L<tamanho_do_LV> <nome_do_vg>

sudo lvdisplay 

para ver o resultado

sudo lvextend -L +3G /dev/rootvg/nome_lv –r

para aumentar o tamanho

Formatar com ext4 64bit:

sudo mke2fs -text4 -O 64bit /dev/rootvg/nome_lv

Formatar com xfs:

sudo mkfs.xfs /dev/rootvg/nome_lv

Alguns comandos para verificação dos LV, VG etc.
 
 # lvdisplay
 
 Verificação do LV:
 
 # vgdisplay
 
 Verificação GV:
 
 # vgscan
 
 Remover a LV:
 
 # lvremove /dev/rootvg/nome_lv

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
• 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
  • Part 17 – Benchmarks
  • Parte 18 – Ajuste de desempenho
    • Enable Hyper-V Enlightenments
    • Configure hugepages
    • Turn on MSI Message Signaled Interrupts in your VM
    • Tuning VM Disk Performance
    • 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

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:

1. 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).
2. 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 .
3. Salve e saia do BIOS e inicialize no Linux.
4. 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
5. 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 .)

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:

1. 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.
2. 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.
3. 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.)

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:

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:

1. 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.
2. 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 é:

1. Coloque a GPU de passagem em um slot PCI secundário;
2. Instale temporariamente uma placa gráfica no slot PCI principal;
3. Crie um arquivo de despejo do BIOS fora da GPU de passagem;
4. 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:

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:

1. A opção nomodeset no arquivo / etc / default / grub (consulte “Intel IGD e bug de arbitragem” acima)
2. Seabios em vez de UEFI / ovmf
3. 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.

1. Adicione seu usuário ao grupo kvm:
   sudo usermod -a -G kvm myusername
   Nota: Sempre substitua “ meunomedeusuario ” pelo seu nome de usuário.
2. Reinicialize (ou saia e faça login) para ver seu usuário no grupo kvm.
3. 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 .
4. Edite o arquivo /etc/security/limits.conf e adicione as seguintes linhas:
   @kvm soft memlock unlimited
@kvm hard memlock unlimited
5. 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
6. 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.
7. 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"

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

}

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 \

O texto acima é uma linha! Para verificar se ele realmente funciona, inicie sua VM do Windows e mude para o Linux. Abra uma janela de terminal e digite (em uma linha):
ps -aux | grep qemu | grep -Eo 'hv_relaxed|hv_spinlocks=0x1fff|hv_vapic|hv_time'

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:

1. Não menos do que 4 GB. Use 8 GB ou mais para uma VM de jogos do Windows.
2. 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:

* 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

• # linux
• # tutorial
• # janela
• # pci passthrough
• # máquinas virtuais

Com a inicialização dupla, o outro SO em seu sistema é totalmente reiniciado. Se você estiver no Arch Linux e quiser jogar um jogo, ou no Windows e quiser fazer alguma programação, você deve parar, fechar tudo o que estiver ocupado, reiniciar o computador, escolher a outra opção na tela do Grub e em seguida, faça login novamente. Então, na melhor das hipóteses, você tende a passar algumas semanas no Windows, algumas semanas no Linux e, na pior, se esquece completamente de um dos sistemas operacionais.

A virtualização melhorou isso, permitindo o uso de ambos os sistemas operacionais simultaneamente: eu poderia colocar a VM do Arch Linux em tela inteira em um dos meus monitores e usar programas do Windows no outro com apenas o ocasional Ctrl-Alt interrompendo o fluxo . Mas eu nunca conseguia fazer o som funcionar em minhas VMs do Arch Linux e muitas vezes tornava acidentalmente o armazenamento muito pequeno e tinha que passar pela tarefa de estender vmdks.

Esse uso virtualizado também significava que eu não poderia realmente usar o Linux para operar meu PC: a VM apenas começou para tarefas de programação. E embora eu goste de muitos jogos e programas somente para Windows, prefiro amplamente a forma altamente configurável e menos opaca do Linux de fazer tudo fora da execução desses jogos e programas. Também é incrivelmente irritante quando o Windows 10 se depara com um 😦 enfrenta o BSOD ² e decide reiniciar imediatamente, travando meu pobre e inocente Arch Linux VM junto com ele – se há algo que você pode dizer sobre a maioria das distros Linux convencionais, é que o sistema completo trava realmente não acontecem.

A passagem de GPU parecia exatamente o que eu precisava. Felizmente, eu tinha um SSD sobressalente que não estava usando por muito tempo, então fui capaz de isolar uma passagem experimental da instalação do Arch Linux para aquele SSD sem tocar na instalação do Windows no outro SSD do meu PC. Assim que tive certeza de que tudo funcionava (um processo muito mais rápido do que o previsto), substituí a instalação do Windows por uma VM do Windows e passei por completo.

Isso foi há alguns meses e até agora estou muito feliz com a configuração. Não foi totalmente simples e eu experimentei alguns momentos de desespero em que pensei que algum recurso ou comportamento minúsculo, mas importante, era impossivelmente incompatível com minha configuração, mas, no final das contas, coloquei tudo funcionando, a ponto de estar escrevendo este guia para salvar outros do mesmo desespero e buscas frenéticas.

Grande parte do guia a seguir foi parafraseado de outras fontes, para as quais foram fornecidos links. Você provavelmente precisará se referir a eles e a outras pessoas ao configurar isso, porque o que funcionou na minha máquina pode não funcionar na sua. Também recebi ajuda e sugestões de alguns amigos e colegas que também configuraram isso e tiveram experiências um pouco diferentes com ele.

As partes 1 e 2 detalham a passagem e a configuração da VM, e são muito semelhantes aos guias mais populares já existentes. A Parte 3 é um pouco mais rara: ela contém uma série de coisas pequenas e importantes que você deseja fazer após a configuração para que tudo funcione bem para que possa realmente usar sua configuração.

AVISO: passagem de GPU e VAC : jogadores competitivos jogando em servidores protegidos pelo Valve Anti-Cheat podem querer pensar duas vezes antes de configurar algo assim como sua máquina de jogo principal, já que o VAC pode detectar que está sendo executado em uma VM e banir você.

Relatórios que ouvi indicam que este é apenas um problema nos CounterStrike: Global Offensive servidores (a partir de 29-04-2017), mas pode se tornar um problema para outros jogos protegidos por VAC no futuro.

Esta é uma postagem longa e detalhada, então aqui está um índice para facilitar o acesso:

• Parte 0: O que você precisa
• Parte 1: Configurando o passthrough
• Parte 2: Configurando a VM
  • Pré-requisitos
  • Configurando páginas enormes
  • Criação da VM
    • Usando a GUI virtman
    • Usando um script bash
  • Instalando o Windows
• Parte 3: Usando a VM
  • Teclado e mouse
  • Som
    • Reparando o som instável
  • Compartilhamento de arquivos
  • De outros
• Parte 4: Pensamentos finais
• Bibliografia

Parte 0: O que você precisa

A passagem de GPU depende de algumas tecnologias de virtualização específicas, portanto, você precisará certificar-se de que seu hardware oferece suporte. Se você tiver uma placa de vídeo razoavelmente nova e seu BIOS permitir que você defina uma opção chamada algo semelhante a “VT-d” (Intel) ou “AMD Virtualization” (AMD), você deve estar pronto para ir. Caso contrário, adie para a próxima atualização.

Depois de determinar que seu hardware é capaz de facilitar a passagem da GPU, você desejará reunir algumas outras coisas que tornarão a configuração mais fácil de criar e usar.

• Você deve ter uma placa gráfica secundária. Para a maioria das pessoas, essa será a placa de vídeo integrada da CPU, mas uma segunda placa conectada a PCI também funciona bem.
• Você deve ter pelo menos dois monitores. Exceto isso, você deve ter duas entradas em seu monitor. Exceto isso, você deve sair e comprar um divisor HDMI para a entrada única do seu monitor único. Mas eu realmente recomendo dois monitores.
• Em termos de software, você precisará de uma cópia do Windows para sua máquina convidada e uma cópia do Synergy para compartilhar seu teclado e mouse (há outras opções aqui, mas Synergy é meu favorito por motivos que explicarei mais tarde).
• Não é estritamente necessário, mas se você pode dispensar um SSD para a instalação do Windows, você deve. Quanto mais hardware você passar diretamente para a VM, melhor será seu desempenho.

Mas qual hardware especificamente? Você deve conseguir fazer a configuração certa com a maioria dos sistemas razoavelmente modernos que atendem aos requisitos acima, mas no interesse da divulgação completa, aqui estão as estatísticas do meu sistema:

• Gráficos: GeForce GTX 1050 Ti Mobile, 4GB DDR5
• CPU: Intel Core i7-8750H 2,2 GHz
• Placa-mãe: Acer Nitro AN515-52
• 16 GB de RAM

Também estou incluindo algum conteúdo baseado em notas de um cara que configurou o seguinte:

• Passthrough Graphics: AMD Sapphire Radeon HD5870
• Gráficos hospedeiros: Nvidia PoV BV G92 GeForce 8800 GT
• CPU: Intel Core i7-5820K
• Placa-mãe: ASUS X99-M WS

Notavelmente, o cartão que ele usou para passagem não suporta inicialização UEFI, o que foi um obstáculo, mas não foi um obstáculo.

Parte 1: Configurando o passthrough

Antes de configurar sua VM, você vai querer preparar seu sistema para passar por sua GPU. Isso significa liberá-lo do manuseio da tela do host, portanto, neste ponto, você desejará conectar o monitor à placa secundária como preparação (mas não desconecte a placa principal ainda). Então, podemos começar a seguir este tutorial (parafraseado e, em alguns lugares, totalmente copiado abaixo).

Se você ainda não fez isso, habilite VT-d / AMD-Vi em seu BIOS . Você pode verificar se ele está habilitado com o seguinte comando para Intel:

dmesg | grep -e "Directed I/O"

com saída como

DMAR: Intel(R) Virtualization Technology for Directed I/O

ou

PCI-DMA: Intel(R) Virtualization Technology for Directed I/O

E o seguinte comando para AMD:

dmesg | grep AMD-Vi

com saída como

AMD-Vi: Enabling IOMMU at 0000:00:00.2 cap 0x40
AMD-Vi: Lazy IO/TLB flushing enabled
AMD-Vi: Initialized for Passthrough Mode

Depois de determinar que o VT-d / AMD-Vi está funcionando, você pode prosseguir para localizar a placa de vídeo pela qual deseja passar. Execute este comando com sudo:

lspci | grep VGA

Eu recebo esta saída:

00:02.0 VGA compatible controller: Intel Corporation Xeon E3-1200 v3/4th Gen Core Processor Integrated Graphics Controller (rev 06)
01:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Tahiti PRO [Radeon HD 7950/8950 OEM / R9 280]

A primeira é minha placa de vídeo integrada Intel, a placa que desejo usar para gráficos host, e a segunda é minha R9 280, a placa que desejo passar para a VM. Então, isolei o R9 280 com o seguinte comando:

lspci -nn | grep 01:00.

Isso me dá a seguinte saída:

01:00.0 VGA compatible controller [0300]: Advanced Micro Devices, Inc. [AMD/ATI] Tahiti PRO [Radeon HD 7950/8950 OEM / R9 280] [1002:679a]
01:00.1 Audio device [0403]: Advanced Micro Devices, Inc. [AMD/ATI] Tahiti XT HDMI Audio [Radeon HD 7970 Series] [1002:aaa0]

Então, encontramos a placa de vídeo. Anote os IDs entre colchetes: no meu caso 1002: 679a (gráficos) e 1002: aaa0 (som). Observe que precisaremos enviar a placa de som integrada da placa de vídeo para a passagem porque ambos os dispositivos estão no mesmo grupo IOMMU.

Grupos IOMMU : Para nossos propósitos, um grupo IOMMU é uma unidade indivisível: vários dispositivos no mesmo grupo devem ser passados ​​juntos. Freqüentemente, como no meu caso, isso não apresentará problemas, mas às vezes você pode ter mais dispositivos em um determinado grupo do que deseja passar. Soluções para lidar com isso são fornecidas aqui .

A próxima etapa é dizer ao sistema operacional para capturá-lo com os pci-stubdrivers na inicialização, para que fique livre para se conectar à VM. Isso é imperativo: você não pode passar por uma placa de vídeo que está sendo controlada por drivers gráficos para exibir gráficos no host. Existem algumas maneiras de fazer isso, mas a mais comum parece ser modificar o seu carregador de boot Grub CMDLINE. O arquivo /etc/default/grubdeve ter uma linha semelhante a esta:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

Você precisará alterá-lo para ter a seguinte aparência:

GRUB_CMDLINE_LINUX_DEFAULT="radeon.blacklist=1 quiet splash intel_iommu=on pci-stub.ids=1002:679a,1002:aaa0"

• radeon.blacklist=1diz ao sistema para não carregar os drivers Radeon – obviamente não aplicável se você estiver passando por uma placa Nvidia
• intel_iommu=ondiz ao sistema para carregar VT-d ( amd_iommu=onpara CPUs AMD)
• pci-stub.ids=1002:679a,1002:aaa0diz pci-stubpara capturar nossos dispositivos de passagem

Se você tiver uma placa Nvidia, verifique a Parte 4 desse tutorial que vinculei acima . A solução que ele oferece para placas AMD não funcionou totalmente para mim, então você pode ter que mexer um pouco. Eu não fiz isso pessoalmente com uma placa Nvidia, então não quero dar falsas soluções. Consulte a Bibliografia seção no final desta postagem para obter mais recursos.

ATUALIZAÇÃO 10/08/2017: Veja como outra pessoa conseguiu fazer com que sua placa Nvidia funcionasse em passthrough . Curiosidade: por padrão, alguns drivers da Nvidia realmente desabilitarão sua placa de vídeo se ela parecer estar rodando em uma VM.

Depois de classificado, você precisará adicionar esta linha ao final de /etc/initramfs-tools/modules:

pci-stub

O que realmente carregará o muito discutido pci-stubmódulo do kernel do driver (chocante!) Que fará o trabalho pesado de capturar a placa de vídeo para que possa ser redirecionada para a VM.

vfio vs pci-stub : Muitos dos tutoriais recomendam usar o vfiomódulo em vez de pci-stub, se o seu hardware suportar – é um módulo mais novo que faz as mesmas coisas, mas melhor, e possui algumas funcionalidades menores de economia de energia não presentes no pci-stub.

Eu, pessoalmente, não consegui fazer funcionar, então continuei pci-stub, mas sinta-se à vontade para experimentar !

Em seguida, adicione esses drivers adicionais para /etc/modules:

vfio
vfio_iommu_type1
vfio_pci
vhost-net

E atualizar initramfs:

update-initramfs -u

Quando estiver tudo pronto, reinicie seu PC e verifique se tudo foi carregado corretamente com estes comandos:

lsmod | grep vfio
dmesg | grep pci-stub
dmesg | grep VFIO

Sua saída deve ser semelhante a esta:

$ lsmod | grep vfio
vfio_pci               40960  0
vfio_virqfd            16384  1 vfio_pci
irqbypass              16384  2 kvm,vfio_pci
vfio_iommu_type1       20480  0
vfio                   28672  2 vfio_iommu_type1,vfio_pci
$ dmesg | grep pci-stub
[    0.000000] Command line: BOOT_IMAGE=/vmlinuz-4.4.0-34-generic root=UUID=792ede72-4448-43dc-886d-23c5b4338acc ro radeon.blacklist=1 quiet splash intel_iommu=on pci-stub.ids=1002:679a,1002:aaa0 vt.handoff=7
[    0.000000] Kernel command line: BOOT_IMAGE=/vmlinuz-4.4.0-34-generic root=UUID=792ede72-4448-43dc-886d-23c5b4338acc ro radeon.blacklist=1 quiet splash intel_iommu=on pci-stub.ids=1002:679a,1002:aaa0 vt.handoff=7
[    1.469074] pci-stub: add 1002:679A sub=FFFFFFFF:FFFFFFFF cls=00000000/00000000
[    1.469087] pci-stub 0000:01:00.0: claimed by stub
[    1.469092] pci-stub: add 1002:AAA0 sub=FFFFFFFF:FFFFFFFF cls=00000000/00000000
[    1.469097] pci-stub 0000:01:00.1: claimed by stub
[40622.538249] pci-stub 0000:01:00.0: claimed by stub
[40622.554222] pci-stub 0000:01:00.1: claimed by stub
[40713.693527] pci-stub 0000:01:00.0: claimed by stub
[40713.709499] pci-stub 0000:01:00.1: claimed by stub
$ dmesg | grep VFIO
[    1.870411] VFIO - User Level meta-driver version: 0.3

Parabéns, seu sistema está pronto para a passagem de gráficos!

Depois de terminar de configurar isso, sua VM pode enfrentar um BSOD com o erro KMODE_EXCEPTION_NOT_HANDLEDao tentar iniciar certos jogos. Para corrigir isso, inclua a seguinte linha em /etc/modprobe.d/kvm.conf:

options kvm ignore_msrs=1

Observe que isso pode quebrar outras coisas, então não faça isso a menos que você experimente o BSOD mencionado acima.

Parte 2: Configurando a VM

Existem duas maneiras de configurar sua VM. A maioria dos tutoriais que encontrei fazem isso por meio de linha de comando, usando um script, mas como Alex Williamson mostrou , também é possível fazer a maior parte do que é necessário usando a do QEMU / KVM virt-managerinterface . Essa é a abordagem que optei e recomendaria, ³ mas cobrirei os dois métodos.

Pré-requisitos

A primeira coisa a fazer é instalar os vários pacotes relacionados ao Qemu- e KVM necessários para criar e executar máquinas virtuais KVM. Também instalaremos hugepages, que você pode usar para reservar um pedaço da RAM do sistema para a VM.

Para começar, instale estes pacotes:

sudo apt-get update
sudo apt-get install qemu-kvm seabios qemu-utils hugepages ovmf

Em seguida, verifique se ovmfestá instalado e funcionando com estes comandos:

kvm-ok
lsmod | grep kvm

E você deve obter resultados como:

$ kvm-ok 
INFO: /dev/kvm exists
KVM acceleration can be used
$ lsmod | grep kvm
kvm_intel             172032  0
kvm                   540672  1 kvm_intel
irqbypass              16384  2 kvm,vfio_pci

Certifique-se de ter um ISO do Windows para instalar o sistema operacional de sua VM. A Microsoft fornece ISOs do Windows 10 para download nesta página .

Por último, pegue a versão mais recente ou estável dos drivers do Windows VirtIO para aproveitar a velocidade doce e agradável de rede paravirtualizada e drivers de dispositivo de disco em sua VM:

• Página wiki dos drivers do Windows VirtIO
• Download ISO dos drivers mais recentes do win-virtio
• Download de drivers ISO estáveis ​​para win-virtio

Configurando páginas enormes

Você realmente não precisa configurar hugepagespara que a passagem de GPU funcione, mas como você provavelmente usará sua VM para jogos e outras atividades com sistema intensivo, você desejará otimizar o máximo possível. Portanto, é uma boa ideia reservar um pouco de RAM para sua VM.

Você deve fazer isso com um sistema que tenha pelo menos 16 GB de RAM. Você pode conseguir passar com 8, mas se leva a sério o repasse, saia e compre mais oito.

Na minha configuração, eu dou ao meu VM 8 GB de RAM: metade dos meus 16. Você provavelmente não quer dar menos do que quatro.

hugeadm --explain

Em /etc/default/qemu-kvmconjunto:

KVM_HUGEPAGES=1

grep "Hugepagesize:" /proc/meminfo

Seu tamanho de página enorme é provavelmente o mesmo que o meu, 2048 KB (2 MB).

Agora você precisa descobrir quantas páginas enormes atribuir. Geralmente, você deseja atribuir a quantidade de RAM escolhida (geralmente 8 GB) mais um pequeno espaço de buffer (entre 2% e 10%). A menos que você esteja rolando em RAM, não atribua muito espaço de buffer ou você começará a ficar sem RAM em seu sistema principal – devido à natureza da hugepagesRAM que você reserva está sempre reservada, mesmo quando a VM não está funcionando .

Aqui está o cálculo: quantidade_de_RAM / tamanho_da_pagina + small_buffer = vm.nr_pages_huge

8192M / 2048k + 7,5% = 4300

Se você atribuir mais páginas enormes do que seu sistema pode suportar, seu sistema operacional não inicializará.

Para reservar 8 GB, adicione a seguinte linha a /etc/sysctl.conf:

vm.nr_hugepages = 4300

Obviamente, substitua 4300qualquer número que você identificou em seu sistema.

Criação da VM

Você diria que é fã de GUIs ou de scripts ? Admito que aprecio a interface gráfica ocasionalmente agradável, uma descrição que certamente se encaixa no virtman do KVM / Qemu. Mas é realmente uma questão de preferência pessoal qual opção você escolher, já que ambas terão os mesmos resultados.

Usando a GUI virtman

Eu segui este guia . Configurar uma VM do Windows com a GUI virtman é principalmente um processo simples de seguir as instruções e clicar em Avançar . Seguindo o assistente inicial, você receberá uma interface de forma livre por meio da qual poderá adicionar hardware – e, novamente, a maior parte do que você precisa fazer é bastante intuitivo e autoexplicativo.

Primeiro, lembre-se de configurar sua VM com inicialização UEFI se sua placa de vídeo exigir (a maioria das placas modernas o fará). Consulte a caixa amarela intitulada Usando SeaBIOS em vez de UEFI abaixo, se este não for o caso.

Armazenamento: para o disco rígido da VM, usei um SSD bruto de 512 GB: a mesma unidade em que tinha instalado o Windows anteriormente como sistema operacional de base. Se isso não for uma opção para você, você pode criar um arquivo de imagem através da interface do virtman, ou talvez um volume LVM se for mais sua velocidade. Apenas certifique-se de dar algumas centenas de GBs para que você tenha espaço para jogos e tudo o mais que você precisa.

Processador: conforme o guia vinculado acima detalha, você deve digitar a opção não padrão host-passthroughna Configuração> Modelo lista suspensa para obter o melhor desempenho possível.

GPU passthrough : Um dos tipos de hardware que você pode adicionar ao seu host é “PCI Host Device”. Certifique-se de adicionar tudo o que estiver passando (placa de vídeo e placa de som).

Apoio do Hugepages : Esta é a única coisa para a qual você precisa sair da interface amigável. Execute sudo virsh edit <name of VM>e adicione isso antes da <os>tag XML.

<memoryBacking
  <hugepages/>
</memoryBacking>

Você também pode configurar a pinagem da CPU para desempenho extra, mas não me incomodei. Reinicie seu PC depois de fazer esta edição e antes de tentar inicializar sua VM.

Provavelmente, você desejará manter os dispositivos padrão de vídeo, exibição e canal no VM, para que possa usar a interface SPICE do KVM (visualizador de desktop integrado do KVM) para controlar o sistema enquanto instala o Windows. Você sempre pode removê-los mais tarde.

Finalmente, adicione seu Windows ISO e VirtIO ISO como unidades de CD-ROM virtuais e, em seguida, inicialize e inicie a instalação.

Usando SeaBIOS em vez de UEFI de vídeo : A placa não oferece suporte à inicialização UEFI? Não se preocupe, você pode configurar uma VM para usá-lo. Mas em vez de adicionar seus dispositivos PCI diretamente por meio da GUI, você precisará fazer mais algumas edições de XML. Execute sudo virsh edit <name of VM>novamente e adicione o seguinte após a linha <seclabel type='dynamic' model='apparmor' relabel='yes'/>:

  <qemu:commandline>
    <qemu:arg value='-bios'/>
    <qemu:arg value='/usr/share/seabios/bios.bin'/>
    <qemu:arg value='-device'/>
    <qemu:arg value='ioh3420,bus=pcie.0,addr=1c.0,multifunction=on,port=1,chassis=1,id=root.1'/
    <qemu:arg value='-device'/>
    <qemu:arg value='vfio-pci,host=02:00.0,bus=root.1,addr=00.0,multifunction=on,x-vga=on'/>
    <qemu:arg value='-device'/>
    <qemu:arg value='vfio-pci,host=02:00.1,bus=root.1,addr=00.1'/>
  </qemu:commandline>

O bit operativo parece adicionar o ioh3420dispositivo, o que não é necessário com a configuração padrão.

Usando um script bash

Fazer isso dá a você um controle mais preciso sobre sua VM do que a GUI do virtman e talvez lhe dê pontos de frieza extras? De qualquer forma, esta é a abordagem adotada por este guia e o venerável Arch wiki .

Você precisará criar o disco da sua VM primeiro.

# 250G virtual disk (adjust according to your needs).
dd if=/dev/zero of=<storage>.img bs=1M seek=250000 count=0

O script da VM, que você executará sempre que quiser iniciar a VM, deve ter esta estrutura geral:

#!/bin/bash

## DEVICE PASSTHROUGH

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

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
   
}


if ps -A | grep -q $vmname; then
   echo "$vmname is already running." &
   exit 1

else

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

cp /usr/share/edk2.git/ovmf-x64/OVMF_VARS-pure-efi.fd /tmp/my_vars.fd

## VM INITIALISATION

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 \
  -enable-kvm \
  -m 4G \
  -mem-path /run/hugepages/kvm \
  -mem-prealloc \
  -balloon none \
  -rtc clock=host,base=localtime \
  -vga qxk \
  -serial none \
  -parallel none \
  -soundhw hda \
  -device vfio-pci,host=01:00.0,multifunction=on \
  -device vfio-pci,host=01:00.1 \
  -drive if=pflash,format=raw,readonly,file=/usr/share/edk2.git/ovmf-x64/OVMF_CODE-pure-efi.fd \
  -drive if=pflash,format=raw,file=/tmp/my_vars.fd \
  -boot order=dc \
  -device virtio-scsi-pci,id=scsi \
  -drive id=disk0,if=virtio,cache=none,format=raw,file=<storage>.img \
  -drive file=<windows>.iso,id=isocd,format=raw,if=none -device scsi-cd,drive=isocd \
  -drive file=<virtio-win>.iso,id=virtiocd,format=raw,if=none -device ide-cd,bus=ide.1,drive=virtiocd \
  -netdev type=tap,id=net0,ifname=tap0,vhost=on \
  -device virtio-net-pci,netdev=net0,mac=00:16:3e:00:01:01

   exit 0
fi

A primeira parte do script terá a mesma aparência para quase todos, mas você desejará fazer algumas alterações na inicialização da VM com base em seu hardware e configuração. Por exemplo, aqui está o que aquele cara que mencionei acima, cujo hardware não suportava inicialização UEFI, usou (observe a linha que começa com -bios):

## VM INITIALISATION

qemu-system-x86_64 \
-enable-kvm \
-M q35 \
-m 8192 \
-cpu host \
-smp 4,sockets=1,cores=4,threads=1 \
-bios /usr/share/seabios/bios.bin
-vga qxk \
-device ioh3420,bus=pcie.0,addr=1c.0,multifunction=on,port=1,chassis=1,id=root.1 \
-device vfio-pci,host=02:00.0,bus=root.1,addr=00.0,multifunction=on,x-vga=on \
-device vfio-pci,host=02:00.1,bus=root.1,addr=00.1 \
-device virtio-scsi-pci \
-drive file=<storage>.img,id=disk,format=raw,if=none -device scsi-hd,drive=disk \
-drive file=<windows>.iso,id=isocd,format=raw,if=none -device ide-cd,bus=ide.0,drive=isocd \
-drive file=<virtio-win>.iso,id=isocd1,format=raw,if=none -device ide-cd,bus=ide.1,drive=isocd1 \
-boot menu=on

A grande vantagem de fazer isso com um script é que você pode adicionar etapas extras para configurar todos os confortos discutidos na parte 3 para som, controles e assim por diante.

Instalando o Windows

Inicialize sua VM e siga o procedimento de instalação por meio da interface SPICE. Compre uma licença do Windows se ainda não tiver uma. Isso deve ser bastante simples.

Você provavelmente não verá a saída de vídeo da GPU pela qual passou durante ou imediatamente após a instalação do Windows. Não entre em pânico! Use a interface SPICE para baixar e instalar os apropriados drivers para sua placa gráfica. Após uma reinicialização, você deve começar a ver a saída de vídeo de seus dispositivos de passagem.

Groundhog Patch Tuesday : Quando eu inicialmente configurei isso em maio de 2016, usei um Windows 10 ISO em torno de seu lançamento público em julho de 2015. Devido a algum problema com uma atualização do Windows para o microcódigo de CPU Intel, esta instalação do Windows parou na compilação 10204 e entrou em um ciclo desagradável do Windows Update, no qual:

1. Baixe novas atualizações
2. Reinicie para instalar atualizações
3. Falha ao instalar atualizações
4. Reverter para um status de pré-atualização
5. GOTO 1

Um ciclo horrível, como uma versão muito chata de Memento .

Para quebrar o ciclo, era necessário fazer um boot limpo do Windows, após trocar o CPU por um Core2Duo . ^{[1] [2]} Felizmente, é uma VM, então você pode fazer esse tipo de coisa sem muita dificuldade.

O tempo continua escorregando : você pode ter problemas para sincronizar a hora com a de seu sistema host. Apesar de configurar o Windows para obter informações de horário e fuso horário da Internet, minha VM consistentemente se atrasava duas horas a cada reinicialização. Para corrigir isso, você precisará alterar uma configuração de registro .

Abra regedit, encontre HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformatione defina o seguinte:

"RealTimeIsUniversal" = DWORD:00000001

Com isso no lugar, a sincronização de tempo deve funcionar ™.

Parabéns, você acabou de configurar sua VM de passagem de gráficos do Windows! Continue na próxima seção para obter alguns conselhos sobre como realmente usar essa nova configuração maluca.

Parte 3: Usando a VM

Embora as partes um e dois tratassem principalmente de seguir os tutoriais certos (e, portanto, consistiam principalmente em meus resumos e paráfrases), esta parte conterá informações pelas quais tive que trabalhar um pouco mais. Configurar o passthrough é fácil o suficiente, mas uma vez feito isso, você precisa colocar algumas coisas no lugar para que usar seu host e VM no dia a dia seja simples e sem complicações.

Teclado e mouse

Você tem algumas opções diferentes para controlar sua VM do Windows recém-criada:

A interface QEMU / KVM SPICE : Se você seguiu a última seção, já estará familiarizado com ela. Usando o sistema SPICE da QEMU / KVM, você pode interagir com sua VM usando uma interface não muito diferente daquela presente no VirtualBox e no VMWare Player. O movimento do mouse é um pouco lento, então não é realmente algo que eu recomendaria, mas é definitivamente possível usar sua VM e até mesmo jogar com o SPICE.

Quando ativada, a interface SPICE funcionará como um display extra. Para interagir com sua VM, basta clicar dentro da janela SPICE e mover o mouse sobre a tela principal que você está usando para passar os gráficos. Para voltar ao seu host, pressione Ctrl-Altcomo faria com o VMWare Player. Não é totalmente elegante, mas parece funcionar basicamente (embora não o tenha testado completamente e não seja o que faço).

Um switch KVM físico : Se você gosta de comprar hardware físico, você pode obter um switch KVM para conectar seu teclado e mouse e alternar um switch físico para alternar entre controlar seu host e sua VM. Novamente, não é algo que eu faço, então não posso dizer muito sobre como funciona bem na prática.

Dois conjuntos de teclados e mouses : se por acaso você não tiver um switch KVM, mas tiver um teclado e mouse extras, poderá conectá-los e passar suas portas USB para a VM. Eu imagino que isso seria muito chato.

Software de compartilhamento de teclado e mouse Synergy : Isso é o que eu faço e acho que é a melhor opção. Por uma taxa única de $ 10, você pode obter acesso ao da Symless excelente teclado baseado em rede , software de compartilhamento de mouse ⁴ para Windows, Mac e Linux, para sempre.

Este foi um acéfalo para mim. Eu tenho meus dois monitores conectados a ambas as placas gráficas e o Synergy está configurado para colocar a VM do Windows acima do host Linux. Então, para trocar de dispositivo, apenas movo meu mouse para cima ou para baixo e alterno a entrada no monitor relevante. É muito mais fácil do que lidar com uma janela SPICE ou um switch físico e, usando um adaptador de rede KVM virtio para a conexão, não noto nenhum atraso. Além disso, o Synergy permite que você compartilhe o conteúdo da área de transferência entre dispositivos (embora eu imagine que isso também seja possível com o SPICE).

Configurar o Synergy é bastante simples: você o instala em seu host e em sua VM e tem o host atuando como servidor e a VM como cliente. Existem apenas dois pontos importantes e não óbvios dos quais você deve estar ciente.

Ponto 1 : por padrão, o Synergy envia aos dispositivos clientes coordenadas absolutas do mouse, o que torna impossível jogar jogos 3D em que a câmera é controlada pelo mouse. Para jogar esses jogos, você precisa fazer duas coisas:

1. Na Configurações avançadas do servidor guia do do Synergy Configurar Servidor pop-up , habilite “Usar movimentos relativos do mouse”.
2. Sempre que você quiser jogar um jogo dependente das posições relativas do mouse, pressione a Scroll Locktecla para capturar o cursor em sua VM (pressione Scroll Locknovamente para soltar o cursor quando terminar). Se o seu teclado não tiver Scroll Lock, você pode usar a Teclas atalho guia de deste mesmo diálogo para criar um novo mapeamento de teclas para travar o cursor em uma tela.

Ponto 2 : Os efeitos visuais das configurações padrão do UAC do Windows interferem no Synergy. Quando um programa tenta ser executado com privilégios elevados, mas é bloqueado pelo UAC, sua tela escurece e a conectividade de rede parece ser cortada brevemente enquanto o Windows abre uma caixa de diálogo para perguntar se a solicitação do programa deve ser concedida. Obviamente, isso é um problema quando o mouse que você usa para clicar em Sim ou Não é fornecido pela rede via Synergy.

A solução é reduzir um pouco o UAC para tornar o pop-up menos dramático. Pesquise por Controle de conta de usuário no menu Iniciar e altere isso:

Para isso:

À parte, a passagem de GPU provavelmente não é uma coisa boa para configurar em sistemas onde a segurança é uma prioridade muito alta. A maioria dos benefícios de segurança da virtualização são cancelados assim que você começa a passar o hardware físico diretamente.

Som

A maneira mais fácil de fazer o som funcionar em sua VM é simplesmente deixar uma janela SPICE aberta no host. Desative o display gráfico SPICE se desejar. Tenho feito isso porque não posso me incomodar em desenvolver mais cabelos grisalhos lutando com o PulseAudio e o ALSA.

A segunda maneira mais fácil de fazer o som funcionar é apenas usar a placa de som da placa de vídeo (se houver) para alimentar o áudio HDMI. Dessa forma, o som da sua VM será completamente separado do som do seu host (que pode ser uma vantagem ou uma desvantagem, dependendo do que você quiser). Tenho preguiça de desconectar e reconectar meus fones de ouvido o tempo todo, então não faço isso.

The hardest, but probably most elegant way, is to set up KVM to pass sound from your VM to your host, i.e. fight with PulseAudio and ALSA. I fiddled with this for a while before giving up and going with option one. If you get this working, let me know how you did it.

Reparando o som instável

Se você experimentar um som entrecortado em sua máquina virtual, tente mudar o dispositivo de som da VM do padrão ich6para ac97. O Windows não tem nenhum driver padrão para este dispositivo, então você precisará baixar e instalar os drivers AC97 do site da Realtek .

Infelizmente, esses drivers não são assinados, portanto, para que o Windows os aceite e instale, você precisa desativar a aplicação da assinatura de drivers. Para fazer isso no Windows 10:

1. Vá para Configurações -> Atualização e segurança -> Recuperação .
2. Selecione Inicialização avançada .
3. No menu de tela inteira que aparece, vá para de Solução problemas -> Opções avançadas -> Configurações de inicialização e selecione Reiniciar .
4. Após a reinicialização, escolha a opção 7, Desative a aplicação da assinatura do driver pressionando 7.

Em seguida, você poderá instalar o driver Realtek baixado do Gerenciador de Dispositivos da maneira normal.

Compartilhamento de arquivos

É uma boa ideia configurar um compartilhamento Samba entre seu host e VM para que você possa transferir arquivos. Para fazer isso, primeiro certifique-se de que sambaestá instalado e, em seguida, adicione algo como o seguinte a /etc/samba/smb.conf:

[Data]
path = /path/to/your/share
available = yes
valid users = yourusername
read only = no
browsable = yes
public = yes
writable = yes

Em seguida, forneça ao seu usuário uma senha SMB com:

sudo smbpasswd -a yourusername

E finalmente reinicie o serviço:

sudo service smbd restart

Em seguida, você pode conectar este compartilhamento como uma unidade de rede no Windows, usando yourusername:yoursmbpasswordquando solicitado para credenciais. Compartilho todo o meu HDD de armazenamento extra dessa maneira.

De outros

Se você gostaria de plug-and-play com dispositivos USB em sua VM, você pode passar um controlador USB PCI da mesma forma que fez com sua placa gráfica.

Gostaria de ter uma seção sobre ponte de rede aqui também (ou seja, colocar sua VM do Windows na mesma rede do host), mas não tive muito sucesso em fazê-la funcionar. A configuração de rede NAT padrão é suficiente para 99% dos casos, mas às vezes você precisa fazer a ponte. Infelizmente, KVM não é VirtualBox, onde você pode apenas selecionar “rede de ponte no adaptador físico X”.

Ouvi dizer que é mais fácil com uma conexão ethernet do que com wi-fi, mas infelizmente a logística do meu espaço residencial me restringe ao uso exclusivo de wi-fi para conectividade de rede. Tentei alguns tutoriais e outras coisas, mas nenhum funcionou bem. Se você tiver alguma ideia, me avise.

Parte 4: Pensamentos finais

Então, passo a passo: não é um pouco de trabalho, mas vale muito a pena o esforço. Posso dizer sem exagero que configurar isso é uma das melhores coisas que já fiz com um computador. É literalmente o melhor dos dois mundos e, depois de executar essa configuração por quatro meses, não conseguia me imaginar voltando para uma base Windows. Se você sempre quis usar uma configuração como essa, posso recomendar 100% colocar o trabalho e simplesmente fazê-lo.

Correções, advertências, sugestões e histórias de suas experiências com o passthrough podem ser enviadas por e-mail para mim em d @ vidyat.es tweetadas ou para mim @davidyat_es .

Essa solução pode ser escalonada . Se você tiver hardware suficiente, ative outras VMs e tenha uma única CPU LAN.

Bibliografia

Tentei tornar esta postagem o mais abrangente possível, mas consulte esses recursos também se você realmente decidir configurá-la. A maioria deles também foi relacionada acima.

• Como tornar o dual-boot obsoleto usando o KVM VGA passthrough – Linux Mint Forums
• Passthrough da GPU revisitado – reddit
• Passagem de PCI via OVMF – Archwiki
• Blog de dicas e truques de VFIO de Alex Williamson
• Jogos com vários sistemas operacionais sem inicialização dupla – Rafał Cieślak
• Crie uma máquina virtual de jogos usando VFIO PCI passthrough para KVM – firewing1
• Multiheaded Nvidia Gaming usando Ubuntu 14.04 + KVM – Puget Custom Computers
• Controlador USB completo de passagem – Fóruns de tecnologia Lime
• Linux e Windows rodando simultaneamente com GPU passthrough | É impostos
• https://libvirt.org/formatdomain.html
• Virtualization Tuning and Optimization Guide
• https://pve.proxmox.com/wiki/Pci_passthrough
• gpu_passthrough_with_two_nearly_identical_gpus
• X_does_not_start_after_enabling_vfio_pci
• https://vfio.blogspot.com/2014/08/vfiovga-faq.html
• https://blog.zerosector.io/2018/07/28/kvm-qemu-windows-10-gpu-passthrough/
• Virt-Manager passo a passo.
• Acpi e SMBIOS
• Smbios exato