Iniciando GNU/Linux en una placa ARM desde cero (usando Kali e iMX.6 como ejemplo)

tl; dr: Estoy construyendo una imagen de Kali Linux para una computadora ARM, en el programa debootstrap, linux и u-boot.

Si compró algunos de pago único no muy populares, es posible que le falte una imagen de su kit de distribución favorito. Más o menos le pasó lo mismo Flipper uno planeado. Simplemente no hay Kali Linux para IMX6 (estoy cocinando), así que tengo que montarlo yo mismo.

El proceso de descarga es bastante simple:

1. El hardware se inicializa.
2. Desde algún área del dispositivo de almacenamiento (tarjeta SD/eMMC/etc) se lee y ejecuta el gestor de arranque.
3. El cargador busca el núcleo del sistema operativo y lo carga en algún área de memoria y lo ejecuta.
4. El kernel carga el resto del sistema operativo.

Para mi tarea, este nivel de detalle es suficiente, puedes leer los detalles en otro articulo. Las "algunas" áreas mencionadas anteriormente difieren de una placa a otra, lo que crea algunas dificultades de instalación. Carga de plataformas ARM del servidor tratando de estandarizar usando UEFI, pero mientras no esté disponible para todos, tendrás que recolectar todo por separado.

Construyendo el sistema de archivos raíz

Primero necesitas preparar secciones. Das U-Boot admite diferentes sistemas de archivos, elegí FAT32 para /boot y ext3 para root, este es el marcado de imagen estándar para Kali bajo ARM. Usaré GNU Parted, pero puedes hacer lo mismo más familiar fdisk. también necesitarás dosfstools и e2fsprogs para crear un sistema de archivos: apt install parted dosfstools e2fsprogs.

Partición de la tarjeta SD:

1. Marque la tarjeta SD para usar la partición MBR: parted -s /dev/mmcblk0 mklabel msdos
2. Crear una sección para /boot para 128 megas: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB. El primer megabyte perdido debe dejarse para el marcado en sí y para el gestor de arranque.
3. Cree un FS raíz para el resto de la capacidad: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
4. Si de repente no ha creado o cambiado los archivos de partición, debe ejecutar `partprobe`, luego se volverá a leer la tabla de partición.
5. Cree un sistema de archivos de partición de arranque etiquetado BOOT: mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
6. Crear un sistema de archivos raíz con una etiqueta ROOTFS: mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Genial, ahora puedes llenarlo. Esto requerirá además debootstrap, una utilidad para crear root FS en sistemas operativos similares a Debian: apt install debootstrap.

Recolectamos FS:

1. Monte la partición para /mnt/ (use un punto de montaje más conveniente para usted): mount /dev/mmcblk0p2 /mnt
2. En realidad llenamos el sistema de archivos: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. Parámetro --include especifica para instalar adicionalmente algunos paquetes, especifiqué un emulador QEMU construido estáticamente. Te permite realizar chroot al entorno ARM. El significado de las otras opciones se puede encontrar en man debootstrap. No olvide que no todas las placas ARM admiten la arquitectura armhf.
3. Debido a la diferencia en las arquitecturas debootstrap se realiza en dos etapas, la segunda se realiza de la siguiente manera: chroot /mnt/ /debootstrap/debootstrap --second-stage
4. Ahora necesitas girar: chroot /mnt /bin/bash
5. Rellene /etc/hosts и /etc/hostname FS de destino. Complete lo mismo que el contenido en su computadora local, recuerde reemplazar solo el nombre de host.
6. Puedes personalizar todo lo demás. En particular, instalo locales (claves de repositorio), reconfiguración de locales y zona horaria (dpkg-reconfigure locales tzdata). No olvides establecer la contraseña con el comando passwd.
7. Establecer una contraseña para root el equipo passwd.
8. La preparación de la imagen para mí se completa rellenando /etc/fstab dentro /mnt/.

Subiré de acuerdo con las etiquetas creadas anteriormente, por lo que el contenido será así:

ETIQUETA=ROOTFS / errores automáticos=remontar-ro 0 1
ETIQUETA=ARRANQUE /arranque automático por defecto 0 0

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

Construyendo Linux

Para compilar el kernel (y luego el cargador de arranque) en Debian Testing, debe instalar el conjunto estándar de GCC, GNU Make y los archivos de encabezado de la biblioteca GNU C para la arquitectura de destino (tengo armhf), así como encabezados OpenSSL, calculadora de consola bc, bison и flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Dado que el cargador predeterminado busca un archivo zImage en el sistema de archivos de la partición de arranque, es hora de romper la unidad flash.

1. Clonar el núcleo es demasiado largo, así que simplemente descargaré: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Descomprima y vaya al directorio de origen: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
2. Configurar antes de compilar: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. La configuración está en el directorio. arch/arm/configs/. Si no hay ninguno, puede intentar encontrar y descargar uno listo y pasar el nombre del archivo en este directorio al parámetro KBUILD_DEFCONFIG. En casos extremos, pase inmediatamente al párrafo siguiente.
3. Opcionalmente, puede modificar la configuración: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
4. Y compilar de forma cruzada la imagen: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
5. Ahora puede copiar el archivo del kernel: cp arch/arm/boot/zImage /mnt/boot/
6. Y archivos de DeviceTree (descripción del hardware disponible en la placa): cp arch/arm/boot/dts/*.dtb /mnt/boot/
7. E instale los módulos ensamblados como archivos separados: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

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

Bota Das U

Dado que el cargador de arranque es interactivo, la placa en sí, un dispositivo de almacenamiento y un dispositivo USB a UART opcional son suficientes para probar su funcionamiento. Es decir, puede posponer el kernel y el sistema operativo para más adelante.

La gran mayoría de los fabricantes sugieren usar Das U-Boot para el arranque principal. El soporte completo generalmente se proporciona en su propia bifurcación, pero no se olvide de contribuir en la parte superior. En mi caso, la placa se apoya en línea principalpor eso tenedor Ignoré.

Recopilamos el gestor de arranque en sí:

1. Clona la rama estable del repositorio: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
2. Vamos al propio directorio: cd u-boot
3. Preparando la configuración de compilación: make mx6ull_14x14_evk_defconfig. Esto solo funciona si la configuración está en Das U-Boot, de lo contrario, deberá encontrar la configuración del fabricante y colocarla en la raíz del repositorio en el archivo. .config, o ensamblado de otra manera recomendada por el fabricante.
4. Recopilamos la imagen del cargador de arranque con un compilador cruzado armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Como resultado, obtenemos el archivo u-boot.imx, esta es una imagen preparada que se puede escribir en una unidad flash USB. Escribimos en la tarjeta SD saltándonos los primeros 1024 bytes. ¿Por qué elegí el objetivo? u-boot.imx? ¿Por qué se perdieron exactamente 1024 bytes? Esto es lo que proponen hacer en documentación. Para otras placas, el proceso de creación y grabación de imágenes puede ser ligeramente diferente.

Listo, puedes descargar. El cargador de arranque debe informar su propia versión, alguna información sobre la placa e intentar encontrar la imagen del kernel en la partición. Si falla, intentará arrancar a través de la red. En general, la salida es bastante detallada, puede encontrar un error en caso de un problema.

En lugar de una conclusión

¿Sabías que la frente de un delfín no es huesuda? ¡Es literalmente un tercer ojo, una lente grasa para la ecolocalización!

Fuente: habr.com