Jump to content

# VirtualBox (Português)

From ArchWiki
Status de tradução: Esse artigo é uma tradução de VirtualBox. Data da última tradução: 2024-01-02. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- VirtualBox/Instalar Arch Linux como convidado
- Categoria: Hypervisors
- PhpVirtualBox
- RemoteBox
- Moving an existing install into (or out of) a virtual machine

VirtualBox é um hypervisor usado para executar sistemas operacionais em um ambiente especial, chamado de máquina virtual, sobre o sistema operacional existente. O VirtualBox está em constante desenvolvimento e novos recursos são implementados continuamente. Ele vem com uma interface GUI Qt, bem como ferramentas de linha de comando sem cabeçalho e SDL para gerenciar e executar máquinas virtuais.

Para integrar funções do sistema hospedeiro aos convidados, incluindo pastas compartilhadas e área de transferência, aceleração de vídeo e um modo de integração de janela contínua, guest additions são fornecidas para alguns sistemas operacionais convidados.

## Passos de instalação para hospedeiros Arch Linux

Para iniciar máquinas virtuais VirtualBox no seu Arch Linux, siga estes passos de instalação.

### Instale os pacotes principais

Instale o pacote virtualbox. Você também precisará escolher um pacote para fornecer módulos hospedeiros:

- para o kernel linux, escolha virtualbox-host-modules-arch
- para qualquer outro Kernel (incluindo linux-lts), escolha virtualbox-host-dkms

Para compilar os módulos VirtualBox fornecidos pelo virtualbox-host-dkms, também será necessário instalar o(s) pacote(s) de cabeçalhos apropriados para o(s) seu(s) kernel(s) instalado(s) (por exemplo, linux-lts-headers). Quando o VirtualBox ou o kernel for atualizado, os módulos do kernel serão automaticamente recompilados graças ao DKMS pacman hook.

### Assine os módulos

Ao usar um kernel personalizado com a opção `CONFIG_MODULE_SIG_FORCE` ativada, você deve assinar seus módulos com uma chave gerada durante a compilação do kernel.

Navegue até a pasta da árvore do seu kernel e execute o seguinte comando:

    # for module in `ls /lib/modules/$(uname -r)/kernel/misc/{vboxdrv.ko,vboxnetadp.ko,vboxnetflt.ko}` ; do ./scripts/sign-file sha1 certs/signing_key.pem certs/signing_key.x509 $module ; done

Nota O algoritmo de hash não precisa corresponder ao configurado, mas deve estar integrado ao kernel.

### Carregue os módulos do kernel VirtualBox

virtualbox-host-modules-arch e virtualbox-host-dkms usam `systemd-modules-load.service` para carregar automaticamente os módulos VirtualBox na inicialização. Para que os módulos sejam carregados após a instalação, reinicie ou carregue os módulos manualmente uma vez; a lista de módulos pode ser encontrada em `/usr/lib/modules-load.d/virtualbox-host-modules-arch.conf` ou `/usr/lib/modules-load.d/virtualbox-host-dkms.conf`.

Nota Se você não deseja que os módulos VirtualBox sejam carregados automaticamente na inicialização, você deve mascarar o padrão `/usr/lib/modules-load.d/virtualbox-host-modules-arch.conf` (ou `/usr/lib/modules-load.d/virtualbox-host-dkms.conf`) criando um arquivo vazio (ou link simbólico para `/dev/null`) com o mesmo nome em `/etc/modules-load.d/`.

Entre os kernel modules usados pelo VirtualBox, há um módulo obrigatório chamado `vboxdrv`, que deve ser carregado antes de qualquer máquina virtual poder rodar.

Para carregar o módulo manualmente, execute:

    # modprobe vboxdrv

Os seguintes módulos são necessários apenas em configurações avançadas:

- `vboxnetadp` e `vboxnetflt` são ambos necessários quando você pretende usar o recurso de rede em ponte ou somente anfitrião. Mais precisamente, `vboxnetadp` é necessário para criar a interface do host nas preferências globais do VirtualBox, e `vboxnetflt` é necessário para iniciar uma máquina virtual usando essa interface de rede.

Nota Se os módulos do kernel VirtualBox estavam carregados no kernel enquanto você atualizava os módulos, você precisa recarregá-los manualmente para usar a nova versão atualizada. Para fazer isso, execute `vboxreload` como root.

### Acessando dispositivos USB do host no convidado

Para usar as portas USB da sua máquina hospedeira em suas máquinas virtuais, adicione usuários que estarão autorizados a usar esse recurso ao grupo de usuários `vboxusers`.

### Disco de adições de convidado

Também é recomendado instalar o pacote virtualbox-guest-iso no hospedeiro que executa o VirtualBox. Este pacote atuará como uma imagem de disco que pode ser usada para instalar as adições de convidado em sistemas convidados que não sejam o Arch Linux. O arquivo .iso estará localizado em `/usr/lib/virtualbox/additions/VBoxGuestAdditions.iso`, e pode ter que ser montado manualmente dentro da máquina virtual. Uma vez montado, você pode executar o instalador das adições de convidado dentro do convidado.

### Modelos não supervisionados

Para evitar ter que instalar o sistema convidado manualmente, alguns sistemas operacionais suportam instalação não supervisionada. Isso permite que o usuário configure o sistema a ser instalado na interface do VirtualBox antes de iniciar a máquina. Ao final do processo de configuração, o sistema operacional é instalado sem necessidade de mais interação do usuário. Este recurso requer o pacote virtualbox-unattended-templatesAUR[link quebrado: package not found].

### Pacote de extensão

O Oracle Extension Pack oferece recursos adicionais e é lançado sob uma licença não livre disponível apenas para uso pessoal. Para instalá-lo, o pacote virtualbox-ext-oracleAUR está disponível, e uma versão pré-construída pode ser encontrada no repositório seblu.

Se preferir usar o método tradicional e manual: baixe a extensão manualmente e instale-a através da GUI (Arquivo > Ferramentas > Gerenciador de Pacote de Extensão) ou via `VBoxManage extpack install <.vbox-extpack>`, certifique-se de ter um toolkit como Polkit para conceder acesso privilegiado ao VirtualBox. A instalação desta extensão requer acesso root.

### Front-ends

O VirtualBox vem com três front-ends:

- Se você deseja usar o VirtualBox com a GUI regular, use `VirtualBox`.
- Se deseja iniciar e gerenciar suas máquinas virtuais a partir da linha de comando, use o comando `VBoxSDL`, que fornece apenas uma janela simples para a máquina virtual sem sobreposições.
- Se deseja usar o VirtualBox sem executar nenhuma GUI (por exemplo, em um servidor), use o comando `VBoxHeadless`. Com a extensão VRDP, você ainda pode acessar remotamente as telas de suas máquinas virtuais.

Um recurso de segurança no Wayland (ou seja, ao usar GDM) impede que o VirtualBox capture toda a entrada do teclado e do mouse. Isso é inconveniente quando você deseja passar atalhos do gerenciador de janelas para o seu sistema operacional convidado. Pode ser contornado adicionando o VirtualBox à lista de permissões:

    $ gsettings get org.gnome.mutter.wayland xwayland-grab-access-rules
    $ gsettings set org.gnome.mutter.wayland xwayland-grab-access-rules "['VirtualBox Machine']"

O primeiro comando mostrará se outros aplicativos já estão na lista de permissões. Se sim, adicione 'VirtualBox Machine' a essa lista, em vez de tê-lo como o único.

Finalmente, você também pode usar phpVirtualBox para administrar suas máquinas virtuais via interface web.

Consulte o VirtualBox manual para aprender como criar máquinas virtuais.

Atenção Se você pretende armazenar imagens de disco virtual em um sistema de arquivos Btrfs, antes de criar quaisquer imagens, você deve considerar desativar copy-on-write para o diretório de destino dessas imagens.

## Passos de instalação para convidados Arch Linux

Veja VirtualBox/Install Arch Linux as a guest.

## Gerenciamento de discos virtuais

Veja também #Importar/exportar máquinas virtuais VirtualBox de/para outros hipervisores.

### Formatos suportados pelo VirtualBox

O VirtualBox suporta os seguintes formatos de disco virtual:

- VDI: O Virtual Disk Image é o próprio contêiner aberto do VirtualBox usado por padrão ao criar uma máquina virtual com o VirtualBox.
- VMDK: O Virtual Machine Disk foi inicialmente desenvolvido pela VMware para seus produtos. A especificação era inicialmente fechada, mas desde então se tornou um formato aberto totalmente suportado pelo VirtualBox. Este formato oferece a capacidade de ser dividido em vários arquivos de 2GB. Esta característica é especialmente útil se você deseja armazenar a máquina virtual em máquinas que não suportam arquivos muito grandes. Outros formatos, excluindo o formato HDD da Parallels, não fornecem tal recurso equivalente.
- VHD: O Virtual Hard Disk é o formato usado pela Microsoft no Windows Virtual PC e Hyper-V. Se você pretende usar qualquer um desses produtos Microsoft, terá que escolher este formato.

  Dica Desde o Windows 7, este formato pode ser montado diretamente sem nenhum aplicativo adicional.

- VHDX (somente leitura): Esta é a versão estendida do formato Virtual Hard Disk desenvolvida pela Microsoft, que foi lançada em 2012-09-04 com o Hyper-V 3.0 junto com o Windows Server 2012. Esta nova versão do formato de disco oferece desempenho aprimorado (melhor alinhamento de blocos), tamanho de blocos maiores e suporte a jornal, o que traz resiliência a falhas de energia. O VirtualBox deve suportar este formato somente para leitura.
- HDD (versão 2): O formato HDD é desenvolvido pela Parallels Inc e usado em suas soluções de hipervisor como o Parallels Desktop for Mac. Versões mais recentes deste formato (ou seja, 3 e 4) não são suportadas devido à falta de documentação para este formato proprietário.
  Nota Atualmente há uma controvérsia sobre o suporte à versão 2 do formato. Enquanto o manual oficial do VirtualBox apenas relata a segunda versão do formato de arquivo HDD como suportada, os colaboradores da Wikipedia estão relatando que a primeira versão também pode funcionar. Ajuda é bem-vinda se você puder realizar alguns testes com a primeira versão do formato HDD.
- QED: O formato QEMU Enhanced Disk é um formato de arquivo antigo para QEMU, outro hipervisor gratuito e de código aberto. Este formato foi projetado em 2010 de forma a fornecer uma alternativa superior ao QCOW2 e outros. Este formato possui um caminho de E/S totalmente assíncrono, forte integridade de dados, arquivos de suporte e arquivos esparsos. O formato QED é suportado apenas por compatibilidade com máquinas virtuais criadas com versões antigas do QEMU.
- QCOW: O formato QEMU Copy On Write é o formato atual para QEMU. O formato QCOW suporta compressão transparente baseada em zlib e criptografia (esta última é falha e não é recomendada). QCOW está disponível em duas versões: QCOW e QCOW2. O QCOW2 tende a substituir o primeiro. O QCOW é atualmente totalmente suportado pelo VirtualBox. O QCOW2 vem em duas revisões: QCOW2 0.10 e QCOW2 1.1 (que é o padrão quando você cria um disco virtual com o QEMU). O VirtualBox não suporta QCOW2.
- OVF: O Open Virtualization Format é um formato aberto projetado para interoperabilidade e distribuição de máquinas virtuais entre diferentes hipervisores. O VirtualBox suporta todas as revisões deste formato via recurso de importação/exportação VBoxManage mas com limitações conhecidas.
- RAW: Este é o modo quando o disco virtual é exposto diretamente ao disco sem estar contido em um contêiner de formato de arquivo específico. O VirtualBox suporta este recurso de várias maneiras: convertendo disco RAW para um formato específico, ou clonando um disco para RAW, ou usando diretamente um arquivo VMDK que aponta para um disco físico ou um arquivo simples.

### Conversão de formato de imagem de disco

VBoxManage clonehd pode ser usado para converter entre VDI, VMDK, VHD e RAW.

    $ VBoxManage clonehd inputfile outputfile --format outputformat

Por exemplo, para converter VDI para VMDK:

    $ VBoxManage clonehd source.vdi destination.vmdk --format VMDK

#### QCOW

O VirtualBox não suporta o formato de imagem de disco QCOW2 do QEMU. Para usar uma imagem de disco QCOW2 com o VirtualBox, você precisará convertê-la, o que pode ser feito com qemu-img. qemu-img pode converter QCOW para / de VDI, VMDK, VHDX, RAW e vários outros formatos (que você pode ver executando `qemu-img --help`).

    $ qemu-img convert -O output_fmt inputfile outputfile

Por exemplo, para converter QCOW2 para VDI:

    $ qemu-img convert -O vdi source.qcow2 destination.vdi

Dica O parâmetro `-p` é usado para obter a progressão da tarefa de conversão.

Existem duas revisões do QCOW2: 0.10 e 1.1. Você pode especificar a revisão a ser usada com `-o compat=revision`.

### Montar discos virtuais

#### VDI

Montar imagens VDI só funciona com imagens de tamanho fixo (também conhecidas como imagens estáticas); imagens dinâmicas (que alocam tamanho dinamicamente) não são facilmente montáveis.

O deslocamento da partição (dentro do VDI) é necessário, então adicione o valor de `offData` a `32256` (por exemplo, 69632 + 32256 = 101888):

    $ VBoxManage internalcommands dumphdinfo storage.vdi | grep "offData"

O armazenamento agora pode ser montado com:

    # mount -t ext4 -o rw,noatime,noexec,loop,offset=101888 storage.vdi /mntpoint/

Para discos VDI com mais partições, você também pode usar `losetup`:

    # losetup -o $offData -Pf

Após isso, você deve encontrar as partições em `/dev/loop*` (por exemplo, `/dev/loop0p1`). Então você pode montá-los como de costume (por exemplo, `mount mount /dev/loop0p1 /mnt/`).

Você também pode usar script mount.vdi que você pode usar como (instale o script em si para `/usr/bin/`):

    # mount -t vdi -o fstype=ext4,rw,noatime,noexec vdi_file_location /mnt/

Alternativamente, você pode usar o módulo do kernel nbd e qemu-nbd de qemu-img[1]:

    # modprobe nbd max_part=16
    # qemu-nbd -c /dev/nbd0 storage.vdi
    # mount /dev/nbd0p1 /mnt/dir/

E então para desmontar:

    # umount /mnt/dir/
    # qemu-nbd -d /dev/nbd0

Se os nós de partição não forem propagados, tente usar `partprobe /dev/nbd0`; caso contrário, uma partição VDI pode ser mapeada diretamente para um nó por: `qemu-nbd -P 1 -c /dev/nbd0 storage.vdi`.

Outra maneira é usar vdfuseAUR[link quebrado: package not found]:

    # vdfuse -a -f storage.vdi mountpoint1

que monta o disco em `mountpoint1` com o formato de nome `PartitionN`. Cada partição pode então ser montada em loop em `mountpoint2`:

    # mount -o loop mountpoint1/PartitionN mountpoint2

#### VHD

Assim como o VDI, imagens VHD podem ser montadas com o módulo nbd do QEMU:

    # modprobe nbd
    # qemu-nbd -c /dev/nbd0 storage.vhd
    # mount /dev/nbd0p1 /mnt

Para desmontar:

    # umount /mnt
    # qemu-nbd -d /dev/nbd0

### Compactar discos virtuais

Compactar discos virtuais funciona apenas com arquivos .vdi e basicamente consiste nos seguintes passos.

Inicie sua máquina virtual e remova todo o excesso manualmente ou usando ferramentas de limpeza como bleachbit que está disponível para sistemas Windows também[link inativo 2024-07-30 ⓘ].

Limpar espaço livre com zeros pode ser feito com várias ferramentas:

- Se você estava usando o Bleachbit anteriormente, marque a caixa System > Free disk space na GUI, ou use `bleachbit -c system.free_disk_space` na CLI;
- Em sistemas baseados em UNIX, usando `dd` ou preferencialmente dcflddAUR (veja aqui para aprender as diferenças):

      # dcfldd if=/dev/zero of=/fillfile bs=4M

  Quando `fillfile` atingir o limite da partição, você receberá uma mensagem como `1280 blocks (5120Mb) written. dcfldd:: No space left on device`. Isso significa que todos os blocos de espaço do usuário e não reservados da partição serão preenchidos com zeros. Usar este comando como root é importante para garantir que todos os blocos livres tenham sido sobrescritos. De fato, por padrão, ao usar partições com sistema de arquivos ext, uma porcentagem especificada de blocos do sistema de arquivos é reservada para o superusuário (veja o argumento `-m` nas páginas man do `mkfs.ext4` ou use `tune2fs -l` para ver quanto espaço está reservado para aplicativos root).
  Quando o processo mencionado acima estiver concluído, você pode remover o arquivo `fillfile` que você criou.

- No Windows, existem duas ferramentas disponíveis:
  - `sdelete` da Sysinternals Suite, digite `sdelete -s -z c:`, onde você precisará executar o comando para cada unidade que você tem em sua máquina virtual;
  - ou, se você gosta de scripts, há uma solução PowerShell, mas que ainda precisa ser repetida para todas as unidades.

        PS> ./Write-ZeroesToFreeSpace.ps1 -Root c:\ -PercentFree 0

    Nota Este script deve ser executado em um ambiente PowerShell com privilégios de administrador. Por padrão, scripts não podem ser executados, certifique-se de que a política de execução esteja pelo menos em `RemoteSigned` e não em `Restricted`. Isso pode ser verificado com `Get-ExecutionPolicy` e a política necessária pode ser definida com `Set-ExecutionPolicy RemoteSigned`.

Uma vez que o espaço livre no disco tenha sido limpo, desligue sua máquina virtual.

Na próxima vez que você iniciar sua máquina virtual, é recomendado fazer uma verificação do sistema de arquivos.

- Em sistemas baseados em UNIX, você pode usar `fsck` manualmente;
  - Em sistemas GNU/Linux, e, portanto, no Arch Linux, você pode forçar uma verificação de disco na inicialização graças a um parâmetro de inicialização do kernel;
- Em sistemas Windows, você pode usar:
  - ou `chkdsk c: /F` onde `c:` precisa ser substituído por cada disco que você precisa verificar e corrigir erros;
  - ou `FsckDskAll` daqui que é basicamente o mesmo software que `chkdsk`, mas sem a necessidade de repetir o comando para todas as unidades;

Agora, remova os zeros do arquivo .vdi com VBoxManage modifyhd:

    $ VBoxManage modifyhd your_disk.vdi --compact

Nota Se sua máquina virtual tem snapshots, você precisa aplicar o comando acima em cada arquivo `.vdi` que você tem.

#### TRIM

O VirtualBox oferece simulação de TRIM em arquivos VDI por meio de uma opção experimental de anexo "discard". Esta opção é não documentada e pode ser acessada por linha de comando ou edição de arquivo .vbox. Quando ativada, comandos TRIM do sistema operacional convidado fazem com que a parte correspondente do arquivo VDI seja compactada.

Atenção Usar esta opção sem o Host I/O Cache é conhecido por causar travamentos.

### Aumentar discos virtuais

#### Procedimento geral

Se você está ficando sem espaço devido ao pequeno tamanho do disco rígido selecionado quando criou sua máquina virtual, a solução aconselhada pelo manual do VirtualBox é usar VBoxManage modifyhd. No entanto, este comando só funciona para discos VDI e VHD e apenas para as variantes alocadas dinamicamente. Se você quiser redimensionar um disco virtual de tamanho fixo também, continue lendo este truque que funciona tanto para uma máquina virtual Windows quanto para UNIX.

Primeiro, crie um novo disco virtual ao lado do que você deseja aumentar:

    $ VBoxManage createmedium disk -filename new.vdi --size 10000

onde o tamanho está em MiB, neste exemplo 10000MiB ≈ 10GiB, e new.vdi é o nome do novo disco rígido a ser criado.

Nota Por padrão, este comando usa a variante de formato de arquivo Standard (correspondente a alocação dinâmica) e, portanto, não usará a mesma variante de formato de arquivo que o seu disco virtual original. Se o seu old.vdi tem um tamanho fixo e você deseja manter esta variante, adicione o parâmetro `--variant Fixed`.

Em seguida, o antigo disco virtual precisa ser clonado para o novo, o que pode levar algum tempo:

    $ VBoxManage clonemedium disk old.vdi new.vdi --existing

Desconecte o antigo disco rígido e conecte o novo, substitua todos os argumentos em itálico pelos seus próprios:

    $ VBoxManage storageattach virtual_machine_name --storagectl SATA --port 0 --medium none
    $ VBoxManage storageattach virtual_machine_name --storagectl SATA --port 0 --medium new.vdi --type hdd

Para obter o nome do controlador de armazenamento e o número da porta, você pode usar o comando `VBoxManage showvminfo virtual_machine_name`. Entre a saída, você obterá um resultado como este (o que você está procurando está em itálico):

    [...]
    Storage Controller Name (0):            IDE
    Storage Controller Type (0):            PIIX4
    Storage Controller Instance Number (0): 0
    Storage Controller Max Port Count (0):  2
    Storage Controller Port Count (0):      2
    Storage Controller Bootable (0):        on
    Storage Controller Name (1):            SATA
    Storage Controller Type (1):            IntelAhci
    Storage Controller Instance Number (1): 0
    Storage Controller Max Port Count (1):  30
    Storage Controller Port Count (1):      1
    Storage Controller Bootable (1):        on
    IDE (1, 0): Empty
    SATA (0, 0): /home/wget/IT/Virtual_machines/GNU_Linux_distributions/ArchLinux_x64_EFI/Snapshots/{6bb17af7-e8a2-4bbf-baac-fbba05ebd704}.vdi (UUID: 6bb17af7-e8a2-4bbf-baac-fbba05ebd704)
    [...]

Baixe a imagem ao vivo do GParted e monte-a como um arquivo de disco de CD/DVD virtual, inicie sua máquina virtual, aumente/mova suas partições, desmonte a imagem ao vivo do GParted e reinicie.

Nota Em discos GPT, aumentar o tamanho do disco resultará no cabeçalho GPT de backup não estar no final do dispositivo. O GParted perguntará para corrigir isso, clique em Corrigir ambas as vezes. Em discos MBR, você não terá esse problema, pois esta tabela de partição não tem um trailer no final do disco.

Finalmente, desregistre o disco virtual do VirtualBox e remova o arquivo:

    $ VBoxManage closemedium disk old.vdi
    $ rm old.vdi

#### Aumentando o tamanho de discos VDI

Se o seu disco é um VDI, execute:

    $ VBoxManage modifymedium disk your_virtual_disk.vdi --resize the_new_size

Depois, retorne ao passo do GParted para aumentar o tamanho da partição no disco virtual.

### Substituir um disco virtual manualmente no arquivo .vbox

Se você acha que editar um simples arquivo XML é mais conveniente do que usar a GUI ou o `VBoxManage` e quer substituir (ou adicionar) um disco virtual à sua máquina virtual, no arquivo de configuração .vbox correspondente à sua máquina virtual, simplesmente substitua o UUID, o local do arquivo e o formato pelas suas necessidades:

    ArchLinux_vm.vbox

    <HardDisk uuid="{670157e5-8bd4-4f7b-8b96-9ee412a712b5}" location="ArchLinux_vm.vdi" format="VDI" type="Normal"/>

então, na subtag `<AttachedDevice>` de `<StorageController>`, substitua o UUID pelo novo.

    ArchLinux_vm.vbox

    <AttachedDevice type="HardDisk" port="0" device="0">
      <Image uuid="{670157e5-8bd4-4f7b-8b96-9ee412a712b5}"/>
    </AttachedDevice>

Nota Se você não sabe o UUID da unidade que deseja adicionar, você pode usar o comando `VBoxManage showhdinfo file`. Se você usou anteriormente `VBoxManage clonehd` para copiar/converter seu disco virtual, este comando deve ter exibido o UUID logo após a cópia/conversão ser concluída. Usar um UUID aleatório não funciona, pois cada UUID é armazenado dentro de cada imagem de disco.

#### Transferência entre hospedeiro Linux e outro sistema operacional

As informações sobre o caminho para os discos rígidos e os snapshots são armazenadas entre as tags `<HardDisks> .... </HardDisks>` no arquivo com extensão .vbox. Você pode editá-las manualmente ou usar este script, onde você precisará alterar apenas o caminho ou usar os padrões, assumindo que o arquivo .vbox está no mesmo diretório do disco rígido virtual e da pasta de snapshots. Ele imprimirá a nova configuração no stdout.

    #!/bin/sh
    NewPath="${PWD}/"
    Snapshots="Snapshots/"
    Filename="$1"

     awk -v SetPath="$NewPath" -v SnapPath="$Snapshots" '{if(index($0,"<HardDisk uuid=") != 0){A=$3;split(A,B,"=");
    L=B[2];
     gsub(/\"/,"",L);
      sub(/^.*\//,"",L);
      sub(/^.*\\/,"",L);
     if(index($3,"{") != 0){SnapS=SnapPath}else{SnapS=""};
      print $1" "$2" location="\"SetPath SnapS L"\" "$4" "$5}
    else print $0}' "$Filename"

Nota

- Se você preparar a máquina virtual para uso em um hospedeiro Windows, então no final do nome do caminho você deve usar a barra invertida \ em vez de /.
- O script detecta snapshots procurando por `{` no nome do arquivo.
- Para fazer funcionar em um novo hospedeiro, você precisará adicioná-la primeiro ao registro clicando em Máquina -> Adicionar... ou use os atalhos Ctrl+A e, em seguida, navegue até o arquivo .vbox que contém a configuração ou use a linha de comando `VBoxManage registervm filename.vbox`

### Clonar um disco virtual e atribuir um novo UUID a ele

UUIDs são amplamente usados pelo VirtualBox. Cada máquina virtual e cada disco virtual de uma máquina virtual devem ter um UUID diferente. Quando você inicia uma máquina virtual no VirtualBox, o VirtualBox mantém o controle de todos os UUIDs da sua instância de máquina virtual. Veja o VBoxManage list para listar os itens registrados no VirtualBox.

Se você clonou um disco virtual manualmente copiando o arquivo do disco virtual, você precisará atribuir um novo UUID ao disco virtual clonado se quiser usar o disco na mesma máquina virtual ou mesmo em outra (se aquela já foi aberta, e, portanto, registrada, no VirtualBox).

Você pode usar este comando para atribuir um novo UUID a um disco virtual:

    $ VBoxManage internalcommands sethduuid /path/to/disk.vdi

Dica Para evitar copiar o disco virtual e atribuir um novo UUID ao seu arquivo manualmente, você pode usar VBoxManage clonehd.
Nota Os comandos acima suportam todos os formatos de disco virtual suportados pelo VirtualBox.

## Dicas e truques

### Importar/exportar máquinas virtuais VirtualBox de/para outros hipervisores

Se você planeja usar sua máquina virtual em outro hipervisor ou deseja importar no VirtualBox uma máquina virtual criada com outro hipervisor, pode estar interessado em ler as etapas a seguir.

#### Remover adições

Adições de convidado estão disponíveis na maioria das soluções de hipervisor: o VirtualBox vem com as Guest Additions, a VMware com as VMware Tools, a Parallels com as Parallels Tools, etc. Esses componentes adicionais são projetados para serem instalados dentro de uma máquina virtual após o sistema operacional convidado ter sido instalado. Eles consistem em drivers de dispositivos e aplicativos de sistema que otimizam o sistema operacional convidado para melhor desempenho e usabilidade fornecendo esses recursos.

Se você instalou as adições em sua máquina virtual, desinstale-as primeiro. Seu convidado, especialmente se estiver usando um sistema operacional da família Windows, pode se comportar de maneira estranha, travar ou mesmo não inicializar se você ainda estiver usando os drivers específicos em outro hipervisor.

#### Use o formato de disco virtual correto

Esta etapa dependerá da capacidade de converter a imagem do disco virtual diretamente ou não.

##### Ferramentas automáticas

Algumas empresas fornecem ferramentas que oferecem a capacidade de criar máquinas virtuais a partir de um sistema operacional Windows ou GNU/Linux localizado em uma máquina virtual ou mesmo em uma instalação nativa. Com tal produto, você não precisa aplicar esta e as etapas seguintes e pode parar de ler aqui.

- Parallels Transporter que é pago, é um produto da Parallels Inc. Esta solução basicamente consiste em um software chamado agente que será instalado no convidado que você deseja importar/converter. Então, o Parallels Transporter, que só funciona no OS X, criará uma máquina virtual a partir desse agente, que é contatado por USB ou rede Ethernet.
- VMware vCenter Converter[link inativo 2024-07-30 ⓘ] que é gratuito mediante registro no site da VMware, funciona quase da mesma forma que o Parallels Transporter, mas o software que reunirá os dados para criar a máquina virtual só funciona em uma plataforma Windows.

##### Conversão manual

Primeiro, familiarize-se com os formatos suportados pelo VirtualBox e aqueles suportados por hipervisores de terceiros.

- Importar ou exportar uma máquina virtual de/para uma solução VMware não é problema se você usar o formato de disco VMDK ou OVF, caso contrário, converter VMDK para VDI e VDI para VMDK é possível e a ferramenta VMware vCenter Converter mencionada acima está disponível.
- Importar ou exportar de/para QEMU também não é problema: alguns formatos QEMU são suportados diretamente pelo VirtualBox e a conversão entre QCOW2 para VDI e VDI para QCOW2 ainda está disponível, se necessário.
- Importar ou exportar de/para o hipervisor Parallels é o caminho mais difícil: a Parallels só suporta seu próprio formato HDD (até mesmo o formato OVF padrão e portátil não é suportado!).

  - Para exportar sua máquina virtual para a Parallels, você precisará usar a ferramenta Parallels Transporter descrita acima.
  - Para importar sua máquina virtual para o VirtualBox, você precisará usar o VMware vCenter Converter descrito acima para converter a máquina virtual para o formato VMware primeiro. Em seguida, aplique a solução para migrar do VMware.

#### Crie o arquivo de configuração da máquina virtual para o seu hipervisor

Cada hipervisor tem seu próprio arquivo de configuração da máquina virtual: `.vbox` para o VirtualBox, `.vmx` para a VMware, um arquivo `config.pvs` localizado no pacote da máquina virtual (arquivo `.pvm`), etc. Você terá, portanto, que recriar uma nova máquina virtual no seu novo hipervisor de destino e especificar sua configuração de hardware o mais próximo possível da sua máquina virtual inicial.

Preste especial atenção à interface do firmware (BIOS ou UEFI) usada para instalar o sistema operacional convidado. Embora uma opção esteja disponível para escolher entre estas 2 interfaces no VirtualBox e nas soluções Parallels, na VMware, você terá que adicionar manualmente a seguinte linha ao seu arquivo .vmx.

    ArchLinux_vm.vmx

    firmware = "efi"

Finalmente, peça ao seu hipervisor para usar o disco virtual existente que você converteu e inicie a máquina virtual.

Dica

- No VirtualBox, se você não quiser navegar pela GUI inteira para encontrar o local certo para adicionar seu novo dispositivo de unidade virtual, você pode Substituir um disco virtual manualmente no arquivo .vbox, ou usar o `VBoxManage storageattach` descrito em #Aumentando o tamanho de discos VDI ou na página do manual do VirtualBox.
- Da mesma forma, nos produtos VMware, você pode substituir o local do disco virtual atual adaptando o local do arquivo .vmdk no seu arquivo de configuração .vmx.

### Gerenciamento de inicialização de máquinas virtuais

#### Iniciar máquinas virtuais com um serviço (autostart)

A seguir estão os detalhes de implementação de um serviço systemd que será usado para considerar uma máquina virtual como um serviço.

    /etc/systemd/system/vboxvmservice@.service

    [Unit]
    Description=VBox Virtual Machine %i Service
    Requires=systemd-modules-load.service
    After=systemd-modules-load.service

    [Service]
    User=username
    Group=vboxusers
    ExecStart=/usr/bin/VBoxManage startvm %i --type startmode
    ExecStop=/usr/bin/VBoxManage controlvm %i stopmode
    RemainAfterExit=yes

    [Install]
    WantedBy=multi-user.target

Nota

- Substitua `username` por um usuário que seja membro do grupo `vboxusers`. Certifique-se de que o usuário escolhido seja o mesmo usuário que criará/importará máquinas virtuais, caso contrário, o usuário não verá os aparelhos de máquinas virtuais.
- Substitua `startmode` por um tipo de frontend de máquina virtual, geralmente `gui`, `headless` ou `separate`
- Substitua `stopmode` pelo estado desejado de desligamento, geralmente `savestate` ou `acpipowerbutton`

Nota Se você tem várias máquinas virtuais gerenciadas pelo Systemd e elas não estão desligando corretamente, tente adicionar `KillMode=none` e `TimeoutStopSec=40` no final da seção `[Service]`.

Enable a unidade systemd `vboxvmservice@your_virtual_machine_name` para iniciar a máquina virtual na próxima inicialização. Para lançá-la diretamente, simplesmente start a unidade systemd.

O VirtualBox 4.2 introduz um novo método para sistemas semelhantes ao UNIX terem máquinas virtuais iniciadas automaticamente, além de usar um serviço systemd.

#### Iniciar máquinas virtuais com um atalho de teclado

Pode ser útil iniciar máquinas virtuais diretamente com um atalho de teclado, em vez de usar a interface do VirtualBox (GUI ou CLI). Para isso, você pode simplesmente definir ligações de teclas em `.xbindkeysrc`. Consulte Xbindkeys para mais detalhes.

Exemplo, usando a tecla `Fn` de um laptop com uma tecla de bateria não utilizada (`F3` no computador usado neste exemplo):

    "VBoxManage startvm 'Windows 7'"
    m:0x0 + c:244
    XF86Battery

Nota Se você tem um espaço no nome da sua máquina virtual, então coloque-o entre apóstrofos simples como feito no exemplo acima.

### Usar dispositivo específico na máquina virtual

#### Usando webcam / microfone USB

Nota Você precisará ter o pacote de extensão VirtualBox instalado antes de seguir as etapas abaixo. Veja #Pacote de extensão para detalhes.

1. Certifique-se de que a máquina virtual não está em execução e que sua webcam/microfone não está sendo usada. 2. Abra a janela principal do VirtualBox e vá para as configurações da máquina Arch. Vá para a seção USB. 3. Certifique-se de que "Habilitar Controlador USB" está selecionado. Também certifique-se de que "Habilitar Controlador USB 2.0 (EHCI)" está selecionado. 4. Clique no botão "Adicionar filtro a partir do dispositivo" (o cabo com o ícone '+'). 5. Selecione seu dispositivo de webcam/microfone USB na lista. 6. Agora clique em OK e inicie sua máquina virtual.

Nota Se o seu Microfone não aparecer no menu "Adicionar filtro a partir do dispositivo", tente as opções USB 3.0 e 1.1 (No Passo 3).

#### Detectando webcams e outros dispositivos USB

Nota Isso não fará muita diferença se você estiver executando um sistema operacional Linux/Unix dentro da sua máquina virtual, pois a maioria não tem recursos de detecção automática.

Se o dispositivo que você está procurando não aparecer em nenhum dos menus na seção acima e você tiver tentado todas as três opções de controlador USB, inicie sua máquina virtual três vezes separadas. Uma vez usando o controlador USB 1.1, outra usando o controlador USB 2.0, etc. Deixe a máquina virtual em execução por pelo menos 5 minutos após a inicialização. Às vezes, o Windows detectará o dispositivo automaticamente. Certifique-se de filtrar quaisquer dispositivos que não sejam um teclado ou um mouse para que eles não iniciem na inicialização. Isso garante que o Windows detectará o dispositivo na inicialização.

### Acessar um servidor convidado

Para acessar servidor Apache em uma Máquina Virtual do host apenas, execute as seguintes linhas no host:

    $ VBoxManage setextradata GuestName "VBoxInternal/Devices/pcnet/0/LUN#0/Config/Apache/HostPort" 8888
    $ VBoxManage setextradata GuestName "VBoxInternal/Devices/pcnet/0/LUN#0/Config/Apache/GuestPort" 80
    $ VBoxManage setextradata GuestName "VBoxInternal/Devices/pcnet/0/LUN#0/Config/Apache/Protocol" TCP

onde `8888` é a porta que o host deve ouvir e `80` é a porta que a máquina virtual enviará o sinal do Apache.

Para usar uma porta inferior a 1024 na máquina host, serão necessárias alterações no firewall dessa máquina host. Isso também pode ser configurado para funcionar com SSH ou outros serviços alterando "Apache" para o serviço correspondente e as portas.

Nota `pcnet` refere-se ao cartão de rede da máquina virtual. Se você usa um cartão Intel nas configurações da sua máquina virtual, altere `pcnet` para `e1000`.

Para se comunicar entre o convidado e o host do VirtualBox usando ssh, a porta do servidor deve ser encaminhada em Configurações > Rede. Ao conectar do cliente/host, conecte-se ao endereço IP da máquina cliente/host, ao contrário da conexão da outra máquina. Isso ocorre porque a conexão será feita por meio de um adaptador virtual.

### Aceleração D3D em convidados Windows

Versões recentes do Virtualbox têm suporte para acelerar OpenGL dentro dos convidados. Isso pode ser ativado com uma simples caixa de seleção nas configurações da máquina, logo abaixo de onde a RAM de vídeo é definida, e instalando as Guest Additions do Virtualbox. No entanto, a maioria dos jogos Windows usa Direct3D (parte do DirectX), não OpenGL, e, portanto, não é beneficiada por esse método. No entanto, é possível obter aceleração Direct3D acelerada em seus convidados Windows emprestando as bibliotecas d3d do Wine, que traduzem chamadas d3d para OpenGL, que é então acelerado. Essas bibliotecas agora fazem parte do software de adições de convidado do Virtualbox.

Após habilitar a aceleração OpenGL conforme descrito acima, reinicie o convidado no modo de segurança (pressione F8 antes da tela do Windows aparecer, mas depois que a tela do Virtualbox desaparecer), e instale as Guest Additions do Virtualbox, durante a instalação, habilite a caixa de seleção "Suporte Direct3D". Reinicie no modo normal e você deverá ter aceleração Direct3D.

Nota

- Este hack pode ou não funcionar para alguns jogos, dependendo das verificações de hardware que eles fazem e das partes do D3D que usam.
- Isso foi testado no Windows XP, 7 e 8.1. Se o método não funcionar na sua versão do Windows, adicione os dados aqui.

### VirtualBox em um pendrive USB

Ao usar o VirtualBox em um pendrive USB, por exemplo, para iniciar uma máquina instalada com uma imagem ISO, você terá que criar manualmente VDMKs dos drives existentes. No entanto, uma vez que os novos VDMKs são salvos e você passa para outra máquina, você pode ter problemas ao iniciar uma máquina apropriada novamente. Para se livrar deste problema, você pode usar o seguinte script para iniciar o VirtualBox. Este script limpará e desregistrará arquivos VMDK antigos e criará novos VMDKs apropriados para você:

This article or section needs language, wiki syntax or style improvements. See Help:Style for reference.

Reason: O seguinte script analisa a saída do ls, o que é muito frágil e conhecido por quebrar. (Discuss in Talk:VirtualBox (Português))

    #!/bin/sh
    # Apagar entradas antigas de VMDK
    rm ~/.VirtualBox/*.vmdk

    # Limpar registro VBox
    sed -i '/sd/d' ~/.VirtualBox/VirtualBox.xml

    # Remover discos rígidos antigos de máquinas existentes
    find ~/.VirtualBox/Machines -name \*.xml | while read -r file; do
      line=$(grep -e "type\=\"HardDisk\"" -n "$file" | cut -d ':' -f 1)
      if [ -n "$line" ]; then
        sed -i "${line}"d "$file"
        sed -i "${line}"d "$file"
        sed -i "${line}"d "$file"
      fi
      sed -i "/rg/d" "$file"
    done

    # Excluir arquivos -prev criados pelo VirtualBox
    find  ~/.VirtualBox/Machines -name \*-prev -exec rm '{}' \;

    # Recriar VMDKs
    ls -l /dev/disk/by-uuid | cut -d ' ' -f 9,11 | while read -r ln; do
      if [ -n "$ln" ]; then
        uuid=$(echo "$ln" | cut -d ' ' -f 1)
        device=$(echo "$ln" | cut -d ' ' -f 2 | cut -d '/' -f 3 | cut -b 1-3)

        # determinar se o drive está montado
        checkstr1=$(mount | grep "$uuid")
        checkstr2=$(mount | grep "$device")
        checkstr3=$(ls ~/.VirtualBox/*.vmdk | grep "$device")
        if [ -z "$checkstr1" ] && [ -z "$checkstr2" ] && [ -z "$checkstr3" ]; then
          VBoxManage internalcommands createrawvmdk -filename ~/.VirtualBox/"$device".vmdk -rawdisk /dev/"$device" -register
        fi
      fi
    done

    # Iniciar VirtualBox
    VirtualBox

Observe que seu usuário deve ser adicionado ao grupo "disk" para criar VMDKs de drives existentes.

### Executar uma instalação nativa do Arch Linux dentro do VirtualBox

Se você tem um sistema dual boot entre Arch Linux e outro sistema operacional, pode se tornar tedioso alternar entre eles se você precisar trabalhar nos dois. Você também pode experimentar problemas de desempenho ou compatibilidade ao usar uma máquina virtual, o que pode afetar sua capacidade de realizar certas tarefas.

Este guia permitirá que você reutilize, em uma máquina virtual, sua instalação nativa do Arch Linux quando estiver executando seu segundo sistema operacional. Desta forma, você mantém a capacidade de executar cada sistema operacional nativamente, mas tem a opção de executar sua instalação do Arch Linux dentro de uma máquina virtual.

#### Certifique-se de que você tem um esquema de nomeação persistente

Dependendo da configuração do seu disco rígido, os arquivos de dispositivo representando seus discos rígidos podem aparecer de forma diferente quando você executa sua instalação do GNU/Linux nativamente ou em uma máquina virtual. Este problema ocorre ao usar FakeRAID, por exemplo. O dispositivo RAID falso será mapeado em `/dev/mapper/` quando você executar sua distribuição GNU/Linux nativamente, enquanto os dispositivos ainda são acessíveis separadamente. No entanto, na sua máquina virtual, ele pode aparecer sem qualquer mapeamento em `/dev/sdaX`, por exemplo, porque os drivers que controlam o RAID falso no seu sistema operacional host (por exemplo, Windows) estão abstraindo o dispositivo RAID falso.

Para contornar esse problema, precisaremos usar um esquema de endereçamento que seja persistente em ambos os sistemas. Isso pode ser alcançado usando UUID. Certifique-se de que seu boot loader e o arquivo fstab estejam usando UUIDs, caso contrário, corrija esse problema. Leia fstab e Persistent block device naming.

Atenção

- Certifique-se de que sua partição host seja acessível apenas como somente leitura pela sua máquina virtual Arch Linux, isso evitará riscos de corrupções se você corromper essa partição host por escrever nela por falta de atenção.
- Você NUNCA deve permitir que o VirtualBox inicialize a partir da entrada do seu segundo sistema operacional, que, como lembrete, é usado como o host para esta máquina virtual! Tenha assim um cuidado especial, especialmente se a entrada padrão do seu boot loader/gerenciador de boot for seu outro sistema operacional. Dê um tempo maior ou coloque-o abaixo na ordem de preferências.

#### Certifique-se de que sua imagem mkinitcpio está correta

Certifique-se de que sua configuração mkinitcpio usa o HOOK `block`:

    /etc/mkinitcpio.conf

    ...
    HOOKS="base udev autodetect modconf block filesystems keyboard fsck"
    ...

Se ele não estiver presente, adicione-o e regenerate the initramfs.

#### Crie uma configuração de máquina virtual para inicializar a partir do drive físico

##### Crie uma imagem .vmdk de disco bruto

Agora, precisamos criar uma nova máquina virtual que usará um disco RAW como unidade virtual, para isso usaremos um arquivo VMDK de ~ 1Kio que será mapeado para um disco físico. Infelizmente, o VirtualBox não tem essa opção na GUI, então teremos que usar o console e um comando interno do `VBoxManage`.

Inicialize o host que usará a máquina virtual Arch Linux. O comando precisará ser adaptado de acordo com o host que você tem.

Em um host GNU/Linux

Há 3 maneiras de conseguir isso: fazer login como root, mudar o direito de acesso do dispositivo com `chmod`, adicionar seu usuário ao grupo `disk`. Este último é o mais elegante, vamos prosseguir dessa maneira:

    # gpasswd -a your_user disk

Aplique as novas configurações do grupo com:

    $ newgrp

Agora, você pode usar o comando:

    $ VBoxManage internalcommands createrawvmdk -filename /path/to/file.vmdk -rawdisk /dev/sdb -register

Adapte o comando acima para a sua necessidade, especialmente o caminho e o nome do arquivo do local VMDK e a localização do disco bruto a ser mapeado que contém sua instalação do Arch Linux.

Em um host Windows

Abra um prompt de comando que deve ser executado como administrador.

Dica No Windows, abra seu menu iniciar/tela inicial, digite `cmd`, e digite `Ctrl+Shift+Enter`, este é um atalho para executar o programa selecionado com direitos de administrador.

No Windows, como a convenção de nome de arquivo do disco é diferente do UNIX, use este comando para determinar quais drives você tem no seu sistema Windows e suas localizações:

    # wmic diskdrive get name,size,model

    Model                               Name                Size
    WDC WD40EZRX-00SPEB0 ATA Device     \\.\PHYSICALDRIVE1  4000783933440
    KINGSTON SVP100S296G ATA Device     \\.\PHYSICALDRIVE0  96024821760
    Hitachi HDT721010SLA360 ATA Device  \\.\PHYSICALDRIVE2  1000202273280
    Innostor Ext. HDD USB Device        \\.\PHYSICALDRIVE3  1000202273280

Neste exemplo, como a convenção do Windows é `\\.\PhysicalDriveX` onde X é um número a partir de 0, `\\.\PHYSICALDRIVE1` pode ser análogo a `/dev/sdb` da terminologia de disco do Linux.

Para usar o comando `VBoxManage` no Windows, você pode alterar o diretório atual para a pasta de instalação do VirtualBox primeiro com `cd C:\Program Files\Oracle\VirtualBox\`

    # .\VBoxManage.exe internalcommands createrawvmdk -filename C:\file.vmdk -rawdisk \\.\PHYSICALDRIVE1

ou use o caminho absoluto:

    # "C:\Program Files\Oracle\VirtualBox\VBoxManage.exe" internalcommands createrawvmdk -filename C:\file.vmdk -rawdisk \\.\PHYSICALDRIVE1

Em outro sistema operacional host

Há outras limitações em relação ao comando mencionado anteriormente quando usado em outros sistemas operacionais como OS X, portanto, leia atentamente a página do manual, se você for afetado.

##### Criar o arquivo de configuração da máquina virtual

Nota

- Para usar o comando VBoxManage no Windows, você precisa mudar o diretório atual para a pasta de instalação do VirtualBox primeiro: cd C:\Program Files\Oracle\VirtualBox\.
- O Windows usa barras invertidas em vez de barras, então substitua todas as ocorrências de "/" por "\" nos comandos a seguir quando for usá-los.

Depois, precisamos criar uma nova máquina (substitua virtual_machine_name conforme sua conveniência) e registrá-la no VirtualBox.

    $ VBoxManage createvm -name virtual_machine_name -register

Então, o novo disco bruto precisa ser anexado à máquina. Isso dependerá se seu computador ou, na verdade, a raiz de sua instalação nativa do Arch Linux está em um controlador IDE ou SATA.

Se você precisar de um controlador IDE:

    $ VBoxManage storagectl virtual_machine_name --name "IDE Controller" --add ide
    $ VBoxManage storageattach virtual_machine_name --storagectl "IDE Controller" --port 0 --device 0 --type hdd --medium /path/to/file.vmdk

caso contrário:

    $ VBoxManage storagectl virtual_machine_name --name "SATA Controller" --add sata
    $ VBoxManage storageattach virtual_machine_name --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium /path/to/file.vmdk

Enquanto você continua usando a CLI, é recomendável usar a GUI do VirtualBox, para personalizar a configuração da máquina virtual. De fato, você deve especificar sua configuração de hardware o mais próximo possível da sua máquina nativa: ativando a aceleração 3D, aumentando a memória de vídeo, configurando a interface de rede, etc.

Finalmente, você pode querer integrar perfeitamente seu Arch Linux com seu sistema operacional host e permitir copiar e colar entre ambos os sistemas operacionais. Consulte VirtualBox/Install Arch Linux as a guest#Install the Guest Additions para isso, já que esta máquina virtual Arch Linux é basicamente um convidado Arch Linux.

Atenção Para o Xorg funcionar nativamente e na máquina virtual, já que obviamente estará usando drivers diferentes, é melhor se não houver `/etc/X11/xorg.conf`, para que o Xorg possa pegar tudo o que precisa em tempo real. No entanto, se você realmente precisar de sua própria configuração do Xorg, talvez valha a pena definir seu alvo padrão do systemd para `multi-user.target` com `systemctl isolate graphical.target` como root (mais detalhes em Systemd#Targets e Systemd#Change current target). Dessa forma, a interface gráfica é desabilitada (ou seja, Xorg não é iniciado) e depois de fazer login, você pode `startx` manualmente com um `xorg.conf` personalizado.

### Instalar um sistema Arch Linux nativo a partir do VirtualBox

Em alguns casos, pode ser útil instalar um sistema Arch Linux nativo enquanto executa outro sistema operacional: uma maneira de realizar isso é fazer a instalação por meio do VirtualBox em um disco bruto. Se o sistema operacional existente for baseado em Linux, você pode querer considerar seguir Install from existing Linux em vez disso.

Este cenário é muito semelhante a #Executar uma instalação nativa do Arch Linux dentro do VirtualBox, mas seguirá essas etapas em uma ordem diferente: comece por #Crie uma imagem .vmdk de disco bruto, depois #Criar o arquivo de configuração da máquina virtual.

Agora, você deve ter uma configuração de máquina virtual funcional cujo disco VMDK virtual está vinculado a um disco real. O processo de instalação é exatamente o mesmo que as etapas descritas em VirtualBox/Install Arch Linux as a guest, mas #Certifique-se de que você tem um esquema de nomeação persistente e #Certifique-se de que sua imagem mkinitcpio está correta.

Atenção

- Para sistemas BIOS e discos MBR, não instale um carregador de inicialização dentro da sua máquina virtual, isso não funcionará, pois o MBR não está vinculado ao MBR da sua máquina real e seu disco virtual é apenas mapeado para uma partição real sem o MBR.
- Para sistemas UEFI sem CSM e discos GPT, a instalação não funcionará de forma alguma, pois:

  - a partição ESP não é mapeada para o seu disco virtual e o Arch Linux exige que o kernel Linux esteja nela para inicializar como um aplicativo EFI (veja EFISTUB para detalhes);
  - e as efivars, se você está instalando o Arch Linux usando o modo EFI trazido pelo VirtualBox, não são as do seu sistema real: as entradas do bootmanager, portanto, não serão registradas.

- É por isso que é recomendável criar suas partições em uma instalação nativa primeiro, caso contrário, as partições não serão consideradas na sua tabela de partições MBR/GPT.

Após concluir a instalação, inicialize seu computador nativamente com um meio de instalação do GNU/Linux (seja Arch Linux ou não), chroot na sua instalação do Arch Linux instalada e instale e configure um boot loader.

### Instalar convidado MacOS

Antes de iniciar a máquina virtual, execute os seguintes comandos na máquina host [2]:

    $ VBoxManage modifyvm "MyMacVM" --cpuid-set 00000001 000106e5 00100800 0098e3fd bfebfbff
    $ VBoxManage setextradata "MyMacVM" "VBoxInternal/Devices/efi/0/Config/DmiSystemProduct" "iMac11,3"
    $ VBoxManage setextradata "MyMacVM" "VBoxInternal/Devices/efi/0/Config/DmiSystemVersion" "1.0"
    $ VBoxManage setextradata "MyMacVM" "VBoxInternal/Devices/efi/0/Config/DmiBoardProduct" "Iloveapple"
    $ VBoxManage setextradata "MyMacVM" "VBoxInternal/Devices/smc/0/Config/DeviceKey" "ourhardworkbythesewordsguardedpleasedontsteal(c)AppleComputerInc"
    $ VBoxManage setextradata "MyMacVM" "VBoxInternal/Devices/smc/0/Config/GetKeyFromRealSMC" 1
    $ VBoxManage setextradata "MyMacVM" VBoxInternal2/EfiGopMode 4

Se você usar um processador AMD e a primeira inicialização travar, você também terá que executar

    $ VBoxManage modifyvm "MyMacVM" --cpu-profile "Intel Core i7-6700K"

#### Sem entrada de teclado/mouse ao tentar instalar o Mojave

Se você estiver tentando instalar o Mojave, após fazer as etapas mencionadas acima, o instalador será carregado, mas você pode não conseguir enviar entrada de teclado ou mouse. A razão parece ser que o Mojave não suporta mais os controladores USB 1.1 e, para corrigir o problema, você precisa emular USB 3.0. Para fazer isso, primeiro instale o pacote de extensão VirtualBox.

Em seguida, vá para Máquina > Configurações > USB e selecione USB 3.0. A entrada deve funcionar a partir deste ponto.

#### Shell interativo UEFI após reiniciar

Se o instalador não conseguir formatar corretamente a unidade inicializável durante a instalação e você acabar em um shell UEFI, insira o seguinte:

1. Digite `exit` no prompt UEFI
2. Selecione Gerenciador de Manutenção de Inicialização
3. Selecione Inicializar a partir do arquivo

Agora você será levado a alguns caminhos PCI obscuros. O primeiro é o que você acabou de tentar inicializar e não funcionou. O segundo (ou terceiro) deve ser o com a partição de recuperação do MacOS que você precisa carregar para continuar a instalação. Clique na segunda entrada. Se estiver vazia, pressione `Esc` para voltar e selecione a terceira entrada. Uma vez que você obtiver um com pastas, clique nas pastas. Deve ser algo como macOS Install Data > Locked Files > Boot Files > boot.efi. Uma vez que você clicar em boot.efi, você deve inicializar no instalador do MacOS e retomar a instalação. Observe que alguns dos subdiretórios podem estar faltando. Lembre-se de que você precisa chegar a um `boot.efi`.[3]

### Mover uma instalação nativa do Windows para uma máquina virtual

Se você deseja migrar uma instalação nativa do Windows existente para uma máquina virtual que será usada com o VirtualBox no GNU/Linux, este caso de uso é para você. Esta seção cobre apenas a instalação nativa do Windows usando o esquema de partição MSDOS/Intel. Sua instalação do Windows deve residir na primeira partição MBR para que essa operação seja bem-sucedida. Operações para outras partições estão disponíveis, mas não foram testadas (veja #Limitações conhecidas para detalhes).

Atenção Se você estiver usando uma versão OEM do Windows, este processo é não autorizado pela licença do usuário final. De fato, a licença OEM normalmente afirma que a instalação do Windows está vinculada ao hardware junto. Transferir uma instalação do Windows para uma máquina virtual remove esse vínculo. Portanto, certifique-se de que você tem uma instalação completa do Windows ou um modelo de licença por volume antes de continuar. Se você tem uma licença completa do Windows, mas a última não é em volume, nem como uma licença especial para vários PCs, isso significa que você terá que remover a instalação nativa após a operação de transferência ter sido concluída.

Algumas tarefas são necessárias para serem feitas dentro da sua instalação nativa do Windows primeiro, depois no seu host GNU/Linux.

#### Tarefas no Windows

Os três primeiros pontos a seguir vêm de esta página desatualizada do wiki do VirtualBox, mas estão atualizados aqui.

- Remova verificações de controladores IDE/ATA (somente Windows XP): o Windows memoriza os controladores de drive IDE/ATA nos quais foi instalado e não inicializará se detectar que esses mudaram. A solução proposta pela Microsoft é reutilizar o mesmo controlador ou usar um da mesma série, o que é impossível de alcançar, pois estamos usando uma Máquina Virtual. MergeIDE, uma ferramenta alemã, desenvolvida com base em outra solução proposta pela Microsoft, pode ser usada. Essa solução basicamente consiste em pegar todos os drivers de controlador IDE/ATA suportados pelo Windows XP do arquivo de driver inicial (o local é codificado ou especifique como o primeiro argumento para o script `.bat`), instalá-los e registrá-los no banco de dados do regedit.
- Use o tipo certo de Camada de Abstração de Hardware (versões antigas de Windows de 32 bits): a Microsoft envia 3 versões padrão: `Hal.dll` (PC padrão), `Halacpi.dll` (HAL ACPI) e `Halaacpi.dll` (HAL ACPI com IO APIC). Sua instalação do Windows pode vir instalada com a primeira ou a segunda versão. Dessa forma, por favor, desative o recurso estendido do VirtualBox Habilitar IO/APIC.
- Desative qualquer driver de dispositivo AGP (somente versões desatualizadas do Windows): Se você tiver os arquivos `agp440.sys` ou `intelppm.sys` dentro do diretório `C:\Windows\SYSTEM32\drivers\`, remova-o. Como o VirtualBox usa uma placa gráfica virtual PCI, isso pode causar problemas quando esse driver AGP é usado.
- Crie um disco de recuperação do Windows: Nas etapas seguintes, se as coisas derem errado, você precisará reparar sua instalação do Windows. Certifique-se de ter um meio de instalação à mão ou crie um com Criar um disco de recuperação a partir do Vista SP1, Criar um disco de reparo do sistema no Windows 7 ou Criar uma unidade de recuperação no Windows 8.x).

#### Usando Disk2vhd para clonar a partição do Windows

Inicialize no Windows, limpe a instalação (com CCleaner, por exemplo), use a ferramenta disk2vhd para criar uma imagem VHD. Inclua uma partição de sistema reservada (se presente) e a partição de dados básica do Windows (geralmente disco C:). O tamanho da imagem criada pelo Disk2vhd será a soma dos arquivos reais na partição (espaço usado), não o tamanho da partição inteira. Se tudo correr bem, a imagem deve apenas inicializar em uma máquina virtual e você não terá que passar pelo incômodo com MBR e carregador de inicialização do Windows, como no caso de clonar uma partição inteira.

#### Tarefas no GNU/Linux

Dica Pule as partes relacionadas à partição se você criou a imagem VHD com Disk2vhd.

- Reduza o tamanho da partição nativa do Windows para o tamanho que o Windows realmente precisa com `ntfsresize` disponível em ntfs-3g. O tamanho que você especificará será o mesmo tamanho do VDI que será criado na próxima etapa. Se este tamanho for muito baixo, você pode quebrar sua instalação do Windows e a última pode não inicializar de forma alguma.

  Use a opção `--no-action` primeiro para executar um teste:

      # ntfsresize --no-action --size 52Gi /dev/sda1

  Se apenas o teste anterior for bem-sucedido, execute este comando novamente, mas desta vez sem a flag de teste mencionada.

- Instale o VirtualBox no seu host GNU/Linux (veja #Passos de instalação para hospedeiros Arch Linux se o seu host for Arch Linux).

- Crie a imagem de disco do Windows do início do drive até o final da primeira partição onde está localizada a sua instalação do Windows. Copiar do início do disco é necessário porque o espaço do MBR no início do disco precisa estar no disco virtual junto com a partição do Windows. Neste exemplo, duas partições a seguir `sda2` e `sda3` serão posteriormente removidas da tabela de partições e o carregador de inicialização MBR será atualizado.

      # sectnum=$(( $(cat /sys/block/sda/sda1/start) + $(cat /sys/block/sda/sda1/size) ))

  Usando `cat /sys/block/sda/sda1/size` exibirá o número de setores totais da primeira partição do disco `sda`. Adapte onde necessário.

      # dd if=/dev/sda bs=512 count=$sectnum | VBoxManage convertfromraw stdin windows.vdi $(( $sectnum * 512 ))

  Precisamos exibir o tamanho em bytes, `$(( $sectnum * 512 ))` converterá os números dos setores para bytes.

- Como você criou sua imagem de disco como root, defina a propriedade correta para a imagem do disco virtual:

      # chown your_user:your_group windows.vdi

- Crie seu arquivo de configuração de máquina virtual e use o disco virtual criado anteriormente como o principal disco rígido virtual.

- Tente inicializar sua máquina virtual Windows, ela pode simplesmente funcionar. Primeiro, remova e repare discos do processo de inicialização, pois podem interferir (e provavelmente interferirão) na inicialização em modo de segurança.

- Tente inicializar sua máquina virtual Windows em modo de segurança (pressione a tecla F8 antes da tela do Windows aparecer, mas depois que a tela do VirtualBox desaparecer)... se encontrar problemas de inicialização, leia #Corrigir MBR e carregador de inicialização Microsoft. No modo de segurança, os drivers serão instalados provavelmente pelo mecanismo de detecção plug-and-play do Windows view. Além disso, instale as Guest Additions do VirtualBox através do menu Dispositivos > Inserir imagem de CD das Guest Additions. Se um novo diálogo de disco não aparecer, navegue até a unidade de CD e inicie o instalador manualmente.

- Você deve finalmente ter uma máquina virtual Windows funcionando. Não se esqueça de ler as #Limitações conhecidas.

- Dica de desempenho: de acordo com o manual do VirtualBox, o controlador SATA tem um desempenho melhor do que o IDE. Se você não conseguir inicializar o Windows do controlador SATA virtual imediatamente, provavelmente é devido à falta de drivers SATA. Anexe o disco virtual ao controlador IDE, crie um controlador SATA vazio e inicialize a máquina virtual - o Windows deve instalar automaticamente os drivers SATA para o controlador. Você pode então desligar a máquina virtual, desanexar o disco virtual do controlador IDE e anexá-lo ao controlador SATA.

#### Corrigir MBR e carregador de inicialização Microsoft

Se a sua máquina virtual Windows se recusar a inicializar, talvez seja necessário aplicar as seguintes modificações à sua máquina virtual.

- Inicie uma distribuição GNU/Linux ao vivo dentro da sua máquina virtual antes que o Windows inicie.

- Remova outras entradas de partições do MBR do disco virtual. De fato, como copiamos o MBR e apenas a partição do Windows, as entradas das outras partições ainda estão presentes no MBR, mas as partições não estão mais disponíveis. Use `fdisk` para fazer isso, por exemplo.

      fdisk ''/dev/sda''
      Comando (m para ajuda): a
      Número da partição (''1-3'', padrão ''3''): ''1''

- Escreva a tabela de partições atualizada no disco (isso recriará o MBR) usando o comando `m` dentro do `fdisk`.

- Use testdisk (veja aqui para mais detalhes) para adicionar um MBR genérico:

      # testdisk > Disco /dev/sda... > [Prosseguir] >  [Intel] Partição Intel/PC > [Código MBR] Escrever código MBR do TestDisk no primeiro setor > Escrever nova cópia do código MBR no primeiro setor? (Y/n) > Y > Nova cópia do código MBR foi escrita. Você precisa reiniciar para que a mudança tenha efeito. > [OK]

- Com o novo MBR e a tabela de partições atualizada, sua máquina virtual Windows deve ser capaz de inicializar. Se ainda encontrar problemas, inicie o disco de recuperação do Windows de um dos passos anteriores, e dentro do seu ambiente Windows RE, execute os comandos descritos aqui.

#### Limitações conhecidas

- Sua máquina virtual pode às vezes travar e exceder a RAM, isso pode ser causado por drivers conflitantes ainda instalados dentro de sua máquina virtual Windows. Boa sorte para encontrá-los!
- Software adicional esperando um determinado driver abaixo pode não ser desabilitado/desinstalado ou precisa ser desinstalado primeiro, pois os drivers que não estão mais disponíveis.
- Sua instalação do Windows deve residir na primeira partição para que o processo acima funcione. Se este requisito não for atendido, o processo ainda pode ser alcançado, mas isso não foi testado. Isso exigirá copiar o MBR e editar em hexadecimal, veja VirtualBox: inicializando disco clonado ou exigirá corrigir a tabela de partições manualmente ou reparar o Windows com o disco de recuperação que você criou em um passo anterior. Vamos considerar nossa instalação do Windows na segunda partição; copiaremos o MBR e, em seguida, a segunda partição para a imagem do disco. `VBoxManage convertfromraw` precisa do número total de bytes que serão escritos: calculado graças ao tamanho do MBR (o início da primeira partição) mais o tamanho da segunda partição (Windows). `{ dd if=/dev/sda bs=512 count=$(cat /sys/block/sda/sda1/start) ; dd if=/dev/sda2 bs=512 count=$(cat /sys/block/sda/sda2/size) ; } | VBoxManage convertfromraw stdin windows.vdi $(( ($(cat /sys/block/sda/sda1/start) + $(cat /sys/block/sda/sda2/size)) * 512 ))`.

### Executar uma instalação nativa do Windows dentro do VirtualBox

Nota A técnica descrita nesta seção se aplica apenas a sistemas UEFI.

Em alguns casos, é útil poder dual boot com Windows e acessar a partição em uma máquina virtual. Este processo é significativamente diferente de #Mover uma instalação nativa do Windows para uma máquina virtual de várias maneiras:

- A partição do Windows não é copiada para uma imagem de disco virtual. Em vez disso, um arquivo VMDK bruto é criado;
- As alterações na máquina virtual serão espelhadas na partição e vice-versa;
- Licenças OEM ainda devem ser satisfeitas, já que a partição do Windows ainda inicializa diretamente no hardware.

Atenção Alguns dos comandos usados aqui podem corromper a partição do Windows, a partição do Arch Linux ou ambas. Use extrema cautela ao executar comandos e verifique duas vezes se estão sendo executados no shell correto. Seria uma boa ideia ter um backup de todo o disco pronto antes de começar este processo.
Nota Antes de prosseguir, certifique-se de ter acesso a um meio de instalação do Windows (como o ISO do Windows 11).

#### Criando a máquina virtual

Uma máquina virtual do VirtualBox deve ser criada manualmente. Por enquanto, não adicione nenhum dispositivo de armazenamento ou disco à máquina virtual, isso será feito manualmente mais tarde.

Configure a máquina virtual com as seguintes configurações (o painel de configurações pode ser aberto clicando no botão "Configurações" na barra de ferramentas principal):

- Visualização: Sistema:
  - Aba: Placa-mãe:
    - marque Habilitar I/O APIC;
    - marque Habilitar EFI;
    - marque Relógio de Hardware em Tempo UTC se for o seu caso.
  - Aba: Processador:
    - marque Habilitar PAE/NX;
    - marque Habilitar Nested VT-x/AMD-V;
  - Aba: Aceleração:
    - Escolha a interface de paravirtualização Hyper-V no menu suspenso;
    - marque Habilitar Paginação Aninhada.

Opcionalmente, você também pode habilitar as seguintes configurações:

- Visualização: Display
  - Aba: Tela
    - marque Habilitar Aceleração 3D. Observe que isso pode causar falhas.

Nota A configuração Hyper-V não é necessária para o sistema operar corretamente, mas pode ajudar a evitar problemas de licenciamento.

#### Criando discos de máquina virtual

Para acessar as partições do Windows, crie um arquivo VMDK bruto apontando para as partições relevantes do Windows (são necessários privilégios de root para ler a tabela de partições do disco):

    # VBoxManage createmedium disk -filename VM_DIRECTORY/windows.vmdk --format=VMDK --variant RawDisk --property RawDrive=DISK --property Partitions=RESERVED_PARTITION_NUMBER,BASIC_DATA_PARTITION_NUMBER

Substitua as strings de espaço reservado em maiúsculas da seguinte forma:

- VM_DIRECTORY deve ser substituído pelo caminho da pasta da máquina virtual (geralmente um subdiretório de ~/VirtualBox VMs);
- DISK deve ser substituído pelo dispositivo de bloco que contém todas as partições do Windows (por exemplo: /dev/sda ou /dev/nvme0n1);
- RESERVED_PARTITION_NUMBER deve ser substituído pelo número da partição rotulada "Partição reservada pela Microsoft" (por exemplo: se a partição for /dev/sda2, o número será 2);
- BASIC_DATA_PARTITION_NUMBER deve ser substituído pela partição que contém a instalação do Windows (por exemplo: se a partição for /dev/sda3, o número será 3);

Exemplo:

    $ sudo VBoxManage createmedium disk -filename "/home/user/VirtualBox VMs/windows.vmdk" --format=VMDK --variant RawDisk --property RawDrive=/dev/nvme0n1 --property Partitions=2,3

O comando também criará um arquivo extra na pasta da máquina virtual, "windows-pt.vmdk", que será ignorado.

Nota windows.vmdk deve ser recriado se a tabela de partições for alterada.
Dica

Os números das partições também podem ser encontrados executando este comando e olhando para a coluna MIN:

    lsblk --output NAME,PARTLABEL,FSTYPE,MAJ:MIN,SIZE

    NAME        PARTLABEL                    FSTYPE UUID                                 MAJ:MIN   SIZE
    nvme0n1                                                                              259:0   931,5G
    ├─nvme0n1p1 Partição do sistema EFI         vfat   90DC-A6B3                            259:1     100M
    ├─nvme0n1p2 Partição reservada da Microsoft                                             259:2      16M
    ├─nvme0n1p3 Partição de dados básica         ntfs   D2A2A104A2A0EE63                     259:3     200G
    ...

Agora mude o proprietário do disco virtual para dar acesso ao usuário e ao grupo que executam o VirtualBox.

    # chown VIRTUALBOX_RUNNING_USER:VIRTUALBOX_RUNNING_GROUP VM_DIRECTORY/windows.vmdk VM_DIRECTORY/windows-pt.vmdk

Substitua VIRTUALBOX_RUNNING_USER e VIRTUALBOX_RUNNING_GROUP pelo usuário e pelo grupo que executarão o VirtualBox, que provavelmente será seu usuário.

#### Permitindo que o VirtualBox leia partições físicas

O VirtualBox deve ter acesso a disco bruto para executar uma partição do Windows. Normalmente, isso exigiria que o VirtualBox fosse executado com privilégios de root completos, mas opções mais elegantes estão disponíveis.

##### Opção de maior segurança: usando um grupo dedicado para as partições do Windows

Aqui, o udev é configurado para restringir o acesso às partições do Windows para o grupo vboxusers, e então o usuário que executa o VirtualBox é adicionado ao grupo.

Atribuir os discos ao grupo vboxusers pode ser feito automaticamente criando o seguinte arquivo:

    /etc/udev/rules.d/99-vbox.rules

    #
    # Regras para dar aos usuários do VirtualBox acesso bruto a partições do Windows
    #

    # Partição reservada pela Microsoft
    SUBSYSTEM=="block", ENV{ID_PART_ENTRY_TYPE}=="e3c9e316-0b5c-4db8-817d-f92df00215ae", GROUP="vboxusers"

    # Partição do Windows
    SUBSYSTEM=="block", ENV{ID_PART_ENTRY_TYPE}=="ebd0a0a2-b9e5-4433-87c0-68b6b72699c7", GROUP="vboxusers"

    #
    # Regras para dar aos usuários do VirtualBox acesso bruto a discos do Windows
    #

    # sdb
    ENV{ID_PART_TABLE_UUID}=="WINDOWS_DISK_ID_PART_TABLE_UUID", GROUP="vboxusers"

WINDOWS_DISK_ID_PART_TABLE_UUID deve ser substituído pelo valor obtido de `udevadm info /dev/WINDOWS_DISK` (substitua WINDOWS_DISK pelo disco que contém as partições do Windows). Os UUIDs nessas regras correspondem a tipos específicos de partição GPT, enquanto as outras strings em maiúsculas devem ser escritas dessa forma, portanto, não precisam ser substituídas.

Então, o usuário que executa o VirtualBox deve ser adicionado ao grupo vboxusers. Isso pode ser feito com o seguinte comando:

    # usermod -aG vboxusers VIRTUALBOX_RUNNING_USER

Substitua VIRTUALBOX_RUNNING_USER pelo usuário que executará o VirtualBox, que provavelmente será seu usuário.

##### Opção de menor segurança: usando o grupo 'disk'

Para poder adicionar o arquivo vmdk no Gerenciador de Mídia Virtual do Virtualbox sem executar o VirtualBox como root, o usuário que executa o VirtualBox precisa estar nos grupos vboxusers e disk.

    # usermod -aG disk,vboxusers VIRTUALBOX_RUNNING_USER

Substitua VIRTUALBOX_RUNNING_USER pelo usuário que executará o VirtualBox, que provavelmente será seu usuário.

Atenção Esteja ciente das implicações de segurança potenciais desta edição, pois você está dando à sua conta de usuário acesso total de leitura e gravação a todos os dispositivos de armazenamento pertencentes ao grupo de disco.

#### Configurando uma partição separada do sistema EFI

Os arquivos de inicialização UEFI da máquina virtual se referirão a discos diferentes daqueles na partição do sistema EFI física, então o VirtualBox não deve fazer uso desta última, mas sim de uma partição do sistema EFI dentro de um disco virtual dedicado. Este disco pode ser criado com o seguinte comando:

    $ VBoxManage createmedium disk --filename VM_DIRECTORY/esp.vmdk --size 512 --format VMDK

Substitua VM_DIRECTORY pela pasta que contém a máquina virtual sendo construída.

#### Adicionando discos virtuais à máquina virtual

Configure os dispositivos de armazenamento da máquina virtual (Painel de configurações - Armazenamento) da seguinte forma:

- adicione esp.vmdk como um disco rígido SATA conectado ao "Porta SATA 0";
- adicione windows.vmdk como um disco rígido SATA conectado ao "Porta SATA 1";
- monte o ISO de instalação do Windows na unidade óptica virtual.

Nota

- para adicionar um disco rígido SATA, use o segundo botão à direita do dispositivo "Controlador: SATA";
- a unidade óptica virtual já deve estar presente como "Unidade Óptica".

#### Configurando o firmware UEFI virtual e criando arquivos de inicialização do Windows

Agora inicie a máquina virtual e ela deve inicializar automaticamente a partir do disco de instalação do Windows. Após escolher as localidades de instalação, clique no link "Reparar seu computador", escolha "Solucionar problemas" e depois "Prompt de Comando" para iniciar um prompt de comando a partir do meio de instalação.

Digite os seguintes comandos para criar uma nova tabela GPT no disco esp.vmdk e instalar o carregador de inicialização do Windows nele usando a configuração da partição existente do Windows:

Abra o Diskpart:

    X:\ diskpart

Liste todos os discos identificados pelo sistema:

    DISKPART> list disk

O disco esp.vmkd deve ser rotulado como disco 0 devido ao fato de ter sido anexado à porta SATA 0, com ~512 MiB de tamanho e não particionado. O disco windows.vmdk deve ser rotulado como disco 1; observe que a coluna "Tamanho" exibe o tamanho do disco, não da partição.

Selecione o disco esp.vmdk:

    DISKPART> select Disk 0

Agora crie uma tabela de partição GPT, uma partição do sistema EFI, do tamanho do disco inteiro, e atribua a ela um rótulo e letra de unidade:

    DISKPART> clean
    DISKPART> convert gpt
    DISKPART> create partition efi size=500
    DISKPART> format quick fs=fat32 label="System"
    DISKPART> assign letter="S"

Verifique se a partição foi criada corretamente:

    DISKPART> list volume

Nossa partição EFI recém-criada será rotulada como "SYSTEM" com a letra "S".

Anote a letra de volume da instalação do Windows, pois será usada nas próximas etapas. Geralmente é D, mas pode ser diferente: você pode inferir isso pelo rótulo e pelo tamanho. O tamanho é o mesmo da partição de instalação do Windows no disco rígido físico.

Saia do diskpart:

    DISKPART> exit

Instale o carregador de inicialização do Windows na partição do sistema EFI.

    D:
    cd Windows\System32
    bcdboot D:\Windows /s S: /f UEFI

Agora feche o prompt de comando, desligue a máquina virtual e desconecte o disco de instalação do Windows (em "Preferências > Dispositivos", remova o disco óptico). A máquina virtual agora deve inicializar a partir da partição de inicialização recém-instalada e carregar a instalação física do Windows. Pode mostrar alguns erros relacionados à UEFI no topo da janela da máquina virtual e a primeira inicialização pode demorar um pouco, mas se tudo foi feito corretamente, você poderá acessar sua instalação do Windows.

### Executar um disco físico inteiro no Virtualbox

Nota Você pode consultar a documentação oficial do Virtualbox 9.8.1. Usando um Disco Rígido Host Bruto a partir de um Convidado.

Isso funciona da mesma forma que #Executar uma instalação nativa do Windows dentro do VirtualBox, mas o vmdk conterá o disco inteiro, não apenas uma partição, e assim você não precisará criar uma ESP ou partição MBR separada, pois a existente no disco físico será usada.

Crie o disco bruto:

    # VBoxManage internalcommands createrawvmdk -filename /path/to/file.vmdk -rawdisk /dev/sdb

Em seguida, siga o mesmo método de #Executar uma instalação nativa do Windows dentro do VirtualBox para a configuração e anexação de disco virtual.

### Definir resolução de inicialização do convidado

Você pode alterar a resolução de inicialização do BIOS/UEFI usando a ferramenta `VBoxManage`. Por exemplo:

    $ VBoxManage setextradata "Nome da sua máquina virtual" "VBoxInternal2/EfiGraphicsResolution" "2560x1440"

Resoluções recomendadas são 1280x720, 1920x1080, 2048x1080, 2560x1440, 3840x2160, 1280x800, 1280x1024, 1440x900, 1600x900.

### SSH do host para o convidado

A aba de rede das configurações da máquina virtual contém, em "Avançado", uma ferramenta para criar o encaminhamento de portas. É possível usá-la para encaminhar a porta SSH do Convidado `22` para uma porta do Host, por exemplo `3022`:

    user@host$ ssh -p 3022 $USER@localhost

isso estabelecerá uma conexão do Host para o Convidado.

#### SSHFS como alternativa à pasta compartilhada

Usando esse encaminhamento de porta e sshfs, é simples montar o sistema de arquivos do Convidado no sistema de arquivos do Host:

    user@host$ sshfs -p 3022 $USER@localhost:$HOME ~/pasta_compartilhada

e então transferir arquivos entre ambos.

## Solução de problemas

### Teclado e mouse estão bloqueados na máquina virtual

Isso significa que sua máquina virtual capturou a entrada do seu teclado e mouse. Simplesmente pressione a tecla `Ctrl` direita e sua entrada deve controlar seu host novamente.

Para controlar sua máquina virtual de forma transparente com seu mouse indo e voltando do seu host, sem ter que pressionar nenhuma tecla, e assim ter uma integração perfeita, instale as adições para convidados dentro do convidado. Leia a partir de VirtualBox/Instalar o Arch Linux como um convidado#Instalar as Adições para Convidados se o seu convidado for o Arch Linux, caso contrário, leia a ajuda oficial do VirtualBox.

### Nenhuma opção de cliente de sistema operacional de 64 bits

Ao iniciar um cliente de máquina virtual e nenhuma opção de 64 bits estiver disponível, certifique-se de que as capacidades de virtualização da CPU (geralmente chamadas de `VT-x`) estejam habilitadas no BIOS.

Se você estiver usando um host Windows, pode ser necessário desativar o Hyper-V, pois ele impede que o VirtualBox use VT-x. [4]

### A GUI do VirtualBox não corresponde ao tema GTK do host

Veja Uniform look for Qt and GTK applications para informações sobre como aplicar temas em aplicativos baseados em Qt como o VirtualBox.

### Não é possível enviar Ctrl+Alt+Fn para o convidado

Seu sistema operacional convidado é uma distribuição GNU/Linux e você deseja abrir um novo shell TTY pressionando `Ctrl+Alt+F2` ou sair da sua sessão X atual com `Ctrl+Alt+Backspace`. Se você digitar esses atalhos de teclado sem qualquer adaptação, o convidado não receberá nenhuma entrada e o host (se for uma distribuição GNU/Linux também) interceptará essas teclas de atalho. Para enviar `Ctrl+Alt+F2` para o convidado, por exemplo, basta pressionar sua Tecla Host (geralmente a tecla `Ctrl` direita) e pressionar `F2` simultaneamente.

### Subsistema USB não está funcionando

Seu usuário deve estar no grupo `vboxusers` e você precisa instalar o pacote de extensão se quiser suporte para USB 2. Então você poderá habilitar USB 2 nas configurações da máquina virtual e adicionar um ou vários filtros para os dispositivos que deseja acessar a partir do sistema operacional convidado.

Se `VBoxManage list usbhost` não mostrar nenhum dispositivo USB, mesmo se executado como root, certifique-se de que não há regras udev antigas (do VirtualBox 4.x) em `/etc/udev/rules.d/`. O VirtualBox 5.0 instala regras udev em `/usr/lib/udev/rules.d/`. Você pode usar comandos como `pacman -Qo /usr/lib/udev/rules.d/60-vboxdrv.rules` para determinar se o arquivo de regra udev está desatualizado.

Às vezes, em hosts Linux antigos, o subsistema USB não é detectado automaticamente, resultando em um erro `Could not load the Host USB Proxy service: VERR_NOT_FOUND` ou em uma unidade USB não visível no host, mesmo quando o usuário está no grupo vboxusers. Este problema ocorre porque o VirtualBox mudou de usbfs para sysfs na versão 3.0.8. Se o host não entender essa mudança, você pode reverter para o comportamento antigo definindo a seguinte variável de ambiente em qualquer arquivo que seja carregado pelo seu shell (por exemplo, seu `~/.bashrc` se você estiver usando bash):

    ~/.bashrc

    VBOX_USB=usbfs

Em seguida, certifique-se de que o ambiente tenha sido informado dessa mudança (reconecte, carregue o arquivo manualmente, inicie uma nova instância do shell ou reinicie).

Também verifique se seu usuário é membro do grupo `storage`.

### Modem USB não funciona no host

Se você tiver um modem USB que está sendo usado pelo sistema operacional convidado, encerrar o sistema operacional convidado pode fazer com que o modem se torne inutilizável pelo sistema operacional host. Matar e reiniciar o `VBoxSVC` deve corrigir este problema.

### Dispositivo USB causa falha no convidado

Se anexar um dispositivo USB ao convidado causar uma falha ou qualquer outro comportamento errôneo, tente trocar o controlador USB de USB 2 (EHCI) para USB 3 (xHCI) ou vice-versa.

### Host congela ao iniciar a máquina virtual

Geralmente, esses problemas são observados após a atualização do VirtualBox ou do kernel Linux. Reverter para as versões anteriores pode resolver o problema.

### Microfone analógico não funciona

Se a entrada de áudio de um microfone analógico estiver funcionando corretamente no host, mas nenhum som parece passar para o convidado, apesar do dispositivo de microfone ser detectado normalmente, a instalação de um Servidor de àudio como o PulseAudio (Português) no host pode corrigir o problema.

Se, após a instalação do PulseAudio (Português), o microfone ainda se recusar a funcionar, definir o Driver de Áudio do Host (em VirtualBox > Máquina > Configurações > Áudio) para Driver de Áudio ALSA pode ajudar.

### Problemas com imagens convertidas para ISO

Alguns formatos de imagem não podem ser convertidos confiavelmente para ISO. Por exemplo, ccd2iso ignora arquivos .ccd e .sub, o que pode resultar em imagens de disco com arquivos corrompidos.

Nesse caso, você terá que usar o CDemu para Linux dentro do VirtualBox ou qualquer outra utilidade usada para montar imagens de disco.

### Falha ao criar a interface de rede host-only

Certifique-se de que todos os módulos de kernel necessários estejam carregados. Veja #Carregue os módulos do kernel VirtualBox.

Se todos os módulos de kernel necessários estiverem carregados e você ainda não conseguir criar o adaptador host-only, navegue até Arquivo > Gerenciador de Rede Host e clique no botão Criar para adicionar a interface de rede.

### Falha ao inserir o módulo

Quando você receber o seguinte erro ao tentar carregar módulos:

    Falha ao inserir 'vboxdrv': Chave necessária não disponível

Assine seus módulos ou desative `CONFIG_MODULE_SIG_FORCE` na configuração do seu kernel.

### VBOX_E_INVALID_OBJECT_STATE (0x80BB0007)

Isso pode ocorrer se uma máquina virtual for encerrada de maneira inadequada. Execute o seguinte comando:

    $ VBoxManage controlvm nome_da_máquina_virtual poweroff

### NS_ERROR_FAILURE e itens de menu ausentes

Este erro pode aparecer se virtualbox-ext-oracleAUR não tiver sido atualizado e se tornar incompatível com uma versão recém-lançada do VirtualBox.

Este erro também acontece às vezes ao selecionar o formato de disco QCOW/QCOW2/QED ao criar um novo disco virtual.

Se você encontrar esta mensagem na primeira vez que iniciar a máquina virtual:

    Falha ao abrir uma sessão para a máquina virtual debian.
    Não foi possível abrir o meio '/home/.../VirtualBox VMs/debian/debian.qcow'.
    QCow: A leitura da tabela L1 para a imagem '/home/.../VirtualBox VMs/debian/debian.qcow' falhou (VERR_EOF).
    VD: erro VERR_EOF ao abrir o arquivo de imagem '/home/.../VirtualBox VMs/debian/debian.qcow' (VERR_EOF).

    Código de Resultado:
    NS_ERROR_FAILURE (0x80004005)
    Componente:
    Médio

Saia do VirtualBox, exclua todos os arquivos da nova máquina e remova a última linha no arquivo de configuração do VirtualBox em `MachineRegistry` (ou a máquina ofensora que você está criando):

    ~/.config/VirtualBox/VirtualBox.xml

    ...
    <MachineRegistry>
      <MachineEntry uuid="{00000000-0000-0000-0000-000000000000}" src="/home/void/VirtualBox VMs/debian/debian.vbox"/>
      <MachineEntry uuid="{00000000-0000-0000-0000-000000000000}" src="/home/void/VirtualBox VMs/ubuntu/ubuntu.vbox"/>
      <MachineEntry uuid="{00000000-0000-0000-0000-000000000000}" src="/home/void/VirtualBox VMs/lastvmcausingproblems/lastvmcausingproblems.qcow"/>
    </MachineRegistry>
    ...

### Windows: "O caminho especificado não existe. Verifique o caminho e tente novamente."

Esta mensagem de erro pode aparecer ao executar um arquivo `.exe` que requer privilégios de administrador a partir de uma pasta compartilhada em convidados Windows. [5]

Como solução, copie o arquivo para o disco virtual ou use caminhos UNC (`\\vboxsvr`). Veja [6] para mais informações.

### Windows 8.x código de erro 0x000000C4

Se você receber este código de erro ao inicializar, mesmo se escolher o tipo de sistema operacional Win 8, tente habilitar a instrução de CPU `CMPXCHG16B`:

    $ vboxmanage setextradata nome_da_máquina_virtual VBoxInternal/CPUM/CMPXCHG16B 1

### Windows 8, 8.1 ou 10 falha ao instalar, inicializar ou tem erro "ERR_DISK_FULL"

Atualize as configurações da máquina virtual indo em Configurações > Armazenamento > Controlador:SATA e marque Usar Cache de E/S do Host.

### WinXP: Profundidade de bit não pode ser maior que 16

Se você estiver executando com profundidade de cor de 16 bits, os ícones podem aparecer embaçados. No entanto, ao tentar mudar a profundidade de cor para um nível mais alto, o sistema pode restringi-lo a uma resolução mais baixa ou simplesmente não permitir que você mude a profundidade de cor. Para corrigir isso, execute `regedit` no Windows e adicione a seguinte chave ao registro da máquina virtual Windows XP:

    [HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services]
    "ColorDepth"=dword:00000004

Em seguida, atualize a profundidade de cor na janela de "propriedades de desktop". Se nada acontecer, force a tela a redesenhar por algum método (por exemplo, `Host+f` para redesenhar/entrar em tela cheia).

### Windows: Tela pisca se a aceleração 3D estiver habilitada

VirtualBox > 4.3.14 tem uma regressão na qual convidados Windows com aceleração 3D piscam. Desde a r120678, um patch foi implementado para reconhecer uma variável de ambiente, inicie o VirtualBox assim:

    $ CR_RENDER_FORCE_PRESENT_MAIN_THREAD=0 VirtualBox

Certifique-se de que nenhum serviço do VirtualBox ainda esteja em execução. Veja bug 13653 do VirtualBox.

### Não é possível iniciar o VirtualBox com Wayland: Falha de segmentação

Este problema é causado pelo Qt detectando o Wayland (por exemplo, se `XDG_SESSION_TYPE=wayland`), enquanto o VirtualBox ainda não funciona no Wayland. Veja FS#58761 e o bug upstream.

A detecção da plataforma Qt pode ser desabilitada e o X11 forçado sobre o Wayland definindo a variável de ambiente `QT_QPA_PLATFORM=xcb`. Para não afetar os outros aplicativos Qt (que geralmente funcionam bem com o Wayland), `QT_QPA_PLATFORM=xcb` deve ser definido apenas ao iniciar o VirtualBox.

Se iniciar através da entrada de desktop, siga as instruções em Desktop entries#Modify environment variables e altere as linhas que começam com `Exec=VirtualBox ...` para `Exec=env QT_QPA_PLATFORM=xcb VirtualBox ...`. Se iniciar pelo shell, crie um alias para `virtualbox` como `env QT_QPA_PLATFORM=xcb virtualbox`.

Nota Se você tiver problemas relacionados ao mouse ou teclado no Wayland, também pode tentar a configuração acima.

### Congelamento aleatório em convidados com GPU Intel

Com CPU e gráficos Intel, alocar mais processadores para o convidado pode diminuir o desempenho de renderização, causando congelamento aleatório. Alocar menos processadores pode ajudar.

### Incapaz de visualizar o desktop no modo de tela cheia

Desative a Mini Barra de Ferramentas selecionando Máquina > Configurações, selecione a aba Interface do Usuário e desmarque a caixa de seleção Mini Barra de Ferramentas.

### Travamentos aleatórios com sistema operacional convidado Windows 10 com chipset Intel Tiger Lake

Desabilite a detecção de divisão de bloqueio adicionando `split_lock_detect=off` aos parâmetros do kernel.

Detalhes estão descritos no Ticket #20180 do VirtualBox.

### Falha ao salvar as configurações ao habilitar o Secure Boot

No VirtualBox 7.0.0, habilitar o Secure Boot em uma máquina virtual que foi criada em uma versão anterior do VirtualBox falhará com um erro indescritível (FS#76234):

    Falha ao salvar as configurações.

A solução é clicar no botão Redefinir Chaves para Padrão logo abaixo da caixa de seleção Habilitar Secure Boot.

### Falha ao iniciar a máquina VirtualBox após usar o emulador do Android Studio

Os módulos de kernel KVM e VirtualBox podem ser carregados, mas não usados simultaneamente. O emulador do Android Studio é um emulador QEMU, que usa KVM para aceleração. Portanto, o emulador do Android Studio e a máquina VirtualBox (se a aceleração de hardware estiver habilitada) não podem ser executados ao mesmo tempo. Temos que usar um após o outro ter parado completamente.

Às vezes, o módulo de kernel do VirtualBox ainda pode ser usado inesperadamente por algum processo e manter todas as máquinas VirtualBox falhando ao iniciar, a mensagem de erro no GUI do VirtualBox é "Ocorreu um erro crítico".

Neste momento, podemos verificar e recarregar os módulos de kernel do VirtualBox usando `vboxreload` como root. Se disser que alguns módulos ainda estão em uso, você precisa matar o processo relacionado manualmente e executar novamente o comando.

## Veja também

- Manual do Usuário do VirtualBox
- Wikipedia:VirtualBox

Categories:

- Hypervisors (Português)
- Oracle (Português)

Hidden categories:

- Pages with broken package links
- Pages with dead links
- Pages or sections flagged with Template:Style

VirtualBox (Português)
Add topic