Iniciar GNU/Linux nunha placa ARM desde cero (usando Kali e iMX.6 como exemplo)

tl; dr: Estou construíndo unha imaxe de Kali Linux para un ordenador ARM, no programa debootstrap, linux и u-boot.

Se compraches un só pagador non moi popular, podes atopar a falta dunha imaxe do teu kit de distribución favorito para iso. Pasoulle practicamente o mesmo planeado Flipper One. Simplemente non hai Kali Linux para IMX6 (estou a cociñar), así que teño que montalo eu.

O proceso de descarga é bastante sinxelo:

1. O hardware está inicializado.
2. Desde algunha área do dispositivo de almacenamento (tarxeta SD/eMMC/etc) o cargador de arranque é lido e executado.
3. O cargador busca o núcleo do sistema operativo e cárgao nalgunha área de memoria e execútao.
4. O núcleo carga o resto do SO.

Para a miña tarefa, este nivel de detalle é suficiente, podes ler os detalles noutro artigo. As "algunhas" áreas mencionadas anteriormente difiren de placa a placa, o que crea algunhas dificultades de instalación. Cargando plataformas ARM do servidor intentando estandarizar usando UEFI, pero mentres non estea dispoñible para todos, terás que recoller todo por separado.

Construír o sistema de ficheiros raíz

Primeiro cómpre preparar seccións. Das U-Boot admite diferentes sistemas de ficheiros, eu escollín FAT32 para /boot e ext3 para root, esta é a marca de imaxe estándar para Kali baixo ARM. Usarei GNU Parted, pero podes facer o mesmo máis familiar fdisk. Tamén necesitarás dosfstools и e2fsprogs para crear un sistema de ficheiros: apt install parted dosfstools e2fsprogs.

Partición da tarxeta SD:

1. Marque a tarxeta SD como usando a partición MBR: parted -s /dev/mmcblk0 mklabel msdos
2. Crear unha sección para /boot para 128 megabytes: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB. O primeiro megabyte perdido débese deixar para o propio marcado e para o cargador de arranque.
3. Cree un FS raíz para o resto da capacidade: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
4. Se de súpeto non creou nin cambiou ficheiros de partición, cómpre executar `partprobe`, entón a táboa de particións volverase ler.
5. Cree un sistema de ficheiros de partición de arranque etiquetado BOOT: mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
6. Crea un sistema de ficheiros raíz cunha etiqueta ROOTFS: mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Xenial, agora podes enchelo. Isto requirirá ademais debootstrap, unha utilidade para crear FS root en sistemas operativos similares a Debian: apt install debootstrap.

Recollemos FS:

1. Monte a partición en /mnt/ (utiliza un punto de montaxe máis cómodo para ti): mount /dev/mmcblk0p2 /mnt
2. En realidade, enchemos o sistema de ficheiros: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali... Parámetro --include especifica instalar adicionalmente algúns paquetes, especifiquei un emulador QEMU construído de forma estática. Permítelle realizar chroot ao contorno ARM. O significado das outras opcións pódese atopar en man debootstrap. Non esquezas que non todas as placas ARM admiten a arquitectura armhf.
3. Debido á diferenza de arquitecturas debootstrap realízase en dúas etapas, a segunda realízase do seguinte xeito: chroot /mnt/ /debootstrap/debootstrap --second-stage
4. Agora tes que xirar: chroot /mnt /bin/bash
5. Enchemos /etc/hosts и /etc/hostname obxectivo FS. Encha o mesmo que o contido no seu ordenador local, lembre de substituír só o nome de host.
6. Podes personalizar todo o demais. En particular, instalo locales (claves do repositorio), reconfiguración de locais e zona horaria (dpkg-reconfigure locales tzdata). Non esquezas establecer o contrasinal co comando passwd.
7. Establece un contrasinal para root o equipo passwd.
8. A preparación da imaxe para min complétase recheo /etc/fstab dentro /mnt/.

Subirei de acordo coas etiquetas creadas anteriormente, polo que o contido será así:

LABEL=ROOTFS/erros automáticos=remount-ro 0 1
LABEL=BOOT /boot auto por defecto 0 0

Finalmente, pode montar a partición de arranque, necesitarémola para o núcleo: `mount /dev/mmcblk0p1 /mnt/boot/`

Construíndo Linux

Para construír o núcleo (e despois o cargador de arranque) en Debian Testing, cómpre instalar o conxunto estándar de ficheiros de cabeceira GCC, GNU Make e GNU C Library para a arquitectura de destino (teño armhf), así como cabeceiras OpenSSL, calculadora da consola bc, bison и flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Xa que o cargador predeterminado busca un ficheiro zImage no sistema de ficheiros da partición de arranque, é hora de romper a unidade flash.

1. A clonación do núcleo é demasiado longa, así que só descargarei: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Descomprimir e ir ao directorio de orixe: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
2. Configure antes de compilar: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. A configuración está no directorio arch/arm/configs/. Se non o hai, pode tentar buscar e descargar un preparado e pasar o nome do ficheiro neste directorio ao parámetro KBUILD_DEFCONFIG. En casos extremos, proceda inmediatamente ao seguinte parágrafo.
3. Opcionalmente, pode modificar a configuración: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
4. E compila a imaxe cruzada: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
5. Agora podes copiar o ficheiro do núcleo: cp arch/arm/boot/zImage /mnt/boot/
6. E ficheiros de DeviceTree (descrición do hardware dispoñible no taboleiro): cp arch/arm/boot/dts/*.dtb /mnt/boot/
7. E instala os módulos ensamblados como ficheiros separados: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

O núcleo está listo. Podes desmontar todo: umount /mnt/boot/ /mnt/

Das U Boot

Dado que o cargador de arranque é interactivo, a propia placa, un dispositivo de almacenamento e un dispositivo USB a UART opcional son suficientes para probar o seu funcionamento. É dicir, pode aprazar o núcleo e o sistema operativo para máis tarde.

A gran maioría dos fabricantes suxiren usar Das U-Boot para o arranque principal. O soporte completo adoita proporcionarse no seu propio fork, pero non esquezas contribuír na fase ascendente. No meu caso, o taboleiro é compatible liña principalpolo tanto garfo Ignorei.

Recollemos o propio cargador de arranque:

1. Clona a rama estable do repositorio: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
2. Imos ao propio directorio: cd u-boot
3. Preparando a configuración de compilación: make mx6ull_14x14_evk_defconfig. Isto só funciona se a configuración está no propio Das U-Boot, se non, terás que buscar a configuración do fabricante e poñela na raíz do repositorio no ficheiro .config, ou montado doutra forma recomendada polo fabricante.
4. Recollemos a propia imaxe do cargador de arranque cun compilador cruzado armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Como resultado, obtemos o ficheiro u-boot.imx, esta é unha imaxe preparada que se pode escribir nunha unidade flash USB. Escribimos na tarxeta SD, saltando os primeiros 1024 bytes. Por que escollín o destino u-boot.imx? Por que perdeu exactamente 1024 bytes? Isto é o que se propoñen facer documentación. Para outras placas, o proceso de construción e gravación da imaxe pode ser lixeiramente diferente.

Feito, podes descargar. O cargador de arranque debería informar da súa propia versión, algunha información sobre o taboleiro e tentar atopar a imaxe do núcleo na partición. Se falla, tentará iniciar a través da rede. En xeral, a saída é bastante detallada, podes atopar un erro en caso de problema.

En vez de unha conclusión

Sabías que a fronte dun golfiño non é ósea? É literalmente un terceiro ollo, unha lente graxa para a ecolocalización.

Fonte: www.habr.com