🥇 Erstellung eines Ubuntu-Images für ARM „from scratch“

Wenn die Entwicklung gerade beginnt, ist oft noch unklar, welche Pakete in das Ziel-rootfs gehen werden.

Mit anderen Worten, es ist noch zu früh, um sich mit LFS, buildroot oder yocto (oder etwas anderem) zu beschäftigen, aber man muss bereits anfangen. Für die wohlhabenden (ich habe auf meinen Prototypen 4GB eMMC) gibt es die Möglichkeit, den Entwicklern eine Distribution zur Verfügung zu stellen, die es ermöglicht, schnell etwas zur Verfügung zu stellen, was momentan fehlt. Danach können wir immer die Paketlisten zusammenstellen und eine Liste für das Ziel-rootfs erstellen.

Dieser Artikel enthält keine Neuheiten und ist eine einfache Copy-Paste-Anleitung.

Ziel des Artikels ist der Aufbau von Ubuntu rootfs für ARM-Boards (in meinem Fall basierend auf Colibri imx7d).

Der Build des Images

Wir erstellen das Ziel-rootfs zur Vervielfältigung.

Wir entpacken das Ubuntu Base

Die Release-Version wählen wir selbst aus, je nach Notwendigkeit und persönlichen Vorlieben. Hier habe ich 20 aufgeführt.

$ 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

Überprüfung der BINFMT-Unterstützung im Kernel

Wenn Sie eine verbreitete Distribution haben, gibt es die Unterstützung für BINFMT_MISC und alles ist eingerichtet. Andernfalls bin ich mir sicher, dass Sie wissen, wie Sie die Unterstützung für BINFMT im Kernel aktivieren.

Stellen Sie sicher, dass BINFMT_MISC im Kernel aktiviert ist:

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

Jetzt müssen die Einstellungen überprüft werden:

$ 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

Manuell registrieren kann man mit beispielsweise dieser Anleitung.

Konfiguration von qemu static arm

Jetzt benötigen wir eine statisch kompilierte Version von qemu.

!!! ACHTUNG!!!
Wenn Sie planen, einen Container zum Kompilieren zu verwenden, lesen Sie:
https://sourceware.org/bugzilla/show_bug.cgi?id=23960
https://bugs.launchpad.net/qemu/+bug/1805913
Dann muss für einen x86_64 Host und einen Arm Gast die i386-Version von qemu verwendet werden:
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
$ alien -t qemu-user-static_5.0-13_amd64.deb
# Der Pfad im rootfs und der Name der ausführbaren Datei müssen mit /proc/sys/fs/binfmt_misc/qemu-arm übereinstimmen
$ 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), statisch verlinkt, BuildID[sha1]=be45f9a321cccc5c139cc1991a4042907f9673b6, für 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), statisch verlinkt, BuildID[sha1]=be45f9a321cccc5c139cc1991a4042907f9673b6, für GNU/Linux 3.2.0, stripped

Chroot

Ein einfaches Skript:

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

Bewundern wir das erhaltene Ergebnis:

$ ./ch-mount.sh -m rootfs/
# cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
# uname -a
Linux NShubin 5.5.9-gentoo-x86_64 #1 SMP PREEMPT Mon Mar 16 14:34:52 MSK 2020 armv7l armv7l armv7l GNU/Linux

Aus Interesse messen wir die Größe vor und nach der Installation des minimalen (für mich) Paketsets:

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

Aktualisieren wir:

# apt update
# apt upgrade --yes

Installieren wir die Pakete, die uns interessieren:

# 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

Die Header-Dateien des Kernels und Module sind ein separates Thema. Den Bootloader, Kernel und Module sowie die Device-Tree-Files werden wir über Ubuntu natürlich nicht installieren. Diese kommen von außen, entweder wir bauen sie selbst oder der Hersteller des Boards stellt sie uns zur Verfügung. In jedem Fall liegt das außerhalb dieser Anleitung.

Bis zu einem gewissen Grad sind Abweichungen der Versionen akzeptabel, aber es ist besser, sie mit der Kernel-Build zu beziehen.

# apt install --yes linux-headers-generic

Sehen wir uns an, was herausgekommen ist, und es ist nicht wenig:

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

Vergessen Sie nicht, ein Passwort festzulegen.

Packen wir das Image

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

Zusätzlich können wir etckeeper mit der Autopush-Konfiguration installieren.

Angenommen, wir haben unser Build verteilt, die Arbeit hat begonnen, wie sammeln wir später verschiedene Versionen unseres Systems am besten zusammen.

Etckeeper kann uns helfen.

Sicherheit ist persönliche Angelegenheit:

Sie können bestimmte Branches schützen

einen einzigartigen Schlüssel für jedes Gerät generieren

Force Push verbieten

usw. …

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

Wir richten Autopush ein

Wir können natürlich im Voraus Branches auf dem Gerät erstellen (wir könnten ein Skript oder einen Dienst machen, der beim ersten Start ausgeführt wird).

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

Oder wir gehen einen clevereren Weg…

Die bequeme Lösung

Lassen Sie uns eine Art einzigartige ID haben, z.B. die Seriennummer des Prozessors (oder MAC — seriöse Unternehmen kaufen einen Bereich):

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

Dann können wir ihn als Branch-Namen verwenden, in den wir pushen werden:

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

Lassen Sie uns ein einfaches Skript erstellen:

# 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

Und das ist alles — nach einer gewissen Zeit können wir die Änderungen einsehen und eine Liste der Pakete für das Ziel-Flash erstellen.