Dostęp do zdalnego głównego systemu plików za pomocą DB410 jako klucza Ethernet: 6 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

Cele:

• Zainstaluj toolchain i przekompiluj jądro, aby wstawić USB Ethernet CDC Gadget;
• Odtwórz boot.img z Linaro, aby uruchomić USB Ethernet CDC;
• Utwórz serwer NFS, aby hostować główny system plików;
• Konfiguracja IP w URZĄDZENIU i HOSTA.

Krok 1: Zapytania

Będziesz potrzebować następujących rzeczy:

1. DragonBoard™ 410c (nazywany tutaj URZĄDZENIEM);
2. Zaktualizowany komputer PC korzystający z Ubuntu 16.04.3 (nazywany tutaj HOST) z połączeniem internetowym i gniazdem SDCard;
3. Czysta instalacja Linaro-developer w wersji 431 - Link: Snapshot Linaro Debian v431
4. Monitor HDMI;
5. Klawiatura USB;
6. Karta SD 8 Gb;
7. Kabel USB, uUSB USB do podłączenia URZĄDZENIA do HOSTA.

Krok 2: Konfigurowanie hosta do budowania jądra i budowania jądra w HOST

Najpierw utworzymy wszystkie katalogi, aby kontynuować. Więc:

$ cd ~

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

Niestety jądro Linuksa używane przez Linaro (wersja 431) nie obsługuje gadżetu USB Ethernet, z tego powodu jądro Linuksa musi zostać przebudowane dla tej konkretnej wersji. Pobierz toolchain Linaro, aby zbudować i wdrożyć jądro Linuksa na Dragonboard410c z hosta x86.

$ wget

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

Teraz zainstaluj pakiety wymagane do zbudowania jądra:

$ sudo apt update && sudo apt-get install git build-essential abootimg pakiet jądra fakeroot libncurses5-dev libssl-dev ccache

Uzyskaj źródło jądra Linux Clone Repozytorium Linux zespołu startującego Qualcomm:

$ git clone

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

Teraz ustaw zmienne środowiskowe kompilacji:

$ eksportuj ARCH=arm64

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

W tym momencie musimy dodać moduły do USB Ethernet CDC w jądrze. Zrobiłem to wcześniej i możesz to uzyskać na końcu tego kroku. Usunąłem kilka rzeczy, ale działa.

Przed kompilacją proszę poprawić błąd jądra w drivers/mmc/host/sdhci-msm.c zmieniając strukturę w linii 1150 na:

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

Rozpakuj plik configfile.zip, skopiuj plik.config do katalogu jądra, zbuduj jądro, moduły i zainstaluj moduły w katalogu:

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

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

Odniesienie: Dokumentacja 96Boards

Krok 3: Odbuduj Boot.img w HOST

W tym kroku musimy otworzyć obraz initrd, umieścić moduły wbudowane w obraz, skonfigurować system do uruchamiania tych modułów i przebudować plik initrd.img z nowym wierszem poleceń jądra, aby zdalnie uruchomić główny system plików.

Więc najpierw musimy pobrać initrd.img ze strony linaro:

$ cd..

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

Teraz, po pobraniu, rozpakuj i rozpakuj initrd:

$ zcat ramdisk.img | cpio -idmv

W tym katalogu mamy główny system plików używany przez jądro podczas inicjalizacji, więc skonfigurujemy tutaj moduły USB Ethernet CDC i parametry zdalne NFS, takie jak IP serwera NFS i Ethernet (usb).

Teraz skonfigurujmy kilka plików:

conf/initramfs.conf:

MODUŁY=najbardziej

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

Utwórz katalog init-premount w katalogu scripts/

$ skrypty mkdir/init-premount

i dodaj pliki w tych właśnie utworzonych katalogach:

ZAMÓWIENIE

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

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

usb

#!/kosz/sz

PREREQ="" wymagania wstępne() { echo "$PREREQ" } case $1 in # pobierz wymagania wstępne wymagania wstępne) wymagania wstępne exit 0;; esac modprobe usb_f_ecm modprobe libcomposite modprobe usb_f_rndis modprobe g_ether

Nie zapomnij użyć chmod w pliku usb, aby był wykonywalny:

$ chmod +x skryptów/init-premount/usb

Teraz skopiuj cały katalog z modułami z db410c-modules (KROK 2) do lib/modules w initrd:

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

Usuń wszystkie pliki w lib/modules/4.14.96-xxxx-dirty z wyjątkiem wszystkich plików module.* i tej listy plików:

jądro/sterowniki/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

Te pliki to wszystkie moduły potrzebne do uruchomienia USB Ethernet CDC.

Na koniec przepakuj i skompresuj obraz initrd:

$ znajdź. | cpio -o -H nowyc | gzip -9 >../kernel/initrd_nfs.img

Przynajmniej obraz jądra i plik DTB muszą być spakowane do obrazu rozruchowego Androida. Taki obraz można wygenerować za pomocą narzędzia abootimg.

Przejdźmy do katalogu jądra i użyj poniższego polecenia, aby zbudować obraz i dołączyć DTB do skompresowanego obrazu jądra:

$ cd../jądro

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

I na koniec wygeneruj obraz rozruchowy (tutaj nasz rootfs znajduje się na zdalnej partycji w 10.42.0.1)

abootimg --create boot-db410c.img -k Image.gz+dtb -r initrd_nfs.img -c rozmiar strony=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 konsola=tty0 konsola=ttyMSM0, 115200n8"

Bibliografia:

• https://access.redhat.com/solutions/24029
• 96Dokumentacja tablic

Krok 4: Tworzenie głównego systemu plików na hoście

Teraz mamy nowy obraz rozruchowy, aby zaktualizować Dragonboard 410c. Ale potrzebujemy głównego systemu plików na zdalnym serwerze, aby uruchamiać moduły, usługi i aplikacje. W tym kroku zbudujemy współdzielony katalog na hoście, aby zapisać wszystkie te dane. W ten sposób pobierzmy system plików rootfs ze strony linaro w tej samej wersji, co w initrd. Cofnij się więc o jeden katalog i pobierz obraz linaro-developer rootfs w wersji 431.

$ cd..

$ wget

Rozpakuj ten plik

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

Korzystając z tego pliku, zapiszmy cały obraz na karcie sdcard, aby uzyskać dostęp do wszystkich partycji i skopiować pliki rootfs. Upewnij się więc, że utworzono kopię zapasową danych z karty uSD, ponieważ wszystko na karcie SD zostanie utracone.

Aby znaleźć nazwę urządzenia SDCard, usuń SDCard i uruchom następujące polecenie:

$ lsblk

Zapisz w pamięci wszystkie rozpoznane nazwy dysków. Teraz włóż kartę SD, odczekaj chwilę i ponownie wykonaj polecenie:

$ lsblk

Zanotuj nowo rozpoznany dysk. To będzie twoja karta SD. Zapamiętaj swoje imię i zmień parametr „of=” dla nazwy urządzenia na karcie SD i upewnij się, że używasz nazwy urządzenia bez partycji, np.: /dev/mmcblk0

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

Uwagi:

• Wykonanie tego polecenia zajmie trochę czasu. Zachowaj cierpliwość i unikaj manipulacji przy terminalu do czasu zakończenia procesu.
• Po zakończeniu flashowania karty SD wyjmij ją z komputera hosta.

Odniesienie: dokumentacja 96 tablic

Krok 5: Tworzenie serwera NFS w HOST i kopiowanie plików

W tym momencie mamy obraz startowy do flashowania na dragonboard 410c i kartę SD z systemem plików rootfs dla naszych modułów, usług i aplikacji. Następnym krokiem jest utworzenie zdalnego katalogu, aby połączyć USB Ethernet DEVICE z systemem plików HOST rootfs. Można to zrobić za pomocą pakietu z Ubuntu o nazwie nfs-kernel-server.

Ten pakiet instaluje usługę NFS w Ubuntu pozwalającą na udostępnianie niektórych katalogów dla niektórych urządzeń w sieci, możemy skonfigurować, który katalog będzie używany dla każdego urządzenia, używając twojego IP.

Zainstalujmy więc pakiet i skonfigurujmy go.

$ sudo apt-get install nfs-kernel-server

Usługa NFS uruchamia się automatycznie. Aby kontrolować usługi NFS, użyj:

$ sudo service nfs-kernel-server restart // aby zrestartować lub użyj 'stop' lub 'start' zależnie od potrzeb.

Aby sprawdzić stan usługi NFS z wiersza poleceń, użyj:

$ sudo service nfs-kernel-server status

nfsd uruchomiony // usługa nie działa nfsd nie działa // usługa nie działa

Teraz stwórzmy główny katalog /srv/nfs i stwórzmy podkatalog pod nim dla każdego wymaganego głównego systemu plików zamontowanego przez NFS. Tutaj dołączamy współdzielony główny system plików, aby zachować nasz główny system plików:

$ sudo mkdir -p /srv/nfs

$ sudo mkdir -p /srv/nfs/rootfs

Teraz serwer NFS wymaga poprawnej konfiguracji /etc/exports, aby kontrolować dostęp do każdego katalogu systemu plików NFS do określonych hostów. W tym przypadku hosty są identyfikowane przez ich adres IP. Tak więc dla każdego tworzonego głównego systemu plików dodaj wiersz kontroli eksportu do /etc/exports, dostosowując w razie potrzeby lokalny adres IP i schemat nazewnictwa katalogów. W tym samouczku zawsze używamy tego:

/srv/nfs/rootfs 10.42.0.2(rw, synchronizacja, brak_root_squash, brak_sprawdzenia_poddrzewa)

Włóż ponownie kartę SD, zamontuj ją i skopiuj cały system plików rootfs do /srv/nfs/rootfs, uruchom ponownie usługę NFS, aby zaktualizować katalog przy użyciu nowych skopiowanych plików.

Dodatkowo musimy skopiować nowe pliki modułów do systemu plików rootfs, ponieważ skompilowaliśmy jądro w kroku 2. Skopiuj więc wszystkie katalogi z ~/db410c-modules/ do /srv/nfs/rootfs.

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

Upewnij się, że te katalogi są widoczne przez usługę NFS. Albo:

$ sudo exportfs -a

Odniesienie: Główny system plików TFTP/NFS

Krok 6: Aktualizacja obrazu rozruchowego Dragonboard 410c i konfiguracja interfejsów sieciowych

Wcześnie wykonaliśmy wszystkie kroki, aby zaimplementować zdalny system plików rootfs, teraz potrzebujemy zaktualizować obraz rozruchowy wewnątrz Dragonboard 410c, w tym celu podłącz kabel USB do komputera i do złącza uUSB Dragonboard. Upewnij się więc, że fastboot jest skonfigurowany na komputerze hosta, jeśli nie, zainstaluj za pomocą:

$ sudo apt install fastboot

Teraz, aby zaktualizować obraz, uruchom de dragonboard w trybie fastboot, wykonując następujące kroki:

• Naciśnij i przytrzymaj przycisk Vol (-) na DragonBoard 410c, to jest przycisk S4. DragonBoard™ 410c nadal NIE powinien być włączony
• Trzymając wciśnięty przycisk Vol (-), włącz DragonBoard 410c, podłączając go do zasilania
• Po podłączeniu DragonBoard 410c do zasilania zwolnij przycisk Vol (-).
• Poczekaj około 20 sekund.
• Płyta powinna uruchomić się w trybie fastboot.

W oknie terminala podłączonego komputera hosta uruchom następujące polecenia:

$ sudo urządzenia fastboot

Zazwyczaj będzie to wyglądać jak poniżej

de82318 fastboot

W tym momencie powinieneś być podłączony do DragonBoard 410c za pomocą kabla USB do microUSB. DragonBoard 410c powinien być uruchomiony w trybie fastboot i gotowy do flashowania z odpowiednimi obrazami. Zaktualizujmy obraz rozruchowy za pomocą naszego obrazu rozruchowego:

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

I zrestartuj tablicę

$ sudo fastboot restart

Teraz Twój HOST wykryje nowy interfejs o nazwie usb0, ale nie ma jeszcze adresu IP. Dodaj więc statyczny adres IP do tego interfejsu, używając:

$ sudo ifconfig usb0 10.42.0.1 maska sieci 255.255.255.0 w górę

Lub wejdź w "Konfiguracja" na HOST, w pozycji "sieć", ustawiając USB Ethernet na statyczny adres IP tego interfejsu.

Teraz uruchom ponownie dragonboard i sprawdź uruchamianie systemu, próbując połączyć się za pomocą ssh:

$ ssh [email protected]

Bibliografia:

• Dokumentacja 96 tablic
• HowtoForge - Pozycja 6