Accesarea sistemului de fișiere rădăcină la distanță folosind DB410 ca dongle Ethernet: 6 pași

2025 Autor: John Day | [email protected]. Modificat ultima dată: 2025-01-23 15:04

Obiective:

• Instalați lanțul de instrumente și recompilați nucleul pentru a insera suportul USB Ethernet CDC Gadget;
• Recreați boot.img de la Linaro pentru a porni USB Ethernet CDC;
• Creați un server NFS pentru a găzdui sistemul de fișiere rădăcină;
• Configurare IP în DEVICE și HOST.

Pasul 1: Cerințe

Veți avea nevoie de următoarele elemente:

1. Un DragonBoard ™ 410c (denumit aici DISPOZITIV);
2. Un PC care utilizează Ubuntu 16.04.3 actualizat (denumit aici HOST) cu conexiune la internet și slot SDCard;
3. O instalare curată a versiunii 431 pentru dezvoltatori Linaro - Link: Instantaneu Linaro Debian v431
4. Un monitor HDMI;
5. O tastatură USB;
6. O card SDC de 8 GB;
7. Un cablu USB, USB USB pentru conectarea DISPOZITIVULUI la HOST.

Pasul 2: Configurarea gazdei pentru a construi kernel și a construi kernel în HOST

Mai întâi, vom crea toate directoarele înainte de a continua. Asa de:

$ cd ~

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

Din păcate, nucleul Linux utilizat de Linaro (versiunea 431) nu are suport pentru gadget-ul USB Ethernet, din această cauză, nucleul Linux trebuie reconstruit pentru această versiune specifică. Descărcați linaro toolchain pentru a construi și implementa nucleul Linux pe Dragonboard410c de pe mașina gazdă x86.

$ wget

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

Acum instalați pachetele necesare pentru a construi nucleul:

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

Obțineți sursa kernel-ului Linux Clone Qualcomm landing team Linux repository:

$ git clone

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

Acum, setați variabilele de mediu de compilare:

$ export ARCH = arm64

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

În acest moment, trebuie să adăugăm modulele la USB Ethernet CDC din kernel. Am făcut asta înainte și puteți obține acest lucru la sfârșitul acestui pas. Am îndepărtat câteva itens, dar funcționează.

Înainte de a compila, corectați o eroare de kernel în drivers / mmc / host / sdhci-msm.c schimbând structura din linia 1150 la:

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};

Decomprimați configfile.zip, copiați fișierul.config în directorul kernel, construiți kernel, module și instalați module într-un director:

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

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

Referință: 96Boards Documentation

Pasul 3: Reconstruiți Boot.img în HOST

În acest pas, trebuie să deschidem imaginea initrd, să punem modulele construite în interiorul imaginii, să configurăm sistemul pentru a porni modulele respective și să reconstruim un initrd.img cu o nouă linie de comandă a nucleului pentru a porni sistemul de fișiere rădăcină de la distanță.

Deci, mai întâi, trebuie să descărcăm initrd.img de pe site-ul linaro:

$ cd..

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

Acum, după descărcare, decomprimați și extrageți initrd:

$ zcat ramdisk.img | cpio -idmv

În acest director, avem sistemul de fișiere rădăcină folosit de kernel la inițializare, așa că vom configura aici modulele CDC USB Ethernet și parametrii de la distanță NFS, cum ar fi serverul NFS IP și ethernet (usb).

Acum, să configurăm câteva fișiere:

conf / initramfs.conf:

MODULURI = cele mai multe

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

Creați directorul init-premount în scripturile de director /

$ mkdir scripts / init-premount

și adăugați fișierele în acest director recent creat:

ORDIN

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

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

USB

#! / bin / sh

PREREQ = "" prereqs () {echo "$ PREREQ"} caz $ 1 în # obține prerequisite prereqs) prereqs ieșire 0;; esac modprobe usb_f_ecm modprobe libcomposite modprobe usb_f_rndis modprobe g_ether

Nu uitați să utilizați chmod în fișierul USB pentru al face executabil:

$ chmod + x scripturi / init-premount / usb

Acum, copiați tot directorul cu modulele din modulele db410c (PASUL 2) în lib / modules în initrd:

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

Eliminați toate fișierele din lib / modules / 4.14.96-xxxx-dirty, cu excepția tuturor modulelor de fișiere. * Și a listei de fișiere:

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 kernel.ko / 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 kernel /usb_f_serial.ko / 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

Aceste fișiere sunt toate modulele necesare pentru a porni USB Ethernet CDC.

Reambalați în final și comprimați imaginea initrd:

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

Cel puțin, imaginea kernelului și fișierul DTB trebuie să fie împachetate într-o imagine de boot Android. O astfel de imagine poate fi generată cu instrumentul abootimg.

Să intrăm în directorul kernelului și să folosim comanda de mai jos pentru a construi imaginea și a adăuga DTB în imaginea kernelului comprimată:

$ cd../kernel

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

Și, în cele din urmă, generați imaginea de boot (aici rootfs-ul nostru este localizat o partiție la distanță în 10.42.0.1)

abootimg --create boot-db410c.img -k Image.gz + dtb -r initrd_nfs.img -c size pages = 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"

Referințe:

• https://access.redhat.com/solutions/24029
• Documentația 96Boards

Pasul 4: Crearea sistemului de fișiere rădăcină în HOST

Acum, avem o nouă imagine de boot pentru a actualiza dragonboard 410c. Dar avem nevoie de un sistem de fișiere rădăcină pe serverul de la distanță pentru a porni module, servicii și aplicații. În acest pas, vom construi un director partajat în gazdă pentru a salva toate aceste date. În acest fel, să descărcăm un sistem de fișiere rootfs de pe site-ul linaro cu aceeași versiune folosită în initrd. Deci, reveniți la un director și descărcați imaginea root-linaro-developer cu versiunea 431.

$ cd..

$ wget

Decomprimați acest fișier

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

Folosind acest fișier, să scriem toată imaginea într-o sdcard pentru a accesa toate partițiile și a copia fișierele rootfs. Deci, asigurați-vă că datele de pe uSDCard sunt copiate, deoarece totul de pe SDCard se va pierde.

Pentru a găsi numele dispozitivului dvs. SDCard, eliminați cardul SDCard și executați următoarea comandă:

$ lsblk

Salvați în minte toate numele de discuri recunoscute. Acum introduceți cardul SDC, așteptați un moment și executați din nou comanda:

$ lsblk

Rețineți discul recent recunoscut. Aceasta va fi cardul dvs. SDCard. Amintiți-vă numele dvs. și modificați parametrul "of =" pentru numele dispozitivului dvs. SDCard și asigurați-vă că utilizați numele dispozitivului fără partiție, de ex.: / dev / mmcblk0

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

Note:

• Această comandă va dura ceva timp pentru a fi executată. Aveți răbdare și evitați manipularea terminalului până la terminarea procesului.
• Odată ce cardul SD este intermitent, scoateți-l de pe computerul gazdă.

Referință: documentație 96boards

Pasul 5: Crearea serverului NFS în HOST și copierea fișierelor

În acest moment, avem o imagine de încărcare pentru a fi afișată în dragonboard 410c și o SDCard cu un sistem de fișiere rootfs pentru modulele, serviciile și aplicațiile noastre. Următorul pas este crearea unui director de la distanță pentru conectarea dispozitivului USB Ethernet DEVICE la sistemul de fișiere rootOST HOST. Acest lucru se poate face folosind un pachet de la Ubuntu numit nfs-kernel-server.

Acest pachet instalează un serviciu NFS în Ubuntu permițând partajarea unor directoare pentru unele dispozitive din rețea, putem configura ce director va fi utilizat pentru fiecare dispozitiv folosind IP-ul dvs.

Deci, să instalăm pachetul și să-l configurăm.

$ sudo apt-get install nfs-kernel-server

Serviciul NFS pornește automat. Pentru a controla utilizarea serviciilor NFS:

$ sudo service nfs-kernel-server restart // pentru a reporni sau utilizați „stop” sau „start” după cum este necesar.

Pentru a verifica starea serviciului NFS din linia de comandă utilizați:

$ sudo service nfs-kernel-server status

nfsd rulează // Serviciul este în sus nfsd nu rulează // Serviciul este oprit

Acum, să creăm un director de top / srv / nfs și să creăm un subdirector sub cel pentru fiecare sistem de fișiere rădăcină montat NFS necesar. Aici includem un sistem de fișiere rădăcină partajat pentru a păstra sistemul nostru de fișiere rădăcină:

$ sudo mkdir -p / srv / nfs

$ sudo mkdir -p / srv / nfs / rootfs

Acum, serverul NFS necesită ca / etc / exporturile să fie configurate corect, pentru a controla accesul la fiecare director de sistem de fișiere NFS către anumite gazde. În acest caz, gazdele sunt identificate după adresa lor IP. Deci, pentru fiecare sistem de fișiere rădăcină care este creat, adăugați linia de control export la / etc / exporturi, ajustând pentru adresa IP locală și schema de denumire a directorului, dacă este necesar. În acest tutorial, folosim întotdeauna:

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

Introduceți din nou cardul SDC, montați-l și copiați tot sistemul de fișiere rootfs în / srv / nfs / rootfs, reporniți serviciul NFS pentru a actualiza directorul folosind noi fișiere copiate.

În plus, trebuie să copiem noile fișiere module în sistemul de fișiere rootfs, deoarece am compilat nucleul la pasul 2. Deci, copiați toate directoarele din ~ / db410c-modules / în / srv / nfs / rootfs.

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

Asigurați-vă că aceste directoare sunt făcute vizibile de către serviciul NFS. Fie:

$ sudo exportfs -a

Referință: TFTP / NFS Root Filesystem

Pasul 6: Actualizarea Dragonboard 410c Boot Image și configurarea interfețelor de rețea

Am făcut mai devreme toți pașii pentru a implementa un sistem de fișiere rootfs de la distanță, acum trebuie să actualizăm imaginea de boot din dragonboard 410c, pentru aceasta, conectați cablul USB al computerului și pe conectorul uUSB al dragonboardului. Deci, asigurați-vă că fastboot este configurat pe computerul gazdă, dacă nu instalați utilizând:

$ sudo apt instalează fastboot

Acum pentru a actualiza imaginea, porniți dragonboard în modul fastboot urmând acești pași:

• Țineți apăsat butonul Vol (-) de pe DragonBoard 410c, acesta este butonul S4. DragonBoard ™ 410c încă nu ar trebui să fie pornit
• Ținând apăsat butonul Vol (-), porniți DragonBoard 410c conectându-l
• Odată ce DragonBoard 410c este conectat la alimentare, eliberați apăsarea butonului Vol (-).
• Așteptați aproximativ 20 de secunde.
• Placa ar trebui să pornească în modul fastboot.

Din fereastra terminalului conectat al mașinii gazdă, executați următoarele comenzi:

Dispozitive $ sudo fastboot

De obicei, va apărea după cum urmează

de82318 fastboot

În acest moment ar trebui să fiți conectat la DragonBoard 410c cu un cablu USB la microUSB. DragonBoard 410c ar trebui să fie pornit în modul fastboot și gata să fie intermitent cu imaginile corespunzătoare. Să actualizăm imaginea de boot cu imaginea de boot a noastră:

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

Și, reporniți placa

$ sudo repornire rapidă

Acum, HOST-ul dvs. va detecta o nouă interfață numită usb0, dar nu are încă un IP. Deci, adăugați un IP static la această interfață folosind:

$ sudo ifconfig usb0 10.42.0.1 netmask 255.255.255.0 up

Sau introduceți în „Configurare” pe HOST, în elementul „rețea”, setând USB Ethernet un IP static la acea interfață.

Acum, reporniți din nou dragonboard-ul și verificați pornirea sistemului, încercând să vă conectați folosind ssh:

$ ssh [email protected]

Referințe:

• 96 panouri documentație
• HowtoForge - Punctul 6