Hypervisor

A hypervisor is a software technology used in virtualization, which allows several operating systems to run side-by-side on a given piece of hardware.

Unlike conventional virtual-computing programs, a hypervisor runs directly on the target hardware’s “bare metal,” instead of as a program in another operating system. This allows both the guest OSes and the hypervisor to perform that much more efficiently.

Hypervisor Methodology
Hypervisor History
Major Hypervisors
• Xen
• KVM
• VMware ESX / vmkernel
• Microsoft Hyper-V
• PowerVM
• Logical Domains / Oracle VM
• Wind River Hypervisor
Hypervisor Variant: Container-based virtualization

Hypervisor Methodology

When running, it presents all of the OSes that run on top of it—the “guests”—with a virtualized version of all the system’s hardware. This way, the guests cannot access hardware directly, and so any problems caused by one OS’s programs (or even by the OS itself) are isolated from any other OS.

Virtualization requires some degree of hardware support to be practical. Commodity desktop systems with Intel/AMD processors, for instance, had trouble running OSes in hypervisors because the processor-level features that made such things viable didn’t exist. It was possible to run hypervisors on those processors, just not efficiently, and the guest OSes had to be modified to be hypervisor-aware. Modified versions of Linux and Windows, for instance, were originally created to run on top of the Xen hypervisor infrastructure. Both Intel and AMD have since added instruction sets to their x86- and x64-family processors that allow hypervisors to run efficiently, and many OSes (including Windows) have since natively added features to make them “hypervisor-aware.”

Hypervisors can also offer their guests a technique known as paravirtualization to accelerate performance, where the operating system talks directly to the hypervisor—not to the emulated hardware—to accomplish certain functions. Again, paravirtualization only works if the guest OS is hypervisor-aware, although as of late most commercial operating systems (Windows, Linux, etc.) ship with some variety of native support for running as a hypervisor guest.

Mark Hermeling of Wind River has categorized hypervisors into “Type 1” and “Type 2” products—the former being something like Xen, which runs directly on bare metal, and the latter being something like VMware, which runs within the main OS. His opinion is that the difference between the two is steadily being eroded by advances in hardware and operating-system technology.

Hypervisor History

The first commercial computer system that could run a hypervisor was IBM System/360 line of mainframes, vintage 1966, which had hardware-level support for preserving and restoring the machine’s state. This function was crucial to the way a hypervisor worked,

IBM had tinkered with the idea before in its experimental CP-40 system; with the System/360, the idea went public, although they didn’t at first provide end-user support for it. By 1972, IBM supported virtualization via their VM/370 operating system, although they didn’t expect VM to be as successful as it turned out to be.

In time, VM—and its modern successor, z/VM—became an elegant way for IBM customers to run AIX, Linux and other operating systems side by side on the same hardware.

The current crop of hypervisors run on commodity hardware—the x86/x64 processor family, as opposed to specialized server hardware. Some of this is again due to the fact that processor architecture makes virtualization all the easier, but some of it is due to the way various hypervisor technologies were developed in the open source domain (e.g., Xen and KVM), making it that much easier for their technologies to be used all the more broadly.

Major Hypervisors

Xen

Originally developed as a research project at the University of Cambridge, Xen is now a product of Citrix after they acquired XenSource, Inc., the company that was created to continue its support and development. The project continues to be open source under Citrix.

Xen allows an initial operating system to boot and run as “domain 0,” or a sort of privileged guest. The domain 0 OS, typically a Linux or UNIX variant, can talk directly to the system hardware (where the other guests generally cannot) and also talk directly to the hypervisor itself (ditto).

Many versions of Linux have built-in support for Xen as both the domain 0 OS and a guest: Debian (“Etch” and later releases), Novell SUSE Enterprise Linux (version 10 and later), Red Hat Enterprise Linux 5 (and Red Hat Fedora version 7) and later, and Solaris. All of these OSes and more can be run as guests, including Microsoft Windows, for which special drivers have been created to improve Windows’s performance as a guest.

Among Xen’s major features are the ability to live-migrate guests between physical hosts connected across a LAN. The guest OS can run almost entirely interrupted during the migration.

KVM

An acronym for “kernel-based virtual machine,” KVM is a kernel-level extension to Linux (as of kernel revision 2.6.20) that allows an instance of Linux to run other OSes, via hardware-assisted virtualization. KVM has also been ported to FreeBSD, allowing that OS to run as a host as well.

KVM itself doesn’t perform emulation. It simply provides an interface for programs that do—for instance, QEMU, which KVM uses to perform the actual emulation for guest OSes. OSes that can run under QEMU (including Microsoft Windows) can run as KVM guests.

VMware ESX / vmkernel

One of VMware’s server-level offerings, ESX uses a Linux kernel outfitted with VMware’s vmkernel add-on as both a hypervisor and initial virtual machine. Under ESX, guests should be able to run without any modification, although VMware provides device drivers for many common OSes to allow the guests to run that much more efficiently.

Another version of ESX, ESXi, has a smaller local footprint (leaving more room for guests), but can only be accessed through a remote service console. ESX installs a full local instance of Linux for management, but takes up that much more resources.

Microsoft Hyper-V

Hyper-V is Microsoft’s own hypervisor technology, available either as a free standalone product or as a component of Microsoft Windows Server 2008 R2. It uses a core instance of Windows Server as a “parent partition” (similar to Xen’s “domain 0”), with guests running in “child partitions.”

Most every current native Windows operating system, including Windows 7 (although not Windows 7 Home), run natively as guests in Hyper-V. Support for Linux as a guest is also available via the Linux Integration Components.

PowerVM

IBM’s virtualization technology, created and sold specifically for their POWER5/6/7 line of servers, and which supports IBM’s own AIX and Linux as guests. Three editions exist for different levels of usage: Express (only thee guests), Standard, and Enterprise (allows live migration of virtual machines to other hosts).

Logical Domains / Oracle VM

A relatively new virtualization technology offered by Sun/Oracle. Originally named Logical Domains, it’s since been rebranded as Oracle VM Server for SPARC, and exploits multithreading features specific to SPARC processors to work its magic. Solaris, Free/OpenBSD and Ubuntu Linux are among the major supported guest platforms.

Wind River Hypervisor

The Wind Rivers Hypervisor is one of a new breed of such products aimed not at servers or even desktops, but embedded devices—phones, for instance, or specialized devices such as the iPad. Most people see such devices as never hosting more than one instance of a single, specifically-designed OS; embedded-device hypervisors could allow multiple OS instances, either from the same OS provider or different ones, to exist side-by-side for the sake of testing or enhanced end-user functionality.

Hypervisor Variant: Container-based virtualization

Another virtualization variant, similar to a hypervisor system but different enough that it’s worth talking about on its own, allows the OS to present what appears to be entirely discrete instances of itself to userland applications. The terminology for these instances varies: OpenVZ, for instance, calls them “containers.” Solaris, “zones.” BSD, “jails.” This technique doesn’t directly allow for another OS to be run in such an instance—it’s meant more to provide isolation between instances for the sake of security or stability.