Criando uma mini distro Linux! - SempreUpdate
LENDO: Criando uma mini distro Linux!
SempreUpdate > Blog > Linux > Criando uma mini distro Linux!
Emanuel Negromonte 23/09/2016
Atualizado em 23/09/16 às 12:30 PM
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
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
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 é:
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.
echo"Init run..."
PATH="/bin:/sbin:/usr/bin:/usr/sbin
Arquivo inittab
#::askfirst:-/sbin/getty 38400 tty1
#::respawn:-/bin/login
#tty1::respawn:-/bin/sh
#tty2::respawn:-/bin/sh
#tty3::respawn:-/bin/login
#tty4::respawn:-/bin/login
#::respawn:/sbin/getty 9600 ttyS0
#::ctrlaltdel:/etc/init.d/rc.reboot
#::shutdown:/etc/init.d/rc.reboot
#::respawn:/sbin/getty 57600 -L tty 9600 vt100
#::respawn:/sbin/getty 57600 tty2
Arquivo rcS
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
#mount -vt tmpfs tmpfs /dev
mount -vt devpts devpts /dev/pts -o gid=5,mode=620
mount -vt sysfs  sysfs /sys
mount -vt tmpfs tmpfs /run
#mount -vt dev
#Populing /dev
echo "" >/dev/mdev.seq
echo "Populing devices in /dev"
#Nome Logo do sistema em ascii (caracteres)
#cat /etc/init.d/logo
echo "   Mini LINUX GNU        "
Mais detalhes vide Referências [2],[17],[18],
Arquivo rcS (básico)
echo "Mount proc"
Atribuindo permissão de execução ao arquivo rcS:
$ chmod +x rcS
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:
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).
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:
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:
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:
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
$ 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).
Programação Avançada em Linux – Gleicon da Silveira, Editora Novatec
Processo de Inicialização do Linux (internet) https://www.ibm.com/developerworks/br/library/l-linuxboot/
Embedded Linux From Scratch http://free-electrons.com/doc/embedded_lfs.pdf
Free-Electrons http://free-electrons.com/docs/
Criar uma Distribuição Linux Integrada do Zero http://www.ibm.com/developerworks/br/library/l-embedded-distro/
Embedded Linux From Scratch (em português) http://free-electrons.com/doc/embedded_lfs_pt_BR.odp
Guia Foca Gnu/Linux http://www.guiafoca.org/
Exemplo Linigos/Mini Linux https://sourceforge.net/projects/gnulinuxos/
Kernel Build https://kernelnewbies.org/KernelBuild
Traditional Compilation https://wiki.archlinux.org/index.php/Kernels/Traditional_compilation
Compilando Kernel Linux https://www.debian.org/releases/jessie/i386/ch08s06.html.pt
Manual do Administrador Debian – Compilando o Nucleo https://debian-handbook.info/browse/pt-BR/stable/sect.kernel-compilation.html
Instalação de Programas no Linux VOL
Create Daemons Service in 5 Minutes
Arquivo /etc/fstab https://wiki.archlinux.org/index.php/fstab e https://en.wikipedia.org/wiki/Fstab;
Init http://www.tldp.org/LDP/sag/html/init-process.html
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