Accès au système de fichiers racine distant à l'aide de DB410 comme dongle Ethernet : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Objectifs:

• Installez la chaîne d'outils et recompilez le noyau pour insérer la prise en charge du gadget USB Ethernet CDC;
• Recréez boot.img à partir de Linaro pour démarrer le CDC Ethernet USB;
• Créer un serveur NFS pour héberger le système de fichiers racine;
• Configuration IP dans DEVICE et HOST.

Étape 1: Exigences

Vous aurez besoin des éléments suivants:

1. Un DragonBoard™ 410c (nommé ici DEVICE);
2. Un PC utilisant Ubuntu 16.04.3 mis à jour (nommé ici HOST) avec connexion Internet et emplacement pour carte SDC;
3. Une installation propre de Linaro-developer version 431 - Lien: Snapshot Linaro Debian v431
4. Un moniteur HDMI;
5. Un clavier USB;
6. Une carte SD de 8 Go;
7. Un câble USB, uUSB USB pour connecter l'APPAREIL sur HOST.

Étape 2: Configuration de l'hôte pour construire le noyau et construire le noyau dans l'HTE

Tout d'abord, nous allons créer tous les répertoires avant de continuer. Donc:

$ cd ~

$ mkdir db410remoteroot $ cd db410remoteroot $ chaîne d'outils mkdir $ mkdir db410c-modules

Malheureusement, le noyau Linux utilisé par Linaro (Version 431) ne prend pas en charge le gadget Ethernet USB, à cause de cela, le noyau Linux doit être reconstruit pour cette version spécifique. Téléchargez la chaîne d'outils Linaro pour créer et déployer le noyau Linux sur Dragonboard410c à partir de la machine hôte x86.

$ wget

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

Installez maintenant les packages nécessaires à la compilation du noyau:

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

Obtenez le référentiel Linux de l'équipe de débarquement de clone de la source du noyau Linux:

$ git clone

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

Maintenant, définissez les variables d'environnement de compilation:

$ export ARCH=arm64

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

À ce stade, nous devons ajouter les modules à USB Ethernet CDC dans le noyau. Je l'ai déjà fait et vous pouvez l'obtenir à la fin de cette étape. J'ai supprimé certains éléments mais ça marche.

Avant de compiler, veuillez corriger un bogue du noyau dans drivers/mmc/host/sdhci-msm.c en changeant la structure de la ligne 1150 en:

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

Décompressez configfile.zip, copiez le fichier.config dans le répertoire du noyau, construisez le noyau, les modules et installez les modules dans un répertoire:

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

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

Référence: 96Boards Documentation

Étape 3: Reconstruisez Boot.img dans l'HTE

Dans cette étape, nous devons ouvrir l'image initrd, mettre les modules construits à l'intérieur de l'image, configurer le système pour démarrer ces modules et reconstruire un initrd.img avec une nouvelle ligne de commande du noyau pour démarrer le système de fichiers racine à distance.

Donc, tout d'abord, nous devons télécharger initrd.img depuis le site Web de Linaro:

$ cd..

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

Maintenant, après le téléchargement, décompressez et extrayez l'initrd:

$ zcat ramdisk.img | cpio -idmv

Dans ce répertoire, nous avons le système de fichiers racine utilisé par le noyau lors de l'initialisation, nous allons donc configurer les modules CDC Ethernet USB et les paramètres distants NFS tels que l'adresse IP du serveur NFS et ethernet (usb) nécessaires ici.

Maintenant, configurons quelques fichiers:

conf/initramfs.conf:

MODULES=la plupart

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

Créez le répertoire init-premount dans le répertoire scripts/

$ mkdir scripts/init-premount

et ajoutez les fichiers dans le répertoire que vous venez de créer:

ORDRE

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

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

USB

#!/bin/sh

PREREQ="" prereqs() { echo "$PEREQ" } case $1 dans # obtenir les prérequis prereqs) prereqs exit 0;; esac modprobe usb_f_ecm modprobe libcomposite modprobe usb_f_rndis modprobe g_ether

N'oubliez pas d'utiliser chmod dans le fichier usb pour le rendre exécutable:

$ chmod +x scripts/init-premount/usb

Maintenant, copiez tous les répertoires avec les modules de db410c-modules (STEP 2) vers lib/modules dans initrd:

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

Supprimez tous les fichiers dans lib/modules/4.14.96-xxxx-dirty à l'exception de tous les fichiers module.* et cette liste de fichiers:

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

Ces fichiers sont tous les modules nécessaires pour démarrer USB Ethernet CDC.

Enfin remballez et compressez l'image initrd:

$ trouver. | cpio -o -H nouveauc | gzip -9 >../kernel/initrd_nfs.img

Au moins, l'image du noyau et le fichier DTB doivent être compressés dans une image de démarrage Android. Une telle image peut être générée avec l'outil abootimg.

Allons dans le répertoire du noyau et utilisons la commande ci-dessous pour créer l'image et ajouter DTB dans l'image du noyau compressé:

$ cd../noyau

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

Et enfin, générez l'image de démarrage (ici notre rootfs se trouve une partition distante en 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=0x810000000 -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"

Les références:

• https://access.redhat.com/solutions/24029
• 96Boîtes Documentation

Étape 4: Création du système de fichiers racine dans l'HTE

Maintenant, nous avons une nouvelle image de démarrage pour mettre à jour le dragonboard 410c. Mais nous avons besoin d'un système de fichiers racine sur le serveur distant pour démarrer les modules, les services et les applications. Dans cette étape, nous allons créer un répertoire partagé dans l'hôte pour enregistrer toutes ces données. De cette façon, téléchargeons un système de fichiers rootfs depuis le site linaro avec la même version que celle utilisée dans initrd. Donc, revenez en arrière et téléchargez l'image rootfs de linaro-developer avec la version 431.

$ cd..

$ wget

Décompresser ce fichier

$ décompressez dragonboard-410c-sdcard-developer-buster-431.zip

En utilisant ce fichier, écrivons toutes les images dans une carte SD pour accéder à toutes les partitions et copier les fichiers rootfs. Assurez-vous donc que les données de la carte uSDCard sont sauvegardées, car tout ce qui se trouve sur la carte SDC sera perdu.

Pour trouver le nom de votre appareil SDCard, supprimez la SDCard et exécutez la commande suivante:

$ lsblk

Enregistrez dans votre esprit tous les noms de disques reconnus. Insérez maintenant la carte SD, attendez un moment et exécutez à nouveau la commande:

$ lsblk

Notez le disque nouvellement reconnu. Ce sera votre carte SD. Rappelez-vous votre nom et modifiez le paramètre "of=" pour le nom de votre périphérique SDCard et assurez-vous d'utiliser le nom du périphérique sans la partition, p.e.: /dev/mmcblk0

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

Remarques:

• Cette commande prendra un certain temps à s'exécuter. Soyez patient et évitez de manipuler le terminal jusqu'à la fin du processus.
• Une fois que la carte SD a fini de clignoter, retirez-la de l'ordinateur hôte.

Référence: documentation 96boards

Étape 5: Création du serveur NFS dans l'HTE et copie des fichiers

À ce stade, nous avons une image de démarrage à flasher dans dragonboard 410c et une carte SDC avec un système de fichiers rootfs pour nos modules, services et applications. L'étape suivante consiste à créer un répertoire distant pour connecter le périphérique Ethernet USB avec le système de fichiers rootfs HOST. Cela peut être fait en utilisant un package d'Ubuntu nommé nfs-kernel-server.

Ce package installe un service NFS dans Ubuntu permettant de partager certains répertoires pour certains appareils sur le réseau, nous pouvons configurer quel répertoire sera utilisé pour chaque appareil en utilisant votre IP.

Alors, installons le package et configurons-le.

$ sudo apt-get install nfs-kernel-server

Le service NFS démarre automatiquement. Pour contrôler les services NFS, utilisez:

$ sudo service nfs-kernel-server restart // pour redémarrer, ou utilisez 'stop' ou 'start' selon vos besoins.

Pour vérifier l'état du service NFS à partir de la ligne de commande, utilisez:

$ sudo service nfs-kernel-server status

nfsd en cours d'exécution // Le service est actif nfsd ne fonctionne pas // Le service est en panne

Maintenant, créons un répertoire supérieur /srv/nfs et créons un sous-répertoire sous celui-ci pour chaque système de fichiers racine monté NFS requis. Ici, nous incluons un système de fichiers racine partagé pour conserver le nôtre:

$ sudo mkdir -p /srv/nfs

$ sudo mkdir -p /srv/nfs/rootfs

Désormais, le serveur NFS nécessite que /etc/exports soit configuré correctement, pour contrôler l'accès à chaque répertoire du système de fichiers NFS à des hôtes spécifiques. Dans ce cas, les hôtes sont identifiés par leur adresse IP. Ainsi, pour chaque système de fichiers racine créé, ajoutez la ligne de contrôle d'exportation à /etc/exports, en ajustant votre adresse IP locale et votre schéma de nommage de répertoire si nécessaire. Dans ce tutoriel, nous utilisons toujours cela:

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

Insérez à nouveau votre carte SDC, montez-la et copiez tout le système de fichiers rootfs dans /srv/nfs/rootfs, redémarrez le service NFS pour mettre à jour le répertoire en utilisant les nouveaux fichiers copiés.

De plus, nous devons copier les nouveaux fichiers de modules dans le système de fichiers rootfs car nous avons compilé le noyau à l'étape 2. Copiez donc tous les répertoires de ~/db410c-modules/ dans /srv/nfs/rootfs.

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

Assurez-vous que ces répertoires sont rendus visibles par le service NFS. Soit:

$ sudo exportfs -a

Référence: Système de fichiers racine TFTP/NFS

Étape 6: Mise à jour de l'image de démarrage de Dragonboard 410c et configuration des interfaces réseau

Nous avons fait au début toutes les étapes pour implémenter un système de fichiers rootfs distant, maintenant nous devons mettre à jour l'image de démarrage à l'intérieur de dragonboard 410c, pour cela, connectez votre câble USB sur PC et sur le connecteur uUSB de dragonboard. Assurez-vous donc que fastboot est configuré sur l'ordinateur hôte, sinon installez-le en utilisant:

$ sudo apt installer fastboot

Maintenant, pour mettre à jour l'image, démarrez le dragonboard en mode fastboot en suivant ces étapes:

• Appuyez sur le bouton Vol (-) de la DragonBoard 410c et maintenez-le enfoncé, il s'agit du bouton S4. DragonBoard™ 410c ne doit toujours PAS être allumé
• Tout en maintenant le bouton Vol (-) enfoncé, allumez la DragonBoard 410c en la branchant
• Une fois la DragonBoard 410c branchée, relâchez votre appui sur le bouton Vol (-).
• Attendez environ 20 secondes.
• La carte devrait démarrer en mode de démarrage rapide.

À partir de la fenêtre du terminal de la machine hôte connectée, exécutez les commandes suivantes:

$ appareils de démarrage rapide sudo

Typiquement, il s'affichera comme ci-dessous

de82318 démarrage rapide

À ce stade, vous devez être connecté à votre DragonBoard 410c avec un câble USB vers microUSB. Votre DragonBoard 410c doit être démarré en mode de démarrage rapide et prêt à être flashé avec les images appropriées. Mettons à jour l'image de démarrage avec la nôtre image de démarrage:

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

Et, redémarrez la carte

$ sudo redémarrage rapide

Maintenant, votre HOST détectera une nouvelle interface nommée usb0, mais il n'a pas encore d'IP. Alors, ajoutez une IP statique à cette interface en utilisant:

$ sudo ifconfig usb0 10.42.0.1 netmask 255.255.255.0 up

Ou entrez dans "Configuration" sur HOST, dans l'élément "réseau", en définissant USB Ethernet une adresse IP statique sur cette interface.

Maintenant, redémarrez à nouveau le dragonboard et vérifiez le démarrage du système, en essayant de vous connecter en utilisant ssh:

$ ssh [email protected]

Les références:

• 96cartes documentation
• HowtoForge - Article 6