Labrador 32 bits - Criando uma imagem: mudanças entre as edições

De Caninos Loucos
Ir para navegação Ir para pesquisar
← Edição anteriorEdição posterior →
Sem resumo de edição
Linha 7: Linha 7:
Para a versão 64 bits acesse a seguinte página: [[Labrador 64 bits - Criando uma imagem]]
Para a versão 64 bits acesse a seguinte página: [[Labrador 64 bits - Criando uma imagem]]


= Pré-requesitos =
= Pré-requisitos =


== Bootloader ==
== Bootloader ==
Linha 134: Linha 134:


= Gravando o sistema num cartão SD =
= Gravando o sistema num cartão SD =
'''i) Criar a tabela de partições'''
 
O cartão SD deve conter uma tabela de partições padronizada, que pode ser feita com os seguintes comandos:


Obs.: Você deve substituir mmcblkX pelo descritor correto para o seu caso.
Obs.: Você deve substituir mmcblkX pelo descritor correto para o seu caso.


<pre>
<pre>
# parted /dev/mmcblkX
# parted -s /dev/mmcblkX mklabel msdos
Welcome to GNU Parted! Type 'help' to view a list of commands.
# parted -s /dev/mmcblkX mkpart primary fat32 1MB 32MB
(parted) mklabel gpt
# parted -s /dev/mmcblkX mkpart primary ext4 33MB 100%
(parted) unit s
# parted -s /dev/mmcblkX set 1 boot on
(parted) mkpart primary 16384 114687                                     
(parted) mkpart primary 114688 -1                                       
Warning: You requested a partition from 114688s to AAAs (sectors 114688..AAA).
The closest location we can manage is 114688s to BBBs (sectors 114688..BBB).
Is this still acceptable to you?
Yes/No? yes                                                             
(parted) print                                                           
Model:  (file)
Disk /dev/mmcblkX: DDDs
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:


Number  Start    End      Size    File system  Name    Flags
# mkfs.ext4 -F -D SYSTEM /dev/mmcblkXp2
1      16384s  114687s  98304s                primary
# mkfs.vfat -F -L BOOT /dev/mmcblkXp1
2      114688s  BBBs    CCCs                  primary
 
(parted) q
</pre>
</pre>


'''ii) Gravar o bootloader'''
O próximo passo é gravar o bootloader, que está contido no repositório do kernel.
<pre># dd if=/path/to/u-boot-dtb.img of=/dev/mmcblkX bs=512 seek=66 status=progress</pre>


'''iii) Formatar as partições'''
<pre>
<pre>
# mkfs.vfat /dev/mmcblkXp1
# dd if=labrador-linux-6/boot32/u-boot-dtb.img of=/dev/mmcblkX bs=512 seek=66
# mkfs.ext4 /dev/mmcblkXp2
# dd if=labrador-linux-6/boot32/bootloader.bin of=/dev/mmcblkX bs=512 seek=1
# sync
</pre>
</pre>


'''iv) Gravar o kernel na partição 1'''
Retire o cartão SD e insira novamente para montar as partições automaticamente. Com o comando <code>lsblk</code> é 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
 
<pre>
<pre>
# mount /dev/mmcblkXp1 /mnt
$ git clone https://github.com/caninos-loucos/labrador-linux-6
# cp /path/to/kernel.dtb /mnt
$ cd labrador-linux-6
# cp /path/to/uImage /mnt
$ make install32
# cat << EOT > /mnt/uEnv.txt
$ cp boot32/uEnv.txt [ponto de montagem da partição BOOT, ex. /run/media/usuario/BOOT]
uenvcmd=setenv ramdisk_addr_r -; setenv os_type linux;
bootargs=clk_ignore_unused selinux=0 scandelay root=/dev/mmcblk0p2 rw console=ttyS3 rootfstype=ext4 console=tty0 loglevel=6 rootwait
EOT
# sync
# umount /mnt
</pre>
</pre>


'''v) Gravar o rootfs na partição 2'''
E assim, finalmente, podemos gravar o rootfs na partição SYSTEM
 
<pre>
<pre>
# mount /dev/mmcblk0p2 /mnt
$ cp -rp rootfs/* [Ponto de montagem SYSTEM]
# cp -rp /path/to/rootfs/* /mnt
$ sync
# cp -r /path/to/lib/modules /mnt/lib
# sync
# umount /mnt
</pre>
</pre>
E assim, o sistema estará pronto.

Edição das 20h48min de 7 de março de 2025

Nesta página você encontrará instruções de como criar uma imagem mínima para Labrador 32 bits. Se você deseja usar uma imagem mínima pronta, clique aqui.

O processo para criar uma imagem compreende compilar o bootloader, o Kernel Linux e gerar um sistema de arquivos de uma distribuição GNU/Linux Debian-like. Compreende também os passos para escrever essa imagem em um cartão SD.

Para encontrar a versão mais atualizada dos softwares aqui citados, acesse nosso Github.

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

Pré-requisitos

Bootloader

O primeiro passo é obter o bootloader. É possível usar um binário pré-compilado ou compilá-lo a partir do código-fonte, seguindo as instruções da página do github/labrador-uboot-32.


Ao final desse processo você terá um arquivo u-boot-dtb.img ou u-boot-dtb-no-UART3-console.img.


Obs.: Se você quer ter a UART3 (/dev/ttyS3) ativada para console de debug, que é o recomendado para a maior parte dos casos, use o u-boot-dtb.img. Caso você tenha intenção de usar o UART3 para alguma outra finalidade, use o u-boot-dtb-no-UART3-console.img.

Kernel Linux

Para obter o kernel com a versão 6, acesse github/labrador-linux-6. Há outras versões do kernel no git da caninos-loucos, mas a mais moderna é recomendada. Novamente aqui você tem a opção de usar binários pré-compilados ou compilá-los a partir do código-fonte, conforme as instruções do arquivo README.md.

Obs.: Se você está fazendo compilação cruzada do kernel, é possível usar o arm-linux-gnueabihf-gcc disponível no repositório do bootloader. Nesse caso adicione o caminho para o compilador ao PATH. Por exemplo, se você fez o clone do u-boot em $HOME: 

$ export PATH=$PATH:$HOME/labrador-uboot-32/toolchain/arm-linux-gnueabihf/bin

Ao final desse processo você terá um arquivo labrador-kernel6-armhf-v*.tar.gz com os arquivos:

  • kernel.dtb
  • uImage
  • lib/modules/6.1.76 (pode ser diferente caso esteja usando outra versão do kernel)

Distro

Você pode usar qualquer sistema compatível com a arquitetura ARM. 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=armhf --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

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.

Gravando o sistema num cartão SD

O cartão SD deve conter uma tabela de partições padronizada, que pode ser feita com os seguintes comandos:

Obs.: Você deve substituir mmcblkX pelo descritor correto para o seu caso. 

# parted -s /dev/mmcblkX mklabel msdos
# parted -s /dev/mmcblkX mkpart primary fat32 1MB 32MB
# parted -s /dev/mmcblkX mkpart primary ext4 33MB 100%
# parted -s /dev/mmcblkX set 1 boot on

# mkfs.ext4 -F -D SYSTEM /dev/mmcblkXp2
# mkfs.vfat -F -L BOOT /dev/mmcblkXp1

O próximo passo é gravar o bootloader, que está contido no repositório do kernel. 

# dd if=labrador-linux-6/boot32/u-boot-dtb.img of=/dev/mmcblkX bs=512 seek=66
# dd if=labrador-linux-6/boot32/bootloader.bin of=/dev/mmcblkX bs=512 seek=1
# sync

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 install32
$ cp boot32/uEnv.txt [ponto de montagem da partição BOOT, ex. /run/media/usuario/BOOT]

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

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

E assim, o sistema estará pronto.

Disponível em “https://wiki.canisinc.com.br/index.php?title=Labrador_32_bits_-_Criando_uma_imagem&oldid=764”