
=== OVMF OVERVIEW ===

The Open Virtual Machine Firmware (OVMF) project aims
to support firmware for Virtual Machines using the edk2
code base.  More information can be found at:

http://sourceforge.net/apps/mediawiki/tianocore/index.php?title=OVMF

=== STATUS ===

Current status: Alpha

Current capabilities:
* IA32 and X64 architectures
* QEMU (0.9.1 or later)
  - Video, keyboard, IDE, CD-ROM, serial
  - Runs UEFI shell
  - Optional NIC support.  Requires QEMU (0.12.2 or later)
* UEFI Linux has booted (but is not stable)

=== FUTURE PLANS ===

* Stabilize UEFI Linux boot
* Test/Stabilize UEFI Self-Certification Tests (SCT) results

=== BUILDING OVMF ===

Pre-requisites:
* Build environment capable of build the edk2 MdeModulePkg.
* A properly configured ASL compiler:
  - Intel ASL compiler: Available from http://www.acpica.org
  - Microsoft ASL compiler: Available from http://www.acpi.info

Update Conf/target.txt ACTIVE_PLATFORM for OVMF:
                             PEI arch   DXE arch   UEFI interfaces
* OvmfPkg/OvmfPkgIa32.dsc      IA32       IA32           IA32
* OvmfPkg/OvmfPkgIa32X64.dsc   IA32       X64            X64
* OvmfPkg/OvmfPkgX64.dsc       X64        X64            X64

Update Conf/target.txt TARGET_ARCH based on the .dsc file:
                             TARGET_ARCH
* OvmfPkg/OvmfPkgIa32.dsc     IA32
* OvmfPkg/OvmfPkgIa32X64.dsc  IA32 X64
* OvmfPkg/OvmfPkgX64.dsc      X64

Following the edk2 build process, you will find the OVMF binaries
under the $WORKSPACE/Build/*/*/FV directory.  The actual path will
depend on how your build is configured.  You can expect to find
these binary outputs:
* OVMF.FD
  - Please note!  This filename has changed.  Older releases used OVMF.Fv.
* OvmfVideo.rom

More information on building OVMF can be found at:

http://sourceforge.net/apps/mediawiki/tianocore/index.php?title=How_to_build_OVMF

=== RUNNING OVMF on QEMU ===

* QEMU 0.9.1 or later is required.
* Either copy, rename or symlink OVMF.FD => bios.bin
* Either copy, rename or symlink OvmfVideo.rom => vgabios-cirrus.bin
* Be sure to use qemu-system-x86_64, if you are using and X64 firmware.
  (qemu-system-x86_64 works for the IA32 firmware as well, of course.)
* Use the QEMU -L parameter to specify the directory where the bios.bin
  and vgabios-cirrus.bin files are located.
* Optionally you can use the QEMU -serial command to capture the
  OVMF debug messages.  For example: -serial file:serial.log
* The EFI shell is built into OVMF builds at this time, so it should
  run automatically if a UEFI boot application is not found on the
  removable media.
* On Linux, newer version of QEMU may enable KVM feature, and this might
  cause OVMF to fail to boot.  The QEMU '-no-kvm' may allow OVMF to boot.

=== Build Scripts ===

On systems with the bash shell you can use OvmfPkg/build.sh to simplify
building and running OVMF.

So, for example, to build + run OVMF X64:
$ OvmfPkg/build.sh -a X64
$ OvmfPkg/build.sh -a X64 qemu

And to run a 64-bit UEFI bootable ISO image:
$ OvmfPkg/build.sh -a X64 qemu -cdrom /path/to/disk-image.iso

To build a 32-bit OVMF without debug serial messages using GCC 4.5:
$ OvmfPkg/build.sh -a IA32 -b RELEASE -t GCC45

=== Network Support ===

To add network drivers to OVMF:

* Download UEFI drivers for the e1000 NIC
  - http://downloadcenter.intel.com/Detail_Desc.aspx?agr=Y&DwnldID=17515&lang=eng
  - Install the drivers into a directory called Intel3.5 in your WORKSPACE

* Include the drivers in OVMF during the build:
  - Add '-D NETWORK_ENABLE' to your build command
  - For example: build -D NETWORK_ENABLE

* Use the QEMU -net parameter to enable NIC support.
  - QEMU does not support UEFI DHCP or UEFI PXE Boot, so long timeouts will
    occur when NICs are enabled.  The long timeouts can be avoided by
    interrupts the boot sequence by pressing a key when the logo appears.
  - Example: Enable e1000 NIC with a DHCP server and restrict packet
    forwarding:
    -net nic,model=e1000 -net user,restrict=yes -net user,dhcpstart=10.0.2.10
  - Example: Enable e1000 NIC with a DHCP server, restrict packet forwarding,
    and generate PCAP file:
    -net nic,model=e1000 -net user,restrict=yes -net user,dhcpstart=10.0.2.10
    -net dump,file=a.pcap
  - Example: Enable 2 e1000 NICs with a DHCP server and restrict
    packet forwarding:
    -net nic,model=e1000,addr=3 -net nic,model=e1000,addr=4
    -net user,restrict=yes -net user,dhcpstart=10.0.2.10

