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

De Caninos Loucos
Ir para navegação Ir para pesquisar
← Edição anterior
Glhrm (discussão | contribs)
editor, Administradores
85 edições
Sem resumo de edição
Sem resumo de edição
 
(39 revisões intermediárias por 3 usuários não estão sendo mostradas)
Linha 1: Linha 1:
Nesta página você encontrará instruções de como criar uma imagem mínima para Labrador 32 bits. Esse processo 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.
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 [https://wiki.caninosloucos.org.br/index.php/Labrador_32_bits_imagem_mínima 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 [http://github.com/caninos-loucos/ Github].
Para encontrar a versão mais atualizada dos softwares aqui citados, acesse nosso [http://github.com/caninos-loucos/ Github].


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 ==
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 [https://github.com/caninos-loucos/labrador-uboot-32 github/labrador-uboot-32].


== ''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 [https://github.com/caninos-loucos/labrador-uboot-32 github/labrador-uboot-32].


Ao final desse processo você terá um arquivo ''u-boot-dtb.img'' ou ''u-boot-dtb-no-UART3-console.img''.
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''.
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 ==
== Kernel Linux ==
Para obter o kernel, acesse [https://github.com/caninos-loucos/labrador-linux github/labrador-linux]. 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.
Para obter o kernel com a versão 6, acesse [https://github.com/caninos-loucos/labrador-linux-6 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.
 
<blockquote>
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:


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:
<pre>$ export PATH=$PATH:$HOME/labrador-uboot-32/toolchain/arm-linux-gnueabihf/bin</pre>
</blockquote>


<pre>
Ao final desse processo você terá um arquivo <code>labrador-kernel6-armhf-v*.tar.gz</code> com os arquivos:
$ export PATH=$PATH:$HOME/labrador-uboot-32/toolchain/arm-linux-gnueabihf/bin
* <code>kernel.dtb</code>
</pre>
* <code>uImage</code>
* <code>lib/modules/6.1.76</code> (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 ARM. Nesse procedimento descreveremos o processo para criação de um sistema Debian usando o [https://wiki.debian.org/pt_BR/Debootstrap debootstrap].


Ao final desse processo você terá:
É 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
* kernel.dtb
* uImage
* lib/modules


== Sistema de Arquivos ==
<pre># apt install qemu-user-static</pre>


Você pode baixar qualquer rootfs compatível com a arquitetura arm. Nesse procedimento descreveremos o processo para criação de um rootfs usando o [https://wiki.debian.org/pt_BR/Debootstrap debootstrap].
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.


=== i) debootstrap primeiro estágio ===
Neste exemplo usaremos uma pasta <code>rootfs</code> 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.


Para gerar um sistema base Debian Stretch:
<pre># debootstrap --arch=armhf --foreign --components=main,contrib,non-free-firmware bookworm /home/[usuário]/rootfs</pre>
<pre>
# mkdir  debootstrap --arch=armhf --foreign stretch rootfs
</pre>


Para gerar um sistema base Ubuntu :
Assim que o sistema tiver concluído o primeiro estágio de instalação, entraremos no sistema e realizaremos o segundo estágio.
<pre>
# mkdir  debootstrap --arch=armhf --foreign stretch rootfs
</pre>


=== ii) debootstrap segundo estágio ===
<pre>
<pre>
# cp /usr/bin/qemu-arm-static rootfs/usr/bin
# cp /usr/bin/qemu-arm-static rootfs/usr/bin
Linha 53: Linha 56:
</pre>
</pre>


=== iii) configurando o repositório de pacotes ===
Com o segundo estágio completo, alteraremos a lista de pacotes para ficarem o mais completa possível.
 
<pre>
<pre>
# cat << EOT > /etc/apt/sources.list
# cat << EOT > /etc/apt/sources.list
deb http://ftp.br.debian.org/debian/ stretch main contrib non-free
deb https://ftp.debian.org/debian/ bookworm contrib main non-free non-free-firmware
deb-src http://ftp.br.debian.org/debian/ stretch main contrib non-free
deb-src https://ftp.debian.org/debian/ bookworm contrib main non-free non-free-firmware


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


# stretch-updates, previously known as 'volatile'
deb https://ftp.debian.org/debian/ bookworm-backports contrib main non-free non-free-firmware
deb http://ftp.br.debian.org/debian/ stretch-updates main contrib non-free
deb-src https://ftp.debian.org/debian/ bookworm-backports contrib main non-free non-free-firmware
deb-src http://ftp.br.debian.org/debian/ stretch-updates main contrib non-free
 
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
EOT
</pre>
</pre>


=== iv) instalando pacotes adicionais ===
Com isso feito, atualize o apt e instale outras dependências.
<pre>
# apt update
# apt upgrade
# apt install sudo firmware-realtek systemd-timesyncd locales
</pre>
 
Para o sudo funcionar corretamente, devemos alterar o hostname da máquina
 
<pre># echo labrador > /etc/hostname</pre>
 
Você deve adicionar o nome definido no passo anterior à primeir a linha do arquivo <code>/etc/hosts</code>, da seguinte forma:
 
<pre>
<pre>
# apt-get update
# nano /etc/hosts
# apt-get upgrade
127.0.0.1      localhost labrador
# apt-get install sudo
::1            localhost ip6-localhost ip6-loopback
ff02::1        ip6-allnodes
ff02::2        ip6-allrouters
</pre>
</pre>


=== v) definindo o hostname ===
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.
 
<pre>
<pre>
# echo labrador > /etc/hostname
# useradd -m -G sudo -s /bin/bash caninos
# passwd caninos
# passwd
</pre>
</pre>


=== vi) adiocionar o hostname ao hosts ===
Assim, podemos limpar o cache do apt.
Você deve adicionar o nome definido no passo anterior ao arquivo /etc/hosts. Adicione a esse arquivo a seguinte linha:
127.0.1.1 labrador


<pre>
<pre>
# nano /etc/hosts
# apt-get autoclean
# apt-get clean
</pre>
</pre>


Para sair do chroot, apenas escrever ou teclar Ctrl + D.
<pre># exit</pre>
Limpando a máquina:
<pre>
# rm -f rootfs/root/.bash_history rootfs/usr/bin/qemu-arm-static
# cat /dev/null > rootfs/etc/resolv.conf
</pre>


Para iniciar o processo deve-se montar o arquivo rootfs, neste caso o montaremos no destino /media/mountpoint
== Passos Opcionais ==


<pre>$ mount -o rootfs.img /media/mountpoint</pre>
1. Ethernet


Após a montagem do sistema uma pasta boot deve ser criada no mesmo, e os arquivos de compilação e logo.bmp devem ser colocados nesta pasta, os comandos abaixo realizam essa tarefa:
Para configurar o Ethernet é necessário alterar o arquivo <code>/etc/network/interfaces</code> para


<pre>
<pre>
$ mkdir /media/mountpoint/rootfs/boot
auto end0
$ cp -r /media/caninos/kernel/Image /media/mountpoint/rootfs/boot
iface end0 inet dhcp
$ cp -r /media/caninos/kernel/v3emmc.dtb /media/mountpoint/rootfs/boot
$ cp -r /media/caninos/kernel/v3sdc.dtb /media/mountpoint/rootfs/boot
$ cp -r /media/caninos/kernel/logo.bmp /media/mountpoint/rootfs/boot
</pre>
</pre>


Após finalizar a pasta de boot o próximo passo é editar a pasta /lib/modules. Para isso é necessário remover a pasta original do rootfs e colocar a pasta gerada na compilação do Kernel.
e usar o comando <code>ifup end0</code> para ligá-la da primeira vez.
 
== Gravando o sistema num cartão SD ==
 
Isso pode ser feito com o seguinte script, assumindo 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 <code>lsblk</code>. Geralmente estará em mmcblk0, mas pode ser sda, sdb ou outros dependendo do uso de adaptadores.'''
 
<pre>
<pre>
$ sudo rm -r /media/mountpoint/rootfs/lib/modules
# parted -s /dev/mmcblk0 mklabel msdos
$ sudo cp -r /media/caninos/kernel/lib/modules /media/mountpoint/ rootfs/lib/
# parted -s /dev/mmcblk0 mkpart primary fat32 1MB 32MB
# parted -s /dev/mmcblk0 mkpart primary ext4 33MB 100%
# parted -s /dev/mmcblk0 set 1 boot on
 
# mkfs.ext4 -F -D SYSTEM /dev/mmcblk0p2
# mkfs.vfat -F -L BOOT /dev/mmcblk0p1
</pre>
</pre>


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. Conforme seção [[Labrador 64 bits - Criando uma imagem|Arquivo config.json]]
O próximo passo é gravar o bootloader, que está contido no repositório do kernel.  


=== Exemplo do debootstrap ===
<pre>
Para gerar um arquivo de sistema via debootsrap inicialmente ele deve ser instalado. Num sistema Debian isso pode ser feito com o comando
# dd if=labrador-linux-6/boot32/u-boot-dtb.img of=/dev/mmcblk0 bs=512 seek=66
<pre>$sudo apt install debootstrap</pre>
# dd if=labrador-linux-6/boot32/bootloader.bin of=/dev/mmcblk0 bs=512 seek=1
Após isto, o comando criará um arquivo de sistema. Neste caso, um arquivo do Debian Buster, é possível substituir a versão para qualquer uma desejada.
# sync
<pre>$ sudo debootstrap --arch=arm64 --foreign buster <pasta_de_destino></pre>
</pre>


=== Arquivo config.json ===
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.
O arquivo config.json deve ser criado na pasta boot do rootfs, basta criá-lo e preenchê-lo com os parâmetros necessários, conforme tabela abaixo.


{| class="wikitable"
Com isso, podemos instalar o sistema com o script de make do repositório do kernel
|-
! Parâmetro
! Descrição
! Formato de entrada
! Padrão
|-
| ”mode”
| Configura o modo de boot da imagem (Mais informação na seção Modos de  Boot)
| Normal, Upgrade, Produce
| Normal
|-
| ”default_boot_device”
| Configura a fonte primária do boot
| SDcard, Emmc
| Sdcard
|-
| ”screen_resolution”
| Define a resolução e frequência do display
| [horizontal]x [vertical]x[freq]
| 1920x1080x60
|-
| ”sdcard_dtb”
| Nome do arquivo dtb na pasta de boot referente ao cartão SD.
| *.dtb
| v3sdc.dtb
|-
| ”emmc_dtb”
| Nome do arquivo dtb na pasta de boot referente à eMMC.
| *.dtb
| v3emmc.dtb
|-
| ”kernel”
| Nome do arquivo de kernel na pasta de boot.
| *
| Image
|-
| ”source”
| Caminho do arquivo de bootloader utilizado nos modos Upgrade e Produce  (ignorada no modo Normal)
| *.bin
| bootloader.bin
|-
| ”image”
| Caminho da imagem a ser gravada na eMMC no modo Produce (ignorada nos  modos Normal e Upgrade)
| *.tar
| rootfs.tar
|-
| ”label”
| Rótulo de partição do sistema de arquivos ext4 no modo Produce (ignorado  nos modos Normal e Upgrade)
| *
| rootfs
|}


Abaixo temos um exemplo para este arquivo, considerando o modo de boot Normal, boot através da eMMC, resolução de tela 1920x1080@60Hz. Como sdcard_dtb, emmc_dtb e kernel não são explicitados, seus valores padrão são utilizados automaticamente.
<pre>
$ 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]
</pre>
 
E assim, finalmente, podemos gravar o rootfs na partição SYSTEM


<pre>
<pre>
config.json:
$ cp -rp rootfs/* [Ponto de montagem SYSTEM]
    {
$ sync
    "mode": "normal",
    "default_boot_device": "emmc",
    "screen_resolution":
    "1920x1080x60"
    }
</pre>
</pre>


== Salvando o sistema num cartão SD ==
E assim, o sistema estará pronto.
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


Após formatar o cartão SD neste formato, basta copiar o sistema rootfs, é recomendado o uso da ferramenta rsync seguindo o comando abaixo:
= Atualizando uma imagem existente =
<pre>$ rsync -r /media/mountpoint/rootfs /media/SDCARD/partition</pre>


Finalizado isto, basta copiar o arquivo bootloader.bin para o início do cartão SD '''não é no início da primeira partição, mas sim no offset deixado antes da mesma'''. Os parâmetros conv, seek e bs recomendados seguem abaixo.
É 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:
<pre>$ sudo dd if=/src/bootloader.bin of=/dev/SDCARD conv=notrunc seek=1 bs=512</pre>


= Modos de boot =
1. Atualizar o kernel, sendo recomendável ser a versão mais recente oferecida no [https://github.com/caninos-loucos Github], e executar os seguintes comandos:
No arquivo de configuração 3 modos de boot são possíveis: Normal, Upgrade e Produce.  
<pre>
$ git clone https://github.com/caninos-loucos/labrador-linux-6
$ cd labrador-linux-6
$ make install32
</pre>


== Modo Normal ==
Caso haja algum erro, certifique-se que o cartão SD contendo a imagem a ser atualizada está montado, usando o comando <code>lsblk</code>.
O modo Normal criará um cartão SD bootável, similar ao disponível na nossa seção de downloads.
Para utilizar seu sistema no modo Normal o arquivo config.json disponibilizado nas seções anteriores é suficiente e não requer nenhuma mudança adicional. O sistema irá iniciar de acordo com o parâmetro "default_boot_device". Para pular esta escolha e iniciar o sistema estritamente do cartão SD o botão de recuberação da Labrador Coreboard deve ser pressionado.


== Modo Upgrade ==
2. Atualizar a instalação existente com:
O modo Upgrade fará uma atualização do bootloader e do logo de início conforme arquivo indicado no parâmetro "source" do config. A maioria dos passos listados é desnecessário para este modo, portanto, para criá-lo é recomendado:
<pre>
* Formatar o cartão SD conforme instrução deste artigo.
# apt update
* Pular a instrução de cópia do sistema para a primeira partição.
# apt upgrade
* Copiar o arquivo bootloader.bin para o início do cartão SD.
</pre>
* Criar uma pasta /boot vazia na primeira partição.
* Copiar os arquivos logo.bmp e bootloader.bin para esta pasta.
* Criar um arquivo config.json nesta pasta. (Parâmetros válidos deste modo são  "mode", "source" e "screen_resolution").


'''Atenção:''' o bootloader transferido para a placa será o bootloader da basta boot, não o colocado no início do cartão SD.
3. Modificar o arquivo <code>/etc/apt/sources.list</code> 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).


== Modo Produce ==
4. Atualizar todos os pacotes para a próxima versão, com os seguintes comandos:
 
<pre>
O modo Produce, além de substituir o bootloader como no Upgrade, substituirá também o sistema gravado na memória interna da labrador pelo sistema indicado no parâmetro "image". Para utilizar o modo produce uma imagem do sistema conforme gerada nas seções anteriores é necessária, esta deve estar no formato .tar. É possível criar esta imagem rodando os seguintes comandos após os passos de criação da imagem:
# apt update
<pre> $ export org=/media/mountpoint/rootfs
# apt full-upgrade
$ sudo tar cvfp rootfs.tar --format=ustar --exclude=lost+found --exclude=dev --exclude=proc --exclude=sys -C $org . </pre>
</pre>


Após gerar o sistema .tar os seguintes passos são recomendados para a criação de um cartão de modo Produce:
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.
* Formatar o cartão SD conforme instrução deste artigo.
* Pular a instrução de cópia do sistema para a primeira partição.
* Copiar o arquivo bootloader.bin para o início do cartão SD.
* Criar uma pasta /boot vazia na primeira partição.
* Copiar os arquivos logo.bmp, bootloader.bin e rootfs.tar para esta pasta.
* Criar um arquivo config.json nesta pasta. (Parâmetros válidos deste modo são  "mode", "source", "image", "label" e "screen_resolution").

Edição atual tal como às 17h14min de 12 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)

Criando um sistema Bootável

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

Isso pode ser feito com o seguinte script, assumindo 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 fat32 1MB 32MB
# parted -s /dev/mmcblk0 mkpart primary ext4 33MB 100%
# parted -s /dev/mmcblk0 set 1 boot on

# mkfs.ext4 -F -D SYSTEM /dev/mmcblk0p2
# mkfs.vfat -F -L BOOT /dev/mmcblk0p1

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/mmcblk0 bs=512 seek=66
# dd if=labrador-linux-6/boot32/bootloader.bin of=/dev/mmcblk0 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.

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.

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