Installera GNU/LINUX på en ARM-plattform från grunden (med Kali och iMX.6 som exempel)

tl;dr: jag bygger en Kali Linux-bild för ARM-datorer, med programmet debootstrap, linux och u-boot.

Om du har köpt någon mindre populär enkortsdator kan du ha stött på bristen på en bild av din favoritdistribution. Ungefär samma sak har hänt med den planerade Flipper One. Det finns helt enkelt ingen Kali Linux för IMX6 (jag förbereder det), så jag måste bygga den själv.

Laddningsprocessen är ganska enkel:

1. Hårdvaran initieras.
2. Från ett visst område på lagringsenheten (SD-kort/eMMC/osv) läses en bootloader in och körs.
3. Bootloadern söker efter operativsystemets kärna och laddar den i ett visst minnesområde och kör den.
4. Kärnan laddar resten av operativsystemet.

För min uppgift räcker denna detaljnivå, detaljer kan du läsa i en annan artikel. De ovan nämnda "vissa" områden varierar från kort till kort, vilket skapar vissa problem med installationen. Laddning av serverbaserade ARM-plattformar försöker standardiseras genom UEFI, men så länge detta inte är tillgängligt för alla måste man sätta ihop allt separat.

Bygga rotfilsystemet

Först måste partitionerna förberedas. Das U-Boot stöder olika filsystem, jag valde FAT32 för /boot och ext3 för roten, detta är standardpartitioneringen för Kali för ARM. Jag kommer att använda GNU Parted, men du kan göra det på ett mer bekant fdisk. Du kommer också att behöva dosfstools och e2fsprogs för att skapa filsystem: apt install parted dosfstools e2fsprogs.

Partitionera SD-kortet:

1. Markera SD-kortet som använder MBR-partitionering: parted -s /dev/mmcblk0 mklabel msdos
2. Skapa en partition för /boot på 128 megabyte: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB. Den första uteslutna megabyte måste lämnas för själva partitioneringen och bootloadern.
3. Skapa rotfilsystemet med all kvarvarande kapacitet: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
4. Om filerna för partitionerna inte skapades eller ändrades, kör `partprobe`, då kommer partitionstabellen att läsas om.
5. Skapa filsystemet för bootpartitionen med etiketten BOOT: mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
6. Skapa rotfilsystemet med etiketten ROOTFS: mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Utmärkt, nu kan det fyllas. För detta behövs även debootstrap, ett verktyg för att skapa rotfilsystem för Debian-liknande operativsystem: apt install debootstrap.

Bygger filsystemet:

1. Montera partitionen i /mnt/ (använd en mer bekväm monteringspunkt för dig): mount /dev/mmcblk0p2 /mnt
2. Fyll i filsystemet: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. Parametern --include anger att installera vissa paket, jag angav den statiskt sammanställda emulatorn QEMU. Den möjliggör körning av chroot i ARM-miljön. Syftet med de andra alternativen kan ses i man debootstrap. Tänk på att inte alla ARM-kort stöder arkitekturen armhf.
3. På grund av arkitekturernas skillnader debootstrap utförs i två steg, det andra utförs så här: chroot /mnt/ /debootstrap/debootstrap --second-stage
4. Nu måste vi chroota: chroot /mnt /bin/bash
5. Fyller i /etc/hosts och /etc/hostname mål-FS. Fyll på liknande med innehållet på din lokala dator, glöm inte att byta värdnamnet.
6. Allt annat kan justeras. Specifikt installerar jag locales (förvaringsnycklar), konfigurerar om lokaler och tidszon (dpkg-reconfigure locales tzdata). Glöm inte att ställa in ett lösenord med kommandot passwd.
7. Ställer in lösenord för root med kommandot passwd.
8. För att förbereda bilden avslutas jag med att fylla i /etc/fstab inuti /mnt/.

Jag kommer att ladda upp i enlighet med de tidigare skapade etiketterna, så innehållet kommer att vara så här:

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

Till sist kan vi montera startpartitionen, den kommer att behövas för kärnan: `mount /dev/mmcblk0p1 /mnt/boot/`

Bygg Linux

För att bygga kärnan (och i nästa steg bootloadern) på Debian Testing måste du installera standardpaketet med GCC, GNU Make och headerfiler för GNU C Library för den målarkitekturen (jag har armhf), samt headerfiler för OpenSSL, en konsolräknare bc, bison och flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Eftersom bootloadern som standard letar efter filen zImage i filsystemet för startpartitionen, är det dags att partitionera USB-minnet.

1. Att klona kärnan tar för lång tid, så jag laddar ner den istället: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Vi packar upp och går in i mappen med källkoden: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
2. Konfigurerar innan kompilering: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. Konfigurationen finns i mappen arch/arm/configs/. Om den inte finns kan du försöka hitta och ladda ner en färdig och ange filnamnet i den här mappen som parameter KBUILD_DEFCONFIG. I värsta fall går du direkt till nästa steg.
3. Valfritt kan inställningarna justeras: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
4. Och vi krosskompilerar bilden: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
5. Nu kan vi kopiera filen med kärnan: cp arch/arm/boot/zImage /mnt/boot/
6. Och filer med DeviceTree (beskrivning av den befintliga hårdvaran på kortet): cp arch/arm/boot/dts/*.dtb /mnt/boot/
7. Och installera de samlade modulerna som separata filer: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

Kärnan är klar. Du kan avmontera allt: umount /mnt/boot/ /mnt/

Das U-Boot

Eftersom startprogrammet är interaktivt, räcker det med själva kortet, lagringsenheten och eventuellt en USB-to-UART-enhet för att kontrollera dess funktion. Det vill säga, du kan skjuta upp kärnan och OS till senare.

Nästan alla tillverkare rekommenderar att använda Das U-Boot för den primära inladdningen. Fullständig support erbjuds oftast i sin egen fork, men de glömmer inte att bidra till upstream. I mitt fall stöds kortet i mainline, därför fork ignorerade jag.

Vi bygger själva startprogrammet:

1. Klona den stabila grenen av biblioteket: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
2. Vi går in i själva katalogen: cd u-boot
3. Förbered byggkonfigurationen: make mx6ull_14x14_evk_defconfig. Detta fungerar bara om konfigurationen finns i själva Das U-Boot, annars måste du hitta tillverkarens konfigurationsfil och lägga den i roten av biblioteket i filen .config, eller bygga enligt något annat rekommenderat av tillverkaren.
4. Vi bygger själva starten med krosskompilatorn armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Som resultat får vi filen u-boot.imx, detta är en färdig bild som kan skrivas på ett USB-minne. Vi skriver till SD-kortet och hoppar över de första 1024 byte. Varför valde jag målet u-boot.imx? Почему пропустил именно 1024 байта? Так предлагают сделать в dokumentationen. För andra kort kan processen för att bygga bilden och skriva skilja sig något.

Klart, du kan starta. Startprogrammet bör rapportera sin egen version, viss information om kortet och försöka hitta kärnbilden på partitionen. Om det misslyckas kommer det att försöka starta över nätverket. Totalt är output ganska detaljerad, man kan hitta misstag om det uppstår problem.

Avslutande

Visste du att delfinens panna inte är benig? Det är bokstavligen den tredje ögat, en fet linse för ekolokalisering!

Källa: habr.com