Accesso al file system root remoto utilizzando DB410 come dongle Ethernet: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Obiettivi:

• Installa toolchain e ricompila il kernel per inserire il supporto USB Ethernet CDC Gadget;
• Ricrea boot.img da Linaro per avviare USB Ethernet CDC;
• Crea un server NFS per ospitare il filesystem di root;
• Configurazione IP in DEVICE e HOST.

Passaggio 1: requisiti

Avrai bisogno dei seguenti articoli:

1. Un DragonBoard™ 410c (denominato qui DEVICE);
2. Un PC con Ubuntu 16.04.3 aggiornato (chiamato qui HOST) con connessione internet e slot SDCard;
3. Un'installazione pulita di Linaro-developer versione 431 - Link: Snapshot Linaro Debian v431
4. Un monitor HDMI;
5. Una tastiera USB;
6. una scheda SD da 8 Gb;
7. Un cavo USB, uUSB USB per collegare il DISPOSITIVO su HOST.

Passaggio 2: configurazione dell'host per la creazione del kernel e creazione del kernel nell'HOST

Innanzitutto, creeremo tutte le directory prima di continuare. Così:

$ cd ~

$ mkdir db410remoteroot $ cd db410remoteroot $ toolchain mkdir $ mkdir db410c-modules

Sfortunatamente, il kernel Linux usato da Linaro (Versione 431) non ha il supporto per il gadget USB Ethernet, a causa di ciò, il kernel Linux deve essere ricostruito per questa versione specifica. Scarica la toolchain Linaro per creare e distribuire il kernel Linux su Dragonboard410c dalla macchina host x86.

$ wget

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

Ora installa i pacchetti necessari per compilare il kernel:

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

Ottieni il codice sorgente del kernel Linux Clona il repository Linux del team di destinazione Qualcomm:

$ git clone

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

Ora, imposta le variabili di ambiente di compilazione:

$ export ARCH=arm64

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

A questo punto, dobbiamo aggiungere i moduli a USB Ethernet CDC nel kernel. L'ho fatto prima e puoi ottenerlo alla fine di questo passaggio. Ho rimosso alcuni elementi ma funziona.

Prima di compilare, correggere un bug del kernel in drivers/mmc/host/sdhci-msm.c cambiando la struttura nella riga 1150 in:

static const struct 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};

Decomprimi configfile.zip, copia il file.config nella directory del kernel, compila il kernel, i moduli e installa i moduli in una directory:

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

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

Riferimento: Documentazione 96Boards

Passaggio 3: ricostruire Boot.img nell'HOST

In questo passaggio, dobbiamo aprire l'immagine initrd, inserire i moduli compilati all'interno dell'immagine, configurare il sistema per avviare quei moduli e ricostruire un initrd.img con una nuova riga di comando del kernel per avviare il filesystem di root in remoto.

Quindi, per prima cosa, dobbiamo scaricare initrd.img dal sito web di linaro:

$ cd..

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

Ora, dopo il download, decomprimi ed estrai l'initrd:

$ zcat ramdisk.img | cpio -idmv

In questa directory, abbiamo il filesystem root utilizzato dal kernel nell'inizializzazione, quindi configureremo i moduli USB Ethernet CDC e i parametri remoti NFS come IP del server NFS ed ethernet (usb) necessari qui.

Ora, configuriamo alcuni file:

conf/initramfs.conf:

MODULI=più

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

Crea la directory init-premount nella directory scripts/

$ script mkdir/init-premount

e aggiungi i file in queste directory appena create:

ORDINE

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

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

USB

#!/bin/sh

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

Non dimenticare di usare chmod nel file usb per renderlo eseguibile:

$ chmod +x scripts/init-premount/usb

Ora, copia tutta la directory con i moduli da db410c-modules (PASSO 2) a lib/modules in initrd:

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

Rimuovi tutti i file in lib/modules/4.14.96-xxxx-dirty eccetto tutti i file module.* e quell'elenco di file:

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

Questi file sono tutti i moduli necessari per avviare USB Ethernet CDC.

Infine ricomprimi e comprimi l'immagine initrd:

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

Almeno, l'immagine del kernel e il file DTB devono essere compressi in un'immagine di avvio di Android. Tale immagine può essere generata con lo strumento abootimg.

Entriamo nella directory del kernel e usiamo il comando seguente per creare l'immagine e aggiungere DTB nell'immagine compressa del kernel:

$ cd../kernel

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

E infine, genera l'immagine di avvio (qui il nostro rootfs si trova in una partizione remota 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"

Riferimenti:

• https://access.redhat.com/solutions/24029
• 96Documentazione delle schede

Passaggio 4: creazione del file system radice nell'HOST

Ora abbiamo una nuova immagine di avvio per aggiornare la dragonboard 410c. Ma abbiamo bisogno di un filesystem di root nel server remoto per avviare moduli, servizi e applicazioni. In questo passaggio, creeremo una directory condivisa nell'host per salvare tutti questi dati. In questo modo scarichiamo un filesystem rootfs dal sito linaro con la stessa versione usata in initrd. Quindi, torna indietro di una directory e scarica l'immagine rootfs di linaro-developer con la versione 431.

$ cd..

$ wget

Decomprimi questo file

$ unzip dragonboard-410c-sdcard-developer-buster-431.zip

Usando questo file, scriviamo tutte le immagini in una sdcard per accedere a tutte le partizioni e copiare i file rootfs. Quindi, assicurati che venga eseguito il backup dei dati da uSDCard perché tutto su SDCard andrà perso.

Per trovare il nome del tuo dispositivo SDCard, rimuovi SDCard ed esegui il seguente comando:

$ lsblk

Salva nella tua mente tutti i nomi dei dischi riconosciuti. Ora inserisci SDCard, attendi un attimo ed esegui nuovamente il comando:

$ lsblk

Nota il disco appena riconosciuto. Questa sarà la tua SDCard. Ricorda il tuo nome e modifica il parametro "of=" per il nome del dispositivo SDCard e assicurati di utilizzare il nome del dispositivo senza la partizione, ad esempio: /dev/mmcblk0

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

Appunti:

• Questo comando richiederà del tempo per essere eseguito. Sii paziente ed evita di manomettere il terminale fino al termine del processo.
• Una volta che la scheda SD ha finito di lampeggiare, rimuoverla dal computer host.

Riferimento: documentazione 96boards

Passaggio 5: creazione del server NFS nell'host e copia dei file

A questo punto, abbiamo un'immagine di avvio da flashare in dragonboard 410c e una SDCard con un filesystem rootfs per i nostri moduli, servizi e applicazioni. Il passaggio successivo è creare una directory remota per connettere il DISPOSITIVO Ethernet USB insieme al filesystem HOST rootfs. Questo può essere fatto usando un pacchetto da Ubuntu chiamato nfs-kernel-server.

Questo pacchetto installa un servizio NFS in Ubuntu che consente di condividere alcune directory per alcuni dispositivi sulla rete, possiamo configurare quale directory verrà utilizzata per ciascun dispositivo utilizzando il tuo IP.

Quindi, installiamo il pacchetto e lo configuriamo.

$ sudo apt-get install nfs-kernel-server

Il servizio NFS si avvia automaticamente. Per controllare i servizi NFS utilizzare:

$ sudo service nfs-kernel-server restart // per riavviare o utilizzare 'stop' o 'start' secondo necessità.

Per verificare lo stato del servizio NFS dalla riga di comando utilizzare:

$ sudo service nfs-kernel-server status

nfsd in esecuzione // Il servizio è attivo nfsd non in esecuzione // Il servizio è inattivo

Ora, creiamo una directory principale /srv/nfs e creiamo una sottodirectory sotto quella per ogni filesystem root montato su NFS richiesto. Qui includiamo un filesystem root condiviso per mantenere il nostro filesystem root:

$ sudo mkdir -p /srv/nfs

$ sudo mkdir -p /srv/nfs/rootfs

Ora, il server NFS richiede che /etc/exports sia configurato correttamente, per controllare l'accesso a ciascuna directory del filesystem NFS a host specifici. In questo caso gli host sono identificati dal loro indirizzo IP. Quindi, per ogni filesystem root che viene creato, aggiungi la riga di controllo dell'esportazione a /etc/exports, adattando il tuo indirizzo IP locale e lo schema di denominazione della directory, se necessario. In questo tutorial, usiamo sempre che:

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

Inserisci nuovamente la tua SDCard, montala e copia tutto il filesystem rootfs in /srv/nfs/rootfs, riavvia il servizio NFS per aggiornare la directory utilizzando i nuovi file copiati.

Inoltre, abbiamo bisogno di copiare i nuovi file dei moduli nel filesystem rootfs perché abbiamo compilato il kernel al passaggio 2. Quindi, copia tutte le directory in ~/db410c-modules/ in /srv/nfs/rootfs.

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

Assicurati che queste directory siano rese visibili dal servizio NFS. O:

$ sudo exportfs -a

Riferimento: file system radice TFTP/NFS

Passaggio 6: aggiornamento dell'immagine di avvio di Dragonboard 410c e configurazione delle interfacce di rete

Abbiamo fatto in anticipo tutti i passaggi per implementare un filesystem rootfs remoto, ora abbiamo bisogno di aggiornare l'immagine di avvio all'interno di dragonboard 410c, per questo, collega il tuo cavo USB sul PC e sul connettore uUSB di dragonboard. Quindi assicurati che il fastboot sia impostato sul computer host, se non installalo usando:

$ sudo apt install fastboot

Ora per aggiornare l'immagine, avvia de dragonboard in modalità fastboot seguendo questi passaggi:

• Tieni premuto il pulsante Vol (-) sulla DragonBoard 410c, questo è il pulsante S4. DragonBoard™ 410c NON dovrebbe essere ancora acceso
• Tenendo premuto il pulsante Vol (-), accendi DragonBoard 410c collegandolo alla presa
• Una volta che DragonBoard 410c è collegato all'alimentazione, rilascia la presa sul pulsante Vol (-).
• Attendi circa 20 secondi.
• La scheda dovrebbe avviarsi in modalità fastboot.

Dalla finestra del terminale del computer host connesso, eseguire i seguenti comandi:

$ sudo dispositivi fastboot

In genere mostrerà come di seguito

de82318 avvio rapido

A questo punto dovresti essere connesso alla tua DragonBoard 410c con un cavo da USB a microUSB. La tua DragonBoard 410c dovrebbe essere avviata in modalità fastboot e pronta per essere flashata con le immagini appropriate. Aggiorniamo l'immagine di avvio con la nostra immagine di avvio:

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

E riavvia la scheda

$ sudo fastboot riavvio

Ora, il tuo HOST rileverà una nuova interfaccia denominata usb0, ma non ha ancora un IP. Quindi, aggiungi un IP statico a questa interfaccia usando:

$ sudo ifconfig usb0 10.42.0.1 netmask 255.255.255.0 up

Oppure entrare in "Configurazione" su HOST, alla voce "rete", impostando su USB Ethernet un IP statico a quell'interfaccia.

Ora, riavvia nuovamente la dragonboard e verifica l'avvio del sistema, provando a connetterti usando ssh:

$ ssh [email protected]

Riferimenti:

• 96schede documentazione
• HowtoForge - Articolo 6