Få åtkomst till fjärrrotfilsystem med DB410 som en Ethernet -Dongle: 6 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

Mål:

• Installera verktygskedja och kompilera om kärnan för att sätta in USB Ethernet CDC Gadget -stöd;
• Återskapa boot.img från Linaro för att starta USB Ethernet CDC;
• Skapa NFS -server för att vara värd för rotfilsystem;
• IP -konfiguration i ENHET och HOST.

Steg 1: Krav

Du behöver följande itens:

1. En DragonBoard ™ 410c (heter här ENHET);
2. En dator med Ubuntu 16.04.3 uppdaterad (heter här HOST) med internetanslutning och SDCard -kortplats;
3. En ren installation av Linaro -utvecklare version 431 - Länk: Snapshot Linaro Debian v431
4. En HDMI -skärm;
5. Ett USB -tangentbord;
6. Ett 8 Gb SDCard;
7. En USB -kabel, uUSB USB för att ansluta ENHETEN på HOST.

Steg 2: Konfigurera värd för att bygga kärna och bygga kärna i HOST

Först skapar vi alla kataloger innan vi fortsätter. Så:

$ cd ~

$ mkdir db410remoteroot $ cd db410remoteroot $ mkdir verktygskedja $ mkdir db410c-moduler

Tyvärr har Linux -kärnan som används av Linaro (version 431) inte stöd för USB Ethernet -gadget, därför måste Linux -kärnan byggas om för den här specifika versionen. Ladda ner Linaro toolchain för att bygga och distribuera Linux -kärnan på Dragonboard410c från x86 -värdmaskin.

$ wget

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

Installera nu paket som krävs för att bygga kärnan:

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

Skaffa Linux Kernel source Clone Qualcomm landing team Linux repository:

$ git-klon

$ cd-kärnan $ git checkout origin/release/qcomlt-4.14 -b my-custom-4.14

Ställ nu in kompilationsmiljövariabler:

$ export ARCH = arm64

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

Vid denna tidpunkt måste vi lägga till modulerna till USB Ethernet CDC i kärnan. Jag gjorde det förut och du kan få det här i slutet av det här steget. Jag tog bort några itens men det fungerar.

Innan du kompilerar, korrigera en kärnfel till drivers/mmc/host/sdhci-msm.c genom att ändra strukturen i raden 1150 till:

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

Komprimera configfile.zip, kopiera.config -filen till kärnkatalogen, bygg kärnan, moduler och installera moduler i en katalog:

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

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

Referens: 96Boards Documentation

Steg 3: Bygg om Boot.img i HOST

I det här steget måste vi öppna initrd -bilden, sätta modulerna inbyggda i bilden, konfigurera systemet för att starta modulerna och bygga om en initrd.img med en ny kommandorad för att starta rotfilsystemet på distans.

Så först måste vi ladda ner initrd.img från linaros webbplats:

$ cd..

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

Nu, efter nedladdning, packa upp och extrahera initrd:

$ zcat ramdisk.img | cpio -idmv

I den här katalogen har vi rotfilsystemet som används av kärnan vid initialisering, så vi konfigurerar USB Ethernet CDC -moduler och NFS -fjärrparametrar som NFS -server -IP och ethernet (usb) som behövs här.

Låt oss nu konfigurera några filer:

conf/initramfs.conf:

MODULER = de flesta

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

Skapa katalogen init-premount i katalogskripten/

$ mkdir-skript/init-premount

och lägg till filerna i dessa just skapade katalog:

BESTÄLLA

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

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

usb

#!/bin/sh

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

Glöm inte att använda chmod i usb -fil för att göra den körbar:

$ chmod +x scripts/init-premount/usb

Kopiera nu alla kataloger med modulerna från db410c-moduler (STEG 2) till lib/modules i initrd:

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

Ta bort alla filer i lib/modules/4.14.96-xxxx-dirty utom alla filmoduler.* Och den fillistan:

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 -kärnan/drivers/usb/gadget/function/usb_f_ecm.ko -kärnan/drivers/usb/gadget/function/usb_f_rndis.ko -kärnan/drivers/usb/gadget/function/u_serial.ko -kärnan/drivers/usb/gadget /function/usb_f_fs.ko -kärnan/drivers/usb/gadget/function/usb_f_ecm_subset.ko -kärnan/drivers/usb/gadget/libcomposite.ko

Dessa filer är alla moduler som behövs för att starta USB Ethernet CDC.

Slutligen packa om och komprimera initrd -bilden:

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

Åtminstone måste kärnbilden och DTB -filen packas in i en Android -startbild. Sådan bild kan genereras med abootimg -verktyg.

Låt oss i kärnkatalogen och använd kommandot nedan för att bygga bild och lägga till DTB i den komprimerade kärnbilden:

$ cd../kernel

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

Och slutligen, generera startbilden (här ligger våra rootfs en fjärrpartition i 10.42.0.1)

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

Referenser:

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

Steg 4: Skapa rotfilsystem i HOST

Nu har vi en ny startbild för att uppdatera Dragonboard 410c. Men vi behöver ett rotfilsystem i fjärrservern för att starta moduler, tjänster och applikationer. I det här steget kommer vi att bygga en delad katalog i värden för att spara alla dessa data. På det sättet, låt oss ladda ner ett rootfs filsystem från linaro -webbplats med samma version som används i initrd. Så gå tillbaka en katalog och ladda ner linaro-developer rootfs-bild med version 431.

$ cd..

$ wget

Komprimera den här filen

$ packa upp dragonboard-410c-sdcard-developer-buster-431.zip

Med den här filen, låt oss skriva all bild i ett sdcard för att komma åt alla partitioner och kopiera rootfs -filer. Så se till att data från uSDCard säkerhetskopieras eftersom allt på SDCard går förlorat.

För att hitta ditt SDCard -enhetsnamn, ta bort SDCard och kör följande kommando:

$ lsblk

Spara i ditt sinne alla erkända disknamn. Sätt nu in SDCard, vänta en stund och kör kommandot igen:

$ lsblk

Notera den nyligen erkända disken. Detta blir ditt SDCard. Kom ihåg ditt namn och ändra parametern "of =" för ditt SDCard -enhetsnamn och se till att använda enhetsnamnet utan partitionen, p.e.: /dev /mmcblk0

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

Anmärkningar:

• Detta kommando tar lite tid att utföra. Var tålmodig och undvik att manipulera terminalen tills processen är slut.
• När SD -kortet har blinkat tar du bort det från värddatorn.

Referens: 96boards dokumentation

Steg 5: Skapa Server NFS i HOST och kopiera filer

I denna punkt har vi en startbild som ska flashas in i dragonboard 410c och ett SDCard med ett rootfs filsystem för våra moduler, tjänster och applikationer. Nästa steg är att skapa en fjärrkatalog för att ansluta USB Ethernet -ENHETEN tillsammans med HOST rootfs -filsystem. Det kan göras med ett paket från Ubuntu som heter nfs-kernel-server.

Detta paket installerar en NFS -tjänst i Ubuntu som tillåter att dela några kataloger för vissa enheter i nätverket, vi kan konfigurera vilken katalog som ska användas för varje enhet med din IP.

Så, låt oss installera paketet och konfigurera det.

$ sudo apt-get install nfs-kernel-server

NFS -tjänsten startar automatiskt. För att styra NFS -tjänster använder du:

$ sudo service nfs-kernel-server restart // för att starta om, eller använd 'stop' eller 'start' efter behov.

För att kontrollera statusen för NFS -tjänsten från kommandoraden, använd:

$ sudo service nfs-kernel-server status

nfsd körs // Tjänsten är upp nfsd körs inte // Tjänsten är nere

Låt oss nu skapa en toppkatalog /srv /nfs och skapa en underkatalog under den för varje NFS -monterat rotfilsystem som krävs. Här inkluderar vi ett delat rotfilsystem för att behålla vårt rotfilsystem:

$ sudo mkdir -p /srv /nfs

$ sudo mkdir -p/srv/nfs/rootfs

Nu kräver NFS -servern /etc /exports att konfigureras korrekt för att styra åtkomsten till varje NFS -filsystemkatalog till specifika värdar. I det här fallet identifieras värdarna med deras IP -adress. Så, för varje rotfilsystem som skapas, lägg till exportkontrollraden till /etc /exports, justera för din lokala IP -adress och katalognamnschema om det behövs. I den här självstudien använder vi alltid det:

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

Sätt in ditt SDCard igen, montera det och kopiera alla rootfs filsystem till/srv/nfs/rootfs, starta om NFS -tjänsten för att uppdatera katalogen med nya kopierade filer.

Dessutom behöver vi kopiera de nya modulfilerna till rootfs filsystem eftersom vi sammanställde kärnan i steg 2. Så kopiera alla kataloger i ~/db410c-modules/till/srv/nfs/rootfs.

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

Se till att dessa kataloger synliggörs av NFS -tjänsten. Antingen:

$ sudo exportfs -a

Referens: TFTP/NFS rotfilsystem

Steg 6: Uppdatera Dragonboard 410c Boot Image och konfigurera nätverksgränssnitt

Vi gjorde tidigt alla steg för att implementera ett fjärrsystem för rootfs -filer, nu behöver vi uppdatera startbilden inuti dragonboard 410c, för att ansluta din USB -kabel till PC och dragonboard uUSB -kontakt. Så se till att fastboot är konfigurerat på värddatorn, om inte installeras med:

$ sudo apt installera fastboot

Nu för att uppdatera bilden, starta dragonboard till snabbstartsläge enligt dessa steg:

• Tryck och håll ner Vol (-) -knappen på DragonBoard 410c, detta är S4-knappen. DragonBoard ™ 410c ska fortfarande INTE vara påslagen
• Medan du håller Vol (-)-knappen sätter du på DragonBoard 410c genom att ansluta den
• När DragonBoard 410c har anslutits till strömmen släpper du volymknappen (-).
• Vänta i cirka 20 sekunder.
• Kortet ska starta i snabbstartsläge.

Kör följande kommandon från det anslutna värdmaskinterminalfönstret:

$ sudo fastboot -enheter

Normalt kommer det att visas som nedan

de82318 fastboot

Vid denna tidpunkt bör du vara ansluten till din DragonBoard 410c med en USB till microUSB -kabel. Din DragonBoard 410c bör startas upp i snabbstartsläge och redo att blixtras med lämpliga bilder. Låt oss uppdatera startbilden med vår startbild:

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

Och starta om styrelsen

$ sudo fastboot starta om

Nu kommer din HOST att upptäcka ett nytt gränssnitt som heter usb0, men det har ingen IP än. Så lägg till en statisk IP till det här gränssnittet med:

$ sudo ifconfig usb0 10.42.0.1 netmask 255.255.255.0 upp

Eller ange "Konfiguration" på HOST, i posten "nätverk", ställ in USB Ethernet en statisk IP till det gränssnittet.

Starta nu om dragonboard igen och verifiera systemstart, försök att ansluta med ssh:

$ ssh [email protected]

Referenser:

• 96boards dokumentation
• HowtoForge - artikel 6