Criando uma mini distro Linux!

1. Downloads

Alguns pacotes podem ser requeridos dependendo do sistema  que se vai compilar. Focaremos no básico.
 * Kernel linux www.kernel.org;
 * Busybox www.busybox.net
 * Lua www.lua.org (opcional)
 * Mini python, TinyPython (opcional) www.tinypy.org

1.1 Introdução


Recomenda-se
ao leitor uma rápida leitura do texto afim de compreender os passos
envolvidos e em caso de dúvidas, verificar os links de referências
contendo maiores detalhes sobre os comandos, arquivos e diretórios de
configuração.

Para fins de organização quando da montagem das imagens (rootfs e disk.img) que serão criadas no decorrer deste texto, como usuário root, crie os diretórios ‘dir1’ e ‘dir2’ em /mnt, com o comando:

$ mkdir -v /mnt/[nome_DIRetorio]

É preciso instalar alguns programas necessários de desenvolvimento como ferramentas de compilação (vide Referências [13] ou página de sua ditribuição linux), o ncurses (para acessar o menu de configuração do kernel), o qemu (programa de virtualização de sistemas, para testar a imagem do sistema criada), e o syslinux (bootloader para o sistema).

Caso utilize Debian e Ubuntu, o procedimento para instalar as ferramentas básicas de desenvolvimento é:

# apt-get install build-essential

Note que o pacote (package) build-essential pode aparecer referenciado com outro nome dependendo da distribuição linux (Fedora, OpenSuse, Slackware, Arch, Linux Mint), esse processo também pode ser usado – apt-get – para instalar o Qemu (necessário para testar a mini distro), o syslinux, .

1.2 Arquivos De Configuração e Inicialização

Alguns arquivos de configuração e inicialização são necessários ao processo de boot (vide Referências [2],[15],[16],[17]). Exemplo: /etc/rcS, /init, /etc/inittab,  /etc/fstab e outros dependendo do sistema montado.

init

#!/bin/sh -e
echo"Init run..."
PATH="/bin:/sbin:/usr/bin:/usr/sbin
export PATH
init='/bin/busybox init'
exec $init
sleep 5

Arquivo inittab

# This is run first except when booting in single-user mode.
#
::sysinit:/etc/init.d/rcS

# /bin/sh invocations on selected ttys
#
# Start an "askfirst" shell on the console (whatever that may be)
::askfirst:-/bin/sh
#::askfirst:-/sbin/getty 38400 tty1
#::respawn:-/bin/login 

# Start an "askfirst" shell on /dev/tty2-4
#tty1::respawn:-/bin/sh
#tty2::respawn:-/bin/sh
#tty3::respawn:-/bin/login
#tty4::respawn:-/bin/login

#::respawn:/sbin/getty 9600 ttyS0

# /sbin/getty invocations for selected ttys
#
tty4::respawn:/sbin/getty 38400 tty4
tty5::respawn:/sbin/getty 38400 tty5


# Example of how to put a getty on a serial line (for a terminal)
#
#::respawn:/sbin/getty -L ttyS0 9600 vt100
#::respawn:/sbin/getty -L ttyS1 9600 vt100
#
# Example how to put a getty on a modem line.
#::respawn:/sbin/getty 57600 ttyS2

# Stuff to do when restarting the init process
::restart:/sbin/init

# Stuff to do before rebooting
#::ctrlaltdel:/etc/init.d/rc.reboot
#::shutdown:/etc/init.d/rc.reboot
/bin/sh
#tty1::askfirst:-/bin/sh
#tty2::askfirst:-/bin/sh
#tty3::askfirst:-/bin/sh
#::respawn:/sbin/getty 57600 -L tty 9600 vt100
#::respawn:/sbin/getty 57600 tty2

::restart:/sbin/init
::shutdown:/sbin/halt
::ctrlaltdel:/sbin/reboot

Arquivo rcS

#!/bin/sh

echo "Setting blank sccreen interval."
echo -ne "33[9;15]"
echo "Mounting procfs"
#mount proc /proc -t proc
#mount sys /sys -t sysfs

#mknod -m 600 /dev/console c 5 1
#mknod -m 666 /dev/null c 1 3
#mknod  /dev/sda b 8 0
#mknod  /dev/sdb b 8 16

#Mounting Virtual Kernel File System
echo "Mounting..."
#mount -vt tmpfs tmpfs /dev
mount -vt devpts devpts /dev/pts -o gid=5,mode=620
mount -vt proc proc /proc
mount -vt sysfs  sysfs /sys
mount -vt tmpfs tmpfs /run
#mount -vt dev
sleep 5
#Populing /dev
echo "" >/dev/mdev.seq
echo /sbin/mdev >/proc/sys/kernel/hotplug
echo "Populing devices in /dev"
mdev -s

echo " "
#Nome Logo do sistema em ascii (caracteres)
#cat /etc/init.d/logo
echo " "
echo "--------------------------------------------------------------"
echo "   Mini LINUX GNU        "
echo "--------------------------------------------------------------"
echo " "

Mais detalhes vide Referências [2],[17],[18],

 


Arquivo rcS (básico)

#!/bin/sh
echo "Start"
echo -ne "33[9;15]"
echo "Mount proc"
mount proc /proc -t proc

Atribuindo permissão de execução ao arquivo rcS:

$ chmod +x rcS
 
 

Inicialização

Visualização
Estratégica do Processo de Inicialização do Linux
Fonte: https://www.ibm.com/developerworks/br/library/l-linuxboot/  Versão PDF
Quando o sistema carrega pela primeira vez, dar-se inicio a uma sequência de passos até carregamento total do sistema. Esse processo em geral varia com dispositivo e seu processador que carregará uma área especifica da memória onde executa um código. Em PC cabe a BIOS determinar os dispositivos do hardware, informação essa útil no boot do sistema, quando um dispositivo de boot é encontrado dar-se inicio ao ‘loader de boot’ (Stage 1) o loader por sua vez entra num segundo estágio o qual estará na memoria RAM do computador (PC) onde será montado um sistema raiz de arquivo temporário. Logo o loader passa o controle para o Kernel (núcleo do sistema operacional), após finalizado com sucesso, o Kernel é descompactado, inicializado e carregado para memória RAM (nesse momento o loader de segundo estágio mapeia dispositivos de hardware que serão configurados, e logo monta o sistema raiz),  em seguida os módulos necessários do kernel são carregados e o primeiro programa de usuário, o init, é executado no espaço de usuário.

 

2. Criando Imagens rootfs e disk.img

Antes é necessário criar a imagem do arquivo raiz (rootfs) que será carregado quando o sistema for iniciado, este será carregado para memória ram do computador seguido do kernel.
Comandos necessários para a criação (terá cerca de 10 megabytes) são:

$ dd if=/dev/zero of=rootfs bs=1024 count=10440

Formatando o rootfs para o sistema de arquivos desejado (requer suporte do modulo do kernel habilitado quando o mesmo for compilado) neste caso,  ext2:

$ mke2fs rootfs 

Para montar o arquivo rootfs:

$ mount -o loop rootfs /mnt

Isto será necessário quando for compilar o busybox (conjunto de utilitários gnu/linux básicos) e instalá-lo. Também considere criar diretórios como etc, usr, bin, proc, dev dentro do rootfs. Vamos a criação da imagem disk.img que conterá o kernel e o rootfs; e também o arquivo de configuração syslinux.cfg (requer syslinux instalado no sistema anfitrião ou “host”). O arquivo disk.img deve ser formatado como DOS com o comando, processo de criação é semelhante ao rootfs devendo ter um tamanho maior, já que conterá o rootfs e a imagem kernel linux:

$ mkdosfs disk.img

Sua montagem no diretório /mnt é semelhante ao do rootfs (recomenda-se, lembrando que algumas operações exigem possuir direitos de root, criar dois subdiretórios em /mnt afim de facilitar a criação).

3. Compilando

Para compilação e instalação verifique os arquivos README e INSTALL em cada pacote baixado. Em geral para compilação têm-se o comando ‘make’ e para instalação ‘make install’. Para configurar o busybox antes de sua instalação selecionando utilitários (programas) desejados e o modo de compilação estática (static compile), e especificar o ‘path install’ (diretório de instalação); lembrando que a imagem do rootfs deve estar montado e local dele será o caminho:
$ make menuconfig

 Com atalho ‘/’ pode-se abrir uma janela pesquisa afim de pesquisar por
um modulo necessário de acordo a máquina pra se compilará o kernel.

Após isto é só completar com ‘make’ e ‘make install’. Para criação do arquivo initrd (este será copiado para imagem disk.img) do rootfs faça (dentro do diretório montado do rootfs, exemplo, /mnt/dir1):

 $ find . | cpio –create –format='newc' > /[diretório_pra_salvar]/initrd  

Agora compile o kernel com os seguintes comandos,
lembrando-se de na configuração de instalação desativar ‘loadable modules’ e acrescentar os módulos necessários ao linux, por exemplo, sistemas de arquivos (ext, dos e outros), devices de usb, teclado, etc. A compilação do kernel pode requerer uma maior atenção aos módulos marcados para inclusão no kernel (vide Referências [3], [10]), para detalhes visualize o arquivo REAME no diretório do código fonte do kernel Linux:
$ make menuconfig

$ make bzImage 

Veja a saída no terminal especificando o local onde está o arquivo bzImage e faça:
$ cp -v /<local>/bzImage /mnt/dir2/vmlinuz

Copiará o kernel linux para o diretório que deverá conter a imagem disk.img montada (como dito anteriormente). Para instalação do interpretador lua (opcional), compilar estaticamente e instalar no rootfs.

4. Finalizando e Testando

Crie o arquivo das configurações do boot loader syslinux.cfg contendo as seguintes linhas baixo:

default linux
prompt 0
label linux
KERNELvmlinuz
APPEND load_ramdisk=1 initrd=initrd root=/dev/ram0 rw 


Com o programa de ‘loader’  syslinux instalado e o arquivo syslinux.cfg criado e copiado para imagem disk.img façamos:

$ syslinux -s disk.img 

Após todo procedimento feito para testá-lo, instale a maquina virtual qemu (vide Referências [25],[26]), e use o comando:

$ qemu disk.img 

ou

$ qemu-system-i386 disk.img

ou caso compilado em 64 bits

$ qemu-system-x86_64 disk.img 

É possível através do comando dd gravar a imagem (veja man dd) em um pendrive (USB stick), desde que módulos de suporte ao usb estejam ativos, e ainda possível com o comando cfdisk ou com GParted (Vide referências [21],[22],[23], [24]) particionar o pendrive em duas partições uma para a qual você colocará os arquivos de disk.img (rootfs, syslinux.cfg, initrd,…) e a outra para salvar arquivos (com sistema de arquivos FAT32).
Para testar use o mesmo comando acima só que no lugar de ‘disk.img’ use o local do dispositivo do pendrive (exemplo: /dev/sdb).

Referências
  1. Programação Avançada em Linux – Gleicon da Silveira, Editora Novatec
  2. Processo de Inicialização do Linux (internet) https://www.ibm.com/developerworks/br/library/l-linuxboot/
  3. Embedded Linux From Scratch http://free-electrons.com/doc/embedded_lfs.pdf
  4. Free-Electrons http://free-electrons.com/docs/
  5. Criar uma Distribuição Linux Integrada do Zero  http://www.ibm.com/developerworks/br/library/l-embedded-distro/
  6. Embedded Linux From Scratch (em português) http://free-electrons.com/doc/embedded_lfs_pt_BR.odp
  7. Guia Foca Gnu/Linux http://www.guiafoca.org/
  8. Linux From Scratch http://www.linuxfromscratch.org/
  9. Exemplo Linigos/Mini Linux https://sourceforge.net/projects/gnulinuxos/ 
  10. Kernel Build https://kernelnewbies.org/KernelBuild
  11. Traditional Compilation https://wiki.archlinux.org/index.php/Kernels/Traditional_compilation
  12. Compilando Kernel Linux https://www.debian.org/releases/jessie/i386/ch08s06.html.pt
  13. Manual do Administrador Debian – Compilando o Nucleo https://debian-handbook.info/browse/pt-BR/stable/sect.kernel-compilation.html 
  14. Instalação de Programas no Linux VOL
  15. Create Daemons Service in 5 Minutes
  16. Arquivo /etc/fstab https://wiki.archlinux.org/index.php/fstab e https://en.wikipedia.org/wiki/Fstab;
  17.   Init http://www.tldp.org/LDP/sag/html/init-process.html
  18. Resultado do rootfs está lá arquivos básicos da configuração usada (Obs.: Atente aos modulos do kernel adicionados) https://github.com/AngelH4ck3r-LI/Coding/tree/master/linuz
  19. Syslinux HowTo http://www.syslinux.org/wiki/index.php?title=HowTos
  20. Syslinux Help http://www.syslinux.org/wiki/index.php?title=SYSLINUX
  21. https://www.vivaolinux.com.br/artigo/Particionamento-de-disco-(HD)
  22. Garted Video Tutorial https://www.youtube.com/watch?v=QCkSrGzeQuo 
  23. https://www.vivaolinux.com.br/topico/Hard-on-Linux/Particionamento-de-Pendrive
  24. Gerenciando Particões com fdisk https://www.vivaolinux.com.br/artigo/Gerenciando-o-HD-com-o-fdisk
  25. Qemu Manual http://wiki.qemu.org/Manual 
  26. Emulação de Sistemas com Qemu https://www.ibm.com/developerworks/br/library/l-qemu/

Comentários