🥇Arrancando GNU/Linux en una placa ARM desde cero (con Kali y iMX.6)

resumen: estoy creando una imagen de Kali Linux para una computadora ARM, utilizando el programa debootstrap, linux y u-boot.

Si compraste alguna placa de un solo tablero que no sea muy popular, podrías haberte encontrado con la falta de una imagen de tu distribución favorita. Algo similar ocurrió con el planificado Flipper One. No existe Kali Linux para IMX6 (estoy preparándolo), así que tengo que compilarlo por mi cuenta.

El proceso de arranque es bastante simple:

Se inicializa el hardware.
Desde una determinada área del dispositivo de almacenamiento (tarjeta SD/eMMC/etc) se lee y ejecuta el cargador de arranque.
El cargador de arranque busca el núcleo del sistema operativo y lo carga en una cierta área de memoria y lo ejecuta.
El núcleo carga el resto del sistema operativo.

Para mi tarea es suficiente con tal nivel de detalle, puedes leer más sobre el tema en otro artículo. Las mencionadas "ciertas" áreas varían de placa a placa, lo que crea algunas dificultades en la instalación. Se intenta estandarizar el arranque de plataformas ARM de servidor con UEFI, pero mientras esto no esté disponible para todos, habrá que compilar todo por separado. Compilación del sistema de archivos raíz

Primero, es necesario preparar las particiones. Das U-Boot soporta diferentes sistemas de archivos, elegí FAT32 para

y ext3 para la raíz; esta es la partición estándar de imágenes para Kali en ARM. Usaré GNU Parted, pero puedes hacer lo mismo de una forma más familiar /boot . También se necesitarán fdiskdosfstools y e2fsprogs y para crear sistemas de archivos: apt install parted dosfstools e2fsprogs Particionamos la tarjeta SD:.

Marcamos la tarjeta SD para usar particionamiento MBR:

parted -s /dev/mmcblk0 mklabel msdos Creamos una partición para
de 128 megabytes: /boot parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB . El primer megabyte omitido debe dejarse para la propia tabla de particiones y para el cargador de arranque.Creamos el sistema de archivos raíz en toda la capacidad restante:
parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100% Si por alguna razón no se crearon o no se modificaron los archivos de las particiones, debes ejecutar `partprobe`, para que la tabla de particiones sea readaptada.
Creamos el sistema de archivos de la partición de arranque con la etiqueta
mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1 BOOT: Creamos el sistema de archivos raíz con la etiqueta
ROOTFS mkfs.ext3 -L ROOTFS /dev/mmcblk0p2: Perfecto, ahora podemos llenarlo. Para esto, adicionalmente se requerirá

, una utilidad para crear sistemas de archivos de sistemas operativos similares a Debian: debootstrapapt install debootstrap Compilamos el sistema de archivos:.

Montamos la partición en

(usa un punto de montaje que te sea más conveniente): /mnt/ mount /dev/mmcblk0p2 /mnt montar /dev/mmcblk0p2 /mnt
Llenamos el sistema de archivos: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. El parámetro --include indica instalar paquetes adicionales, he especificado el emulador QEMU compilado estáticamente. Permite ejecutar chroot en el entorno ARM. El significado de las otras opciones se puede ver en man debootstrap. No olvides que no todas las placas ARM son compatibles con la arquitectura armhf.
Debido a las diferencias de arquitectura debootstrap se ejecuta en dos etapas, la segunda se realiza así: chroot /mnt/ /debootstrap/debootstrap --second-stage
Ahora necesitamos cambiar el chroot: chroot /mnt /bin/bash
Llenamos /etc/hosts y /etc/hostname el sistema de archivos de destino. Llena por analogía con el contenido de tu computadora local, solo recuerda cambiar el nombre del host.
Puedes ajustar el resto. En particular, instalo locales (claves del repositorio), reconfiguro las locales y la zona horaria (dpkg-reconfigure locales tzdata). No olvides establecer la contraseña con el comando passwd.
Establecemos la contraseña para root con el comando passwd.
La preparación de la imagen para mí termina con llenar /etc/fstab dentro /mnt/.

Voy a cargar de acuerdo con las etiquetas creadas anteriormente, así que el contenido será:

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

Finalmente, se puede montar la partición de arranque, que necesitaremos para el núcleo: `mount /dev/mmcblk0p1 /mnt/boot/`

Compilación de Linux

Para compilar el núcleo (y el cargador después) en Debian Testing, es necesario instalar el conjunto estándar de GCC, GNU Make y los archivos de encabezado de GNU C Library para la arquitectura objetivo (yo tengo armhf), así como los encabezados de OpenSSL, calculadora de consola bc, bison y flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Dado que el cargador por defecto busca el archivo zImage en el sistema de archivos de la partición de arranque, es hora de dividir la memoria USB.

Clonar el núcleo lleva demasiado tiempo, así que simplemente lo descargaré: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Descomprimimos y vamos a la carpeta de los fuentes: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
Configuramos antes de compilar: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. La configuración se encuentra en la carpeta arch/arm/configs/. Si no hay tal archivo, puedes intentar encontrar y descargar uno preparado y pasar el nombre del archivo en esta carpeta al parámetro KBUILD_DEFCONFIG. En el peor de los casos, pasa directamente al siguiente punto.
Opcionalmente, se pueden ajustar los parámetros: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
Y compilamos la imagen: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
Ahora se puede copiar el archivo del núcleo: cp arch/arm/boot/zImage /mnt/boot/
Y archivos de DeviceTree (descripción del hardware existente en la placa): cp arch/arm/boot/dts/*.dtb /mnt/boot/
Y para instalar los módulos compilados como archivos separados: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

El núcleo está listo. Se puede desmontar todo: umount /mnt/boot/ /mnt/

Das U-Boot

Dado que el cargador de arranque es interactivo, para verificar su funcionamiento se necesita únicamente la placa, el dispositivo de almacenamiento y opcionalmente un dispositivo USB-a-UART. Es decir, se puede dejar el núcleo y el SO para después.

La gran mayoría de los fabricantes recomienda utilizar Das U-Boot para el arranque inicial. El soporte completo suele proporcionarse en su propio fork, pero no olvidan contribuir al upstream. En mi caso, la placa está soportada en mainline, por lo tanto fork lo ignoré.

Compilamos el propio cargador:

Clonamos la rama estable del repositorio: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
Accedemos al directorio: cd u-boot
Preparamos la configuración de compilación: make mx6ull_14x14_evk_defconfig. Esto solo funciona si la configuración está en el propio Das U-Boot, de lo contrario, necesitarás encontrar la configuración del fabricante y colocarla en la raíz del repositorio en el archivo .config, o compilar de otra manera recomendada por el fabricante.
Compilamos la propia imagen del cargador cruzado armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Como resultado, obtenemos el archivo u-boot.imx, es una imagen lista para grabar en un USB. Grabamos en la tarjeta SD, omitiendo los primeros 1024 bytes. ¿Por qué elegí el objetivo u-boot.imx? Почему пропустил именно 1024 байта? Так предлагают сделать в la documentación. Para otras placas, el proceso de compilación de la imagen y grabado puede diferir un poco.

Listo, se puede iniciar. El cargador debe informar su propia versión, algo de información sobre la placa e intentar encontrar la imagen del núcleo en la partición. Si falla, intentará arrancar desde la red. En general, el resultado es bastante detallado, se puede encontrar un error en caso de problema.