🥇 Avviamo GNU/Linux su una scheda ARM da zero (con un esempio di Kali e iMX.6)

tl;dr: sto creando un'immagine di Kali Linux per computer ARM, con il programma debootstrap, linux e u-boot.

Se hai acquistato una scheda single-board non molto popolare, potresti aver incontrato l'assenza di un'immagine del tuo distro preferito. È successo più o meno lo stesso con il pianificato Flipper One. Kali Linux per IMX6 semplicemente non esiste (sto preparando), quindi è necessario assemblarlo da soli.

Il processo di avvio è abbastanza semplice:

L'hardware viene inizializzato.
Un bootloader viene letto ed eseguito da una certa area del dispositivo di memoria (scheda SD/eMMC/etc).
Il bootloader cerca il kernel del sistema operativo e lo carica in un'area di memoria e lo esegue.
Il kernel carica tutto il resto del sistema operativo.

Per il mio compito, un tale livello di dettaglio è sufficiente; puoi leggere maggiori dettagli in un altro articolo. Le "alcune" aree menzionate sopra variano da scheda a scheda, creando alcune difficoltà nell'installazione. Il caricamento delle piattaforme server ARM cerca di standardizzarlo tramite UEFI, ma poiché questo non è accessibile a tutti, dovremo assemblare tutto separatamente.

Assemblaggio del file system radice

Per iniziare, è necessario preparare le partizioni. Das U-Boot supporta diversi FS, ho scelto FAT32 per /boot e ext3 per la radice, questa è una partizione standard delle immagini per Kali su ARM. Userò GNU Parted, ma puoi fare lo stesso con un fdisk. Serviranno anche dosfstools e e2fsprogs per creare il FS: apt install parted dosfstools e2fsprogs.

Partizioniamo la scheda SD:

Seguiamo la scheda SD come utilizzante la partizione MBR: parted -s /dev/mmcblk0 mklabel msdos
Creiamo una partizione per /boot di 128 megabyte: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB. Il primo megabyte saltato deve essere lasciato per la partizione stessa e per il bootloader.
Creiamo il FS radice per tutta la capacità rimanente: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
Se per caso non hai creato o modificato i file delle partizioni, devi eseguire `partprobe`, così la tabella delle partizioni verrà riletta.
Creiamo il file system della partizione di avvio con l'etichetta BOOT: mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
Creiamo il FS radice con l'etichetta ROOTFS: mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Ottimo, ora possiamo iniziare a riempirlo. Per questo avremo bisogno di debootstrap, uno strumento per creare file system radici per sistemi operativi simili a Debian: apt install debootstrap.

Assembliamo il FS:

Montiamo la partizione in /mnt/ (usa un punto di montaggio più comodo per te): mount /dev/mmcblk0p2 /mnt
Iniziamo a riempire il filesystem: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. Il parametro --include indica di installare aggiuntivamente alcuni pacchetti, ho specificato l'emulatore QEMU compilato staticamente. Questo consente di eseguire chroot nell'ambiente ARM. Il significato delle altre opzioni può essere trovato in man debootstrap. Non dimenticate che non tutte le schede ARM supportano l'architettura armhf.
A causa delle differenze architettoniche debootstrap il processo avviene in due fasi, la seconda viene eseguita con: chroot /mnt/ /debootstrap/debootstrap --second-stage
Ora dobbiamo entrare nel chroot: chroot /mnt /bin/bash
Compiliamo /etc/hosts e /etc/hostname sistema di destinazione. Compilate in modo analogo ai contenuti presenti sul vostro computer locale, ricordate solo di sostituire il nome dell'host.
È possibile configurare il resto. In particolare, io installo locales (chiavi del repository), riconfiguro le impostazioni locali e il fuso orario (dpkg-reconfigure locales tzdata). Non dimenticate di impostare una password usando il comando passwd.
Impostiamo la password per root comando passwd.
La preparazione dell'immagine per me si conclude con il riempimento /etc/fstab all'interno /mnt/.

Caricherò in base alle etichette create in precedenza, quindi il contenuto sarà così:

LABEL=ROOTFS / auto errors=remount-ro 0 1
LABEL=BOOT /boot auto defaults 0 0

Infine, possiamo montare la partizione di avvio, ci servirà per il kernel: `mount /dev/mmcblk0p1 /mnt/boot/`

Costruzione di Linux

Per costruire il kernel (e poi il bootloader) su Debian Testing è necessario installare il pacchetto standard di GCC, GNU Make e i file di intestazione della GNU C Library per l'architettura target (io ho armhf), oltre ai file di intestazione di OpenSSL, il calcolatore da console bc, bison e flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Poiché il bootloader per impostazione predefinita cerca il file zImage nel filesystem della partizione di avvio, è ora di partizionare la chiavetta USB.

Clonare il kernel è troppo lungo, quindi scaricherò semplicemente: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Estrarre e passare alla directory con i sorgenti: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
Configuriamo prima della compilazione: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. La configurazione si trova nella directory arch/arm/configs/. Se non è presente, potete provare a trovare e scaricare uno preconfigurato e passare il nome del file a questa directory come parametro KBUILD_DEFCONFIG. In ultima istanza, passate direttamente al punto successivo.
Facoltativamente, è possibile ottimizzare le impostazioni: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
E compiliamo cross il firmware: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
Ora possiamo copiare il file con il kernel: cp arch/arm/boot/zImage /mnt/boot/
E i file con DeviceTree (descrizione dell'hardware sulla scheda): cp arch/arm/boot/dts/*.dtb /mnt/boot/
E installare i moduli compilati come file separati: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

Il kernel è pronto. Puoi smontare tutto: umount /mnt/boot/ /mnt/

Das U-Boot

Poiché il bootloader è interattivo, basta avere la scheda, il dispositivo di archiviazione e facoltativamente un dispositivo USB-to-UART per verificare il suo funzionamento. Vale a dire, il kernel e il sistema operativo possono essere rimandati.

La stragrande maggioranza dei produttori offre l'uso di Das U-Boot per l'avvio iniziale. Il supporto completo è solitamente garantito nel proprio fork, ma non dimenticano di contribuire anche all'upstream. Nel mio caso la scheda è supportata in mainline, quindi un fork l'ho ignorato.

Compiliamo il bootloader stesso:

Cloniamo il branch stabile del repository: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
Entriamo nella directory principale: cd u-boot
Prepariamo la configurazione della build: make mx6ull_14x14_evk_defconfig. Questo funziona solo se la configurazione è presente nel Das U-Boot stesso, altrimenti dovrai trovare il file di configurazione del produttore e metterlo nella radice del repository nel file .config, o compilare in un altro modo raccomandato dal produttore.
Compiliamo l'immagine del bootloader con cross-compiler armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Come risultato otteniamo il file u-boot.imx, è un'immagine pronta da scrivere su una chiavetta USB. Scriviamo sulla scheda SD, saltando i primi 1024 byte. Perché ho scelto il target u-boot.imx? Почему пропустил именно 1024 байта? Так предлагают сделать в documentazione. Per altre schede il processo di costruzione dell'immagine e scrittura potrebbe variare leggermente.

Fatto, si può avviare. Il bootloader dovrebbe segnalare la propria versione, alcune informazioni sulla scheda e cercare di trovare l'immagine del kernel nella partizione. In caso di fallimento, tenterà di avviarsi tramite rete. In generale, l'output è piuttosto dettagliato, puoi trovare l'errore in caso di problemi.