Zugriff auf das Remote-Root-Dateisystem mit DB410 als Ethernet-Dongle - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Ziele:

• Installieren Sie die Toolchain und kompilieren Sie den Kernel neu, um die Unterstützung für USB-Ethernet-CDC-Gadgets einzufügen;
• Erstellen Sie boot.img von Linaro neu, um USB-Ethernet-CDC zu booten;
• Erstellen Sie einen NFS-Server, um das Root-Dateisystem zu hosten;
• IP-Konfiguration in DEVICE und HOST.

Schritt 1: Anforderungen

Sie benötigen die folgenden Elemente:

1. Ein DragonBoard™ 410c (hier als DEVICE bezeichnet);
2. Ein PC mit Ubuntu 16.04.3 aktualisiert (hier HOST genannt) mit Internetverbindung und SDCard-Steckplatz;
3. Eine saubere Installation der Linaro-Entwicklerversion 431 - Link: Snapshot Linaro Debian v431
4. Ein HDMI-Monitor;
5. Eine USB-Tastatur;
6. Eine 8-GB-SD-Karte;
7. Ein USB-Kabel, uUSB USB, um das GERÄT mit dem HOST zu verbinden.

Schritt 2: Konfigurieren des Hosts zum Erstellen von Kernel und Erstellen des Kernels im HOST

Zuerst erstellen wir alle Verzeichnisse, bevor wir fortfahren. So:

$ cd ~

$ mkdir db410remoteroot $ cd db410remoteroot $ mkdir Toolchain $ mkdir db410c-modules

Leider unterstützt der von Linaro verwendete Linux-Kernel (Version 431) kein USB-Ethernet-Gadget, daher muss der Linux-Kernel für diese spezielle Version neu erstellt werden. Laden Sie die Linaro-Toolchain herunter, um den Linux-Kernel auf Dragonboard410c von einem x86-Hostcomputer zu erstellen und bereitzustellen.

$ wget

$ tar -xf gcc-*-x86_64_aarch64-linux-gnu.tar.xz -C./toolchain --strip-components=1

Installieren Sie nun Pakete, die zum Erstellen des Kernels benötigt werden:

$ sudo apt update && sudo apt-get install git build-essential abootimg kernel-package fakeroot libncurses5-dev libssl-dev ccache

Holen Sie sich die Linux-Kernel-Quelle Klonen Sie das Linux-Repository des Qualcomm-Landing-Teams:

$ git-Klon

$ cd kernel $ git checkout origin/release/qcomlt-4.14 -b my-custom-4.14

Legen Sie nun die Umgebungsvariablen für die Kompilierung fest:

$ export ARCH=arm64

$ export CROSS_COMPILE=$(pwd)/../toolchain/bin/aarch64-linux-gnu-

An dieser Stelle müssen wir die Module zu USB Ethernet CDC im Kernel hinzufügen. Ich habe das zuvor getan und Sie können dies am Ende dieses Schritts erhalten. Ich habe einige Elemente entfernt, aber es funktioniert.

Korrigieren Sie vor dem Kompilieren einen Kernel-Fehler in driver/mmc/host/sdhci-msm.c und ändern Sie die Struktur in der Zeile 1150 in:

statisches Konstrukt sdhci_ops sdhci_msm_ops = {

. Reset = sdhci_reset,.set_clock = sdhci_msm_set_clock,.get_min_clock = sdhci_msm_get_min_clock,.get_max_clock = sdhci_msm_get_max_clock,.set_bus_width = sdhci_set_bus_width,.set_uhs_signaling = sdhci_msm_set_uhs_signaling,.voltage_switch = sdhci_msm_voltage_switch, #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS.write_w = sdhci_msm_write_w, endif};

Entpacken Sie configfile.zip, kopieren Sie die.config-Datei in das Kernel-Verzeichnis, bauen Sie den Kernel, die Module und installieren Sie die Module in einem Verzeichnis:

$ make -j$(nproc) Image.gz dtbs

$ make -j$(nproc) modules $ make modules_install INSTALL_MOD_PATH=../db410c-modules

Referenz: 96Boards-Dokumentation

Schritt 3: Boot.img im HOST neu erstellen

In diesem Schritt müssen wir das initrd-Image öffnen, die eingebauten Module in das Image einfügen, das System so konfigurieren, dass es diese Module startet, und eine initrd.img mit einer neuen Kernel-Befehlszeile neu erstellen, um das Root-Dateisystem remote zu booten.

Zuerst müssen wir initrd.img von der Linaro-Website herunterladen:

$ cd..

$ mkdir inird_nfs $ cd initrd_nfs $ wget -O ramdisk.img

Entpacken und extrahieren Sie nun nach dem Download die initrd:

$ zcat ramdisk.img | cpio -idmv

In diesem Verzeichnis haben wir das Root-Dateisystem, das vom Kernel bei der Initialisierung verwendet wird, daher konfigurieren wir USB-Ethernet-CDC-Module und NFS-Remote-Parameter wie NFS-Server-IP und Ethernet (usb), die hier benötigt werden.

Lassen Sie uns nun einige Dateien konfigurieren:

conf/initramfs.conf:

MODULE=die meisten

BUSYBOX=auto COMPRESS=gzip DEVICE=usb0 NFSROOT=auto RUNSIZE=10%

Erstellen Sie das Verzeichnis init-premount im Verzeichnis scripts/

$ mkdir scripts/init-premount

und fügen Sie die Dateien in diesem gerade erstellten Verzeichnis hinzu:

AUFTRAG

/scripts/init-premount/usb "$@"

[-e /conf/param.conf] &&. /conf/param.conf

USB

#!/bin/sh

PREREQ="" prereqs() { echo "$PREREQ" } case $1 in # Voraussetzungen abrufen prereqs) prereqs exit 0;; esac modprobe usb_f_ecm modprobe libcomposite modprobe usb_f_rndis modprobe g_ether

Vergessen Sie nicht, chmod in der USB-Datei zu verwenden, um sie ausführbar zu machen:

$ chmod +x scripts/init-premount/usb

Kopieren Sie nun alle Verzeichnisse mit den Modulen von db410c-modules (STEP 2) nach lib/modules in initrd:

$ cp -R../db410-modules/lib usr/

Entfernen Sie alle Dateien in lib/modules/4.14.96-xxxx-dirty außer allen Dateien module.* und dieser Dateiliste:

kernel/drivers/usb/gadget/legacy/g_ether.ko

kernel/drivers/usb/gadget/legacy/g_mass_storage.ko kernel/drivers/usb/gadget/legacy/g_cdc.ko kernel/drivers/usb/gadget/legacy/g_serial.ko kernel/drivers/usb/gadget/function/usb_f_mass_storage.ko kernel/drivers/usb/gadget/function/usb_f_acm.ko kernel/drivers/usb/gadget/function/u_ether.ko kernel/drivers/usb/gadget/function/usb_f_obex.ko kernel/drivers/usb/gadget/function /usb_f_serial.ko kernel/drivers/usb/gadget/function/usb_f_ecm.ko kernel/drivers/usb/gadget/function/usb_f_rndis.ko kernel/drivers/usb/gadget/function/u_serial.ko kernel/drivers/usb/gadget /function/usb_f_fs.ko kernel/drivers/usb/gadget/function/usb_f_ecm_subset.ko kernel/drivers/usb/gadget/libcomposite.ko

Diese Dateien sind alle Module, die zum Starten von USB Ethernet CDC benötigt werden.

Zum Schluss das initrd-Image neu packen und komprimieren:

$ finden. | cpio -o -H newc | gzip -9 >../kernel/initrd_nfs.img

Zumindest müssen das Kernel-Image und die DTB-Datei in ein Android-Boot-Image gepackt werden. Ein solches Image kann mit einem Bootimg-Tool erstellt werden.

Lassen Sie uns in das Kernel-Verzeichnis gehen und den folgenden Befehl verwenden, um das Image zu erstellen und DTB in das komprimierte Kernel-Image anzuhängen:

$ cd../kernel

$ cat arch/$ARCH/boot/Image.gz arch/$ARCH/boot/dts/qcom/apq8016-sbc.dtb > Image.gz+dtb

Und schließlich das Boot-Image generieren (hier befindet sich unser rootfs auf einer Remote-Partition in 10.42.0.1).

abootimg --create boot-db410c.img -k Image.gz+dtb -r initrd_nfs.img -c pagesize=2048

-c kerneladdr=0x80008000 -c ramdiskaddr=0x81000000 -c cmdline="root=/dev/nfs nfsroot=10.42.0.1:/srv/nfs/rootfs ip=10.42.0.2:10.42.0.1:10.42.0.1:255.255.255.0:db410c:usb0:off rw rootwait console=tty0 console=ttyMSM0, 115200n8"

Verweise:

• https://access.redhat.com/solutions/24029
• 96Boards-Dokumentation

Schritt 4: Root-Dateisystem im HOST erstellen

Jetzt haben wir ein neues Boot-Image, um das Dragonboard 410c zu aktualisieren. Aber wir brauchen ein Root-Dateisystem im Remote-Server, um Module, Dienste und Anwendungen zu booten. In diesem Schritt erstellen wir ein freigegebenes Verzeichnis im Host, um all diese Daten zu speichern. Auf diese Weise laden wir ein rootfs-Dateisystem von der Linaro-Site mit derselben Version herunter, die in initrd verwendet wird. Gehen Sie also ein Verzeichnis zurück und laden Sie das Rootfs-Image des Linaro-Entwicklers mit Version 431 herunter.

$ cd..

$ wget

Entpacken Sie diese Datei

$ Dragonboard-410c-sdcard-developer-buster-431.zip entpacken

Mit dieser Datei schreiben wir alle Bilder auf eine SD-Karte, um auf alle Partitionen zuzugreifen und Rootfs-Dateien zu kopieren. Stellen Sie also sicher, dass die Daten von der uSDCard gesichert werden, da alles auf der SDCard verloren geht.

Um Ihren SDCard-Gerätenamen zu finden, entfernen Sie die SDCard und führen Sie den folgenden Befehl aus:

$ lsblk

Speichern Sie alle erkannten Festplattennamen im Kopf. Legen Sie nun die SDCard ein, warten Sie einen Moment und führen Sie den Befehl erneut aus:

$ lsblk

Beachten Sie die neu erkannte Festplatte. Dies wird Ihre SD-Karte sein. Merken Sie sich Ihren Namen und ändern Sie den Parameter "of=" für Ihren SDCard-Gerätenamen und verwenden Sie den Gerätenamen ohne die Partition, z. B.: /dev/mmcblk0

$ sudo dd if=dragonboard-410c-sdcard-developer-buster-431.img of=/dev/XXX bs=4M oflag=sync status=progress

Anmerkungen:

• Die Ausführung dieses Befehls dauert einige Zeit. Seien Sie geduldig und vermeiden Sie Manipulationen am Terminal, bis der Vorgang abgeschlossen ist.
• Sobald die SD-Karte mit dem Flashen fertig ist, entfernen Sie sie vom Host-Computer.

Referenz: 96boards Dokumentation

Schritt 5: Server-NFS im HOST erstellen und Dateien kopieren

An dieser Stelle haben wir ein Boot-Image, das in Dragonboard 410c geflasht wird, und eine SD-Karte mit einem Rootfs-Dateisystem für unsere Module, Dienste und Anwendungen. Der nächste Schritt besteht darin, ein Remote-Verzeichnis zu erstellen, um das USB-Ethernet-GERÄT mit dem HOST-rootfs-Dateisystem mitguther zu verbinden. Dies kann mit einem Paket von Ubuntu namens nfs-kernel-server erfolgen.

Dieses Paket installiert einen NFS-Dienst in Ubuntu, der es ermöglicht, einige Verzeichnisse für einige Geräte im Netzwerk freizugeben. Wir können konfigurieren, welches Verzeichnis für jedes Gerät verwendet wird, indem Sie Ihre IP verwenden.

Also installieren wir das Paket und konfigurieren es.

$ sudo apt-get install nfs-kernel-server

Der NFS-Dienst startet automatisch. So steuern Sie die Verwendung von NFS-Diensten:

$ sudo service nfs-kernel-server restart // um neu zu starten, oder verwenden Sie 'stop' oder 'start' nach Bedarf.

Um den Status des NFS-Dienstes über die Befehlszeile zu überprüfen, verwenden Sie:

$ sudo service nfs-kernel-server status

nfsd läuft // Dienst ist aktiv nfsd läuft nicht // Dienst ist inaktiv

Lassen Sie uns nun ein oberstes Verzeichnis /srv/nfs erstellen und ein Unterverzeichnis darunter für jedes benötigte NFS-gemountete Root-Dateisystem erstellen. Hier fügen wir ein gemeinsam genutztes Root-Dateisystem ein, um unser Root-Dateisystem beizubehalten:

$ sudo mkdir -p /srv/nfs

$ sudo mkdir -p /srv/nfs/rootfs

Jetzt erfordert der NFS-Server, dass /etc/exports richtig konfiguriert ist, um den Zugriff auf jedes NFS-Dateisystemverzeichnis für bestimmte Hosts zu steuern. In diesem Fall werden die Hosts anhand ihrer IP-Adresse identifiziert. Fügen Sie also für jedes erstellte Root-Dateisystem die Exportkontrollzeile zu /etc/exports hinzu und passen Sie gegebenenfalls Ihre lokale IP-Adresse und das Verzeichnisnamensschema an. In diesem Tutorial verwenden wir immer Folgendes:

/srv/nfs/rootfs 10.42.0.2(rw, sync, no_root_squash, no_subtree_check)

Legen Sie Ihre SD-Karte erneut ein, mounten Sie sie und kopieren Sie das gesamte Rootfs-Dateisystem nach /srv/nfs/rootfs, starten Sie den NFS-Dienst neu, um das Verzeichnis mit den neu kopierten Dateien zu aktualisieren.

Außerdem müssen wir die neuen Moduldateien in das Rootfs-Dateisystem kopieren, da wir den Kernel in Schritt 2 kompiliert haben. Kopieren Sie also alle Verzeichnisse in ~/db410c-modules/ nach /srv/nfs/rootfs.

$ sudo cp -R ~/db410c-modules/* /srv/nfs/rootfs/

Stellen Sie sicher, dass diese Verzeichnisse vom NFS-Dienst sichtbar gemacht werden. Entweder:

$ sudo exportfs -a

Referenz: TFTP/NFS Root-Dateisystem

Schritt 6: Dragonboard 410c Boot-Image aktualisieren und Netzwerkschnittstellen konfigurieren

Wir haben früh alle Schritte unternommen, um ein Remote-Rootfs-Dateisystem zu implementieren, jetzt müssen wir das Boot-Image in Dragonboard 410c aktualisieren, dafür schließen Sie Ihr USB-Kabel an den PC und den Dragonboard-uUSB-Anschluss an. Stellen Sie also sicher, dass Fastboot auf dem Host-Computer eingerichtet ist, wenn nicht mit:

$ sudo apt installiere fastboot

Um nun das Image zu aktualisieren, starten Sie das Dragonboard in den Fastboot-Modus, indem Sie die folgenden Schritte ausführen:

• Halten Sie die Vol (-)-Taste am DragonBoard 410c gedrückt, dies ist die S4-Taste. DragonBoard™ 410c sollte immer noch NICHT eingeschaltet sein
• Halten Sie die Lautstärketaste (-) gedrückt und schalten Sie das DragonBoard 410c ein, indem Sie es einstecken
• Sobald das DragonBoard 410c an das Stromnetz angeschlossen ist, lassen Sie die Lautstärketaste (-) los.
• Warten Sie etwa 20 Sekunden.
• Board sollte im Fastboot-Modus booten.

Führen Sie im Terminalfenster des verbundenen Hostcomputers die folgenden Befehle aus:

$ sudo Fastboot-Geräte

Normalerweise wird es wie folgt angezeigt

de82318 Fastboot

Zu diesem Zeitpunkt sollten Sie mit einem USB-zu-Micro-USB-Kabel mit Ihrem DragonBoard 410c verbunden sein. Ihr DragonBoard 410c sollte im Fastboot-Modus gebootet und bereit sein, mit den entsprechenden Images geflasht zu werden. Lassen Sie uns das Boot-Image mit unserem Boot-Image aktualisieren:

$ sudo fastboot flash boot ~/db410remoteroot/kernel/initrd_nfs.img

Und starte das Board neu

$ sudo Fastboot-Neustart

Jetzt erkennt Ihr HOST eine neue Schnittstelle namens usb0, die jedoch noch keine IP hat. Fügen Sie dieser Schnittstelle also eine statische IP hinzu, indem Sie Folgendes verwenden:

$ sudo ifconfig usb0 10.42.0.1 Netzmaske 255.255.255.0 up

Oder geben Sie in "Konfiguration" auf dem HOST im Punkt "Netzwerk" ein und setzen Sie USB-Ethernet eine statische IP für diese Schnittstelle.

Starten Sie nun das Dragonboard erneut und überprüfen Sie den Systemstart, indem Sie versuchen, eine Verbindung mit ssh herzustellen:

$ ssh [email protected]

Verweise:

• 96boards-Dokumentation
• HowtoForge - Artikel 6