Acessando o sistema de arquivos raiz remoto usando DB410 como um adaptador Ethernet: 6 etapas

2025 Autor: John Day | [email protected]. Última modificação: 2025-01-23 15:03

Objetivos

• Instale o conjunto de ferramentas e recompile o kernel para inserir o suporte a USB Ethernet CDC Gadget;
• Recrie o boot.img do Linaro para inicializar o USB Ethernet CDC;
• Crie um servidor NFS para hospedar o sistema de arquivos raiz;
• Configuração de IP em DEVICE e HOST.

Etapa 1: Requerimentos

Você precisará dos seguintes itens:

1. Um DragonBoard ™ 410c (denominado aqui DEVICE);
2. Um PC com Ubuntu 16.04.3 atualizado (denominado aqui HOST) com conexão à Internet e slot para SDCard;
3. Uma instalação limpa do Linaro-developer versão 431 - Link: Snapshot Linaro Debian v431
4. Um monitor HDMI;
5. Um teclado USB;
6. Um SDCard de 8 Gb;
7. Um cabo USB, uUSB USB para conectar o DEVICE no HOST.

Etapa 2: Configurando Host para Construir Kernel e Construindo Kernel no HOST

Primeiro, vamos criar todos os diretórios antes de continuar. Então:

$ cd ~

$ mkdir db410remoteroot $ cd db410remoteroot $ mkdir conjunto de ferramentas $ mkdir db410c-modules

Infelizmente, o kernel do Linux usado pelo Linaro (versão 431) não tem suporte para dispositivo USB Ethernet, por isso, o kernel do Linux deve ser reconstruído para esta versão específica. Baixe o conjunto de ferramentas Linaro para construir e implantar o kernel do Linux no Dragonboard410c da máquina host x86.

$ wget

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

Agora instale os pacotes necessários para construir o kernel:

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

Obtenha a origem do kernel do Linux Clone Qualcomm landing team repository Linux:

$ git clone

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

Agora, defina as variáveis de ambiente de compilação:

$ export ARCH = arm64

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

Neste ponto, precisamos adicionar os módulos ao USB Ethernet CDC no kernel. Eu fiz isso antes e você pode conseguir isso no final desta etapa. Retirei alguns itens, mas funciona.

Antes de compilar, corrija um bug do kernel em drivers / mmc / host / sdhci-msm.c alterando a estrutura na linha 1150 para:

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

Descompacte configfile.zip, copie o arquivo.config para o diretório do kernel, crie o kernel, módulos e instale os módulos em um diretório:

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

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

Referência: 96Boards Documentation

Etapa 3: reconstruir Boot.img no HOST

Nesta etapa, precisamos abrir a imagem initrd, colocar os módulos construídos dentro da imagem, configurar o sistema para iniciar esses módulos e reconstruir um initrd.img com uma nova linha de comando do kernel para inicializar o sistema de arquivos raiz remotamente.

Então, primeiro, temos que baixar initrd.img do site do linaro:

$ cd..

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

Agora, após o download, descompacte e extraia o initrd:

$ zcat ramdisk.img | cpio -idmv

Neste diretório, temos o sistema de arquivos raiz usado pelo kernel na inicialização, portanto, configuraremos os módulos USB Ethernet CDC e os parâmetros remotos NFS como IP do servidor NFS e ethernet (usb) necessários aqui.

Agora, vamos configurar alguns arquivos:

conf / initramfs.conf:

MÓDULOS = mais

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

Crie o diretório init-premount no diretório scripts /

$ mkdir scripts / init-premount

e adicione os arquivos neste diretório recém-criado:

PEDIDO

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

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

USB

#! / bin / sh

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

Não se esqueça de usar chmod no arquivo usb para torná-lo executável:

$ chmod + x scripts / init-premount / usb

Agora, copie todo o diretório com os módulos de db410c-modules (PASSO 2) para lib / modules no initrd:

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

Remova todos os arquivos em lib / modules / 4.14.96-xxxx-dirty, exceto todos os arquivos do módulo. * E essa lista de arquivos:

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

Esses arquivos são todos os módulos necessários para iniciar o USB Ethernet CDC.

Por fim, empacote e compacte a imagem initrd:

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

Pelo menos, a imagem do kernel e o arquivo DTB precisam ser compactados em uma imagem de inicialização do Android. Essa imagem pode ser gerada com a ferramenta abootimg.

Vamos no diretório do kernel e usar o comando abaixo para construir a imagem e anexar o DTB na imagem do kernel compactada:

$ cd../kernel

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

E, finalmente, gere a imagem de inicialização (aqui nosso rootfs está localizado em uma partição remota em 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 = 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"

Referências:

• https://access.redhat.com/solutions/24029
• 96Boards Documentation

Etapa 4: Criando sistema de arquivos raiz no HOST

Agora, temos uma nova imagem de inicialização para atualizar o dragonboard 410c. Mas precisamos de um sistema de arquivos raiz no servidor remoto para inicializar módulos, serviços e aplicativos. Nesta etapa, construiremos um diretório compartilhado no host para salvar todos esses dados. Dessa forma, vamos baixar um sistema de arquivos rootfs do site linaro com a mesma versão usada no initrd. Então, volte um diretório e baixe a imagem rootfs do linaro-developer com a versão 431.

$ cd..

$ wget

Descompacte este arquivo

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

Usando este arquivo, vamos escrever todas as imagens em um sdcard para acessar todas as partições e copiar os arquivos rootfs. Portanto, certifique-se de que os dados do uSDCard tenham backup, pois tudo no SDCard será perdido.

Para encontrar o nome do seu dispositivo SDCard, remova SDCard e execute o seguinte comando:

$ lsblk

Salve em sua mente todos os nomes de discos reconhecidos. Agora insira o SDCard, aguarde um momento e execute o comando novamente:

$ lsblk

Observe o disco recém-reconhecido. Este será o seu SDCard. Lembre-se do seu nome e altere o parâmetro "of =" para o nome do dispositivo SDCard e certifique-se de usar o nome do dispositivo sem a partição, por exemplo: / dev / mmcblk0

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

Notas:

• Este comando levará algum tempo para ser executado. Seja paciente e evite adulterar o terminal até o processo terminar.
• Assim que o cartão SD terminar de piscar, remova-o do computador host.

Referência: documentação 96boards

Etapa 5: Criação de NFS de servidor no HOST e cópia de arquivos

Neste ponto, temos uma imagem de boot a ser flasheada no dragonboard 410c e um SDCard com um sistema de arquivos rootfs para nossos módulos, serviços e aplicativos. A próxima etapa é criar um diretório remoto para conectar o USB Ethernet DEVICE ao sistema de arquivos HOST rootfs. Isso pode ser feito usando um pacote do Ubuntu denominado nfs-kernel-server.

Este pacote instala um serviço NFS no Ubuntu permitindo compartilhar alguns diretórios para alguns dispositivos na rede, podemos configurar qual diretório será usado para cada dispositivo usando seu IP.

Então, vamos instalar o pacote e configurá-lo.

$ sudo apt-get install nfs-kernel-server

O serviço NFS é iniciado automaticamente. Para controlar o uso de serviços NFS:

$ sudo service nfs-kernel-server restart // para reiniciar, ou use 'stop' ou 'start' conforme necessário.

Para verificar o status do serviço NFS na linha de comando, use:

$ sudo service nfs-kernel-server status

nfsd running // serviço está ativo nfsd not running // serviço está inativo

Agora, vamos criar um diretório superior / srv / nfs e criar um subdiretório para cada sistema de arquivos raiz montado por NFS necessário. Aqui, incluímos um sistema de arquivos raiz compartilhado para manter nosso sistema de arquivos raiz:

$ sudo mkdir -p / srv / nfs

$ sudo mkdir -p / srv / nfs / rootfs

Agora, o servidor NFS requer que / etc / exports seja configurado corretamente, para controlar o acesso a cada diretório do sistema de arquivos NFS para hosts específicos. Nesse caso, os hosts são identificados por seu endereço IP. Portanto, para cada sistema de arquivos raiz criado, adicione a linha de controle de exportação a / etc / exports, ajustando para seu endereço IP local e esquema de nomenclatura de diretório, se necessário. Neste tutorial, sempre usamos isso:

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

Insira novamente seu SDCard, monte-o e copie todo o sistema de arquivos rootfs em / srv / nfs / rootfs, reinicie o serviço NFS para atualizar o diretório usando os novos arquivos copiados.

Além disso, precisamos copiar os novos arquivos de módulos no sistema de arquivos rootfs porque compilamos o kernel na etapa 2. Portanto, copie todos os diretórios em ~ / db410c-modules / para / srv / nfs / rootfs.

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

Certifique-se de que esses diretórios se tornem visíveis pelo serviço NFS. Qualquer:

$ sudo exportfs -a

Referência: Sistema de arquivos raiz TFTP / NFS

Etapa 6: Atualizando a imagem de inicialização do Dragonboard 410c e configurando as interfaces de rede

Fizemos todos os passos iniciais para implementar um sistema de arquivos rootfs remoto, agora precisamos atualizar a imagem de boot dentro do dragonboard 410c, para isso, conecte o seu cabo USB no PC e no conector uUSB do dragonboard. Portanto, certifique-se de que o fastboot esteja configurado no computador host, caso não instale usando:

$ sudo apt install fastboot

Agora, para atualizar a imagem, inicie o dragonboard no modo fastboot seguindo estas etapas:

• Pressione e segure o botão Vol (-) no DragonBoard 410c, este é o botão S4. DragonBoard ™ 410c ainda NÃO deve estar ligado
• Enquanto segura o botão Vol (-), ligue o DragonBoard 410c conectando-o
• Assim que o DragonBoard 410c estiver conectado à energia, solte o botão Vol (-).
• Aguarde cerca de 20 segundos.
• A placa deve inicializar no modo fastboot.

Na janela do terminal da máquina host conectada, execute os seguintes comandos:

dispositivos $ sudo fastboot

Normalmente, será mostrado como abaixo

de82318 fastboot

Neste ponto, você deve estar conectado ao DragonBoard 410c com um cabo USB para microUSB. Seu DragonBoard 410c deve ser inicializado no modo fastboot e pronto para ser atualizado com as imagens apropriadas. Vamos atualizar a imagem de inicialização com a nossa imagem de inicialização:

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

E reinicie o tabuleiro

$ sudo fastboot reboot

Agora, seu HOST detectará uma nova interface chamada usb0, mas ainda não tem um IP. Portanto, adicione um IP estático a esta interface usando:

$ sudo ifconfig usb0 10.42.0.1 máscara de rede 255.255.255.0 up

Ou entre em “Configuração” no HOST, no item “rede”, configurando USB Ethernet um IP estático para aquela interface.

Agora, reinicie novamente o dragonboard e verifique a inicialização do sistema, tentando conectar usando ssh:

$ ssh [email protected]

Referências:

• Documentação 96boards
• HowtoForge - Item 6