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

Estou tentando chrootentrar em um ARMsistema de arquivos Arch Linux a partir de x86_64.

Vi que é possível usar a estática qemucopiando 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 diferem. Estou fazendo algo errado?

Você não pode criar uma arquitetura diferente. Fazendo chroot, você está executando os binários (a partir do chroot) em sua arquitetura. A execução de binários ARM no x86 (e x86_64 nesse assunto) levaria ao "erro de formato Exec".

Se você deseja executar binários de arquitetura diferente, precisará de um emulador. O Qemu é um bom candidato para isso, mas você precisará aprender como usá-lo. Isso envolveria a criação do RootFS e a compilação de um kernel para o ARM. Você precisará de uma cadeia de ferramentas para compilar binários ARM (e kernel) talvez. Uma coisa é certa: esqueça o método chroot, você não pode executar binários compilados para ARM no x86 (x86_64).

Edit: Após a pequena conversa com @UrichDangel, eu percebi, 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 host, então o qemu-arm pode executar seu / bin / sh (compilado para arm).

De vez em quando, uso um chroot do ARM: meu telefone executa o Linux Deploy e a imagem morre de vez em quando. Depois, copio-o para o meu computador e examino a situação com o 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

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

Você também pode procurar /proc/sys/fs/binfmt_miscse existe um arquivo qemu-arm. Caso contrário, reinicie o serviço binfmt_support.

Para chegar a este trabalho que eu instalado qemu-static-arme binfmt-supportde AUR.

Leia os comentários para qemu-user-static. Eu tive que atualizar o PKGBUILDURL de download e os hashes mais recentes para o makepkg terminar.

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

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

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

conforme descrito na página de manual para update-binfmts. Depois disso, cat /proc/sys/fs/binfmt_miscmostrará os vários binfmts.

Em seguida, certifique-se de copiar o arquivo qemu-*-staticpara o usr/bin/diretório em que você deseja fazer o chroot e, em seguida, chrootdeve funcionar.

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: https://proot-me.github.io/

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

Embora você normalmente não possa executar uma inicialização 'completa' (ou seja, iniciando init e serviços), é bom executar alguns binários a partir do local 'natural', com acesso a todos os seus arquivos de configuração, incluindo alguns que são montados em bind sistema 'host' etc.

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 

Adicionando a resposta de Luc: você precisa garantir que a localização do intérprete seja a mesma no chroot e no sistema de arquivos principal. Isso ocorre porque o kernel detecta a arquitetura de um executável e, em seguida, usa o local do intérprete como mostrado update-binfmts --displaypara iniciá-lo. Então a linha

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

realmente deveria ser

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

Caso contrário, você poderá obter os espelhos "Não encontrado" dentro do seu chroot, pois o kernel não consegue encontrar o intérprete necessário, se o local qemu-arm-staticnão estiver dentro /usr/bindo seu sistema.

Acabei de encontrar o mesmo problema no Ubuntu. Eu binfmtconfigurei e qemu-arm-staticcopiei para o mesmo caminho chroot-ed que no sistema host.

Depois de uma hora, eu fiz set|grep bashem uma máquina host. Eu descobri que tinha /bin/bashduas variáveis ​​env: SHELLe SUDO_COMMAND. Depois de substituir as variáveis, meu chroot para o ARM funcionou:

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

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

update-binfmts --enable qemu-arm

Depois de executar isso, o chroot no sistema de arquivos arm seria possível.