Criando uma mini distro Linux!

Want create site? Find Free WordPress Themes and plugins.

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/
Did you find apk for android? You can find new Free Android Games and apps.

você pode gostar também Mais do autor

Comentários