Obtener GNU / Linux en una placa ARM desde cero (por ejemplo, Kali e iMX.6)

tl; dr : crea una imagen de Kali Linux para una computadora ARM, en un programa debootstrap, linux y u-boot. Si compró algún dispositivo de placa única no muy popular, es posible que se enfrente a la falta de una imagen de su kit de distribución favorito. Casi lo mismo sucedió con el Flipper One planeado . Kali Linux para IMX6 simplemente no existe (estoy cocinando), así que tengo que construirlo yo mismo.











El proceso de descarga es bastante sencillo:

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

Este nivel de detalle es suficiente para mi tarea, puedes leer los detalles en otro artículo . Las "algunas" áreas mencionadas anteriormente difieren de una placa a otra, lo que crea algunas dificultades con la instalación. Están tratando de estandarizar la carga de plataformas ARM de servidor utilizando UEFI, pero como esto no está disponible para todos, tendrá que recopilar todo por separado.

Construyendo el sistema de archivos raíz

Primero necesitas preparar las secciones. Das U-Boot admite diferentes sistemas de archivos, elegí FAT32 para /booty ext3 para la raíz, este es el marcado de imagen estándar para Kali en ARM. Usaré GNU Parted, pero puedes hacer lo mismo más familiar fdisk. También se necesita dosfstoolsy e2fsprogspara crear un sistema de archivos: apt install parted dosfstools e2fsprogs.



Marcamos la tarjeta SD:

1. Marque la tarjeta SD como usando el marcado MBR: parted -s /dev/mmcblk0 mklabel msdos
2. Crear una sección de /boot128 megabytes: 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. Creamos un sistema de archivos raíz para toda la capacidad restante: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
4. Si de repente sus archivos de partición no han sido creados o cambiados, necesita ejecutar `partprobe`, entonces se volverá a leer la tabla de particiones.
5. Cree un sistema de archivos de partición de arranque con la etiqueta BOOT:mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
6. Cree un sistema de archivos raíz con una etiqueta ROOTFS:mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Genial, ahora puedes completarlo. Para hacer esto, se requerirá una debootstraputilidad adicional para crear un sistema de archivos raíz de sistemas operativos basados ​​en Debian apt install debootstrap.



Recopilamos FS:

1. Monte la partición en /mnt/(use un punto de montaje más conveniente):mount /dev/mmcblk0p2 /mnt
2. : debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. --include , QEMU. chroot ARM-. man debootstrap. , ARM- armhf.
3. - debootstrap , : chroot /mnt/ /debootstrap/debootstrap --second-stage
4. : chroot /mnt /bin/bash
5. /etc/hosts /etc/hostname . , .
6. . locales ( ), (dpkg-reconfigure locales tzdata). passwd.
7. Establezca una contraseña para el rootcomando passwd.
8. La preparación de la imagen para mí termina con el relleno /etc/fstabinterior /mnt/.

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

LABEL = ROOTFS / auto errors = remount-ro 0 1

LABEL = BOOT / boot auto por defecto 0 0

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

Construyendo Linux

Para construir el núcleo (y luego el cargador de arranque) en Debian Testing es necesario establecer un conjunto estándar de GCC, GNU Marca y archivos de cabecera de C de GNU Library para la arquitectura objetivo (I armhf), así como las cabeceras de OpenSSL, calculadora de la consola bc, bisony flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Dado que el gestor de arranque busca de forma predeterminada un archivo zImageen el sistema de archivos de la partición de arranque, es hora de particionar la unidad flash USB.

1. Núcleo clon demasiado tiempo, por lo que sólo tiene que descargar: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Descomprímalo y vaya al directorio de origen:tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
2. Configurar antes de la compilación: 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 buscar y descargar el listo y pasar el nombre del archivo en este directorio al parámetro KBUILD_DEFCONFIG. Como último recurso, vaya directamente al siguiente punto.
3. Opcionalmente, puede ajustar la configuración: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
4. Y compilaremos la imagen: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
5. Ahora puede copiar el archivo con el kernel: cp arch/arm/boot/zImage /mnt/boot/
6. Y archivos con 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 kernel está listo. Puedes desmontar todo:umount /mnt/boot/ /mnt/

Das U-Boot

Dado que el cargador de arranque es interactivo, la placa en sí, un dispositivo de almacenamiento y un dispositivo opcional de USB a UART 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 fabricantes sugiere usar Das U-Boot para el arranque inicial. El soporte completo generalmente se proporciona en su propia bifurcación, pero no se olvidan de contribuir al upstream. En mi caso, la placa se apoya en la línea principal , así que ignoré la bifurcación .



Recopilamos el propio gestor de arranque:

1. : git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
2. : cd u-boot
3. : make mx6ull_14x14_evk_defconfig. Das U-Boot, .config, .
4. - armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

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



Listo, puedes arrancar. El cargador de arranque debe informar su propia versión, información de la placa e intentar encontrar la imagen del núcleo en la partición. Si no tiene éxito, 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!