VirtualBox

VirtualBox is a hypervisor used to run operating systems in a special environment, called a virtual machine, on top of the existing operating system. VirtualBox is in constant development and new features are implemented continuously. It comes with a Qt GUI interface, as well as headless and SDL command-line tools for managing and running virtual machines.

In order to integrate functions of the host system to the guests, including shared folders and clipboard, video acceleration and a seamless window integration mode, guest additions are provided for some guest operating systems.

Installation steps for Arch Linux hosts

In order to launch VirtualBox virtual machines on your Arch Linux box, follow these installation steps.

Install the core packages

Install the virtualbox package. You will also need to choose a package to provide host modules:

for the linux kernel, choose virtualbox-host-modules-arch
for any other kernel (including linux-lts), choose virtualbox-host-dkms

To compile the VirtualBox modules provided by virtualbox-host-dkms, it will also be necessary to install the appropriate headers package(s) for your installed kernel(s) (e.g. linux-lts-headers for linux-lts). [1] When either VirtualBox or the kernel is updated, the kernel modules will be automatically recompiled thanks to the DKMS pacman hook.

Sign modules

When using a custom kernel with CONFIG_MODULE_SIG_FORCE option enabled, you must sign your modules with a key generated during kernel compilation.

Navigate to your kernel tree folder and execute the following command:

# 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

Note: Hashing algorithm does not have to match the one configured, but it must be built into the kernel.

Load the VirtualBox kernel modules

virtualbox-host-modules-arch and virtualbox-host-dkms use systemd-modules-load.service to load VirtualBox modules automatically at boot time. For the modules to be loaded after installation, either reboot or load the modules once manually; the list of modules can be found in /usr/lib/modules-load.d/virtualbox-host-modules-arch.conf or /usr/lib/modules-load.d/virtualbox-host-dkms.conf.

Note: If you do not want the VirtualBox modules to be automatically loaded at boot time, you have to mask the default /usr/lib/modules-load.d/virtualbox-host-modules-arch.conf (or /usr/lib/modules-load.d/virtualbox-host-dkms.conf) by creating an empty file (or symlink to /dev/null) with the same name in /etc/modules-load.d/.

Among the kernel modules VirtualBox uses, there is a mandatory module named vboxdrv, which must be loaded before any virtual machines can run.

To load the module manually, run:

# modprobe vboxdrv

The following modules are only required in advanced configurations:

vboxnetadp and vboxnetflt are both needed when you intend to use the bridged or host-only networking feature. More precisely, vboxnetadp is needed to create the host interface in the VirtualBox global preferences, and vboxnetflt is needed to launch a virtual machine using that network interface.

Note: If the VirtualBox kernel modules were loaded in the kernel while you updated the modules, you need to reload them manually to use the new updated version. To do it, run vboxreload as root.

Accessing host USB devices in guest

To use the USB ports of your host machine in your virtual machines, add users that will be authorized to use this feature to the vboxusers user group.

Guest additions disc

It is also recommended to install the virtualbox-guest-iso package on the host running VirtualBox. This package will act as a disc image that can be used to install the guest additions onto guest systems other than Arch Linux. The .iso file will be located at /usr/lib/virtualbox/additions/VBoxGuestAdditions.iso, and may have to be mounted manually inside the virtual machine. Once mounted, you can run the guest additions installer inside the guest.

Unattended templates

In order to avoid having to install the guest system manually, some operating systems support unattended installation. This allows the user to configure the system to be installed in VirtualBox's interface prior to starting the machine. At the end of the setup process, the operating system is installed without requiring any further user interaction. This feature requires the virtualbox-unattended-templates^AUR package.

Extension pack

The Oracle Extension Pack provides additional features and is released under a non-free license only available for personal use. To install it, the virtualbox-ext-oracle^AUR package is available, and a prebuilt version can be found in the seblu repository.

If you prefer to use the traditional and manual way: download the extension manually and install it via the GUI (File > Preferences > Extensions) or via VBoxManage extpack install <.vbox-extpack>, make sure you have a toolkit like Polkit to grant privileged access to VirtualBox. The installation of this extension requires root access.

Front-ends

VirtualBox comes with three front-ends:

If you want to use VirtualBox with the regular GUI, use VirtualBox.
If you want to launch and manage your virtual machines from the command-line, use the VBoxSDL command, which only provides a plain window for the virtual machine without any overlays.
If you want to use VirtualBox without running any GUI (e.g. on a server), use the VBoxHeadless command. With the VRDP extension you can still remotely access the displays of your virtual machines.

A security feature in Wayland (i.e. when using GDM) disallows VirtualBox to grab all keyboard input. This is annoying when you want to pass window manager shortcuts to your guest operating system. It can be bypassed by whitelisting VirtualBox:

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

The first command will show if any other applications are already whitelisted. If so, add 'VirtualBox Machine' to that list, rather than having it as the only one.

Finally, you can also use phpVirtualBox to administrate your virtual machines via a web interface.

Refer to the VirtualBox manual to learn how to create virtual machines.

Warning: If you intend to store virtual disk images on a Btrfs file system, before creating any images, you should consider disabling copy-on-write for the destination directory of these images.

Installation steps for Arch Linux guests

See VirtualBox/Install Arch Linux as a guest.

Virtual disks management

Formats supported by VirtualBox

VirtualBox supports the following virtual disk formats:

VDI: The Virtual Disk Image is the VirtualBox own open container used by default when you create a virtual machine with VirtualBox.
VMDK: The Virtual Machine Disk has been initially developed by VMware for their products. The specification was initially closed source, but has since become an open format which is fully supported by VirtualBox. This format offers the ability to be split into several 2GB files. This feature is especially useful if you want to store the virtual machine on machines which do not support very large files. Other formats, excluding the HDD format from Parallels, do not provide such an equivalent feature.
VHD: The Virtual Hard Disk is the format used by Microsoft in Windows Virtual PC and Hyper-V. If you intend to use any of these Microsoft products, you will have to choose this format.

Tip: Since Windows 7, this format can be mounted directly without any additional application.

VHDX (read only): This is the eXtended version of the Virtual Hard Disk format developed by Microsoft, which has been released on 2012-09-04 with Hyper-V 3.0 coming with Windows Server 2012. This new version of the disk format does offer enhanced performance (better block alignment), larger blocks size, and journal support which brings power failure resiliency. VirtualBox should support this format in read only.
HDD (version 2): The HDD format is developed by Parallels Inc and used in their hypervisor solutions like Parallels Desktop for Mac. Newer versions of this format (i.e. 3 and 4) are not supported due to the lack of documentation for this proprietary format.
Note: There is currently a controversy regarding the support of the version 2 of the format. While the official VirtualBox manual only reports the second version of the HDD file format as supported, Wikipedia's contributors are reporting the first version may work too. Help is welcome if you can perform some tests with the first version of the HDD format.
QED: The QEMU Enhanced Disk format is an old file format for QEMU, another free and open source hypervisor. This format was designed from 2010 in a way to provide a superior alternative to QCOW2 and others. This format features a fully asynchronous I/O path, strong data integrity, backing files, and sparse files. QED format is supported only for compatibility with virtual machines created with old versions of QEMU.
QCOW: The QEMU Copy On Write format is the current format for QEMU. The QCOW format does support zlib-based transparent compression and encryption (the latter is flawed and is not recommended). QCOW is available in two versions: QCOW and QCOW2. QCOW2 tends to supersede the first one. QCOW is currently fully supported by VirtualBox. QCOW2 comes in two revisions: QCOW2 0.10 and QCOW2 1.1 (which is the default when you create a virtual disk with QEMU). VirtualBox does not support QCOW2.
OVF: The Open Virtualization Format is an open format which has been designed for interoperability and distributions of virtual machines between different hypervisors. VirtualBox supports all revisions of this format via the VBoxManage import/export feature but with known limitations.
RAW: This is the mode when the virtual disk is exposed directly to the disk without being contained in a specific file format container. VirtualBox supports this feature in several ways: converting RAW disk to a specific format, or by cloning a disk to RAW, or by using directly a VMDK file which points to a physical disk or a simple file.

Disk image format conversion

VBoxManage clonehd can be used to convert between VDI, VMDK, VHD and RAW.

$ VBoxManage clonehd inputfile outputfile --format outputformat

For example to convert VDI to VMDK:

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

QCOW

VirtualBox does not support QEMU's QCOW2 disk image format. To use a QCOW2 disk image with VirtualBox you therefore need to convert it, which you can do with qemu-img. qemu-img can convert QCOW to / from VDI, VMDK, VHDX, RAW and various other formats (which you can see by running qemu-img --help).

$ qemu-img convert -O output_fmt inputfile outputfile

For example to convert QCOW2 to VDI:

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

Tip: The -p parameter is used to get the progression of the conversion task.

There are two revisions of QCOW2: 0.10 and 1.1. You can specify the revision to use with -o compat=revision.

Mount virtual disks

VDI

Mounting VDI images only works with fixed size images (a.k.a. static images); dynamic (dynamically size allocating) images are not easily mountable.

The offset of the partition (within the VDI) is needed, then add the value of offData to 32256 (e.g. 69632 + 32256 = 101888):

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

The storage can now be mounted with:

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

For VDI disks with more partitions you can also use losetup:

# losetup -o $offData -Pf

After this you should find the partitions under /dev/loop* (e.g. /dev/loop0p1). Then you can mount them as usual (e.g. mount mount /dev/loop0p1 /mnt/).

You can also use mount.vdi script that, which you can use as (install script itself to /usr/bin/):

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

Alternately you can use the nbd kernel module and qemu-nbd from qemu-img[2]:

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

And then to unmount:

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

If the partition nodes are not propagated try using partprobe /dev/nbd0; otherwise, a VDI partition can be mapped directly to a node by: qemu-nbd -P 1 -c /dev/nbd0 storage.vdi.

Another way is to use vdfuse^AUR:

# vdfuse -a -f storage.vdi mountpoint1

which mounts the disk in mountpoint1 with the PartitionN naming format. Each partition can then be loop-mounted in mountpoint2:

# mount -o loop mountpoint1/PartitionN mountpoint2

VHD

Like VDI, VHD images can be mounted with QEMU's nbd module:

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

To unmount:

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

Compact virtual disks

Compacting virtual disks only works with .vdi files and basically consists of the following steps.

Boot your virtual machine and remove all bloat manually or by using cleaning tools like bleachbit which is available for Windows systems too.

Wiping free space with zeroes can be achieved with several tools:

If you were previously using Bleachbit, check the checkbox System > Free disk space in the GUI, or use bleachbit -c system.free_disk_space in CLI;
On UNIX-based systems, by using dd or preferably dcfldd^AUR (see here to learn the differences):

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

When fillfile reaches the limit of the partition, you will get a message like 1280 blocks (5120Mb) written.dcfldd:: No space left on device. This means that all of the user-space and non-reserved blocks of the partition will be filled with zeros. Using this command as root is important to make sure all free blocks have been overwritten. Indeed, by default, when using partitions with ext filesystem, a specified percentage of filesystem blocks is reserved for the super-user (see the -m argument in the mkfs.ext4 man pages or use tune2fs -l to see how much space is reserved for root applications).

When the aforementioned process has completed, you can remove the file fillfile you created.

On Windows, there are two tools available:
- sdelete from the Sysinternals Suite, type sdelete -s -z c:, where you need to reexecute the command for each drive you have in your virtual machine;
- or, if you love scripts, there is a PowerShell solution, but which still needs to be repeated for all drives.

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

Note: This script must be run in a PowerShell environment with administrator privileges. By default, scripts cannot be run, ensure the execution policy is at least on RemoteSigned and not on Restricted. This can be checked with Get-ExecutionPolicy and the required policy can be set with Set-ExecutionPolicy RemoteSigned.

Once the free disk space have been wiped, shut down your virtual machine.

The next time you boot your virtual machine, it is recommended to do a filesystem check.

On UNIX-based systems, you can use fsck manually;
- On GNU/Linux systems, and thus on Arch Linux, you can force a disk check at boot thanks to a kernel boot parameter;
On Windows systems, you can use:
- either chkdsk c: /F where c: needs to be replaced by each disk you need to scan and fix errors;
- or FsckDskAll from here which is basically the same software as chkdsk, but without the need to repeat the command for all drives;

Now, remove the zeros from the .vdi file with VBoxManage modifyhd:

$ VBoxManage modifyhd your_disk.vdi --compact

Note: If your virtual machine has snapshots, you need to apply the above command on each .vdi files you have.

TRIM

VirtualBox offers simulation of TRIM in VDI files via an experimental "discard" attachment option. This option is undocumented and can be accessed by commandline or .vbox file editing. When enabled, TRIM commands from the guest operating system causes the corresponding part of the VDI file to be compacted away.

Warning: Using this option without Host I/O Cache is known to cause lockups.

Increase virtual disks

General procedure

If you are running out of space due to the small hard drive size you selected when you created your virtual machine, the solution adviced by the VirtualBox manual is to use VBoxManage modifyhd. However this command only works for VDI and VHD disks and only for the dynamically allocated variants. If you want to resize a fixed size virtual disk disk too, read on this trick which works either for a Windows or UNIX-like virtual machine.

First, create a new virtual disk next to the one you want to increase:

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

where size is in MiB, in this example 10000MiB ~= 10GiB, and new.vdi is name of new hard drive to be created.

Note: By default, this command uses the Standard (corresponding to dynamic allocated) file format variant and thus will not use the same file format variant as your source virtual disk. If your old.vdi has a fixed size and you want to keep this variant, add the parameter --variant Fixed.

Next, the old virtual disk needs to be cloned to the new one which this may take some time:

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

Detach the old hard drive and attach new one, replace all mandatory italic arguments by your own:

$ 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

To get the storage controller name and the port number, you can use the command VBoxManage showvminfo virtual_machine_name. Among the output you will get such a result (what you are looking for is in italic):

[...]
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)
[...]

Download GParted live image and mount it as a virtual CD/DVD disk file, boot your virtual machine, increase/move your partitions, umount GParted live and reboot.

Note: On GPT disks, increasing the size of the disk will result in the backup GPT header not being at the end of the device. GParted will ask to fix this, click on Fix both times. On MBR disks, you do not have such a problem as this partition table as no trailer at the end of the disk.

Finally, unregister the virtual disk from VirtualBox and remove the file:

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

Increasing the size of VDI disks

If your disk is a VDI one, run:

$ VBoxManage modifymedium disk your_virtual_disk.vdi --resize the_new_size

Then jump back to the Gparted step, to increase the size of the partition on the virtual disk.

Replace a virtual disk manually from the .vbox file

If you think that editing a simple XML file is more convenient than playing with the GUI or with VBoxManage and you want to replace (or add) a virtual disk to your virtual machine, in the .vbox configuration file corresponding to your virtual machine, simply replace the GUID, the file location and the format to your needs:

ArchLinux_vm.vbox

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

then in the <AttachedDevice> sub-tag of <StorageController>, replace the GUID by the new one.

ArchLinux_vm.vbox

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

Note: If you do not know the GUID of the drive you want to add, you can use the VBoxManage showhdinfo file. If you previously used VBoxManage clonehd to copy/convert your virtual disk, this command should have outputted the GUID just after the copy/conversion completed. Using a random GUID does not work, as each UUID is stored inside each disk image.

Transfer between Linux host and other operating system

The information about path to harddisks and the snapshots is stored between <HardDisks> .... </HardDisks> tags in the file with the .vbox extension. You can edit them manually or use this script where you will need change only the path or use defaults, assumed that .vbox is in the same directory with a virtual harddisk and the snapshots folder. It will print out new configuration to 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"

Note:

If you will prepare virtual machine for use in Windows host then in the path name end you should use backslash \ instead of / .
The script detects snapshots by looking for { in the file name.
To make it run on a new host you will need to add it first to the register by clicking on Machine -> Add... or use hotkeys Ctrl+A and then browse to .vbox file that contains configuration or use command line VBoxManage registervm filename.vbox

Clone a virtual disk and assigning a new UUID to it

UUIDs are widely used by VirtualBox. Each virtual machines and each virtual disk of a virtual machine must have a different UUID. When you launch a virtual machine in VirtualBox, VirtualBox will keep track of all UUIDs of your virtual machine instance. See the VBoxManage list to list the items registered with VirtualBox.

If you cloned a virtual disk manually by copying the virtual disk file, you will need to assign a new UUID to the cloned virtual drive if you want to use the disk in the same virtual machine or even in another (if that one has already been opened, and thus registered, with VirtualBox).

You can use this command to assign a new UUID to a virtual disk:

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

Tip: To avoid copying the virtual disk and assigning a new UUID to your file manually you can use VBoxManage clonehd.

Note: The commands above support all virtual disk formats supported by VirtualBox.

Tips and tricks

Import/export VirtualBox virtual machines from/to other hypervisors

If you plan to use your virtual machine on another hypervisor or want to import in VirtualBox a virtual machine created with another hypervisor, you might be interested in reading the following steps.

Remove additions

Guest additions are available in most hypervisor solutions: VirtualBox comes with the Guest Additions, VMware with the VMware Tools, Parallels with the Parallels Tools, etc. These additional components are designed to be installed inside a virtual machine after the guest operating system has been installed. They consist of device drivers and system applications that optimize the guest operating system for better performance and usability by providing these features.

If you have installed the additions to your virtual machine, please uninstall them first. Your guest, especially if it is using an operating system from the Windows family, might behave weirdly, crash or even might not boot at all if you are still using the specific drivers in another hypervisor.

Use the right virtual disk format

This step will depend on the ability to convert the virtual disk image directly or not.

Automatic tools

Some companies provide tools which offer the ability to create virtual machines from a Windows or GNU/Linux operating system located either in a virtual machine or even in a native installation. With such a product, you do not need to apply this and the following steps and can stop reading here.

Parallels Transporter which is non free, is a product from Parallels Inc. This solution basically consists in an piece of software called agent that will be installed in the guest you want to import/convert. Then, Parallels Transporter, which only works on OS X, will create a virtual machine from that agent which is contacted either by USB or Ethernet network.
VMware vCenter Converter which is free upon registration on the VMware webiste, works nearly the same way as Parallels Transporter, but the piece of software that will gather the data to create the virtual machine only works on a Windows platform.

Manual conversion

First, familiarize yourself with the formats supported by VirtualBox and those supported by third-party hypervisors.

Importing or exporting a virtual machine from/to a VMware solution is not a problem at all if you use the VMDK or OVF disk format, otherwise converting VMDK to VDI and VDI to VMDK is possible and the aforementioned VMware vCenter Converter tool is available.
Importing or exporting from/to QEMU is not a problem neither: some QEMU formats are supported directly by VirtualBox and conversion between QCOW2 to VDI and VDI to QCOW2 is still available if needed.
Importing or exporting from/to Parallels hypervisor is the hardest way: Parallels does only support its own HDD format (even the standard and portable OVF format is not supported!).

To export your virtual machine to Parallels, you will need to use the Parallels Transporter tool described above.
To import your virtual machine to VirtualBox, you will need to use the VMware vCenter Converter described above to convert the virtual machine to the VMware format first. Then, apply the solution to migrate from VMware.

Create the virtual machine configuration for your hypervisor

Each hypervisor have their own virtual machine configuration file: .vbox for VirtualBox, .vmx for VMware, a config.pvs file located in the virtual machine bundle (.pvm file), etc. You will have thus to recreate a new virtual machine in your new destination hypervisor and specify its hardware configuration as close as possible as your initial virtual machine.

Pay a close attention to the firmware interface (BIOS or UEFI) used to install the guest operating system. While an option is available to choose between these 2 interfaces on VirtualBox and on Parallels solutions, on VMware, you will have to add manually the following line to your .vmx file.

ArchLinux_vm.vmx

firmware = "efi"

Finally, ask your hypervisor to use the existing virtual disk you have converted and launch the virtual machine.

Tip:

On VirtualBox, if you do not want to browse the whole GUI to find the right location to add your new virtual drive device, you can Replace a virtual disk manually from the .vbox file, or use the VBoxManage storageattach described in #Increasing the size of VDI disks or in the VirtualBox manual page.
Similarly, in VMware products, you can replace the location of the current virtual disk location by adapting the .vmdk file location in your .vmx configuration file.

Virtual machine launch management

Starting virtual machines with a service (autostart)

Find hereafter the implementation details of a systemd service that will be used to consider a virtual machine as a service.

/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

Note:

Replace username with a user that is a member of the vboxusers group. Make sure the user chosen is the same user that will create/import virtual machines, otherwise the user will not see the virtual machine appliances.
Replace startmode with a virtual machine frontend type, usually gui, headless or separate
Replace stopmode with desired state switch, usually savestate or acpipowerbutton

Note: If you have multiple virtual machines managed by Systemd and they are not stopping properly, try to add KillMode=none and TimeoutStopSec=40 at the end of [Service] section.

Enable the vboxvmservice@your_virtual_machine_name systemd unit in order to launch the virtual machine at next boot. To launch it directly, simply start the systemd unit.

VirtualBox 4.2 introduces a new way for UNIX-like systems to have virtual machines started automatically, other than using a systemd service.

Starting virtual machines with a keyboard shortcut

It can be useful to start virtual machines directly with a keyboard shortcut instead of using the VirtualBox interface (GUI or CLI). For that, you can simply define key bindings in .xbindkeysrc. Please refer to Xbindkeys for more details.

Example, using the Fn key of a laptop with an unused battery key (F3 on the computer used in this example):

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

Note: If you have a space in the name of your virtual machine, then enclose it with single apostrophes like made in the example just above.

Use specific device in the virtual machine

Using USB webcam / microphone

Note: You will need to have VirtualBox extension pack installed before following the steps below. See #Extension pack for details.

Make sure the virtual machine is not running and your webcam / microphone is not being used.
Bring up the main VirtualBox window and go to settings for Arch machine. Go to USB section.
Make sure "Enable USB Controller" is selected. Also make sure that "Enable USB 2.0 (EHCI) Controller" is selected too.
Click the "Add filter from device" button (the cable with the '+' icon).
Select your USB webcam/microphone device from the list.
Now click OK and start your virtual machine.

Note: If your Microphone does not show up in the "Add filter from device" menu, try the USB 3.0 and 1.1 options instead (In Step 3).

Detecting web-cams and other USB devices

Note: This will not do much if you are running a Linux/Unix operating system inside of your virtual machine, as most do not have autodetection features.

If the device that you are looking for does not show up on any of the menus in the section above and you have tried all three USB controller options, boot up your virtual machine three separate times. Once using the USB 1.1 controller, another using the USB 2.0 controller, etc. Leave the virtual machine running for at least 5 minutes after startup. Sometimes Windows will autodetect the device for you. Be sure you filter any devices that are not a keyboard or a mouse so they do not start up at boot. This ensures that Windows will detect the device at start-up.

Access a guest server

To access Apache server on a Virtual Machine from the host machine only, simply execute the following lines on the 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

where 8888 is the port the host should listen on and 80 is the port the virtual machine will send Apache's signal on.

To use a port lower than 1024 on the host machine, changes need to be made to the firewall on that host machine. This can also be set up to work with SSH or any other services by changing "Apache" to the corresponding service and ports.

Note: pcnet refers to the network card of the virtual machine. If you use an Intel card in your virtual machine settings, change pcnet to e1000.

To communicate between the VirtualBox guest and host using ssh, the server port must be forwarded under Settings > Network. When connecting from the client/host, connect to the IP address of the client/host machine, as opposed to the connection of the other machine. This is because the connection will be made over a virtual adapter.

D3D acceleration in Windows guests

Recent versions of Virtualbox have support for accelerating OpenGL inside guests. This can be enabled with a simple checkbox in the machine's settings, right below where video ram is set, and installing the Virtualbox guest additions. However, most Windows games use Direct3D (part of DirectX), not OpenGL, and are thus not helped by this method. However, it is possible to gain accelerated Direct3D in your Windows guests by borrowing the d3d libraries from Wine, which translate d3d calls into OpenGL, which is then accelerated. These libraries are now part of Virtualbox guest additions software.

After enabling OpenGL acceleration as described above, reboot the guest into safe mode (press F8 before the Windows screen appears but after the Virtualbox screen disappears), and install Virtualbox guest additions, during install enable checkbox "Direct3D support". Reboot back to normal mode and you should have accelerated Direct3D.

Note:

This hack may or may not work for some games depending on what hardware checks they make and what parts of D3D they use.
This was tested on Windows XP, 7 and 8.1. If method does not work on your Windows version please add data here.

VirtualBox on a USB key

When using VirtualBox on a USB key, for example to start an installed machine with an ISO image, you will manually have to create VDMKs from the existing drives. However, once the new VMDKs are saved and you move on to another machine, you may experience problems launching an appropriate machine again. To get rid of this issue, you can use the following script to launch VirtualBox. This script will clean up and unregister old VMDK files and it will create new, proper VMDKs for you:

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

Reason: The following script parses the output of ls, which is very brittle and known to break. (Discuss in Talk:VirtualBox)

#!/bin/sh
# Erase old VMDK entries
rm ~/.VirtualBox/*.vmdk

# Clean up VBox-Registry
sed -i '/sd/d' ~/.VirtualBox/VirtualBox.xml

# Remove old harddisks from existing machines
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

# Delete prev-files created by VirtualBox
find  ~/.VirtualBox/Machines -name \*-prev -exec rm '{}' \;

# Recreate 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)

    # determine whether drive is mounted already
    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

# Start VirtualBox
VirtualBox

Note that your user has to be added to the "disk" group to create VMDKs out of existing drives.

Run a native Arch Linux installation inside VirtualBox

If you have a dual boot system between Arch Linux and another operating system, it can become tedious to switch back and forth if you need to work in both. You may also experience performance or compatibility issues when using a virtual machine, which can impact your ability to do certain tasks.

This guide will let you reuse, in a virtual machine, your native Arch Linux installation when you are running your second operating system. This way, you keep the ability to run each operating system natively, but have the option to run your Arch Linux installation inside a virtual machine.

Make sure you have a persistent naming scheme

Depending on your hard drive setup, device files representing your hard drives may appear differently when you will run your Arch Linux installation natively or in virtual machine. This problem occurs when using FakeRAID for example. The fake RAID device will be mapped in /dev/mapper/ when you run your GNU/Linux distribution natively, while the devices are still accessible separately. However, in your virtual machine, it can appear without any mapping in /dev/sdaX for example, because the drivers controlling the fake RAID in your host operating system (e.g. Windows) are abstracting the fake RAID device.

To circumvent this problem, we will need to use an addressing scheme that is persistent to both systems. This can be achieved using UUIDs. Make sure your boot loader and fstab file is using UUIDs, otherwise fix this issue. Read fstab and Persistent block device naming.

Warning:

Make sure your host partition is only accessible in read only from your Arch Linux virtual machine, this will avoid risk of corruptions if you were to corrupt that host partition by writing on it due to lack of attention.
You should NEVER allow VirtualBox to boot from the entry of your second operating system, which, as a reminder, is used as the host for this virtual machine! Take thus a special care especially if your default boot loader/boot manager entry is your other operating system. Give a more important timeout or put it below in the order of preferences.

Make sure your mkinitcpio image is correct

Make sure your mkinitcpio configuration uses the HOOK block:

/etc/mkinitcpio.conf

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

If it is not present, add it and regenerate the initramfs.

Create a virtual machine configuration to boot from the physical drive

Create a raw disk .vmdk image

Now, we need to create a new virtual machine which will use a RAW disk as virtual drive, for that we will use a ~ 1Kio VMDK file which will be mapped to a physical disk. Unfortunately, VirtualBox does not have this option in the GUI, so we will have to use the console and use an internal command of VBoxManage.

Boot the host which will use the Arch Linux virtual machine. The command will need to be adapted according to the host you have.

On a GNU/Linux host