Plex86

It is a very lightweight x86 virtualization strategy which executes
x86 code as-is, but inside a virtualization container. It does not
use any dynamic translation nor dynamic code scanning techniques to
deal with unvirtualizable x86 instructions. But rather executes only
code which is virtualizable by nature. As well, this new architecture
does not model the IO hardware.

The x86 ISA (Instruction Set Architecture) is not 100% virtualizable,
especially with respect to system code. To build an x86 VM which can
execute arbitrary binary-only OSes and related software on current
x86 hardware requires a lot of software complexity to overcome the
unvirtualizability of the x86 ISA. And would also require that
reasonably complete IO modeling be implemented, as the guest OS
executing within the VM needs to drive a distinct set of hardware
which can not conflict with the host hardware.

But Linux (and perhaps other OSes) require extremely few modifications
to make it execute within the plex86 VM, and can be configured easily
to trim out unnecessary IO hardware and CPU support which would otherwise
require a heavy VM. What remains is a very lightweight and highly
virtualized Linux VM resource which is completely untied from the
host hardware. And in fact, rather than model IO hardware for
functions such as networking/disk/console, special Linux guest drivers
communicate packets from the guest to the host via a HAL (Hardware
Abstraction Layer). This makes the VM very simplistic and abstracted
from IO hardware. It can also be more efficient, as no IO emulation
is necessary.

One of the ways that plex86 achieves this simple strategy is that
it executes kernel code at user privilige where many system instructions
will naturally generate exceptions and can be monitored.

The modifications to Linux necessary to make it VM'able within plex86
actually only affect the Makefiles, adding an extra compile option
which forces the inclusion of an assembly macro file. This file
redefines the meaning of a few instructions, notably PUSHF/POPF, because
their behaviour with respect to the interrupt flag is broken.

Another use of this lightweight style x86 virtualization is to accelerate
an x86 emulator (like bochs), for those parts of execution (for
example application code) where heavy virtualization is not necessary.
Execution of system code and IO can be left to the emulator to handle.