I'm trying to chroot into a Arch Linux ARM filesystem from x86_64.

I've seen that it's possible to do using static qemu by copying the binary into the chroot system:

$ cp /usr/bin/qemu-arm archarm-chroot/usr/bin    

But despite this I always get the following error:

chroot: failed to run command ‘/bin/bash’: Exec format error

I know this means that the architectures differ. Am I doing something wrong?

  • 2
    You have to configure binfmt first, have a look at wiki.debian.org/QemuUserEmulation for a quiet short introduction. An example for configuring binfmt_misc can be found at svn.kju-app.org/trunk/qemu/qemu/qemu-binfmt-conf.sh Commented Jun 28, 2012 at 23:00
  • Qemu static packages don't appear to be in the Arch repositories.
    – Jivings
    Commented Jun 28, 2012 at 23:04
  • 2
    Sorry i don't use arch, but you should probably be able to build a static qemu package by adding -static to the linker options Commented Jun 28, 2012 at 23:07
  • If you're using something like CentOS then the static version of qemu isn't available, you have to build it yourself :(
    – G Huxley
    Commented Sep 12, 2021 at 22:11

9 Answers 9


I use an ARM chroot from time to time: my phone runs Linux Deploy and the image dies now and then. I then copy it to my computer and examine the situation with chroot like this:

# This provides the qemu-arm-static binary
apt-get install qemu-user-static

# Mount my target filesystem on /mnt
mount -o loop fs.img /mnt

# Copy the static ARM binary that provides emulation
cp $(which qemu-arm-static) /mnt/usr/bin
# Or, more simply: cp /usr/bin/qemu-arm-static /mnt/usr/bin

# Finally chroot into /mnt, then run 'qemu-arm-static bash'
# This chroots; runs the emulator; and the emulator runs bash
chroot /mnt qemu-arm-static /bin/bash
  • This one works , but after chroot all command gives no such file or directory. I'm using Fedora 24 , selinux problem? Need help please
    – Superbiji
    Commented Sep 5, 2016 at 10:33
  • 2
    Even ls gives /bin/ls: no such file or directory. export shows good path. But echo /* is working, echo /usr/bin/qemu-arm* list the file. I have also mount sys, proc, dev
    – Superbiji
    Commented Sep 5, 2016 at 16:01
  • 2
    Thanks for helping.. found the problem the cause is interpreter in binfmt point to invalid path
    – Superbiji
    Commented Sep 8, 2016 at 15:51
  • 1
    ok, somehow it was solved by copying qemu-arm-static to bla/usr/bin instead of bla/bin. When I run which qemu-arm-static it gives me /bin/usr so I guess it should be consistent ? Commented Nov 11, 2017 at 18:52
  • 1
    qemu-aarch64-static for arm64 Commented Mar 8 at 15:24

IMPORTANT: Please look at the other answers. This is old and inaccurate answer.

You cannot chroot into different architecture. By chrooting, you are executing the binaries (from the chroot) on your architecture. Executing ARM binaries on x86 (and x86_64 in that matter) would lead to "Exec format error".

If you want to run binaries from different architecture you will need an Emulator. Qemu is a good candidate for this, but you will need to learn how to use it. This would involve creating RootFS and compiling a kernel for ARM. You will need a toolchain for compiling ARM binaries (and kernel) perhaps. One thing is for sure: Forget the chroot method, you cannot run binaries compiled for ARM on x86 (x86_64).

Edit: After the small talk with @UrichDangel, I realized, it should be possible to enter the chroot environment with qemu-user programs (qemu-arm in this case). Chroot should be executing qemu-arm compiled for your host architecture, then the qemu-arm can execute your /bin/sh (compiled for arm).

  • 7
    You should be able to use binfmt and qemu in combination to run non native targets - wiki.debian.org/QemuUserEmulation Commented Jun 28, 2012 at 22:59
  • 2
    I know how to use Qemu for emulation. Apparently you can use it with chroot, although clearly I cannot work out how.
    – Jivings
    Commented Jun 28, 2012 at 23:01
  • @UlrichDangel, Yes, this is a good information. But I think the OP were not looking for this king of solution. binfmt would be possible once he has properly installed qemu with qemu-arm emulation, but I believe he is wanting to enter his ARM emulation environment (e.g. Raspberry Pi) where he would need qemu-system-arm.
    – 0xAF
    Commented Jun 28, 2012 at 23:07
  • @0xAF but the binfmt/qemu-user solution is exactly what OP described, being able to chroot into into an arm chroot and run the commands without the need to build a dedicated rootfs etc. Commented Jun 28, 2012 at 23:09
  • 1
    @UlrichDangel, now on a second though, I believe you're right. It is possible to enter emulated chroot with the qemu-arm (or should be). I'll Edit my comment on that.
    – 0xAF
    Commented Jun 28, 2012 at 23:16

On Arch, Install qemu-user-static and binfmt-qemu-static from the AUR .

Then make sure to copy the qemu-*-static to the usr/bin/ directory in the thing you want to chroot to and then the chroot should work with something like chroot /mnt qemu-arm-static /bin/bash

  • qemu-aarch64-static for arm64 qemu-arm-static for 32bit arm Commented Mar 8 at 15:28

I think the problem is that you should not copy qemu-arm but qemu-arm-static. This is a static compiled executable able to run from inside the chroot without any libraries.

You can also look in /proc/sys/fs/binfmt_misc if there exists a file qemu-arm. If not restart the service binfmt_support.

  • I had to manually run: update-binfmts --importdir /var/lib/binfmts/ --import then everything showed up in /proc/sys/fs/binfmt_misc and the chroot works. Commented Jan 2, 2015 at 22:58

You can most definitely 'chroot' into a (mounted) filesystem meant for a different architecture and do some meaningful work, you just need the right tools.

Have a look at PRoot, which is a user-space implementation of chroot, mount --bind, and binfmt_misc: https://proot-me.github.io/

Together with QEMU's user mode emulators, you're all set.

Although you usually cannot perform a 'full' boot (i.e. starting init and services), it is good enough to run some binaries from their 'natural' place, with access to all their configuration files, including some that are bind-mounted from the 'host' system, etc.


I believe, for this OP, all he needed to do was configure binfmts, simply by running:

update-binfmts --enable qemu-arm

After running this, chroot into the arm filesystem would have been possible.

  • I didn't decide to do it but good to know about this option. Commented Mar 8 at 16:13

Adding to Luc's answer: you need to make sure the location of the interpreter is the same in the chroot as it is in the main file system. This is because the kernel detects the architecture of an executable and then uses the location of the interpreter as shown by update-binfmts --display to start it up. So the line

cp $(which qemu-arm-static) /mnt/usr/bin

should actually be

cp $(which qemu-arm-static) /mnt/$(which qemu-arm-static)

Otherwise, you may get "Not found"-errors inside your chroot as your kernel can't find the required interpreter, if the location of qemu-arm-static is not inside /usr/bin on your system.

sudo apt-get update
sudo apt-get install debootstrap qemu qemu-user-static
sudo qemu-debootstrap --arch armhf bionic armhf-chroot
sudo chroot armhf-chroot

uname -m 

I just ran into the same issue on Ubuntu. I did have binfmt configured and qemu-arm-static copied to the same chroot-ed path as on host system.

After an hour, I did set|grep bash on a host machine. I found that I had /bin/bash in two env variables: SHELL and SUDO_COMMAND. After replacing the variables, my chroot to ARM worked:

SHELL=/bin/sh SUDO_COMMAND=/bin/sh chroot hd

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .