🥇Creación de una imagen de Ubuntu para ARM «desde cero»

Cuando comienza el desarrollo, a menudo no está claro qué paquetes se incluirán en el rootfs objetivo.

En otras palabras, todavía es pronto para intentar LFS, buildroot o yocto (o algo más), pero ya es hora de comenzar. Para aquellos con recursos (en mis muestras piloto tengo 4GB eMMC), hay una solución: proporcionar a los desarrolladores una distribución que permita entregar rápidamente lo que falta en este momento, y luego siempre podemos compilar listas de paquetes y formar una lista para el rootfs objetivo.

Este artículo no aporta novedades y es simplemente una instrucción de copia y pega.

El objetivo del artículo es compilar un rootfs de Ubuntu para una placa ARM (en mi caso, basada en Colibri imx7d).

Compilación de la imagen

Compilamos el rootfs objetivo para su replicación.

Descomprimimos Ubuntu Base

Elegimos la versión según nuestras necesidades y preferencias. Aquí he mencionado 20.

$ mkdir ubuntu20
$ cd ubuntu20
$ mkdir rootfs
$ wget http://cdimage.ubuntu.com/ubuntu-base/releases/20.04/release/ubuntu-base-20.04-base-armhf.tar.gz
$ tar xf ubuntu-base-20.04-base-armhf.tar.gz -C rootfs

Verificación del soporte de BINFMT en el núcleo

Si tiene una distribución común, entonces el soporte para BINFMT_MISC está presente y todo está configurado; si no, estoy seguro de que sabe cómo habilitar el soporte para BINFMT en el núcleo.

Asegúrese de que BINFMT_MISC esté habilitado en el núcleo:

$ zcat /proc/config.gz | grep BINFMT
CONFIG_BINFMT_ELF=y
CONFIG_COMPAT_BINFMT_ELF=y
CONFIG_BINFMT_SCRIPT=y
CONFIG_BINFMT_MISC=y

Ahora necesitamos verificar la configuración:

$ ls /proc/sys/fs/binfmt_misc
qemu-arm  register  status
$ cat /proc/sys/fs/binfmt_misc/qemu-arm
enabled
interpreter /usr/bin/qemu-arm
flags: OC
offset 0
magic 7f454c4601010100000000000000000002002800
mask ffffffffffffff00fffffffffffffffffeffffff

Se puede registrar manualmente usando, por ejemplo, esta instrucción.

Configuración de qemu static arm

Ahora necesitaremos una instancia de qemu compilada estáticamente.

!!! ATENCIÓN!!!
Si planea usar un contenedor para compilar algo, consulte:
https://sourceware.org/bugzilla/show_bug.cgi?id=23960
https://bugs.launchpad.net/qemu/+bug/1805913
Entonces, para un host x86_64 y un invitado arm, se debe usar la versión i386 de qemu:
http://ftp.ru.debian.org/debian/pool/main/q/qemu/qemu-user-static_5.0-13_i386.deb

$ wget http://ftp.debian.org/debian/pool/main/q/qemu/qemu-user-static_5.0-13_amd64.deb
$ alient -t qemu-user-static_5.0-13_amd64.deb
# la ruta en rootfs y el nombre del archivo ejecutable deben coincidir con /proc/sys/fs/binfmt_misc/qemu-arm
$ mkdir qemu
$ tar xf qemu-user-static-5.0.tgz -C qemu
$ file qemu/usr/bin/qemu-arm-static
qemu/usr/bin/qemu-arm-static: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), linked statically, BuildID[sha1]=be45f9a321cccc5c139cc1991a4042907f9673b6, for GNU/Linux 3.2.0, stripped
$ cp qemu/usr/bin/qemu-arm-static rootfs/usr/bin/qemu-arm
$ file rootfs/usr/bin/qemu-arm
rootfs/usr/bin/qemu-arm: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), linked statically, BuildID[sha1]=be45f9a321cccc5c139cc1991a4042907f9673b6, for GNU/Linux 3.2.0, stripped

Chroot

Un script simple:

ch-mount.sh

#!/bin/bash

function mnt() {
    echo "MOUNTING"
    sudo mount -t proc /proc ${2}proc
    sudo mount --rbind /sys ${2}sys
    sudo mount --make-rslave ${2}sys
    sudo mount --rbind /dev ${2}dev
    sudo mount --make-rslave ${2}dev
    sudo mount -o bind /dev/pts ${2}dev/pts
    sudo chroot ${2}
}

function umnt() {
    echo "UNMOUNTING"
    sudo umount ${2}proc
    sudo umount ${2}sys
    sudo umount ${2}dev/pts
    sudo umount ${2}dev

}

if [ "$1" == "-m" ] && [ -n "$2" ] ;
then
    mnt $1 $2
elif [ "$1" == "-u" ] && [ -n "$2" ];
then
    umnt $1 $2
else
    echo ""
    echo "Either 1'st, 2'nd or both parameters were missing"
    echo ""
    echo "1'st parameter can be one of these: -m(mount) OR -u(umount)"
    echo "2'nd parameter is the full path of rootfs directory(with trailing '/')"
    echo ""
    echo "For example: ch-mount -m /media/sdcard/"
    echo ""
    echo 1st parameter : ${1}
    echo 2nd parameter : ${2}
fi

Admiremos el resultado obtenido:

$ .\/ch-mount.sh -m rootfs\/\n# cat \/etc\/os-release\nNAME="Ubuntu"\nVERSION="20.04 LTS (Focal Fossa)"\nID=ubuntu\nID_LIKE=debian\nPRETTY_NAME="Ubuntu 20.04 LTS"\nVERSION_ID="20.04"\nHOME_URL="https:\/\/www.ubuntu.com\/"\nSUPPORT_URL="https:\/\/help.ubuntu.com\/"\nBUG_REPORT_URL="https:\/\/bugs.launchpad.net\/ubuntu\/"\nPRIVACY_POLICY_URL="https:\/\/www.ubuntu.com\/legal\/terms-and-policies\/privacy-policy"\nVERSION_CODENAME=focal\nUBUNTU_CODENAME=focal\n# uname -a\nLinux NShubin 5.5.9-gentoo-x86_64 #1 SMP PREEMPT Mon Mar 16 14:34:52 MSK 2020 armv7l armv7l armv7l GNU\/Linux

Por curiosidad, mediremos el tamaño antes y después de instalar el conjunto mínimo de paquetes (para mí):

# du -d 0 -h / 2>/dev/null
63M     /

Actualicemos:

# apt update
# apt upgrade --yes

Instalemos los paquetes que nos interesan:

# SYSTEMD_IGNORE_CHROOT=yes apt install --yes autoconf kmod socat ifupdown ethtool iputils-ping net-tools ssh g++ iproute2 dhcpcd5 incron ser2net udev systemd gcc minicom vim cmake make mtd-utils util-linux git strace gdb libiio-dev iiod

Los archivos de encabezado del núcleo, los módulos, son un tema aparte. No podremos instalar el gestor de arranque, el núcleo, los módulos y el árbol de dispositivos a través de Ubuntu. Vienen de fuera o los compilaremos nosotros mismos o nos los proporcionará el fabricante de la placa; en cualquier caso, esto está fuera del alcance de este instructivo.

Hasta cierto punto, la discrepancia de versiones es aceptable, pero es mejor tomarlas de la compilación del núcleo.

# apt install --yes linux-headers-generic

Veamos lo que se ha conseguido, y es bastante:

# apt clean
# du -d 0 -h / 2>/dev/null
770M    /

No olvides establecer una contraseña.

Embalamos la imagen

$ sudo tar -C rootfs --transform "s|^.\/||" --numeric-owner --owner=0 --group=0 -c .\/ | tar --delete .\/ | gzip > rootfs.tar.gz

Además, podemos instalar etckeeper con la configuración de autopush

Digamos que distribuimos nuestra compilación, el trabajo ha empezado, ¿cómo podemos compilar luego distintas versiones de nuestro sistema?

Etckeeper puede ser de ayuda.

La seguridad es un asunto personal:

puedes proteger ciertas ramas

generar una clave única para cada dispositivo

prohibir el push forzado

etc. …

# ssh-keygen
# apt install etckeeper
# etckeeper init
# cd /etc
# git remote add origin ...

Configurar autopush

Podemos, por supuesto, crear ramas en el dispositivo de antemano (digamos hacer un script o un servicio que se ejecute en el primer arranque).

# cat /etc/etckeeper/etckeeper.conf
PUSH_REMOTE="origin"

O podemos ser más astutos…

El camino perezoso

Supongamos que tenemos un identificador único, como el número de serie del procesador (o MAC, empresas serias compran un rango):

cat \/proc\/cpuinfo

# cat /proc/cpuinfo
processor       : 0
model name      : ARMv7 Processor rev 5 (v7l)
BogoMIPS        : 60.36
Features        : half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt vfpd32 lpae evtstrm 
CPU implementer : 0x41
CPU architecture: 7
CPU variant     : 0x0
CPU part        : 0xc07
CPU revision    : 5

processor       : 1
model name      : ARMv7 Processor rev 5 (v7l)
BogoMIPS        : 60.36
Features        : half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt vfpd32 lpae evtstrm 
CPU implementer : 0x41
CPU architecture: 7
CPU variant     : 0x0
CPU part        : 0xc07
CPU revision    : 5

Hardware        : Freescale i.MX7 Dual (Device Tree)
Revision        : 0000
Serial          : 06372509

Entonces podemos usarlo para el nombre de la rama en la que haremos el push:

# cat /proc/cpuinfo | grep Serial | cut -d':' -f 2 | tr -d [:blank:]
06372509

Crearemos un script simple:

# cat /etc/etckeeper/commit.d/40myown-push
#!/bin/sh
set -e

if [ "$VCS" = git ] && [ -d .git ]; then
  branch=$(cat /proc/cpuinfo | grep Serial | cut -d':' -f 2 | tr -d [:blank:])
  cd /etc/
  git push origin master:${branch}
fi

Y eso es todo, después de un tiempo podremos ver los cambios y crear una lista de paquetes para el firmware objetivo.