ProHoster > blogg > administration > Starta GNU/Linux på ett ARM-kort från början (med Kali och iMX.6 som exempel)

Starta GNU/Linux på ett ARM-kort från början (med Kali och iMX.6 som exempel)

tl; dr: Jag bygger en Kali Linux-avbildning för en ARM-dator, i programmet debootstrap, linux и u-boot.

Starta GNU/Linux på ett ARM-kort från början (med Kali och iMX.6 som exempel)

Om du köpte någon inte särskilt populär mjukvara för ett kort kan du ställas inför bristen på en bild av din favoritdistribution för den. Ungefär samma sak hände med planerade Flipper One. Det finns helt enkelt ingen Kali Linux för IMX6 (jag förbereder), så jag måste montera det själv.

Nedladdningsprocessen är ganska enkel:

  1. Hårdvaran initieras.
  2. Från något område på lagringsenheten (SD-kort/eMMC/etc) läses och körs starthanteraren.
  3. Starthanteraren letar efter operativsystemets kärna och laddar den i något minnesområde och kör den.
  4. Kärnan laddar resten av operativsystemet.

Denna detaljnivå räcker för min uppgift, du kan läsa detaljerna i en annan artikel. De "vissa" områdena som nämns ovan skiljer sig från bräda till bräda, vilket skapar vissa installationssvårigheter. Laddar ARM-serverplattformar försöker standardisera använder UEFI, men även om detta inte är tillgängligt för alla, måste du montera allt separat.

Bygga rotfilsystemet

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

Vi markerar SD-kortet:

  1. Markera SD-kortet som använder MBR-partitionering: parted -s /dev/mmcblk0 mklabel msdos
  2. Skapa ett avsnitt under /boot för 128 megabyte: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB. Den första megabyten som missas måste lämnas till själva uppmärkningen och för starthanteraren.
  3. Vi skapar ett rotfilsystem för hela den återstående kapaciteten: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
  4. Om dina partitionsfiler plötsligt inte har skapats eller inte har ändrats, måste du köra `partprobe`, då kommer partitionstabellen att läsas igen.
  5. Skapa ett filsystem för startpartitionen med etiketten BOOT: mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
  6. Skapa ett rotfilsystem med en etikett ROOTFS: mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Bra, nu kan du fylla i det. För detta behöver du dessutom debootstrap, ett verktyg för att skapa rotfilsystem för Debian-liknande operativsystem: apt install debootstrap.

Vi samlar in FS:

  1. Montera partitionen i /mnt/ (använd en mer bekväm monteringspunkt): mount /dev/mmcblk0p2 /mnt
  2. Vi fyller faktiskt filsystemet: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. Parameter --include indikerar att ytterligare installera några paket, angav jag en statiskt byggd QEMU-emulator. Det låter dig prestera chroot i ARM-miljön. Innebörden av de återstående alternativen kan hittas i man debootstrap. Glöm inte att inte alla ARM-kort stöder arkitekturen armhf.
  3. På grund av skillnaden i arkitektur debootstrap utförs i två steg, den andra utförs så här: chroot /mnt/ /debootstrap/debootstrap --second-stage
  4. Nu måste du skruva ihop det: chroot /mnt /bin/bash
  5. fylla /etc/hosts и /etc/hostname mål FS. Fyll i samma som innehållet på din lokala dator, kom bara ihåg att byta ut värdnamnet.
  6. Du kan anpassa allt annat. I synnerhet installerar jag locales (förvarsnycklar), konfigurera om lokaler och tidszon (dpkg-reconfigure locales tzdata). Glöm inte att ställa in lösenordet med kommandot passwd.
  7. Ange ett lösenord för root team passwd.
  8. Förberedelsen av bilden för mig slutar med fyllning /etc/fstab inom /mnt/.

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

LABEL=ROOTFS / auto errors=remount-ro 0 1
LABEL=BOOT /boot auto standardvärden 0 0

Slutligen kan du montera startpartitionen, vi kommer att behöva den för kärnan: `mount /dev/mmcblk0p1 /mnt/boot/`

Linux-bygge

För att bygga kärnan (och sedan starthanteraren) på Debian Testing måste du installera en standarduppsättning av GCC, GNU Make och GNU C Library header-filer för målarkitekturen (för mig) armhf), samt OpenSSL-rubriker, konsolkalkylator bc, bison и flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Eftersom standardinläsaren letar efter filen zImage på startpartitionens filsystem är det dags att dela upp flashenheten.

  1. Det tar för lång tid att klona kärnan, så jag laddar bara ner: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Låt oss packa upp och gå till katalogen med källorna: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
  2. Konfigurera före kompilering: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. Konfigurationen finns i katalogen arch/arm/configs/. Om det inte finns någon kan du försöka hitta och ladda ner en färdig och skicka namnet på filen i den här katalogen som en parameter KBUILD_DEFCONFIG. Som en sista utväg, gå omedelbart vidare till nästa punkt.
  3. Alternativt kan du justera inställningarna: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
  4. Och korskompilera bilden: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
  5. Nu kan du kopiera kärnfilen: cp arch/arm/boot/zImage /mnt/boot/
  6. Och filer från DeviceTree (beskrivning av hårdvaran på kortet): cp arch/arm/boot/dts/*.dtb /mnt/boot/
  7. Och installera modulerna som samlas in i form av 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/

Den här U-booten

Eftersom starthanteraren är interaktiv är allt du behöver för att testa dess funktion själva kortet, en lagringsenhet och eventuellt en USB-till-UART-enhet. Det vill säga, du kan skjuta upp kärnan och OS till senare.

De allra flesta tillverkare erbjuder att använda Das U-Boot för den första starten. Fullständigt stöd ges vanligtvis i deras egen gaffel, men de glömmer inte att bidra till uppströms. I mitt fall får styrelsen stöd i huvudlinjenSå gaffel Jag ignorerade det.

Låt oss sätta ihop själva bootloadern:

  1. Vi klonar den stabila grenen av förvaret: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
  2. Låt oss gå till själva katalogen: cd u-boot
  3. Förbereder byggkonfigurationen: make mx6ull_14x14_evk_defconfig. Detta fungerar bara om konfigurationen är i själva Das U-Boot, annars måste du hitta tillverkarens konfiguration och lägga den i roten av förvaret i en fil .config, eller montera på något annat sätt som rekommenderas av tillverkaren.
  4. Vi sätter ihop själva bootloader-bilden med hjälp av en korskompilator armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Som ett resultat får vi filen u-boot.imx, detta är en färdig bild som kan skrivas till en flashenhet. Vi skriver till SD-kortet och hoppar över de första 1024 byten. Varför valde jag Target u-boot.imx? Varför missade jag exakt 1024 byte? Detta är vad de föreslår att göra i dokumentation. För andra kort kan bildbyggandet och inspelningsprocessen vara något annorlunda.

Klart, du kan starta. Starthanteraren måste rapportera sin egen version, lite information om kortet och försöka hitta kärnavbildningen på partitionen. Om det misslyckas kommer det att försöka starta över nätverket. I allmänhet är utdata ganska detaljerad, du kan hitta felet om det finns ett problem.

I stället för en slutsats

Visste du att en delfins panna inte är benig? Det är bokstavligen ett tredje öga, en fet lins för ekolokalisering!

Starta GNU/Linux på ett ARM-kort från början (med Kali och iMX.6 som exempel)

Starta GNU/Linux på ett ARM-kort från början (med Kali och iMX.6 som exempel)

Källa: will.com