Como posso fazer chroot em um sistema de arquivos com uma arquitetura diferente?

Question

Estou tentando chroot em um sistema de arquivos Arch Linux ARM de x86_64 .

Eu vi que é possível fazer usando static qemu copiando o binário no sistema chroot:

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

Mas apesar disso, sempre recebo o seguinte erro:

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

Eu sei que isso significa que as arquiteturas são diferentes. Estou fazendo algo errado?

    

Answer 1

Você não pode chroot em arquitetura diferente. Por chrooting, você está executando os binários (do chroot) em sua arquitetura. Executar binários do ARM em x86 (e x86_64 nessa questão) levaria a "Erro no formato Exec".

Se você deseja executar binários de diferentes arquiteturas, precisará de um emulador. O Qemu é um bom candidato para isso, mas você precisará aprender como usá-lo. Isso envolveria criar RootFS e compilar um kernel para o ARM. Você precisará de um toolchain para compilar os binários do ARM (e kernel), talvez. Uma coisa é certa: Esqueça o método chroot, você não pode executar binários compilados para o ARM em x86 (x86_64).

Editar: Depois da pequena conversa com o @UrichDangel, percebi que deveria ser possível entrar no ambiente chroot com programas qemu-user (qemu-arm neste caso). O chroot deve estar executando o qemu-arm compilado para sua arquitetura de host, então o qemu-arm pode executar seu / bin / sh (compilado para arm).

    

Answer 2

Eu uso um chroot ARM de tempos em tempos: meu telefone executa o Linux Deploy e a imagem morre de vez em quando. Eu então copio para o meu computador e examino a situação com chroot assim:

# 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

    

Answer 3

Acho que o problema é que você não deve copiar qemu-arm , mas qemu-arm-static . Este é um executável estático compilado capaz de executar dentro do chroot sem nenhuma biblioteca.

Você também pode procurar em /proc/sys/fs/binfmt_misc se houver um arquivo qemu-arm . Se não reiniciar o serviço binfmt_support .

    

Answer 4

Para fazer isso funcionar, instalei qemu-static-arm e binfmt-support da AUR.

Leia os comentários para qemu-user-static . Eu tive que atualizar o PKGBUILD com o URL de download mais recente e os hashes para o makepkg terminar.

(Para instalar a partir do AUR, baixe o tarball, untar , cd , execute makepkg -i )

A resposta de Christian Wolf é importante. update-binfmts não é executado corretamente para ativar esses formatos. Para fazer isso eu corri:

update-binfmts --importdir /var/lib/binfmts/ --import

, conforme descrito na manpage para update-binfmts. Depois disso, cat /proc/sys/fs/binfmt_misc mostrará os vários binfmts.

Em seguida, copie o qemu-*-static para o diretório usr/bin/ na coisa que você quer fazer o chroot e então o chroot deve funcionar.

    

Answer 5

Você pode definitivamente 'chroot' em um sistema de arquivos (montado) destinado a uma arquitetura diferente e fazer algum trabalho significativo, você só precisa das ferramentas certas.

Dê uma olhada no PRoot, que é uma implementação no espaço do usuário de chroot, mount -bind e binfmt_misc: link

Juntamente com os emuladores de modo de usuário do QEMU, está tudo pronto.

Embora você geralmente não possa executar uma inicialização 'completa' (isto é, iniciar init e serviços), é bom executar alguns binários a partir de seu local 'natural', com acesso a todos os arquivos de configuração, incluindo alguns que são vinculados. montado a partir do sistema 'host', etc.

    

Answer 6

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 

    

Answer 7

Acabei de me deparar com o mesmo problema no Ubuntu. Eu tinha binfmt configurado e qemu-arm-static copiado para o mesmo caminho chroot que no sistema host.

Após uma hora, eu fiz set|grep bash em uma máquina host. Descobri que tinha /bin/bash em duas variáveis de env: SHELL e SUDO_COMMAND . Depois de substituir as variáveis, meu chroot para o ARM funcionou:

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

    

Answer 8

Eu acredito que, para este OP, tudo o que ele precisava fazer era configurar binfmts, simplesmente executando:

update-binfmts --enable qemu-arm

Depois de executar isso, chroot no sistema de arquivos arm teria sido possível.

    

Answer 9

Adicionando a resposta de Luc: você precisa ter certeza que a localização do interpretador é a mesma no chroot como no sistema de arquivos principal. Isso ocorre porque o kernel detecta a arquitetura de um executável e, em seguida, usa a localização do interpretador, conforme mostrado por update-binfmts --display para iniciá-lo. Então a linha

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

deve realmente ser

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

Caso contrário, você poderá receber "Não encontrado" -erros dentro do seu chroot, pois o seu kernel não pode encontrar o interpretador requerido, se a localização de qemu-arm-static não estiver dentro de /usr/bin em seu sistema.