For the various versions of Linux that we support as host operating systems, please refer to Section 1.4, “Supported host operating systems”.
You will need to install the following packages on your Linux system before starting the installation (some systems will do this for you automatically when you install VirtualBox):
-
Qt 5.3.2 or higher (Qt 5.6.2 or higher recommended);
-
SDL 1.2.7 or higher (this graphics library is typically called
libsdlor similar).
Note
To be precise, these packages are only required if you want to
run the VirtualBox graphical user interfaces. In particular,
VirtualBox, the graphical VirtualBox
manager, requires both Qt and SDL;
VBoxSDL, our simplified GUI, requires
only SDL. By contrast, if you only want to run
VBoxHeadless, neither Qt nor SDL are
required.
In order to run other operating systems in virtual machines
alongside your main operating system, VirtualBox needs to integrate
very tightly into the system. To do this it installs a "driver"
module called vboxdrv which does
a lot of that work into the system kernel, which is the part of
the operating system which controls your processor and physical
hardware. Without this kernel module, you can still use the
VirtualBox manager to configure virtual machines, but they will not
start. It also installs network drivers called
vboxnetflt and
vboxnetadp which let virtual machines
make more use of your computer's network capabilities and are needed
for any virtual machine networking beyond the basic "NAT" mode.
Since distributing driver modules separately from the kernel
is not something which Linux supports well, we create the modules
on the system where they will be used. This usually means first
installing software packages from the distribution which are needed
for the "build" process. Normally, these will be the GNU compiler
(GCC), GNU Make (make) and packages containing "header files" for
your kernel - and making sure that all system updates are
installed and that the system is running the most up-to-date
kernel included in the distribution. The running kernel
and the header files must be updated to matching versions.
We will give some instructions for common distributions. For most
of them you will want to start by finding the version name of your
kernel using the command
uname -r in a terminal. They
assume that you have not changed too much from the original
installation, particularly not installed a different kernel type.
If you have then you will need to determine yourself what to set
up.
-
With Debian and Ubuntu-based distributions, you must install the right version of the
linux-headers, usually whichever oflinux-headers-generic,linux-headers-amd64,linux-headers-i686orlinux-headers-i686-paebest matches the kernel version name; and if it exists thelinux-kbuildpackage. Basic Ubuntu releases should have the right packages installed by default. -
On Fedora, Redhat, Oracle Linux and many other RPM-based systems, the kernel version sometimes has a code of letters or a word close to the end of the version name, for example "uek" for the Oracle Enterprise kernel or "default" or "desktop" for the standard SUSE kernels. In this case the package name is
kernel-uek-develor equivalent. If there is no such code, it is usuallykernel-devel. -
On older SUSE and openSUSE Linux, you must install the
kernel-sourceandkernel-symspackages.
If you suspect that something has gone wrong with module installation, check that your system is set up as described above and try running (as root) the following command:
rcvboxdrv setup
VirtualBox is available in a number of package formats native to various common Linux distributions (see Section 1.4, “Supported host operating systems” for details). In addition, there is an alternative generic installer (.run) which should work on most Linux distributions. The generic installer packages are built on EL5 systems and thus require reasonable old versions of glibc (version 2.5) and other system libraries.
First, download the appropriate package for your distribution.
The following examples assume that you are installing to a 32-bit
Ubuntu Wily system. Use dpkg to
install the Debian package:
sudo dpkg -i virtualbox-5.0_5.2.4_Ubuntu_wily_i386.deb
The installer will also try to build kernel modules suitable for
the current running kernel. If the build process is not successful you
will be shown a
warning and the package will be left unconfigured. Please have a look
at /var/log/vbox-install.log to find
out why the compilation failed. You may have to install the
appropriate Linux kernel headers (see Section 2.3.2, “The VirtualBox driver modules”). After correcting any problems, do
sudo rcvboxdrv setup
This will start a second attempt to build the module.
If a suitable kernel module was found in the package or the module was successfully built, the installation script will attempt to load that module. If this fails, please see Section 12.8.1, “Linux kernel module refuses to load” for further information.
Once VirtualBox has been successfully installed and configured, you can start it by selecting "VirtualBox" in your start menu or from the command line (see Section 2.3.5, “Starting VirtualBox on Linux”).
The alternative generic installer performs the following steps:
-
It unpacks the application files to the target directory,
/opt/VirtualBox/
which cannot be changed.
-
It builds the VirtualBox kernel modules (
vboxdrv,vboxnetfltandvboxnetadp) and installs them. -
It creates
/sbin/rcvboxdrv, an init script to start the VirtualBox kernel module. -
It creates a new system group called
vboxusers. -
It creates symbolic links in
/usr/binto the a shell script (/opt/VirtualBox/VBox) which does some sanity checks and dispatches to the actual executables,VirtualBox,VBoxSDL,VBoxVRDP,VBoxHeadlessandVBoxManage -
It creates
/etc/udev/rules.d/60-vboxdrv.rules, a description file for udev, if that is present, which makes the USB devices accessible to all users in thevboxusersgroup. -
It writes the installation directory to
/etc/vbox/vbox.cfg.
The installer must be executed as root with either
install or
uninstall as the first
parameter.
sudo ./VirtualBox.run install
Or if you do not have the "sudo" command available, run the following as root instead:
./VirtualBox.run install
After that you need to put every user which should be able to
access USB devices from VirtualBox guests in the group
vboxusers, either through the GUI
user management tools or by running the following command as
root:
sudo usermod -a -G vboxusers username
Note
The usermod command of some
older Linux distributions does not support the
-a option (which adds the user to
the given group without affecting membership of other groups). In
this case, find out the current group memberships with the
groups command and add all these
groups in a comma-separated list to the command line after the
-G option, e.g. like this:
usermod -G group1,group2,vboxusers
username.
If, for any reason, you cannot use the shell script installer described previously, you can also perform a manual installation. Invoke the installer like this:
./VirtualBox.run --keep --noexec
This will unpack all the files needed for installation in the
directory install under the current
directory. The VirtualBox application files are contained in
VirtualBox.tar.bz2 which you can
unpack to any directory on your system. For example:
sudo mkdir /opt/VirtualBox sudo tar jxf ./install/VirtualBox.tar.bz2 -C /opt/VirtualBox
or as root:
mkdir /opt/VirtualBox tar jxf ./install/VirtualBox.tar.bz2 -C /opt/VirtualBox
The sources for VirtualBox's kernel module are provided in the
src directory. To build the module,
change to the directory and issue
make
If everything builds correctly, issue the following command to install the module to the appropriate module directory:
sudo make install
In case you do not have sudo, switch the user account to root and perform
make install
The VirtualBox kernel module needs a device node to operate. The
above make command will tell you how to create the device node,
depending on your Linux system. The procedure is slightly different
for a classical Linux setup with a
/dev directory, a system with the now
deprecated devfs and a modern Linux
system with udev.
On certain Linux distributions, you might experience difficulties building the module. You will have to analyze the error messages from the build system to diagnose the cause of the problems. In general, make sure that the correct Linux kernel sources are used for the build process.
Note that the /dev/vboxdrv
kernel module device node must be owned by root:root and must be
read/writable only for the user.
Next, you will have to install the system initialization script for the kernel module:
cp /opt/VirtualBox/vboxdrv.sh /sbin/rcvboxdrv
(assuming
you installed VirtualBox to the
/opt/VirtualBox directory) and
activate the initialization script using the right method for your
distribution. You should create VirtualBox's configuration
file:
mkdir /etc/vbox echo INSTALL_DIR=/opt/VirtualBox > /etc/vbox/vbox.cfg
and, for convenience, create the following symbolic links:
ln -sf /opt/VirtualBox/VBox.sh /usr/bin/VirtualBox ln -sf /opt/VirtualBox/VBox.sh /usr/bin/VBoxManage ln -sf /opt/VirtualBox/VBox.sh /usr/bin/VBoxHeadless ln -sf /opt/VirtualBox/VBox.sh /usr/bin/VBoxSDL
Before updating or uninstalling VirtualBox, you must terminate any virtual machines which are currently running and exit the VirtualBox or VBoxSVC applications. To update VirtualBox, simply run the installer of the updated version. To uninstall VirtualBox, invoke the installer like this:
sudo ./VirtualBox.run uninstall
or as root
./VirtualBox.run uninstall
. Starting with version 2.2.2, you can uninstall the .run package by invoking
/opt/VirtualBox/uninstall.sh
To manually uninstall VirtualBox, simply undo the steps in the manual installation in reverse order.
The Debian packages will request some user feedback when
installed for the first time. The debconf system is used to perform
this task. To prevent any user interaction during installation,
default values can be defined. A file
vboxconf can contain the following
debconf settings:
virtualbox virtualbox/module-compilation-allowed boolean true virtualbox virtualbox/delete-old-modules boolean true
The first line allows compilation of the vboxdrv kernel module if no module was found for the current kernel. The second line allows the package to delete any old vboxdrv kernel modules compiled by previous installations.
These default settings can be applied with
debconf-set-selections vboxconf
prior to the installation of the VirtualBox Debian package.
In addition there are some common configuration options that can be set prior to the installation, described in Section 2.3.3.7, “Automatic installation options”.
The .rpm format does not provide a configuration system comparable to the debconf system. See Section 2.3.3.7, “Automatic installation options” for how to set some common installation options provided by VirtualBox.
To configure the installation process of our .deb and .rpm
packages, you can create a response file named
/etc/default/virtualbox. The
automatic generation of the udev rule can be prevented by the
following setting:
INSTALL_NO_UDEV=1
The creation of the group vboxusers can be prevented by
INSTALL_NO_GROUP=1
If the line
INSTALL_NO_VBOXDRV=1
is specified, the
package installer will not try to build the
vboxdrv kernel module if no module
fitting the current kernel was found.
The Linux installers create the system user group
vboxusers during installation. Any
system user who is going to use USB devices from VirtualBox guests must
be a member of that group. A user can be made a member of the group
vboxusers through the GUI user/group
management or at the command line with
sudo usermod -a -G vboxusers username
The easiest way to start a VirtualBox program is by running the
program of your choice (VirtualBox,
VBoxManage,
VBoxSDL or
VBoxHeadless) from a terminal. These
are symbolic links to VBox.sh that
start the required program for you.
The following detailed instructions should only be of interest if
you wish to execute VirtualBox without installing it first. You should
start by compiling the vboxdrv kernel
module (see above) and inserting it into the Linux kernel. VirtualBox
consists of a service daemon (VBoxSVC)
and several application programs. The daemon is automatically started if
necessary. All VirtualBox applications will communicate with the daemon
through Unix local domain sockets. There can be multiple daemon
instances under different user accounts and applications can only
communicate with the daemon running under the user account as the
application. The local domain socket resides in a subdirectory of your
system's directory for temporary files called
.vbox-<username>-ipc. In case of
communication problems or server startup problems, you may try to remove
this directory.
All VirtualBox applications
(VirtualBox,
VBoxSDL,
VBoxManage and
VBoxHeadless) require the VirtualBox
directory to be in the library path:
LD_LIBRARY_PATH=. ./VBoxManage showvminfo "Windows XP"