• Diff for "QemuUserEmulation"

QEMU User Emulation

This page describes how to setup and use QEMU user emulation in a "transparent" fashion, allowing execution of non-native target executables just like native ones (i.e. ./program).

In this text, "target" means the system being emulated, and "host" means the system where QEMU is running.

Note: this text depends on features that are not available in official Debian Lenny qemu package. Here is the current summary of the bugs related to this feature:

Note this setup is incompatible with Scratchbox (both use the binfmt_misc module to register the same formats), so it's recommended to remove it (or stop its init script) before continuing.

Building qemu

1. Download and unpack qemu sources:

   apt-get source qemu
   dpkg-source -x *.dsc

2. Apply the following patches to the source, in order:

   • qemu_0.8.2-1_clean_build.patch

   • qemu_0.8.2-1_binfmt-5.patch

   • qemu_0.8.2-1_user_static.patch

3. Build the package as usual:

   dpkg-buildpackage -rfakeroot

This will generate 3 packages: qemu, qemu-binfmt and qemu-user-static. The latter is only required if you want to chroot into non-native root file systems (see "Appendix: chrooting into target filesystems" below).

Installing packages

The binfmt-support package contains a helper script to easily register/unregister binary formats with the kernel using the binfmt_misc module.

1. Install qemu, binfmt-support and qemu-binfmt:

   # apt-get install qemu binfmt-support
   # dpkg -i qemu-binfmt*.deb

2. Check whether the binfmt entries were successfully registered:

   # update-binfmts --display

   This command should print entries for each supported target user emulator, except for the host system.

Adjusting the system

Depending on the your kernel settings, you may need to set 'vm.mmap_min_addr=0' sysctl option to allow a program being run under a regular user, not root.

Running dynamically linked executables

With the instructions above, you should be able to run statically linked target executables. To be able to run dynamically linked binaries, QEMU needs to have access to the target ELF interpreter.

Installing the target C libraries with dpkg-cross

The libc6 package contains the target's ELF interpreter used by QEMU. The target Debian package cannot be installed directly on the host, so we need to use dpkg-cross to "cross-install" the package.

For example purposes, let's assume the target system is "arm".

1. Install the dpkg-cross package:

   # apt-get install dpkg-cross

2. Now download the target libc6 package from one of the Debian mirrors and install it using dpkg-cross:

   # dpkg-cross -i -a arm libc6_<version>_arm.deb

Alternatively, you can install the libc6-dev-arm-cross package from EmDebian:

# wget http://www.emdebian.org/debian/pool/cross-unstable/g/glibc/libc6-dev-arm-cross_2.3.6.ds1-6_all.deb
# dpkg -i libc6-dev-arm-cross_2.3.6.ds1-6_all.deb

Testing the emulation environment

We will use the "hello" ARM Debian package to test the new environment.

1. Download the hello package (e.g. from http://http.us.debian.org/debian/pool/main/h/hello/hello_2.1.1-5_arm.deb)

2. Unpack it with the command:

   $ dpkg -x hello_2.1.1-5_arm.deb /tmp/hello_arm

3. Finally, run the hello executable with:

   $ /tmp/hello_arm/usr/bin/hello

It should print "Hello, world!".

That's it! You can now run non-native executables transparently, as long as QEMU supports the system calls used by it.

Appendix: chrooting into target file systems

To be able to chroot into a target file system, the qemu emulator for the target CPU needs to be accessible from inside the chroot jail. For this to work, you need first to install the qemu-user-static package (compiled above):

# dpkg -i qemu-user-static*.deb

You cannot use the dynamically linked qemu because the host libraries will not be accessible from inside the chroot.

Next, copy the emulator for the target architecture to the path registered by binfmt-support. For example, for an ARM target file system, you need to do the following:

# mkdir -p /target_fs/usr/lib/qemu-binfmt
# cp /usr/bin/qemu-arm-static /target_fs/usr/lib/qemu-binfmt/arm

You should now be able to chroot into the file system:

# chroot /target_fs/

See Also

• EmDebian/CrossDebootstrap, Embedded_Debian

TODO

• Modify Scratchbox to take advantage of the new qemu packages, instead of using its own internal qemu (possible?).

CategoryEmdebian