🥇Iniciando GNU/Linux em uma placa ARM do zero (com o exemplo do Kali e iMX.6)

resumo: estou criando uma imagem do Kali Linux para um computador ARM na ferramenta debootstrap, Linux e u-boot.

Se você comprou algum single-board computer menos conhecido, pode ter se deparado com a falta da imagem do seu distribuidor favorito. Aconteceu algo similar com o planejado Flipper One. Não existe Kali Linux para IMX6 (estou preparando), então eu tenho que compilar sozinho.

O processo de inicialização é bastante simples:

O hardware é inicializado.
Um carregador é lido e executado a partir de uma área do dispositivo de armazenamento (cartão SD / eMMC / etc).
O carregador busca o kernel do sistema operacional e o carrega em uma área de memória para execução.
O kernel carrega o restante do SO.

Este nível de detalhe é suficiente para a minha tarefa, você pode ler mais detalhes em outro artigo. As "algumas" áreas mencionadas acima variam de placa para placa, o que causa alguns desafios na instalação. O carregamento de plataformas ARM para servidores está sendo padronizado por meio do UEFI, mas enquanto isso não estiver disponível para todos, será necessário compilar tudo separadamente.

Compilação do sistema de arquivos raiz

Primeiro, você precisa preparar as partições. O U-Boot suporta diferentes sistemas de arquivos, eu escolhi FAT32 para /boot e ext3 para a raiz, essa é a partição padrão de imagens do Kali para ARM. Vou usar o GNU Parted, mas você pode fazer o mesmo de uma maneira mais familiar fdisk. Também serão necessários dosfstools e e2fsprogs para criar o sistema de arquivos: apt install parted dosfstools e2fsprogs.

Particionamos o cartão SD:

Marcamos o cartão SD para usar a partição MBR: parted -s /dev/mmcblk0 mklabel msdos
Criamos uma partição para /boot de 128 megabytes: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB. O primeiro megabyte deve ser deixado para a partição em si e para o carregador.
Criamos o sistema de arquivos raiz com toda a capacidade restante: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
Se por acaso os arquivos das partições não foram criados ou não foram modificados, você deve executar `partprobe`, então a tabela de partições será lida novamente.
Criamos o sistema de arquivos da partição de inicialização com o rótulo BOOT: mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
Criamos o sistema de arquivos raiz com o rótulo ROOTFS: mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Ótimo, agora podemos preenchê-lo. Para isso, será necessária a ferramenta adicional debootstrap, utilitário para criar sistemas de arquivos de sistemas operacionais baseados em Debian: apt install debootstrap.

Compilamos o sistema de arquivos:

Montamos a partição em /mnt/ (use um ponto de montagem mais conveniente para você): mount /dev/mmcblk0p2 /mnt
Preenchemos o sistema de arquivos: debootstrap --foreign --include=qemu-user-static --arch armhf kali-rolling /mnt/ http://http.kali.org/kali. Parâmetro --include indica instalar pacotes adicionais, eu indiquei um emulador QEMU compilado estaticamente. Ele permite executar chroot no ambiente ARM. O significado das outras opções pode ser visto em man debootstrap. Não se esqueça de que nem todo placa ARM suporta a arquitetura armhf.
Devido às diferenças de arquitetura debootstrap é executado em duas etapas, a segunda é executada assim: chroot /mnt/ /debootstrap/debootstrap --second-stage
Agora precisamos fazer o chroot: chroot /mnt /bin/bash
Preenchemos /etc/hosts e /etc/hostname o sistema de arquivos de destino. Preencha de forma semelhante ao conteúdo do seu computador local, mas não se esqueça de trocar o nome do host.
Você pode ajustar mais coisas. Em particular, eu instalo locales (chaves do repositório), reconfiguro os locais e o fuso horário (dpkg-reconfigure locales tzdata). Não se esqueça de definir uma senha com o comando passwd.
Definimos a senha para root com o comando passwd.
A preparação da imagem para mim termina com o preenchimento /etc/fstab dentro /mnt/.

Eu vou carregar de acordo com as etiquetas criadas anteriormente, então o conteúdo será assim:

LABEL=ROOTFS / auto errors=remount-ro 0 1
LABEL=BOOT /boot auto defaults 0 0

Finalmente, podemos montar a partição de inicialização, que precisamos para o kernel: `mount /dev/mmcblk0p1 /mnt/boot/`

Compilação do Linux

Para compilar o kernel (e o carregador depois) no Debian Testing, é necessário instalar o conjunto padrão de GCC, GNU Make e os arquivos de cabeçalho da GNU C Library para a arquitetura de destino (eu tenho armhf), além dos cabeçalhos do OpenSSL, calculadora de console bc, bison e flex: apt install crossbuild-essential-armhf bison flex libssl-dev bc. Como o carregador por padrão procura o arquivo zImage no sistema de arquivos da partição de inicialização, é hora de formatar o pen drive.

Clonar o kernel leva muito tempo, por isso vou baixar apenas: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz. Descompacte e vá para o diretório com os fontes: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
Configuramos antes da compilação: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig. A configuração está no diretório arch/arm/configs/. Se não houver, você pode tentar encontrar e baixar um pronto e passar o nome do arquivo nesse diretório no parâmetro KBUILD_DEFCONFIG. No pior caso, passe diretamente para o próximo ponto.
Opcionalmente, você pode ajustar as configurações: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
E compilamos a imagem: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
Agora podemos copiar o arquivo do kernel: cp arch/arm/boot/zImage /mnt/boot/
E arquivos com o DeviceTree (descrição do hardware presente na placa): cp arch/arm/boot/dts/*.dtb /mnt/boot/
E instalar os módulos compilados como arquivos separados: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

O núcleo está pronto. Podemos desmontar tudo: umount /mnt/boot/ /mnt/

Das U-Boot

Como o carregador é interativo, para verificar seu funcionamento, bastam a própria placa, o dispositivo de armazenamento e, opcionalmente, um dispositivo USB-to-UART. Ou seja, você pode deixar o núcleo e o SO para depois.

A absoluta maioria dos fabricantes recomenda o uso do Das U-Boot para o inicialização. O suporte completo geralmente é fornecido em seu próprio fork, mas também não esquecem de contribuir para o upstream. No meu caso, a placa é suportada no mainline, por isso fork ignorei.

Vamos compilar o carregador:

Clonando o ramo estável do repositório: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
Entramos na própria diretório: cd u-boot
Preparamos a configuração da compilação: make mx6ull_14x14_evk_defconfig. Isso só funciona se a configuração estiver presente no próprio Das U-Boot, caso contrário, você precisará encontrar a configuração do fabricante e colocá-la na raiz do repositório no arquivo .config, ou compilar de outra forma recomendada pelo fabricante.
Compilamos a imagem do carregador com o cross-compiler armhf: make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

Como resultado, obtemos o arquivo u-boot.imx, esta é a imagem pronta, que pode ser gravada em um pen drive. Gravamos no cartão SD, pulando os primeiros 1024 bytes. Por que escolhi o target u-boot.imx? Почему пропустил именно 1024 байта? Так предлагают сделать в documentação. Para outras placas, o processo de compilação da imagem e gravação pode diferir um pouco.

Pronto, podemos inicializar. O carregador deve informar sua própria versão, algumas informações sobre a placa e tentar encontrar a imagem do núcleo na partição. Em caso de falha, tentará inicializar pela rede. No geral, a saída é bastante detalhada, permitindo encontrar o erro em caso de problema.