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
 
(44 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é-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 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 =
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''.
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.
 
== Kernel Linux ==
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:
 
<pre>$ export PATH=$PATH:$HOME/labrador-uboot-32/toolchain/arm-linux-gnueabihf/bin</pre>
</blockquote>
 
Ao final desse processo você terá um arquivo <code>labrador-kernel6-armhf-v*.tar.gz</code> com os arquivos:
* <code>kernel.dtb</code>
* <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].
 
É 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


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># apt install qemu-user-static</pre>
 
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 <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.
 
<pre># debootstrap --arch=armhf --foreign --components=main,contrib,non-free-firmware bookworm /home/[usuário]/rootfs</pre>
 
Assim que o sistema tiver concluído o primeiro estágio de instalação, entraremos no sistema e realizaremos o segundo estágio.


<pre>
<pre>
$ export PATH=$PATH:$HOME/labrador-uboot-32/toolchain/arm-linux-gnueabihf/bin
# cp /usr/bin/qemu-arm-static rootfs/usr/bin
# cp /etc/resolv.conf rootfs/etc
# chroot rootfs
# export LANG=C
# /debootstrap/debootstrap --second-stage
</pre>
</pre>


Ao final desse processo você terá:
Com o segundo estágio completo, alteraremos a lista de pacotes para ficarem o mais completa possível.
* kernel.dtb
* uImage
* lib/modules


== Gerando o Sistema de Arquivos ==
<pre>
# 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


Você pode baixar qualquer rootfs compatível com a arquitetura arm ou usar o [https://wiki.debian.org/pt_BR/Debootstrap debootstrap] para criar seu próprio. Abaixo damos um exemplo de como utilizar o debootstrap para baixar uma versão do Debian buster, por enquanto prosseguiremos assumindo que o rootfs.img já está baixado.
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


Para iniciar o processo deve-se montar o arquivo rootfs, neste caso o montaremos no destino /media/mountpoint
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


<pre>$ mount -o rootfs.img /media/mountpoint</pre>
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
</pre>


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:
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>
$ mkdir /media/mountpoint/rootfs/boot
# nano /etc/hosts
$ cp -r /media/caninos/kernel/Image /media/mountpoint/rootfs/boot
127.0.0.1      localhost labrador
$ cp -r /media/caninos/kernel/v3emmc.dtb /media/mountpoint/rootfs/boot
::1            localhost ip6-localhost ip6-loopback
$ cp -r /media/caninos/kernel/v3sdc.dtb /media/mountpoint/rootfs/boot
ff02::1        ip6-allnodes
$ cp -r /media/caninos/kernel/logo.bmp /media/mountpoint/rootfs/boot
ff02::2        ip6-allrouters
</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.
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>
$ sudo rm -r /media/mountpoint/rootfs/lib/modules
# useradd -m -G sudo -s /bin/bash caninos
$ sudo cp -r /media/caninos/kernel/lib/modules /media/mountpoint/ rootfs/lib/
# passwd caninos
# passwd
</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]]
Assim, podemos limpar o cache do apt.
 
<pre>
# apt-get autoclean
# apt-get clean
</pre>


=== Exemplo do debootstrap ===
Para sair do chroot, apenas escrever ou teclar Ctrl + D.
Para gerar um arquivo de sistema via debootsrap inicialmente ele deve ser instalado. Num sistema Debian isso pode ser feito com o comando
<pre># exit</pre>
<pre>$sudo apt install debootstrap</pre>
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.
<pre>$ sudo debootstrap --arch=arm64 --foreign buster <pasta_de_destino></pre>


=== Arquivo config.json ===
Limpando a máquina:
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.
<pre>
# rm -f rootfs/root/.bash_history rootfs/usr/bin/qemu-arm-static
# cat /dev/null > rootfs/etc/resolv.conf
</pre>


{| class="wikitable"
== Passos Opcionais ==
|-
! 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.
1. Ethernet
 
Para configurar o Ethernet é necessário alterar o arquivo <code>/etc/network/interfaces</code> para
 
<pre>
auto end0
iface end0 inet dhcp
</pre>
 
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>
# 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
</pre>
 
O próximo passo é gravar o bootloader, que está contido no repositório do kernel.
 
<pre>
# 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
</pre>
 
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>
config.json:
$ git clone https://github.com/caninos-loucos/labrador-linux-6
    {
$ cd labrador-linux-6
    "mode": "normal",
$ make install32
    "default_boot_device": "emmc",
$ cp boot32/uEnv.txt [ponto de montagem da partição BOOT, ex. /run/media/usuario/BOOT]
    "screen_resolution":
    "1920x1080x60"
    }
</pre>
</pre>


== Salvando o sistema num cartão SD ==
E assim, finalmente, podemos gravar o rootfs na partição SYSTEM
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:
<pre>
<pre>$ rsync -r /media/mountpoint/rootfs /media/SDCARD/partition</pre>
$ cp -rp rootfs/* [Ponto de montagem SYSTEM]
$ sync
</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.
E assim, o sistema estará pronto.
<pre>$ sudo dd if=/src/bootloader.bin of=/dev/SDCARD conv=notrunc seek=1 bs=512</pre>


= Modos de boot =
= Atualizando uma imagem existente =
No arquivo de configuração 3 modos de boot são possíveis: Normal, Upgrade e Produce.


== Modo Normal ==
É 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:
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 ==
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:
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.
$ git clone https://github.com/caninos-loucos/labrador-linux-6
* Pular a instrução de cópia do sistema para a primeira partição.
$ cd labrador-linux-6
* Copiar o arquivo bootloader.bin para o início do cartão SD.
$ make install32
* Criar uma pasta /boot vazia na primeira partição.
</pre>
* 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.
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>.
 
2. Atualizar a instalação existente com:
<pre>
# apt update
# apt upgrade
</pre>


== Modo Produce ==
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).


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:
4. Atualizar todos os pacotes para a próxima versão, com os seguintes comandos:
<pre> $ export org=/media/mountpoint/rootfs
<pre>
$ sudo tar cvfp rootfs.tar --format=ustar --exclude=lost+found --exclude=dev --exclude=proc --exclude=sys -C $org . </pre>
# apt update
# apt full-upgrade
</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”