From Wikipedia, the free encyclopedia

Jump to: navigation, search
Developed by Fabrice Bellard
Latest release 0.10.1 / 2009-03-21; 16 days ago
Operating system Cross-platform
Type Emulator
License Various
Website http://www.nongnu.org/qemu/

QEMU is a processor emulator that relies on dynamic binary translation to achieve a reasonable speed while being easy to port on new host CPU architectures.

In conjunction with CPU emulation, it also provides a set of device models, allowing it to run a variety of unmodified guest operating systems, thus it can be viewed as a hosted virtual machine monitor. It also provides an accelerated mode for supporting a mixture of binary translation (for kernel code) and native execution (for user code), in the same fashion as VMware Workstation and Microsoft Virtual PC.

QEMU can also be used purely for CPU emulation for user level processes; in this mode of operation it is most similar to valgrind.

One feature exclusive to QEMU is that of portability: the virtual machines can be run on any PC, even those where the user has only Limited Rights with no Administrator access, making the 'PC-on-a-USB-stick' concept very real. Similar applications exist (such as MojoPac) but they currently require Administrator rights to run, making them useless in areas such as public libraries, internet cafes, and so on.


[edit] Licensing

QEMU was written by Fabrice Bellard and is free software. Specifically, the QEMU virtual CPU core library is released under the GNU Lesser General Public License (GNU LGPL). Many hardware device emulation sources are released under the BSD license.[1] When running on Windows, although by default it uses DirectSound, there is the option to use the proprietary FMOD library, which if used disqualifies it for a single, unified, Open Source software license.

[edit] Details

QEMU has two operating modes[2]:

User mode emulation
QEMU can launch Linux or Darwin/Mac OS X processes compiled for one CPU on another CPU. Target OS system calls are thunked for endianness and 32/64 bit mismatches. Wine Windows API reimplementation and DOSEMU are the main targets for QEMU in user mode emulation. This mode also eases cross-compilation and cross-debugging.
Complete Computer System mode emulation
QEMU emulates a full computer system, including a processor and various peripherals. It can be used to provide virtual hosting of several virtual computers on a single computer. QEMU can boot many guest operating systems, including Linux, Solaris, Microsoft Windows, DOS, and BSD [1]; it supports emulating several hardware platforms, including x86, AMD64, Alpha, ETRAX CRIS, MIPS, and SPARC.

[edit] Features

QEMU offers many features that are also present in other emulators. For example, it can save and restore the state of the virtual machine with all programs running. As with many emulators, guest operating systems do not need to be patched to successfully run.

QEMU supports the emulation of various architectures, including IA-32 (x86) PCs, AMD64 PCs, MIPS R4000, Sun's SPARC sun4m, Sun's SPARC sun4u, ARM development boards (Integrator/CP and Versatile/PB), SH4 SHIX board, PowerPC (PReP and Power Macintosh), and ETRAX CRIS architectures. The QEMU homepage provides a complete list of supported architectures.

The virtual machine can be equipped with many types of hardware. Some of these are: hard disks, CD-ROM drives, network cards, sound chips, and USB devices. USB devices can be completely emulated (mass storage from image files, input devices), or the host's USB devices can be used (however, this requires administator privileges and does not work with all devices).

Virtual hard disk images can be stored in a special format (QCOW2) that only takes up disk space that the guest OS actually uses. This way, an emulated 120 GiB disk can still take up just several hundred megabytes on the host. The QCOW2 format also allows the creation of overlay images that record the difference to another base image file which is not modified. This can be useful to have the possibility of reverting the disk's contents to an earlier state. For example, a base image could hold a fresh install of an operating system that is known to work, and the overlay images are worked with. Should the guest system be unusable (virus attack, accidental system destruction, ...), the overlay can be deleted and recreated.

QEMU can emulate network cards (of different models) which share the host system's connectivity by doing network address translation, effectively allowing the guest to use the same network as the host. The virtual network cards can also be connected to network cards of other instances of QEMU or local TAP interfaces.

It also has some features that are not present in many emulators. QEMU integrates several services to allow the host and guest systems to communicate, for example, a SMB server and network port redirection (to allow incoming connections to the virtual machine). It can also boot Linux kernels without having to prepare a bootable image with a bootloader.

QEMU does not depend on the presence of graphical output methods on the host system. It allows to access the screen of the guest OS via VNC. Operating systems that support it can also use no screen at all and use an emulated serial line instead.

Simulating multiple CPUs that can be used like a real SMP system is possible.

Unlike some other emulators, QEMU does not require administrative rights to run, except if additional kernel modules for improving speed are used (like KQEMU).

[edit] User mode emulation

QEMU is able to not just emulate a full system, but also to run a normal program that was compiled for another architecture. This is done when it cannot be recompiled because the source code is unavailable, or when the program's architecture does not permit running it under all architectures (one example is Wine[3]).

[edit] Tiny Code Generator

The Tiny Code Generator (TCG) aims to remove the shortcoming of relying on a particular version of GCC or any compiler, instead incorporating the compiler (code generator) into other tasks performed by QEMU in run-time. The whole translation task thus consists of two parts: blocks of target code (TBs) being rewritten in TCG ops - a kind of machine-independent intermediate notation, and subsequently this notation being compiled for the host's architecture by TCG. Optional optimisation passes are performed between them.

TCG requires that there be dedicated code written to support every architecture it is being run on. It also requires that the target instruction translation be rewritten to take advantage of TCG ops, instead of the previously used dyngen ops. Currently officially supported host architectures are x86 and AMD64 only, however there exists in-development code for ARM, PowerPC, SPARC, and HPPA. As of December 7, 2008, all of the supported targets have been moved over to TCG.

Starting with QEMU Version 0.10.0, TCG ships with the QEMU stable release.[4]

[edit] Accelerator

Virtualization of machines or operating systems comes at the cost of speed of execution. One tried and true method to reduce the effect (cost) are software-based drivers which perform specific functions that would otherwise be very costly to perform by the virtualization software. Two of those software programs, developed for QEMU, are KQEMU and QVM86.

[edit] KQEMU

Fabrice Bellard also wrote a Linux kernel module (with preliminary ports to FreeBSD and MS Windows) named KQEMU or QEMU Accelerator, which notably speeds up x86 emulation on x86 platforms. This is accomplished by running user mode code directly on the host computer's CPU, and using processor and peripheral emulation only for kernel mode and real mode code. KQEMU also supports a kernel emulation mode in which portions of kernel mode code run on the host's CPU.

Unlike KVM, KQEMU can execute code from many guest OSes even if the host CPU does not support hardware virtualization. KQEMU supports both x86 and x86_64 CPUs. As a future development[5] for KQEMU there are plans to support the hardware (CPU) based virtualization extensions introduced by Intel VT and AMD-V families of processors.

Also of interest is that the QEMU Accelerator, KQEMU, was initially released free of charge but was licensed as a closed-source proprietary product. However, since version 1.3.0pre10[6], released on February 5, 2007, it has been available under the GNU General Public License.

[edit] QVM86

QVM86 was a Linux kernel module to provide x86 virtualization capabilities for the QEMU emulator. Virtualization allowed "emulated" code to be run natively on the host CPU, using the CPU protection mechanisms to intercept and emulate privileged events. It was licensed under GNU GPLv2 license. It was developed as a drop-in replacement for the then closed-source KQEMU, which has since been made available under the GPL. The developer of QVM86 ceased development on January 21, 2007 as they decided that the project had been rendered obsolete by the release of VirtualBox.

[edit] Integration in other virtualization solutions

[edit] VirtualBox

In January 2007, VirtualBox was released. It uses some of QEMU's virtual hardware devices and has a built-in dynamic recompiler that is based on QEMU. As with KQEMU, it runs nearly all guest code natively on the host via the VMM (Virtual Machine Manager), and uses the recompiler only for special situations as a fallback mechanism (this holds true for guest code that executes in real mode and some other rare scenarios at runtime)[7]. In addition, VirtualBox goes through a lot of code analysis and patching via a built-in disassembler to reduce usage of the recompiler to a minimum. VirtualBox is open-source software under the GPL, except for a number of enterprise features, and standard user features like USB.

As of the 2.0.2 release (updated 2008-09-12) VirtualBox still has no support for SMP in a Guest OS. It has been confirmed by one of the developers of VirtualBox that SMP is slated to be added in a future release, but a fixed date for it can't be given.[8]

[edit] Xen-HVM

The Xen virtual machine monitor can run in HVM (hardware virtual machine) mode, using Intel VT or AMD-V hardware x86 virtualization extensions. This means that instead of paravirtualized devices, a real set of virtual hardware is exposed to the domU to use real device drivers to talk to.

QEMU includes several components: CPU emulators, emulated devices, generic devices, machine descriptions, user interface, and a debugger. The emulated devices and generic devices in QEMU make up its device models for I/O virtualization [9].

Xen-HVM has device emulation based on the QEMU project to provide I/O virtualization to the VMs. Hardware is emulated via a patched QEMU "device manager" (qemu-dm) daemon running as a backend in dom0. This means that the virtualized machines see as hardware: a PIIX3 IDE (with some rudimentary PIIX4 capabilities), Cirrus Logic or vanilla VGA emulated video, RTL8139 or NE2000 network emulation, PAE, and somewhat limited ACPI and APIC support and no SCSI emulation.[10]

[edit] Kernel-based Virtual Machine (KVM)

KVM is a Linux kernel virtualization infrastructure. By itself, it does not perform any emulation. Instead, a user-space program uses the /dev/kvm interface to set up the guest VM's address space, feed it simulated I/O and map its video display back onto the host's. At least three programs exploit KVM: a modified version of QEMU[11], QEMU itself since version 0.10.0 and, as an option, Virtualbox.

[edit] Darwine

Darwine was originally intended to support compiling of Win32 source into Mach-O/PowerPC binaries for Macintosh computers. The project shifted objectives combining Wine's program loader with QEMU in user mode emulation, to allow running of Win32 binaries on Mac OS X for PowerPC.

[edit] Win4Lin Pro Desktop

In early 2005, Win4Lin introduced Win4Lin Pro Desktop, based on a 'tuned' version of QEMU and KQEMU and it hosts NT-versions of Windows. In June 2006[12], Win4Lin released Win4Lin Virtual Desktop Server based on the same code base. Win4Lin Virtual Desktop Server serves Microsoft Windows sessions to thin clients from a Linux server.

In September 2006, Win4Lin announced a change of the company name to Virtual Bridges with the release of Win4BSD Pro Desktop, a port of the product to FreeBSD and PC-BSD. Solaris support followed in May 2007 with the release of Win4Solaris Pro Desktop and Win4Solaris Virtual Desktop Server[13].

[edit] Shortcomings

  • Incomplete support for Microsoft Windows and other host operating systems; this has improved with recent versions
  • Incomplete support for less frequently-used architectures
  • Currently only supports traditional BIOS boot model for the guest OSes, no UEFI boot model support yet on x64 systems
  • No special device drivers (graphics, sound, IO) for guests are available, thus quite large overhead for multimedia applications. For example, a Cirrus Logic graphics chip and various popular sound cards (ES1370, Sound Blaster 16, Gravis Ultrasound and AdLib) are emulated, but they do not provide hardware-accelerated performance on the host system. Also, it supports only SDL or Cocoa video output libraries although a patch for GGI support exists[14]

[edit] See also

[edit] References

[edit] External links

Personal tools