Linux From Scratch (LFS): creazione di un sistema Linux partendo da zero, usando solamente i sorgenti dei software richiesti.

Linux From Scratch (LFS, letteralmente dall'inglese Linux da zero) è un libro scritto da Gerard Beekmans, Matthew Burgess ed altri. Nel libro sono fornite istruzioni su come costruire un sistema Linux a partire dai codici sorgente.
La storia di LFS inizia nel 1998, quando Gerard Beekmans, non soddisfatto di altre distribuzioni, decide di creare il suo sistema ideale personale che si adatti alle sue esigenze, e scrive i suoi progressi in un pezzo di carta. In breve tempo, il libro riscuote successo, ed attorno ad esso si sviluppa un progetto, con lo scopo di educare l'utente a costruire nel modo più pulito possibile un nuovo Sistema Operativo.
Il libro è disponibile gratuitamente dal sito di Linux From Scratch, la cui versione corrente è la 6.8. Per mantenere LFS piccolo e conservare il suo scopo, è stato creato un altro libro, Beyond Linux From Scratch, che presenta le istruzioni su come proseguire lo sviluppo del sistema di base creato con LFS.
Linux From Scratch consiste in un modo per installare un sistema Linux funzionante attraverso la costruzione manuale e configurazione di tutti i suoi componenti. Tale processo è molto più laborioso rispetto all'installazione di una distribuzione pre-costruita. L'idea di base è che installare i singoli pacchetti uno per uno porterà ad una comprensione dei meccanismi interni di un sistema Linux funzionante. Inoltre, ovviamente, compilare tutto il software specificamente per la piattaforma ed architettura su cui verrà eseguito tende a far risultare i programmi più leggeri e veloci. Infine, è più facile personalizzare i pacchetti installati quando ognuno di essi è stato installato manualmente - "La tua distro, le tue regole".

Procedura.
Per costruire LFS, il costruttore necessita di una partizione vuota e un file system Linux funzionante. Per prima cosa bisogna compilare una toolchain che consiste in strumenti (tools) come gcc, glibc e Perl, usati per compilare LFS. Poi la cartella radice deve essere cambiata (chroot) a quella cassetta degli attrezzi per far partire la costruzione del sistema finale. Uno dei primi pacchetti da compilare è glibc; dopo di che il linker della cassetta degli attrezzi deve essere impostato per linkare glibc appena costruito, così che tutti gli altri pacchetti che verranno costruiti per il sistema finale saranno linkati a quest'ultimo. Non appena le versioni finali dei pacchetti sono installate, queste devono essere quelle utilizzate da bash, piuttosto che quelle temporanee nella cassetta degli attrezzi. Questo si realizza vuotando la tabella hash di bash ed impostando la cartella dei binari della cassetta degli attrezzi per ultima nella variabile di ambiente path del nuovo ambiente.

Creazione di una nuova partizione.
Per costruire il nostro nuovo sistema Linux abbiamo bisogno di un po' di spazio: una partizione vuota sul disco. Se non avete una partizione libera, nè spazio in nessuno dei vostri hard disk per farne una, allora potete costruire LFS nella stessa partizione in cui è installata la vostra distribuzione host. Non è una procedura raccomandata per la vostra prima installazione di LFS, ma se non avete spazio e vi sentite coraggiosi, date un'occhiata ai suggerimenti su http://www.linuxfromscratch.org/hints/downloads/files/lfs_next_to_existing_systems.txt.
Per un sistema minimale avrete bisogno di una partizione di circa 1,3 GB. Questo spazio è sufficiente per archiviare tutti i tarball sorgenti e compilare tutti i pacchetti. Ma se intendete usare il sistema LFS come vostro sistema Linux principale, probabilmente vorrete installare software addizionale, e avrete bisogno di più spazio, probabilmente attorno ai 2 o 3 GB.
Dal momento che non abbiamo praticamente mai sufficiente RAM nel nostro PC, è una buona idea utilizzare una piccola partizione come area di swap: questo spazio è utilizzato dal kernel per archiviare dati usati raramente e fare spazio in memoria per cose più urgenti. La partizione di swap per il vostro sistema LFS può essere la stessa del vostro sistema host, così non dovrete crearne un'altra nel caso in cui il vostro sistema usi già una partizione di swap.
Avviate un programma di partizionamento come cfdisk o fdisk che abbia per argomento l'hard disk su cui deve essere creata la nuova partizione, ad esempio /dev/hda per il disco IDE primario. Create una partizione Linux nativa e una partizione swap, se necessario. Fate riferimento alle pagine man di cfdisk o fdisk se non sapete come usare i programmi.
Ricordate la designazione della vostra nuova partizione, qualcosa tipo hda5. Questo libro vi farà riferimento come partizione LFS. Se avete anche una partizione di swap ricordatevi anche la sua designazione. Questi nomi saranno in seguito necessari per il file /etc/fstab.
Creazione di un file system sulla nuova partizione.
Ora che abbiamo una partizione vuota, possiamo creare un file system su di essa. Il più utilizzato nel mondo Linux è il second extended file system (ext2), ma con gli hard disk ad alta capacità di oggi i cosiddetti file system journaling sono sempre più popolari. Qui noi creeremo un file system ext2, ma istruzioni per costruire altri file system possono essere trovate su http://www.linuxfromscratch.org/blfs/view/stable/postlfs/filesystems.html.
Per creare un file system ext2 sulla partizione LFS lanciate:
mke2fs /dev/xxx
Sostituite xxx col nome della partizione LFS (qualcosa tipo hda5).
Se avete creato una (nuova) partizione di swap dovrete anche inizializzarla come partizione di swap (detta anche formattazione, come avete fatto prima con mke2fs) lanciando:
mkswap /dev/yyy
Sostituite yyy con il nome della partizione di swap.
Montaggio della nuova partizione
Ora che abbiamo creato un file system, vogliamo poter accedere alla partizione. Per fare questo, dobbiamo montarla e avere accesso al punto di mount. In questo libro supponiamo che il file system sia montato sotto /mnt/lfs, ma non importa quale directory scegliete.
Scegliete un punto di mount ed assegnatelo alla variabile di ambiente LFS eseguendo:
export LFS=/mnt/lfs
Ora create il punto di mount del file system di LFS lanciando:
mkdir -p $LFS
mount /dev/xxx $LFS

Sostituite xxx con la designazione della partizione LFS.
Se avete deciso di utilizzare partizioni multiple per LFS (ovvero una per / e un'altra per /usr), montatele come segue:
mkdir -p $LFS
mount /dev/xxx $LFS
mkdir $LFS/usr
mount /dev/yyy $LFS/usr

Ovviamente, sostituite xxx e yyy con gli appropriati nomi di partizione.
Dovete anche assicurarvi che questa nuova partizione non sia montata con permessi troppo restrittivi (come le opzioni nosuid, nodev o noatime). Potete lanciare il comando mount senza alcun parametro per vedere con quali opzioni è montata la partizione LFS. Se vedete nosuid, nodev o noatime avete bisogno di rimontarla.
Ora che ci siamo creati uno spazio per lavorare, siamo pronti a scaricare i pacchetti.
Costruzione di un sistema provvisorio.
Introduzione.
In questo capitolo compileremo e installeremo un sistema Linux minimale. Questo sistema conterrà sufficienti strumenti da permettere di costruire il sistema LFS finale nel prossimo capitolo e consentire un ambiente di lavoro un po' più agevole per l'utente di un ambiente minimo.
La costruzione di questo sistema minimo è eseguita in due fasi: prima costruiamo una toolchain totalmente nuova e indipendente dall'host (compilatore, assemblatore, linker, librerie e qualche altro tool) ed in seguito la useremo per costruire tutti gli altri strumenti essenziali.
I file compilati in questo capitolo verranno installati nella directory $LFS/tools per tenerli separati dai file installati nel prossimo capitolo e dalle directory dell'host. Dal momento che questi pacchetti compilati sono puramente temporanei, non vogliamo inquinare il prossimo sistema LFS.
Prima di digitare le istruzioni di costruzione di un pacchetto, dovrete averlo già scompattato come utente lfs, e dovrete aver digitato un comando cd nella directory creata. Le istruzioni di costruzione suppongono che stiate usando la shell bash.
A molti pacchetti occorre applicare una patch prima della compilazione, ma solo quando la patch è necessaria per aggirare un problema. Spesso la patch è necessaria sia in questo che nel prossimo capitolo, ma talvolta solo in uno dei due. D'altra parte, non preoccupatevi se le istruzioni per una patch scaricata sembrano mancare. Inoltre, applicando una patch, occasionalmente potreste vedere messaggi di warning riguardanti offset o fuzz. Questi warning non sono nulla di cui preoccuparsi, in quanto la patch è stata applicata con successo.
Durante la compilazione di molti pacchetti, vedrete molti warning scorrere sul vostro schermo. Sono normali, e possono essere ignorati senza problemi. Sono giusto ciò che dicono di essere: avvisi, per lo più a proposito di deprecati, ma non sbagliati, usi della sintassi C o C++. È solo che il C standard cambia piuttosto spesso e certi pacchetti usano ancora lo standard vecchio, il che non è esattamente un problema.
Dopo aver installato ciascun pacchetto dovete cancellare le sue directory dei sorgenti e di costruzione, tranne ove richiesto diversamente. Cancellare i sorgenti fa risparmiare spazio, ma previene anche errate configurazioni quando lo stesso pacchetto viene reinstallato nuovamente. Solo per tre pacchetti dovrete tenere le directory dei sorgenti e di costruzione per un po', così che il loro contenuto possa essere usato da comandi successivi.
Ora, per prima cosa, controllate che la vostra variabile ambiente LFS sia settata correttamente:
echo $LFS
Assicuratevi che l'output mostri il percorso del punto di mount della vostra partizione LFS, che è /mnt/lfs se avete seguito il nostro esempio.
Binutils-2.14 - Passo 1
Il pacchetto Binutils contiene un linker, un assemblatore e altri strumenti per manipolare file oggetto.
Tempo approssimativo di costruzione: 1.0 SBU
Spazio necessario sul disco: 170 MB
L'installazione di Binutils dipende da: Bash, Coreutils, Diffutils, GCC, Gettext, Glibc, Grep, Make, Perl, Sed, Texinfo.
Installazione di Binutils
È importante che Binutils sia il primo pacchetto che viene compilato, poiché sia Glibc che GCC eseguono diversi test sul linker e sull'assemblatore disponibili per determinare quale delle loro caratteristiche abilitare.
Questo pacchetto è noto per avere problemi quando vengono cambiati i suoi flag di ottimizzazione di default (incluse le opzioni -march e -mcpu). Pertanto, se doveste aver definito variabili di ambiente che disabilitano le nostre ottimizzazioni di default, come i flag CFLAGS e CXXFLAGS, raccomandiamo di eliminarle quando costruite Binutils.
La documentazione di Binutils raccomanda di costruire Binutils fuori dalla directory dei sorgenti, in una directory dedicata:
mkdir ../binutils-build
cd ../binutils-build

Nota
Se volete che i valori degli SBU elencati nel resto del libro siano di qualche utilità, dovrete misurare il tempo impiegato a costruire questo pacchetto, partendo dalla configurazione e includendo la prima installazione. Per realizzare facilmente questo, potete racchiudere i quattro comandi in un comando time come questo: time { ./configure ... & ... & ... & make install; }.

Ora preparate Binutils per la compilazione:
../binutils-2.14/configure --prefix=/tools --disable-nls
Il significato delle opzioni di configurazione:
   *   --prefix=/tools: questo dice allo script di configurazione di prepararsi a installare i programmi di Binutils nella directory /tools.
   *   --disable-nls: questo disabilita l'internazionalizzazione (parola spesso abbreviata con i18n). Non ne abbiamo bisogno per i nostri programmi statici e nls spesso causa problemi quando viene linkato staticamente.
Proseguite con la compilazione del pacchetto:
make configure-host
make LDFLAGS="-all-static"
Il significato dei parametri di make:
   *   configure-host: questo forza l'immediata configurazione di tutte le sottodirectory. Una costruzione linkata staticamente fallirebbe senza questo. Perciò usiamo questa opzione per aggirare il problema.
   *   LDFLAGS="-all-static": questo dice al linker che tutti i programmi di Binutils devono essere linkati staticamente. Tuttavia, parlando letteralmente, "-all-static" è passato al programma libtool, che, quindi, passa "-static" al linker.
La compilazione è completa. Normalmente ora avvieremmo la suite di test, ma in questa fase preliminare il framework della suite di test (Tcl, Expect e DejaGnu) non è ancora in pista. E comunque avremmo uno scarso vantaggio avviando ora i test, poiché i programmi di questa prima fase saranno presto rimpiazzati da quelli della seconda.
Ora installate il pacchetto:
make install

Ora preparate il linker per la fase di “Regolazione” successiva:
make -C ld clean
make -C ld LDFLAGS="-all-static" LIB_PATH=/tools/lib

Il significato dei parametri di make:
   *   -C ld clean: questo dice al programma make di rimuovere tutti i file compilati nella sottodirectory ld.
   *   -C ld LDFLAGS="-all-static" LIB_PATH=/tools/lib: questa opzione ricostruisce ogni cosa nella sottodirectory ld. Specificare la variabile del makefile LIB_PATH nella linea di comando ci permette di sovrapporci ai valori di default e farlo puntare alla nostra locazione temporanea degli strumenti. Il valore di questa variabile specifica il percorso di ricerca predefinito da parte del linker. Vedrete come viene utilizzata questa preparazione più avanti in questo capitolo.

Attenzione
Non rimuovete le directory dei sorgenti e di costruzione di Binutils. Ne avrete di nuovo bisogno nel loro stato attuale un po' più avanti in questo capitolo.

Installazione degli header del kernel.
Poiché alcuni pacchetti devono avere riferimenti ai file header del kernel, ora scompatteremo l'archivio del kernel, lo imposteremo e copieremo i file necessari in un posto in cui gcc possa trovarli più tardi.
Preparate l'installazione degli header con:
make mrproper

Questo assicura che l'albero del kernel sia assolutamente pulito. Il kernel team raccomanda di dare questo comando prima di ogni compilazione del kernel. Non dovete fare conto che l'albero dei sorgenti sia pulito dopo la scompattazione.
Create il file include/linux/version.h:
make include/linux/version.h

Create il link simbolico include/asm specifico della piattaforma:
make symlinks
Installate i file header specifici per la vostra piattaforma:
mkdir /tools/include/asm
cp include/asm/* /tools/include/asm
cp -R include/asm-generic /tools/include

Infine, installate i file header multi-piattaforma del kernel:
cp -R include/linux /tools/include
Screenshots.

Imagehosting at Imageloop