Acceso al sistema de archivos raíz remoto usando DB410 como un Dongle Ethernet: 6 pasos

2025 Autor: John Day | [email protected]. Última modificación: 2025-01-13 06:57

Objetivos:

• Instale la cadena de herramientas y vuelva a compilar el kernel para insertar soporte USB Ethernet CDC Gadget;
• Vuelva a crear boot.img de Linaro para arrancar USB Ethernet CDC;
• Cree un servidor NFS para alojar el sistema de archivos raíz;
• Configuración de IP en DEVICE y HOST.

Paso 1: Requerimientos

Necesitará los siguientes elementos:

1. Un DragonBoard ™ 410c (llamado aquí DISPOSITIVO);
2. Una PC que usa Ubuntu 16.04.3 actualizado (llamado aquí HOST) con conexión a Internet y ranura para tarjeta SD;
3. Una instalación limpia de Linaro-developer versión 431 - Enlace: Instantánea de Linaro Debian v431
4. Un monitor HDMI;
5. Un teclado USB;
6. Una tarjeta SD de 8 Gb;
7. Un cable USB, uUSB USB para conectar el DISPOSITIVO al HOST.

Paso 2: Configurar el host para compilar el kernel y compilar el kernel en el HOST

Primero, crearemos todos los directorios antes de continuar. Entonces:

$ cd ~

$ mkdir db410remoteroot $ cd db410remoteroot $ mkdir cadena de herramientas $ mkdir db410c-modules

Desafortunadamente, el kernel de Linux utilizado por Linaro (Versión 431) no tiene soporte para el dispositivo USB Ethernet, debido a eso, el kernel de Linux debe reconstruirse para esta versión específica. Descargue la cadena de herramientas de Linaro para compilar e implementar el kernel de Linux en Dragonboard410c desde la máquina host x86.

$ wget

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

Ahora instale los paquetes necesarios para compilar el kernel:

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

Obtenga el repositorio de Linux del equipo de aterrizaje de Qualcomm, clon de origen del kernel de Linux:

$ git clone

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

Ahora, configure las variables de entorno de compilación:

$ exportación ARCH = arm64

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

En este punto, necesitamos agregar los módulos a USB Ethernet CDC en el kernel. Hice eso antes y puede obtenerlo al final de este paso. Eliminé algunos itens pero funciona.

Antes de compilar, corrija un error del kernel en drivers / mmc / host / sdhci-msm.c cambiando la estructura en la línea 1150 a:

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

Descomprima configfile.zip, copie el archivo.config al directorio del kernel, compile el kernel, los módulos e instale los módulos en un directorio:

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

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

Referencia: 96Boards Documentation

Paso 3: Reconstruir Boot.img en el HOST

En este paso, necesitamos abrir la imagen initrd, poner los módulos construidos dentro de la imagen, configurar el sistema para iniciar esos módulos y reconstruir un initrd.img con una nueva línea de comando del kernel para iniciar el sistema de archivos raíz de forma remota.

Entonces, primero, tenemos que descargar initrd.img del sitio web de linaro:

$ cd..

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

Ahora, después de la descarga, descomprima y extraiga el initrd:

$ zcat ramdisk.img | cpio -idmv

En este directorio, tenemos el sistema de archivos raíz utilizado por el kernel en la inicialización, por lo que configuraremos módulos CDC Ethernet USB y parámetros remotos NFS como IP del servidor NFS y ethernet (usb) necesarios aquí.

Ahora, configuremos algunos archivos:

conf / initramfs.conf:

MÓDULOS = la mayoría

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

Cree el directorio init-premount en el directorio scripts /

$ mkdir scripts / init-premount

y agregue los archivos en estos directorios recién creados:

PEDIDO

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

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

USB

#! / bin / sh

PREREQ = "" prereqs () {echo "$ PREREQ"} caso $ 1 en # obtener pre-requisitos prereqs) prereqs exit 0;; esac modprobe usb_f_ecm modprobe libcomposite modprobe usb_f_rndis modprobe g_ether

No olvide usar chmod en el archivo usb para hacerlo ejecutable:

$ chmod + x scripts / init-premount / usb

Ahora, copie todo el directorio con los módulos de db410c-modules (PASO 2) a lib / modules en initrd:

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

Elimine todos los archivos en lib / modules / 4.14.96-xxxx-dirty excepto all files module. * Y esa lista de archivos:

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

Esos archivos son todos los módulos necesarios para iniciar USB Ethernet CDC.

Finalmente vuelva a empaquetar y comprimir la imagen initrd:

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

Al menos, la imagen del kernel y el archivo DTB deben empaquetarse en una imagen de arranque de Android. Dicha imagen se puede generar con la herramienta abootimg.

Vayamos al directorio del kernel y usemos el siguiente comando para compilar la imagen y agregar DTB en la imagen del kernel comprimida:

$ cd../kernel

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

Y finalmente, genere la imagen de arranque (aquí nuestro rootfs se encuentra en una partición remota en 10.42.0.1)

abootimg --create boot-db410c.img -k Image.gz + dtb -r initrd_nfs.img -c tamaño de página = 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"

Referencias:

• https://access.redhat.com/solutions/24029
• 96 Documentación de tableros

Paso 4: Creación del sistema de archivos raíz en el HOST

Ahora, tenemos una nueva imagen de arranque para actualizar la dragonboard 410c. Pero necesitamos un sistema de archivos raíz en el servidor remoto para iniciar módulos, servicios y aplicaciones. En este paso, crearemos un directorio compartido en el host para guardar todos estos datos. De esa manera, descarguemos un sistema de archivos rootfs del sitio de linaro con la misma versión que se usó en initrd. Entonces, retroceda un directorio y descargue la imagen rootfs de linaro-developer con la versión 431.

$ cd..

$ wget

Descomprime este archivo

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

Usando este archivo, escribamos todas las imágenes en una tarjeta SD para acceder a todas las particiones y copiar archivos rootfs. Por lo tanto, asegúrese de que se haga una copia de seguridad de los datos de uSDCard porque se perderá todo lo que esté en SDCard.

Para encontrar el nombre de su dispositivo SDCard, elimine SDCard y ejecute el siguiente comando:

$ lsblk

Guarde en su mente todos los nombres de disco reconocidos. Ahora inserte SDCard, espere un momento y ejecute el comando nuevamente:

$ lsblk

Tenga en cuenta el disco recién reconocido. Esta será su tarjeta SD. Recuerde su nombre y cambie el parámetro "of =" para el nombre de su dispositivo SDCard y asegúrese de usar el nombre del dispositivo sin la partición, p.e.: / dev / mmcblk0

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

Notas:

• Este comando tardará algún tiempo en ejecutarse. Sea paciente y evite manipular el terminal hasta que el proceso haya finalizado.
• Una vez que la tarjeta SD termine de parpadear, retírela de la computadora host.

Referencia: documentación 96boards

Paso 5: Crear servidor NFS en el HOST y copiar archivos

En este punto, tenemos una imagen de arranque para ser flasheada en dragonboard 410c y una SDCard con un sistema de archivos rootfs para nuestros módulos, servicios y aplicaciones. El siguiente paso es crear un directorio remoto para conectar el DISPOSITIVO USB Ethernet junto con el sistema de archivos HOST rootfs. Eso se puede hacer usando un paquete de Ubuntu llamado nfs-kernel-server.

Este paquete instala un servicio NFS en Ubuntu que permite compartir algunos directorios para algunos dispositivos en la red, podemos configurar qué directorio se usará para cada dispositivo usando su IP.

Entonces, instalemos el paquete y configurémoslo.

$ sudo apt-get install nfs-kernel-server

El servicio NFS se inicia automáticamente. Para controlar el uso de los servicios NFS:

$ sudo service nfs-kernel-server restart // para reiniciar, o use 'detener' o 'iniciar' según sea necesario.

Para verificar el estado del servicio NFS desde la línea de comando, use:

$ sudo service nfs-kernel-server status

nfsd en ejecución // El servicio está activo nfsd no se está ejecutando // El servicio está inactivo

Ahora, creemos un directorio superior / srv / nfs, y creemos un subdirectorio debajo para cada sistema de archivos raíz montado en NFS requerido. Aquí incluimos un sistema de archivos raíz compartido para mantener nuestro sistema de archivos raíz:

$ sudo mkdir -p / srv / nfs

$ sudo mkdir -p / srv / nfs / rootfs

Ahora, el servidor NFS requiere que / etc / export esté configurado correctamente para controlar el acceso a cada directorio del sistema de archivos NFS a hosts específicos. En este caso, los hosts se identifican por su dirección IP. Por lo tanto, para cada sistema de archivos raíz que se crea, agregue la línea de control de exportación a / etc / export, ajustando su dirección IP local y el esquema de nombres de directorio si es necesario. En este tutorial, siempre usamos eso:

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

Inserte nuevamente su SDCard, móntela y copie todo el sistema de archivos rootfs en / srv / nfs / rootfs, reinicie el servicio NFS para actualizar el directorio usando nuevos archivos copiados.

Además, necesitamos copiar los archivos de los nuevos módulos en el sistema de archivos rootfs porque compilamos el kernel en el paso 2. Entonces, copie todos los directorios en ~ / db410c-modules / a / srv / nfs / rootfs.

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

Asegúrese de que el servicio NFS haga visibles estos directorios. Cualquiera:

$ sudo exportfs -a

Referencia: Sistema de archivos raíz TFTP / NFS

Paso 6: Actualización de la imagen de arranque de Dragonboard 410c y configuración de interfaces de red

Hicimos todos los pasos iniciales para implementar un sistema de archivos rootfs remoto, ahora necesitamos actualizar la imagen de arranque dentro de dragonboard 410c, para eso, conecte su cable USB en la PC y en el conector uUSB de dragonboard. Así que asegúrese de que fastboot esté configurado en la computadora host, si no lo instala usando:

$ sudo apt instalar fastboot

Ahora, para actualizar la imagen, inicie el dragonboard en modo fastboot siguiendo estos pasos:

• Mantenga presionado el botón Vol (-) en la DragonBoard 410c, este es el botón S4. DragonBoard ™ 410c aún NO debe estar encendido
• Mientras mantiene presionado el botón Vol (-), encienda la DragonBoard 410c enchufándola
• Una vez que la DragonBoard 410c esté conectada a la corriente, suelte el botón Vol (-).
• Espere unos 20 segundos.
• La placa debería arrancar en modo fastboot.

Desde la ventana del terminal de la máquina host conectada, ejecute los siguientes comandos:

$ sudo dispositivos fastboot

Normalmente se mostrará a continuación

de82318 fastboot

En este punto, debería estar conectado a su DragonBoard 410c con un cable USB a microUSB. Su DragonBoard 410c debe iniciarse en modo fastboot y estar listo para ser flasheado con las imágenes apropiadas. Actualicemos la imagen de arranque con la nuestra:

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

Y reinicia el tablero

$ sudo fastboot reiniciar

Ahora, su HOST detectará una nueva interfaz llamada usb0, pero aún no tiene una IP. Entonces, agregue una IP estática a esta interfaz usando:

$ sudo ifconfig usb0 10.42.0.1 máscara de red 255.255.255.0 hasta

O ingrese en "Configuración" en HOST, en el elemento "red", configurando USB Ethernet como una IP estática para esa interfaz.

Ahora, reinicie nuevamente el tablero y verifique el inicio del sistema, tratando de conectarse usando ssh:

$ ssh [email protected]

Referencias:

• Documentación de 96boards
• HowtoForge - Elemento 6