qemu-intel64

This page file describes the contents of the build configurations available for the NuttX QEMU x86_64 port.

QEMU/KVM

QEMU is a generic and open source machine emulator and virtual machine. Here are some links (which will probably be mostly outdated by the time your read this):

KVM is the Linux kernel hypervisor. It supports creations of virtual machines in Linux systems. It is usually coupled with Qemu as its I/O supporting layer.

The qemu can be build from source or downloaded from distro repositories. However, a modern CPU and KVM support are mandatory because the X2APIC is not available in pure emulator mode. This mean using this build with qemu in windows or old x86 machine can be frustrating. In such case, looks the next section and use bochs emulator instead.

Running QEMU

When you created a bootable disk, use command:

qemu-system-x86_64 -cpu host -enable-kvm -m 2G -cdrom boot.iso -nographic -serial mon:stdio

or, when option CONFIG_ARCH_PVHBOOT is set, you can use -kernel argument instead:

qemu-system-x86_64 -cpu host -enable-kvm -m 2G -kernel nuttx.elf -nographic -serial mon:stdio

This multiplex the qemu console and COM1 to your console.

Use control-a 1 and 2 to switch between. Use control-a x to terminate the emulation.

P.S. Make sure that you CPU supports the mandatory features. Look at Real machine section for more information.

For testing the PCI bus and driver layers. This QEMU configuration can be used with the pcitest NuttX configuration:

qemu-system-x86_64  -cpu host,+pcid,+x2apic,+tsc-deadline,+xsave,+rdrand --enable-kvm -smp 1 -m 2G -cdrom boot.iso --nographic -s -no-reboot -device edu -device pci-testdev

This will enable the QEMU pci-test and edu PCI test devices which test PIO, MMIO, IRQ, and DMA functions. Additionally it will show detailed information about the enumeration of the PCI bus.

If you want to boot using UEFI and TianoCore you will need to add a flag like this to point at OVMF --bios /usr/share/edk2/ovmf/OVMF_CODE.fd

Bochs

Bochs is also a generic and open source machine emulator and virtualizer. It does very comprehensive emulation of x86 platform, even the state-of-art processors. Here are some links (which will probably be mostly outdated by the time your read this):

The bochs can be build from source. Unlike qemu, it does not rely on KVM to support modern hardware features, therefore it can also be used under Windows. When building bochs, remember to enable x86-64 support with --enable-x86-64. If you also want support for SIMD instructions, enable them with --enable-avx --enable-evex.

Running Bochs

First edit/check the .bochsrc You can create one in the top-level NuttX directory or bochs will use the one in your $HOME. Remember to change the CPU model to one with mandatory features and enable the COM port.

  • Find and edit (You might adjust the IPS as you machine perform):

    cpu: model=broadwell_ult, count=1, ips=50000000, reset_on_triple_fault=0, ignore_bad_msrs=0, msrs="msrs.def"
ata0-master: type=cdrom, path="<PATH TO boot.iso>", status=inserted

  • Add:

    com1: enabled=1, mode=file, dev=com1.out

  • In the top-level NuttX directory:

    bochs

The emulator will drop into debugger mode. Enter c to start the emulation. COM port output will be in the com1.out file.

Real machine

This port can work on real x86-64 machine with a proper CPU. The mandatory CPU features are:

  • TSC DEADLINE or APIC timer or HPET

  • PCID

  • X2APIC

  • legacy serial port support or PCI serial card (AX99100 only supported now)

WARNING: IF you use TSC DEADLINE, make sure that your CPU’s TSC DEADLINE timer is not buggy!

Toolchains

Currently, only the Linux GCC toolchain is tested. While building on a modern x86_64 PC, the default system GCC can be used.

Configurations

Common Configuration Notes

  1. Each Qemu-intel64 configuration is maintained in a sub-directory and can be selected as follow:

    tools/configure.sh qemu-intel64:<subdir>

    Where <subdir> is one of the configuration sub-directories described in the following paragraph.

  2. These configurations use the mconf-based configuration tool. To change a configurations using that tool, you should:

    1. Build and install the kconfig-mconf tool. See nuttx/README.txt see additional README.txt files in the NuttX tools repository.

    2. Execute make menuconfig in nuttx/ in order to start the reconfiguration process.

  3. By default, all configurations assume the Linux. This is easily reconfigured:

    CONFIG_HOST_LINUX=y

Configuration Sub-Directories

nsh

This configuration provides a basic NuttShell configuration (NSH) with the default console on legacy UART0 port (base=0x3f8)

nsh_pci

This configuration provides a basic NuttShell configuration (NSH) with the default console on PCI serial port (AX99100 based card).

nsh_pci_smp

This is a configuration to run NuttX in SMP mode on hardware with a PCI serial port card (AX99100).

ostest

The “standard” NuttX examples/ostest configuration with the default console on legacy UART0 port (base=0x3f8)

jumbo

This is a QEMU configuration that enables many NuttX features.

Basic command to run the image without additional PCI devices attached:

qemu-system-x86_64 -m 2G -cpu host -smp 4 -enable-kvm \
-kernel nuttx -nographic -serial mon:stdio

knsh_romfs

This is similar to the nsh configuration except that NuttX is built as a kernel-mode, monolithic module, and the user applications are built separately. It uses ROMFS to load the user-space applications. This is intended to run on QEMU with COM serial port support.

Steps to build kernel image with user-space apps in ROMFS:

./tools/configure.sh qemu-intel64/knsh_romfs
make -j
make export -j
pushd ../apps
./tools/mkimport.sh -z -x ../nuttx/nuttx-export-*.tar.gz
make import -j
./tools/mkromfsimg.sh
mv boot_romfsimg.h ../nuttx/arch/x86_64/src/board/romfs_boot.c
popd
make -j

knsh_romfs_pci

This is similar to the knsh_romfs configuration except that it is intended to run on a bare metal Intel hardware with PCI serial port support.

lvgl

LVGL demo example that demonstrates x86_64 framebufer feature.

fb

Configuration that enables NuttX framebuffer examples.