Labrador 64 bits - Criando uma imagem

Nesta página você encontrará instruções de como obter o bootloader atualizado da Labrador 64-bits, compilar um novo Kernel Linux, montar uma distribuição Linux para sua placa e escrever seu sistema num cartão SD e na memória da placa. Para encontrar a versão mais atualizada dos softwares aqui citados, acesse nosso Github.

Para a versão 32 bits acesse a seguinte página: Labrador 32 bits - Criando uma imagem

Dependências

Para montar seu próprio sistema compatível com a Labrador serão necessários:

• Um arquivo bootloader.bin
• Os arquivos de Kernel para o seu sistema
• Um arquivo config.json
• Um sistema de arquivos rootfs arm64 do sistema operacional que deseja instalar.

Os três primeiros podem ser encontrados no Github, o sistema de arquivos pode ser encontrado no site de diversas distribuições diferentes de Linux. Você também pode utilizar o debootstrap para gerar seu próprio sistema Debian. Recomendamos o uso de sistemas de arquivo ext4 mas outros sistemas ext funcionarão também.

Criando sua imagem

Compilando o Kernel

Após baixar os últimos arquivos de Kernel do Github o Kernel Linux deve ser compilado conforme as instruções do arquivo README.md. Basta rodar o comando make na pasta linux-source. Qualquer dependência de pacotes do sistema será alertada pelo compilador. Outras dúvidas gerais podem ser encontradas no mesmo arquivo readme. Os arquivos de saída dessa compilação estarão contidos no arquivo release/labrador-kernel6-arm64-v01.tar.gz:

• Vários arquivos de devicetree (.dtb) a serem usados de acordo com a placa base. Por padrão, o sistema usa a v3psci.dtb;
• Um binário de kernel Image;
• Os módulos do kernel lib/modules/6.1.76 (pode ser diferente caso esteja usando outra versão do kernel)

Criando um sistema bootável

Você pode usar qualquer sistema compatível com a arquitetura ARM64. Nesse procedimento descreveremos o processo para criação de um sistema Debian usando o debootstrap.

É necessário instalar também o emulador QEMU caso a imagem esteja sendo criada em uma máquina de arquitetura não ARM, como x86. Este pacote pode ser instalado no Debian pelo comando

# apt install qemu-user-static

Escolha um diretório para criação do sistema. É recomendável que seja feito diretamente em um cartão SD, mas é possível também criar em uma pasta local e apenas copiar o sistema para o cartão.

Neste exemplo usaremos uma pasta rootfs no diretório /home do seu usuário para criar um sistema Debian 12 (bookworm), mas a versão pode ser alterada se necessário.

# debootstrap --arch=arm64 --foreign --components=main,contrib,non-free-firmware bookworm /home/[usuário]/rootfs

Assim que o sistema tiver concluído o primeiro estágio de instalação, entraremos no sistema e realizaremos o segundo estágio.

# cp /usr/bin/qemu-arm-static rootfs/usr/bin
# cp /etc/resolv.conf rootfs/etc
# chroot rootfs
# export LANG=C
# /debootstrap/debootstrap --second-stage

Com o segundo estágio completo, alteraremos a lista de pacotes para ficarem o mais completa possível.

# cat << EOT > /etc/apt/sources.list
deb https://ftp.debian.org/debian/ bookworm contrib main non-free non-free-firmware
deb-src https://ftp.debian.org/debian/ bookworm contrib main non-free non-free-firmware

deb https://ftp.debian.org/debian/ bookworm-updates contrib main non-free non-free-firmware
deb-src https://ftp.debian.org/debian/ bookworm-updates contrib main non-free non-free-firmware

deb https://ftp.debian.org/debian/ bookworm-backports contrib main non-free non-free-firmware
deb-src https://ftp.debian.org/debian/ bookworm-backports contrib main non-free non-free-firmware

deb https://security.debian.org/debian-security/ bookworm-security contrib main non-free non-free-firmware
deb-src https://security.debian.org/debian-security/ bookworm-security contrib main non-free non-free-firmware
EOT

Com isso feito, atualize o apt e instale outras dependências.

# apt update
# apt upgrade
# apt install sudo firmware-realtek systemd-timesyncd locales

Para o sudo funcionar corretamente, devemos alterar o hostname da máquina

# echo labrador > /etc/hostname

Você deve adicionar o nome definido no passo anterior à primeir a linha do arquivo /etc/hosts, da seguinte forma:

# nano /etc/hosts
127.0.0.1       localhost labrador
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

Com isso já feito, pode-se criar um usuário comum e adicioná-lo a todos os grupos necessários. Neste exemplo, criamos um usuário 'caninos' pertencente ao grupo sudo e criamos uma senha. É *altamente recomendado* criar uma senha para o root também.

# useradd -m -G sudo -s /bin/bash caninos
# passwd caninos
# passwd

Assim, podemos limpar o cache do apt.

# apt-get autoclean
# apt-get clean

Para sair do chroot, apenas escrever ou teclar Ctrl + D.

# exit

Limpando a máquina:

# rm -f rootfs/root/.bash_history rootfs/usr/bin/qemu-arm-static
# cat /dev/null > rootfs/etc/resolv.conf

Após este processo o sistema estará pronto para ser usado na Labrador, no entanto, ainda temos que criar um arquivo de configuração com as instruções de boot para a Labrador. Essas configurações serão feitas num arquivo config.json na pasta /boot. Uma versão deste arquivo já está presente no GitHub em boot/config.json do repositório, com o seguinte conteúdo:

{
   "model":"Caninos Labrador K7",
   "compatible":"caninos,k7",
   "bootloader":{
      "major-version":2,
      "minor-version":0,
      "prioritize-sdcard":true,
      "graphics-enabled":true,
      "logo-enabled":true,
      "cpu-core-clock":1104,
      "common-bootargs":"loglevel=0 selinux=0 earlycon console=ttyS3,115200 console=tty0 no_console_suspend"
   },
   "display":{
      "source":"hdmi",
      "width":1920,
      "height":1080,
      "refresh-rate":60
   },
   "sdcard":{
      "kernel-filename":"Image",
      "kernel-address":"0x400000",
      "dtc-filename":"v3psci.dtb",
      "dtc-address":"0x200000",
      "initrd-filename":null,
      "initrd-address":null,
      "append-bootargs":"root=/dev/mmcblk0p1 rw rootwait"
   },
   "emmc":{
      "kernel-filename":"Image",
      "kernel-address":"0x400000",
      "dtc-filename":"v3psci.dtb",
      "dtc-address":"0x200000",
      "initrd-filename":null,
      "initrd-address":null,
      "append-bootargs":"root=/dev/mmcblk2p1 rw rootwait"
   }
}

Passos Opcionais

1. Ethernet

Para configurar o Ethernet é necessário alterar o arquivo /etc/network/interfaces para

auto end0
iface end0 inet dhcp

e usar o comando ifup end0 para ligá-la da primeira vez.

Salvando o sistema num cartão SD

Para utilizar um cartão SD no boot da labrador, o cartão deve ser formatado com os seguintes parâmetros:

• Partição MBR (EFI não funcionará)
• A primeira partição precisa ter offset de 1MB
• Sistema de arquivo EXT4

Isso pode ser feito com o seguinte script, assumiondo que neste caso o cartão SD é representado no sistema como /dev/mmcblk0. Atenção! Para evitar perda de dados, é necessário confirmar onde está seu cartão SD com o comando lsblk. Geralmente estará em mmcblk0, mas pode ser sda, sdb ou outros dependendo do uso de adaptadores.

# parted -s /dev/mmcblk0 mklabel msdos
# parted -s /dev/mmcblk0 mkpart primary ext4 1 100%
# parted -s /dev/mmcblk0 set 1 boot on
# mkfs.ext4 -F -D linux64 /dev/mmcblk0p1

Assim, podemos copiar o arquivo bootloader.bin contido no repositório do kernel para o início do cartão SD.

$ sudo dd if=labrador-linux-6/boot/bootloader.bin of=/dev/mmcblk0 conv=notrunc seek=1 bs=512

Retire o cartão SD e insira novamente para montar as partições automaticamente. Com o comando lsblk é possível ver o diretório em que as partições do cartão SD estão montadas. Com isso, podemos instalar o sistema com o script de make do repositório do kernel:

$ git clone https://github.com/caninos-loucos/labrador-linux-6
$ cd labrador-linux-6
$ make install
$ cp boot/config.json.txt [ponto de montagem do siistema]/boot

E assim, finalmente, podemos gravar o rootfs na partição

$ cp -rp rootfs/* [Ponto de montagem]
$ sync

E assim, o sistema estará pronto.

Atualizando uma imagem existente

É possível tamém atualizar imagens existentes para uma nova versão do debian a fim de não perder configurações. São necessários os seguintes passos:

1. Atualizar o kernel, sendo recomendável ser a versão mais recente oferecida no Github, e executar os seguintes comandos:

$ git clone https://github.com/caninos-loucos/labrador-linux-6
$ cd labrador-linux-6
$ make install32

Caso haja algum erro, certifique-se que o cartão SD contendo a imagem a ser atualizada está montado, usando o comando lsblk.

2. Atualizar a instalação existente com:

# apt update
# apt upgrade

3. Modificar o arquivo /etc/apt/sources.list para se referir à próxima versão do Debian: no caso do Debian 10 (buster), mudar para bullseye (Debian 11) e assim por diante. Não é recomendado pular versões, como ir diretamente do buster para o bookworm (Debian 12).

4. Atualizar todos os pacotes para a próxima versão, com os seguintes comandos:

# apt update
# apt full-upgrade

4. Caso esteja avançando duas versões ou mais (do Debian 10 para o 12, por exemplo), repita o processo para a próxima versão.