Costruire una distro SliTaz GNU/Linux capace di girare in RAM e equipaggiata con BusyBox

Questo documento descrive la costruzione del sistema base SliTaz e le motivazioni per cui è utilizzato il kernel Linux, BusyBox e Syslinux per far partire il sistema. SliTaz Usa un archivio initramfs che viene decompresso in RAM dal kernel all'avvio. Noi creeremo una “scatola” che contega una root di 3-4MB e le cui librerie e binari siano strippati per risparmiare spazio.

Gli script e i file di configurazione sono creati con GNU nano, usando <ctrl+x> per salvare e uscire. Ma ovviamente potete sostituirlo con il vostro editor preferito.

Questo documento è basato su u howto presente negli archivi di BusyBox, che è a sua volta basato su un paper preentato da Erik Anderson alla Embedded Systems Conference del 2001.

Create una directory src per scaricare e compilare.

 # mkdir -p src
 # cd src

• Linux Kernel 2.6.20 (http://www.kernel.org/).

 # wget ftp://ftp.kernel.org/pub/linux/kernel/v2.6/linux-2.6.20.tar.bz2

• Busybox 1.2.2 (http://www.busybox.net/).

 # wget http://www.busybox.net/downloads/busybox-1.2.2.tar.bz2

• Syslinux 3.35 (http://syslinux.zytor.com/).

 # wget ftp://ftp.kernel.org/pub/linux/boot/syslinux/3.xx/syslinux-3.35.tar.gz

• SliTaz tools 1.1. Scaricare SliTaz tools, decomprireme il pacchetto, save in src/:

   # wget http://download.tuxfamily.org/slitaz/sources/tools/slitaz-tools-1.1.tar.gz
   # tar xzf slitaz-tools-1.1.tar.gz

Cominceremo compilando il kernel linux. Ci vorrà poco tempo.

Il tuo kernel deve supportare il filesystem initramfs, altrimenti il cdrom non partirà. Puoi anche installare i moduli in una directory così da non toccare il sistema ospite. La configurazione del kernel linux è fatta tramite “make menuconfig” usando ncurses o graficamente con “make gconfig” o “make xconfig” usando i pacchetti di sviluppo di GTK e/o QT, rispettivamente. Puoi trovare in SliTaz tools, Makefiles per vari kernel 2.6.xx.

Una feature dei kernel 2.6 è che se vengono compilati con menuconfig, xconfig o config per la prima volta, il menu di setup e basato sulla configurazione del kernel corrente.

Le opzioni dipendono dai tuoi bisogni, puoi installare module-init-tools per supportare i moduli compressi oppure, per un'installazione minimale, puoi selezionare solo le opzioni vitali.

Intanto cominciamo con “make mrproper” per mettere le cose in ordine, quindi lanciamo un'interfaccia di configurazione.

 # tar xjf linux-2.6.20.tar.bz2
 # cd linux-2.6.20
 # make mrproper
 # cp ../slitaz-tools-1.1/Makefiles/linux-2.6.20-slitaz.config .config
 # make oldconfig
 (# make menuconfig)
 # make bzImage
 # make modules
 # make INSTALL_MOD_PATH=$PWD/_pkg modules_install
 # cd ..

Se vuoi più informazioni sulla compilazione di un kernel, ci sono un mucchio di testi. Considera che puoi installare il kernel e, dopo il riavvio, compilare il tuo stesso kernel seguendo le medesime istruzioni.

Lo step successivo e creare una directory chiamata rootsfs (il Filesystem di root) nella directory di lavoro SliTaz/:

 # mkdir ../rootfs

BusyBox (www.busybox.net) è un singolo eseguibile che offre versioni dei più importanti strumenti per utilizzare un kernel. E' (principalmente) disegnato per essere usato nel mondo embedded e può fare qualsiasi cosa. Fornisce numerose funzionalità.

 # tar xjf busybox-1.2.2.tar.bz2

Una volta esploso il pacchetto BusyBox va configurato e compilato. In particolare make config (con interfaccia a piacere) invoca un'interfaccia che, in modo simile a quello che accade nel kernel, permette di selezionare le funzionalità che si vogliono effettivamente presenti nel prodotto finito. A te la scelta di inserire i comandi che ritieni necessari, al massimo, per orientarti, puoi considerare i Makefile presenti in Slitaz BusyBox tools

make install crea una directory _install sotto busybox che rappresenta il pacchetto effettivamente compilato.

 # cd busybox-1.2.2
 # cp ../slitaz-tools-1.1/Makefiles/busybox-1.2.2.config .config
 # make oldconfig
 (# make menuconfig)
 # make
 # make install
 # chmod 4755 _install/bin/busybox

Copia i file compilati da BusyBox nella directory _install nel tuo filesystem di root (rootfs):

 # cp -a _install/* ../../rootfs

In questo modo viene aggiunto a rootfs:

• un linuxrc link che punta a /bin/busybox
• una cartella /bin
• una cartella /usr con rispettive /bin e /sbin
• una cartella /sbin

Verifica pure.

Il link potrebbe mancare,nel caso non hai selezionato l'opzione “initrd support” in Busybox. Cancelleremo il link linuxrc e creeremo un link per l'init che punti a /bin/busybox:

 # cd ../../rootfs
 # ls -CF
 bin/  linuxrc@  sbin/  usr/

 # rm linuxrc
 # ln -s bin/busybox init

BusyBox è stato compilato sul sistema ospite. E' quindi normale che si appoggi su alcune librerie proprie di questo sistema. Per individuarle puoi usare il comando ldd sull'eseguibile sotto bin.

Su Slackware 13.1 l'output, per esempio, è:

 # linux-gate.so.1 =>  (0xffffe000)
 # libm.so.6 => /lib/libm.so.6 (0xb76f9000)
 # libc.so.6 => /lib/libc.so.6 (0xb7596000)
 # /lib/ld-linux.so.2 (0xb774d000)

E' ovvio che una volta che lasceremo il sistema ospite queste librerie non saranno più disponibili. E' quindi necessario creare, nell'alberatura rootfs, una directory lib per contenerle:

 # mkdir lib

A questo punto si tratta semplicemente di copiarle dal sistema ospite a questa alberatura. (attenzione: linux-gate.so.1 non è un vero file, quindi non potrete copiarlo)

SliTaz o altro:

 # cp /lib/{libcrypt.so.1,libm.so.6,libc.so.6} lib
 # cp /lib/ld-linux.so.2 lib

Esempio su Debian Etch:

 # cp /lib/tls/{libcrypt.so.1,libm.so.6,libc.so.6} lib
 # cp /lib/ld-linux.so.2 lib

Ripuliamo le librerie con strip:

 # strip -v lib/*

Crea le directory classi per un sistema Linux. /dev per i devices, /etc, /home, /proc, /root e compagnia bella. Per imparare qualcosa sulla gerarchia di un file system e sui suoi contenuti c'è una gerarchia standard disponibile i vari formati a www.pathname.com/fhs/.

Puoi creare la tua alberatura come più ti aggrada. Nei sistemi Unix tradizionali, /usr solitamente contiene files dalla distribuzione, /dev contiene i devices, /etc contiene i file di configurazione, /lib le librierie, /home è per le home degli utenti e /var per i dati variabili. Nota che non abbiamo creato /bin o /sbin, queste vengono create da Busybox all'installazione. /lib invece è stata creata per inserire le librerie.

 # mkdir -p dev etc root home proc media mnt sys tmp var
 # mkdir -p usr/{lib,local,games,share} \
   var/{cache,lib,lock,log,games,run,spool} \
   media/{cdrom,flash,usbdisk}

Cambiamo i permessi della directory tmp

 # chmod 1777 tmp

Configuriamo le glibc - nota che /etc/ld.so.conf e /etc/rpc non sono essenziali per un sistema micro:

 # touch etc/ld.so.conf
 # cp /etc/rpc etc

Questo si può fare con mkdevs.sh, script presente in BusyBox, o col nostro script mktazdevs.sh, negli SliTaz tools. Se volete più dettagli, leggete lo script. Se avete usato la versione di BusyBox, dovrete comunque creare la directory pts:

 # cp ../src/slitaz-tools-1.1/utils/mktazdevs.sh bin
 # ./bin/mktazdevs.sh dev

o:

 # cp ../src/busybox-1.2.2/examples/bootfloppy/mkdevs.sh bin
 # ./bin/mkdevs.sh dev
 # mkdir -p dev/{pts,input,shm,net,usb}

Nota che avviamo mdev-s con lo script rcS per creare dinamicamente i devices al boot.

Copiamo le librierie libnss_* del sistem ospite nel nostro sistema SliTaz. Queste librerie sono usate per la risoluzione dei nomi e vanno ripulite con strip:

 # cp /lib/{libnss_dns.so.2,libnss_files.so.2} lib
 # cp /lib/libresolv.so.2 lib
 # strip -v lib/*.so*

Creiamo i files necessari in /etc. Per maggiori informazioni, guarda il contenuto dei file. Cominciamo col creare alcuni file importanti per il cuore del sistema.

Creare i file base usati per configurare la rete

 # echo "127.0.0.1      localhost" > etc/hosts
 # echo "localnet    127.0.0.1" > etc/networks
 # echo "slitaz" > etc/hostname
 # echo "order hosts,bind" > etc/host.conf
 # echo "multi on" >> etc/host.conf

File di configurazione usato per risolvere i nomi

 # nano etc/nsswitch.conf

  # /etc/nsswitch.conf: GNU Name Service Switch config.
  #

  passwd:     files
  group:      files
  shadow:     files

  hosts:      files dns
  networks:   files

/etc/securetty elenca i terminali che possono connettersi usando root.

 # nano etc/securetty

  # /etc/securetty: List of terminals on which root is allowed to login.
  #
  console

  # For people with serial port consoles
  ttyS0

  # Standard consoles
  tty1
  tty2
  tty3
  tty4
  tty5
  tty6
  tty7

/etc/shells rappresenta una lista di shell utili a conntettersi. Questo file è usato dal server SSH (Dropbear, nel nostro caso)

 # nano etc/shells

  # /etc/shells: valid login shells.
  /bin/sh
  /bin/ash
  /bin/hush

/etc/issue è mostrato alla fine del boot, mentre il messaggio del giorno è mostrato subito dopo la login:

 # echo "SliTaz GNU/Linux 1.0 Kernel \r \l" > etc/issue
 # echo "" >> etc/issue
 # nano etc/motd

   (°-  { Get documentation in: /usr/share/doc.
   //\    Use: 'less' or 'more' to read files, 'su' to be root. }
   v_/_

  SliTaz is distributed in the hope that it will be useful, but
  with ABSOLUTELY NO WARRANTY.

Il file di configurazione di BusyBox, può assegnare compiti alle applicazioni BusyBox. Per maggiori informazioni puoi leggere la pagina riguardo la sicurezza nel Handbook (ancora in inglese):

 # nano etc/busybox.conf

  # /etc/busybox.conf: SliTaz GNU/linux Busybox configuration.
  #

  [SUID]
  # Allow command to be run by anyone.
  su = ssx root.root
  passwd = ssx root.root
  loadkmap = ssx root.root
  mount = ssx root.root
  reboot = ssx root.root
  halt = ssx root.root

For added security, change the permissions on the file:

 # chmod 600 etc/busybox.conf

File di configurazione minimo per l'init. Per facilitare le cose, configura una console di root senza aver bisogno di passare dalla login e una console su tty2

Minimal configuration file for init. It helps to have a root console without having to go through the login and a console on tty2.

 # nano etc/inittab

  # /etc/inittab: init configuration for SliTaz GNU/Linux.

  ::sysinit:/etc/init.d/rcS
  ::respawn:-/bin/sh
  tty2::askfirst:-/bin/sh
  ::ctrlaltdel:/bin/umount -a -r
  ::ctrlaltdel:/sbin/reboot

Ci sono vari esempi di inittab nell'archivio di BusyBox.

Questo file è letto a ogni login e riguarda tutti gli utenti. Questo file verrà usato da ogni singolo utente:

 # nano etc/profile

  # /etc/profile: system-wide .profile file for the Bourne shells

  PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
  LD_LIBRARY_PATH="/usr/lib:/lib"

  if [ "`id -u`" -eq 0 ]; then
    PS1='\e[1m\u@\h:\w\#\e[m '
  else
    PS1='\e[1m\u@\h:\w\$\e[m '
  fi

  DISPLAY=:0.0

  export PATH LD_LIBRARY_PATH PS1 DISPLAY ignoreeof
  umask 022

Creiamo un fle di configurazione per utenti, gruppi e password in /etc/ {passwd, shadow, group, gshadow}, e configuriamo correttamente i permessi.

 # echo "root:x:0:0:root:/root:/bin/sh" > etc/passwd
 # echo "root::13525:0:99999:7:::" > etc/shadow
 # echo "root:x:0:" > etc/group
 # echo "root:*::" > etc/gshadow
 # chmod 640 etc/shadow
 # chmod 640 etc/gshadow

Puoi aggiungere altri utenti, per esempio l'utente hacker è presente nella modalità LiveCD. Puoi anche configurare una password per root usanto il comando passwd. Per aggiungere un utente a un gruppo (entrambi esistenti), devi cambiare /etc/group e /etc/gshadow poiché l'applicazione adduser fornita da BusyBox non offre tutte le opzioni proprie del programma originale.

Lista dei filesystem da montare:

 # nano etc/fstab

  # /etc/fstab: information about static file system.
  #
  proc            /proc        proc    defaults          0       0
  sysfs           /sys         sysfs   defaults          0       0
  devpts          /dev/pts     devpts  defaults          0       0
  tmpfs           /dev/shm     tmpfs   defaults          0       0

/etc/mtab is used by other mkfs*, for listing the mounted partitions. It needs /proc because there is a link on /proc/mounts:

 # chroot . /bin/ash
 /# ln -s /proc/mounts /etc/mtab

Puoi creare un file kmap specifico per la tua tastiera con il comando dumpkmap fornito da BusyBox. Puoi trovare divers files kmap negli SliTaz tools. Per creare, per esempio, il file kmap fr_CH:

 /# mkdir /usr/share/kmap
 /# /bin/busybox dumpkmap > /usr/share/kmap/fr_CH.kmap
 /# exit

Una volta fatto questo, puoi caricare automaticamente la tua tastiera con loadkmap, aggiungendolo allo script /etc/init.d/rcS.

Hai la possibilità di aggiungere svariati documenti, come il manuale utente di SliTaz, che puoi scaricare come tar.gz dal sito della distro:

 # mkdir -p usr/share/doc

Il client DHCP Udhcpc fornito da BusyBox è veloce e stabile, ma è stato sviluppato indipendentemente. Il sito internet è http://udhcp.busybox.net/. Puoi usare lo script di default fornito nell'archivio di BusyBox. Qesto script va in /usr/share/udhcpc/default.script, ma può essere modificato. Su SliTaz, il client è avviato al boot dallo script /etc/init.d/network.sh e si basa sul file di configurazione /etc/network.conf:

 # mkdir usr/share/udhcpc
 # cp ../src/busybox-1.2.2/examples/udhcp/simple.script \
   usr/share/udhcpc/default.script
 # chmod +x usr/share/udhcpc/default.script

Per completare questa prima fase, devi creare lo script di inizializzazione /etc/init.d/rcS per montare i filesystem e lanciare alcuni comandi. Per maggiori informazioni, puoi controllare la pagina degli script di boot (in inglese). Puoi anche cambiare il valore della variabile KMAP= per la tastiera:

 # mkdir etc/init.d
 # nano etc/init.d/rcS

  #! /bin/sh
  # /etc/init.d/rcS: rcS initial script.
  #

  KMAP=fr_CH

  echo "Processing /etc/init.d/rcS... "

  /bin/mount proc
  /bin/mount -a
  /bin/hostname -F /etc/hostname
  /sbin/ifconfig lo 127.0.0.1 up
  /sbin/loadkmap < /usr/share/kmap/$KMAP.kmap

   # chmod +x etc/init.d/rcS

Nota che puoi comunque installare Tazpkg, il package manager (10 kb) che abbiamo creato, le informazioni per l'installazione sono nel tarball dei sorgenti. Puoi anche inserire diversi files dagli SliTaz tools, come per esempio la licenza.

L'initramfs è un archivio “cpio” generato dalla radice del sistema. Viene decompresso nella RAM dal kernel al boot per creare il filesystem (sempre in RAM). Per generare un archivio initramfs utilizzabile come directory di root dei tuoi files di sistema (rootfs), prima recuperiamo tutti i file tramite una find (con qualche pipe). Dopodiché creiamo un archivio cpio con gzip e lo piazziamo nella directory di lavoro.

L'initramfs rootfs.gz e il sistema root, ma con l'estensione gz. Se vuoi cambiarne il nome, devi modificare il file di configurazione di isolinux: isolinux.cfg o il menu.lst di GRUB.

Generazione del initramfs:

 # find . -print | cpio -o -H newc | gzip -9 > ../rootfs.gz

Ora dovresti avere un file rootfs.gz di circa uno o due megabyte nella directory SliTaz/.

Gli step che seguono ti aiuteranno a creare la root di un CD-ROM avviabile. Cominciamo col creare la directory rootcd/boot/isolinux, per i files del cd-rom.

 # cd ..
 # mkdir -p rootcd/boot/isolinux

In più, puoi creare altre directory in cui inserire vari dati, come documenti HTML o pacchetti.

Copia semplicemente il kernel precedentemente compilato in rootcd/boot:

 # cp src/linux-2.6.20/arch/i386/boot/bzImage rootcd/boot

Copia rootfs.gz in rootcd/boot. Non dimentichiamo di generare un nuovo archivio initramfs ogni volta che facciamo cambiamenti al rootfs (file system di root):

 # cp rootfs.gz rootcd/boot

E' sufficiente copiare il file isolinux.bin dall'archivio di sorgenti di Syslinux:

 # cd src
 # tar xzf syslinux-3.35.tar.gz
 # cp syslinux-3.35/isolinux.bin ../rootcd/boot/isolinux
 # cd ..

Ecco un esempio di un file di configurazione isolinux.cfg che dovrebbe funzionare. Puoi modificarlo a piacimento:

 # nano rootcd/boot/isolinux/isolinux.cfg

  display display.txt
  default slitaz
  label slitaz
      kernel /boot/bzImage
      append initrd=/boot/rootfs.gz rw root=/dev/null vga=788
  implicit 0
  prompt 1
  timeout 80

Qui ci sono alcuni cambiamenti che potresti voler fare in isolinux.cfg:

• Il valore di timeout è il numero di secondi da attendere prima di avviare il boot. Posto a 0 (o se la linea è assente), fa partire il sistema istantaneamente. Altrimenti è consueto scegliere un'attesa di 10 secondi.
• prompt configurato a 0 disabilita il prompt 'boot:'.
• Aggiungendo linee puoi mostrare il contenuto di diversi file quando l'utente preme F1, F2, F3, ecc…

Una piccola nota di benvenuto, fornita da isolinux, modificabile a piacimento:

 # nano rootcd/boot/isolinux/display.txt

  /*       _\|/_
           (o o)
   +----oOO-{_}-OOo---------------------------------------------------+
       ____  _ _ _____
      / ___|| (_)_   _|_ _ ____
      \___ \| | | | |/ _` |_  /
       ___) | | | | | (_| |/ /
      |____/|_|_| |_|\__,_/___|

   SliTaz GNU/Linux - Temporary Autonomous Zone

       <ENTER> to boot.

                                                                     */

 # genisoimage -R -o slitaz-cooking.iso -b boot/isolinux/isolinux.bin \
   -c boot/isolinux/boot.cat -no-emul-boot -boot-load-size 4 \
   -V "SliTaz" -input-charset iso8859-1 -boot-info-table rootcd

Ogni volta che la root della box viene modificata, deve essere creata una nuova ISO.

Puoi scrivere un breve script che generi l'archivio cpio compresso e la nuova immagine, oppure usare mktaziso, presente all'interno degli SliTaz tools. Nota che la box può essere anche avviata tramite GRUB.

Puoi creare il CD dall'immagine con Graveman, k3b, o wodim, dopodiché provare a usarla all'avvio. Il comando per creare il CD con wodim (o cdrecord), considerando un kernel 2.6.xx:

# wodim -v -speed=24 -data slitaz-cooking.iso

Puoi testare l'immagine con l'emulatore Qemu (considerando Debian, puoi installarlo via aptitude). Per emulare la ISO appena creata digita semplicemente:

# qemu -cdrom slitaz-cooking.iso

Nel prossimo capitolo Applicazioni Base faremo vedere come installare e configurare le applicazioni base e le relative librerie.