Come posso chroot in un filesystem con un diverso architechture?

Sto provando a chrootentrare in un ARMfilesystem Arch Linux da x86_64.

Ho visto che è possibile fare un uso statico qemucopiando il file binario nel sistema chroot:

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

Ma nonostante ciò ottengo sempre il seguente errore:

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

So che questo significa che le architetture differiscono. Sto facendo qualcosa di sbagliato?

Non puoi chroot in diverse architetture. Con il chrooting, si eseguono i binari (dal chroot) sulla propria architettura. L'esecuzione di binari ARM su x86 (e x86_64 in quella materia) porterebbe a "Errore di formato Exec".

Se vuoi eseguire binari di diversa architettura avrai bisogno di un emulatore. Qemu è un buon candidato per questo, ma dovrai imparare come usarlo. Ciò implicherebbe la creazione di RootFS e la compilazione di un kernel per ARM. Avrai probabilmente bisogno di una toolchain per compilare binari ARM (e kernel). Una cosa è certa: dimentica il metodo chroot, non puoi eseguire i binari compilati per ARM su x86 (x86_64).

Modifica: Dopo la piccola chiacchierata con @UrichDangel, mi sono reso conto che dovrebbe essere possibile entrare nell'ambiente chroot con i programmi utente qemu (qemu-arm in questo caso). Chroot dovrebbe eseguire qemu-arm compilato per l'architettura host, quindi qemu-arm può eseguire il / bin / sh (compilato per arm).

Di tanto in tanto uso un chroot ARM: il mio telefono esegue Linux Deploy e l'immagine scompare di tanto in tanto. Poi lo copio sul mio computer ed esamino la situazione con chroot in questo modo:

# 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

Penso che il problema sia che non dovresti copiare qemu-armma qemu-arm-static. Questo è un eseguibile compilato statico in grado di funzionare dall'interno del chroot senza librerie.

Puoi anche cercare /proc/sys/fs/binfmt_miscse esiste un file qemu-arm. In caso contrario, riavviare il servizio binfmt_support.

Per farlo funzionare ho installato qemu-static-arme binfmt-supportda AUR.

Leggi i commenti per qemu-user-static. Ho dovuto aggiornare il file PKGBUILDcon l'URL di download più recente e gli hash per completare makepkg.

(Per installare da AUR, scaricare il tarball, untar, cd, run makepkg -i)

La risposta di Christian Wolf è importante. update-binfmtsnon viene eseguito correttamente per abilitare questi formati. Per fare ciò ho corso:

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

come descritto nella manpage di update-binfmts. Successivamente, cat /proc/sys/fs/binfmt_miscmostrerà i vari binfmts.

Quindi assicurati di copiare il file qemu-*-staticnella usr/bin/directory nella quale vuoi eseguire il chroot e quindi chrootdovrebbe funzionare.

Puoi sicuramente 'chroot' in un filesystem (montato) pensato per un'architettura diversa e fare un lavoro significativo, hai solo bisogno degli strumenti giusti.

Dai un'occhiata a PRoot, che è un'implementazione nello spazio utente di chroot, mount --bind e binfmt_misc: https://proot-me.github.io/

Insieme agli emulatori della modalità utente di QEMU, sei pronto.

Sebbene di solito non sia possibile eseguire un avvio "completo" (ovvero avviare init e servizi), è abbastanza buono eseguire alcuni binari dal loro posto "naturale", con accesso a tutti i loro file di configurazione, inclusi alcuni che sono montati dal bind dal sistema "host", ecc.

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 

Aggiungendo alla risposta di Luc: è necessario assicurarsi che la posizione dell'interprete sia la stessa nel chroot come nel file system principale. Questo perché il kernel rileva l'architettura di un eseguibile e quindi utilizza la posizione dell'interprete come mostrato da update-binfmts --displayper avviarlo. Quindi la linea

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

dovrebbe effettivamente essere

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

Altrimenti, potresti avere errori "Not found" all'interno del tuo chroot poiché il tuo kernel non riesce a trovare l'interprete richiesto, se la posizione di qemu-arm-staticnon è all'interno /usr/bindel tuo sistema.

Ho appena incontrato lo stesso problema su Ubuntu. Ho binfmtconfigurato e qemu-arm-staticcopiato sullo stesso percorso chroot del sistema host.

Dopo un'ora, l'ho fatto set|grep bashsu una macchina host. Ho scoperto che avevo /bin/bashin due variabili env: SHELLe SUDO_COMMAND. Dopo aver sostituito le variabili, il mio chroot in ARM ha funzionato:

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

Credo, per questo PO, tutto ciò che doveva fare era configurare binfmts, semplicemente eseguendo:

update-binfmts --enable qemu-arm

Dopo averlo eseguito, sarebbe stato possibile eseguire il chroot nel filesystem arm.